private void verifyPartition(boolean hasPartition, TableMetadata tableMetadata, List<String> partitionKeys) { Object partitionByProperty = tableMetadata.getMetadata().getProperties().get(PARTITIONED_BY_PROPERTY); if (hasPartition) { assertEquals(partitionByProperty, partitionKeys); for (ColumnMetadata columnMetadata : tableMetadata.getColumns()) { boolean partitionKey = partitionKeys.contains(columnMetadata.getName()); assertEquals(columnMetadata.getExtraInfo(), columnExtraInfo(partitionKey)); } } else { assertNull(partitionByProperty); } }
@Override public TableMetadata getTableMetadata(Session session, TableHandle tableHandle) { ConnectorId connectorId = tableHandle.getConnectorId(); ConnectorMetadata metadata = getMetadata(session, connectorId); ConnectorTableMetadata tableMetadata = metadata.getTableMetadata(session.toConnectorSession(connectorId), tableHandle.getConnectorHandle()); if (tableMetadata.getColumns().isEmpty()) { throw new PrestoException(NOT_SUPPORTED, "Table has no columns: " + tableHandle); } return new TableMetadata(connectorId, tableMetadata); }
List<String> tableColumns = tableMetadata.getColumns().stream() .filter(column -> !column.isHidden()) .map(ColumnMetadata::getName) .map(insertColumn -> tableMetadata.getColumn(insertColumn).getType()) .collect(toImmutableList());
private Input createInput(TableMetadata table, Optional<TableLayoutHandle> layout, Set<Column> columns) { SchemaTableName schemaTable = table.getTable(); Optional<Object> inputMetadata = layout.flatMap(tableLayout -> metadata.getInfo(session, tableLayout)); return new Input(table.getConnectorId(), schemaTable.getSchemaName(), schemaTable.getTableName(), inputMetadata, ImmutableList.copyOf(columns)); }
@Test public void testBucketedCatalog() { String bucketedCatalog = bucketedSession.getCatalog().get(); String bucketedSchema = bucketedSession.getSchema().get(); TableMetadata ordersTableMetadata = getTableMetadata(bucketedCatalog, bucketedSchema, "orders"); assertEquals(ordersTableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("custkey")); assertEquals(ordersTableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); TableMetadata customerTableMetadata = getTableMetadata(bucketedCatalog, bucketedSchema, "customer"); assertEquals(customerTableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("custkey")); assertEquals(customerTableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); }
public ColumnMetadata getColumn(String name) { return getColumns().stream() .filter(columnMetadata -> columnMetadata.getName().equals(name)) .findFirst() .orElseThrow(() -> new IllegalArgumentException(String.format("Invalid column name: %s", name))); } }
@Override public MatchResult detailMatches(PlanNode node, StatsProvider stats, Session session, Metadata metadata, SymbolAliases symbolAliases) { checkState(shapeMatches(node), "Plan testing framework error: shapeMatches returned false in detailMatches in %s", this.getClass().getName()); TableScanNode tableScanNode = (TableScanNode) node; TableMetadata tableMetadata = metadata.getTableMetadata(session, tableScanNode.getTable()); String actualTableName = tableMetadata.getTable().getTableName(); return new MatchResult( expectedTableName.equalsIgnoreCase(actualTableName) && ((!expectedConstraint.isPresent()) || domainsMatch(expectedConstraint, tableScanNode.getCurrentConstraint(), tableScanNode.getTable(), session, metadata)) && hasTableLayout(tableScanNode)); }
private void assertColumnType(TableMetadata tableMetadata, String columnName, Type expectedType) { assertEquals(tableMetadata.getColumn(columnName).getType(), canonicalizeType(expectedType)); }
List<String> tableColumns = tableMetadata.getVisibleColumnNames(); .map(insertColumn -> tableMetadata.getColumn(insertColumn).getType()) .collect(toImmutableList());
private void verifyPartitionedBucketedTable(HiveStorageFormat storageFormat, String tableName) { TableMetadata tableMetadata = getTableMetadata(catalog, TPCH_SCHEMA, tableName); assertEquals(tableMetadata.getMetadata().getProperties().get(STORAGE_FORMAT_PROPERTY), storageFormat); assertEquals(tableMetadata.getMetadata().getProperties().get(PARTITIONED_BY_PROPERTY), ImmutableList.of("orderstatus")); assertEquals(tableMetadata.getMetadata().getProperties().get(BUCKETED_BY_PROPERTY), ImmutableList.of("custkey", "custkey2")); assertEquals(tableMetadata.getMetadata().getProperties().get(BUCKET_COUNT_PROPERTY), 11); List<?> partitions = getPartitions(tableName); assertEquals(partitions.size(), 3); assertQuery("SELECT * from " + tableName, "SELECT custkey, custkey, comment, orderstatus FROM orders"); for (int i = 1; i <= 30; i++) { assertQuery( format("SELECT * from " + tableName + " where custkey = %d and custkey2 = %d", i, i), format("SELECT custkey, custkey, comment, orderstatus FROM orders where custkey = %d", i)); } assertThatThrownBy(() -> assertUpdate("INSERT INTO " + tableName + " VALUES (1, 1, 'comment', 'O')", 1)) .hasMessage(getExpectedErrorMessageForInsertExistingBucketedTable( getInsertExistingPartitionsBehavior(getConnectorSession(getSession())), "orderstatus=O")); }
private List<Expression> buildStatisticsRows(TableMetadata tableMetadata, Map<String, ColumnHandle> columnHandles, TableStatistics tableStatistics) { ImmutableList.Builder<Expression> rowsBuilder = ImmutableList.builder(); for (ColumnMetadata columnMetadata : tableMetadata.getColumns()) { if (columnMetadata.isHidden()) { continue; } String columnName = columnMetadata.getName(); Type columnType = columnMetadata.getType(); ColumnHandle columnHandle = columnHandles.get(columnName); ColumnStatistics columnStatistics = tableStatistics.getColumnStatistics().get(columnHandle); if (columnStatistics != null) { rowsBuilder.add(createColumnStatsRow(columnName, columnType, columnStatistics)); } else { rowsBuilder.add(createEmptyColumnStatsRow(columnName)); } } // Stats for whole table rowsBuilder.add(createTableStatsRow(tableStatistics)); return rowsBuilder.build(); }
@Override public Void visitTableScan(TableScanNode node, IOPlanBuilder context) { TableMetadata tableMetadata = metadata.getTableMetadata(session, node.getTable()); context.addInputTableColumnInfo(new IOPlan.TableColumnInfo( new CatalogSchemaTableName( tableMetadata.getConnectorId().getCatalogName(), tableMetadata.getTable().getSchemaName(), tableMetadata.getTable().getTableName()), parseConstraints(node.getTable(), node.getCurrentConstraint()))); return null; }
private TableWriterNode.WriterTarget createWriterTarget(TableWriterNode.WriterTarget target) { // TODO: begin these operations in pre-execution step, not here // TODO: we shouldn't need to store the schemaTableName in the handles, but there isn't a good way to pass this around with the current architecture if (target instanceof TableWriterNode.CreateName) { TableWriterNode.CreateName create = (TableWriterNode.CreateName) target; return new TableWriterNode.CreateHandle(metadata.beginCreateTable(session, create.getCatalog(), create.getTableMetadata(), create.getLayout()), create.getTableMetadata().getTable()); } if (target instanceof TableWriterNode.InsertReference) { TableWriterNode.InsertReference insert = (TableWriterNode.InsertReference) target; return new TableWriterNode.InsertHandle(metadata.beginInsert(session, insert.getHandle()), metadata.getTableMetadata(session, insert.getHandle()).getTable()); } if (target instanceof TableWriterNode.DeleteHandle) { TableWriterNode.DeleteHandle delete = (TableWriterNode.DeleteHandle) target; return new TableWriterNode.DeleteHandle(metadata.beginDelete(session, delete.getHandle()), delete.getSchemaTableName()); } throw new IllegalArgumentException("Unhandled target type: " + target.getClass().getSimpleName()); }
private void assertColumnType(TableMetadata tableMetadata, String columnName, Type expectedType) { assertEquals(tableMetadata.getColumn(columnName).getType(), canonicalizeType(expectedType)); }
inheritedProperties = likeTableMetadata.getMetadata().getProperties(); likeTableMetadata.getColumns().stream() .filter(column -> !column.isHidden()) .forEach(column -> {
ConnectorTableMetadata connectorTableMetadata = metadata.getTableMetadata(session, tableHandle.get()).getMetadata();
if (metadata.getTableMetadata(session, tableHandle).getColumns().stream() .filter(info -> !info.isHidden()).count() <= 1) { throw new SemanticException(NOT_SUPPORTED, statement, "Cannot drop the only column in a table");
@Override public TableMetadata fromTableDto(final QualifiedName name, final TableDto table, final TypeManager typeManager) { Preconditions.checkNotNull(name, "name is null"); Preconditions.checkNotNull(table, "table is null"); Preconditions.checkNotNull(typeManager, "typeManager is null"); return new TableMetadata(name.getCatalogName(), fromTableDto(table, typeManager)); }
private static TableEntry createTableEntry(TableMetadata table) { SchemaTableName schemaTable = table.getTable(); return new TableEntry(table.getConnectorId(), schemaTable.getSchemaName(), schemaTable.getTableName()); }
symbolAllocator.newSymbol("fragment", VARBINARY)); return new DeleteNode(idAllocator.getNextId(), builder.getRoot(), new DeleteHandle(handle, metadata.getTableMetadata(session, handle).getTable()), rowId, outputs);