core/src/main/java/org/apache/calcite/sql/validate/JoinScope.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.calcite.sql.validate;

import org.apache.calcite.sql.SqlJoin;
import org.apache.calcite.sql.SqlNode;
import org.apache.calcite.sql.SqlWindow;

import org.checkerframework.checker.nullness.qual.Nullable;

import static org.apache.calcite.sql.JoinType.LEFT_ANTI_JOIN;
import static org.apache.calcite.sql.JoinType.LEFT_SEMI_JOIN;
import static org.apache.calcite.sql.SqlUtil.stripAs;

import static java.util.Objects.requireNonNull;

/**
 * The name-resolution context for expression inside a JOIN clause. The objects
 * visible are the joined table expressions, and those inherited from the parent
 * scope.
 *
 * <p>Consider "SELECT * FROM (A JOIN B ON {exp1}) JOIN C ON {exp2}". {exp1} is
 * resolved in the join scope for "A JOIN B", which contains A and B but not
 * C.
 */
public class JoinScope extends ListScope {
  //~ Instance fields --------------------------------------------------------

  private final @Nullable SqlValidatorScope usingScope;
  private final SqlJoin join;

  //~ Constructors -----------------------------------------------------------

  /**
   * 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,
      @Nullable SqlValidatorScope usingScope,
      SqlJoin join) {
    super(parent);
    this.usingScope = usingScope;
    this.join = join;
  }

  //~ Methods ----------------------------------------------------------------

  @Override public SqlNode getNode() {
    return join;
  }

  @Override public void addChild(SqlValidatorNamespace ns, String alias,
      boolean nullable) {
    super.addChild(ns, alias, nullable);

    // LEFT SEMI JOIN and LEFT ANTI JOIN can only come from Babel.
    if ((join.getJoinType() == LEFT_SEMI_JOIN
        || join.getJoinType() == LEFT_ANTI_JOIN)
        && stripAs(join.getRight()) == ns.getNode()) {
      // Ignore the right hand side.
      return;
    }

    if ((usingScope != null) && (usingScope != parent)) {
      // We're looking at a join within a join. Recursively add this
      // child to its parent scope too. Example:
      //
      //   select *
      //   from (a join b on expr1)
      //   join c on expr2
      //   where expr3
      //
      // 'a' is a child namespace of 'a join b' and also of
      // 'a join b join c'.
      usingScope.addChild(ns, alias, nullable);
    }
  }

  @Override public @Nullable SqlWindow lookupWindow(String name) {
    // Lookup window in enclosing select.
    if (usingScope != null) {
      return usingScope.lookupWindow(name);
    } else {
      return null;
    }
  }

  /**
   * Returns the scope which is used for resolving USING clause.
   */
  public @Nullable SqlValidatorScope getUsingScope() {
    return usingScope;
  }

  @Override public boolean isWithin(SqlValidatorScope scope2) {
    if (this == scope2) {
      return true;
    }
    // go from the JOIN to the enclosing SELECT
    return requireNonNull(usingScope, "usingScope").isWithin(scope2);
  }
}