Java RelOptTableImpl类代码示例

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
/** Creates a relational expression to modify a table or modifiable view. */
private RelNode createModify(RelOptTable targetTable, RelNode source) {
	final ModifiableTable modifiableTable =
		targetTable.unwrap(ModifiableTable.class);
	if (modifiableTable != null) {
		return modifiableTable.toModificationRel(cluster, targetTable,
			catalogReader, source, LogicalTableModify.Operation.INSERT, null,
			null, false);
	}
	final ModifiableView modifiableView =
		targetTable.unwrap(ModifiableView.class);
	if (modifiableView != null) {
		final Table delegateTable = modifiableView.getTable();
		final RelDataType delegateRowType = delegateTable.getRowType(typeFactory);
		final RelOptTable delegateRelOptTable =
			RelOptTableImpl.create(null, delegateRowType, delegateTable,
				modifiableView.getTablePath());
		final RelNode newSource =
			createSource(targetTable, source, modifiableView, delegateRowType);
		return createModify(delegateRelOptTable, newSource);
	}
	return LogicalTableModify.create(targetTable, catalogReader, source,
		LogicalTableModify.Operation.INSERT, null, null, false);
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
private TableScan createNewTableScanFromSelection(EnumerableTableScan oldScan, List<String> newFiles, String cacheFileRoot,
    boolean wasAllPartitionsPruned, MetadataContext metaContext) {
  final RelOptTableImpl t = (RelOptTableImpl) oldScan.getTable();
  final FormatSelection formatSelection = (FormatSelection) table.getSelection();
  final FileSelection newFileSelection = new FileSelection(null, newFiles, getBaseTableLocation(),
          cacheFileRoot, wasAllPartitionsPruned, formatSelection.getSelection().getDirStatus());
  newFileSelection.setMetaContext(metaContext);
  final FormatSelection newFormatSelection = new FormatSelection(formatSelection.getFormat(), newFileSelection);
  final DrillTranslatableTable newTable = new DrillTranslatableTable(
          new DynamicDrillTable(table.getPlugin(), table.getStorageEngineName(),
          table.getUserName(),
          newFormatSelection));
  final RelOptTableImpl newOptTableImpl = RelOptTableImpl.create(t.getRelOptSchema(), t.getRowType(), newTable);

  // return an EnumerableTableScan with fileSelection being part of digest of TableScan node.
  return DirPrunedEnumerableTableScan.create(oldScan.getCluster(), newOptTableImpl, newFileSelection.toString());
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
private void populateMaterializationsAndLattice(
    QuarkMaterializeCluster.RelOptPlannerHolder plannerHolder,
    CalciteSchema rootSchema) {
  if (materializations == null) {
    materializations =
        MaterializationService.instance().query(rootSchema);
  }
  Materializer materializer = new Materializer(materializations);

  materializer.populateMaterializations(context.getPrepareContext(), plannerHolder);

  List<CalciteSchema.LatticeEntry> lattices = Schemas.getLatticeEntries(rootSchema);

  for (CalciteSchema.LatticeEntry lattice : lattices) {
    final CalciteSchema.TableEntry starTable = lattice.getStarTable();
    final JavaTypeFactory typeFactory = context.getTypeFactory();
    final RelOptTableImpl starRelOptTable =
        RelOptTableImpl.create(catalogReader,
            starTable.getTable().getRowType(typeFactory), starTable, null);
    plannerHolder.getPlanner().addLattice(
        new RelOptLattice(lattice.getLattice(), starRelOptTable));
  }
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
/** Creates a relational expression to modify a table or modifiable view. */
private RelNode createModify(RelOptTable targetTable, RelNode source) {
  final ModifiableTable modifiableTable =
      targetTable.unwrap(ModifiableTable.class);
  if (modifiableTable != null) {
    return modifiableTable.toModificationRel(cluster, targetTable,
        catalogReader, source, LogicalTableModify.Operation.INSERT, null,
        null, false);
  }
  final ModifiableView modifiableView =
      targetTable.unwrap(ModifiableView.class);
  if (modifiableView != null) {
    final Table delegateTable = modifiableView.getTable();
    final RelDataType delegateRowType = delegateTable.getRowType(typeFactory);
    final RelOptTable delegateRelOptTable =
        RelOptTableImpl.create(null, delegateRowType, delegateTable,
            modifiableView.getTablePath());
    final RelNode newSource =
        createSource(targetTable, source, modifiableView, delegateRowType);
    return createModify(delegateRelOptTable, newSource);
  }
  return LogicalTableModify.create(targetTable, catalogReader, source,
      LogicalTableModify.Operation.INSERT, null, null, false);
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
@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);
  }
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
/** Creates a relational expression to modify a table or modifiable view. */
private RelNode createModify(RelOptTable targetTable, RelNode source) {
  final ModifiableTable modifiableTable =
      targetTable.unwrap(ModifiableTable.class);
  if (modifiableTable != null
      && modifiableTable == targetTable.unwrap(Table.class)) {
    return modifiableTable.toModificationRel(cluster, targetTable,
        catalogReader, source, LogicalTableModify.Operation.INSERT, null,
        null, false);
  }
  final ModifiableView modifiableView =
      targetTable.unwrap(ModifiableView.class);
  if (modifiableView != null) {
    final Table delegateTable = modifiableView.getTable();
    final RelDataType delegateRowType = delegateTable.getRowType(typeFactory);
    final RelOptTable delegateRelOptTable =
        RelOptTableImpl.create(null, delegateRowType, delegateTable,
            modifiableView.getTablePath());
    final RelNode newSource =
        createSource(targetTable, source, modifiableView, delegateRowType);
    return createModify(delegateRelOptTable, newSource);
  }
  return LogicalTableModify.create(targetTable, catalogReader, source,
      LogicalTableModify.Operation.INSERT, null, null, false);
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
public RelOptTable copyOf(RelOptTable table) {
  if (table instanceof RelOptTableWrapper) {
    final RelOptTableWrapper wrapper = (RelOptTableWrapper) table;
    return new RelOptTableWrapper(
      wrapper.getQualifiedName(),
      copyOf(wrapper.getRelOptTable())
    );
  } else if (table instanceof RelOptTableImpl) {
    final RelOptTableImpl impl = (RelOptTableImpl) table;
    return impl.copy(copyOf(impl.getRowType())); // this won't copy the RelOptSchema
  }
  notSupported(table);
  return table;
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
@Override
public RelOptNamespaceTable read(final Kryo kryo, final Input input, final Class<RelOptNamespaceTable> type) {
  final List<String> path = kryo.readObject(input, ArrayList.class);
  final RelOptTableImpl relOptTable = catalog.getTable(path);
  if(relOptTable == null){
    throw new IllegalStateException("Unable to retrieve table: " + new NamespaceKey(path));
  }
  NamespaceTable namespace = relOptTable.unwrap(NamespaceTable.class);
  return new RelOptNamespaceTable(namespace, cluster);
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
@Override
public TableMetadata read(final Kryo kryo, final Input input, final Class<TableMetadata> type) {
  final List<String> path = kryo.readObject(input, ArrayList.class);
  final RelOptTableImpl relOptTable = catalog.getTable(path);
  NamespaceTable namespace = relOptTable.unwrap(NamespaceTable.class);
  return namespace.getDataset();
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
/**
 * If schema is not indicated (only one element in the list) or schema is default temporary workspace,
 * we need to check among session temporary tables in default temporary workspace first.
 * If temporary table is found and temporary tables usage is allowed, its table instance will be returned,
 * otherwise search will be conducted in original workspace.
 *
 * @param names list of schema and table names, table name is always the last element
 * @return table instance, null otherwise
 * @throws UserException if temporary tables usage is disallowed
 */
@Override
public RelOptTableImpl getTable(final List<String> names) {
  RelOptTableImpl temporaryTable = null;

  if (mightBeTemporaryTable(names, session.getDefaultSchemaPath(), drillConfig)) {
    String temporaryTableName = session.resolveTemporaryTableName(names.get(names.size() - 1));
    if (temporaryTableName != null) {
      List<String> temporaryNames = Lists.newArrayList(temporarySchema, temporaryTableName);
      temporaryTable = super.getTable(temporaryNames);
    }
  }
  if (temporaryTable != null) {
    if (allowTemporaryTables) {
      return temporaryTable;
    }
    throw UserException
        .validationError()
        .message("Temporary tables usage is disallowed. Used temporary table name: %s.", names)
        .build(logger);
  }

  RelOptTableImpl table = super.getTable(names);

  // Check the schema and throw a valid SchemaNotFound exception instead of TableNotFound exception.
  if (table == null) {
    isValidSchema(names);
  }

  return table;
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
public QuarkViewTable(QuarkSchema schema,
                      String name,
                      RelOptTableImpl relOptTable,
                      QuarkTable backupTable,
                      CalciteSchema tableSchema) {
  super(schema, name, backupTable.getColumns());
  this.backUpRelOptTable = relOptTable;
  this.backupTable = backupTable;
  this.backupTableSchema = tableSchema;
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
public QuarkTileTable(QuarkTile quarkTile, CalciteCatalogReader calciteCatalogReader,
                      RelDataType relDataType, Path path, QuarkTable backingTable) {
  this.quarkTile = quarkTile;
  this.backingTable = backingTable;
  this.relOptTable = RelOptTableImpl.create(
      calciteCatalogReader,
      relDataType,
      this,
      path);
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
public RelNode toRel(final RelOptTable table) {
  final RelNode scan = table.toRel(createToRelContext());

  final InitializerExpressionFactory ief =
      Util.first(table.unwrap(InitializerExpressionFactory.class),
          NullInitializerExpressionFactory.INSTANCE);

  // Lazily create a blackboard that contains all non-generated columns.
  final Supplier<Blackboard> bb = new Supplier<Blackboard>() {
    public Blackboard get() {
      RexNode sourceRef = rexBuilder.makeRangeReference(scan);
      return createInsertBlackboard(table, sourceRef,
          table.getRowType().getFieldNames());
    }
  };

  int virtualCount = 0;
  final List<RexNode> list = new ArrayList<>();
  for (RelDataTypeField f : table.getRowType().getFieldList()) {
    final ColumnStrategy strategy =
        ief.generationStrategy(table, f.getIndex());
    switch (strategy) {
    case VIRTUAL:
      list.add(ief.newColumnDefaultValue(table, f.getIndex(), bb.get()));
      ++virtualCount;
      break;
    default:
      list.add(
          rexBuilder.makeInputRef(scan,
              RelOptTableImpl.realOrdinal(table, f.getIndex())));
    }
  }
  if (virtualCount > 0) {
    relBuilder.push(scan);
    relBuilder.project(list);
    return relBuilder.build();
  }
  return scan;
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
static JdbcTable getJdbcTable(RelNode originalRel) {
	return (JdbcTable) get(RelOptTableImpl.class, originalRel.getTable(), "table");
}
 

import org.apache.calcite.prepare.RelOptTableImpl; //导入依赖的package包/类
@Override
public void write(final Kryo kryo, final Output output, final RelOptTableImpl relOptTable) {
  final List<String> path = relOptTable.getQualifiedName();
  kryo.writeObject(output, path);
}