import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
/**
 * Update the schema path for the session.
 * @param newDefaultSchemaPath New default schema path to set. It could be relative to the current default schema or
 *                             absolute schema.
 * @param currentDefaultSchema Current default schema.
 * @throws ValidationException If the given default schema path is invalid in current schema tree.
 */
public void setDefaultSchemaPath(String newDefaultSchemaPath, SchemaPlus currentDefaultSchema)
    throws ValidationException {
  final List<String> newDefaultPathAsList = Lists.newArrayList(newDefaultSchemaPath.split("\\."));
  SchemaPlus newDefault;

  // First try to find the given schema relative to the current default schema.
  newDefault = SchemaUtilites.findSchema(currentDefaultSchema, newDefaultPathAsList);

  if (newDefault == null) {
    // If we fail to find the schema relative to current default schema, consider the given new default schema path as
    // absolute schema path.
    newDefault = SchemaUtilites.findSchema(currentDefaultSchema, newDefaultPathAsList);
  }

  if (newDefault == null) {
    SchemaUtilites.throwSchemaNotFoundException(currentDefaultSchema, newDefaultSchemaPath);
  }

  setProp(SCHEMA, SchemaUtilites.getSchemaPath(newDefault));
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
/**
 * Function resolves the schema and invokes the drop method. Raises an exception if the schema is
 * immutable.
 * @param sqlNode - Table name identifier
 * @return - Single row indicating drop succeeded, raise exception otherwise
 * @throws ValidationException
 * @throws RelConversionException
 * @throws IOException
 */
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException {

  SqlDropTable dropTableNode = ((SqlDropTable) sqlNode);
  SqlIdentifier tableIdentifier = dropTableNode.getTableIdentifier();

  SchemaPlus defaultSchema = context.getNewDefaultSchema();
  AbstractSchema drillSchema = null;

  if (tableIdentifier != null) {
    drillSchema = SchemaUtilites.resolveToMutableDrillSchema(defaultSchema, dropTableNode.getSchema());
  }

  String tableName = ((SqlDropTable) sqlNode).getName();
  if (drillSchema == null) {
    throw UserException.validationError()
        .message("Invalid table_name [%s]", tableName)
        .build(logger);
  }

  drillSchema.dropTable(tableName);

  return DirectPlan.createDirectPlan(context, true,
      String.format("Table [%s] %s", tableName, "dropped"));
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  final ConvertedRelNode convertedRelNode = validateAndConvert(sqlNode);
  final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
  final RelNode queryRelNode = convertedRelNode.getConvertedNode();

  log("Optiq Logical", queryRelNode, logger);
  DrillRel drel = convertToDrel(queryRelNode, validatedRowType);

  log("Drill Logical", drel, logger);
  Prel prel = convertToPrel(drel);
  log("Drill Physical", prel, logger);
  PhysicalOperator pop = convertToPop(prel);
  PhysicalPlan plan = convertToPlan(pop);
  log("Drill Plan", plan, logger);
  return plan;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
private TypedSqlNode validateNode(SqlNode sqlNode) throws ValidationException, RelConversionException, ForemanSetupException {
  TypedSqlNode typedSqlNode = planner.validateAndGetType(sqlNode);

  SqlNode sqlNodeValidated = typedSqlNode.getSqlNode();

  // Check if the unsupported functionality is used
  UnsupportedOperatorsVisitor visitor = UnsupportedOperatorsVisitor.createVisitor(context);
  try {
    sqlNodeValidated.accept(visitor);
  } catch (UnsupportedOperationException ex) {
    // If the exception due to the unsupported functionalities
    visitor.convertException();

    // If it is not, let this exception move forward to higher logic
    throw ex;
  }

  return typedSqlNode;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  SqlDropView dropView = unwrap(sqlNode, SqlDropView.class);
  final String viewToDrop = dropView.getName();
  final AbstractSchema drillSchema =
      SchemaUtilites.resolveToMutableDrillSchema(context.getNewDefaultSchema(), dropView.getSchemaPath());

  final String schemaPath = drillSchema.getFullSchemaName();

  final Table existingTable = SqlHandlerUtil.getTableFromSchema(drillSchema, viewToDrop);
  if (existingTable != null && existingTable.getJdbcTableType() != Schema.TableType.VIEW) {
    throw UserException.validationError()
        .message("[%s] is not a VIEW in schema [%s]", viewToDrop, schemaPath)
        .build(logger);
  } else if (existingTable == null) {
    throw UserException.validationError()
        .message("Unknown view [%s] in schema [%s].", viewToDrop, schemaPath)
        .build(logger);
  }

  drillSchema.dropView(viewToDrop);

  return DirectPlan.createDirectPlan(context, true,
      String.format("View [%s] deleted successfully from schema [%s].", viewToDrop, schemaPath));
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  final ConvertedRelNode convertedRelNode = validateAndConvert(sqlNode);
  final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
  final RelNode queryRelNode = convertedRelNode.getConvertedNode();

  log("Optiq Logical", queryRelNode, logger);
  DrillRel drel = convertToDrel(queryRelNode, validatedRowType);
  log("Drill Logical", drel, logger);

  if (mode == ResultMode.LOGICAL) {
    LogicalExplain logicalResult = new LogicalExplain(drel, level, context);
    return DirectPlan.createDirectPlan(context, logicalResult);
  }

  Prel prel = convertToPrel(drel);
  log("Drill Physical", prel, logger);
  PhysicalOperator pop = convertToPop(prel);
  PhysicalPlan plan = convertToPlan(pop);
  log("Drill Plan", plan, logger);
  PhysicalExplain physicalResult = new PhysicalExplain(prel, plan, level, context);
  return DirectPlan.createDirectPlan(context, physicalResult);
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
public static UserException.Builder validationError(String query, ValidationException ex) {
  Throwable cause = ex;
  if (ex.getCause() != null) {
    // ValidationException generally wraps the "real" cause that we are interested in
    cause = ex.getCause();
  }
  UserException.Builder b = UserException.validationError(cause)
    .addContext("Sql Query", query);

  // CalciteContextException alters the error message including the start/end positions
  // we need to extract the original error message and add the remaining information as context
  if (cause instanceof CalciteContextException && cause.getCause() != null) {
    CalciteContextException cce = (CalciteContextException) cause;
    b.message(cce.getCause().getMessage())
            .addContext("startLine", cce.getPosLine())
            .addContext("startColumn", cce.getPosColumn())
            .addContext("endLine", cce.getEndPosLine())
            .addContext("endColumn", cce.getEndPosColumn());
  }
  return b;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
public static Exception coerceException(Logger logger, String sql, Exception e, boolean coerceToPlan){
  if(e instanceof UserException){
    return e;
  } else if(e instanceof ValidationException){
    throw validationError(sql, (ValidationException) e).build(logger);
  } else if (e instanceof AccessControlException){
  throw UserException.permissionError(e)
      .addContext("Sql Query", sql)
      .build(logger);
  } else if (e instanceof SqlUnsupportedException){
  throw UserException.unsupportedError(e)
      .addContext("Sql Query", sql)
      .build(logger);
  } else if (e instanceof IOException || e instanceof RelConversionException){
    return new QueryInputException("Failure handling SQL.", e);
  } else if (coerceToPlan){
    throw UserException.planError(e)
    .addContext("Sql Query", sql)
    .build(logger);
  }
  return e;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
/**
   * Update the schema path for the session.
   * @param newDefaultSchemaPath New default schema path to set. It could be relative to the current default schema or
   *                             absolute schema.
   * @param currentDefaultSchema Current default schema.
   * @throws ValidationException If the given default schema path is invalid in current schema tree.
   */
  public void setDefaultSchemaPath(String newDefaultSchemaPath, SchemaPlus currentDefaultSchema)
      throws ValidationException {
    final List<String> newDefaultPathAsList = SqlUtils.parseSchemaPath(newDefaultSchemaPath);

    SchemaPlus newDefault = null;

    // First try to find the given schema relative to the current default schema.
    // TODO validate if schema exists
//    newDefault = SchemaUtilities.findSchema(currentDefaultSchema, newDefaultPathAsList);

    if (newDefault == null) {
      // If we fail to find the schema relative to current default schema, consider the given new default schema path as
      // absolute schema path.
      newDefault = SchemaUtilities.findSchema(currentDefaultSchema, newDefaultPathAsList);
    }

    if (newDefault == null) {
      SchemaUtilities.throwSchemaNotFoundException(currentDefaultSchema, newDefaultSchemaPath);
    }

    setProp(SCHEMA, SchemaUtilities.getSchemaPath(newDefault));
  }
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
/**
 * Update the schema path for the session.
 * @param newDefaultSchemaPath New default schema path to set. It could be relative to the current default schema or
 *                             absolute schema.
 * @param currentDefaultSchema Current default schema.
 * @throws ValidationException If the given default schema path is invalid in current schema tree.
 */
public void setDefaultSchemaPath(String newDefaultSchemaPath, SchemaPlus currentDefaultSchema)
    throws ValidationException {
  final List<String> newDefaultPathAsList = Lists.newArrayList(newDefaultSchemaPath.split("\\."));
  SchemaPlus newDefault;

  // First try to find the given schema relative to the current default schema.
  newDefault = SchemaUtilites.findSchema(currentDefaultSchema, newDefaultPathAsList);

  if (newDefault == null) {
    // If we fail to find the schema relative to current default schema, consider the given new default schema path as
    // absolute schema path.
    newDefault = SchemaUtilites.findSchema(currentDefaultSchema, newDefaultPathAsList);
  }

  if (newDefault == null) {
    SchemaUtilites.throwSchemaNotFoundException(currentDefaultSchema, newDefaultSchemaPath);
  }

  properties.setProperty(DrillProperties.SCHEMA, SchemaUtilites.getSchemaPath(newDefault));
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
private TypedSqlNode validateNode(SqlNode sqlNode) throws ValidationException, RelConversionException, ForemanSetupException {
  final SqlNode sqlNodeValidated = config.getConverter().validate(sqlNode);
  final TypedSqlNode typedSqlNode = new TypedSqlNode(sqlNodeValidated, config.getConverter().getOutputType(
      sqlNodeValidated));

  // Check if the unsupported functionality is used
  UnsupportedOperatorsVisitor visitor = UnsupportedOperatorsVisitor.createVisitor(context);
  try {
    sqlNodeValidated.accept(visitor);
  } catch (UnsupportedOperationException ex) {
    // If the exception due to the unsupported functionalities
    visitor.convertException();

    // If it is not, let this exception move forward to higher logic
    throw ex;
  }

  return typedSqlNode;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  final ConvertedRelNode convertedRelNode = validateAndConvert(sqlNode);
  final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
  final RelNode queryRelNode = convertedRelNode.getConvertedNode();

  log("Calcite", queryRelNode, logger, null);
  DrillRel drel = convertToDrel(queryRelNode);

  if (mode == ResultMode.LOGICAL) {
    LogicalExplain logicalResult = new LogicalExplain(drel, level, context);
    return DirectPlan.createDirectPlan(context, logicalResult);
  }

  Prel prel = convertToPrel(drel, validatedRowType);
  logAndSetTextPlan("Drill Physical", prel, logger);
  PhysicalOperator pop = convertToPop(prel);
  PhysicalPlan plan = convertToPlan(pop);
  log("Drill Plan", plan, logger);
  PhysicalExplain physicalResult = new PhysicalExplain(prel, plan, level, context);
  return DirectPlan.createDirectPlan(context, physicalResult);
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的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.tools.ValidationException; //导入依赖的package包/类
private static void runProjectQueryWithLex(Lex lex, String sql)
    throws SqlParseException, ValidationException, RelConversionException {
  Config javaLex = SqlParser.configBuilder().setLex(lex).build();
  Planner planner = getPlanner(null, javaLex, Programs.ofRules(Programs.RULE_SET));
  SqlNode parse = planner.parse(sql);
  SqlNode validate = planner.validate(parse);
  RelNode convert = planner.rel(validate).rel;
  RelTraitSet traitSet =
      planner.getEmptyTraitSet().replace(EnumerableConvention.INSTANCE);
  RelNode transform = planner.transform(0, traitSet, convert);
  assertThat(transform, instanceOf(EnumerableProject.class));
  List<String> fieldNames = transform.getRowType().getFieldNames();
  assertThat(fieldNames.size(), is(2));
  if (lex.caseSensitive) {
    assertThat(fieldNames.get(0), is("EMPID"));
    assertThat(fieldNames.get(1), is("empid"));
  } else {
    assertThat(fieldNames.get(0) + "-" + fieldNames.get(1),
        anyOf(is("EMPID-empid0"), is("EMPID0-empid")));
  }
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  final SqlUseSchema useSchema = unwrap(sqlNode, SqlUseSchema.class);
  final String newDefaultSchemaPath = useSchema.getSchema();

  context.getSession().setDefaultSchemaPath(newDefaultSchemaPath, context.getNewDefaultSchema());

  return DirectPlan.createDirectPlan(context, true,
      String.format("Default schema changed to [%s]", context.getSession().getDefaultSchemaPath()));
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
protected ConvertedRelNode validateAndConvert(SqlNode sqlNode) throws ForemanSetupException, RelConversionException, ValidationException {
  final SqlNode rewrittenSqlNode = rewrite(sqlNode);
  final TypedSqlNode validatedTypedSqlNode = validateNode(rewrittenSqlNode);
  final SqlNode validated = validatedTypedSqlNode.getSqlNode();

  RelNode rel = convertToRel(validated);
  rel = preprocessNode(rel);

  return new ConvertedRelNode(rel, validatedTypedSqlNode.getType());
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  SqlTrainModel sqlTrainModel = unwrap(sqlNode, SqlTrainModel.class);
  final String newMdlName = sqlTrainModel.getName();

  final ConvertedRelNode convertedRelNode = validateAndConvert(sqlTrainModel.getQuery());
  final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
  final RelNode queryRelNode = convertedRelNode.getConvertedNode();


  final RelNode newMdlRelNode = 
  		SqlHandlerUtil.resolveNewTableRel(false, sqlTrainModel.getFieldNames(), validatedRowType, queryRelNode);


  final AbstractSchema drillSchema =
      SchemaUtilites.resolveToMutableDrillSchema(context.getNewDefaultSchema(), sqlTrainModel.getSchemaPath());
  final String schemaPath = drillSchema.getFullSchemaName();

  if (SqlHandlerUtil.getTableFromSchema(drillSchema, newMdlName) != null) {
    throw UserException.validationError()
        .message("A model with given name [%s] already exists in schema [%s]", newMdlName, schemaPath)
        .build(logger);
  }

  final RelNode newMdlRelNodeWithPCol = SqlHandlerUtil.qualifyPartitionCol(newMdlRelNode, sqlTrainModel.getPartitionColumns());

  log("Optiq Logical", newMdlRelNodeWithPCol, logger);

  // Convert the query to Drill Logical plan and insert a writer operator on top.
  DrillRel drel = convertToDrel(newMdlRelNodeWithPCol, drillSchema, newMdlName, sqlTrainModel.getPartitionColumns(), newMdlRelNode.getRowType());
  log("Drill Logical", drel, logger);
  Prel prel = convertToPrel(drel, newMdlRelNode.getRowType(), sqlTrainModel.getPartitionColumns());
  log("Drill Physical", prel, logger);
  PhysicalOperator pop = convertToPop(prel);
  PhysicalPlan plan = convertToPlan(pop);
  log("Drill Plan", plan, logger);

  return plan;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
private static void ensureNoDuplicateColumnNames(List<String> fieldNames) throws ValidationException {
  final HashSet<String> fieldHashSet = Sets.newHashSetWithExpectedSize(fieldNames.size());
  for(String field : fieldNames) {
    if (fieldHashSet.contains(field.toLowerCase())) {
      throw new ValidationException(String.format("Duplicate column name [%s]", field));
    }
    fieldHashSet.add(field.toLowerCase());
  }
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
@Override
public PhysicalPlan getPlan(SqlNode sqlNode) throws ValidationException, RelConversionException, IOException, ForemanSetupException {
  SqlCreateTable sqlCreateTable = unwrap(sqlNode, SqlCreateTable.class);
  final String newTblName = sqlCreateTable.getName();

  final ConvertedRelNode convertedRelNode = validateAndConvert(sqlCreateTable.getQuery());
  final RelDataType validatedRowType = convertedRelNode.getValidatedRowType();
  final RelNode queryRelNode = convertedRelNode.getConvertedNode();


  final RelNode newTblRelNode =
      SqlHandlerUtil.resolveNewTableRel(false, sqlCreateTable.getFieldNames(), validatedRowType, queryRelNode);


  final AbstractSchema drillSchema =
      SchemaUtilites.resolveToMutableDrillSchema(context.getNewDefaultSchema(), sqlCreateTable.getSchemaPath());
  final String schemaPath = drillSchema.getFullSchemaName();

  if (SqlHandlerUtil.getTableFromSchema(drillSchema, newTblName) != null) {
    throw UserException.validationError()
        .message("A table or view with given name [%s] already exists in schema [%s]", newTblName, schemaPath)
        .build(logger);
  }

  final RelNode newTblRelNodeWithPCol = SqlHandlerUtil.qualifyPartitionCol(newTblRelNode, sqlCreateTable.getPartitionColumns());

  log("Optiq Logical", newTblRelNodeWithPCol, logger);

  // Convert the query to Drill Logical plan and insert a writer operator on top.
  DrillRel drel = convertToDrel(newTblRelNodeWithPCol, drillSchema, newTblName, sqlCreateTable.getPartitionColumns(), newTblRelNode.getRowType());
  log("Drill Logical", drel, logger);
  Prel prel = convertToPrel(drel, newTblRelNode.getRowType(), sqlCreateTable.getPartitionColumns());
  log("Drill Physical", prel, logger);
  PhysicalOperator pop = convertToPop(prel);
  PhysicalPlan plan = convertToPlan(pop);
  log("Drill Plan", plan, logger);

  return plan;
}
 

import org.apache.calcite.tools.ValidationException; //导入依赖的package包/类
public static ConvertedRelNode validateAndConvert(SqlHandlerConfig config, SqlNode sqlNode) throws ForemanSetupException, RelConversionException, ValidationException {
  final Pair<SqlNode, RelDataType> validatedTypedSqlNode = validateNode(config, sqlNode);
  final SqlNode validated = validatedTypedSqlNode.getKey();
  final RelNode rel = convertToRel(config, validated);
  final RelNode preprocessedRel = preprocessNode(config, rel);
  assert preprocessedRel.getRowType().getFieldCount() == validatedTypedSqlNode.getValue().getFieldCount();
  return new ConvertedRelNode(preprocessedRel, validatedTypedSqlNode.getValue());
}