Class SqlNode

java.lang.Object
org.apache.calcite.sql.SqlNode
All Implemented Interfaces:
Cloneable
Direct Known Subclasses:
SqlCall, SqlDataTypeSpec, SqlDynamicParam, SqlIdentifier, SqlIntervalQualifier, SqlLiteral, SqlNodeList

public abstract class SqlNode extends Object implements Cloneable
A SqlNode is a SQL parse tree.

It may be an operator, literal, identifier, and so forth.

  • Field Details

    • EMPTY_ARRAY

      public static final @Nullable SqlNode[] EMPTY_ARRAY
    • pos

      protected final SqlParserPos pos
  • Method Details

    • clone

      @Deprecated public Object clone()
      Deprecated.
      Please use clone(SqlNode); this method brings along too much baggage from early versions of Java
      Overrides:
      clone in class Object
    • clone

      public static <E extends SqlNode> E clone(E e)
      Creates a copy of a SqlNode.
    • clone

      public abstract SqlNode clone(SqlParserPos pos)
      Clones a SqlNode with a different position.
    • getKind

      public SqlKind getKind()
      Returns the type of node this is, or SqlKind.OTHER if it's nothing special.
      Returns:
      a SqlKind value, never null
      See Also:
    • isA

      public final boolean isA(Set<SqlKind> category)
      Returns whether this node is a member of an aggregate category.

      For example, node.isA(SqlKind.QUERY) returns true if the node is a SELECT, INSERT, UPDATE etc.

      This method is shorthand: node.isA(category) is always equivalent to node.getKind().belongsTo(category).

      Parameters:
      category - Category
      Returns:
      Whether this node belongs to the given category.
    • cloneArray

      @Deprecated public static SqlNode[] cloneArray(SqlNode[] nodes)
      Deprecated.
    • toString

      public String toString()
      Overrides:
      toString in class Object
    • toSqlString

      public SqlString toSqlString(UnaryOperator<SqlWriterConfig> transform)
      Returns the SQL text of the tree of which this SqlNode is the root.

      Typical return values are:

      • 'It''s a bird!'
      • NULL
      • 12.3
      • DATE '1969-04-29'
      Parameters:
      transform - Transform that sets desired writer configuration
    • toSqlString

      public SqlString toSqlString(@Nullable SqlDialect dialect, boolean forceParens)
      Returns the SQL text of the tree of which this SqlNode is the root.

      Typical return values are:

      • 'It''s a bird!'
      • NULL
      • 12.3
      • DATE '1969-04-29'
      Parameters:
      dialect - Dialect (null for ANSI SQL)
      forceParens - Whether to wrap all expressions in parentheses; useful for parse test, but false by default
    • toSqlString

      public SqlString toSqlString(@Nullable SqlDialect dialect)
    • unparse

      public abstract void unparse(SqlWriter writer, int leftPrec, int rightPrec)
      Writes a SQL representation of this node to a writer.

      The leftPrec and rightPrec parameters give us enough context to decide whether we need to enclose the expression in parentheses. For example, we need parentheses around "2 + 3" if preceded by "5 *". This is because the precedence of the "*" operator is greater than the precedence of the "+" operator.

      The algorithm handles left- and right-associative operators by giving them slightly different left- and right-precedence.

      If SqlWriter.isAlwaysUseParentheses() is true, we use parentheses even when they are not required by the precedence rules.

      For the details of this algorithm, see SqlCall.unparse(org.apache.calcite.sql.SqlWriter, int, int).

      Parameters:
      writer - Target writer
      leftPrec - The precedence of the SqlNode immediately preceding this node in a depth-first scan of the parse tree
      rightPrec - The precedence of the SqlNode immediately
    • unparseWithParentheses

      public void unparseWithParentheses(SqlWriter writer, int leftPrec, int rightPrec, boolean parentheses)
    • getParserPosition

      public SqlParserPos getParserPosition()
    • validate

      public abstract void validate(SqlValidator validator, SqlValidatorScope scope)
      Validates this node.

      The typical implementation of this method will make a callback to the validator appropriate to the node type and context. The validator has methods such as SqlValidator.validateLiteral(org.apache.calcite.sql.SqlLiteral) for these purposes.

      Parameters:
      scope - Validator
    • findValidOptions

      public void findValidOptions(SqlValidator validator, SqlValidatorScope scope, SqlParserPos pos, Collection<SqlMoniker> hintList)
      Lists all the valid alternatives for this node if the parse position of the node matches that of pos. Only implemented now for SqlCall and SqlOperator.
      Parameters:
      validator - Validator
      scope - Validation scope
      pos - SqlParserPos indicating the cursor position at which completion hints are requested for
      hintList - list of valid options
    • validateExpr

      public void validateExpr(SqlValidator validator, SqlValidatorScope scope)
      Validates this node in an expression context.

      Usually, this method does much the same as validate(org.apache.calcite.sql.validate.SqlValidator, org.apache.calcite.sql.validate.SqlValidatorScope), but a SqlIdentifier can occur in expression and non-expression contexts.

    • accept

      public abstract <R> R accept(SqlVisitor<R> visitor)
      Accepts a generic visitor.

      Implementations of this method in subtypes simply call the appropriate visit method on the visitor object.

      The type parameter R must be consistent with the type parameter of the visitor.

    • equalsDeep

      public abstract boolean equalsDeep(@Nullable SqlNode node, Litmus litmus)
      Returns whether this node is structurally equivalent to another node. Some examples:
      • 1 + 2 is structurally equivalent to 1 + 2
      • 1 + 2 + 3 is structurally equivalent to (1 + 2) + 3, but not to 1 + (2 + 3), because the '+' operator is left-associative
    • equalsDeep

      @Deprecated public final boolean equalsDeep(@Nullable SqlNode node, boolean fail)
      Deprecated.
    • equalDeep

      public static boolean equalDeep(@Nullable SqlNode node1, @Nullable SqlNode node2, Litmus litmus)
      Returns whether two nodes are equal (using equalsDeep(SqlNode, Litmus)) or are both null.
      Parameters:
      node1 - First expression
      node2 - Second expression
      litmus - What to do if an error is detected (expressions are not equal)
    • getMonotonicity

      public SqlMonotonicity getMonotonicity(@Nullable SqlValidatorScope scope)
      Returns whether expression is always ascending, descending or constant. This property is useful because it allows to safely aggregate infinite streams of values.

      The default implementation returns SqlMonotonicity.NOT_MONOTONIC.

      Parameters:
      scope - Scope
    • equalDeep

      public static boolean equalDeep(List<SqlNode> operands0, List<SqlNode> operands1, Litmus litmus)
      Returns whether two lists of operands are equal.
    • toList

      public static <T extends SqlNode> Collector<T,ArrayList<@Nullable SqlNode>,SqlNodeList> toList()
      Returns a Collector that accumulates the input elements into a SqlNodeList, with zero position.
      Type Parameters:
      T - Type of the input elements
      Returns:
      a Collector that collects all the input elements into a SqlNodeList, in encounter order
    • toList

      public static <T extends @Nullable SqlNode> Collector<T,ArrayList<@Nullable SqlNode>,SqlNodeList> toList(SqlParserPos pos)
      Returns a Collector that accumulates the input elements into a SqlNodeList.
      Type Parameters:
      T - Type of the input elements
      Returns:
      a Collector that collects all the input elements into a SqlNodeList, in encounter order