package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.nodes.hana.TTimeTravel;
import gudusoft.gsqlparser.nodes.mssql.TForXMLClause;
import gudusoft.gsqlparser.nodes.mssql.TOptionClause;
import gudusoft.gsqlparser.nodes.teradata.TExpandOnClause;
import gudusoft.gsqlparser.nodes.hive.*;
import gudusoft.gsqlparser.nodes.teradata.THashByClause;
import gudusoft.gsqlparser.nodes.vertica.TTimeSeries;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

import java.util.ArrayList;

/**
 * Internal used by parser, reprsents raw parse tree node of select statement.
*/
public class TSelectSqlNode extends TParseTreeNode{

    private TForXMLClause forXMLClause;

    public void setForXMLClause(TForXMLClause forXMLClause) {
        this.forXMLClause = forXMLClause;
    }

    public TForXMLClause getForXMLClause() {
        return forXMLClause;
    }

    public void setRelationExpr(TRelationExpr relationExpr) {
        this.relationExpr = relationExpr;
    }

    /**
     * The relation of a {@code TABLE t} query (the SQL-standard shorthand for
     * {@code SELECT * FROM t}), or null when this node is not such a query.
     *
     * @return the relation named after the TABLE keyword
     */
    public TRelationExpr getRelationExpr() {
        return relationExpr;
    }

    private TRelationExpr relationExpr = null;

    /**
     * Give a {@code TABLE t} node the FROM list and select list of
     * {@code SELECT * FROM t}, which is what the SQL standard defines it to be,
     * so every consumer of a select (statement tables, resolver, lineage) sees
     * the relation and a wildcard result column instead of an empty select.
     * <p>
     * The wildcard is synthesized: its part token is typed
     * {@link ETokenType#ttasterisk} (wildcard identity comes from the token
     * type, never from the text) and placed at the TABLE keyword, but it is
     * not linked into the source token chain, so the text of this node and of
     * the statement still reads {@code TABLE t}.
     * <p>
     * Does nothing unless this node is a {@code TABLE t} query that has not
     * been expanded yet, so calling it again is harmless.
     */
    public void expandTableQuery() {
        if (relationExpr == null || resultColumnList != null || fromTableList != null
                || isCombinedQuery() || valueClause != null) {
            return;
        }

        TNodeFactory nf = new TNodeFactory(dbvendor);
        nf.setGsqlParser(getGsqlparser());

        TFromTable fromTable = (TFromTable) nf.createNode(ENodeType.T_FromTable.getId(), relationExpr);
        fromTable.setStartToken(relationExpr.getStartToken());
        fromTable.setEndToken(relationExpr.getEndToken());
        TFromTableList fromList = (TFromTableList) nf.createNode(ENodeType.T_FromTableList.getId(), fromTable);
        fromList.setStartToken(relationExpr.getStartToken());
        fromList.setEndToken(relationExpr.getEndToken());
        this.fromTableList = fromList;

        TSourceToken tableKeyword = tableQueryKeyword();
        TSourceToken star = new TSourceToken("*");
        star.tokentype = ETokenType.ttasterisk;
        star.tokencode = '*';
        if (tableKeyword != null) {
            star.lineNo = tableKeyword.lineNo;
            star.columnNo = tableKeyword.columnNo;
            star.offset = tableKeyword.offset;
            star.posinlist = tableKeyword.posinlist;
        }
        TObjectName starName = nf.createObjectName(null, null, star);
        TExpression starExpr = nf.createSimpleExpression(starName);
        TResultColumn starColumn = (TResultColumn) nf.createNode(ENodeType.T_ResultColumn.getId(), starExpr);
        starColumn.setStartToken(star);
        starColumn.setEndToken(star);
        TResultColumnList columns = (TResultColumnList) nf.createNode(ENodeType.T_ResultColumnList.getId(), starColumn);
        columns.setStartToken(star);
        columns.setEndToken(star);
        this.resultColumnList = columns;
    }

    /**
     * The TABLE keyword of a {@code TABLE t} query: every grammar builds it as
     * {@code RW_TABLE relation}, so it is the solid token right before the relation.
     */
    private TSourceToken tableQueryKeyword() {
        TSourceToken relationStart = relationExpr.getStartToken();
        if (relationStart == null) {
            return null;
        }
        TSourceToken keyword = relationStart.prevSolidToken();
        if (keyword != null && "TABLE".equalsIgnoreCase(keyword.toString())) { // non-identifier-compare: SQL keyword
            return keyword;
        }
        return relationStart;
    }

    private TClusterBy clusterBy;

    public void setClusterBy(TClusterBy clusterBy) {
        this.clusterBy = clusterBy;
    }

    public TClusterBy getClusterBy() {
        return clusterBy;
    }

    private boolean isConsume;

    public void setConsume(boolean consume) {
        isConsume = consume;
    }

    public boolean isConsume() {
        return isConsume;
    }

    public void setHiveFromQuery(boolean hiveFromQuery) {
        isHiveFromQuery = hiveFromQuery;
    }

    private boolean isHiveFromQuery = false;

    public boolean isHiveFromQuery() {
        return isHiveFromQuery;
    }

    public void setHiveBodyList(ArrayList<TParseTreeNode> hiveBodyList) {
        this.hiveBodyList = hiveBodyList;
    }

    /**
     * @deprecated since 2.6.3.5, insert and select statement after from query
     * is represented by {@link TSelectSqlNode#getSelectSqlNodes()} or {@link TInsertSqlNode#getInsertSqlNodes()}
     *
     * @return
     */
    public ArrayList<TParseTreeNode> getHiveBodyList() {
        return hiveBodyList;
    }

    private ArrayList<TParseTreeNode> hiveBodyList;



//    private TExpression skipOffset;
//    private TExpression firstMax;
//    private TExpression limitMax;
//
//    public void setSkipOffset(TExpression skipOffset) {
//        this.skipOffset = skipOffset;
//    }
//
//    public void setFirstMax(TExpression firstMax) {
//        this.firstMax = firstMax;
//    }
//
//    public void setLimitMax(TExpression limitMax) {
//        this.limitMax = limitMax;
//    }
//
//    /**
//     * Informix skip offset
//     * @return skip offset
//     */
//    public TExpression getSkipOffset() {
//
//        return skipOffset;
//    }
//
//    /**
//     * Informix first Max
//     * @return first Max
//     */
//    public TExpression getFirstMax() {
//        return firstMax;
//    }
//
//    /**
//     * Informix limit max
//     * @return limit max
//     */
//    public TExpression getLimitMax() {
//        return limitMax;
//    }

    private THashByClause hashByClause;

    public void setHashByClause(THashByClause hashByClause) {
        this.hashByClause = hashByClause;
    }

    public THashByClause getHashByClause() {
        return hashByClause;
    }

    private THavingClause havingClause;

    public void setHavingClause(THavingClause havingClause) {
        this.havingClause = havingClause;
        if (this.groupByClause != null){
            this.groupByClause.setHavingClause(havingClause.getCondition());
        }else{
            this.groupByClause = new TGroupBy();
            this.groupByClause.setHavingClause(havingClause.getCondition());
        }
    }

    public THavingClause getHavingClause() {
        return havingClause;
    }

    private TPTNodeList<TParseTreeNode> queryClauseList;

    public void setQueryClauseList(TPTNodeList<TParseTreeNode> queryClauseList) {
        this.queryClauseList = queryClauseList;
        for(int i=0;i<this.queryClauseList.size();i++){
            TParseTreeNode parseTreeNode = this.queryClauseList.getElement(i);
            if (parseTreeNode instanceof TFromTableList){
                //from clause
                this.setFromTableList((TFromTableList)parseTreeNode);
            }else if (parseTreeNode instanceof THashByClause){
                this.setHashByClause((THashByClause)parseTreeNode);
            }else if (parseTreeNode instanceof TWhereClause){
                this.setWhereCondition((TWhereClause)parseTreeNode);
            }else if (parseTreeNode instanceof TGroupBy){
                this.setGroupByClause((TGroupBy)parseTreeNode);
            }else if (parseTreeNode instanceof THavingClause){
                this.setHavingClause((THavingClause)parseTreeNode);
            }else if (parseTreeNode instanceof TQualifyClause){
                this.setQualifyClause((TQualifyClause)parseTreeNode);
            }else if (parseTreeNode instanceof TSampleClause){
                this.setSampleClause((TSampleClause)parseTreeNode);
            }else if (parseTreeNode instanceof TExpandOnClause){
                this.setExpandOnClause((TExpandOnClause)parseTreeNode);
            }else if (parseTreeNode instanceof TTeradataWithClause){
                this.setWithClause((TTeradataWithClause)parseTreeNode);
            }else if (parseTreeNode instanceof TOrderBy){
                this.setOrderbyClause((TOrderBy)parseTreeNode);
            }else if (parseTreeNode instanceof TIntoClause){
                this.setIntoClause((TIntoClause)parseTreeNode);
            }else if (parseTreeNode instanceof TClusterBy){
                this.setClusterBy((TClusterBy)parseTreeNode);
            }else if (parseTreeNode instanceof TDistributeBy){
                this.setDistributeBy((TDistributeBy)parseTreeNode);
            }else if (parseTreeNode instanceof TSortBy){
                this.setSortBy((TSortBy)parseTreeNode);
            }
        }
    }

    public void setSelectModifiers(ArrayList<TSelectModifier> selectModifiers) {
        this.selectModifiers = selectModifiers;
    }

    public ArrayList<TSelectModifier> getSelectModifiers() {
        return selectModifiers;
    }

    private ArrayList<TSelectModifier> selectModifiers;

    private TWithTableLock withTableLock;

    public void setWithTableLock(TWithTableLock withTableLock) {
        this.withTableLock = withTableLock;
    }

    public TWithTableLock getWithTableLock() {

        return withTableLock;
    }

    private TTimeSeries timeSeries;

    public void setTimeSeries(TTimeSeries timeSeries) {
        this.timeSeries = timeSeries;
    }

    public TTimeSeries getTimeSeries() {

        return timeSeries;
    }

    private TTimeTravel timeTravel; // hana
    private THintClause hintClause; //hana

    public TTimeTravel getTimeTravel() {
        return timeTravel;
    }

    public void setClauses(TPTNodeList<TParseTreeNode> clauses){
        for(int i=0;i<clauses.size();i++){
            TParseTreeNode node = clauses.getElement(i);
            if (node instanceof TForUpdate){
                this.forupdateClause = (TForUpdate)node;
            }else if (node instanceof TOrderBy){
                this.orderbyClause = (TOrderBy)node;
            }else if (node instanceof TLimitClause){
                this.limitClause  = (TLimitClause)node;
            }else if (node instanceof TTimeTravel){
                this.timeTravel = (TTimeTravel)node;
            }
        }
    }


    public void setHintClause(THintClause hintClause) {
        this.hintClause = hintClause;
    }

    public THintClause getHintClause() {

        return hintClause;
    }

    public int getParenthesisCount() {
        return parenthesisCount;
    }

    public void incParenthesisCount() {
       this.parenthesisCount++;
    }

    private int parenthesisCount = 0;
    private int parenthissisCountBeforeOrder = 0;


    public void setParenthesisCount(int parenthesisCount) {
        this.parenthesisCount = parenthesisCount;
    }

    public void setParenthissisCountBeforeOrder() {

        this.parenthissisCountBeforeOrder = parenthesisCount;
        parenthesisCount = 0;
    }

    public int getParenthissisCountBeforeOrder() {

        return parenthissisCountBeforeOrder;
    }

    private TOffsetClause offsetClause;

    public void setOffsetClause(TOffsetClause offsetClause) {
        this.offsetClause = offsetClause;
    }

    public TOffsetClause getOffsetClause() {

        return offsetClause;
    }

    public void setOptionClause(TOptionClause optionClause) {
        this.optionClause = optionClause;
    }

    public TOptionClause getOptionClause() {

        return optionClause;
    }

    /**
     * sql server option clause
     * @see gudusoft.gsqlparser.nodes.mssql.TOptionClause
     */
    private TOptionClause optionClause;

    private TLateralView lateralView;

    public void setLateralView(TLateralView lateralView) {
        this.lateralView = lateralView;
    }

    public TLateralView getLateralView() {

        return lateralView;
    }

    private TSortBy sortBy;

    public void setSortBy(TSortBy sortBy) {
        this.sortBy = sortBy;
    }

    public TSortBy getSortBy() {

        return sortBy;
    }

    private TDistributeBy distributeBy;

    public void setDistributeBy(TDistributeBy distributeBy) {
        this.distributeBy = distributeBy;
    }

    public TDistributeBy getDistributeBy() {

        return distributeBy;
    }

//    private THiveClusterBy hiveClusterBy;
//
//    public void setHiveClusterBy(THiveClusterBy hiveClusterBy) {
//        this.hiveClusterBy = hiveClusterBy;
//    }
//
//    public THiveClusterBy getHiveClusterBy() {
//
//        return hiveClusterBy;
//    }

    private THiveTransformClause transformClause;

    public THiveTransformClause getTransformClause() {
        return transformClause;
    }

    public void setTransformClause(THiveTransformClause transformClause) {
        this.transformClause = transformClause;
    }

    public void setHiveHintClause(THiveHintClause hiveHintClause) {
        this.hiveHintClause = hiveHintClause;
    }

    public THiveHintClause getHiveHintClause() {
        return hiveHintClause;
    }

    private THiveHintClause hiveHintClause;

    private TIntoTableClause intoTableClause;

    public void setIntoTableClause(TIntoTableClause intoTableClause) {
        this.intoTableClause = intoTableClause;
    }

    public TIntoTableClause getIntoTableClause() {

        return intoTableClause;
    }

    public void setSelectToken(TSourceToken selectToken) {
        this.selectToken = selectToken;
    }

    public TSourceToken getSelectToken() {

        return selectToken;
    }

    private TSourceToken selectToken = null;

    private TResultColumnList resultColumnList;

    public TSelectDistinct getSelectDistinct() {
        return selectDistinct;
    }

    public void setSelectDistinct(TSelectDistinct selectDistinct) {

        this.selectDistinct = selectDistinct;
    }

    private TSelectDistinct selectDistinct = null;

    public void setTopClause(TTopClause topClause) {
        this.topClause = topClause;
    }

    public TTopClause getTopClause() {

        return topClause;
    }

    private TTopClause topClause = null;

    public void setComputeClause(TComputeClause computeClause) {

        this.computeClause = computeClause;
    }

    public TComputeClause getComputeClause() {
        return computeClause;
    }

    private TComputeClause computeClause = null;
    
    public TResultColumnList getResultColumnList() {
        return resultColumnList;
    }

    public TFromTableList getFromTableList() {
        return fromTableList;
    }

    public TWhereClause getWhereCondition() {
        return whereCondition;
    }

    private TFromTableList fromTableList;

    public void setResultColumnList(TResultColumnList resultColumnList) {
        this.resultColumnList = resultColumnList;
    }

    public void setFromTableList(TFromTableList fromTableList) {
        this.fromTableList = fromTableList;
    }

    public void setWhereCondition(TWhereClause whereCondition) {
        this.whereCondition = whereCondition;
    }

    private TWhereClause whereCondition;

    private TSelectSqlNode leftNode,rightNode;

    public TCTEList cteList;

    public TCTEList getCteList() {
        return cteList;
    }

    // Oracle 12c WITH FUNCTION/PROCEDURE support - inline PL/SQL definitions
    private TStatementListSqlNode withPlsqlItems;

    public TStatementListSqlNode getWithPlsqlItems() {
        return withPlsqlItems;
    }

    public void setWithPlsqlItems(TStatementListSqlNode withPlsqlItems) {
        this.withPlsqlItems = withPlsqlItems;
    }

    public int getSetOperator() {
        return setOperator;
    }

    private int setOperator = 0;
    private boolean setOperatorByName = false;

    public void setSetOperator(int setOperator) {
        this.setOperator = setOperator;
    }

    /**
     * Returns true if the set operator uses BY NAME matching (Snowflake).
     * When BY NAME is used, columns are matched by their names rather than positions.
     */
    public boolean isSetOperatorByName() {
        return setOperatorByName;
    }

    /**
     * Sets whether the set operator uses BY NAME matching.
     */
    public void setSetOperatorByName(boolean byName) {
        this.setOperatorByName = byName;
    }

    public void setSetOperator(TSourceToken st1, TSourceToken st2)
    {
        if (st1.toString().equalsIgnoreCase("union")){
            if (st2 == null){
                this.setOperator = TSelectSqlStatement.setOperator_union;
            }else if (st2.toString().equalsIgnoreCase("all")){
                this.setOperator = TSelectSqlStatement.setOperator_unionall;
            }else if (st2.toString().equalsIgnoreCase("distinct")){
                this.setOperator = TSelectSqlStatement.SET_OPERATOR_UNIONDISTINCT;
            }
        }
        else if (st1.toString().equalsIgnoreCase("intersect")){
            if (st2 == null){
                this.setOperator = TSelectSqlStatement.setOperator_intersect;
            }else if (st2.toString().equalsIgnoreCase("all")){
                this.setOperator = TSelectSqlStatement.setOperator_intersectall;
            }else if (st2.toString().equalsIgnoreCase("distinct")){
                this.setOperator = TSelectSqlStatement.SET_OPERATOR_INTERSECTDISTINCT;
            }
        }
        else if (st1.toString().equalsIgnoreCase("minus")){
            if (st2 == null){
                this.setOperator = TSelectSqlStatement.setOperator_minus;
            }else if (st2.toString().equalsIgnoreCase("all")){
                this.setOperator = TSelectSqlStatement.setOperator_minusall;
            }else if (st2.toString().equalsIgnoreCase("distinct")){
                this.setOperator = TSelectSqlStatement.SET_OPERATOR_MINUSDISTINCT;
            }
        }
        else if (st1.toString().equalsIgnoreCase("except")){
            if (st2 == null){
                this.setOperator = TSelectSqlStatement.setOperator_except;
            }else if (st2.toString().equalsIgnoreCase("all")){
                this.setOperator = TSelectSqlStatement.setOperator_exceptall;
            }else if (st2.toString().equalsIgnoreCase("distinct")){
                this.setOperator = TSelectSqlStatement.SET_OPERATOR_EXCEPTDISTINCT;
            }
        }
    }

    public TSelectSqlNode getLeftNode() {
        return leftNode;
    }

    public TSelectSqlNode getRightNode() {
        return rightNode;
    }

    public void init(Object arg1, Object arg2)
    {
        leftNode = (TSelectSqlNode)arg1;
        rightNode = (TSelectSqlNode)arg2;
    }

    public boolean isCombinedQuery(){
    // combine multiple queries using the set operators UNION, UNION ALL, INTERSECT, and MINUS.
        return (setOperator > 0);
    }

    public TOrderBy getOrderbyClause() {
        return orderbyClause;
    }

    private TOrderBy orderbyClause;

    public void setOrderbyClause(TOrderBy orderbyClause) {
        this.orderbyClause = orderbyClause;
        if  (orderbyClause == null) return;

        if (orderbyClause.getOffsetClause() != null ){ // 在 sqlserver yacc rule中， offset clause 先被挂在了order by clause 下
            this.setOffsetClause(orderbyClause.getOffsetClause());
        }
        if (orderbyClause.getFetchFirstClause() != null){
            this.setFetchFirstClause(orderbyClause.getFetchFirstClause());
        }

    }

    public TForUpdate getForupdateClause() {
        return forupdateClause;
    }

    private TForUpdate forupdateClause;

    public void setForupdateClause(TParseTreeNode forupdateClause) {
        if (forupdateClause instanceof TForUpdate){
            this.forupdateClause = (TForUpdate) forupdateClause;
        }else if (forupdateClause instanceof TForXMLClause){
            this.forXMLClause = (TForXMLClause)forupdateClause;
        }
    }

    public THierarchical getHierarchicalClause() {
        return hierarchicalClause;
    }

    private THierarchical hierarchicalClause;

    public void setHierarchicalClause(THierarchical hierarchicalClause) {
        this.hierarchicalClause = hierarchicalClause;
    }

    public TGroupBy getGroupByClause() {
        return groupByClause;
    }

    private TGroupBy groupByClause;

    public void setGroupByClause(TGroupBy groupByClause) {
        this.groupByClause = groupByClause;
        if (groupByClause != null){
            if ((groupByClause.getQualifyClause() != null)&&(this.getQualifyClause() == null)){
                this.setQualifyClause(groupByClause.getQualifyClause());
            }
            if ((this.getHavingClause() != null)&&(this.groupByClause.getHavingClause() == null)){
                this.groupByClause.setHavingClause(this.getHavingClause().getCondition());
            }
        }
    }

    private TIntoClause intoClause = null;

    public void setIntoClause(TIntoClause intoClause) {
        if (intoClause == null) return;
        this.intoClause = intoClause;
    }

    public TIntoClause getIntoClause() {

        return intoClause;
    }

    private TQualifyClause qualifyClause = null;

    public void setQualifyClause(TQualifyClause qualifyClause) {
        if (qualifyClause == null) return;
        this.qualifyClause = qualifyClause;
    }

    public TQualifyClause getQualifyClause() {

        return qualifyClause;
    }

    private TSampleClause sampleClause = null;

    public void setSampleClause(TSampleClause sampleClause) {
        this.sampleClause = sampleClause;
    }

    public TSampleClause getSampleClause() {

        return sampleClause;
    }

    private TTeradataWithClause withClause = null;

    public TTeradataWithClause getWithClause() {
        return withClause;
    }

    public void setWithClause(TTeradataWithClause withClause) {

        this.withClause = withClause;
    }

    private TLimitClause limitClause = null;

    public void setLimitClause(TLimitClause limitClause) {
        this.limitClause = limitClause;
    }

    public TLimitClause getLimitClause() {

        return limitClause;
    }

    private TFetchFirstClause fetchFirstClause = null;

    public void setFetchFirstClause(TFetchFirstClause fetchFirstClause) {
        this.fetchFirstClause = fetchFirstClause;
    }

    public TFetchFirstClause getFetchFirstClause() {

        return fetchFirstClause;
    }

    private TOptimizeForClause optimizeForClause = null;

    public void setOptimizeForClause(TOptimizeForClause optimizeForClause) {
        this.optimizeForClause = optimizeForClause;
    }

    public TOptimizeForClause getOptimizeForClause() {

        return optimizeForClause;
    }

    private TIsolationClause isolationClause = null;

    public void setIsolationClause(TIsolationClause isolationClause) {
        this.isolationClause = isolationClause;
    }

    public TIsolationClause getIsolationClause() {
        return isolationClause;
    }

    public void setValueClause(TValueClause valueClause) {
        this.valueClause = valueClause;
        this.setStartToken(valueClause);
        this.setEndToken(valueClause);
    }

    public TValueClause getValueClause() {

        return valueClause;
    }

    private TValueClause valueClause = null;

    private TPTNodeList <TLockingClause> lockingClauses;

    public TPTNodeList<TLockingClause> getLockingClauses() {
        return lockingClauses;
    }

    public void setLockingClauses(TPTNodeList<TLockingClause> lockingClauses) {
        this.lockingClauses = lockingClauses;
    }

//    private TSelectLimit selectLimit;
//
//    public void setSelectLimit(TSelectLimit selectLimit) {
//        this.selectLimit = selectLimit;
//    }
//
//    public TSelectLimit getSelectLimit() {
//
//        return selectLimit;
//    }

    private  TWindowClause  windowClause;

    public void setWindowClause(TWindowClause windowClause) {
        this.windowClause = windowClause;
    }

    public TWindowClause getWindowClause() {

        return windowClause;
    }

    private TExpandOnClause expandOnClause;

    public TExpandOnClause getExpandOnClause() {
        return expandOnClause;
    }

    public void setExpandOnClause(TExpandOnClause expandOnClause) {

        this.expandOnClause = expandOnClause;
    }

    public static void setFromList(ArrayList<TSelectSqlNode> selectSqlNode, TFromTableList fromTables){
        for(int i=0;i<selectSqlNode.size();i++){
            TSelectSqlNode select = selectSqlNode.get(i);
            select.setFromTableList(fromTables);
        }
    }

    private ArrayList<TSelectSqlNode> selectSqlNodes;

    public ArrayList<TSelectSqlNode> getSelectSqlNodes() {
        return selectSqlNodes;
    }

    public void setSelectSqlNodes(ArrayList<TSelectSqlNode> selectSqlNodes){
        this.selectSqlNodes = selectSqlNodes;
    }

    public static TSelectSqlNode getFirstSelectSqlNode(ArrayList<TSelectSqlNode> selectSqlNodes){
        return  selectSqlNodes.get(0);
    }

    // StarRocks pipe operator support
    private TPTNodeList<TParseTreeNode> pipeOperators;
    private boolean isPipeQuery = false;

    public TPTNodeList<TParseTreeNode> getPipeOperators() {
        return pipeOperators;
    }

    public void setPipeOperators(TPTNodeList<TParseTreeNode> pipeOperators) {
        this.pipeOperators = pipeOperators;
    }

    public boolean isPipeQuery() {
        return isPipeQuery;
    }

    public void setIsPipeQuery(boolean isPipeQuery) {
        this.isPipeQuery = isPipeQuery;
    }

}