Exemple #1
0
 void commaList(SqlWriter writer) {
   // The precedence of the comma operator if low but not zero. For
   // instance, this ensures parentheses in
   //    select x, (select * from foo order by z), y from t
   for (SqlNode node : list) {
     writer.sep(",");
     node.unparse(writer, 2, 3);
   }
 }
 public static SqlNode[] cloneArray(SqlNode[] nodes) {
   SqlNode[] clones = (SqlNode[]) nodes.clone();
   for (int i = 0; i < clones.length; i++) {
     SqlNode node = clones[i];
     if (node != null) {
       clones[i] = (SqlNode) node.clone();
     }
   }
   return clones;
 }
Exemple #3
0
 public SqlNode findAgg(List<SqlNode> nodes) {
   try {
     for (SqlNode node : nodes) {
       node.accept(this);
     }
     return null;
   } catch (Util.FoundOne e) {
     Util.swallow(e, null);
     return (SqlNode) e.getNode();
   }
 }
 boolean containsAnd(SqlNode node) {
   try {
     node.accept(this);
     return false;
   } catch (AndFinder.Found e) {
     return true;
   }
 }
Exemple #5
0
  public void validateExpr(SqlValidator validator, SqlValidatorScope scope) {
    // While a SqlNodeList is not always a valid expression, this
    // implementation makes that assumption. It just validates the members
    // of the list.
    //
    // One example where this is valid is the IN operator. The expression
    //
    //    empno IN (10, 20)
    //
    // results in a call with operands
    //
    //    {  SqlIdentifier({"empno"}),
    //       SqlNodeList(SqlLiteral(10), SqlLiteral(20))  }

    for (SqlNode node : list) {
      node.validateExpr(validator, scope);
    }
  }
Exemple #6
0
  void andOrList(SqlWriter writer, SqlKind sepKind) {
    SqlBinaryOperator sepOp =
        sepKind == SqlKind.AND ? SqlStdOperatorTable.AND : SqlStdOperatorTable.OR;
    for (int i = 0; i < list.size(); i++) {
      SqlNode node = list.get(i);
      writer.sep(sepKind.name(), false);

      // The precedence pulling on the LHS of a node is the
      // right-precedence of the separator operator, except at the start
      // of the list; similarly for the RHS of a node. If the operator
      // has left precedence 4 and right precedence 5, the precedences
      // in a 3-node list will look as follows:
      //   0 <- node1 -> 4  5 <- node2 -> 4  5 <- node3 -> 0
      int lprec = (i == 0) ? 0 : sepOp.getRightPrec();
      int rprec = (i == (list.size() - 1)) ? 0 : sepOp.getLeftPrec();
      node.unparse(writer, lprec, rprec);
    }
  }
 /**
  * Returns whether two nodes are equal (using {@link #equalsDeep(SqlNode,boolean)}) or are both
  * null.
  *
  * @param node1 First expression
  * @param node2 Second expression
  * @param fail Whether to throw {@link AssertionError} if expressions are not equal
  */
 public static boolean equalDeep(SqlNode node1, SqlNode node2, boolean fail) {
   if (node1 == null) {
     return node2 == null;
   } else if (node2 == null) {
     return false;
   } else {
     return node1.equalsDeep(node2, fail);
   }
 }
Exemple #8
0
 public boolean equalsDeep(SqlNode node, boolean fail) {
   if (!(node instanceof SqlNodeList)) {
     assert !fail : this + "!=" + node;
     return false;
   }
   SqlNodeList that = (SqlNodeList) node;
   if (this.size() != that.size()) {
     assert !fail : this + "!=" + node;
     return false;
   }
   for (int i = 0; i < list.size(); i++) {
     SqlNode thisChild = list.get(i);
     final SqlNode thatChild = that.list.get(i);
     if (!thisChild.equalsDeep(thatChild, fail)) {
       return false;
     }
   }
   return true;
 }
 public void unparse(SqlWriter writer, SqlNode[] operands, int leftPrec, int rightPrec) {
   assert operands.length >= 2;
   final SqlWriter.Frame frame = writer.startList(SqlWriter.FrameTypeEnum.Simple);
   operands[0].unparse(writer, leftPrec, getLeftPrec());
   final boolean needsSpace = true;
   writer.setNeedWhitespace(needsSpace);
   writer.sep("AS");
   writer.setNeedWhitespace(needsSpace);
   operands[1].unparse(writer, getRightPrec(), rightPrec);
   if (operands.length > 2) {
     final SqlWriter.Frame frame1 = writer.startList(SqlWriter.FrameTypeEnum.Simple, "(", ")");
     for (int i = 2; i < operands.length; i++) {
       SqlNode operand = operands[i];
       writer.sep(",", false);
       operand.unparse(writer, 0, 0);
     }
     writer.endList(frame1);
   }
   writer.endList(frame);
 }
Exemple #10
0
 public void validate(SqlValidator validator, SqlValidatorScope scope) {
   for (SqlNode child : list) {
     child.validate(validator, scope);
   }
 }