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;

/**
 * <h1>TParseTreeNode - Core Parse Tree Node Implementation</h1>
 * 
 * <h2>Overview</h2>
 * This class is the root class for all syntax/parse tree nodes in the GSP SQL Parser.
 * A parse tree node represents a syntactic element of a SQL statement, composed of a sequence 
 * of tokens generated by the lexer. The node maintains references to its start and end tokens
 * in a double-linked token chain, enabling both traversal and modification of the SQL text.
 *
 * <h2>Architecture and Design</h2>
 * 
 * <h3>Token Chain Structure</h3>
 * The parse tree is built on a double-linked list of {@link TSourceToken} objects. Each node:
 * <ul>
 *   <li>Has a {@code startToken} and {@code endToken} that define its boundaries</li>
 *   <li>Can iterate through its tokens using the token chain links</li>
 *   <li>Maintains relationships with other nodes that may share the same tokens</li>
 * </ul>
 * 
 * <h3>Critical: Node Nesting and Token Sharing</h3>
 * <b>Nodes in the parse tree are nested and share tokens.</b> This is fundamental to the design:
 * <ul>
 *   <li>A WHERE clause node contains an expression node, both sharing the same tokens</li>
 *   <li>A SELECT statement contains multiple clauses, all sharing tokens from the same chain</li>
 *   <li>Each token maintains stacks of nodes that start/end on it (via {@code nodesStartFromThisToken} 
 *       and {@code nodesEndWithThisToken})</li>
 * </ul>
 * 
 * <h4>Token Sharing Example:</h4>
 * <pre>
 * SQL: "SELECT * FROM table WHERE id = 1"
 * 
 * - SelectStatement node: [SELECT...1]
 *   - SelectList node: [*]
 *   - FromClause node: [FROM table]
 *   - WhereClause node: [WHERE id = 1]
 *     - Expression node: [id = 1]
 *       - LeftOperand: [id]
 *       - Operator: [=]
 *       - RightOperand: [1]
 * </pre>
 * 
 * <h3>Modification Strategy for Nested Nodes</h3>
 * 
 * <h4>Core Rules:</h4>
 * <ol>
 *   <li><b>Leaf-First Modification:</b> Always modify the most specific (leaf) node when possible</li>
 *   <li><b>Status Propagation:</b> When a node is modified, all overlapping nodes are updated:
 *       <ul>
 *         <li>{@code nsDetached}: Node's tokens were partially modified</li>
 *         <li>{@code nsPartitial}: Node contains modified sub-nodes</li>
 *         <li>{@code nsRemoved}: Node's tokens were completely removed</li>
 *       </ul>
 *   </li>
 *   <li><b>Chain Integrity:</b> The token chain must remain valid after any modification</li>
 * </ol>
 * 
 * <h4>Modification Scenarios and Handling:</h4>
 * 
 * <b>Scenario 1: Modifying a Leaf Node</b>
 * <pre>
 * // Original: WHERE id = 1
 * // Modify the right operand from "1" to "100"
 * rightOperandNode.setString("100");
 * 
 * Result:
 * - RightOperand node: replaced with new token "100"
 * - Expression node: status = nsPartitial (contains modified child)
 * - WhereClause node: status = nsPartitial (contains modified descendant)
 * </pre>
 * 
 * <b>Scenario 2: Modifying a Parent Node</b>
 * <pre>
 * // Original: WHERE id = 1
 * // Replace entire WHERE clause
 * whereClauseNode.setString("WHERE status = 'active'");
 * 
 * Result:
 * - All child nodes (Expression, operands): status = nsDetached
 * - WhereClause node: completely replaced with new tokens
 * - SelectStatement: updated to reference new WHERE tokens
 * </pre>
 * 
 * <b>Scenario 3: Removing a Node</b>
 * <pre>
 * // Remove WHERE clause entirely
 * whereClauseNode.removeTokens();
 * 
 * Result:
 * - WhereClause and all children: status = nsRemoved
 * - Tokens removed from chain
 * - Parent SelectStatement: adjusted boundaries
 * </pre>
 * 
 * <h3>Best Practices for API Users</h3>
 * 
 * <ol>
 *   <li><b>Check Node Status Before Modification:</b>
 *       <pre>
 *       if (node.getNodeStatus() == ENodeStatus.nsNormal) {
 *           // Safe to modify
 *           node.setString(newText);
 *       }
 *       </pre>
 *   </li>
 *   
 *   <li><b>Prefer Leaf Node Modifications:</b>
 *       <pre>
 *       // GOOD: Modify specific value
 *       tableNameNode.setString("new_table");
 *       
 *       // AVOID: Replacing entire FROM clause when only table name needs change
 *       fromClause.setString("FROM new_table");
 *       </pre>
 *   </li>
 *   
 *   <li><b>Use toScript() for Complex Modifications:</b>
 *       <pre>
 *       // After multiple modifications, use script generator
 *       if (statement.isChanged()) {
 *           String result = statement.toScript();
 *       }
 *       </pre>
 *   </li>
 *   
 *   <li><b>Understand Cascading Effects:</b>
 *       <pre>
 *       // Modifying a node affects all overlapping nodes
 *       expression.setString("new_condition");
 *       // Parent WHERE clause is now marked as modified
 *       assert whereClause.getNodeStatus() == ENodeStatus.nsPartitial;
 *       </pre>
 *   </li>
 * </ol>
 * 
 * <h3>Text Modification Mechanism</h3>
 * The node supports dynamic text modification through the {@link #setString(String)} method:
 * <ol>
 *   <li><b>Tokenization:</b> New text is tokenized using {@link TSingletonParser} to create new tokens</li>
 *   <li><b>Chain Replacement:</b> Old tokens are removed from the chain and replaced with new ones</li>
 *   <li><b>Relationship Updates:</b> All nodes sharing the modified tokens are updated:
 *       <ul>
 *         <li>{@code updateNodeWithTheSameStartToken()}: Updates nodes starting at modified position</li>
 *         <li>{@code updateMeNodeWithTheSameEndToken()}: Updates nodes ending at modified position</li>
 *         <li>{@code updateStatusOfNodeShareSameTokens()}: Propagates status changes</li>
 *       </ul>
 *   </li>
 *   <li><b>Status Tracking:</b> Node status changes to track modifications</li>
 * </ol>
 * 
 * <h3>String Reconstruction ({@link #toString()})</h3>
 * The toString() method uses a sophisticated two-pass algorithm when {@code doubleLinkedTokenListToString} is true:
 * <ul>
 *   <li><b>First Pass:</b> Detects chain modifications and marks redundant newlines for deletion</li>
 *   <li><b>Second Pass:</b> Builds the final string by concatenating non-deleted tokens</li>
 * </ul>
 * This approach cleanly handles both original parsed text and user modifications.
 *
 * <h2>Current Implementation Trade-offs</h2>
 * 
 * <h3>Design Decisions (Simplicity over Features)</h3>
 * <ul>
 *   <li><b>Re-tokenization on Every Modification:</b> Simple but potentially expensive. 
 *       Accepted trade-off for reliability and consistency.</li>
 *   <li><b>No Partial Token Modification:</b> Cannot modify part of a token; must replace entire token. 
 *       Keeps token integrity and chain management simple.</li>
 *   <li><b>Status-based Conflict Resolution:</b> When nodes overlap, status flags determine behavior. 
 *       Simple rule-based system rather than complex conflict resolution.</li>
 *   <li><b>Single Token Chain:</b> All nodes reference the same global chain. 
 *       Simpler than managing multiple chains but requires careful synchronization.</li>
 * </ul>
 * 
 * <h3>Limitations by Design</h3>
 * <ul>
 *   <li><b>Cannot Preserve Comments in Modified Nodes:</b> When a node is replaced via setString(), 
 *       internal comments are lost. This is acceptable for most use cases.</li>
 *   <li><b>No Undo/Redo:</b> Modifications are permanent. Applications must manage their own undo stack.</li>
 *   <li><b>Thread Safety:</b> Not thread-safe by design. Simpler implementation, caller must synchronize.</li>
 *   <li><b>Memory vs Speed:</b> Keeps all tokens in memory for fast access. Not optimized for very large SQLs.</li>
 * </ul>
 *
 * <h2>Implementation Details</h2>
 * 
 * <h3>Token Sharing Management</h3>
 * When modifying a node with shared tokens:
 * <ol>
 *   <li>Calculate token count for all affected nodes ({@code refreshAllNodesTokenCount()})</li>
 *   <li>Identify nodes with same start/end tokens</li>
 *   <li>Update node boundaries based on token count comparison:
 *       <ul>
 *         <li>Same count = sibling node, needs same update</li>
 *         <li>Larger count = parent node, needs boundary adjustment</li>
 *         <li>Smaller count = child node, may become detached</li>
 *       </ul>
 *   </li>
 *   <li>Splice new tokens into chain maintaining prev/next links</li>
 * </ol>
 * 
 * <h3>Status Flags and Their Meanings</h3>
 * <ul>
 *   <li>{@code nsNormal}: Unmodified node with original tokens</li>
 *   <li>{@code nsFlattened}: Node created from user text (no original tokens)</li>
 *   <li>{@code nsPartitial}: Contains modified child nodes but own tokens unchanged</li>
 *   <li>{@code nsDetached}: Tokens modified by parent/sibling operation</li>
 *   <li>{@code nsRemoved}: Tokens removed from chain, node is defunct</li>
 * </ul>
 *
 * <h2>Proposed Future Improvements</h2>
 * 
 * <h3>1. Decouple Lexer Reference</h3>
 * <pre>
 * // Instead of token->lexer reference, use a TokenContext:
 * class TokenContext {
 *     EDbVendor vendor;
 *     SourceBuffer sourceBuffer;
 *     int sourceId; // Identifies original vs modified source
 * }
 * </pre>
 * 
 * <h3>2. Implement SourceBuffer System</h3>
 * <pre>
 * class SourceBuffer {
 *     List&lt;TextSegment&gt; segments;
 *     
 *     class TextSegment {
 *         String text;
 *         SourceType type; // ORIGINAL, USER_MODIFIED, GENERATED
 *         int startOffset;
 *         int endOffset;
 *     }
 *     
 *     String getText(int segmentId, int start, int end);
 *     int addSegment(String text, SourceType type);
 * }
 * </pre>
 * 
 * <h3>3. Token Source Tracking</h3>
 * <pre>
 * class TSourceToken {
 *     int sourceBufferId;
 *     int segmentId;
 *     int startOffset;
 *     int endOffset;
 *     SourceType sourceType;
 *     
 *     String getText() {
 *         return SourceBufferManager.getBuffer(sourceBufferId)
 *                                  .getText(segmentId, startOffset, endOffset);
 *     }
 * }
 * </pre>
 * 
 * <h3>4. Lazy Token Creation</h3>
 * <ul>
 *   <li>Don't re-tokenize for simple text replacements</li>
 *   <li>Create synthetic tokens only when necessary</li>
 *   <li>Reuse existing tokens when possible</li>
 * </ul>
 * 
 * <h3>5. Unified Modification API</h3>
 * <pre>
 * class NodeModification {
 *     ModificationType type; // REPLACE, INSERT, DELETE
 *     String newText;
 *     boolean preserveFormatting;
 *     boolean retokenize;
 * }
 * 
 * public void modifyNode(NodeModification mod) {
 *     // Single entry point for all modifications
 * }
 * </pre>
 *
 * <h2>Critical Methods Documentation</h2>
 * 
 * <h3>{@link #setString(String)}</h3>
 * Main entry point for modifying node text. Process:
 * <ol>
 *   <li>Tokenizes new text using TSingletonParser</li>
 *   <li>Creates new token chain from tokenized text</li>
 *   <li>Replaces old tokens in the chain</li>
 *   <li>Updates all affected node relationships</li>
 * </ol>
 * 
 * <h3>{@link #toString()}</h3>
 * Reconstructs text from token chain. Two-pass algorithm:
 * <ol>
 *   <li><b>Pass 1:</b> Detect modifications and mark redundant formatting</li>
 *   <li><b>Pass 2:</b> Build string from valid tokens</li>
 * </ol>
 * 
 * <h3>{@link #setText(TSourceToken, TSourceToken)}</h3>
 * Low-level token replacement. Core of the modification system:
 * <ul>
 *   <li>Updates token chain links</li>
 *   <li>Maintains node relationships</li>
 *   <li>Handles edge cases (null tokens, chain boundaries)</li>
 * </ul>
 *
 * <h2>Usage Patterns</h2>
 * 
 * <h3>Reading Original Text</h3>
 * <pre>
 * TParseTreeNode node = ...;
 * String originalText = node.toString(); // Get text from token chain
 * </pre>
 * 
 * <h3>Modifying Node Text</h3>
 * <pre>
 * node.setString("new SQL text"); // Replace node's text
 * String modifiedText = node.toString(); // Get modified text
 * </pre>
 * 
 * <h3>Checking Modifications</h3>
 * <pre>
 * if (node.isChanged()) {
 *     String newText = node.toScript(); // Use script generator for complex mods
 * }
 * </pre>
 *
 * <h2>Thread Safety</h2>
 * This class is NOT thread-safe. Concurrent modifications to the token chain
 * or node structure may result in inconsistent state or corruption.
 *
 * <h2>Performance Considerations</h2>
 * <ul>
 *   <li>Token chain traversal is O(n) where n is number of tokens</li>
 *   <li>Text modification requires re-tokenization (expensive)</li>
 *   <li>toString() performs two passes over tokens</li>
 *   <li>Node relationship updates can cascade to many nodes</li>
 * </ul>
 *
 * @see TSourceToken
 * @see TSingletonParser
 * @see TScriptGenerator
 * @since 1.0
 */
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(java.util.Locale.ROOT));
            }
        }
        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)
    {
    }

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

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

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

    public void init(Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6, Object arg7, Object arg8, Object arg9, Object arg10)
    {
    }

    /**
     * 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.getCurrentDBVendor(),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(){
        return getCommentBeforeNode(false);
    }

    /**
     * The comment block that precedes this node, verbatim, including the {@code --} or
     * <code>/* *&#47;</code> markers.
     *
     * @param stopAtBlankLine when {@code true}, stop at a blank line, so only the comment block
     *        ADJACENT to this node is returned. A blank line is how a file says a comment
     *        introduces the section rather than the next declaration: in
     *        {@code CREATE PACKAGE BODY p AS /}<code>** header **</code>{@code /}, blank line,
     *        {@code /}<code>** 主方法调用 **</code>{@code / PROCEDURE m}, only the second block is
     *        the procedure's. Unbounded ({@code false}) returns both concatenated, which is what
     *        {@link #getCommentBeforeNode()} has always done and what its callers still get.
     */
    public String getCommentBeforeNode(boolean stopAtBlankLine){
        return getCommentBeforeNode(stopAtBlankLine, null);
    }

    /**
     * As {@link #getCommentBeforeNode(boolean)}, but the walk also stops when it reaches
     * {@code stopBefore}.
     *
     * @param stopBefore a token the walk must not pass — the {@code AS} that opens the enclosing
     *        package body, or the first token of the statement a call sits in. Whatever was
     *        collected before reaching it is kept; deciding whether that text belongs to this node
     *        or to the thing the bound opens is the caller's, which knows both. {@code null}
     *        imposes no bound.
     */
    public String getCommentBeforeNode(boolean stopAtBlankLine, TSourceToken stopBefore){
        String ret = null;
        TSourceToken lcStartToken;

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

            TSourceToken lcCurrentToken = lcStartToken.getPrevTokenInChain();
            int consecutiveLineBreaks = 0;
            while (lcCurrentToken != null){
                // Positional, not identity: when the node IS the first token of its statement,
                // the walk starts already outside the bound and must stop at once.
                if (stopBefore != null && lcCurrentToken.posinlist <= stopBefore.posinlist) break;
                if ((lcCurrentToken.tokentype == ETokenType.ttreturn)||(lcCurrentToken.tokentype == ETokenType.ttwhitespace))
                {
                    // Count line-break CHARACTERS: one whitespace token can carry "\n\n", so
                    // counting tokens would never see a blank line.
                    consecutiveLineBreaks += countLineBreaks(lcCurrentToken.toString());
                    // Also when nothing has been collected yet: a blank line means the comment
                    // above it introduces something else, so this node simply has none.
                    if (stopAtBlankLine && consecutiveLineBreaks > 1) break;
                    if (ret != null){
                        ret = lcCurrentToken.toString() + ret ;
                    }
                    lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                    continue;
                }
                else if (lcCurrentToken.toString().trim().length() == 0) {
                    lcCurrentToken = lcCurrentToken.getPrevTokenInChain();
                    continue;
                }
                // Real text: any run of line breaks before it is over.
                consecutiveLineBreaks = 0;
                if ((lcCurrentToken.tokencode == TBaseType.cmtslashstar) ||(lcCurrentToken.tokencode == TBaseType.cmtdoublehyphen)
                        || lcCurrentToken.toString().startsWith("--") || lcCurrentToken.toString().startsWith("/*")
                ){
                    if (stopAtBlankLine && trailsFinishedStatement(lcCurrentToken)) break;
                    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;

            int consecutiveLineBreaks = 0;
            for(int i = b - 1 ; i>=0;i--){
                TSourceToken st = stList.get(i);
                if (stopBefore != null && st.posinlist <= stopBefore.posinlist) break;
                if ((st.tokencode == TBaseType.lexspace)|| (st.tokencode == TBaseType.lexnewline)
                        || (st.getAstext().trim().length() == 0)) {
                    consecutiveLineBreaks += countLineBreaks(st.getAstext());
                    // Same bound as the double-linked walk above: this branch is what runs when
                    // TParseTreeNode.doubleLinkedTokenListToString is off, and the bounded API
                    // must mean the same thing in both.
                    if (stopAtBlankLine && consecutiveLineBreaks > 1) break;
                    continue;
                }
                consecutiveLineBreaks = 0;
                if ((st.tokencode == TBaseType.cmtslashstar) ||(st.tokencode == TBaseType.cmtdoublehyphen)){
                    if (stopAtBlankLine && trailsFinishedStatementInList(stList, i)) break;
                    if (ret == null){
                        ret = st.toString();
                    }else{
                        ret = st.toString()+TBaseType.newline + ret;
                    }
                    continue;
                }
                else if (st.getAstext().startsWith("--") || st.getAstext().startsWith("/*")){
                    if (ret == null){
                        ret = st.toString();
                    }else{
                        ret = st.toString()+TBaseType.newline + ret;
                    }
                    continue;
                }
                break;
            }
        }

        if (stopAtBlankLine && ret != null){
            ret = ret.trim();
            if (ret.isEmpty()) ret = null;
        }
        return ret;
    }

    /** As {@link #trailsFinishedStatement}, for the indexed token-list walk. */
    private static boolean trailsFinishedStatementInList(TSourceTokenList list, int commentIndex){
        for (int i = commentIndex - 1; i >= 0; i--){
            TSourceToken st = list.get(i);
            String text = st.getAstext();
            if (countLineBreaks(text) > 0) return false;
            if (isCommentToken(st)) continue;
            if (text.trim().length() > 0) return closesAStatementOrOpensABody(text);
        }
        return false;
    }

    private static boolean isCommentToken(TSourceToken token){
        String text = token.toString();
        return (token.tokencode == TBaseType.cmtslashstar) || (token.tokencode == TBaseType.cmtdoublehyphen)
                || text.startsWith("--") || text.startsWith("/*");
    }

    /**
     * Whether {@code commentToken} follows a FINISHED statement on its own line, which makes it
     * that statement's trailing note rather than an introduction to whatever comes next.
     *
     * <p>The discriminator is the terminator: in {@code g_counter NUMBER; -- variable only} the
     * comment describes the declaration above it, while in {@code x := f1() + /* second *}{@code / f2()}
     * the code before the comment is the same unfinished statement and the comment introduces the
     * call that follows. Looking for a statement boundary rather than for any code is what tells
     * those apart, on one line or across several.
     */
    private static boolean trailsFinishedStatement(TSourceToken commentToken){
        TSourceToken current = commentToken.getPrevTokenInChain();
        while (current != null){
            String text = current.toString();
            if (countLineBreaks(text) > 0) return false;          // reached the start of the line
            if (isCommentToken(current)){                         // `/* a */ /* b */` is one block
                current = current.getPrevTokenInChain();
                continue;
            }
            if (text.trim().length() > 0) return closesAStatementOrOpensABody(text);
            current = current.getPrevTokenInChain();
        }
        return false;
    }

    /**
     * Whether {@code text} is the end of a statement, or the keyword that opens a body.
     *
     * <p>Both mean a comment after it on the same line describes what came before rather than
     * what follows: {@code g_counter NUMBER; -- variable only} labels the declaration, and
     * {@code IF 1=1 THEN -- only when enabled} labels the branch, not the first call inside it.
     */
    private static boolean closesAStatementOrOpensABody(String text){
        String token = text.trim();
        if (token.endsWith(";")) return true;
        return "THEN".equalsIgnoreCase(token) || "ELSE".equalsIgnoreCase(token)
                || "LOOP".equalsIgnoreCase(token) || "BEGIN".equalsIgnoreCase(token)
                || "DECLARE".equalsIgnoreCase(token) || "DO".equalsIgnoreCase(token)
                || "AS".equalsIgnoreCase(token) || "IS".equalsIgnoreCase(token);
    }

    private static int countLineBreaks(String text){
        if (text == null) return 0;
        int n = 0;
        for (int i = 0; i < text.length(); i++){
            char c = text.charAt(i);
            // CRLF counts once; a lone CR is a line break too, as in CR-only files.
            if (c == '\n') n++;
            else if (c == '\r' && (i + 1 >= text.length() || text.charAt(i + 1) != '\n')) n++;
        }
        return n;
    }

    /**
     * The comment block that FOLLOWS {@code token}, up to a blank line or the first real token.
     *
     * <p>Used for a header that sits under a declaration rather than above it — a package body
     * writes its description after {@code AS}, where no node starts.
     */
    /**
     * The last token of the comment block {@link #commentBlockAfter} would return, or {@code null}
     * when there is none. Callers bound a later walk with it, so ownership is decided by the
     * tokens themselves rather than by comparing rendered text — two objects may legitimately
     * carry identical comments.
     */
    public static TSourceToken commentBlockEndAfter(TSourceToken token){
        if (token == null) return null;
        TSourceToken last = null;
        int consecutiveLineBreaks = 0;
        TSourceToken current = token.getNextTokenInChain();
        while (current != null){
            if ((current.tokentype == ETokenType.ttreturn) || (current.tokentype == ETokenType.ttwhitespace)
                    || (current.toString().trim().length() == 0)){
                consecutiveLineBreaks += countLineBreaks(current.toString());
                if (consecutiveLineBreaks > 1) break;
                current = current.getNextTokenInChain();
                continue;
            }
            if (isCommentToken(current)){
                consecutiveLineBreaks = 0;
                last = current;
                current = current.getNextTokenInChain();
                continue;
            }
            break;
        }
        return last;
    }

    public static String commentBlockAfter(TSourceToken token){
        if (token == null) return null;
        String ret = null;
        String pending = "";
        int consecutiveLineBreaks = 0;
        TSourceToken current = token.getNextTokenInChain();
        while (current != null){
            if ((current.tokentype == ETokenType.ttreturn) || (current.tokentype == ETokenType.ttwhitespace)
                    || (current.toString().trim().length() == 0)){
                consecutiveLineBreaks += countLineBreaks(current.toString());
                // Unconditional: a blank line right after the keyword means the block below it
                // introduces whatever follows, not this node.
                if (consecutiveLineBreaks > 1) break;
                pending = pending + current.toString();
                current = current.getNextTokenInChain();
                continue;
            }
            if ((current.tokencode == TBaseType.cmtslashstar) || (current.tokencode == TBaseType.cmtdoublehyphen)
                    || current.toString().startsWith("--") || current.toString().startsWith("/*")){
                consecutiveLineBreaks = 0;
                // Keep the whitespace BETWEEN comments: two line comments run together would
                // otherwise read as one line, `-- one-- two`.
                ret = (ret == null) ? current.toString() : ret + pending + current.toString();
                pending = "";
                current = current.getNextTokenInChain();
                continue;
            }
            break;
        }
        if (ret != null){
            ret = ret.trim();
            if (ret.isEmpty()) ret = null;
        }
        return ret;
    }

    /**
     * The comment that trails this node on the SAME line, verbatim, including its
     * {@code --} or <code>/* *&#47;</code> markers.
     *
     * <p>Returns {@code null} when there is none — the common case, since most statements end at a
     * semicolon with nothing after it. It never throws.
     *
     * <p>Bounded to the line the node ends on, because a comment on the NEXT line introduces
     * whatever follows it; claiming it here would hand one comment to two nodes. See
     * {@link #getCommentBeforeNode(boolean)} for the leading side of the same idea.
     */
    public String getCommentAfterNode(){
        if (!doubleLinkedTokenListToString) return null;

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

        String ret = null;
        // Forward, not backward: a TRAILING comment sits after the node's last token. The walk
        // used to start at that token and follow getPrevTokenInChain(), which reads the LEADING
        // comment and then dereferenced a null result for every node that had none.
        TSourceToken lcCurrentToken = lcEndToken.getNextTokenInChain();
        boolean terminatorSkipped = false;
        while (lcCurrentToken != null){
            if (lcCurrentToken.tokentype == ETokenType.ttreturn) break;   // end of this line
            if (!terminatorSkipped && ret == null && ";".equals(lcCurrentToken.toString().trim())){
                // `NULL; --部门港口`: the node ends at NULL, so the comment sits past the
                // terminator. Step over it once, never over anything else.
                terminatorSkipped = true;
                lcCurrentToken = lcCurrentToken.getNextTokenInChain();
                continue;
            }
            if ((lcCurrentToken.tokentype == ETokenType.ttwhitespace)
                    || (lcCurrentToken.toString().trim().length() == 0)){
                lcCurrentToken = lcCurrentToken.getNextTokenInChain();
                continue;
            }
            if ((lcCurrentToken.tokencode == TBaseType.cmtslashstar)
                    || (lcCurrentToken.tokencode == TBaseType.cmtdoublehyphen)
                    || lcCurrentToken.toString().startsWith("--")
                    || lcCurrentToken.toString().startsWith("/*")){
                ret = (ret == null) ? lcCurrentToken.toString() : ret + lcCurrentToken.toString();
                lcCurrentToken = lcCurrentToken.getNextTokenInChain();
                continue;
            }
            break;   // real code follows: nothing here belongs to this node
        }

        if (ret == null){
            // A statement's span can INCLUDE its trailing comment: for a semicolon-less T-SQL
            // `INSERT ... -- note`, the end token is the line break AFTER the note, so walking
            // forward starts at the next statement. Look back over the span's tail instead,
            // stopping at this statement's own last code token so the leading comment — which
            // lies before it — can never be reached.
            TSourceToken tail = lcEndToken;
            while (tail != null){
                String text = tail.toString();
                if (isCommentToken(tail)){
                    ret = (ret == null) ? text : text + ret;
                } else if (text.trim().length() > 0){
                    break;
                } else if (countLineBreaks(text) > 0 && ret == null){
                    break;   // a comment on a later line introduces what follows, it does not trail
                }
                tail = tail.getPrevTokenInChain();
            }
        }
        return ret == null ? null : ret.trim();
    }

    /**
     * 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();
    }

    /**
     * <p>
     * 将一个语法树节点（{@code TParseTreeNode}）转换回它对应的原始SQL字符串。
     * 它通过遍历一个由 {@code startToken}（起始词法单元）和 {@code endToken}（结束词法单元）界定的双向链表来实现这一功能。
     * </p>
     * <p>
     * 这个方法的设计采用了“两遍扫描”（Two-Pass）的策略，也就是使用了两个 {@code while} 循环。
     * 第一个循环是预处理阶段，用于清理格式；第二个循环则负责构建最终的字符串。
     * </p>
     * <h3>第一个 {@code while} 循环</h3>
     * <p>
     * 这个循环的主要目标是识别并“软删除”多余的换行符（newline tokens）。这种情况尤其在SQL被程序动态修改后容易出现。
     * 这个循环本身不构建字符串，只负责分析和更新词法单元的状态。
     * 其工作原理是：
     * <ol>
     *     <li><b>遍历：</b> 它从 {@code startToken} 开始，通过 {@code getNextTokenInChain()} 方法遍历到 {@code endToken}。</li>
     *     <li><b>检测链表变化：</b> 它通过比较当前和前一个词法单元的 {@code posinlist}（词法单元在原始完整列表中的位置索引）来判断链表是否“自然”。
     *     如果不连续，意味着词法单元被插入或重排了，此时 {@code isChainModified} 标志位会被设为 {@code true}。</li>
     *     <li><b>标记换行符：</b> 当遇到第一个换行符时，它会设置一个标志。如果紧接着又遇到了另一个换行符，并且此时链表已经被修改过,
     *     那么它会将这个多余的换行符标记为待删除状态。这个逻辑能有效地将代码被修改后可能产生的多个连续换行压缩成一个。</li>
     * </ol>
     * 简而言之，第一个循环是一个格式清理过程，它为后续生成整洁的字符串做准备。
     * </p>
     * <h3>第二个 {@code while} 循环</h3>
     * <p>
     * 这个循环负责从（经过第一步清理后的）词法单元流中实际地构建最终的输出字符串。
     * 其工作原理是：
     * <ol>
     *     <li><b>遍历：</b> 它再次遍历完全相同的词法单元序列。</li>
     *     <li><b>构建字符串：</b> 在将每个词法单元追加到 {@code StringBuffer} 之前，它会进行检查。</li>
     *     <li><b>跳过特定单元：</b> 如果一个词法单元在第一个循环中被标记为待删除，或者它是一个注释（且配置为不包含注释），那么它将被跳过。</li>
     *     <li><b>拼接字符串：</b> 对于所有未被跳过的词法单元，它会将其字符串值追加到 {@code StringBuffer} 中。</li>
     * </ol>
     * 当这个循环结束后，{@code StringBuffer} 就包含了该语法树节点的最终、重构后的SQL文本。
     * </p>
     * @return 节点对应的SQL字符串。
     */
    public String toString(){
        if (doubleLinkedTokenListToString){
            TSourceToken startToken = getStartToken();
            TSourceToken endToken = getEndToken();
            
            // Return null if boundary tokens are missing
            if (startToken == null || endToken == null) {
                return null;
            }

            // First pass: Mark redundant newlines for deletion
            // This cleans up formatting issues caused by programmatic SQL modifications
            TSourceToken currentToken = startToken;
            TSourceToken previousToken = null;
            boolean shouldIgnoreNextNewline = false;
            boolean tokenChainWasModified = false;

            while (currentToken != null) {
                // Detect if the token chain has been modified by checking position continuity
                if (!tokenChainWasModified && previousToken != null) {
                    tokenChainWasModified = (currentToken.posinlist - previousToken.posinlist != 1);
                }

                // Handle newline tokens - mark redundant ones for deletion
                if (currentToken.tokentype == ETokenType.ttreturn) {
                    boolean isRedundantNewline = shouldIgnoreNextNewline && tokenChainWasModified;
                    
                    if (isRedundantNewline) {
                        currentToken.tokenstatus = ETokenStatus.tsdeleted;
                    } else {
                        shouldIgnoreNextNewline = true;
                    }
                } else if (currentToken.tokentype != ETokenType.ttwhitespace) {
                    // Reset newline flag when encountering non-whitespace tokens
                    shouldIgnoreNextNewline = false;
                }

                previousToken = currentToken;
                
                // Move to next token or break if we've reached the end
                if (currentToken.equals(endToken)) {
                    break;
                }
                currentToken = currentToken.getNextTokenInChain();
            }

            // Second pass: Build the final string by concatenating valid tokens
            StringBuffer result = new StringBuffer();
            currentToken = startToken;

            while (currentToken != null) {
                boolean shouldSkipToken = currentToken.tokenstatus == ETokenStatus.tsdeleted ||
                    (!includingComment && (currentToken.tokencode == TBaseType.cmtslashstar || 
                                         currentToken.tokencode == TBaseType.cmtdoublehyphen)
                    );

                if (!shouldSkipToken) {
                    result.append(currentToken.toString());
                }

                // Move to next token or break if we've reached the end
                if (currentToken.equals(endToken)) {
                    break;
                }
                currentToken = currentToken.getNextTokenInChain();
            }

            return result.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.getCurrentDBVendor());
//        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.getCurrentDBVendor(),nodeText);
        }else{
            stList = singletonParser.getTokens(this.dbvendor,nodeText);
        }


        // nodeText may not be tokenizable (e.g. a fragment of an expression such as
        // an unterminated string literal); leave the node unchanged in that case
        if (stList.size() == 0) return;

        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
     */


    /**
     * 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();
//
//  }

}