/*
* JBoss, Home of Professional Open Source.
*
* See the LEGAL.txt file distributed with this work for information regarding copyright ownership and licensing.
*
* See the AUTHORS.txt file distributed with this work for a full listing of individual contributors.
*/
package org.teiid.query.sql;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.teiid.core.types.DataTypeManagerService;
import org.teiid.designer.query.sql.lang.IJoinType.Types;
import org.teiid.designer.query.sql.lang.ISPParameter;
import org.teiid.designer.query.sql.lang.ISetQuery.Operation;
import org.teiid.designer.runtime.version.spi.ITeiidServerVersion;
import org.teiid.query.parser.QueryParser;
import org.teiid.query.parser.TeiidNodeFactory;
import org.teiid.query.parser.TeiidNodeFactory.ASTNodes;
import org.teiid.query.sql.lang.ArrayTable;
import org.teiid.query.sql.lang.BetweenCriteria;
import org.teiid.query.sql.lang.Command;
import org.teiid.query.sql.lang.CompareCriteria;
import org.teiid.query.sql.lang.CompoundCriteria;
import org.teiid.query.sql.lang.Create;
import org.teiid.query.sql.lang.Criteria;
import org.teiid.query.sql.lang.CriteriaOperator.Operator;
import org.teiid.query.sql.lang.Delete;
import org.teiid.query.sql.lang.Drop;
import org.teiid.query.sql.lang.DynamicCommand;
import org.teiid.query.sql.lang.ExistsCriteria;
import org.teiid.query.sql.lang.ExpressionCriteria;
import org.teiid.query.sql.lang.From;
import org.teiid.query.sql.lang.FromClause;
import org.teiid.query.sql.lang.GroupBy;
import org.teiid.query.sql.lang.Insert;
import org.teiid.query.sql.lang.Into;
import org.teiid.query.sql.lang.IsNullCriteria;
import org.teiid.query.sql.lang.JoinPredicate;
import org.teiid.query.sql.lang.JoinType;
import org.teiid.query.sql.lang.MatchCriteria;
import org.teiid.query.sql.lang.NamespaceItem;
import org.teiid.query.sql.lang.NotCriteria;
import org.teiid.query.sql.lang.OrderBy;
import org.teiid.query.sql.lang.OrderByItem;
import org.teiid.query.sql.lang.ProjectedColumn;
import org.teiid.query.sql.lang.Query;
import org.teiid.query.sql.lang.QueryCommand;
import org.teiid.query.sql.lang.SPParameter;
import org.teiid.query.sql.lang.Select;
import org.teiid.query.sql.lang.SetClause;
import org.teiid.query.sql.lang.SetClauseList;
import org.teiid.query.sql.lang.SetCriteria;
import org.teiid.query.sql.lang.SetQuery;
import org.teiid.query.sql.lang.StoredProcedure;
import org.teiid.query.sql.lang.SubqueryCompareCriteria;
import org.teiid.query.sql.lang.SubqueryCompareCriteria.PredicateQuantifier;
import org.teiid.query.sql.lang.SubqueryFromClause;
import org.teiid.query.sql.lang.SubquerySetCriteria;
import org.teiid.query.sql.lang.TextColumn;
import org.teiid.query.sql.lang.TextTable;
import org.teiid.query.sql.lang.UnaryFromClause;
import org.teiid.query.sql.lang.Update;
import org.teiid.query.sql.lang.WithQueryCommand;
import org.teiid.query.sql.lang.XMLColumn;
import org.teiid.query.sql.lang.XMLTable;
import org.teiid.query.sql.proc.AssignmentStatement;
import org.teiid.query.sql.proc.Block;
import org.teiid.query.sql.proc.BranchingStatement;
import org.teiid.query.sql.proc.BranchingStatement.BranchingMode;
import org.teiid.query.sql.proc.CommandStatement;
import org.teiid.query.sql.proc.CreateProcedureCommand;
import org.teiid.query.sql.proc.DeclareStatement;
import org.teiid.query.sql.proc.ExceptionExpression;
import org.teiid.query.sql.proc.IfStatement;
import org.teiid.query.sql.proc.LoopStatement;
import org.teiid.query.sql.proc.Statement;
import org.teiid.query.sql.proc.WhileStatement;
import org.teiid.query.sql.symbol.AggregateSymbol;
import org.teiid.query.sql.symbol.AliasSymbol;
import org.teiid.query.sql.symbol.Array;
import org.teiid.query.sql.symbol.CaseExpression;
import org.teiid.query.sql.symbol.Constant;
import org.teiid.query.sql.symbol.DerivedColumn;
import org.teiid.query.sql.symbol.ElementSymbol;
import org.teiid.query.sql.symbol.Expression;
import org.teiid.query.sql.symbol.Function;
import org.teiid.query.sql.symbol.GroupSymbol;
import org.teiid.query.sql.symbol.JSONObject;
import org.teiid.query.sql.symbol.MultipleElementSymbol;
import org.teiid.query.sql.symbol.Reference;
import org.teiid.query.sql.symbol.ScalarSubquery;
import org.teiid.query.sql.symbol.SearchedCaseExpression;
import org.teiid.query.sql.symbol.TextLine;
import org.teiid.query.sql.symbol.WindowFunction;
import org.teiid.query.sql.symbol.WindowSpecification;
import org.teiid.query.sql.symbol.XMLAttributes;
import org.teiid.query.sql.symbol.XMLElement;
import org.teiid.query.sql.symbol.XMLForest;
import org.teiid.query.sql.symbol.XMLNamespaces;
import org.teiid.query.sql.symbol.XMLParse;
import org.teiid.query.sql.symbol.XMLQuery;
import org.teiid.query.sql.symbol.XMLSerialize;
/**
*
*/
@SuppressWarnings( "javadoc" )
public abstract class AbstractTestFactory {
private QueryParser parser;
public AbstractTestFactory(QueryParser parser) {
this.parser = parser;
}
public ITeiidServerVersion getTeiidVersion() {
return parser.getTeiidVersion();
}
public <T> T newNode(ASTNodes nodeType) {
return TeiidNodeFactory.createASTNode(getTeiidVersion(), nodeType);
}
public GroupSymbol newGroupSymbol(String... groupSymbolProps) {
String name = groupSymbolProps[0];
String definition = null;
if (groupSymbolProps.length > 1)
definition = groupSymbolProps[1];
GroupSymbol gs = newNode(ASTNodes.GROUP_SYMBOL);
gs.setName(name);
if (definition != null)
gs.setDefinition(definition);
return gs;
}
public UnaryFromClause newUnaryFromClause(GroupSymbol groupSymbol) {
UnaryFromClause ufc = newNode(ASTNodes.UNARY_FROM_CLAUSE);
ufc.setGroup(groupSymbol);
return ufc;
}
public UnaryFromClause newUnaryFromClause(String... groupSymbolProps) {
return newUnaryFromClause(newGroupSymbol(groupSymbolProps));
}
public JoinPredicate newJoinPredicate(FromClause leftClause, FromClause rightClause, JoinType.Types joinTypeTypes) {
JoinType joinType = newNode(ASTNodes.JOIN_TYPE);
joinType.setKind(joinTypeTypes);
JoinPredicate jp = newNode(ASTNodes.JOIN_PREDICATE);
jp.setLeftClause(leftClause);
jp.setRightClause(rightClause);
jp.setJoinType(joinType);
return jp;
}
public JoinPredicate newJoinPredicate(FromClause leftClause, FromClause rightClause, JoinType.Types joinTypeTypes, List<? extends Criteria> crits) {
JoinPredicate jp = newJoinPredicate(leftClause, rightClause, joinTypeTypes);
jp.setJoinCriteria((List<Criteria>)crits);
return jp;
}
public From newFrom() {
return newNode(ASTNodes.FROM);
}
public From newFrom(List<? extends FromClause> clauses) {
From from = newFrom();
from.setClauses(clauses);
return from;
}
public Select newSelect() {
return newNode(ASTNodes.SELECT);
}
public Select newSelect(List<? extends Expression> symbols) {
Select select = newSelect();
for (Expression symbol : symbols) {
select.addSymbol(symbol);
}
return select;
}
public MultipleElementSymbol newMultipleElementSymbol() {
MultipleElementSymbol mes = newNode(ASTNodes.MULTIPLE_ELEMENT_SYMBOL);
return mes;
}
public MultipleElementSymbol newMultipleElementSymbol(String name) {
MultipleElementSymbol mes = newMultipleElementSymbol();
mes.setName(name);
return mes;
}
public BranchingStatement newBranchingStatement() {
BranchingStatement stmt = newNode(ASTNodes.BRANCHING_STATEMENT);
return stmt;
}
public BranchingStatement newBranchingStatement(BranchingMode mode) {
BranchingStatement stmt = newBranchingStatement();
stmt.setMode(mode);
return stmt;
}
public DynamicCommand newDynamicCommand() {
DynamicCommand dc = newNode(ASTNodes.DYNAMIC_COMMAND);
return dc;
}
public Select newSelectWithMultileElementSymbol() {
Select select = newSelect();
MultipleElementSymbol all = newMultipleElementSymbol();
select.addSymbol(all);
return select;
}
public Query newQuery() {
Query query = newNode(ASTNodes.QUERY);
return query;
}
public Query newQuery(Select select, From from) {
Query query = newQuery();
query.setSelect(select);
query.setFrom(from);
return query;
}
public ExpressionCriteria newExpressionCriteria(ElementSymbol newElementSymbol) {
ExpressionCriteria ec = newNode(ASTNodes.EXPRESSION_CRITERIA);
ec.setExpression(newElementSymbol);
return ec;
}
public ExceptionExpression newExceptionExpression() {
ExceptionExpression ee = newNode(ASTNodes.EXCEPTION_EXPRESSION);
return ee;
}
public OrderByItem newOrderByItem(Expression symbol, boolean ascending) {
OrderByItem orderByItem = newNode(ASTNodes.ORDER_BY_ITEM);
orderByItem.setSymbol(symbol);
orderByItem.setAscending(ascending);
return orderByItem;
}
public OrderBy newOrderBy() {
OrderBy orderBy = newNode(ASTNodes.ORDER_BY);
return orderBy;
}
public OrderBy newOrderBy(List<? extends Expression> parameters) {
OrderBy orderBy = newOrderBy();
List<OrderByItem> orderByItems = new ArrayList<OrderByItem>();
for (Expression singleElementSymbol : parameters) {
orderByItems.add(newOrderByItem(singleElementSymbol, true));
}
orderBy.getOrderByItems().addAll(orderByItems);
return orderBy;
}
public OrderBy newOrderBy(List<? extends Expression> parameters, List<Boolean> orderTypes) {
OrderBy orderBy = newOrderBy();
List<OrderByItem> orderByItems = new ArrayList<OrderByItem>();
Iterator<Boolean> typeIter = orderTypes.iterator();
for (Expression singleElementSymbol : parameters) {
orderByItems.add(newOrderByItem(singleElementSymbol, typeIter.next()));
}
orderBy.getOrderByItems().addAll(orderByItems);
return orderBy;
}
public ElementSymbol newElementSymbol(String symbolName) {
ElementSymbol elementSymbol = newNode(ASTNodes.ELEMENT_SYMBOL);
elementSymbol.setName(symbolName);
return elementSymbol;
}
public ElementSymbol newElementSymbol(String shortName, GroupSymbol gs) {
return newElementSymbol(shortName, gs, DataTypeManagerService.DefaultDataTypes.STRING.getTypeClass());
}
public ElementSymbol newElementSymbol(String shortName, GroupSymbol gs, Class<?> typeClass) {
ElementSymbol elementSymbol = newNode(ASTNodes.ELEMENT_SYMBOL);
elementSymbol.setShortName(shortName);
elementSymbol.setGroupSymbol(gs);
elementSymbol.setType(typeClass);
return elementSymbol;
}
public Constant newConstant(Object literal) {
Constant constant = newNode(ASTNodes.CONSTANT);
constant.setValue(literal);
return constant;
}
public Constant newConstant(Object literal, Class<?> type) {
Constant constant = newConstant(literal);
constant.setType(type);
return constant;
}
public AliasSymbol newAliasSymbol(String aliasName, Expression expression) {
AliasSymbol aliasSymbol = newNode(ASTNodes.ALIAS_SYMBOL);
aliasSymbol.setName(aliasName);
aliasSymbol.setSymbol(expression);
return aliasSymbol;
}
public AliasSymbol newAliasSymbolWithElementSymbol(String aliasName, String elementSymbolName) {
return newAliasSymbol(aliasName, newElementSymbol(elementSymbolName));
}
public CompareCriteria newCompareCriteria(Expression leftExpr, Operator operator, Expression rightExpr) {
CompareCriteria crit = newNode(ASTNodes.COMPARE_CRITERIA);
crit.setLeftExpression(leftExpr);
crit.setOperator(operator);
crit.setRightExpression(rightExpr);
return crit;
}
public CompareCriteria newCompareCriteria(String leftExprName, Operator operator, String rightExprName) {
ElementSymbol left = newElementSymbol(leftExprName);
ElementSymbol right = newElementSymbol(rightExprName);
return newCompareCriteria(left, operator, right);
}
public CompoundCriteria newCompoundCriteria(int operator, Criteria left, Criteria right) {
CompoundCriteria cc = newNode(ASTNodes.COMPOUND_CRITERIA);
cc.setOperator(operator);
cc.getCriteria().add(left);
cc.getCriteria().add(right);
return cc;
}
public TextColumn newTextColumn(String name, String type, int position) {
TextColumn tc = newNode(ASTNodes.TEXT_COLUMN);
tc.setName(name);
tc.setType(type);
tc.setWidth(position);
return tc;
}
public TextTable newTextTable() {
TextTable tt = newNode(ASTNodes.TEXT_TABLE);
return tt;
}
public Reference newReference(int index) {
Reference reference = newNode(ASTNodes.REFERENCE);
reference.setIndex(index);
reference.setPositional(true);
return reference;
}
public ProjectedColumn newProjectedColumn(String name, String type) {
ProjectedColumn pc = newNode(ASTNodes.PROJECTED_COLUMN);
pc.setName(name);
pc.setType(type);
return pc;
}
public IsNullCriteria newIsNullCriteria(Expression expression) {
IsNullCriteria isNullCriteria = newNode(ASTNodes.IS_NULL_CRITERIA);
isNullCriteria.setExpression(expression);
return isNullCriteria;
}
public NotCriteria newNotCriteria(Criteria criteria) {
NotCriteria notCriteria = newNode(ASTNodes.NOT_CRITERIA);
notCriteria.setCriteria(criteria);
return notCriteria;
}
public WithQueryCommand newWithQueryCommand(GroupSymbol groupSymbol, QueryCommand queryExpression) {
WithQueryCommand withQueryCommand = newNode(ASTNodes.WITH_QUERY_COMMAND);
withQueryCommand.setGroupSymbol(groupSymbol);
withQueryCommand.setQueryExpression(queryExpression);
return withQueryCommand;
}
public Block newBlock() {
Block block = newNode(ASTNodes.BLOCK);
return block;
}
public Block newBlock(CommandStatement cmdStmt) {
Block block = newBlock();
block.addStatement(cmdStmt);
return block;
}
public AssignmentStatement newAssignmentStatement(ElementSymbol var1, Command command) {
AssignmentStatement as = newNode(ASTNodes.ASSIGNMENT_STATEMENT);
as.setVariable(var1);
as.setCommand(command);
return as;
}
public AssignmentStatement newAssignmentStatement(ElementSymbol var1, Expression expression) {
AssignmentStatement as = newNode(ASTNodes.ASSIGNMENT_STATEMENT);
as.setVariable(var1);
as.setExpression(expression);
return as;
}
public Function newFunction(String name, Expression... args) {
Function function = newNode(ASTNodes.FUNCTION);
function.setName(name);
function.setArgs(args);
return function;
}
public DerivedColumn newDerivedColumn(String alias, Expression expression) {
DerivedColumn dc = newNode(ASTNodes.DERIVED_COLUMN);
dc.setAlias(alias);
dc.setExpression(expression);
return dc;
}
public JSONObject newJSONObject(List<DerivedColumn> args) {
JSONObject json = newNode(ASTNodes.JSON_OBJECT);
json.setArgs(args);
return json;
}
public CommandStatement newCommandStatement(Command cmd) {
CommandStatement cmdStmt = newNode(ASTNodes.COMMAND_STATEMENT);
cmdStmt.setCommand(cmd);
return cmdStmt;
}
public GroupBy newGroupBy(ElementSymbol... elementSymbols) {
GroupBy groupBy = newNode(ASTNodes.GROUP_BY);
if (elementSymbols != null) {
for (ElementSymbol es : elementSymbols) {
groupBy.addSymbol(es);
}
}
return groupBy;
}
public MatchCriteria newMatchCriteria(Expression left, Expression right) {
MatchCriteria crit = newNode(ASTNodes.MATCH_CRITERIA);
crit.setLeftExpression(left);
crit.setRightExpression(right);
return crit;
}
public MatchCriteria newMatchCriteria(Expression left, Expression right, char escapeChar) {
MatchCriteria crit = newMatchCriteria(left, right);
crit.setEscapeChar(escapeChar);
return crit;
}
public CreateProcedureCommand newCreateProcedureCommand() {
CreateProcedureCommand cpc = newNode(ASTNodes.CREATE_PROCEDURE_COMMAND);
return cpc;
}
public CreateProcedureCommand newCreateProcedureCommand(Block block) {
CreateProcedureCommand cpc = newCreateProcedureCommand();
cpc.setBlock(block);
return cpc;
}
public IfStatement newIfStatement(Criteria criteria, Block ifBlock) {
IfStatement ifStmt = newNode(ASTNodes.IF_STATEMENT);
ifStmt.setIfBlock(ifBlock);
ifStmt.setCondition(criteria);
return ifStmt;
}
public LoopStatement newLoopStatement(Block block, Query query, String cursorName) {
LoopStatement loopStmt = newNode(ASTNodes.LOOP_STATEMENT);
loopStmt.setBlock(block);
loopStmt.setCommand(query);
loopStmt.setCursorName(cursorName);
return loopStmt;
}
public DeclareStatement newDeclareStatement(ElementSymbol elementSymbol, String varType) {
DeclareStatement ds = newNode(ASTNodes.DECLARE_STATEMENT);
ds.setVariable(elementSymbol);
ds.setVariableType(varType);
return ds;
}
public DeclareStatement newDeclareStatement(ElementSymbol elementSymbol, String varType, Expression value) {
DeclareStatement ds = newDeclareStatement(elementSymbol, varType);
ds.setExpression(value);
return ds;
}
public StoredProcedure newStoredProcedure() {
StoredProcedure sp = newNode(ASTNodes.STORED_PROCEDURE);
return sp;
}
public SPParameter newSPParameter(int index, Expression expression) {
SPParameter parameter = new SPParameter(getTeiidVersion(), index, expression);
return parameter;
}
public SPParameter newSPParameter(int index, ISPParameter.ParameterInfo paramType, String name) {
SPParameter parameter = new SPParameter(getTeiidVersion(), index, paramType.index(), name);
return parameter;
}
public SubqueryFromClause newSubqueryFromClause(String name, Command command) {
SubqueryFromClause sfc = newNode(ASTNodes.SUBQUERY_FROM_CLAUSE);
sfc.setName(name);
sfc.setCommand(command);
return sfc;
}
public ArrayTable newArrayTable() {
ArrayTable arrayTable = newNode(ASTNodes.ARRAY_TABLE);
return arrayTable;
}
public BetweenCriteria newBetweenCriteria(Expression expression, Expression lowerExpression, Expression upperExpression) {
BetweenCriteria betweenCriteria = newNode(ASTNodes.BETWEEN_CRITERIA);
betweenCriteria.setLowerExpression(lowerExpression);
betweenCriteria.setUpperExpression(upperExpression);
betweenCriteria.setExpression(expression);
return betweenCriteria;
}
public Delete newDelete(GroupSymbol group, Criteria criteria) {
Delete delete = newNode(ASTNodes.DELETE);
delete.setGroup(group);
delete.setCriteria(criteria);
return delete;
}
public Insert newInsert() {
Insert insert = newNode(ASTNodes.INSERT);
return insert;
}
public Update newUpdate() {
Update update = newNode(ASTNodes.UPDATE);
return update;
}
public WhileStatement newWhileStatement(Criteria criteria, Block block) {
WhileStatement whileStatement = newNode(ASTNodes.WHILE_STATEMENT);
whileStatement.setBlock(block);
whileStatement.setCondition(criteria);
return whileStatement;
}
public WindowSpecification newWindowSpecification() {
WindowSpecification windowSpecification = newNode(ASTNodes.WINDOW_SPECIFICATION);
return windowSpecification;
}
public Into newInto(GroupSymbol group) {
Into into = newNode(ASTNodes.INTO);
into.setGroup(group);
return into;
}
public SearchedCaseExpression newSearchedCaseExpression(List<? extends Criteria> when, List<? extends Expression> then) {
SearchedCaseExpression sce = newNode(ASTNodes.SEARCHED_CASE_EXPRESSION);
sce.setWhen(when, then);
return sce;
}
public SetClause newSetClause(ElementSymbol symbol, Expression value) {
SetClause setClause = newNode(ASTNodes.SET_CLAUSE);
setClause.setSymbol(symbol);
setClause.setValue(value);
return setClause;
}
public SetClauseList newSetClauseList() {
SetClauseList setClauseList = newNode(ASTNodes.SET_CLAUSE_LIST);
return setClauseList;
}
public SetQuery newSetQuery(QueryCommand leftQuery, Operation operation, QueryCommand rightQuery, boolean all) {
SetQuery setQuery = newNode(ASTNodes.SET_QUERY);
setQuery.setAll(all);
setQuery.setLeftQuery(leftQuery);
setQuery.setOperation(operation);
setQuery.setRightQuery(rightQuery);
return setQuery;
}
public TextLine newTextLine() {
TextLine textLine = newNode(ASTNodes.TEXT_LINE);
return textLine;
}
public ExistsCriteria newExistsCriteria(QueryCommand queryCommand) {
ExistsCriteria existsCriteria = newNode(ASTNodes.EXISTS_CRITERIA);
existsCriteria.setCommand(queryCommand);
return existsCriteria;
}
public XMLParse newXMLParse() {
XMLParse xmlParse = newNode(ASTNodes.XML_PARSE);
return xmlParse;
}
public XMLQuery newXMLQuery() {
XMLQuery xmlQuery = newNode(ASTNodes.XML_QUERY);
return xmlQuery;
}
public XMLTable newXMLTable() {
XMLTable xmlTable = newNode(ASTNodes.XML_TABLE);
return xmlTable;
}
public XMLAttributes newXMLAttributes(List<DerivedColumn> args) {
XMLAttributes xmlAttributes = newNode(ASTNodes.XML_ATTRIBUTES);
xmlAttributes.setArgs(args);
return xmlAttributes;
}
public XMLColumn newXMLColumn(String name, boolean ordinal) {
XMLColumn xmlColumn = newNode(ASTNodes.XML_COLUMN);
xmlColumn.setName(name);
xmlColumn.setOrdinal(ordinal);
return xmlColumn;
}
public XMLSerialize newXMLSerialize() {
XMLSerialize xmlSerialize = newNode(ASTNodes.XML_SERIALIZE);
return xmlSerialize;
}
public XMLElement newXMLElement(String name, List<Expression> content) {
XMLElement xmlElement = newNode(ASTNodes.XML_ELEMENT);
xmlElement.setName(name);
xmlElement.setContent(content);
return xmlElement;
}
public XMLForest newXMLForest(List<DerivedColumn> derivedColumns) {
XMLForest xmlForest = newNode(ASTNodes.XML_FOREST);
xmlForest.setArguments(derivedColumns);
return xmlForest;
}
public XMLNamespaces newXMLNamespaces(List<NamespaceItem> namespaceItems) {
XMLNamespaces xmlNamespaces = newNode(ASTNodes.XML_NAMESPACES);
xmlNamespaces.setNamespaces(namespaceItems);
return xmlNamespaces;
}
public SubquerySetCriteria newSubquerySetCriteria(Expression expression, QueryCommand command) {
SubquerySetCriteria ssc = newNode(ASTNodes.SUBQUERY_SET_CRITERIA);
ssc.setExpression(expression);
ssc.setCommand(command);
return ssc;
}
public SubqueryCompareCriteria newSubqueryCompareCriteria(Expression expression, Query query, Operator operator, PredicateQuantifier quantifier) {
SubqueryCompareCriteria scc = newNode(ASTNodes.SUBQUERY_COMPARE_CRITERIA);
scc.setLeftExpression(expression);
scc.setOperator(operator);
scc.setPredicateQuantifier(quantifier);
scc.setCommand(query);
return scc;
}
public SetCriteria newSetCriteria(ElementSymbol symbol, List<Expression> values) {
SetCriteria sc = newNode(ASTNodes.SET_CRITERIA);
sc.setExpression(symbol);
sc.setValues(values);
return sc;
}
public ScalarSubquery newScalarSubquery(Query query) {
ScalarSubquery scalarSubquery = newNode(ASTNodes.SCALAR_SUBQUERY);
scalarSubquery.setCommand(query);
return scalarSubquery;
}
public Create newCreate() {
return newNode(ASTNodes.CREATE);
}
public Drop newDrop() {
return newNode(ASTNodes.DROP);
}
public Array newArray(Class<?> typeClass, List<Expression> args) {
Array array = newNode(ASTNodes.ARRAY);
array.setComponentType(typeClass);
array.setExpressions(args);
return array;
}
public JoinType newJoinType(Types joinKind) {
JoinType joinType = newNode(ASTNodes.JOIN_TYPE);
joinType.setKind(joinKind);
return joinType;
}
public CaseExpression newCaseExpression(ElementSymbol es, List<Expression> whenExpressions, List<Expression> thenExpressions) {
CaseExpression caseExpression = newNode(ASTNodes.CASE_EXPRESSION);
caseExpression.setExpression(es);
caseExpression.setWhen(whenExpressions, thenExpressions);
return caseExpression;
}
public abstract AggregateSymbol newAggregateSymbol(String name, boolean isDistinct, Expression expression);
public abstract WindowFunction newWindowFunction(String name);
public abstract Expression wrapExpression(Expression expr, String... exprName);
public abstract Statement newRaiseStatement(Expression expr);
}