package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.scriptWriter.TScriptGenerator;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.util.gspMD5Utils;

import java.util.ArrayList;
import java.util.Iterator;

import static java.nio.charset.StandardCharsets.UTF_8;

/**
 * This class is the root class for all syntax/parse tree nodes.
 * A syntax/parse tree node is composed of a sequence of tokens generated by the lexer.
 * <p>
 * The syntax node usually includes sub-nodes such as a where clause including expression node.
 *
 * <br> Check {@link #getNodeType()} for type of this node.
 * <br> This node includes all tokens from {@link #getStartToken() start token} and {@link #getEndToken() end token}
 */

public abstract class TParseTreeNode implements Visitable,Iterator<TSourceToken>{

    public void setEvaluateDatatype(Class<?> evaluateDatatype) {
        this.evaluateDatatype = evaluateDatatype;
    }

    /**
     *  Support String, Integer, Double and Boolean type
     *
     * @return
     */
    public Class<?> getEvaluateDatatype() {
        return evaluateDatatype;
    }

    private Class<?> evaluateDatatype;
    private Object evalValue;

    public void setEvalValue(Object evalValue) {
        this.evalValue = evalValue;
    }

    public Object getEvalValue() {
        return evalValue;
    }

    private String plainText = null;

    public void setPlainText(String plainText) {
        this.plainText = plainText;
    }

    public String getPlainText() {
        if (plainText == null){
            return toString();
        }else{
            return plainText;
        }
    }

    private ESqlClause location = ESqlClause.unknown;

    public void setLocation(ESqlClause location) {
        this.location = location;
    }

    /**
     * SQL clause that include this objectName such as select list, from clause, set clause
     *
     * @return SQL clause that include this objectName
     */
    public ESqlClause getLocation() {
        return location;
    }

    private String compactString = null;

    /**
     * representation of this node by removing all spaces, return and comments
     * @return string representation of this node by removing all spaces, return and comments
     */
    public String getCompactString(){
        if (compactString != null) return compactString;

        StringBuilder sb = new StringBuilder();
        TSourceToken st = null;
        currentIterateToken = null;
        while (this.hasNext()){
            st = next();
            if ((st.tokencode == TBaseType.lexspace)||(st.tokencode == TBaseType.lexnewline)
                    ||(st.tokencode == TBaseType.cmtslashstar)||(st.tokencode == TBaseType.cmtdoublehyphen)
            ) {
                continue;
            }else{
                sb.append(st.toString());
            }
        }

        compactString = sb.toString();
        return compactString;
    }

    private String md5 = null;
    /**
     *  md5 hash code of the string representation of this node.
     *  If the string of this node is empty, return the md5 value of the class name of this node.
     *
     *  1. remove all spaces, return, comments inside the node<br>
     *  2. turn number constant in where clause into ? character. <br>
     *  3. turn string constant in where clause into ?? character. <br>
     *  4. turn all string of the token into uppercase if it's not a delimited identifier.
     *
     * @return md5 hash code of the string representation of this node
     */
    public String getMd5(){
        if (md5 != null) return md5;

        StringBuilder sb = new StringBuilder();
        TSourceToken st = null;
        currentIterateToken = null;
        while (this.hasNext()){
            st = next();
            // cmtslashstar lexspace lexnewline cmtdoublehyphen
            if ((st.tokencode == TBaseType.lexspace)||(st.tokencode == TBaseType.lexnewline)
                    ||(st.tokencode == TBaseType.cmtslashstar)||(st.tokencode == TBaseType.cmtdoublehyphen)
            ){
                continue;
            } else if ((st.tokencode == TBaseType.fconst)||(st.tokencode == TBaseType.iconst)){
                if (st.location == ESqlClause.where){
                    sb.append("?");
                }else{
                    sb.append(st.toString());
                }
            } else if (st.tokencode == TBaseType.sconst){
                if (st.location == ESqlClause.where){
                    sb.append("??");
                }else{
                    sb.append(st.toString());
                }
            } else if (TSQLEnv.isDelimitedIdentifier(this.dbvendor,st.toString())){
                sb.append(st.toString());
            }else {
                sb.append(st.toString().toUpperCase());
            }
        }
        byte[] md5InBytes;
        if (sb.toString().length() > 0){
            md5InBytes = gspMD5Utils.digest(sb.toString().getBytes(UTF_8));
        }else{
            md5InBytes = gspMD5Utils.digest(this.getClass().getName() .getBytes(UTF_8));
        }
        md5 = gspMD5Utils.bytesToHex(md5InBytes);
        return md5;

    }

    public TParseTreeNode getParentObjectName() {
        return parent;
    }

    public void setParent(TParseTreeNode parent) {
        this.parent = parent;
    }

    private TParseTreeNode parent = null;

//    public void  appendAToken(TSourceToken st){
//        // this token is not belonged to this node
//        this.getEndToken()
//    }
    public static boolean doubleLinkedTokenListToString = true;

//    TSourceToken st = getStartToken();
//    TSourceToken et = getEndToken();
    public void insertAfterAToken(TSourceToken anchorToken){
        if ((anchorToken == null)||(this.getEndToken() == null)||(this.getStartToken() == null) )return;
        this.getEndToken().setNextTokenInChain(anchorToken.getNextTokenInChain());
        if (anchorToken.getNextTokenInChain() != null){
            anchorToken.getNextTokenInChain().setPrevTokenInChain(this.getEndToken());
        }else{
            if (anchorToken.getNodesEndWithThisToken().size() > 0){
                for(Object o:anchorToken.getNodesEndWithThisToken()){
                    TParseTreeNode node = (TParseTreeNode)o;
                    node.setEndToken(this.getEndToken());
                }
            }
        }
        anchorToken.setNextTokenInChain(this.getStartToken());
        this.getStartToken().setPrevTokenInChain(anchorToken);

    }

   public void insertNewNodeBeforeMe(TParseTreeNode newNode, boolean needCommaBefore){

       updateNodeWithTheSameStartToken(nodeActionInsert,newNode.getStartToken());

       newNode.getStartToken().setPrevTokenInChain(this.getStartToken().getPrevTokenInChain());
       if (this.getStartToken().getPrevTokenInChain() != null){
           this.getStartToken().getPrevTokenInChain().setNextTokenInChain(newNode.getStartToken());
       }

       newNode.getEndToken().setNextTokenInChain(this.getStartToken());
       this.getStartToken().setPrevTokenInChain(newNode.getEndToken());

       if (needCommaBefore) {
           TSourceToken commaToken = new TSourceToken(",");
           newNode.getEndToken().insertANewTokenAfterMe(commaToken);
       }

   }

   public void appendNewNode(TParseTreeNode newNode, boolean needCommaBefore){
        // the new node must be share the same parent node with this node

       refreshAllNodesTokenCount();
       updateMeNodeWithTheSameEndToken(nodeActionAppend,newNode.getEndToken());

       newNode.getEndToken().setNextTokenInChain(this.getEndToken().getNextTokenInChain());
       if (this.getEndToken().getNextTokenInChain() != null){
           this.getEndToken().getNextTokenInChain().setPrevTokenInChain(newNode.getEndToken());
       }

       newNode.getStartToken().setPrevTokenInChain(this.getEndToken());
       this.getEndToken().setNextTokenInChain(newNode.getStartToken());

       if (needCommaBefore) {
           TSourceToken commaToken = new TSourceToken(",");
           this.getEndToken().insertANewTokenAfterMe(commaToken);
       }

   }

   public void replaceWithNewNode(TParseTreeNode newNode){
       if ((getStartToken() == null)||(getEndToken() == null)) return;
       if ((newNode.getStartToken() == null)||(newNode.getEndToken() == null)) return;

       if (getStartToken().getPrevTokenInChain() == null) return;

       refreshAllNodesTokenCount();
       updateNodeWithTheSameStartToken(nodeActionUpdate,newNode.startToken);
       updateMeNodeWithTheSameEndToken(nodeActionUpdate,newNode.endToken);

       getStartToken().getPrevTokenInChain().setNextTokenInChain(newNode.getStartToken());
       newNode.getStartToken().setPrevTokenInChain(getStartToken().getPrevTokenInChain());

       newNode.getEndToken().setNextTokenInChain(getEndToken().getNextTokenInChain());
       if (getEndToken().getNextTokenInChain() != null){
           getEndToken().getNextTokenInChain().setPrevTokenInChain(newNode.getEndToken());
       }

   }



    TSourceToken currentIterateToken = null;


    public void resetIterator(){
        currentIterateToken = null;
    }

    @Override
    public boolean hasNext() {
        if ((getStartToken() != null)&&(getEndToken() != null)&&(currentIterateToken != getEndToken())){
            return true;
        }
        else{
            return false;
        }

    }

    @Override
    public TSourceToken next() {
        if (this.hasNext()){
            if (currentIterateToken == null){
                currentIterateToken = getStartToken();
            }else {
                currentIterateToken = currentIterateToken.getNextTokenInChain();
            }

            return currentIterateToken;
        }
        else
            return null;
    }

    @Override
    public void remove() {
        throw new UnsupportedOperationException();
    }

//    @Override
//    public Iterator<TSourceToken> iterator() {
//        return new TokenSetIterator();
//    }
//
//    private class TokenSetIterator implements Iterator {
//        TSourceToken st = getStartToken();
//        TSourceToken et = getEndToken();
//        TSourceToken currentToken = null;
//
//         public boolean hasNext() {
//            if ((st != null)&&(et != null)&&(currentToken != et)){
//                return true;
//            }
//            else
//                return false;
//        }
//
//        public TSourceToken next() {
//            if (this.hasNext()){
//                if (currentToken == null){
//                    currentToken = st;
//                }else {
//                    currentToken = currentToken.getNextTokenInChain();
//                }
//
//                return currentToken;
//            }
//            else
//                return null;
//        }
//
//        @Override
//        public void remove() {
//
//        }
//    }

    public void setNodeStatus(ENodeStatus nodeStatus) {
        this.nodeStatus = nodeStatus;
    }

    public ENodeStatus getNodeStatus() {

        return nodeStatus;
    }

    private ENodeStatus nodeStatus = ENodeStatus.nsNormal;



    public void addToTokenChain(TSourceToken anchorToken, boolean beforeAnchorToken){

    };

    private int tokenCount = -1;

    public int getTokenCount() {
        if (tokenCount == -1){
            calculateTokenCount();
        }
        return tokenCount;
    }

    public void refreshAllNodesTokenCount(){
        if (this.startToken != null){
            for(int i=0;i<this.startToken.getNodesStartFromThisToken().size();i++){
                TParseTreeNode node = this.startToken.getNodesStartFromThisToken().get(i);
                node.calculateTokenCount();
            }
        }

        if (this.endToken != null){
            for(int i=0;i<this.endToken.getNodesEndWithThisToken().size();i++){
                TParseTreeNode node = this.endToken.getNodesEndWithThisToken().get(i);
                node.calculateTokenCount();
            }
        }

    }

    public void calculateTokenCount(){
        int ret = 0;
        TSourceToken prevst = null;
        this.resetIterator();
        while (this.hasNext()){
            ret++;
            TSourceToken st = this.next();
            if (st == null){
                if (TBaseType.DEBUG){
                    System.out.println("==========ERROR: start and token is not in the same chain  ===============\n");
                    System.out.println("Start Token:"+this.getStartToken().toString());
                    System.out.println("End Token:"+this.getEndToken().toString());
                    if (prevst != null){
                        System.out.println("Prev token, code:"+prevst.tokencode+", Text:"+prevst.toString());
                    }else{
                        System.out.println("Prev token is null");
                    }
                    System.out.println("============================\n");
                }
                break;
            }
            prevst = st;
        }
        this.resetIterator();
        this.tokenCount = ret;
    }

    public final static int nodeActionUnknown = 0;
    public final static int nodeActionRemove = 1;
    public final static int nodeActionInsert = 2;
    public final static int nodeActionUpdate = 3;
    public final static int nodeActionUpdateText = 4;
    public final static int nodeActionAppend = 5;
    public final static int nodeChangeStartToken = 6;
    public final static int nodeChangeEndToken = 7;

    void updateStatusOfNodeShareSameTokens(int nodeAction){
        TSourceToken startToken = getStartToken();
        TSourceToken endToken = getEndToken();
        if (endToken == null) return;
        if (startToken == null) return;

        // System.out.println("node token count:"+thisNodeTokenCount);
        this.resetIterator();
        while(this.hasNext()){
            TSourceToken st = this.next();
           // System.out.println(st.toString());
            if (st == null) break;

            for(int i=0;i<st.getNodesStartFromThisToken().size();i++){
                TParseTreeNode node = st.getNodesStartFromThisToken().get(i);
                if (st == startToken){
                    if (this == node){
                        switch (nodeAction){
                            case nodeActionRemove:
                                node.nodeStatus = ENodeStatus.nsRemoved;
                                break;
                            default:
                                node.nodeStatus = ENodeStatus.nsDetached;
                                break;
                        }
                    }else if (node.getTokenCount() == this.getTokenCount()){
                        switch (nodeAction){
                            case nodeActionRemove:
                                node.nodeStatus = ENodeStatus.nsRemoved;
                                break;
                            default:
                                node.nodeStatus = ENodeStatus.nsDetached;
                                break;
                        }
                    }else if (node.getTokenCount() > this.getTokenCount()){
                        node.nodeStatus = ENodeStatus.nsPartitial;
                    }else{
                        node.nodeStatus = ENodeStatus.nsDetached;
                    }
                }else{
                    node.nodeStatus = ENodeStatus.nsDetached;
                }
            }

            for(int i=0;i<st.getNodesEndWithThisToken().size();i++){
                TParseTreeNode node = st.getNodesEndWithThisToken().get(i);
                if (st == endToken){
                    if (this == node){
                        switch (nodeAction){
                            case nodeActionRemove:
                                node.nodeStatus = ENodeStatus.nsRemoved;
                                break;
                            default:
                                node.nodeStatus = ENodeStatus.nsDetached;
                                break;
                        }
                    }else if (node.getTokenCount() == this.getTokenCount()){
                        switch (nodeAction){
                            case nodeActionRemove:
                                node.nodeStatus = ENodeStatus.nsRemoved;
                                break;
                            default:
                                node.nodeStatus = ENodeStatus.nsDetached;
                                break;
                        }
                    }else if (node.getTokenCount() > this.getTokenCount()){
                        node.nodeStatus = ENodeStatus.nsPartitial;
                    }else{
                        switch (nodeAction){
                            case nodeActionRemove:
                                node.nodeStatus = ENodeStatus.nsRemoved;
                                break;
                            default:
                                node.nodeStatus = ENodeStatus.nsDetached;
                                break;
                        }
                    }
                }else{
                    switch (nodeAction){
                        case nodeActionRemove:
                            node.nodeStatus = ENodeStatus.nsRemoved;
                            break;
                        default:
                            node.nodeStatus = ENodeStatus.nsDetached;
                            break;
                    }
                }
            }

        }
        this.resetIterator();
    }

    void updateNodeWithTheSameStartToken(int nodeAction, TSourceToken newStartToken){
        TSourceToken oldStartToken = this.getStartToken();
        for(int i=0;i<oldStartToken.getNodesStartFromThisToken().size();i++){
            TParseTreeNode node = oldStartToken.getNodesStartFromThisToken().get(i);
            if (node == this){ // myself
                switch (nodeAction){
                    case nodeActionRemove:
                        node.startToken = null;
                        break;
                    case nodeActionUpdate:
                    case nodeActionUpdateText:
                    case nodeChangeStartToken:
                        node.startToken = newStartToken;
                        newStartToken.getNodesStartFromThisToken().push(node);
                    default:
                        break;
                }
            }else if((node.getTokenCount() == this.getTokenCount())){ // node with same tokens
                switch (nodeAction){
                    case nodeActionRemove:
                        node.startToken = null;
                        break;
                    case nodeActionUpdate:
                    case nodeActionUpdateText:
                    case nodeChangeStartToken:
                        node.startToken = newStartToken;
                        newStartToken.getNodesStartFromThisToken().push(node);
                    default:
                        break;
                }
            }
            else if((node.getTokenCount() > this.getTokenCount())) { // parent node
                node.startToken = newStartToken;
                newStartToken.getNodesStartFromThisToken().push(node);
            }else{ // sub node

            }
        }
    }

    void updateMeNodeWithTheSameEndToken(int nodeAction, TSourceToken newEndToken){
        TSourceToken oldEndToken = this.getEndToken();
        for(int i=0;i<oldEndToken.getNodesEndWithThisToken().size();i++){
            TParseTreeNode node = oldEndToken.getNodesEndWithThisToken().get(i);
            if (node == this){ // myself
                switch (nodeAction){
                    case nodeActionRemove:
                        node.endToken = null;
                        break;
                    case nodeActionUpdate:
                    case nodeActionUpdateText:
                    case nodeChangeEndToken:
                        node.endToken = newEndToken;
                        newEndToken.getNodesEndWithThisToken().push(node);
                    default:
                        break;
                }
            }else if((node.getTokenCount() == this.getTokenCount())){ // node with same tokens
                switch (nodeAction){
                    case nodeActionRemove:
                        node.endToken = null;
                        break;
                    case nodeActionUpdate:
                    case nodeActionUpdateText:
                    case nodeChangeEndToken:
                        node.endToken = newEndToken;
                        newEndToken.getNodesEndWithThisToken().push(node);
                    default:
                        break;
                }
            }
            else if((node.getTokenCount() > this.getTokenCount())) { // parent node
                node.endToken = newEndToken;
                newEndToken.getNodesEndWithThisToken().push(node);
            }else{ // sub node

            }
        }
    }

    /**
     * both begin and end token will be removed from the chain
     *
     * @param startToken
     * @param endToken
     */
    public static void removeTokensBetweenToken(TSourceToken startToken, TSourceToken endToken){
       if ((startToken == null)||(endToken == null)) return;
        startToken.removeFromChain();
        while (startToken != endToken){
            startToken = startToken.getNextTokenInChain();
            if (startToken == null) break;
            startToken.removeFromChain();
        }
    }

    public static void removeTokensBetweenNodes(TParseTreeNode startNode, TParseTreeNode endNode){
        if ((startNode == null)||(endNode == null)) return;
        if ((startNode.getEndToken() == null)||(endNode.getStartToken() == null)) return;
        TSourceToken startToken = startNode.getEndToken().getNextTokenInChain();
        TSourceToken endToken  = endNode.getStartToken().getPrevTokenInChain();
        if ((startToken == null)||(endToken == null)) return;

        startToken.removeFromChain();
        while (startToken != endToken){
            startToken = startToken.getNextTokenInChain();
            if (startToken == null) break;
            startToken.removeFromChain();
        }
    }

    public void removeTokens(){
        if (this.nodeStatus == ENodeStatus.nsRemoved) return;

        TSourceToken oldStartToken = getStartToken();
        TSourceToken oldEndToken = getEndToken();
        if (oldEndToken == null) return;
        if (oldStartToken == null) return;

        refreshAllNodesTokenCount();
        updateStatusOfNodeShareSameTokens(nodeActionRemove);

        if (oldStartToken.getPrevTokenInChain() != null){
            updateMeNodeWithTheSameEndToken(nodeActionRemove,oldStartToken.getPrevTokenInChain());
            oldStartToken.getPrevTokenInChain().setNextTokenInChain(oldEndToken.getNextTokenInChain());
        }
        if (oldEndToken.getNextTokenInChain() != null){
            updateNodeWithTheSameStartToken(nodeActionRemove,oldEndToken.getNextTokenInChain());
            oldEndToken.getNextTokenInChain().setPrevTokenInChain(oldStartToken.getPrevTokenInChain());
        }

        if (this.nodeStatus == ENodeStatus.nsNormal){
            this.nodeStatus = ENodeStatus.nsRemoved;
        }

        this.setStartTokenDirectly(null);
        this.setEndTokenDirectly(null);

    }



    /**
     * SQL dialect of this statement.
     */
    public EDbVendor dbvendor = EDbVendor.dbvgeneric;

    /**
     * The parser that generate this node.
     *
     * @return parser that generate this node
     */
    public TGSqlParser getGsqlparser() {
        if (gsqlparser == null){
            if (getStartToken() != null){
                // TODO  removed in 2.6.8.1, to avoid memory leak in TTypeName
                // gsqlparser = getStartToken().getGsqlparser();
            }
        }
        return gsqlparser;
    }

    boolean includingComment = true;


    public void setIncludingComment(boolean includingComment) {
        this.includingComment = includingComment;
    }

    private TGSqlParser gsqlparser = null;

    public void setGsqlparser(TGSqlParser gsqlparser) {
        this.gsqlparser = gsqlparser;
        if (gsqlparser != null){
            this.dbvendor = gsqlparser.getDbVendor();
        }
    }

    private int dummyTag = 0;

    public void setDummyTag(int dummyTag) {
        this.dummyTag = dummyTag;
    }

    /**
     * A temporary value can be used for any purposes
     *
     * @return a temporary value used for any purposes
     */
    public int getDummyTag() {
        return dummyTag;
    }


    private TSourceToken startToken;

    /**
     * The first token in this parse tree node
     *
     * @return the first token of node
     */
    public TSourceToken getStartToken() {
        return startToken;
    }

    /**
     * The last token of the node
     *
     * @return the last token of node
     */
    public TSourceToken getEndToken() {
        return endToken;
    }

    private TSourceToken endToken;
    private long lineNo = -1;

    /**
     * Column position of the first token of this node
     *
     * @return column position
     */
    public long getColumnNo() {
        if (this.getStartToken() != null){
            columnNo = this.getStartToken().columnNo;
        }
        return columnNo;
    }

    /**
     * Line number of the first token of this node
     *
     * @return line number
     */
    public long getLineNo() {
        if (this.getStartToken() != null){
            lineNo = this.getStartToken().lineNo;
        }
        return lineNo;
    }

    private long columnNo = -1;

    private int nodeType;
    /**
         * Set the node type for this node.
         *
         * @param nodeType The node type.
         */
        public void setNodeType(int nodeType)
        {
                this.nodeType = nodeType;
        }

    /**
     * A unique value to distinguish this node from others
     *
     * @return enum value of node type
     * @see gudusoft.gsqlparser.nodes.ENodeType
     */
        public int getNodeType()
        {
                return nodeType;
        }

    String getastext(){ return "";}
    String getasprettytext(){ return "";}

    /**
     * Initialize a query tree node.
     * Used internally
     *
     * @param arg1 first argument
     */
    public void init(Object arg1)
    {
    }

    public void init(Object arg1, Object arg2)
    {
    }

    public void init(Object arg1, Object arg2, Object arg3)
    {
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4)
    {
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5)
    {
    }

    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6)
    {
    }

    /**
     * Analyze the sub-nodes inside this node.
     * Such as build the relationship between table and column.
     *
     * @param psql          SQL statement this node belongs to
     * @param plocation    SQL clause this node belongs to
     */
    public void doParse(TCustomSqlStatement psql, ESqlClause plocation){
        
    }

    public void setStartToken(ArrayList startNode) {
        if (startNode == null) return;
        if (startNode.size() == 0) return;
        TParseTreeNode parseTreeNode = (TParseTreeNode)startNode.get(0);
        this.setStartToken(parseTreeNode.getStartToken());
    }

    public void setEndToken(ArrayList endNode) {
        if (endNode == null) return;
        if (endNode.size() == 0 ) return;
        TParseTreeNode parseTreeNode = (TParseTreeNode)endNode.get(endNode.size()-1);
        this.setEndToken(parseTreeNode.getEndToken());
    }

    public void setStartToken(TSourceToken newStartToken) {
        if (newStartToken == null) return;
        TSourceToken oldStartToken = this.startToken;
        if (oldStartToken != null){
            if (oldStartToken.getNodesStartFromThisToken().peek() == this){
                oldStartToken.getNodesStartFromThisToken().pop();
            }
        }
        if (newStartToken.getNodesStartFromThisToken().indexOf(this) == -1)
        {
            newStartToken.getNodesStartFromThisToken().push(this);
        }

        this.startToken = newStartToken;
    }

    public void setStartToken(TSourceTokenList startTokenList) {
        if (startTokenList == null) return;
        this.setStartToken(startTokenList.get(0));
    }

    public void setStartToken(TParseTreeNode startNode) {
        if (startNode == null) return;
        this.setStartToken(startNode.getStartToken());
    }

    public void setStartTokenDirectly(TSourceToken newStartToken) {
        this.startToken = newStartToken;
    }
    public void setEndTokenDirectly(TSourceToken newEndToken) {
        this.endToken = newEndToken;
    }

    public void setEndToken(TSourceToken newEndToken) {
        if (newEndToken == null) return;
        TSourceToken oldEndToken = this.getEndToken();

        if (oldEndToken != null){
            if (oldEndToken.getNodesEndWithThisToken().peek() == this){
                oldEndToken.getNodesEndWithThisToken().pop();
            }
        }

        if (newEndToken.getNodesEndWithThisToken().indexOf(this) == -1){
            newEndToken.getNodesEndWithThisToken().push(this);
        }

        this.endToken = newEndToken;
    }

    public void setEndToken(TSourceTokenList endTokenList) {
        if (endTokenList == null) return;
        this.setEndToken(endTokenList.get(endTokenList.size()-1));
    }

//    public void setEndToken(TParseTreeNodeList endNodeList) {
//        if (endNodeList == null) return;
//        this.setEndToken(endNodeList.getEndToken());
//    }



    public void setEndToken(TFromTableList endNode) {
        if (endNode == null) return;
        this.setEndToken(endNode.getEndToken());
    }

    public void setEndToken(TParseTreeNode endNode) {
        if (endNode == null) return;
        this.setEndToken(endNode.getEndToken());
    }

    private void setStartTokenToNull(){
        this.startToken = null;
    }

    private void setEndTokenToNull(){
        this.endToken = null;
    }

    private void resetStartAndEndTokenBeforeRemoveTokens(TSourceTokenList stList, int start, int end,boolean isReplace,TSourceToken relpacedStartToken,TSourceToken replacedEndToken){

        for(int m = start; m<=end;m++){
            if ((m>stList.size()-1) ||(m<0)) break;
            TSourceToken deletedToken = stList.get(m);
            for(int i=0;i<deletedToken.getNodesStartFromThisToken().size();i++){
                TParseTreeNode node = deletedToken.getNodesStartFromThisToken().get(i);
                TSourceToken EndSt = node.getEndToken();

                if (isReplace&&((m==start)||(m==end))){
                    node.setStartToken(relpacedStartToken);
                }else{
                    if (EndSt == null){
                        node.setStartTokenToNull();
                    }else{
                        if (EndSt.posinlist > end){
                            node.setStartToken(stList.get(end+1));
                        }else if (EndSt.posinlist < start){
                            node.setStartTokenToNull();
                            node.setEndTokenToNull();
                        }else{
                            node.setStartTokenToNull();
                            node.setEndTokenToNull();
                        }
                    }
                }
            } // nodes start from this token

            for (int i=0;i<deletedToken.getNodesEndWithThisToken().size();i++){
                TParseTreeNode node = deletedToken.getNodesEndWithThisToken().get(i);
                TSourceToken startSt = node.getStartToken();

                if (isReplace&&((m==start)||(m==end))){
                    node.setEndToken(replacedEndToken);
                }else{
                    if (startSt == null){
                        node.setEndTokenToNull();
                    }else{
                        if (startSt.posinlist > end){
                            node.setStartTokenToNull();
                            node.setEndTokenToNull();
                        }else if (startSt.posinlist < start){
                            node.setEndToken(stList.get(start - 1));
                        }else{
                            node.setStartTokenToNull();
                            node.setEndTokenToNull();
                        }
                    }
                }
            }// nodes end with this token

        }//loop all tokens to be deleted in this parse tree nodes
    }



    private void fastResetStartAndEndTokenBeforeRemoveTokens(TSourceTokenList stList, int start, int end,TSourceToken replacedToken){
        int[] startEnd;
        if (start != end) {
            startEnd = new int[2];
            startEnd[0] = start;
            startEnd[1] = end;
        }
        else {
            startEnd = new int[1];
            startEnd[0] = start;
        }
        for(int m : startEnd){
            TSourceToken deletedToken = stList.get(m);
            for(int i=0;i<deletedToken.getNodesStartFromThisToken().size();i++){
                TParseTreeNode node = deletedToken.getNodesStartFromThisToken().get(i);
                node.setStartToken(replacedToken);
            } // nodes start from this token

            for (int i=0;i<deletedToken.getNodesEndWithThisToken().size();i++){
                TParseTreeNode node = deletedToken.getNodesEndWithThisToken().get(i);
                node.setEndToken(replacedToken);
            }// nodes end with this token

        }//loop all tokens to be deleted in this parse tree nodes
    }

    /**
     * @deprecated since v1.8.8.0, use scriptWriter technology to modify the node
     * Set the new string text of a node will destroy all the sub-node structure
     *
     * @param sqlSegment that override original text of this node.
     */

    /*
     * <p>1. new string will be tokenized into a list of source tokens: stlist
     * <p>2. link alternativetoken of start token of this node to the first token in stlist generated in step 1.
     * <p>3. link back alternative token of last token in stlist to the last token of this node.
     * <p>So, if you find a start token of parse tree node has an alternativetoken, then text of this node should be modified by using setString(String sqlSegment)
     * <p> if a parse tree node with an alias clause like: tablename as tablealias,
     * <p> TTable.setString() will replace whole text "tablename as tablealias" including alias clause.
     *
     * steps to set new string(sqlSegment) of parse tree node
     * length(sqlSegment)=0 or sqlSegment = one space,, means remove this node from parse tree
     * length(sqlSegment) > 0 , means replace source tokens of this node with new tokens
     *
     */
    public void setString2(String sqlSegment){

//        TGSqlParser l_sqlparser = new TGSqlParser(getGsqlparser().getDbVendor());
//        l_sqlparser.sqltext =  sqlSegment;
//        l_sqlparser.tokenizeSqltext();

        TSingletonParser singletonParser = TSingletonParser.getInstance();

        TSourceTokenList stList;
        if (this.dbvendor == EDbVendor.dbvgeneric){
            stList = singletonParser.getTokens(TGSqlParser.currentDBVendor,sqlSegment);
        }else{
            stList = singletonParser.getTokens(this.dbvendor,sqlSegment);
        }



        if ((getStartToken() == null)&&(getEndToken() == null)){
            // this is a manually created parse tree node, not created by yacc
//            l_sqlparser.sourcetokenlist.get(0).container = l_sqlparser.sourcetokenlist;
//            l_sqlparser.sourcetokenlist.get(l_sqlparser.sourcetokenlist.size()-1).container = l_sqlparser.sourcetokenlist;
            setStartToken(stList.get(0));
            setEndToken(stList.get(stList.size()-1));
            return;
        }

        TSourceToken lcStartToken = getStartToken();
        TSourceToken lcEndToken = getEndToken();

       // TSourceTokenList stList = lcEndToken.container;

        int lcStartTokenPos = lcStartToken.posinlist;
        int lcEndTokenPos = lcEndToken.posinlist;


        if ((sqlSegment.length()==0) || (sqlSegment == " ")){

           //reset start and end token of those parse tree node
            resetStartAndEndTokenBeforeRemoveTokens(stList, lcStartTokenPos, lcEndTokenPos,false,null,null);

            // remove token from list
            for(int i=lcEndTokenPos;i>=lcStartTokenPos;i--){
                stList.remove(i);
            }

            // reindex posinlist after remove token from container
            for(int i=lcStartTokenPos;i<stList.size();i++){
                stList.get(i).posinlist = i;
            }

        }else{
            //replace
           //reset start and end token of those parse tree node
            TSourceToken lcReplacedStartToken = stList.get(0);
            TSourceToken lcReplacedEndToken = stList.get(stList.size()-1);
            resetStartAndEndTokenBeforeRemoveTokens(stList, lcStartTokenPos, lcEndTokenPos,true,lcReplacedStartToken,lcReplacedEndToken);

            // remove token from list
            for(int i=lcEndTokenPos;i>=lcStartTokenPos;i--){
                stList.remove(i);
            }


//            for(int i = stList.size()-1; i>=0; i--){
//                TSourceToken st = stList.get(i);
//                st.container = stList;
//                stList.add(lcStartTokenPos,st);
//            }

            // reindex posinlist after remove token from container
            for(int i=lcStartTokenPos;i<stList.size();i++){
                TSourceToken st = stList.get(i);
                st.posinlist =  i;
            }

        }

    }

    /**
     * Set the text of the node and update the corresponding source tokens synchronously.
     * This way, when the toString() method of the node itself or its parent node is called,
     * it will return the modified text.
     *
     * @param sqlSegment
     */
    public void setString(String sqlSegment){
        if (doubleLinkedTokenListToString){
            setText(sqlSegment);
        }else{
            setString2(sqlSegment);
        }
    }

    public void fastSetString(String sqlSegment){

        TSourceToken replaceToken = new TSourceToken(sqlSegment);
        setText(replaceToken, replaceToken);
    }


    /**
     * return null if no comment is found before this node.
     *
     * @return the comment before this node
     */
    public String getCommentBeforeNode(){
        String ret = null;
        TSourceToken lcStartToken;

        if (doubleLinkedTokenListToString){
            lcStartToken = getStartToken();
            if (lcStartToken ==  null) return null;

            TSourceToken lcCurrentToken = lcStartToken.getPrevTokenInChain();
            while (lcCurrentToken != null){
                if ((lcCurrentToken.tokentype == ETokenType.ttreturn)||(lcCurrentToken.tokentype == ETokenType.ttwhitespace))
                {
                    if (ret != null){
                        ret = lcCurrentToken.toString() + ret ;
                    }
                    lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                    continue;
                }
                else if (lcCurrentToken.astext.trim().length() == 0) {
                    lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                    continue;
                }
                if ((lcCurrentToken.tokencode == TBaseType.cmtslashstar) ||(lcCurrentToken.tokencode == TBaseType.cmtdoublehyphen)
                        || lcCurrentToken.astext.startsWith("--") || lcCurrentToken.astext.startsWith("/*")
                ){
                    if (ret == null){
                        ret = lcCurrentToken.toString();
                    }else{
                        ret = lcCurrentToken.toString()+ ret;
                    }

                    lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                    continue;
                }

                break;
            }
        }else{
            lcStartToken = getStartToken();
            if (lcStartToken ==  null) return null;

            TSourceTokenList stList = lcStartToken.container;
            if (stList == null) return null;

            int b = lcStartToken.posinlist;

            for(int i = b - 1 ; i>=0;i--){
                TSourceToken st = stList.get(i);
                if ((st.tokencode == TBaseType.lexspace)|| (st.tokencode == TBaseType.lexnewline)) continue;
                if (st.astext.trim().length() == 0) continue;
                if ((st.tokencode == TBaseType.cmtslashstar) ||(st.tokencode == TBaseType.cmtdoublehyphen)){
                    if (ret == null){
                        ret = st.toString();
                    }else{
                        ret = st.toString()+TBaseType.newline + ret;
                    }
                    continue;
                }
                else if (st.astext.startsWith("--") || st.astext.startsWith("/*")){
                    if (ret == null){
                        ret = st.toString();
                    }else{
                        ret = st.toString()+TBaseType.newline + ret;
                    }
                    continue;
                }
                break;
            }
        }

        return ret;
    }

    public String getCommentAfterNode(){
        String ret = null;
        TSourceToken lcEndToken;

        if (!doubleLinkedTokenListToString) return ret;

        lcEndToken = getEndToken();
        if (lcEndToken ==  null) return null;

        TSourceToken lcCurrentToken = lcEndToken;
        while (lcCurrentToken != null){
            if ((lcCurrentToken.tokentype == ETokenType.ttreturn)||(lcCurrentToken.tokentype == ETokenType.ttwhitespace))
            {
                if (ret != null){
                    ret = lcCurrentToken.toString() + ret ;
                }
                lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                continue;
            }
            else if (lcCurrentToken.astext.trim().length() == 0) {
                lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                continue;
            }
            if ((lcCurrentToken.tokencode == TBaseType.cmtslashstar) ||(lcCurrentToken.tokencode == TBaseType.cmtdoublehyphen)
                    || lcCurrentToken.astext.startsWith("--") || lcCurrentToken.astext.startsWith("/*")
            ){
                if (ret == null){
                    ret = lcCurrentToken.toString();
                }else{
                    ret =  lcCurrentToken.toString()  +ret ;
                }

                lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                continue;
            }

            break;
        }

            return ret.trim(); // 移调第一个space or return token if any

    }

    /**
     * String representation of this parse tree node.
     * <p>
     * This string was generated by collecting text from the start token of this node to the end token of this node.
     * If this node was modified, then use {@link #toScript()} to get string representation of this node.
     *
     * @return string representation of this parse tree node
     */
    public String toString2(){
        String ret = null;
        TSourceToken lcStartToken = getStartToken();
        if (lcStartToken ==  null) return null;

        TSourceToken lcEndToken = getEndToken();
        if (lcEndToken ==  null) return null;

        TSourceTokenList stList = lcStartToken.container;
        if (stList == null) return null;

        int b = lcStartToken.posinlist;
        int e = lcEndToken.posinlist;

        StringBuffer sb = new StringBuffer("");

        for(int i= b ; i<=e;i++){
              if(!includingComment && ((stList.get(i).tokencode == TBaseType.cmtslashstar) ||(stList.get(i).tokencode == TBaseType.cmtdoublehyphen))){
                  continue;
              }
            sb.append(stList.get(i).toString());
        }

        return sb.toString();
    }

    /**
     * The returned text is formed by concatenating the source tokens contained in this node one by one.
     *
     * @return
     */
    public String toString(){
        if (doubleLinkedTokenListToString){
            String ret = null;
            TSourceToken lcStartToken = getStartToken();
            if (lcStartToken ==  null) return null;
            TSourceToken lcEndToken = getEndToken();
            if (lcEndToken ==  null) return null;

            boolean chainUnchanged = true;

            StringBuffer sb = new StringBuffer("");
            TSourceToken lcPrevSt = null;
            boolean ignoreNextReturnToken = false, isChainModified = false;

            TSourceToken lcCurrentToken = lcStartToken;
            while (lcCurrentToken != null){
                if (lcCurrentToken.tokentype == ETokenType.ttreturn){
                    if (ignoreNextReturnToken && (isChainModified||((lcPrevSt != null)&&(lcCurrentToken.posinlist - lcPrevSt.posinlist != 1))) ){
                        lcCurrentToken.tokenstatus = ETokenStatus.tsdeleted;
                        //System.out.println("Find deleted token:"+lcCurrentToken.astext);
                    }else{
                        ignoreNextReturnToken = true;
                    }
                }else if (lcCurrentToken.tokentype != ETokenType.ttwhitespace){
                    ignoreNextReturnToken = false;
                }
                if (!isChainModified && lcPrevSt != null){
                    isChainModified = (lcCurrentToken.posinlist - lcPrevSt.posinlist != 1);

                    if (isChainModified){
                        //System.out.println("token chain changed");
                    }
                }
                lcPrevSt = lcCurrentToken;

                if (lcCurrentToken.equals(lcEndToken)){
                    break;
                }else{
                    lcCurrentToken = lcCurrentToken.getNextTokenInChain();
                }
            }

            lcCurrentToken = lcStartToken;
            while (lcCurrentToken != null){
                if((lcCurrentToken.tokenstatus == ETokenStatus.tsdeleted)
                        ||(!includingComment  && ((lcCurrentToken.tokencode == TBaseType.cmtslashstar) ||(lcCurrentToken.tokencode == TBaseType.cmtdoublehyphen)))
                ){
                    // ignore this token, do nothing
                   // System.out.println("out: ignore deleted token:"+lcCurrentToken.astext);
                }else{
                    //
                        sb.append(lcCurrentToken.toString());
                }

                if (lcCurrentToken.equals(lcEndToken)){
                    break;
                }else{
                    lcCurrentToken = lcCurrentToken.getNextTokenInChain();
                }
            }

            return sb.toString();

        }else
        {
            return toString2();
        }
    }


    void setText(String nodeText, EDbVendor dbVendor){
        this.dbvendor = dbVendor;
        setText(nodeText);
    }

    private boolean tokensInChain = true;

    public boolean isTokensInChain() {
        return tokensInChain;
    }

    void setText(TSourceToken startToken, TSourceToken endToken){
        TSourceToken newStartToken = startToken;
        TSourceToken newEndToken = endToken;

        TSourceToken oldStartToken = getStartToken();
        TSourceToken oldEndToken = getEndToken();
        tokensInChain = false;
        if ((oldStartToken == null)||(oldEndToken == null)){
            setStartToken(newStartToken);
            setEndToken(newEndToken);
            nodeStatus = ENodeStatus.nsFlattened;
            return;
        }

        refreshAllNodesTokenCount();

        updateStatusOfNodeShareSameTokens(nodeActionUpdateText);

        updateNodeWithTheSameStartToken(nodeActionUpdateText,newStartToken);
        updateMeNodeWithTheSameEndToken(nodeActionUpdateText,newEndToken);

        if (oldStartToken.getPrevTokenInChain() != null){
            oldStartToken.getPrevTokenInChain().setNextTokenInChain(newStartToken);
            newStartToken.setPrevTokenInChain(oldStartToken.getPrevTokenInChain());
        }

        if (oldEndToken.getNextTokenInChain() != null){
            oldEndToken.getNextTokenInChain().setPrevTokenInChain(newEndToken);
            newEndToken.setNextTokenInChain(oldEndToken.getNextTokenInChain());
        }

        tokensInChain = true;
    }
    /**
     * set text of this node, if the original token of this node
     * is in a token chain, then merge the new token into the chain as well.
     *
     * use double linked list
     *
     * @param nodeText node text
     */
    void setText(String nodeText){
        if ((this.getNodeStatus() == ENodeStatus.nsRemoved)||(nodeText.length() == 0)) return;
       // if ((nodeText.length() == 0)) return;

//        TGSqlParser sqlParser = new TGSqlParser(TGSqlParser.currentDBVendor);
//        sqlParser.sqltext = nodeText;
//        sqlParser.tokenizeSqltext();
//        TSourceToken newStartToken = sqlParser.getSourcetokenlist().get(0);
//        TSourceToken newEndToken = sqlParser.getSourcetokenlist().get(sqlParser.getSourcetokenlist().size() - 1);
//        setText(newStartToken, newEndToken);

        TSingletonParser singletonParser = TSingletonParser.getInstance();

        TSourceTokenList stList;
        if (this.dbvendor == EDbVendor.dbvgeneric){
            stList = singletonParser.getTokens(TGSqlParser.currentDBVendor,nodeText);
        }else{
            stList = singletonParser.getTokens(this.dbvendor,nodeText);
        }


        TSourceToken newStartToken = stList.get(0);
        TSourceToken newEndToken = stList.get(stList.size() - 1);
        setText(newStartToken, newEndToken);

    }


    /**
     * @deprecated since v1.8.8.0, use scriptWriter technology to modify the node
     * Inserts tokens(from start token to end token ) of this parse tree node at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right .

     * @param targetList the new list of source tokens
     * @param index  the position insert the targetList
     * @return length of the source token list after insert targetList
     */
     public int addAllMyTokensToTokenList(TSourceTokenList targetList, int index){
       int ret = -1;

        TSourceToken lcStartToken = getStartToken();
        if (lcStartToken ==  null) return ret;

        TSourceToken lcEndToken = getEndToken();
        if (lcEndToken ==  null) return ret;

        TSourceTokenList stList = lcStartToken.container;
        if (stList == null) return ret;

        for(int i=lcEndToken.posinlist;i>=lcStartToken.posinlist;i--){
            targetList.add(index,stList.get(i));
            stList.get(i).container = targetList;
        }

        // reindex posinlist after remove token from container
        for(int i=index;i<targetList.size();i++){
            targetList.get(i).posinlist = i;
        }

        return lcEndToken.posinlist - lcStartToken.posinlist + 1;
    }

    /**
     * @deprecated since v1.8.8.0, use scriptWriter technology to modify the node
     *
     * @param additionalToken usually was comma before or after this parse tree node that also need to be deleted
     * @return length of the source token list after remove tokens
     */
    protected int removeAllMyTokensFromTokenList(TSourceToken additionalToken){

        int ret = -1;
        TSourceToken lcStartToken = getStartToken();
        if (lcStartToken ==  null) return ret;
        int lcStartTokenPos = lcStartToken.posinlist;


        TSourceToken lcEndToken = getEndToken();
        if (lcEndToken ==  null) return ret;
        int lcEndTokenPos = lcEndToken.posinlist;


        TSourceTokenList stList = lcStartToken.container;
        if (stList == null) return ret;

        if ((additionalToken != null)&&(additionalToken.tokentype != ETokenType.ttRemoved)){
            if (additionalToken.posinlist < lcStartTokenPos){
                lcStartTokenPos = additionalToken.posinlist;
                additionalToken.tokentype = ETokenType.ttRemoved;
            }else if(additionalToken.posinlist > lcEndTokenPos){
                lcEndTokenPos = additionalToken.posinlist;
                additionalToken.tokentype = ETokenType.ttRemoved;
            }
        }

       //reset start and end token of those parse tree node
        resetStartAndEndTokenBeforeRemoveTokens(stList, lcStartTokenPos, lcEndTokenPos,false,null,null);

        // remove token from list
        for(int i=lcEndTokenPos;i>=lcStartTokenPos;i--){
            if ((i>stList.size()-1) ||(i<0)) break;
            stList.remove(i);
        }

        // reindex posinlist after remove token from container
        for(int i=lcStartTokenPos;i<stList.size();i++){
            if ((i>stList.size()-1) ||(i<0)) break;
            stList.get(i).posinlist = i;
        }

        return lcStartTokenPos - lcEndTokenPos +1;
    }

    /**
     * @deprecated since v1.8.8.0, use scriptWriter technology to modify the node
     * parse string to tokens, then add those tokens to the end of this parse tree node
     *
     * @param sqlSegment
     */
//    protected void appendString(String sqlSegment){
//
//        if (sqlSegment.length() == 0) return;
//        if (getStartToken() == null) return;
//        if (getEndToken() == null) return;
//
//        TSourceToken lcEndToken = getEndToken();
//
//        TSourceTokenList stList = lcEndToken.container;
//
//        int lcEndTokenPos = lcEndToken.posinlist;
//
////        TGSqlParser l_sqlparser = new TGSqlParser(getGsqlparser().getDbVendor());
////        l_sqlparser.sqltext =  sqlSegment;
//
//        TGSqlParser l_sqlparser;
//        if (this.dbvendor == EDbVendor.dbvgeneric){
//            l_sqlparser = TGSqlParser.getSingletonParser(getGsqlparser().getDbVendor());
//        }else{
//            l_sqlparser = TGSqlParser.getSingletonParser(this.dbvendor);
//        }
//
//        synchronized(this) {
//            l_sqlparser.tokenizeSqltext();
//            if (l_sqlparser.sourcetokenlist.size() == 0) return;
//            TSourceToken endTokenOfNewSourceTokenList = l_sqlparser.sourcetokenlist.get(l_sqlparser.sourcetokenlist.size()-1);
//
//            for(int i = l_sqlparser.sourcetokenlist.size()-1; i>=0; i--){
//                TSourceToken st = l_sqlparser.sourcetokenlist.get(i);
//                st.container = stList;
//                stList.add(lcEndTokenPos+1,st);
//            }
//
//            // reindex posinlist after remove token from container
//            for(int i=lcEndTokenPos+1;i<stList.size();i++){
//               stList.get(i).posinlist =  i;
//            }
//
//            for(int i=0;i<lcEndToken.getNodesEndWithThisToken().size();i++){
//                TParseTreeNode node = lcEndToken.getNodesEndWithThisToken().get(i);
//                node.setEndToken(endTokenOfNewSourceTokenList);
//            }
//        }
//
//}

    /**
     * Accept a visitor
     *
     * @param v visitor is a descendant class of {@link TParseTreeVisitor}
     */
  public void accept(TParseTreeVisitor v)
  {

  }

    /**
     * Accept a visitor to iterate this class and sub-nodes of this class
     *
     * @param v visitor is a descendant class of {@link TParseTreeVisitor}
     */
    public void acceptChildren(TParseTreeVisitor v)
    {

    }

  private TScriptGenerator scriptGenerator = null;

    /**
     * Return the text string of this node, the return value is the same as {@link #toString()} if this node is not modified manually
     * after created by parser.
     * <br>
     * If this node is modified, then use this method to get string representation instead of the {@link #toString()} method.
     *
     * @return text string of this node
     */
  public String toScript(){
    if (scriptGenerator == null){
        scriptGenerator = new TScriptGenerator();
    }
     return scriptGenerator.generateScript(this);
  }

  public void setChanged(){
      // set the changed status to the first token of this node
      if (getStartToken() == null) return;
      getStartToken().setTokenstatus(ETokenStatus.tschanged);
  }

    /**
     * Detect wether this node is modified by checking all tokens included in this node.
     * @return true if this node is modified.
     */
  public boolean isChanged(){
      boolean ret = false;
      TSourceToken lcStartToken = getStartToken();
      if (lcStartToken ==  null) return ret;

      TSourceToken lcEndToken = getEndToken();
      if (lcEndToken ==  null) return ret;

      TSourceTokenList stList = lcStartToken.container;
      if (stList == null) return ret;

      int b = lcStartToken.posinlist;
      int e = lcEndToken.posinlist;

      for(int i= b ; i<=e;i++){
          if (stList.get(i).getTokenstatus() == ETokenStatus.tschanged){
              ret = true;
              break;
          }
      }
      return ret;
  }

    protected void doAppendNewNode( TParseTreeNode newNode, TParseTreeNode anchorNode,boolean needCommaBefore){
        if (anchorNode != null){
            anchorNode.appendNewNode(newNode,needCommaBefore);
        }else{
            if (!newNode.isTokensInChain()){
                this.appendNewNode(newNode,false);
                this.setEndToken(newNode.getEndToken());
            }
        }
    }

    private TParseTreeNode anchorNode = null;

    public void setAnchorNode(TParseTreeNode anchorNode) {
        this.anchorNode = anchorNode;
    }

    public TParseTreeNode getAnchorNode() {
        return anchorNode;
    }

  public void setNewSubNode( TParseTreeNode oldSubNode, TParseTreeNode newSubNode,TParseTreeNode anchorNode){
      if (newSubNode == null){
          //remove the old node
          if (oldSubNode != null){
              oldSubNode.removeTokens();
          }
      }else {
          if (oldSubNode == null){
              // add a total new where clause, we need to find an anchor
              if (newSubNode.getNodeStatus()!=ENodeStatus.nsNormal){
                  doAppendNewNode(newSubNode,anchorNode,false);
              }

          }else{
              //replace old where clause
              if (newSubNode.getNodeStatus()!=ENodeStatus.nsNormal){
                  oldSubNode.replaceWithNewNode(newSubNode);
              }
          }
      }
  }

    public static boolean subNodeInNode(TParseTreeNode subNode, TParseTreeNode wholeNode){
        if (wholeNode == null) return false;
        TSourceToken startToken = wholeNode.getStartToken();
        if (startToken == null) return false;
        TSourceToken endToken = wholeNode.getEndToken();
        if (endToken == null) return false;

        TSourceToken startTokenOfSubNode = subNode.getStartToken();
        if (startTokenOfSubNode == null) return false;
        if (startTokenOfSubNode.lineNo < startToken.lineNo) return false;
        if ((startTokenOfSubNode.lineNo == startToken.lineNo) && (startTokenOfSubNode.columnNo < startToken.columnNo)) return false;

        TSourceToken endTokenOfSubNode = subNode.getEndToken();
        if (endTokenOfSubNode == null) return false;

        if (endTokenOfSubNode.lineNo > endToken.lineNo) return false;
        if ((endTokenOfSubNode.lineNo == endToken.lineNo)&&(endTokenOfSubNode.columnNo > endToken.columnNo)) return false;

        return true;
    }

//  public int setText(EDbVendor dbVendor, String sqlText){
//      TGSqlParser sqlParser = new TGSqlParser(dbvendor);
//      sqlParser.sqltext = sqlText;
//      sqlParser.tokenizeSqltext();
//
//  }

}