calcite validate

针对一个这样的语句，

String sql = "select id,name from users where id <5";

我们的validate 过程如下：

调用validate 方法 ，输入是一个SqlNode ，输出也是一个经过校验的SqlNode

  public SqlNode validate(SqlNode topNode) {
    SqlValidatorScope scope = new EmptyScope(this); //直接new 出一个EmptyScope ，
    scope = new CatalogScope(scope, ImmutableList.of("CATALOG")); // CATALOG的parent 是Empty
    final SqlNode topNode2 = validateScopedExpression(topNode, scope);  // 将最外层的SqlNode和catalogScope 传入调用具体的validate方法
    final RelDataType type = getValidatedNodeType(topNode2);
    Util.discard(type);
    return topNode2;
  }

具体看validateScopedExpression 这个方法在做什么。方法相对简洁，仍然是一个入口的身份。 这个方法其实就是把topNode 传入进行一个注册的过程。

  private SqlNode validateScopedExpression(
      SqlNode topNode,
      SqlValidatorScope scope) {
    SqlNode outermostNode = performUnconditionalRewrites(topNode, false); //todo
    cursorSet.add(outermostNode);
    top = outermostNode;
    TRACER.trace("After unconditional rewrite: {}", outermostNode);
    if (outermostNode.isA(SqlKind.TOP_LEVEL)) { 
//isA 是当前对象的一个方法，入参是一个set ，判断当前对象是否是的set 中的一员
      registerQuery(scope, null, outermostNode, outermostNode, null, false); 
// 重点方法就是这个registerQuery ，传入了上文说的catalogScope 和 最外层的SqlNode 
// 针对当前的例子来说最外层的SqlNode就是这个SqlSelect
    }
    outermostNode.validate(this, scope);
    if (!outermostNode.isA(SqlKind.TOP_LEVEL)) {
      // force type derivation so that we can provide it to the
      // caller later without needing the scope
      deriveType(scope, outermostNode);
    }
    TRACER.trace("After validation: {}", outermostNode);
    return outermostNode;
  }

到具体的registerQuery有方法会非常的细， 根据传入的topNode 会走不同的分支，此处具体以当前的例子来往下看。
当我们看sqlToRel 的时候有非常多的 scope && nameSpace 的概念，之所以会有各种SelectNamespace ，JoinNamespace ，SelectScope ，CatalogScope 其实可以在这个方法里面看到， 基本都是在validate过程中塞进去的。
在SqlValidatorImpl 里面维护了很多的map .

protected final Map<SqlNode, SqlValidatorScope> scopes = new IdentityHashMap<>();
private final Map<SqlSelect, SqlValidatorScope> whereScopes = new IdentityHashMap<>();
private final Map<SqlSelect, SqlValidatorScope> groupByScopes = new IdentityHashMap<>();
private final Map<SqlSelect, SqlValidatorScope> selectScopes = new IdentityHashMap<>();
private final Map<SqlSelect, SqlValidatorScope> orderScopes = new IdentityHashMap<>();
 private final Map<SqlSelect, SqlValidatorScope> cursorScopes =new IdentityHashMap<>();

还有一个nameSpace 的 map

protected final Map<SqlNode, SqlValidatorNamespace> namespaces = new IdentityHashMap<>();

对于具体的registerQuery 这个方法，其实就是在填充上面这些map 的一个过程。

  private void registerQuery(
      SqlValidatorScope parentScope,
      SqlValidatorScope usingScope,
      SqlNode node,
      SqlNode enclosingNode,
      String alias,
      boolean forceNullable,
      boolean checkUpdate) {
    Objects.requireNonNull(node);
    Objects.requireNonNull(enclosingNode);
    Preconditions.checkArgument(usingScope == null || alias != null);

    SqlCall call;
    List<SqlNode> operands;
    switch (node.getKind()) { //根据node 的种类不同选择不同的case 分支
    case SELECT:
      final SqlSelect select = (SqlSelect) node; // 传入的这个topNode 
      final SelectNamespace selectNs = 
          createSelectNamespace(select, enclosingNode); // 新建这样一个SelectNamespace
      registerNamespace(usingScope, alias, selectNs, forceNullable); // 注册nameSpace 的过程也就是把它放入nameSpace 的那个map 里面(SqlNode--> Namespace)
      final SqlValidatorScope windowParentScope =
          (usingScope != null) ? usingScope : parentScope;
      SelectScope selectScope =
          new SelectScope(parentScope, windowParentScope, select); // 新建这样一个SelectScope 

//可以看到这个SelectScope 被放入了三个map ，一个scopes ，一个whereScopes ，一个selectScopes
      scopes.put(select, selectScope);

      // Start by registering the WHERE clause
      whereScopes.put(select, selectScope); 
      registerOperandSubQueries(
          selectScope,
          select,
          SqlSelect.WHERE_OPERAND);

      // Register FROM with the inherited scope 'parentScope', not
      // 'selectScope', otherwise tables in the FROM clause would be
      // able to see each other.
      final SqlNode from = select.getFrom(); // 对于一个select 的语句会有一个from 的表， 获取他from 的信息
      if (from != null) {
        final SqlNode newFrom =
            registerFrom(
                parentScope,
                selectScope,
                true,
                from,
                from,
                null,
                null,
                false,
                false);
        if (newFrom != from) {
          select.setFrom(newFrom);
        }
      }

      // If this is an aggregating query, the SELECT list and HAVING
      // clause use a different scope, where you can only reference
      // columns which are in the GROUP BY clause.
      SqlValidatorScope aggScope = selectScope;
      if (isAggregate(select)) { // 是否是一个agg 类型的select
        aggScope =
            new AggregatingSelectScope(selectScope, select, false);
        selectScopes.put(select, aggScope);
      } else {
        selectScopes.put(select, selectScope);// selectScopes 在这里放入
      }
      if (select.getGroup() != null) {
        GroupByScope groupByScope =
            new GroupByScope(selectScope, select.getGroup(), select);
        groupByScopes.put(select, groupByScope);
        registerSubQueries(groupByScope, select.getGroup());
      }
//注册subQueries 过程暂时不必关注， 先分析最简单的一种情况
      registerOperandSubQueries(
          aggScope,
          select,
          SqlSelect.HAVING_OPERAND);
      registerSubQueries(aggScope, select.getSelectList());
      final SqlNodeList orderList = select.getOrderList();
      if (orderList != null) {
        // If the query is 'SELECT DISTINCT', restrict the columns
        // available to the ORDER BY clause.
        if (select.isDistinct()) {
          aggScope =
              new AggregatingSelectScope(selectScope, select, true);
        }
//当前案例没有orderby
        OrderByScope orderScope =
            new OrderByScope(aggScope, orderList, select);
        orderScopes.put(select, orderScope);
        registerSubQueries(orderScope, orderList);

        if (!isAggregate(select)) {
          // Since this is not an aggregating query,
          // there cannot be any aggregates in the ORDER BY clause.
          SqlNode agg = aggFinder.findAgg(orderList);
          if (agg != null) {
            throw newValidationError(agg, RESOURCE.aggregateIllegalInOrderBy());
          }
        }
      }
      break;

注意在最初始 的时候， 可以看到这个Validator 对象。
Validate 在最开始我们注册进去两张表到rootSchema 以后。成为整个validate 的基准、
registerQuery

这里的功能主要就是将[元数据]转换成 SqlValidator 内部的 对象 进行表示，也就是 SqlValidatorScope 和 SqlValidatorNamespace 两种类型的对象：

SqlValidatorNamespace：a description of a data source used in a query，它代表了 SQL 查询的数据源，它是一个逻辑上数据源，可以是一张表，也可以是一个子查询； （eg.TableNamespace， JoinNamespace）
SqlValidatorScope：describes the tables and columns accessible at a particular point in the query，代表了在某一个程序运行点，当前可见的字段名和表名。