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;
}
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;
}
}
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);
}
}
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);
}
}
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);
}
public void validate(SqlValidator validator, SqlValidatorScope scope) {
for (SqlNode child : list) {
child.validate(validator, scope);
}
}
