private <E extends TpchEntity> Comparable<?> getTpchValue(E row, TpchColumn<E> column) { TpchColumnType.Base baseType = column.getType().getBase(); switch (baseType) { case IDENTIFIER: return column.getIdentifier(row); case INTEGER: return column.getInteger(row); case DATE: return column.getDate(row); case DOUBLE: return column.getDouble(row); case VARCHAR: return column.getString(row); } throw new UnsupportedOperationException(format("Unsupported TPCH base type [%s]", baseType)); } }
private Optional<String> getPartitionDescription(Optional<TpchColumn<?>> partitionColumn, Optional<String> partitionValue) { checkArgument(partitionColumn.isPresent() == partitionValue.isPresent()); return withBoth(partitionColumn, partitionValue, (column, value) -> column.getColumnName() + "." + value); } }
@Override public final PrestoThriftNullableTableMetadata getTableMetadata(PrestoThriftSchemaTableName schemaTableName) { String schemaName = schemaTableName.getSchemaName(); String tableName = schemaTableName.getTableName(); if (!SCHEMAS.contains(schemaName) || TpchTable.getTables().stream().noneMatch(table -> table.getTableName().equals(tableName))) { return new PrestoThriftNullableTableMetadata(null); } TpchTable<?> tpchTable = TpchTable.getTable(schemaTableName.getTableName()); List<PrestoThriftColumnMetadata> columns = new ArrayList<>(); for (TpchColumn<? extends TpchEntity> column : tpchTable.getColumns()) { columns.add(new PrestoThriftColumnMetadata(column.getSimplifiedColumnName(), getTypeString(column), null, false)); } List<Set<String>> indexableKeys = getIndexableKeys(schemaName, tableName); return new PrestoThriftNullableTableMetadata(new PrestoThriftTableMetadata(schemaTableName, columns, null, !indexableKeys.isEmpty() ? indexableKeys : null)); }
private long getLong(TpchColumn<E> tpchColumn) { if (tpchColumn.getType().getBase() == TpchColumnType.Base.DATE) { return tpchColumn.getDate(row); } if (tpchColumn.getType().getBase() == TpchColumnType.Base.INTEGER) { return tpchColumn.getInteger(row); } return tpchColumn.getIdentifier(row); }
public static Type getPrestoType(TpchColumn<?> column) { TpchColumnType tpchType = column.getType(); switch (tpchType.getBase()) { case IDENTIFIER: return BIGINT; case INTEGER: return INTEGER; case DATE: return DATE; case DOUBLE: return DOUBLE; case VARCHAR: return createVarcharType((int) (long) tpchType.getPrecision().get()); } throw new IllegalArgumentException("Unsupported type " + tpchType); }
private static ConnectorTableMetadata getTableMetadata(String schemaName, TpchTable<?> tpchTable) { ImmutableList.Builder<ColumnMetadata> columns = ImmutableList.builder(); for (TpchColumn<? extends TpchEntity> column : tpchTable.getColumns()) { columns.add(new ColumnMetadata(column.getColumnName(), getPrestoType(column.getType()))); } columns.add(new ColumnMetadata(ROW_NUMBER_COLUMN_NAME, BIGINT, null, true)); SchemaTableName tableName = new SchemaTableName(schemaName, tpchTable.getTableName()); return new ConnectorTableMetadata(tableName, columns.build()); }
private Slice getSlice(TpchColumn<E> tpchColumn) { return Slices.utf8Slice(tpchColumn.getString(row)); }
@Test public void testSimplifiedColumnNamesAreSuffixesOfColumnNames() { forEachTpchColumn(column -> assertEquals(column.getSimplifiedColumnName(), stripPrefix(column.getColumnName()))); }
private double getDouble(TpchColumn<E> tpchColumn) { return tpchColumn.getDouble(row); }
private long getLong(TpchColumn<E> tpchColumn) { if (tpchColumn.getType().getBase() == TpchColumnType.Base.DATE) { return tpchColumn.getDate(row); } if (tpchColumn.getType().getBase() == TpchColumnType.Base.INTEGER) { return tpchColumn.getInteger(row); } return tpchColumn.getIdentifier(row); }
private static Type getColumnType(TpchColumn<?> input) { switch (input.getType().getBase()) { case IDENTIFIER: return BIGINT; case INTEGER: return INTEGER; case DATE: return DATE; case DOUBLE: return DOUBLE; case VARCHAR: return createUnboundedVarcharType(); } throw new IllegalArgumentException("Unsupported type " + input.getType()); }
private <E extends TpchEntity> void computeAndOutputStatsFor(String schemaName, TpchTable<E> table, TpchColumn<E> partitionColumn, String partitionValue) { Predicate<E> predicate = row -> partitionColumn.getString(row).equals(partitionValue); computeAndOutputStatsFor(schemaName, table, predicate, Optional.of(partitionColumn), Optional.of(partitionValue)); }
@Test public void testGetColumn() { TpchTable.getTables().forEach(table -> { table.getColumns().forEach(column -> { assertEquals(table.getColumn(column.getColumnName()), column); assertEquals(table.getColumn(column.getSimplifiedColumnName()), column); }); }); } }
private double getDouble(TpchColumn<E> tpchColumn) { return tpchColumn.getDouble(row); }
TpchColumn<E> column = columns.get(i); BlockBuilder blockBuilder = pageBuilder.getBlockBuilder(i); switch (column.getType().getBase()) { case IDENTIFIER: BIGINT.writeLong(blockBuilder, column.getIdentifier(row)); break; case INTEGER: INTEGER.writeLong(blockBuilder, column.getInteger(row)); break; case DATE: if (format.supportsDate()) { DATE.writeLong(blockBuilder, column.getDate(row)); createUnboundedVarcharType().writeString(blockBuilder, column.getString(row)); DOUBLE.writeDouble(blockBuilder, column.getDouble(row)); break; case VARCHAR: createUnboundedVarcharType().writeSlice(blockBuilder, Slices.utf8Slice(column.getString(row))); break; default: throw new IllegalArgumentException("Unsupported type " + column.getType());
private long getLong(TpchColumn<E> tpchColumn) { if (tpchColumn.getType().getBase() == TpchColumnType.Base.DATE) { return tpchColumn.getDate(row); } if (tpchColumn.getType().getBase() == TpchColumnType.Base.INTEGER) { return tpchColumn.getInteger(row); } return tpchColumn.getIdentifier(row); }
private <E extends TpchEntity> Map<TpchColumn<E>, ColumnStatisticsRecorder> createStatisticsRecorders(List<TpchColumn<E>> columns) { return columns.stream() .collect(toImmutableMap(identity(), (column) -> new ColumnStatisticsRecorder(column.getType()))); }
private Optional<Long> addDistinctValuesCount(TpchColumn<?> partitionColumn, String columnName, ColumnStatisticsData leftStats, ColumnStatisticsData rightStats) { //unique values count can't be added between different partitions //for columns other than the partition column (because almost certainly there are duplicates) return combine(leftStats.getDistinctValuesCount(), rightStats.getDistinctValuesCount(), (a, b) -> a + b) .filter(v -> columnName.equals(partitionColumn.getColumnName())); }
private Slice getSlice(TpchColumn<E> tpchColumn) { return Slices.utf8Slice(tpchColumn.getString(row)); }
private void testColumnStats(String schema, TpchTable<?> table, TpchColumn<?> column, Constraint<ColumnHandle> constraint, ColumnStatistics expected) { TpchTableHandle tableHandle = tpchMetadata.getTableHandle(session, new SchemaTableName(schema, table.getTableName())); TableStatistics tableStatistics = tpchMetadata.getTableStatistics(session, tableHandle, constraint); ColumnHandle columnHandle = tpchMetadata.getColumnHandles(session, tableHandle).get(column.getSimplifiedColumnName()); ColumnStatistics actual = tableStatistics.getColumnStatistics().get(columnHandle); EstimateAssertion estimateAssertion = new EstimateAssertion(TOLERANCE); estimateAssertion.assertClose(actual.getDistinctValuesCount(), expected.getDistinctValuesCount(), "distinctValuesCount"); estimateAssertion.assertClose(actual.getDataSize(), expected.getDataSize(), "dataSize"); estimateAssertion.assertClose(actual.getNullsFraction(), expected.getNullsFraction(), "nullsFraction"); estimateAssertion.assertClose(actual.getRange(), expected.getRange(), "range"); }