import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public static JournalledJdbcSchema create(
		SchemaPlus parentSchema,
		String name,
		Map<String, Object> operand
) {
	DataSource dataSource;
	try {
		dataSource = parseDataSource(operand);
	} catch (Exception e) {
		throw new IllegalArgumentException("Error while reading dataSource", e);
	}
	String catalog = (String) operand.get("jdbcCatalog");
	String schema = (String) operand.get("jdbcSchema");
	Expression expression = null;
	if (parentSchema != null) {
		expression = Schemas.subSchemaExpression(parentSchema, name, JdbcSchema.class);
	}
	final SqlDialect dialect = createDialect(dataSource);
	final JdbcConvention convention = JdbcConvention.of(dialect, expression, name);
	return new JournalledJdbcSchema(dataSource, dialect, convention, catalog, schema, operand);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public OctopusJdbcDataSource(SchemaPlus parentSchema, MetaDataSource metaDataSource) {
    super(metaDataSource);

    LOG.debug("create OctopusJdbcDataSource. dataSourceName: " + metaDataSource.getName());
    dataSource = dataSource(metaDataSource.getConnectionString(), metaDataSource.getDriverName());

    /* TODO: what is this? */
    final Expression expression =
            Schemas.subSchemaExpression(parentSchema, getName(), OctopusJdbcSchema.class);

    this.dialect = createDialect(dataSource);
    this.convention = JdbcConvention.of(dialect, expression, metaDataSource.getName());

    ImmutableMap.Builder<String, Schema> builder = ImmutableMap.builder();
    for (MetaSchema metaSchema : metaDataSource.getSchemas())
        builder.put(metaSchema.getName(), new OctopusJdbcSchema(metaSchema, this));
    setSubSchemaMap(builder.build());
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的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.schema.Schemas; //导入依赖的package包/类
public <T> T unwrap(Class<T> clazz) {
  if (clazz.isInstance(this)) {
    return clazz.cast(this);
  }
  if (clazz.isInstance(table)) {
    return clazz.cast(table);
  }
  if (table instanceof Wrapper) {
    final T t = ((Wrapper) table).unwrap(clazz);
    if (t != null) {
      return t;
    }
  }
  if (clazz == CalciteSchema.class) {
    return clazz.cast(
        Schemas.subSchema(((CalciteCatalogReader) schema).rootSchema,
            Util.skipLast(getQualifiedName())));
  }
  return null;
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public TranslatableTable apply(List<Object> arguments) {
  final CalciteConnection connection =
      MaterializedViewTable.MATERIALIZATION_CONNECTION;
  CalcitePrepare.AnalyzeViewResult parsed =
      Schemas.analyzeView(connection, schema, schemaPath, viewSql, viewPath,
          modifiable != null && modifiable);
  final List<String> schemaPath1 =
      schemaPath != null ? schemaPath : schema.path(null);
  if ((modifiable == null || modifiable)
      && parsed.modifiable
      && parsed.table != null) {
    return modifiableViewTable(parsed, viewSql, schemaPath1, viewPath, schema);
  } else {
    return viewTable(parsed, viewSql, schemaPath1, viewPath);
  }
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
@Test public void testTableWhere() throws SQLException,
    ClassNotFoundException {
  final Connection connection =
      CalciteAssert.that(CalciteAssert.Config.JDBC_FOODMART).connect();
  final CalciteConnection calciteConnection =
      connection.unwrap(CalciteConnection.class);
  final SchemaPlus rootSchema = calciteConnection.getRootSchema();
  ParameterExpression c =
      Expressions.parameter(JdbcTest.Customer.class, "c");
  String s =
      Schemas.queryable(Schemas.createDataContext(connection, rootSchema),
          rootSchema.getSubSchema("foodmart"),
          JdbcTest.Customer.class, "customer")
          .where(
              Expressions.<Predicate1<JdbcTest.Customer>>lambda(
                  Expressions.lessThan(
                      Expressions.field(c, "customer_id"),
                      Expressions.constant(5)),
                  c))
          .toList()
          .toString();
  Util.discard(s);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
/**
 * Called after the constructor has completed and the model has been
 * loaded.
 */
void init() {
    final MaterializationService service = MaterializationService.instance();
    for (CalciteSchema.LatticeEntry e : Schemas.getLatticeEntries(rootSchema)) {
        final Lattice lattice = e.getLattice();
        for (Lattice.Tile tile : lattice.computeTiles()) {
            service.defineTile(lattice, tile.bitSet(), tile.measures, e.schema,
                    true, true);
        }
    }
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
/** Called after the constructor has completed and the model has been
 * loaded. */
void init() {
  final MaterializationService service = MaterializationService.instance();
  for (CalciteSchema.LatticeEntry e : Schemas.getLatticeEntries(rootSchema)) {
    final Lattice lattice = e.getLattice();
    for (Lattice.Tile tile : lattice.computeTiles()) {
      service.defineTile(lattice, tile.bitSet(), tile.measures, e.schema,
          true, true);
    }
  }
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
/** Returns an expression for the object wrapped by this schema (not the
 * schema itself). */
Expression getTargetExpression(SchemaPlus parentSchema, String name) {
  return Types.castIfNecessary(
      target.getClass(),
      Expressions.call(
          Schemas.unwrap(
              getExpression(parentSchema, name),
              ReflectiveSchema.class),
          BuiltInMethod.REFLECTIVE_SCHEMA_GET_TARGET.method));
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public static JdbcSchema create(
    SchemaPlus parentSchema,
    String name,
    DataSource dataSource,
    SqlDialectFactory dialectFactory,
    String catalog,
    String schema) {
  final Expression expression =
      Schemas.subSchemaExpression(parentSchema, name, JdbcSchema.class);
  final SqlDialect dialect = createDialect(dialectFactory, dataSource);
  final JdbcConvention convention =
      JdbcConvention.of(dialect, expression, name);
  return new JdbcSchema(dataSource, dialect, convention, catalog, schema);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
private Table createCloneTable(QueryProvider queryProvider,
    QueryableTable sourceTable, String name) {
  final Queryable<Object> queryable =
      sourceTable.asQueryable(queryProvider, sourceSchema, name);
  final JavaTypeFactory typeFactory =
      ((CalciteConnection) queryProvider).getTypeFactory();
  return createCloneTable(typeFactory, Schemas.proto(sourceTable),
      ImmutableList.<RelCollation>of(), null, queryable);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
/** Allows a sub-class to return an extension of {@link ModifiableViewTable}
 * by overriding this method. */
protected ModifiableViewTable modifiableViewTable(CalcitePrepare.AnalyzeViewResult parsed,
    String viewSql, List<String> schemaPath, List<String> viewPath,
    CalciteSchema schema) {
  final JavaTypeFactory typeFactory = (JavaTypeFactory) parsed.typeFactory;
  final Type elementType = typeFactory.getJavaClass(parsed.rowType);
  return new ModifiableViewTable(elementType,
      RelDataTypeImpl.proto(parsed.rowType), viewSql, schemaPath, viewPath,
      parsed.table, Schemas.path(schema.root(), parsed.tablePath),
      parsed.constraint, parsed.columnMapping);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
/** Test for {@link Path}. */
@Test public void testSchemaPath() {
  final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
  final FrameworkConfig config = Frameworks.newConfigBuilder()
      .defaultSchema(
          CalciteAssert.addSchema(rootSchema, CalciteAssert.SchemaSpec.HR))
      .build();
  final Path path = Schemas.path(config.getDefaultSchema());
  assertThat(path.size(), is(2));
  assertThat(path.get(0).left, is(""));
  assertThat(path.get(1).left, is("hr"));
  assertThat(path.names().size(), is(1));
  assertThat(path.names().get(0), is("hr"));
  assertThat(path.schemas().size(), is(2));

  final Path parent = path.parent();
  assertThat(parent.size(), is(1));
  assertThat(parent.names().size(), is(0));

  final Path grandparent = parent.parent();
  assertThat(grandparent.size(), is(0));

  try {
    Object o = grandparent.parent();
    fail("expected exception, got " + o);
  } catch (IllegalArgumentException e) {
    // ok
  }
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
@Override protected ModifiableViewTable modifiableViewTable(
    CalcitePrepare.AnalyzeViewResult parsed, String viewSql,
    List<String> schemaPath, List<String> viewPath, CalciteSchema schema) {
  final JavaTypeFactory typeFactory = (JavaTypeFactory) parsed.typeFactory;
  final Type elementType = typeFactory.getJavaClass(parsed.rowType);
  return new MockModifiableViewTable(elementType,
      RelDataTypeImpl.proto(parsed.rowType), viewSql, schemaPath, viewPath,
      parsed.table, Schemas.path(schema.root(), parsed.tablePath),
      parsed.constraint, parsed.columnMapping);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
@Override public Path getTablePath() {
  final ImmutableList.Builder<Pair<String, Schema>> builder =
      ImmutableList.builder();
  for (String name : fromTable.names) {
    builder.add(Pair.<String, Schema>of(name, null));
  }
  return Schemas.path(builder.build());
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
protected void check(final Action action) throws Exception {
  Frameworks.withPrepare(
      new Frameworks.PrepareAction<Void>() {
        public Void apply(RelOptCluster cluster, RelOptSchema relOptSchema,
            SchemaPlus rootSchema, CalciteServerStatement statement) {
          final RexBuilder rexBuilder = cluster.getRexBuilder();
          DataContext dataContext =
              Schemas.createDataContext(statement.getConnection(), rootSchema);
          final RexExecutorImpl executor = new RexExecutorImpl(dataContext);
          action.check(rexBuilder, executor);
          return null;
        }
      });
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public ConstExecutor(FunctionImplementationRegistry funcImplReg, FunctionContext udfUtilities, PlannerSettings plannerSettings) {
  this.funcImplReg = funcImplReg;
  this.udfUtilities = udfUtilities;
  this.plannerSettings = plannerSettings;
  this.calciteExecutor = new RexExecutorImpl(Schemas.createDataContext(null));
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public Expression getExpression(SchemaPlus schema, String tableName,
                                Class clazz) {
    return Schemas.tableExpression(schema, getElementType(), tableName, clazz);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
public Expression getExpression(SchemaPlus schema, String tableName,
                                Class clazz) {
  return Schemas.tableExpression(schema, getElementType(), tableName, clazz);
}
 

import org.apache.calcite.schema.Schemas; //导入依赖的package包/类
@Override
public Expression getExpression(SchemaPlus schema, String tableName,
                                Class clazz) {
  return Schemas.tableExpression(schema, getElementType(), tableName, clazz);
}