import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的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.sql.SqlOperatorTable; //导入依赖的package包/类
/**
 * Creates a validator.
 *
 * @param opTab         Operator table
 * @param catalogReader Catalog reader
 * @param typeFactory   Type factory
 * @param conformance   Compatibility mode
 */
protected SqlValidatorImpl(
    SqlOperatorTable opTab,
    SqlValidatorCatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    SqlConformance conformance) {
  this.opTab = Preconditions.checkNotNull(opTab);
  this.catalogReader = Preconditions.checkNotNull(catalogReader);
  this.typeFactory = Preconditions.checkNotNull(typeFactory);
  this.conformance = Preconditions.checkNotNull(conformance);

  unknownType = typeFactory.createUnknownType();
  booleanType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);

  rewriteCalls = true;
  expandColumnReferences = true;
  aggFinder = new AggFinder(opTab, false, true, false, null);
  aggOrOverFinder = new AggFinder(opTab, true, true, false, null);
  overFinder = new AggFinder(opTab, true, false, false, aggOrOverFinder);
  groupFinder = new AggFinder(opTab, false, false, true, null);
  aggOrOverOrGroupFinder = new AggFinder(opTab, true, true, true, null);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
private static void operatorTable(String s,
      Collection<SqlOperatorTable> tables) {
  switch (s) {
  case "standard":
    tables.add(SqlStdOperatorTable.instance());
    return;
  case "oracle":
    tables.add(OracleSqlOperatorTable.instance());
    return;
  case "spatial":
    tables.add(
        CalciteCatalogReader.operatorTable(GeoFunctions.class.getName()));
    return;
  default:
    throw new IllegalArgumentException("Unknown operator table: " + s);
  }
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
StdFrameworkConfig(Context context,
    SqlRexConvertletTable convertletTable,
    SqlOperatorTable operatorTable,
    ImmutableList<Program> programs,
    ImmutableList<RelTraitDef> traitDefs,
    SqlParser.Config parserConfig,
    SqlToRelConverter.Config sqlToRelConverterConfig,
    SchemaPlus defaultSchema,
    RelOptCostFactory costFactory,
    RelDataTypeSystem typeSystem,
    RexExecutor executor) {
  this.context = context;
  this.convertletTable = convertletTable;
  this.operatorTable = operatorTable;
  this.programs = programs;
  this.traitDefs = traitDefs;
  this.parserConfig = parserConfig;
  this.sqlToRelConverterConfig = sqlToRelConverterConfig;
  this.defaultSchema = defaultSchema;
  this.costFactory = costFactory;
  this.typeSystem = typeSystem;
  this.executor = executor;
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public BeamQueryPlanner(SchemaPlus schema) {
  String defaultCharsetKey = "saffron.default.charset";
  if (System.getProperty(defaultCharsetKey) == null) {
    System.setProperty(defaultCharsetKey, ConversionUtil.NATIVE_UTF16_CHARSET_NAME);
    System.setProperty("saffron.default.nationalcharset",
      ConversionUtil.NATIVE_UTF16_CHARSET_NAME);
    System.setProperty("saffron.default.collation.name",
      String.format("%s$%s", ConversionUtil.NATIVE_UTF16_CHARSET_NAME, "en_US"));
  }

  final List<RelTraitDef> traitDefs = new ArrayList<>();
  traitDefs.add(ConventionTraitDef.INSTANCE);
  traitDefs.add(RelCollationTraitDef.INSTANCE);

  List<SqlOperatorTable> sqlOperatorTables = new ArrayList<>();
  sqlOperatorTables.add(SqlStdOperatorTable.instance());
  sqlOperatorTables.add(new CalciteCatalogReader(CalciteSchema.from(schema), false,
      Collections.<String>emptyList(), TYPE_FACTORY));

  FrameworkConfig config = Frameworks.newConfigBuilder()
      .parserConfig(SqlParser.configBuilder().setLex(Lex.MYSQL).build()).defaultSchema(schema)
      .traitDefs(traitDefs).context(Contexts.EMPTY_CONTEXT).ruleSets(BeamRuleSets.getRuleSets())
      .costFactory(null).typeSystem(BeamRelDataTypeSystem.BEAM_REL_DATATYPE_SYSTEM)
      .operatorTable(new ChainedSqlOperatorTable(sqlOperatorTables))
      .build();
  this.planner = Frameworks.getPlanner(config);

  for (String t : schema.getTableNames()) {
    sourceTables.put(t, (BaseBeamTable) schema.getTable(t));
  }
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
/**
 * Method method build a calcite framework configuration for calcite to parse SQL and generate relational tree
 * out of it.
 * @return FrameworkConfig
 */
private FrameworkConfig buildFrameWorkConfig()
{
  List<SqlOperatorTable> sqlOperatorTables = new ArrayList<>();
  sqlOperatorTables.add(SqlStdOperatorTable.instance());
  sqlOperatorTables
    .add(new CalciteCatalogReader(CalciteSchema.from(schema), false, Collections.<String>emptyList(), typeFactory));
  return Frameworks.newConfigBuilder().defaultSchema(schema)
    .parserConfig(SqlParser.configBuilder().setLex(Lex.MYSQL).build())
    .operatorTable(new ChainedSqlOperatorTable(sqlOperatorTables)).build();
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
private FrameworkConfig buildFrameWorkConfig() {
  if (hasUdf) {
    List<SqlOperatorTable> sqlOperatorTables = new ArrayList<>();
    sqlOperatorTables.add(SqlStdOperatorTable.instance());
    sqlOperatorTables.add(new CalciteCatalogReader(CalciteSchema.from(schema),
                                                   false,
                                                   Collections.<String>emptyList(), typeFactory));
    return Frameworks.newConfigBuilder().defaultSchema(schema)
            .operatorTable(new ChainedSqlOperatorTable(sqlOperatorTables)).build();
  } else {
    return Frameworks.newConfigBuilder().defaultSchema(schema).build();
  }
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public static CalciteState sqlOverDummyTable(String sql)
        throws RelConversionException, ValidationException, SqlParseException {
    SchemaPlus schema = Frameworks.createRootSchema(true);
    JavaTypeFactory typeFactory = new JavaTypeFactoryImpl
            (RelDataTypeSystem.DEFAULT);
    StreamableTable streamableTable = new CompilerUtil.TableBuilderInfo(typeFactory)
            .field("ID", SqlTypeName.INTEGER)
            .field("NAME", typeFactory.createType(String.class))
            .field("ADDR", typeFactory.createType(String.class))
            .build();
    Table table = streamableTable.stream();
    schema.add("FOO", table);
    schema.add("BAR", table);
    schema.add("MYPLUS", ScalarFunctionImpl.create(MyPlus.class, "eval"));

    List<SqlOperatorTable> sqlOperatorTables = new ArrayList<>();
    sqlOperatorTables.add(SqlStdOperatorTable.instance());
    sqlOperatorTables.add(new CalciteCatalogReader(CalciteSchema.from(schema),
            false,
            Collections.<String>emptyList(), typeFactory));
    SqlOperatorTable chainedSqlOperatorTable = new ChainedSqlOperatorTable(sqlOperatorTables);
    FrameworkConfig config = Frameworks.newConfigBuilder().defaultSchema(
            schema).operatorTable(chainedSqlOperatorTable).build();
    Planner planner = Frameworks.getPlanner(config);
    SqlNode parse = planner.parse(sql);
    SqlNode validate = planner.validate(parse);
    RelNode tree = planner.convert(validate);
    System.out.println(RelOptUtil.toString(tree, SqlExplainLevel.ALL_ATTRIBUTES));
    return new CalciteState(schema, tree);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
private SqlValidator createSqlValidator(Context context,
                                        CalciteCatalogReader catalogReader) {
  final SqlOperatorTable opTab0 =
      context.config().fun(SqlOperatorTable.class,
          SqlStdOperatorTable.instance());
  final SqlOperatorTable opTab =
      ChainedSqlOperatorTable.of(opTab0, catalogReader);
  final JavaTypeFactory typeFactory = context.getTypeFactory();
  final SqlConformance conformance = context.config().conformance();
  return new CalciteSqlValidator(opTab, catalogReader, typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
private SqlValidator createSqlValidator(Context context,
    CalciteCatalogReader catalogReader) {
  final SqlOperatorTable opTab0 =
      context.config().fun(SqlOperatorTable.class,
          SqlStdOperatorTable.instance());
  final SqlOperatorTable opTab =
      ChainedSqlOperatorTable.of(opTab0, catalogReader);
  final JavaTypeFactory typeFactory = context.getTypeFactory();
  final SqlConformance conformance = context.config().conformance();
  return new CalciteSqlValidator(opTab, catalogReader, typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
/**
 * Factory method for {@link SqlValidator}.
 */
public static SqlValidatorWithHints newValidator(
    SqlOperatorTable opTab,
    SqlValidatorCatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    SqlConformance conformance) {
  return new SqlValidatorImpl(opTab, catalogReader, typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public void lookupOperatorOverloads(SqlIdentifier opName,
    SqlFunctionCategory category, SqlSyntax syntax,
    List<SqlOperator> operatorList) {
  for (SqlOperatorTable table : tableList) {
    table.lookupOperatorOverloads(opName, category, syntax, operatorList);
  }
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public List<SqlOperator> getOperatorList() {
  List<SqlOperator> list = new ArrayList<>();
  for (SqlOperatorTable table : tableList) {
    list.addAll(table.getOperatorList());
  }
  return list;
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public Xyz load(@Nonnull SqlTestFactory factory)
    throws Exception {
  final SqlOperatorTable operatorTable =
      factory.createOperatorTable(factory);
  final JavaTypeFactory typeFactory =
      new JavaTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  final MockCatalogReader catalogReader =
      factory.createCatalogReader(factory, typeFactory);
  return new Xyz(operatorTable, typeFactory, catalogReader);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
public SqlOperatorTable createOperatorTable(SqlTestFactory factory) {
  final SqlOperatorTable opTab0 =
      (SqlOperatorTable) factory.get("operatorTable");
  MockSqlOperatorTable opTab = new MockSqlOperatorTable(opTab0);
  MockSqlOperatorTable.addRamp(opTab);
  return opTab;
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
@Test public void testValidateUserDefinedAggregate() throws Exception {
  final SqlStdOperatorTable stdOpTab = SqlStdOperatorTable.instance();
  SqlOperatorTable opTab =
      ChainedSqlOperatorTable.of(stdOpTab,
          new ListSqlOperatorTable(
              ImmutableList.<SqlOperator>of(new MyCountAggFunction())));
  final SchemaPlus rootSchema = Frameworks.createRootSchema(true);
  final FrameworkConfig config = Frameworks.newConfigBuilder()
      .defaultSchema(
          CalciteAssert.addSchema(rootSchema, CalciteAssert.SchemaSpec.HR))
      .operatorTable(opTab)
      .build();
  final Planner planner = Frameworks.getPlanner(config);
  SqlNode parse =
      planner.parse("select \"deptno\", my_count(\"empid\") from \"emps\"\n"
          + "group by \"deptno\"");
  assertThat(Util.toLinux(parse.toString()),
      equalTo("SELECT `deptno`, `MY_COUNT`(`empid`)\n"
          + "FROM `emps`\n"
          + "GROUP BY `deptno`"));

  // MY_COUNT is recognized as an aggregate function, and therefore it is OK
  // that its argument empid is not in the GROUP BY clause.
  SqlNode validate = planner.validate(parse);
  assertThat(validate, notNullValue());

  // The presence of an aggregate function in the SELECT clause causes it
  // to become an aggregate query. Non-aggregate expressions become illegal.
  planner.close();
  planner.reset();
  parse = planner.parse("select \"deptno\", count(1) from \"emps\"");
  try {
    validate = planner.validate(parse);
    fail("expected exception, got " + validate);
  } catch (ValidationException e) {
    assertThat(e.getCause().getCause().getMessage(),
        containsString("Expression 'deptno' is not being grouped"));
  }
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
/**
 * Creates an operator table.
 *
 * @return New operator table
 */
protected SqlOperatorTable createOperatorTable() {
  final MockSqlOperatorTable opTab =
      new MockSqlOperatorTable(SqlStdOperatorTable.instance());
  MockSqlOperatorTable.addRamp(opTab);
  return opTab;
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
FarragoTestValidator(
    SqlOperatorTable opTab,
    SqlValidatorCatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    SqlConformance conformance) {
  super(opTab, catalogReader, typeFactory, conformance);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
protected FeatureValidator(
    SqlOperatorTable opTab,
    SqlValidatorCatalogReader catalogReader,
    RelDataTypeFactory typeFactory,
    SqlConformance conformance) {
  super(opTab, catalogReader, typeFactory, conformance);
}
 

import org.apache.calcite.sql.SqlOperatorTable; //导入依赖的package包/类
protected SqlValidatorImpl(FlattenOpCounter flattenCount, SqlOperatorTable opTab, SqlValidatorCatalogReader catalogReader,
                         RelDataTypeFactory typeFactory, SqlConformance conformance) {
  super(opTab, catalogReader, typeFactory, conformance);
  this.flattenCount = flattenCount;
}