import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
public SqlNode validate(SqlNode sqlNode) throws ValidationException {
  ensure(State.STATE_3_PARSED);
  final SqlConformance conformance = conformance();
  final CalciteCatalogReader catalogReader = createCatalogReader();
  this.validator =
      new CalciteSqlValidator(operatorTable, catalogReader, typeFactory,
          conformance);
  this.validator.setIdentifierExpansion(true);
  try {
    validatedSqlNode = validator.validate(sqlNode);
  } catch (RuntimeException e) {
    throw new ValidationException(e);
  }
  state = State.STATE_4_VALIDATED;
  return validatedSqlNode;
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
protected TesterImpl(DiffRepository diffRepos, boolean enableDecorrelate,
    boolean enableTrim, boolean enableExpand, boolean enableLateDecorrelate,
    Function<RelDataTypeFactory, Prepare.CatalogReader>
        catalogReaderFactory,
    Function<RelOptCluster, RelOptCluster> clusterFactory,
    SqlToRelConverter.Config config, SqlConformance conformance,
    Context context) {
  this.diffRepos = diffRepos;
  this.enableDecorrelate = enableDecorrelate;
  this.enableTrim = enableTrim;
  this.enableExpand = enableExpand;
  this.enableLateDecorrelate = enableLateDecorrelate;
  this.catalogReaderFactory = catalogReaderFactory;
  this.clusterFactory = clusterFactory;
  this.config = config;
  this.conformance = conformance;
  this.context = context;
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
public SqlConverter(QueryContext context) {
  this.settings = context.getPlannerSettings();
  this.util = context;
  this.functions = context.getFunctionRegistry();
  this.parserConfig = new DrillParserConfig(settings);
  this.sqlToRelConverterConfig = new SqlToRelConverterConfig();
  this.isInnerQuery = false;
  this.typeFactory = new JavaTypeFactoryImpl(DRILL_TYPE_SYSTEM);
  this.defaultSchema =  context.getNewDefaultSchema();
  this.rootSchema = rootSchema(defaultSchema);
  this.temporarySchema = context.getConfig().getString(ExecConstants.DEFAULT_TEMPORARY_WORKSPACE);
  this.session = context.getSession();
  this.drillConfig = context.getConfig();
  this.catalog = new DrillCalciteCatalogReader(
      rootSchema,
      parserConfig.caseSensitive(),
      DynamicSchema.from(defaultSchema).path(null),
      typeFactory,
      drillConfig,
      session);
  this.opTab = new ChainedSqlOperatorTable(Arrays.asList(context.getDrillOperatorTable(), catalog));
  this.costFactory = (settings.useDefaultCosting()) ? null : new DrillCostBase.DrillCostFactory();
  this.validator = new DrillValidator(opTab, catalog, typeFactory, SqlConformance.DEFAULT);
  validator.setIdentifierExpansion(true);
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
private SqlAdvisor getSqlAdvisor() {
    final CalciteConnectionImpl con = (CalciteConnectionImpl) queryProvider;
    final String schemaName = con.getSchema();
    final List<String> schemaPath =
            schemaName == null
                    ? ImmutableList.<String>of()
                    : ImmutableList.of(schemaName);
    final SqlValidatorWithHints validator =
            new SqlAdvisorValidator(SqlStdOperatorTable.instance(),
                    new CalciteCatalogReader(rootSchema, con.config().caseSensitive(),
                            schemaPath, typeFactory),
                    typeFactory, SqlConformance.DEFAULT);
    return new SqlAdvisor(validator);
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的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.validate.SqlConformance; //导入依赖的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.validate.SqlConformance; //导入依赖的package包/类
private SqlConformance conformance() {
  final Context context = config.getContext();
  if (context != null) {
    final CalciteConnectionConfig connectionConfig =
        context.unwrap(CalciteConnectionConfig.class);
    if (connectionConfig != null) {
      return connectionConfig.conformance();
    }
  }
  return SqlConformanceEnum.DEFAULT;
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
@Override public RelRoot expandView(RelDataType rowType, String queryString,
  List<String> schemaPath, List<String> viewPath) {
  SqlParser parser = SqlParser.create(queryString, parserConfig);
  SqlNode sqlNode;
  try {
    sqlNode = parser.parseQuery();
  } catch (SqlParseException e) {
    throw new RuntimeException("parse failed", e);
  }

  final SqlConformance conformance = conformance();
  final CalciteCatalogReader catalogReader =
      createCatalogReader().withSchemaPath(schemaPath);
  final SqlValidator validator =
      new CalciteSqlValidator(operatorTable, catalogReader, typeFactory,
          conformance);
  validator.setIdentifierExpansion(true);
  final SqlNode validatedSqlNode = validator.validate(sqlNode);

  final RexBuilder rexBuilder = createRexBuilder();
  final RelOptCluster cluster = RelOptCluster.create(planner, rexBuilder);
  final SqlToRelConverter.Config config = SqlToRelConverter
      .configBuilder()
      .withConfig(sqlToRelConverterConfig)
      .withTrimUnusedFields(false)
      .withConvertTableAccess(false)
      .build();
  final SqlToRelConverter sqlToRelConverter =
      new SqlToRelConverter(new ViewExpanderImpl(), validator,
          catalogReader, cluster, convertletTable, config);

  root = sqlToRelConverter.convertQuery(validatedSqlNode, true, false);
  root = root.withRel(sqlToRelConverter.flattenTypes(root.rel, true));
  root = root.withRel(RelDecorrelator.decorrelateQuery(root.rel));

  return PlannerImpl.this.root;
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
private ConfigImpl(int identifierMaxLength, Casing quotedCasing,
    Casing unquotedCasing, Quoting quoting, boolean caseSensitive,
    SqlConformance conformance, SqlParserImplFactory parserFactory) {
  this.identifierMaxLength = identifierMaxLength;
  this.caseSensitive = caseSensitive;
  this.conformance = Preconditions.checkNotNull(conformance);
  this.quotedCasing = Preconditions.checkNotNull(quotedCasing);
  this.unquotedCasing = Preconditions.checkNotNull(unquotedCasing);
  this.quoting = Preconditions.checkNotNull(quoting);
  this.parserFactory = Preconditions.checkNotNull(parserFactory);
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
@Override public SqlValidator getValidator(SqlTestFactory factory) {
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  final SqlConformance conformance = (SqlConformance) get("conformance");
  final boolean caseSensitive = (Boolean) factory.get("caseSensitive");
  return new SqlAdvisorValidator(
      SqlStdOperatorTable.instance(),
      new MockCatalogReader(typeFactory, caseSensitive).init(),
      typeFactory,
      conformance);
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
public SqlTesterImpl withConformance(SqlConformance conformance) {
  if (conformance == null) {
    conformance = SqlConformanceEnum.DEFAULT;
  }
  return with("conformance", conformance)
      .withConnectionFactory(
          CalciteAssert.EMPTY_CONNECTION_FACTORY
              .with("conformance", conformance));
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
public SqlParser createParser(SqlTestFactory factory, String sql) {
  return SqlParser.create(sql,
      SqlParser.configBuilder()
          .setQuoting((Quoting) factory.get("quoting"))
          .setUnquotedCasing((Casing) factory.get("unquotedCasing"))
          .setQuotedCasing((Casing) factory.get("quotedCasing"))
          .setConformance((SqlConformance) factory.get("conformance"))
          .build());
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
public SqlValidator getValidator(SqlTestFactory factory) {
  final Xyz xyz = cache.getUnchecked(factory);
  final SqlConformance conformance =
      (SqlConformance) factory.get("conformance");
  return SqlValidatorUtil.newValidator(xyz.operatorTable,
      xyz.catalogReader, xyz.typeFactory, conformance);
}
 

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

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
@Override public SqlValidator getValidator(SqlTestFactory factory) {
  final RelDataTypeFactory typeFactory =
      new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
  SqlConformance conformance = (SqlConformance) get("conformance");
  final boolean caseSensitive = (Boolean) get("caseSensitive");
  return new FeatureValidator(
      factory.createOperatorTable(factory),
      new MockCatalogReader(typeFactory, caseSensitive).init(),
      typeFactory,
      conformance);
}
 

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

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
@Test public void testAbstractConformance()
    throws InvocationTargetException, IllegalAccessException {
  final SqlAbstractConformance c0 = new SqlAbstractConformance() {
  };
  final SqlConformance c1 = SqlConformanceEnum.DEFAULT;
  for (Method method : SqlConformance.class.getMethods()) {
    final Object o0 = method.invoke(c0);
    final Object o1 = method.invoke(c1);
    assertThat(method.toString(), Objects.equals(o0, o1), is(true));
  }
}
 

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
Sql(String sql, boolean expand, boolean decorrelate, Tester tester,
    boolean trim, SqlToRelConverter.Config config,
    SqlConformance conformance) {
  this.sql = sql;
  this.expand = expand;
  this.decorrelate = decorrelate;
  this.tester = tester;
  this.trim = trim;
  this.config = config;
  this.conformance = conformance;
}
 

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

import org.apache.calcite.sql.validate.SqlConformance; //导入依赖的package包/类
@Override
public SqlConformance conformance() {
  return DremioSqlConformance.INSTANCE;
}