@Override public SettableColumnValueSelector makeNewSettableColumnValueSelector() { return getCapabilities().getType().makeNewSettableColumnValueSelector(); } }
@Override public InputRawSupplierColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: return new StringInputRawSupplierColumnSelectorStrategy(); case LONG: return (InputRawSupplierColumnSelectorStrategy<BaseLongColumnValueSelector>) columnSelector -> columnSelector::getLong; case FLOAT: return (InputRawSupplierColumnSelectorStrategy<BaseFloatColumnValueSelector>) columnSelector -> columnSelector::getFloat; case DOUBLE: return (InputRawSupplierColumnSelectorStrategy<BaseDoubleColumnValueSelector>) columnSelector -> columnSelector::getDouble; default: throw new IAE("Cannot create query type helper from invalid type [%s]", type); } } }
public void merge(ColumnCapabilities other) { if (other == null) { return; } if (type == null) { type = other.getType(); } if (!type.equals(other.getType())) { throw new ISE("Cannot merge columns of type[%s] and [%s]", type, other.getType()); } this.dictionaryEncoded |= other.isDictionaryEncoded(); this.runLengthEncoded |= other.isRunLengthEncoded(); this.hasInvertedIndexes |= other.hasBitmapIndexes(); this.hasSpatialIndexes |= other.hasSpatialIndexes(); this.hasMultipleValues |= other.hasMultipleValues(); this.filterable &= other.isFilterable(); } }
@Override public String getColumnTypeName(String column) { final String metricType = index.getMetricType(column); if (metricType != null) { return metricType; } ColumnCapabilities columnCapabilities = getColumnCapabilities(column); if (columnCapabilities != null) { return columnCapabilities.getType().toString(); } else { return null; } }
private void mergeCapabilities( final List<IndexableAdapter> adapters, final List<String> mergedDimensions, final Map<String, ValueType> metricsValueTypes, final Map<String, String> metricTypeNames, final List<ColumnCapabilitiesImpl> dimCapabilities ) { final Map<String, ColumnCapabilitiesImpl> capabilitiesMap = new HashMap<>(); for (IndexableAdapter adapter : adapters) { for (String dimension : adapter.getDimensionNames()) { ColumnCapabilities capabilities = adapter.getCapabilities(dimension); capabilitiesMap.computeIfAbsent(dimension, d -> new ColumnCapabilitiesImpl()).merge(capabilities); } for (String metric : adapter.getMetricNames()) { ColumnCapabilities capabilities = adapter.getCapabilities(metric); capabilitiesMap.computeIfAbsent(metric, m -> new ColumnCapabilitiesImpl()).merge(capabilities); metricsValueTypes.put(metric, capabilities.getType()); metricTypeNames.put(metric, adapter.getMetricType(metric)); } } for (String dim : mergedDimensions) { dimCapabilities.add(capabilitiesMap.get(dim)); } }
@Override public String getColumnTypeName(String columnName) { final ColumnHolder columnHolder = index.getColumnHolder(columnName); try (final BaseColumn col = columnHolder.getColumn()) { if (col instanceof ComplexColumn) { return ((ComplexColumn) col).getTypeName(); } else { return columnHolder.getCapabilities().getType().toString(); } } catch (IOException e) { throw new UncheckedIOException(e); } }
@Override public String getMetricType(String metric) { final ColumnHolder columnHolder = input.getColumnHolder(metric); final ValueType type = columnHolder.getCapabilities().getType(); switch (type) { case FLOAT: return "float"; case LONG: return "long"; case DOUBLE: return "double"; case COMPLEX: { try (ComplexColumn complexColumn = (ComplexColumn) columnHolder.getColumn()) { return complexColumn.getTypeName(); } } default: throw new ISE("Unknown type[%s]", type); } }
@Override public CardinalityAggregatorColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: return new StringCardinalityAggregatorColumnSelectorStrategy(); case LONG: return new LongCardinalityAggregatorColumnSelectorStrategy(); case FLOAT: return new FloatCardinalityAggregatorColumnSelectorStrategy(); case DOUBLE: return new DoubleCardinalityAggregatorColumnSelectorStrategy(); default: throw new IAE("Cannot create query type helper from invalid type [%s]", type); } } }
private static ColumnValueSelector getColumnValueSelectorFromDimensionSpec( DimensionSpec dimSpec, ColumnSelectorFactory columnSelectorFactory ) { String dimName = dimSpec.getDimension(); ColumnCapabilities capabilities = columnSelectorFactory.getColumnCapabilities(dimName); capabilities = getEffectiveCapabilities(dimSpec, capabilities); switch (capabilities.getType()) { case STRING: return columnSelectorFactory.makeDimensionSelector(dimSpec); default: return columnSelectorFactory.makeColumnValueSelector(dimSpec.getDimension()); } }
@Override public ValueMatcherColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: return new StringValueMatcherColumnSelectorStrategy(); case LONG: return new LongValueMatcherColumnSelectorStrategy(); case FLOAT: return new FloatValueMatcherColumnSelectorStrategy(); case DOUBLE: return new DoubleValueMatcherColumnSelectorStrategy(); default: throw new IAE("Cannot create column selector strategy from invalid type [%s]", type); } } }
@Override public SearchColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: return new StringSearchColumnSelectorStrategy(); case LONG: return new LongSearchColumnSelectorStrategy(); case FLOAT: return new FloatSearchColumnSelectorStrategy(); case DOUBLE: return new DoubleSearchColumnSelectorStrategy(); default: throw new IAE("Cannot create query type helper from invalid type [%s]", type); } } }
@Override public SelectColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: return new StringSelectColumnSelectorStrategy(); case LONG: return new LongSelectColumnSelectorStrategy(); case FLOAT: return new FloatSelectColumnSelectorStrategy(); case DOUBLE: return new DoubleSelectColumnSelectorStrategy(); default: throw new IAE("Cannot create query type helper from invalid type [%s]", type); } } }
private ColumnAnalysis analyzeNumericColumn( final ColumnCapabilities capabilities, final int length, final int sizePerRow ) { long size = 0; if (analyzingSize()) { if (capabilities.hasMultipleValues()) { return ColumnAnalysis.error("multi_value"); } size = ((long) length) * sizePerRow; } return new ColumnAnalysis( capabilities.getType().name(), capabilities.hasMultipleValues(), size, null, null, null, null ); }
private DimensionSelector makeDimensionSelectorUndecorated(DimensionSpec dimensionSpec) { final String dimension = dimensionSpec.getDimension(); final ExtractionFn extractionFn = dimensionSpec.getExtractionFn(); if (dimension.equals(ColumnHolder.TIME_COLUMN_NAME)) { return new SingleScanTimeDimensionSelector(makeColumnValueSelector(dimension), extractionFn, descending); } final IncrementalIndex.DimensionDesc dimensionDesc = index.getDimension(dimensionSpec.getDimension()); if (dimensionDesc == null) { // not a dimension, column may be a metric ColumnCapabilities capabilities = getColumnCapabilities(dimension); if (capabilities == null) { return DimensionSelector.constant(null, extractionFn); } if (capabilities.getType().isNumeric()) { return capabilities.getType().makeNumericWrappingDimensionSelector( makeColumnValueSelector(dimension), extractionFn ); } // if we can't wrap the base column, just return a column of all nulls return DimensionSelector.constant(null, extractionFn); } else { final DimensionIndexer indexer = dimensionDesc.getIndexer(); return indexer.makeDimensionSelector(dimensionSpec, rowHolder, dimensionDesc); } }
@Override public Aggregator factorize(final ColumnSelectorFactory metricFactory) { if (metricFactory.getColumnCapabilities(fieldName) != null && ValueType.isNumeric(metricFactory.getColumnCapabilities(fieldName).getType())) { final ColumnValueSelector<Double> selector = metricFactory.makeColumnValueSelector(fieldName); if (selector instanceof NilColumnValueSelector) { return new DoublesSketchNoOpAggregator(); } return new DoublesSketchBuildAggregator(selector, k); } final ColumnValueSelector<DoublesSketch> selector = metricFactory.makeColumnValueSelector(fieldName); if (selector instanceof NilColumnValueSelector) { return new DoublesSketchNoOpAggregator(); } return new DoublesSketchMergeAggregator(selector, k); }
private List<String> selectColumnValuesMatchingFilterUsingRowBasedColumnSelectorFactory( final DimFilter filter, final String selectColumn ) { // Generate rowType final Map<String, ValueType> rowSignature = new HashMap<>(); for (String columnName : Iterables.concat(adapter.getAvailableDimensions(), adapter.getAvailableMetrics())) { rowSignature.put(columnName, adapter.getColumnCapabilities(columnName).getType()); } // Perform test final SettableSupplier<InputRow> rowSupplier = new SettableSupplier<>(); final ValueMatcher matcher = makeFilter(filter).makeMatcher( VIRTUAL_COLUMNS.wrap(RowBasedColumnSelectorFactory.create(rowSupplier, rowSignature)) ); final List<String> values = new ArrayList<>(); for (InputRow row : rows) { rowSupplier.set(row); if (matcher.matches()) { values.add((String) row.getRaw(selectColumn)); } } return values; }
@Override public BufferAggregator factorizeBuffered(final ColumnSelectorFactory metricFactory) { if (metricFactory.getColumnCapabilities(fieldName) != null && ValueType.isNumeric(metricFactory.getColumnCapabilities(fieldName).getType())) { final ColumnValueSelector<Double> selector = metricFactory.makeColumnValueSelector(fieldName); if (selector instanceof NilColumnValueSelector) { return new DoublesSketchNoOpBufferAggregator(); } return new DoublesSketchBuildBufferAggregator(selector, k, getMaxIntermediateSizeWithNulls()); } final ColumnValueSelector<DoublesSketch> selector = metricFactory.makeColumnValueSelector(fieldName); if (selector instanceof NilColumnValueSelector) { return new DoublesSketchNoOpBufferAggregator(); } return new DoublesSketchMergeBufferAggregator(selector, k, getMaxIntermediateSizeWithNulls()); }
@Override public GroupByColumnSelectorStrategy makeColumnSelectorStrategy( ColumnCapabilities capabilities, ColumnValueSelector selector ) { ValueType type = capabilities.getType(); switch (type) { case STRING: DimensionSelector dimSelector = (DimensionSelector) selector; if (dimSelector.getValueCardinality() >= 0) { return new StringGroupByColumnSelectorStrategy(); } else { return new DictionaryBuildingStringGroupByColumnSelectorStrategy(); } case LONG: return makeNullableStrategy(new LongGroupByColumnSelectorStrategy()); case FLOAT: return makeNullableStrategy(new FloatGroupByColumnSelectorStrategy()); case DOUBLE: return makeNullableStrategy(new DoubleGroupByColumnSelectorStrategy()); default: throw new IAE("Cannot create query type helper from invalid type [%s]", type); } }
@Test public void testSerde() throws Exception { String json = mapper.writeValueAsString(new ColumnCapabilitiesImpl() .setDictionaryEncoded(true) .setHasBitmapIndexes(true) .setHasMultipleValues(true) .setHasSpatialIndexes(true) .setType(ValueType.COMPLEX) .setFilterable(true)); Assert.assertFalse(json.contains("filterable")); ColumnCapabilities cc = mapper.readValue(json, ColumnCapabilitiesImpl.class); Assert.assertEquals(ValueType.COMPLEX, cc.getType()); Assert.assertTrue(cc.isDictionaryEncoded()); Assert.assertFalse(cc.isRunLengthEncoded()); Assert.assertTrue(cc.hasSpatialIndexes()); Assert.assertTrue(cc.hasMultipleValues()); Assert.assertTrue(cc.hasBitmapIndexes()); Assert.assertFalse(cc.isFilterable()); }
@Test public void testDeserialization() throws Exception { String json = "{\n" + " \"type\":\"COMPLEX\",\n" + " \"dictionaryEncoded\":true,\n" + " \"runLengthEncoded\":true,\n" + " \"hasSpatialIndexes\":true,\n" + " \"hasMultipleValues\":true,\n" + " \"hasBitmapIndexes\":true,\n" + " \"filterable\":true\n" + "}"; ColumnCapabilities cc = mapper.readValue(json, ColumnCapabilitiesImpl.class); Assert.assertEquals(ValueType.COMPLEX, cc.getType()); Assert.assertTrue(cc.isDictionaryEncoded()); Assert.assertTrue(cc.isRunLengthEncoded()); Assert.assertTrue(cc.hasSpatialIndexes()); Assert.assertTrue(cc.hasMultipleValues()); Assert.assertTrue(cc.hasBitmapIndexes()); Assert.assertFalse(cc.isFilterable()); } }