Examples with TableMetadata io.prestosql.metadata.TableMetadata used on opensource projects

Example 56 with TableMetadata

use of io.prestosql.metadata.TableMetadata in project hetu-core by openlookeng.

the class LogicalPlanner method createVacuumTablePlan.

private RelationPlan createVacuumTablePlan(Analysis analysis, VacuumTable vacuumTable) {
    TableHandle handle = analysis.getTableHandle(vacuumTable.getTable());
    TableMetadata tableMetadata = metadata.getTableMetadata(session, handle);
    List<ColumnMetadata> columns = tableMetadata.getColumns();
    List<String> columnNames = columns.stream().filter(column -> !column.isHidden()).map(ColumnMetadata::getName).collect(Collectors.toList());
    List<Symbol> symbols = columns.stream().filter(column -> !column.isHidden()).map(c -> planSymbolAllocator.newSymbol(c.getName(), c.getType())).collect(Collectors.toList());
    ColumnHandle rowIdHandle = metadata.getDeleteRowIdColumnHandle(session, handle);
    ColumnMetadata rowIdColumnMetadata = metadata.getColumnMetadata(session, handle, rowIdHandle);
    Type rowIdType = rowIdColumnMetadata.getType();
    Symbol rowIdSymbol = planSymbolAllocator.newSymbol("$rowId", rowIdType);
    symbols.add(rowIdSymbol);
    columnNames.add(rowIdHandle.getColumnName());
    String catalogName = handle.getCatalogName().getCatalogName();
    TableStatisticsMetadata statisticsMetadata = TableStatisticsMetadata.empty();
    return createVacuumWriterPlan(analysis, handle, vacuumTable, new VacuumTargetReference(handle, vacuumTable.isFull(), vacuumTable.isUnify(), vacuumTable.getPartition()), symbols, columnNames, statisticsMetadata);
}

Example 57 with TableMetadata

use of io.prestosql.metadata.TableMetadata in project hetu-core by openlookeng.

the class LogicalPlanner method createUpdatePlan.

private RelationPlan createUpdatePlan(Analysis analysis, Update node) {
    TableHandle handle = analysis.getTableHandle(node.getTable());
    if (handle.getConnectorHandle().isUpdateAsInsertSupported()) {
        QueryPlanner.UpdateDeleteRelationPlan updatePlan = new QueryPlanner(analysis, planSymbolAllocator, idAllocator, buildLambdaDeclarationToSymbolMap(analysis, planSymbolAllocator), metadata, session, namedSubPlan, uniqueIdAllocator).planUpdateRowAsInsert(node);
        RelationPlan plan = updatePlan.getPlan();
        Analysis.Update update = analysis.getUpdate().get();
        TableMetadata tableMetadata = metadata.getTableMetadata(session, update.getTarget());
        Optional<NewTableLayout> newTableLayout = metadata.getUpdateLayout(session, update.getTarget());
        String catalogName = update.getTarget().getCatalogName().getCatalogName();
        TableStatisticsMetadata statisticsMetadata = metadata.getStatisticsCollectionMetadataForWrite(session, catalogName, tableMetadata.getMetadata());
        Optional<Expression> constraint = updatePlan.getPredicate().isPresent() ? Optional.of(OriginalExpressionUtils.castToExpression(updatePlan.getPredicate().get())) : Optional.empty();
        return createTableWriterPlan(analysis, plan, new TableWriterNode.UpdateReference(update.getTarget(), constraint, updatePlan.getColumnAssignments()), updatePlan.getColumNames(), newTableLayout, statisticsMetadata);
    }
    UpdateNode updateNode = new QueryPlanner(analysis, planSymbolAllocator, idAllocator, buildLambdaDeclarationToSymbolMap(analysis, planSymbolAllocator), metadata, session, namedSubPlan, uniqueIdAllocator).plan(node);
    TableFinishNode commitNode = new TableFinishNode(idAllocator.getNextId(), updateNode, updateNode.getTarget(), planSymbolAllocator.newSymbol("rows", BIGINT), Optional.empty(), Optional.empty());
    return new RelationPlan(commitNode, analysis.getScope(node), commitNode.getOutputSymbols());
}

Example 58 with TableMetadata

use of io.prestosql.metadata.TableMetadata in project hetu-core by openlookeng.

the class QueryPlanner method planDeleteRowAsInsert.

public UpdateDeleteRelationPlan planDeleteRowAsInsert(Delete node) {
    Table table = node.getTable();
    RelationType descriptor = analysis.getOutputDescriptor(node.getTable());
    TableHandle handle = analysis.getTableHandle(node.getTable());
    ColumnHandle rowIdHandle = analysis.getRowIdHandle(table);
    Type rowIdType = metadata.getColumnMetadata(session, handle, rowIdHandle).getType();
    ImmutableList.Builder<Symbol> outputSymbols = ImmutableList.builder();
    ImmutableMap.Builder<Symbol, ColumnHandle> columnsBuilder = ImmutableMap.builder();
    ColumnMetadata rowIdColumnMetadata = metadata.getColumnMetadata(session, handle, rowIdHandle);
    ImmutableList.Builder<Field> fields = ImmutableList.builder();
    ImmutableList.Builder<Field> projectionFields = ImmutableList.builder();
    Symbol orderBySymbol = null;
    // add table columns
    for (Field field : descriptor.getAllFields()) {
        Symbol symbol = planSymbolAllocator.newSymbol(field.getName().get(), field.getType());
        outputSymbols.add(symbol);
        ColumnHandle column = analysis.getColumn(field);
        columnsBuilder.put(symbol, column);
        fields.add(field);
        ColumnMetadata columnMetadata = metadata.getColumnMetadata(session, handle, column);
        if (columnMetadata.isRequired()) {
            projectionFields.add(field);
        }
        if (field.getName().toString().contains("rowId")) {
            projectionFields.add(field);
        }
        if (field.getName().toString().contains("tupleId")) {
            projectionFields.add(field);
        }
    }
    // create table scan
    ImmutableMap<Symbol, ColumnHandle> columns = columnsBuilder.build();
    PlanNode tableScan = TableScanNode.newInstance(idAllocator.getNextId(), handle, outputSymbols.build(), columns, ReuseExchangeOperator.STRATEGY.REUSE_STRATEGY_DEFAULT, new UUID(0, 0), 0, false);
    Scope scope = Scope.builder().withRelationType(RelationId.anonymous(), new RelationType(fields.build())).build();
    RelationPlan relationPlan = new RelationPlan(tableScan, scope, outputSymbols.build());
    TranslationMap translations = new TranslationMap(relationPlan, analysis, lambdaDeclarationToSymbolMap);
    translations.setFieldMappings(relationPlan.getFieldMappings());
    PlanBuilder builder = new PlanBuilder(translations, relationPlan.getRoot());
    Optional<RowExpression> predicate = Optional.empty();
    if (node.getWhere().isPresent()) {
        builder = filter(builder, node.getWhere().get(), node);
        if (builder.getRoot() instanceof FilterNode) {
            predicate = Optional.of(((FilterNode) builder.getRoot()).getPredicate());
        }
    }
    Assignments.Builder assignments = Assignments.builder();
    TableMetadata tableMetadata = metadata.getTableMetadata(session, handle);
    for (Map.Entry<Symbol, ColumnHandle> entry : columns.entrySet()) {
        ColumnMetadata column;
        ColumnHandle columnHandle = entry.getValue();
        Symbol input = entry.getKey();
        if (columnHandle.getColumnName().equals(rowIdHandle.getColumnName())) {
            column = rowIdColumnMetadata;
        } else {
            column = tableMetadata.getColumn(columnHandle.getColumnName());
        }
        if (column != rowIdColumnMetadata && (column.isHidden() || !column.isRequired())) {
            // Skip unnecessary columns as well.
            continue;
        }
        Symbol output = planSymbolAllocator.newSymbol(column.getName(), column.getType());
        Type tableType = column.getType();
        Type queryType = planSymbolAllocator.getTypes().get(input);
        if (queryType.equals(tableType) || typeCoercion.isTypeOnlyCoercion(queryType, tableType)) {
            assignments.put(output, castToRowExpression(toSymbolReference(input)));
        } else {
            Expression cast = new Cast(toSymbolReference(input), tableType.getTypeSignature().toString());
            assignments.put(output, castToRowExpression(cast));
        }
        if (column == rowIdColumnMetadata) {
            orderBySymbol = output;
        }
    }
    ProjectNode projectNode = new ProjectNode(idAllocator.getNextId(), builder.getRoot(), assignments.build());
    builder = new PlanBuilder(translations, projectNode);
    scope = Scope.builder().withRelationType(RelationId.anonymous(), new RelationType(projectionFields.build())).build();
    RelationPlan plan = new RelationPlan(builder.getRoot(), scope, projectNode.getOutputSymbols());
    List<String> visibleTableColumnNames = tableMetadata.getColumns().stream().filter(c -> c.isRequired()).map(ColumnMetadata::getName).collect(Collectors.toList());
    visibleTableColumnNames.add(rowIdColumnMetadata.getName());
    return new UpdateDeleteRelationPlan(plan, visibleTableColumnNames, columns, predicate);
}

Example 59 with TableMetadata

use of io.prestosql.metadata.TableMetadata in project hetu-core by openlookeng.

the class QueryPlanner method plan.

public UpdateNode plan(Update node) {
    Table table = node.getTable();
    TableHandle handle = analysis.getTableHandle(table);
    TableMetadata tableMetadata = metadata.getTableMetadata(session, handle);
    List<ColumnMetadata> dataColumns = tableMetadata.getMetadata().getColumns().stream().filter(column -> !column.isHidden()).collect(toImmutableList());
    List<String> targetColumnNames = node.getAssignmentItems().stream().map(assignment -> assignment.getName().toString()).collect(toImmutableList());
    // Create lists of columnnames and SET expressions, in table column order
    ImmutableList.Builder<String> updatedColumnNamesBuilder = ImmutableList.builder();
    ImmutableList.Builder<Type> updatedColumnTypesBuilder = ImmutableList.builder();
    ImmutableList.Builder<Expression> orderedColumnValuesBuilder = ImmutableList.builder();
    ImmutableMap.Builder<String, Expression> setExpressions = new ImmutableMap.Builder<>();
    for (ColumnMetadata columnMetadata : dataColumns) {
        String name = columnMetadata.getName();
        Type type = columnMetadata.getType();
        int index = targetColumnNames.indexOf(name);
        if (index >= 0) {
            updatedColumnNamesBuilder.add(name);
            updatedColumnTypesBuilder.add(type);
            orderedColumnValuesBuilder.add(node.getAssignmentItems().get(index).getValue());
            setExpressions.put(name, node.getAssignmentItems().get(index).getValue());
        }
    }
    List<String> updatedColumnNames = updatedColumnNamesBuilder.build();
    List<Type> updatedColumnTypes = updatedColumnTypesBuilder.build();
    List<Expression> orderedColumnValues = orderedColumnValuesBuilder.build();
    // create table scan
    RelationPlan relationPlan = new RelationPlanner(analysis, planSymbolAllocator, idAllocator, lambdaDeclarationToSymbolMap, metadata, session, namedSubPlan, uniqueIdAllocator).process(table, null);
    PlanBuilder builder = planBuilderFor(relationPlan);
    if (node.getWhere().isPresent()) {
        builder = filter(builder, node.getWhere().get(), node);
    }
    builder = builder.appendProjections(orderedColumnValues, planSymbolAllocator, idAllocator);
    PlanAndMappings planAndMappings = coerce(builder, orderedColumnValues, analysis, idAllocator, planSymbolAllocator, typeCoercion);
    builder = planAndMappings.getSubPlan();
    ImmutableList.Builder<Symbol> updatedColumnValuesBuilder = ImmutableList.builder();
    orderedColumnValues.forEach(columnValue -> updatedColumnValuesBuilder.add(planAndMappings.get(columnValue)));
    Symbol rowId = builder.translate(analysis.getRowIdField(table));
    updatedColumnValuesBuilder.add(rowId);
    List<Symbol> outputs = ImmutableList.of(planSymbolAllocator.newSymbol("partialrows", BIGINT), planSymbolAllocator.newSymbol("fragment", VARBINARY));
    Optional<PlanNodeId> tableScanId = getIdForLeftTableScan(relationPlan.getRoot());
    checkArgument(tableScanId.isPresent(), "tableScanId not present");
    // create update node
    return new UpdateNode(idAllocator.getNextId(), builder.getRoot(), new TableWriterNode.UpdateTarget(handle, metadata.getTableMetadata(session, handle).getTable(), updatedColumnNames, updatedColumnTypes), rowId, updatedColumnValuesBuilder.build(), outputs, setExpressions.build());
}

Example 60 with TableMetadata

use of io.prestosql.metadata.TableMetadata in project hetu-core by openlookeng.

the class TestStarTreeAggregationRule method setupBeforeClass.

@BeforeClass
public void setupBeforeClass() {
    PlanSymbolAllocator symbolAllocator = new PlanSymbolAllocator();
    columnOrderkey = symbolAllocator.newSymbol("orderkey", BIGINT);
    columnOrderDate = symbolAllocator.newSymbol("orderdate", DATE);
    columnCustkey = symbolAllocator.newSymbol("custkey", BIGINT);
    columnTotalprice = symbolAllocator.newSymbol("totalprice", DOUBLE);
    orderkeyHandle = new TpchColumnHandle("orderkey", BIGINT);
    orderdateHandle = new TpchColumnHandle("orderdate", DATE);
    custkeyHandle = new TpchColumnHandle("custkey", BIGINT);
    totalpriceHandle = new TpchColumnHandle("totalprice", DOUBLE);
    ColumnMetadata orderKeyColumnMetadata = new ColumnMetadata(orderkeyHandle.getColumnName(), orderkeyHandle.getType());
    ColumnMetadata orderDateColumnMetadata = new ColumnMetadata(orderdateHandle.getColumnName(), orderdateHandle.getType());
    ColumnMetadata custKeyColumnMetadata = new ColumnMetadata(custkeyHandle.getColumnName(), custkeyHandle.getType());
    ColumnMetadata totalPriceColumnMetadata = new ColumnMetadata(totalpriceHandle.getColumnName(), totalpriceHandle.getType());
    output = symbolAllocator.newSymbol("output", DOUBLE);
    assignments = ImmutableMap.<Symbol, ColumnHandle>builder().put(columnOrderkey, orderkeyHandle).put(columnOrderDate, orderdateHandle).put(columnCustkey, custkeyHandle).put(columnTotalprice, totalpriceHandle).build();
    TpchTableHandle orders = new TpchTableHandle("orders", 1.0);
    ordersTableHandle = new TableHandle(tester().getCurrentConnectorId(), orders, TpchTransactionHandle.INSTANCE, Optional.of(new TpchTableLayoutHandle(orders, TupleDomain.all())));
    baseTableScan = new TableScanNode(newId(), ordersTableHandle, ImmutableList.copyOf(assignments.keySet()), assignments, TupleDomain.all(), Optional.empty(), ReuseExchangeOperator.STRATEGY.REUSE_STRATEGY_DEFAULT, new UUID(0, 0), 0, false);
    QualifiedObjectName baseTableName = QualifiedObjectName.valueOf(baseTableScan.getTable().getFullyQualifiedName());
    baseTableMetadata = new TableMetadata(ordersTableHandle.getCatalogName(), new ConnectorTableMetadata(new SchemaTableName(baseTableName.getSchemaName(), baseTableName.getObjectName()), Arrays.asList(orderKeyColumnMetadata, orderDateColumnMetadata, custKeyColumnMetadata, totalPriceColumnMetadata)));
    columnCountAll = symbolAllocator.newSymbol("count_all", BIGINT);
    columnSumTotalPrice = symbolAllocator.newSymbol("sum_totalprice", DOUBLE);
    columnCountOrderKey = symbolAllocator.newSymbol("count_orderkey", BIGINT);
    columnGroupingBitSet = symbolAllocator.newSymbol("grouping_bit_set", BIGINT);
    cubeColumnCustKey = symbolAllocator.newSymbol("custkey", BIGINT);
    cubeColumnOrderDate = symbolAllocator.newSymbol("orderdate", DATE);
    countAllHandle = new TpchColumnHandle("count_all", BIGINT);
    sumTotalPriceHandle = new TpchColumnHandle("sum_totalprice", DOUBLE);
    countOrderKeyHandle = new TpchColumnHandle("count_orderkey", BIGINT);
    groupingBitSetHandle = new TpchColumnHandle("grouping_bit_set", BIGINT);
    custKeyCubeColumnHandle = new TpchColumnHandle("custkey", BIGINT);
    orderDateCubeColumnHandle = new TpchColumnHandle("orderdate", DATE);
    ordersCubeColumnHandles.put(countAllHandle.getColumnName(), countAllHandle);
    ordersCubeColumnHandles.put(sumTotalPriceHandle.getColumnName(), sumTotalPriceHandle);
    ordersCubeColumnHandles.put(countOrderKeyHandle.getColumnName(), countOrderKeyHandle);
    ordersCubeColumnHandles.put(groupingBitSetHandle.getColumnName(), groupingBitSetHandle);
    ordersCubeColumnHandles.put(custKeyCubeColumnHandle.getColumnName(), custKeyCubeColumnHandle);
    ordersCubeColumnHandles.put(orderDateCubeColumnHandle.getColumnName(), orderDateCubeColumnHandle);
    TpchTableHandle ordersCube = new TpchTableHandle("orders_cube", 1.0);
    ordersCubeHandle = new TableHandle(tester().getCurrentConnectorId(), ordersCube, TpchTransactionHandle.INSTANCE, Optional.of(new TpchTableLayoutHandle(ordersCube, TupleDomain.all())));
    countAllColumnMetadata = new ColumnMetadata(countAllHandle.getColumnName(), countAllHandle.getType());
    sumTotalPriceColumnMetadata = new ColumnMetadata(sumTotalPriceHandle.getColumnName(), sumTotalPriceHandle.getType());
    countOrderKeyColumnMetadata = new ColumnMetadata(countOrderKeyHandle.getColumnName(), countOrderKeyHandle.getType());
    groupingBitSetColumnMetadata = new ColumnMetadata(groupingBitSetHandle.getColumnName(), groupingBitSetHandle.getType());
    custKeyCubeColumnMetadata = new ColumnMetadata(custKeyCubeColumnHandle.getColumnName(), custKeyCubeColumnHandle.getType());
    orderDateCubeColumnMetadata = new ColumnMetadata(orderDateCubeColumnHandle.getColumnName(), orderDateCubeColumnHandle.getType());
    config = new FeaturesConfig();
    config.setEnableStarTreeIndex(true);
    cubeManager = Mockito.mock(CubeManager.class);
    provider = Mockito.mock(CubeProvider.class);
    cubeMetaStore = Mockito.mock(CubeMetaStore.class);
    cubeMetadata = Mockito.mock(CubeMetadata.class);
    ordersTableHandleMatcher = new BaseMatcher<TableHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof TableHandle)) {
                return false;
            }
            TableHandle th = (TableHandle) o;
            return th.getFullyQualifiedName().equals(ordersTableHandle.getFullyQualifiedName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
    ordersCubeHandleMatcher = new BaseMatcher<TableHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof TableHandle)) {
                return false;
            }
            TableHandle th = (TableHandle) o;
            return th.getFullyQualifiedName().equals(ordersCubeHandle.getFullyQualifiedName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
    countAllColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public void describeTo(Description description) {
        }

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(countAllHandle.getColumnName());
        }
    };
    sumTotalPriceColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public void describeTo(Description description) {
        }

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(sumTotalPriceHandle.getColumnName());
        }
    };
    countOrderKeyColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(countOrderKeyHandle.getColumnName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
    groupingBitSetColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(groupingBitSetHandle.getColumnName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
    orderDateCubeColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(orderDateCubeColumnHandle.getColumnName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
    custKeyCubeColumnHandleMatcher = new BaseMatcher<ColumnHandle>() {

        @Override
        public boolean matches(Object o) {
            if (!(o instanceof ColumnHandle)) {
                return false;
            }
            ColumnHandle ch = (ColumnHandle) o;
            return ch.getColumnName().equalsIgnoreCase(custKeyCubeColumnHandle.getColumnName());
        }

        @Override
        public void describeTo(Description description) {
        }
    };
}