import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
public JdbcImplementor.Result implement(JdbcImplementor implementor) {
    final JdbcImplementor.Result leftResult =
            implementor.visitChild(0, left);
    final JdbcImplementor.Result rightResult =
            implementor.visitChild(1, right);
    final JdbcImplementor.Context leftContext = leftResult.qualifiedContext();
    final JdbcImplementor.Context rightContext =
            rightResult.qualifiedContext();
    SqlNode sqlCondition = convertConditionToSqlNode(condition,
            leftContext,
            rightContext,
            left.getRowType().getFieldCount());
    SqlNode join =
            new SqlJoin(POS,
                    leftResult.asFrom(),
                    SqlLiteral.createBoolean(false, POS),
                    joinType(joinType).symbol(POS),
                    rightResult.asFrom(),
                    JoinConditionType.ON.symbol(POS),
                    sqlCondition);
    return implementor.result(join, leftResult, rightResult);
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
public Result visitJoin(Join e) {
  final Result leftResult = visitChild(0, e.getLeft());
  final Result rightResult = visitChild(1, e.getRight());
  final Context leftContext = leftResult.qualifiedContext();
  final Context rightContext =
      rightResult.qualifiedContext();
  SqlNode sqlCondition = convertConditionToSqlNode(e.getCondition(),
      leftContext,
      rightContext,
      e.getLeft().getRowType().getFieldCount());
  SqlNode join =
      new SqlJoin(POS,
          leftResult.asFrom(),
          SqlLiteral.createBoolean(false, POS),
          joinType(e.getJoinType()).symbol(POS),
          rightResult.asFrom(),
          JoinConditionType.ON.symbol(POS),
          sqlCondition);
  return result(join, leftResult, rightResult);
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private static void populateAliases(SqlNode from, List<String> aliases,
    String current) {
  if (from instanceof SqlJoin) {
    SqlJoin join = (SqlJoin) from;
    populateAliases(join.getLeft(), aliases, null);
    populateAliases(join.getRight(), aliases, null);
  } else if (from.getKind() == SqlKind.AS) {
    populateAliases(SqlUtil.stripAs(from), aliases,
        SqlValidatorUtil.getAlias(from, -1));
  } else {
    if (current == null) {
      current = SqlValidatorUtil.getAlias(from, -1);
    }
    aliases.add(current);
  }
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private static void getInput(SqlNode node, ArrayList<String> inputSource) {
  if (node instanceof SqlJoin) {
    SqlJoin joinNode = (SqlJoin) node;
    ArrayList<String> inputsLeft = new ArrayList<>();
    ArrayList<String> inputsRight = new ArrayList<>();
    getInput(joinNode.getLeft(), inputsLeft);
    getInput(joinNode.getRight(), inputsRight);

    if (!inputsLeft.isEmpty() && !inputsRight.isEmpty()) {
      throw new SamzaException("Joins on two entities are not supported yet");
    }

    inputSource.addAll(inputsLeft);
    inputSource.addAll(inputsRight);
  } else if (node instanceof SqlIdentifier) {
    inputSource.add(node.toString());
  } else if (node instanceof SqlBasicCall) {
    SqlBasicCall basicCall = ((SqlBasicCall) node);
    if (basicCall.getOperator() instanceof SqlAsOperator) {
      getInput(basicCall.operand(0), inputSource);
    } else if (basicCall.getOperator() instanceof SqlUnnestOperator && basicCall.operand(0) instanceof SqlSelect) {
      inputSource.add(getInputFromSelectQuery(basicCall.operand(0)));
      return;
    }
  } else if (node instanceof SqlSelect) {
    getInput(((SqlSelect) node).getFrom(), inputSource);
  }
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private List<Stream> parseStreams(SqlSelect sqlSelect) throws Exception {
    List<Stream> streams = new ArrayList<>();
    SqlNode sqlFrom = sqlSelect.getFrom();
    LOG.debug("from = {}", sqlFrom);
    if (sqlFrom instanceof SqlJoin) {
        throw new IllegalArgumentException("Sql join is not yet supported");
    } else if (sqlFrom instanceof SqlIdentifier) {
        streams.add(getStream(((SqlIdentifier) sqlFrom).getSimple()));
    }
    LOG.debug("Streams {}", streams);
    return streams;
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
/** @see #dispatch */
public Result visit(Join e) {
  final Result leftResult = visitChild(0, e.getLeft()).resetAlias();
  final Result rightResult = visitChild(1, e.getRight()).resetAlias();
  final Context leftContext = leftResult.qualifiedContext();
  final Context rightContext = rightResult.qualifiedContext();
  SqlNode sqlCondition = null;
  SqlLiteral condType = JoinConditionType.ON.symbol(POS);
  JoinType joinType = joinType(e.getJoinType());
  if (e.getJoinType() == JoinRelType.INNER && e.getCondition().isAlwaysTrue()) {
    joinType = JoinType.COMMA;
    condType = JoinConditionType.NONE.symbol(POS);
  } else {
    sqlCondition = convertConditionToSqlNode(e.getCondition(),
        leftContext,
        rightContext,
        e.getLeft().getRowType().getFieldCount());
  }
  SqlNode join =
      new SqlJoin(POS,
          leftResult.asFrom(),
          SqlLiteral.createBoolean(false, POS),
          joinType.symbol(POS),
          rightResult.asFrom(),
          condType,
          sqlCondition);
  return result(join, leftResult, rightResult);
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private void lookupFromHints(
    SqlNode node,
    SqlValidatorScope scope,
    SqlParserPos pos,
    Collection<SqlMoniker> hintList) {
  final SqlValidatorNamespace ns = getNamespace(node);
  if (ns.isWrapperFor(IdentifierNamespace.class)) {
    IdentifierNamespace idNs = ns.unwrap(IdentifierNamespace.class);
    final SqlIdentifier id = idNs.getId();
    for (int i = 0; i < id.names.size(); i++) {
      if (pos.toString().equals(
          id.getComponent(i).getParserPosition().toString())) {
        final List<SqlMoniker> objNames = new ArrayList<>();
        SqlValidatorUtil.getSchemaObjectMonikers(
            getCatalogReader(),
            id.names.subList(0, i + 1),
            objNames);
        for (SqlMoniker objName : objNames) {
          if (objName.getType() != SqlMonikerType.FUNCTION) {
            hintList.add(objName);
          }
        }
        return;
      }
    }
  }
  switch (node.getKind()) {
  case JOIN:
    lookupJoinHints((SqlJoin) node, scope, pos, hintList);
    break;
  default:
    lookupSelectHints(ns, pos, hintList);
    break;
  }
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private void lookupJoinHints(
    SqlJoin join,
    SqlValidatorScope scope,
    SqlParserPos pos,
    Collection<SqlMoniker> hintList) {
  SqlNode left = join.getLeft();
  SqlNode right = join.getRight();
  SqlNode condition = join.getCondition();
  lookupFromHints(left, scope, pos, hintList);
  if (hintList.size() > 0) {
    return;
  }
  lookupFromHints(right, scope, pos, hintList);
  if (hintList.size() > 0) {
    return;
  }
  final JoinConditionType conditionType = join.getConditionType();
  final SqlValidatorScope joinScope = scopes.get(join);
  switch (conditionType) {
  case ON:
    condition.findValidOptions(this, joinScope, pos, hintList);
    return;
  default:

    // No suggestions.
    // Not supporting hints for other types such as 'Using' yet.
    return;
  }
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
/**
 * Validates the FROM clause of a query, or (recursively) a child node of
 * the FROM clause: AS, OVER, JOIN, VALUES, or sub-query.
 *
 * @param node          Node in FROM clause, typically a table or derived
 *                      table
 * @param targetRowType Desired row type of this expression, or
 *                      {@link #unknownType} if not fussy. Must not be null.
 * @param scope         Scope
 */
protected void validateFrom(
    SqlNode node,
    RelDataType targetRowType,
    SqlValidatorScope scope) {
  Preconditions.checkNotNull(targetRowType);
  switch (node.getKind()) {
  case AS:
    validateFrom(
        ((SqlCall) node).operand(0),
        targetRowType,
        scope);
    break;
  case VALUES:
    validateValues((SqlCall) node, targetRowType, scope);
    break;
  case JOIN:
    validateJoin((SqlJoin) node, scope);
    break;
  case OVER:
    validateOver((SqlCall) node, scope);
    break;
  default:
    validateQuery(node, scope, targetRowType);
    break;
  }

  // Validate the namespace representation of the node, just in case the
  // validation did not occur implicitly.
  getNamespace(node, scope).validate(targetRowType);
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
/**
 * Creates a <code>JoinScope</code>.
 *
 * @param parent     Parent scope
 * @param usingScope Scope for resolving USING clause
 * @param join       Call to JOIN operator
 */
JoinScope(
    SqlValidatorScope parent,
    SqlValidatorScope usingScope,
    SqlJoin join) {
  super(parent);
  this.usingScope = usingScope;
  this.join = join;
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
private List<SqlIdentifier> extractAncestorsFromFrom(SqlNode from) {
  return
      from.accept(new BaseSqlVisitor<List<SqlIdentifier>>() {
    @Override
    public List<SqlIdentifier> visit(SqlIdentifier id) {
      return Arrays.asList(id);
    }
    @Override
    public List<SqlIdentifier> visit(SqlCall call) {
      SqlOperator operator = call.getOperator();
      switch (operator.getKind()) {
      case AS:
        SqlNode sqlNode = call.getOperandList().get(0);
        switch (sqlNode.getKind()) {
        case IDENTIFIER:
          return asList((SqlIdentifier)sqlNode);
        case SELECT:
          return extractAncestors(sqlNode);
        case COLLECTION_TABLE: // table function
          SqlNode operand = ((SqlCall)sqlNode).operand(0);
          if (operand.getKind() == SqlKind.OTHER_FUNCTION) {
            SqlFunction tableFunction = (SqlFunction)((SqlCall)operand).getOperator();
            return asList(tableFunction.getSqlIdentifier());
          }
          // pass through
        case VALUES:
          return Collections.emptyList();
        default:
          logger.warn("Failure while extracting parents from sql. Unexpected 1st operand in AS: {}. SQL: \n {}", sqlNode.getKind() ,SqlNodes.toTreeString(sqlNode));
          return Collections.emptyList();
        }
      case JOIN:
        SqlJoin join = (SqlJoin)call;
        List<SqlIdentifier> result = new ArrayList<>();
        result.addAll(join.getLeft().accept(this));
        result.addAll(join.getRight().accept(this));
        return result;
      default:
        throw new UnsupportedOperationException("Unexpected operator in call: " + operator.getKind() + "\n" + SqlNodes.toTreeString(call));
      }
    }
  });
}
 

import org.apache.calcite.sql.SqlJoin; //导入依赖的package包/类
JoinNamespace(SqlValidatorImpl validator, SqlJoin join) {
  super(validator, null);
  this.join = join;
}