org.apache.calcite.plan.RelOptTable Java Examples

/** Creates a BindableTableScan. */
public static BindableTableScan create(RelOptCluster cluster,
    RelOptTable relOptTable, List<RexNode> filters,
    List<Integer> projects) {
  final Table table = relOptTable.unwrap(Table.class);
  final RelTraitSet traitSet =
      cluster.traitSetOf(BindableConvention.INSTANCE)
          .replaceIfs(RelCollationTraitDef.INSTANCE, () -> {
            if (table != null) {
              return table.getStatistic().getCollations();
            }
            return ImmutableList.of();
          });
  return new BindableTableScan(cluster, traitSet, relOptTable,
      ImmutableList.copyOf(filters), ImmutableIntList.copyOf(projects));
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Delta delta = call.rel(0);
  final TableScan scan = call.rel(1);
  final RelOptCluster cluster = delta.getCluster();
  final RelOptTable relOptTable = scan.getTable();
  final StreamableTable streamableTable =
      relOptTable.unwrap(StreamableTable.class);
  if (streamableTable != null) {
    final Table table1 = streamableTable.stream();
    final RelOptTable relOptTable2 =
        RelOptTableImpl.create(relOptTable.getRelOptSchema(),
            relOptTable.getRowType(), table1,
            ImmutableList.<String>builder()
                .addAll(relOptTable.getQualifiedName())
                .add("(STREAM)").build());
    final LogicalTableScan newScan =
        LogicalTableScan.create(cluster, relOptTable2);
    call.transformTo(newScan);
  }
}
 

public void validateUpdate(SqlUpdate call) {
	final SqlValidatorNamespace targetNamespace = getNamespace(call);
	validateNamespace(targetNamespace, unknownType);
	final RelOptTable relOptTable = SqlValidatorUtil.getRelOptTable(
		targetNamespace, catalogReader.unwrap(Prepare.CatalogReader.class), null, null);
	final SqlValidatorTable table = relOptTable == null
		? targetNamespace.getTable()
		: relOptTable.unwrap(SqlValidatorTable.class);

	final RelDataType targetRowType =
		createTargetRowType(
			table,
			call.getTargetColumnList(),
			true);

	final SqlSelect select = call.getSourceSelect();
	validateSelect(select, targetRowType);

	final RelDataType sourceRowType = getNamespace(call).getRowType();
	checkTypeAssignment(sourceRowType, targetRowType, call);

	checkConstraint(table, call, targetRowType);

	validateAccess(call.getTargetTable(), table, SqlAccessEnum.UPDATE);
}
 

/**
 * Retrieves join factors that correspond to simple table references. A
 * simple table reference is a single table reference with no grouping or
 * aggregation.
 *
 * @param multiJoin join factors being optimized
 *
 * @return map consisting of the simple factors and the tables they
 * correspond
 */
private Map<Integer, RelOptTable> getSimpleFactors(RelMetadataQuery mq, LoptMultiJoin multiJoin) {
  final Map<Integer, RelOptTable> returnList = new HashMap<>();

  // Loop through all join factors and locate the ones where each
  // column referenced from the factor is not derived and originates
  // from the same underlying table.  Also, discard factors that
  // are null-generating or will be removed because of semijoins.
  if (multiJoin.getMultiJoinRel().isFullOuterJoin()) {
    return returnList;
  }
  for (int factIdx = 0; factIdx < multiJoin.getNumJoinFactors(); factIdx++) {
    if (multiJoin.isNullGenerating(factIdx)
        || (multiJoin.getJoinRemovalFactor(factIdx) != null)) {
      continue;
    }
    final RelNode rel = multiJoin.getJoinFactor(factIdx);
    final RelOptTable table = mq.getTableOrigin(rel);
    if (table != null) {
      returnList.put(factIdx, table);
    }
  }

  return returnList;
}
 

public GroupByPartitionRule() {
    super(operandJ(Aggregate.class, null, GroupByPartitionRule::test,
            operandJ(Union.class, null, r -> !r.isDistinct(),
                    operandJ(TableScan.class, null, (Predicate<TableScan>) input -> {
                        if (input != null) {
                            RelOptTable table = input.getTable();
                            if (table != null) {
                                MycatPhysicalTable table1 = table.unwrap(MycatPhysicalTable.class);
                                MycatLogicTable logicTable = table1.getLogicTable();
                                TableHandler tableHandler = logicTable.getTable();
                                if (tableHandler instanceof ShardingTable) {
                                    ShardingTable handler = (ShardingTable) tableHandler;
                                    return logicTable.getDataNodes().size() > 1;
                                }
                                return false;
                            }
                        }
                        return false;
                    }, none()))));
}
 

private static List<SchemaPath> getProjectedColumns(final RelOptTable table, boolean isSelectStar) {
  List<String> columnNames = table.getRowType().getFieldNames();
  List<SchemaPath> projectedColumns = new ArrayList<SchemaPath>(columnNames.size());

  for (String columnName : columnNames) {
     projectedColumns.add(SchemaPath.getSimplePath(columnName));
  }

  // If the row-type doesn't contain the STAR keyword, then insert it
  // as we are dealing with a  SELECT_STAR query.
  if (isSelectStar && !Utilities.isStarQuery(projectedColumns)) {
    projectedColumns.add(SchemaPath.STAR_COLUMN);
  }

  return projectedColumns;
}
 

public InfoSchemaScanPrel(
    RelOptCluster cluster,
    RelTraitSet traitSet,
    RelOptTable table,
    TableMetadata dataset,
    SearchQuery query,
    List<SchemaPath> projectedColumns,
    double observedRowcountAdjustment
    ) {

  super(cluster, traitSet, table, dataset.getStoragePluginId(), dataset, projectedColumns, observedRowcountAdjustment);
  this.pluginId = dataset.getStoragePluginId();
  this.table = Preconditions.checkNotNull(
    InfoSchemaStoragePlugin.TABLE_MAP.get(dataset.getName().getName().toLowerCase()), "Unexpected system table.");
  this.query = query;
}
 

@Override public void onMatch(RelOptRuleCall call) {
  final Delta delta = call.rel(0);
  final TableScan scan = call.rel(1);
  final RelOptCluster cluster = delta.getCluster();
  final RelOptTable relOptTable = scan.getTable();
  final StreamableTable streamableTable =
      relOptTable.unwrap(StreamableTable.class);
  if (streamableTable != null) {
    final Table table1 = streamableTable.stream();
    final RelOptTable relOptTable2 =
        RelOptTableImpl.create(relOptTable.getRelOptSchema(),
            relOptTable.getRowType(), table1,
            ImmutableList.<String>builder()
                .addAll(relOptTable.getQualifiedName())
                .add("(STREAM)").build());
    final LogicalTableScan newScan =
        LogicalTableScan.create(cluster, relOptTable2, scan.getHints());
    call.transformTo(newScan);
  }
}
 

public ScanRelBase(
    RelOptCluster cluster,
    RelTraitSet traitSet,
    RelOptTable table,
    StoragePluginId pluginId,
    TableMetadata tableMetadata,
    List<SchemaPath> projectedColumns,
    double observedRowcountAdjustment) {
  super(cluster, traitSet, table);
  this.pluginId = Preconditions.checkNotNull(pluginId);
  this.tableMetadata = Preconditions.checkNotNull(tableMetadata);
  Preconditions.checkArgument(observedRowcountAdjustment >= 0 && observedRowcountAdjustment <= 1, "observedRowcountAdjustment cannot be set to " + observedRowcountAdjustment);
  this.observedRowcountAdjustment = observedRowcountAdjustment;
  this.projectedColumns = projectedColumns != null ? ImmutableList.copyOf(projectedColumns) : getAllColumns(table);
  setProjectedRowType(projectedColumns);
}
 

private static RelOptTable getRelOptTable(
    TableNamespace tableNamespace,
    CatalogReader catalogReader,
    String datasetName,
    boolean[] usedDataset,
    List<RelDataTypeField> extendedFields) {
  final List<String> names = tableNamespace.getTable().getQualifiedName();
  RelOptTable table;
  if (datasetName != null
      && catalogReader instanceof RelOptSchemaWithSampling) {
    final RelOptSchemaWithSampling reader =
        (RelOptSchemaWithSampling) catalogReader;
    table = reader.getTableForMember(names, datasetName, usedDataset);
  } else {
    // Schema does not support substitution. Ignore the data set, if any.
    table = catalogReader.getTableForMember(names);
  }
  if (!extendedFields.isEmpty()) {
    table = table.extend(extendedFields);
  }
  return table;
}
 

/**
 * Resolve a target column name in the target table.
 *
 * @return the target field or null if the name cannot be resolved
 * @param rowType the target row type
 * @param id      the target column identifier
 * @param table   the target table or null if it is not a RelOptTable instance
 */
public static RelDataTypeField getTargetField(
    RelDataType rowType, RelDataTypeFactory typeFactory,
    SqlIdentifier id, SqlValidatorCatalogReader catalogReader,
    RelOptTable table) {
  final Table t = table == null ? null : table.unwrap(Table.class);
  if (!(t instanceof CustomColumnResolvingTable)) {
    final SqlNameMatcher nameMatcher = catalogReader.nameMatcher();
    return nameMatcher.field(rowType, id.getSimple());
  }

  final List<Pair<RelDataTypeField, List<String>>> entries =
      ((CustomColumnResolvingTable) t).resolveColumn(
          rowType, typeFactory, id.names);
  switch (entries.size()) {
  case 1:
    if (!entries.get(0).getValue().isEmpty()) {
      return null;
    }
    return entries.get(0).getKey();
  default:
    return null;
  }
}
 

@Override public ColumnStrategy generationStrategy(RelOptTable table,
    int iColumn) {
  final ModifiableViewTable viewTable =
      table.unwrap(ModifiableViewTable.class);
  assert iColumn < viewTable.columnMapping.size();

  // Use the view constraint to generate the default value if the column is
  // constrained.
  final int mappedOrdinal = viewTable.columnMapping.get(iColumn);
  final RexNode viewConstraint = projectMap.get(mappedOrdinal);
  if (viewConstraint != null) {
    return ColumnStrategy.DEFAULT;
  }

  // Otherwise use the default value of the underlying table.
  final Table schemaTable = viewTable.getTable();
  if (schemaTable instanceof Wrapper) {
    final InitializerExpressionFactory initializerExpressionFactory =
        ((Wrapper) schemaTable).unwrap(InitializerExpressionFactory.class);
    if (initializerExpressionFactory != null) {
      return initializerExpressionFactory.generationStrategy(table,
          iColumn);
    }
  }
  return super.generationStrategy(table, iColumn);
}
 

/**
 * Determines whether a join is a removable self-join. It is if it's an
 * inner join between identical, simple factors and the equality portion of
 * the join condition consists of the same set of unique keys.
 *
 * @param joinRel the join
 *
 * @return true if the join is removable
 */
public static boolean isRemovableSelfJoin(Join joinRel) {
  final RelNode left = joinRel.getLeft();
  final RelNode right = joinRel.getRight();

  if (joinRel.getJoinType().isOuterJoin()) {
    return false;
  }

  // Make sure the join is between the same simple factor
  final RelMetadataQuery mq = joinRel.getCluster().getMetadataQuery();
  final RelOptTable leftTable = mq.getTableOrigin(left);
  if (leftTable == null) {
    return false;
  }
  final RelOptTable rightTable = mq.getTableOrigin(right);
  if (rightTable == null) {
    return false;
  }
  if (!leftTable.getQualifiedName().equals(rightTable.getQualifiedName())) {
    return false;
  }

  // Determine if the join keys are identical and unique
  return areSelfJoinKeysUnique(mq, left, right, joinRel.getCondition());
}
 

LatticeTable register(RelOptTable t) {
  final LatticeTable table = tableMap.get(t.getQualifiedName());
  if (table != null) {
    return table;
  }
  final LatticeTable table2 = new LatticeTable(t);
  tableMap.put(t.getQualifiedName(), table2);
  g.addVertex(table2);
  return table2;
}
 

@Override
public RelNode toRel(RelOptTable.ToRelContext context, RelOptTable relOptTable) {
	FlinkRelBuilder relBuilder = FlinkRelBuilder.of(context.getCluster(), relOptTable.getRelOptSchema());

	RelNode relNode = relBuilder.tableOperation(catalogView.getQueryOperation()).build();
	return RelOptUtil.createCastRel(relNode, rowType.apply(relBuilder.getTypeFactory()), false);
}
 

public ParquetScanPrel(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable table, StoragePluginId pluginId,
                       TableMetadata dataset, List<SchemaPath> projectedColumns, double observedRowcountAdjustment,
                       ParquetScanFilter filter) {
  super(cluster, traitSet, table, pluginId, dataset, projectedColumns, observedRowcountAdjustment);
  this.filter = filter;
  this.globalDictionaryEncodedColumns = null;
  this.cachedRelDataType = null;
}
 

public HiveScanPrel(RelOptCluster cluster, RelTraitSet traitSet, RelOptTable table, StoragePluginId pluginId,
                    TableMetadata dataset, List<SchemaPath> projectedColumns, double observedRowcountAdjustment,
                    ScanFilter filter, HiveReaderProto.ReaderType readerType) {
  super(cluster, traitSet, table, pluginId, dataset, projectedColumns, observedRowcountAdjustment);
  this.filter = filter;
  this.readerType = readerType;
}
 

private MutableTableModify(RelDataType rowType, MutableRel input,
    RelOptTable table, CatalogReader catalogReader,
    Operation operation, List<String> updateColumnList,
    List<RexNode> sourceExpressionList, boolean flattened) {
  super(MutableRelType.TABLE_MODIFY, rowType, input);
  this.table = table;
  this.catalogReader = catalogReader;
  this.operation = operation;
  this.updateColumnList = updateColumnList;
  this.sourceExpressionList = sourceExpressionList;
  this.flattened = flattened;
}
 

@Override
public RelNode toRel(final RelOptTable.ToRelContext context, final RelOptTable relOptTable) {
    // Request all fields.
    final int fieldCount = relOptTable.getRowType().getFieldCount();
    final int[] fields = new int[fieldCount];
    for (int i = 0; i < fieldCount; i++) {
        fields[i] = i;
    }

    return new FlowFileTableScan(context.getCluster(), relOptTable, this, fields);
}
 

/** Creates a LogicalTableModify. */
public static LogicalTableModify create(RelOptTable table,
    CatalogReader schema, RelNode input,
    Operation operation, List<String> updateColumnList,
    List<RexNode> sourceExpressionList, boolean flattened) {
  final RelOptCluster cluster = input.getCluster();
  final RelTraitSet traitSet = cluster.traitSetOf(Convention.NONE);
  return new LogicalTableModify(cluster, traitSet, table, schema, input,
      operation, updateColumnList, sourceExpressionList, flattened);
}
 

/** Creates a LogicalTableScan.
 *
 * @param cluster Cluster
 * @param relOptTable Table
 */
public static LogicalTableScan create(RelOptCluster cluster,
    final RelOptTable relOptTable) {
  final Table table = relOptTable.unwrap(Table.class);
  final RelTraitSet traitSet =
      cluster.traitSetOf(Convention.NONE)
          .replaceIfs(RelCollationTraitDef.INSTANCE, () -> {
            if (table != null) {
              return table.getStatistic().getCollations();
            }
            return ImmutableList.of();
          });
  return new LogicalTableScan(cluster, traitSet, relOptTable);
}
 

public RelColumnOrigin(
    RelOptTable originTable,
    int iOriginColumn,
    boolean isDerived) {
  this.originTable = originTable;
  this.iOriginColumn = iOriginColumn;
  this.isDerived = isDerived;
}
 

/**
 * Determines the origin of a {@link RelNode}, provided it maps to a single
 * table, optionally with filtering and projection.
 *
 * @param rel the RelNode
 *
 * @return the table, if the RelNode is a simple table; otherwise null
 */
public RelOptTable getTableOrigin(RelNode rel) {
  // Determine the simple origin of the first column in the
  // RelNode.  If it's simple, then that means that the underlying
  // table is also simple, even if the column itself is derived.
  if (rel.getRowType().getFieldCount() == 0) {
    return null;
  }
  final Set<RelColumnOrigin> colOrigins = getColumnOrigins(rel, 0);
  if (colOrigins == null || colOrigins.size() == 0) {
    return null;
  }
  return colOrigins.iterator().next().getOriginTable();
}
 

StdFrameworkConfig(Context context,
    SqlRexConvertletTable convertletTable,
    SqlOperatorTable operatorTable,
    ImmutableList<Program> programs,
    ImmutableList<RelTraitDef> traitDefs,
    SqlParser.Config parserConfig,
    SqlValidator.Config sqlValidatorConfig,
    SqlToRelConverter.Config sqlToRelConverterConfig,
    SchemaPlus defaultSchema,
    RelOptCostFactory costFactory,
    RelDataTypeSystem typeSystem,
    RexExecutor executor,
    boolean evolveLattice,
    SqlStatisticProvider statisticProvider,
    RelOptTable.ViewExpander viewExpander) {
  this.context = context;
  this.convertletTable = convertletTable;
  this.operatorTable = operatorTable;
  this.programs = programs;
  this.traitDefs = traitDefs;
  this.parserConfig = parserConfig;
  this.sqlValidatorConfig = sqlValidatorConfig;
  this.sqlToRelConverterConfig = sqlToRelConverterConfig;
  this.defaultSchema = defaultSchema;
  this.costFactory = costFactory;
  this.typeSystem = typeSystem;
  this.executor = executor;
  this.evolveLattice = evolveLattice;
  this.statisticProvider = statisticProvider;
  this.viewExpander = viewExpander;
}
 

/** Creates an EnumerableTableScan. */
public static EnumerableTableScan create(RelOptCluster cluster,
    RelOptTable relOptTable) {
  final Table table = relOptTable.unwrap(Table.class);
  Class elementType = EnumerableTableScan.deduceElementType(table);
  final RelTraitSet traitSet =
      cluster.traitSetOf(EnumerableConvention.INSTANCE)
          .replaceIfs(RelCollationTraitDef.INSTANCE, () -> {
            if (table != null) {
              return table.getStatistic().getCollations();
            }
            return ImmutableList.of();
          });
  return new EnumerableTableScan(cluster, traitSet, relOptTable, elementType);
}
 

public static boolean test(TableScan scan) {
  // We can only push filters into a FilterableTable or
  // ProjectableFilterableTable.
  final RelOptTable table = scan.getTable();
  return table.unwrap(FilterableTable.class) != null
      || table.unwrap(ProjectableFilterableTable.class) != null;
}
 

/** Converts the ordinal of a field into the ordinal of a stored field.
 * That is, it subtracts the number of virtual fields that come before it. */
public static int realOrdinal(final RelOptTable table, int i) {
  List<ColumnStrategy> strategies = table.getColumnStrategies();
  int n = 0;
  for (int j = 0; j < i; j++) {
    switch (strategies.get(j)) {
    case VIRTUAL:
      ++n;
    }
  }
  return i - n;
}
 

@Override public RexNode newColumnDefaultValue(
    RelOptTable table, int iColumn, InitializerContext context) {
  if (iColumn == 4) {
    final SqlNode node = context.parseExpression(SqlParser.Config.DEFAULT, "A + 1");
    // Actually we should validate the node with physical schema,
    // here full table schema(includes the virtual columns) also works
    // because the expression "A + 1" does not reference any virtual column.
    final SqlNode validated = context.validateExpression(table.getRowType(), node);
    return context.convertExpression(validated);
  } else {
    return super.newColumnDefaultValue(table, iColumn, context);
  }
}
 

/** Creates an EnumerableTableSpool. */
public static EnumerableTableSpool create(RelNode input, Type readType,
    Type writeType, RelOptTable table) {
  RelOptCluster cluster = input.getCluster();
  RelMetadataQuery mq = cluster.getMetadataQuery();
  RelTraitSet traitSet = cluster.traitSetOf(EnumerableConvention.INSTANCE)
      .replaceIfs(RelCollationTraitDef.INSTANCE,
          () -> mq.collations(input))
      .replaceIf(RelDistributionTraitDef.INSTANCE,
          () -> mq.distribution(input));
  return new EnumerableTableSpool(cluster, traitSet, input, readType, writeType, table);
}
 

public boolean isGeneratedAlways(RelOptTable table, int iColumn) {
  switch (generationStrategy(table, iColumn)) {
  case VIRTUAL:
  case STORED:
    return true;
  default:
    return false;
  }
}