import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
Enumerable<MetaSchema> schemas(String catalog) {
    return Linq4j.asEnumerable(
            getConnection().getCalciteRootSchema().getSubSchemaMap().values())
            .select(
                    new Function1<CalciteSchema, MetaSchema>() {
                        public MetaSchema apply(CalciteSchema calciteSchema) {
                            return new CalciteMetaSchema(
                                    calciteSchema,
                                    connection.getCatalog(),
                                    calciteSchema.getName());
                        }
                    })
            .orderBy(
                    new Function1<MetaSchema, Comparable>() {
                        public Comparable apply(MetaSchema metaSchema) {
                            return (Comparable) FlatLists.of(
                                    Util.first(metaSchema.tableCatalog, ""),
                                    metaSchema.tableSchem);
                        }
                    });
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/**
 * Creates an internal connection.
 */
CalciteConnection connect(CalciteSchema rootSchema,
                          JavaTypeFactory typeFactory) {
    /*
    return (CalciteConnection) ((CalciteFactory) factory)
            .newConnection(this, factory, CONNECT_STRING_PREFIX, new Properties(),
                    rootSchema, typeFactory);
                    */

    System.out.println("********************************************************************");
    System.out.println("********************************************************************");
    System.out.println("********************************************************************");
    System.out.println("********************************************************************");
    System.out.println("********************************************************************");
    return (CalciteConnection) ((CalciteFactory) factory)
            .newConnection(this, factory, CONNECT_STRING_PREFIX, new Properties(),
                    (CalciteSchema) SchemaManager.getSingletonInstance(null).getCurrentSchema(),
                    typeFactory);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/**
 * Creates a CalciteConnectionImpl.
 * <p/>
 * <p>Not public; method is called only from the driver.</p>
 *
 * @param driver      Driver
 * @param factory     Factory for JDBC objects
 * @param url         Server URL
 * @param info        Other connection properties
 * @param rootSchema  Root schema, or null
 * @param typeFactory Type factory, or null
 */
protected CalciteConnectionImpl(Driver driver, AvaticaFactory factory,
                                String url, Properties info, CalciteSchema rootSchema,
                                JavaTypeFactory typeFactory) {
    super(driver, factory, url, info);
    CalciteConnectionConfig cfg = new CalciteConnectionConfigImpl(info);
    this.prepareFactory = driver.getPrepareFactory();
    if (typeFactory != null) {
        this.typeFactory = typeFactory;
    } else {
        final RelDataTypeSystem typeSystem =
                cfg.typeSystem(RelDataTypeSystem.class, RelDataTypeSystem.DEFAULT);
        this.typeFactory = new JavaTypeFactoryImpl(typeSystem);
    }
    this.rootSchema =
            Preconditions.checkNotNull(rootSchema != null
                    ? rootSchema
                    : CalciteSchema.createRootSchema(true));
    Preconditions.checkArgument(this.rootSchema.isRoot(), "must be root schema");
    this.properties.put(InternalProperty.CASE_SENSITIVE, cfg.caseSensitive());
    this.properties.put(InternalProperty.UNQUOTED_CASING, cfg.unquotedCasing());
    this.properties.put(InternalProperty.QUOTED_CASING, cfg.quotedCasing());
    this.properties.put(InternalProperty.QUOTING, cfg.quoting());
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的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.jdbc.CalciteSchema; //导入依赖的package包/类
protected void populateMaterializations(Context context,
                                        RelOptPlanner planner, Prepare.Materialization materialization) {
  // REVIEW: initialize queryRel and tableRel inside MaterializationService,
  // not here?
  try {
    final CalciteSchema schema = materialization.materializedTable.schema;
    CalciteCatalogReader catalogReader =
        new CalciteCatalogReader(
            schema.root(),
            context.config().caseSensitive(),
            materialization.viewSchemaPath,
            context.getTypeFactory());
    final CalciteMaterializer materializer =
        new CalciteMaterializer(this, context, catalogReader, schema, planner,
            createConvertletTable());
    materializer.populate(materialization);
  } catch (Exception e) {
    throw new RuntimeException("While populating materialization "
        + materialization.materializedTable.path(), e);
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/** Executes a prepare action. */
public <R> R perform(CalciteServerStatement statement,
    Frameworks.PrepareAction<R> action) {
  final CalcitePrepare.Context prepareContext =
      statement.createPrepareContext();
  final JavaTypeFactory typeFactory = prepareContext.getTypeFactory();
  final CalciteSchema schema =
      action.getConfig().getDefaultSchema() != null
          ? CalciteSchema.from(action.getConfig().getDefaultSchema())
          : prepareContext.getRootSchema();
  CalciteCatalogReader catalogReader =
      new CalciteCatalogReader(schema.root(),
          prepareContext.config().caseSensitive(),
          schema.path(null),
          typeFactory);
  final RexBuilder rexBuilder = new RexBuilder(typeFactory);
  final RelOptPlanner planner =
      createPlanner(prepareContext,
          action.getConfig().getContext(),
          action.getConfig().getCostFactory());
  final RelOptCluster cluster = createCluster(planner, rexBuilder);
  return action.apply(cluster, catalogReader,
      prepareContext.getRootSchema().plus(), statement);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
public CalcitePreparingStmt(CalcitePrepareImpl prepare,
    Context context,
    CatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    CalciteSchema schema,
    EnumerableRel.Prefer prefer,
    RelOptPlanner planner,
    Convention resultConvention,
    SqlRexConvertletTable convertletTable) {
  super(context, catalogReader, resultConvention);
  this.prepare = prepare;
  this.schema = schema;
  this.prefer = prefer;
  this.planner = planner;
  this.typeFactory = typeFactory;
  this.convertletTable = convertletTable;
  this.rexBuilder = new RexBuilder(typeFactory);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
public void execute(CalcitePrepare.Context context) {
  final Pair<CalciteSchema, String> pair =
      SqlDdlNodes.schema(context, true, name);
  final SchemaPlus schemaPlus = pair.left.plus();
  for (Function function : schemaPlus.getFunctions(pair.right)) {
    if (function.getParameters().isEmpty()) {
      if (!getReplace()) {
        throw SqlUtil.newContextException(name.getParserPosition(),
            RESOURCE.viewExists(pair.right));
      }
      pair.left.removeFunction(pair.right);
    }
  }
  final SqlNode q = SqlDdlNodes.renameColumns(columnList, query);
  final String sql = q.toSqlString(CalciteSqlDialect.DEFAULT).getSql();
  final ViewTableMacro viewTableMacro =
      ViewTable.viewMacro(schemaPlus, sql, pair.left.path(null),
          context.getObjectPath(), false);
  final TranslatableTable x = viewTableMacro.apply(ImmutableList.of());
  Util.discard(x);
  schemaPlus.add(pair.right, viewTableMacro);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
@Override public void execute(CalcitePrepare.Context context) {
  final Pair<CalciteSchema, String> pair =
      SqlDdlNodes.schema(context, true, name);
  final Table table = pair.left.plus().getTable(pair.right);
  if (table != null) {
    // Materialized view exists.
    super.execute(context);
    if (table instanceof Wrapper) {
      final MaterializationKey materializationKey =
          ((Wrapper) table).unwrap(MaterializationKey.class);
      if (materializationKey != null) {
        MaterializationService.instance()
            .removeMaterialization(materializationKey);
      }
    }
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
public void visit(JsonLattice jsonLattice) {
  try {
    checkRequiredAttributes(jsonLattice, "name", "sql");
    final SchemaPlus schema = currentSchema();
    if (!schema.isMutable()) {
      throw new RuntimeException("Cannot define lattice; parent schema '"
          + currentSchemaName()
          + "' is not a SemiMutableSchema");
    }
    CalciteSchema calciteSchema = CalciteSchema.from(schema);
    Lattice.Builder latticeBuilder =
        Lattice.builder(calciteSchema, jsonLattice.getSql())
            .auto(jsonLattice.auto)
            .algorithm(jsonLattice.algorithm);
    if (jsonLattice.rowCountEstimate != null) {
      latticeBuilder.rowCountEstimate(jsonLattice.rowCountEstimate);
    }
    if (jsonLattice.statisticProvider != null) {
      latticeBuilder.statisticProvider(jsonLattice.statisticProvider);
    }
    populateLattice(jsonLattice, latticeBuilder);
    schema.add(jsonLattice.name, latticeBuilder.build());
  } catch (Exception e) {
    throw new RuntimeException("Error instantiating " + jsonLattice, e);
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/** Converts a relational expression to use a
 * {@link org.apache.calcite.schema.impl.StarTable} defined in {@code schema}.
 * Uses the first star table that fits. */
private Iterable<Callback> useStar(CalciteSchema schema, RelNode queryRel) {
  List<CalciteSchema.TableEntry> starTables =
      Schemas.getStarTables(schema.root());
  if (starTables.isEmpty()) {
    // Don't waste effort converting to leaf-join form.
    return ImmutableList.of();
  }
  final List<Callback> list = Lists.newArrayList();
  final RelNode rel2 =
      RelOptMaterialization.toLeafJoinForm(queryRel);
  for (CalciteSchema.TableEntry starTable : starTables) {
    final Table table = starTable.getTable();
    assert table instanceof StarTable;
    RelOptTableImpl starRelOptTable =
        RelOptTableImpl.create(catalogReader, table.getRowType(typeFactory),
            starTable, null);
    final RelNode rel3 =
        RelOptMaterialization.tryUseStar(rel2, starRelOptTable);
    if (rel3 != null) {
      list.add(new Callback(rel3, starTable, starRelOptTable));
    }
  }
  return list;
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
protected void populateMaterializations(Context context,
    RelOptPlanner planner, Prepare.Materialization materialization) {
  // REVIEW: initialize queryRel and tableRel inside MaterializationService,
  // not here?
  try {
    final CalciteSchema schema = materialization.materializedTable.schema;
    CalciteCatalogReader catalogReader =
        new CalciteCatalogReader(
            schema.root(),
            materialization.viewSchemaPath,
            context.getTypeFactory(),
            context.config());
    final CalciteMaterializer materializer =
        new CalciteMaterializer(this, context, catalogReader, schema, planner,
            createConvertletTable());
    materializer.populate(materialization);
  } catch (Exception e) {
    throw new RuntimeException("While populating materialization "
        + materialization.materializedTable.path(), e);
  }
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/** Executes a prepare action. */
public <R> R perform(CalciteServerStatement statement,
    Frameworks.PrepareAction<R> action) {
  final CalcitePrepare.Context prepareContext =
      statement.createPrepareContext();
  final JavaTypeFactory typeFactory = prepareContext.getTypeFactory();
  final CalciteSchema schema =
      action.getConfig().getDefaultSchema() != null
          ? CalciteSchema.from(action.getConfig().getDefaultSchema())
          : prepareContext.getRootSchema();
  CalciteCatalogReader catalogReader =
      new CalciteCatalogReader(schema.root(),
          schema.path(null),
          typeFactory,
          prepareContext.config());
  final RexBuilder rexBuilder = new RexBuilder(typeFactory);
  final RelOptPlanner planner =
      createPlanner(prepareContext,
          action.getConfig().getContext(),
          action.getConfig().getCostFactory());
  final RelOptCluster cluster = createCluster(planner, rexBuilder);
  return action.apply(cluster, catalogReader,
      prepareContext.getRootSchema().plus(), statement);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
CalcitePreparingStmt(CalcitePrepareImpl prepare,
    Context context,
    CatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    CalciteSchema schema,
    EnumerableRel.Prefer prefer,
    RelOptPlanner planner,
    Convention resultConvention,
    SqlRexConvertletTable convertletTable) {
  super(context, catalogReader, resultConvention);
  this.prepare = prepare;
  this.schema = schema;
  this.prefer = prefer;
  this.planner = planner;
  this.typeFactory = typeFactory;
  this.convertletTable = convertletTable;
  this.rexBuilder = new RexBuilder(typeFactory);
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
RelNode toRel(Queryable<T> queryable) {
  if (queryable instanceof QueryableDefaults.Replayable) {
    //noinspection unchecked
    ((QueryableDefaults.Replayable) queryable).replay(this);
    return rel;
  }
  if (queryable instanceof AbstractTableQueryable) {
    final AbstractTableQueryable tableQueryable =
        (AbstractTableQueryable) queryable;
    final QueryableTable table = tableQueryable.table;
    final CalciteSchema.TableEntry tableEntry =
        CalciteSchema.from(tableQueryable.schema)
            .add(tableQueryable.tableName, tableQueryable.table);
    final RelOptTableImpl relOptTable =
        RelOptTableImpl.create(null, table.getRowType(translator.typeFactory),
            tableEntry, null);
    if (table instanceof TranslatableTable) {
      return ((TranslatableTable) table).toRel(translator, relOptTable);
    } else {
      return LogicalTableScan.create(translator.cluster, relOptTable);
    }
  }
  return translator.translate(queryable.getExpression());
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的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.jdbc.CalciteSchema; //导入依赖的package包/类
public Prepare.PreparingTable getTable(final List<String> names) {
  // First look in the default schema, if any.
  // If not found, look in the root schema.
  CalciteSchema.TableEntry entry = SqlValidatorUtil.getTableEntry(this, names);
  if (entry != null) {
    final Table table = entry.getTable();
    if (table instanceof Wrapper) {
      final Prepare.PreparingTable relOptTable =
          ((Wrapper) table).unwrap(Prepare.PreparingTable.class);
      if (relOptTable != null) {
        return relOptTable;
      }
    }
    return RelOptTableImpl.create(this,
        table.getRowType(typeFactory), entry, null);
  }
  return null;
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/** Creates an operator table that contains functions in the given class.
 *
 * @see ModelHandler#addFunctions */
public static SqlOperatorTable operatorTable(String className) {
  // Dummy schema to collect the functions
  final CalciteSchema schema =
      CalciteSchema.createRootSchema(false, false);
  ModelHandler.addFunctions(schema.plus(), null, ImmutableList.<String>of(),
      className, "*", true);

  // The following is technical debt; see [CALCITE-2082] Remove
  // RelDataTypeFactory argument from SqlUserDefinedAggFunction constructor
  final SqlTypeFactoryImpl typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);

  final ListSqlOperatorTable table = new ListSqlOperatorTable();
  for (String name : schema.getFunctionNames()) {
    for (Function function : schema.getFunctions(name, true)) {
      final SqlIdentifier id = new SqlIdentifier(name, SqlParserPos.ZERO);
      table.add(
          toOp(typeFactory, id, function));
    }
  }
  return table;
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
private Table findTable(CalciteSchema schema, String tableName, boolean caseSensitive) {
  CalciteSchema.TableEntry entry = schema.getTable(tableName, caseSensitive);
  if (entry != null) {
    return entry.getTable();
  }

  // Check sub schemas
  for (CalciteSchema subSchema : schema.getSubSchemaMap().values()) {
    Table table = findTable(subSchema, tableName, caseSensitive);
    if (table != null) {
      return table;
    }
  }

  return null;
}
 

import org.apache.calcite.jdbc.CalciteSchema; //导入依赖的package包/类
/**
 * Finds a {@link org.apache.calcite.jdbc.CalciteSchema.TableEntry} in a
 * given catalog reader whose table has the given name, possibly qualified.
 *
 * <p>Uses the case-sensitivity policy of the specified catalog reader.
 *
 * <p>If not found, returns null.
 *
 * @param catalogReader accessor to the table metadata
 * @param names Name of table, may be qualified or fully-qualified
 *
 * @return TableEntry with a table with the given name, or null
 */
public static CalciteSchema.TableEntry getTableEntry(
    SqlValidatorCatalogReader catalogReader, List<String> names) {
  // First look in the default schema, if any.
  // If not found, look in the root schema.
  for (List<String> schemaPath : catalogReader.getSchemaPaths()) {
    CalciteSchema schema =
        getSchema(catalogReader.getRootSchema(),
            Iterables.concat(schemaPath, Util.skipLast(names)),
            catalogReader.nameMatcher());
    if (schema == null) {
      continue;
    }
    CalciteSchema.TableEntry entry =
        getTableEntryFrom(schema, Util.last(names),
            catalogReader.nameMatcher().isCaseSensitive());
    if (entry != null) {
      return entry;
    }
  }
  return null;
}