import org.apache.calcite.tools.RelConversionException; //导入依赖的package包/类
/** Rewrite the parse tree as SELECT ... FROM INFORMATION_SCHEMA.SCHEMATA ... */
@Override
public SqlNode rewrite(SqlNode sqlNode) throws RelConversionException, ForemanSetupException {
  SqlShowSchemas node = unwrap(sqlNode, SqlShowSchemas.class);
  List<SqlNode> selectList =
      ImmutableList.of((SqlNode) new SqlIdentifier(SCHS_COL_SCHEMA_NAME, SqlParserPos.ZERO));

  SqlNode fromClause = new SqlIdentifier(
      ImmutableList.of(IS_SCHEMA_NAME, TAB_SCHEMATA), null, SqlParserPos.ZERO, null);

  SqlNode where = null;
  final SqlNode likePattern = node.getLikePattern();
  if (likePattern != null) {
    where = DrillParserUtil.createCondition(new SqlIdentifier(SCHS_COL_SCHEMA_NAME, SqlParserPos.ZERO),
                                            SqlStdOperatorTable.LIKE, likePattern);
  } else if (node.getWhereClause() != null) {
    where = node.getWhereClause();
  }

  return new SqlSelect(SqlParserPos.ZERO, null, new SqlNodeList(selectList, SqlParserPos.ZERO),
      fromClause, where, null, null, null, null, null, null);
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的package包/类
private RelNode convertToRel(SqlNode node) throws RelConversionException {
  final RelNode convertedNode = planner.convert(node);

  final RelMetadataProvider provider = convertedNode.getCluster().getMetadataProvider();

  // Register RelMetadataProvider with HepPlanner.
  final List<RelMetadataProvider> list = Lists.newArrayList(provider);
  hepPlanner.registerMetadataProviders(list);
  final RelMetadataProvider cachingMetaDataProvider = new CachingRelMetadataProvider(ChainedRelMetadataProvider.of(list), hepPlanner);
  convertedNode.accept(new MetaDataProviderModifier(cachingMetaDataProvider));

  // HepPlanner is specifically used for Window Function planning only.
  hepPlanner.setRoot(convertedNode);
  RelNode rel = hepPlanner.findBestExp();

  rel.accept(new MetaDataProviderModifier(provider));
  return rel;
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的package包/类
/**
 * Do logical planning using both VolcanoPlanner and LOPT HepPlanner.
 * @param relNode
 * @return
 * @throws RelConversionException
 * @throws SqlUnsupportedException
 */
private RelNode logicalPlanningVolcanoAndLopt(RelNode relNode) throws RelConversionException, SqlUnsupportedException {

  final RelNode convertedRelNode = planner.transform(DrillSqlWorker.LOGICAL_CONVERT_RULES, relNode.getTraitSet().plus(DrillRel.DRILL_LOGICAL), relNode);
  log("VolCalciteRel", convertedRelNode, logger);

  final RelNode loptNode = getLoptJoinOrderTree(
      convertedRelNode,
      DrillJoinRel.class,
      DrillRelFactories.DRILL_LOGICAL_JOIN_FACTORY,
      DrillRelFactories.DRILL_LOGICAL_FILTER_FACTORY,
      DrillRelFactories.DRILL_LOGICAL_PROJECT_FACTORY);

  log("HepCalciteRel", loptNode, logger);

  return loptNode;
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的package包/类
@Override
public SqlNode rewrite(SqlNode sqlNode) throws RelConversionException, ForemanSetupException {
  SqlExplain node = unwrap(sqlNode, SqlExplain.class);
  SqlLiteral op = node.operand(2);
  SqlExplain.Depth depth = (SqlExplain.Depth) op.getValue();
  if (node.getDetailLevel() != null) {
    level = node.getDetailLevel();
  }
  switch (depth) {
  case LOGICAL:
    mode = ResultMode.LOGICAL;
    break;
  case PHYSICAL:
    mode = ResultMode.PHYSICAL;
    break;
  default:
    throw new UnsupportedOperationException("Unknown depth " + depth);
  }

  return node.operand(0);
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的package包/类
private static Rel convertToDrel(
    SqlHandlerConfig config,
    RelNode relNode,
    AbstractSchema schema,
    String tableName,
    WriterOptions options,
    RelDataType queryRowType,
    final Map<String, Object> storageOptions)
    throws RelConversionException, SqlUnsupportedException {

  Rel convertedRelNode = PrelTransformer.convertToDrel(config, relNode);

  // Put a non-trivial topProject to ensure the final output field name is preserved, when necessary.
  // Only insert project when the field count from the child is same as that of the queryRowType.

  convertedRelNode = new WriterRel(convertedRelNode.getCluster(),
      convertedRelNode.getCluster().traitSet().plus(Rel.LOGICAL),
      convertedRelNode, schema.createNewTable(tableName, options, storageOptions), queryRowType);

  convertedRelNode = SqlHandlerUtil.storeQueryResultsIfNeeded(config.getConverter().getParserConfig(),
      config.getContext(), convertedRelNode);

  return new ScreenRel(convertedRelNode.getCluster(), convertedRelNode.getTraitSet(), convertedRelNode);
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的package包/类
private DrillRel convertToDrel(RelNode relNode,
                               AbstractSchema schema,
                               String tableName,
                               List<String> partitionColumns,
                               RelDataType queryRowType,
                               StorageStrategy storageStrategy)
    throws RelConversionException, SqlUnsupportedException {
  final DrillRel convertedRelNode = convertToRawDrel(relNode);

  // Put a non-trivial topProject to ensure the final output field name is preserved, when necessary.
  // Only insert project when the field count from the child is same as that of the queryRowType.
  final DrillRel topPreservedNameProj = queryRowType.getFieldCount() == convertedRelNode.getRowType().getFieldCount() ?
      addRenamedProject(convertedRelNode, queryRowType) : convertedRelNode;

  final RelTraitSet traits = convertedRelNode.getCluster().traitSet().plus(DrillRel.DRILL_LOGICAL);
  final DrillWriterRel writerRel = new DrillWriterRel(convertedRelNode.getCluster(),
      traits, topPreservedNameProj, schema.createNewTable(tableName, partitionColumns, storageStrategy));
  return new DrillScreenRel(writerRel.getCluster(), writerRel.getTraitSet(), writerRel);
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的package包/类
public RelRoot rel(SqlNode sql) throws RelConversionException {
  ensure(State.STATE_4_VALIDATED);
  assert validatedSqlNode != null;
  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,
          createCatalogReader(), cluster, convertletTable, config);
  root =
      sqlToRelConverter.convertQuery(validatedSqlNode, false, true);
  root = root.withRel(sqlToRelConverter.flattenTypes(root.rel, true));
  root = root.withRel(RelDecorrelator.decorrelateQuery(root.rel));
  state = State.STATE_5_CONVERTED;
  return root;
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的package包/类
@Override
public Prel visitPrel(Prel prel, Object value) throws RelConversionException {
  List<RelNode> children = Lists.newArrayList();
  for(Prel child : prel){
    child = child.accept(this, null);
    children.add(child);
  }
  return (Prel) prel.copy(prel.getTraitSet(), children);
}
 

import org.apache.calcite.tools.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的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.RelConversionException; //导入依赖的package包/类
/**
 *  Given a relNode tree for SELECT statement, convert to Drill Logical RelNode tree.
 * @param relNode
 * @return
 * @throws SqlUnsupportedException
 * @throws RelConversionException
 */
protected DrillRel convertToDrel(RelNode relNode) throws SqlUnsupportedException, RelConversionException {
  try {
    final DrillRel convertedRelNode;

    if (! context.getPlannerSettings().isHepJoinOptEnabled()) {
      convertedRelNode = (DrillRel) logicalPlanningVolcano(relNode);
    } else {
      convertedRelNode = (DrillRel) logicalPlanningVolcanoAndLopt(relNode);
    }

    if (convertedRelNode instanceof DrillStoreRel) {
      throw new UnsupportedOperationException();
    } else {

      // If the query contains a limit 0 clause, disable distributed mode since it is overkill for determining schema.
      if (FindLimit0Visitor.containsLimit0(convertedRelNode)) {
        context.getPlannerSettings().forceSingleMode();
      }

      return convertedRelNode;
    }
  } catch (RelOptPlanner.CannotPlanException ex) {
    logger.error(ex.getMessage());

    if(JoinUtils.checkCartesianJoin(relNode, new ArrayList<Integer>(), new ArrayList<Integer>())) {
      throw new UnsupportedRelOperatorException("This query cannot be planned possibly due to either a cartesian join or an inequality join");
    } else {
      throw ex;
    }
  }
}