package gudusoft.gsqlparser;

import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TParseTreeNode;

import java.util.Stack;

/**
 * Represents a source token which is the basic syntactic unit of SQL.
 * A token can be a key word, an identifier, a quoted identifier, a literal (or constant), or a special character symbol.
 * Tokens are normally separated by whitespace (space, tab, newline), but need not be if there is no ambiguity
 * (which is generally only the case if a special character is adjacent to some other token type).
 * <p>
 * The parse tree node consists of source tokens.
 * <p>
 * <br>A list of source token will be available after parse or tokenize the input SQL.
 * <pre>
 * {@code
 *
 *   TGSqlParser sqlparser = new TGSqlParser(EDbVendor.dbvoracle);
 *   sqlparser.sqltext = "select col from t";
 *   int ret = sqlparser.parse();
 *   if (ret == 0){
 *    for(int i=0;i<sqlparser.sourcetokenlist.size();i++){
 *      TSourceToken st =  sqlparser.sourcetokenlist.get(i);
 *      System.out.println(st.tokentype.toString()+" "+st.toString());
 *    }
 *   }else{
 *     System.out.println(sqlparser.getErrormessage());
 *   }
 *
 * }
 * </pre>
 * Get a list of source tokens after call the method {@link gudusoft.gsqlparser.TGSqlParser#parse() }
 * or just call {@link gudusoft.gsqlparser.TGSqlParser#tokenizeSqltext()} if you only
 * need to access tokens of input SQL without generating the full parse tree.
 * <br><br>
 * {@link #tokencode} is the unique id represents the type of token,
 * some typical tokens are: whitespace, return, keyword, identifier. This value is mainly used by the parser internally.
 * <p>
 * {@link #tokentype} uniquely identify the token type in a more meaningful way. It's more easier to use
 * this field in your program than tokencode.
 */

public class TSourceToken implements Cloneable {

    public TSourceToken clone(){
        TSourceToken cloneObject = new TSourceToken();
        cloneObject.tokencode = this.tokencode;
        cloneObject.tokenstatus = this.tokenstatus;
        cloneObject.tokentype = this.tokentype;
        cloneObject.dbObjectType = this.dbObjectType;
        cloneObject.setAstext(this.getAstext());
        cloneObject.lineNo = this.lineNo;
        cloneObject.columnNo = this.columnNo;

        return cloneObject;
    }

    public ESqlClause location = ESqlClause.unknown;

    public static void  concatInChain(TSourceToken st1, TSourceToken st2){
        st1.setNextTokenInChain(st2);
        st2.setPrevTokenInChain(st1);
    }

    public void insertANewTokenAfterMe(TSourceToken newToken){
        newToken.setNextTokenInChain(this.getNextTokenInChain());
        if (this.getNextTokenInChain() != null){
            this.getNextTokenInChain().setPrevTokenInChain(newToken);
        }

        newToken.setPrevTokenInChain(this);
        this.setNextTokenInChain(newToken);
    }

    public void insertANewTokenBeforeMe(TSourceToken newToken){
        newToken.setPrevTokenInChain(this.getPrevTokenInChain());
        if (this.getPrevTokenInChain() != null){
            this.getPrevTokenInChain().setNextTokenInChain(newToken);
        }

        newToken.setNextTokenInChain(this);
        this.setPrevTokenInChain(newToken);
    }

    public  void updateNodeEndWithThisToken(){
        for(int i=0;i<this.getNodesEndWithThisToken().size();i++){
            TParseTreeNode node = this.getNodesEndWithThisToken().get(i);
                if (this.getPrevTokenInChain() != null){
                    node.setEndTokenDirectly(this.getPrevTokenInChain());
                    this.getPrevTokenInChain().getNodesEndWithThisToken().push(node);
                }
        }
    }

    public void updateNodeStartWithThisToken(){
        for(int i=0;i<this.getNodesStartFromThisToken().size();i++){
            TParseTreeNode node = this.getNodesStartFromThisToken().get(i);
            if (this.getNextTokenInChain() != null){
                node.setStartTokenDirectly(this.getNextTokenInChain());
                this.getNextTokenInChain().getNodesStartFromThisToken().push(node);
            }
        }
    }

    public void removeFromChain(){
        if (this.getPrevTokenInChain() != null){
            this.getPrevTokenInChain().setNextTokenInChain(this.getNextTokenInChain());
            if (this.getNextTokenInChain() != null){
                this.getNextTokenInChain().setPrevTokenInChain(this.getPrevTokenInChain());
            }
        }
    }
    private TSourceToken prevTokenInChain = null, nextTokenInChain = null;

    public void setPrevTokenInChain(TSourceToken prevTokenInChain) {
        this.prevTokenInChain = prevTokenInChain;
    }

    public void setNextTokenInChain(TSourceToken nextTokenInChain) {
        this.nextTokenInChain = nextTokenInChain;
    }

    public TSourceToken getPrevTokenInChain() {
        return prevTokenInChain;
    }

    public TSourceToken getNextTokenInChain() {
        return nextTokenInChain;
    }

    public ETokenStatus getTokenstatus() {
        return tokenstatus;
    }

    public int getQuoteSymbolLength(){
        String pstr = this.toString();
        if (pstr.startsWith("'")){
            return 1;
        }else if (pstr.startsWith("$")){
            return this.dolqstart.length();
        }else {
            return 0;
        }
    }
    public String getQuotedString(){
        String pstr = this.toString();
        if (pstr.startsWith("'")){
            return pstr.substring(1,pstr.length()-1);
        }else if (pstr.startsWith("$")){
            return pstr.substring(this.dolqstart.length(),pstr.length()-  this.dolqstart.length());
        }else {
            return "";
        }
    }

    /**
     * String literal in SQL usually inside ``.
     * Quoted identifier in SQL usually surrounded by [ and ],
     * This method only returns the text inside those surroundings.
     *
     * @return text inside `` and []
     */
    public String getTextWithoutQuoted(){
        if ((toString().startsWith("'"))||(toString().startsWith("["))||(toString().startsWith("\""))){
            return  toString().substring(1, toString().length() - 1);
        }else
          return  toString();
    }

    /**
     * Class constructor
     */
    public  TSourceToken(){
    }

    /**
     * Class constructor, set a string value.
     *
     * @param s the string value this toke represent for.
     */
    public TSourceToken(String s){
        setAstext(s);
    }

    /**
     * The string text of this token
     *
     * @return the string text of this token
     */
    public String toScript(){
        return getAstext();
    }


    public int prevTokenCode = 0;
    /**
     * Unique id of this token used by parser internally.
     * check available value start from {@link gudusoft.gsqlparser.TBaseType#cmtslashstar}
     */
    public int tokencode;

    /**
     * the line number of the first character in this token
     */
    public long lineNo;

    /**
     * the column number of the first character in this token
     */
    public long columnNo;

    /**
     * Token's offset from the beginning of the input query.
     * <pre>
     *     {@code
     *    public void testOffset(){
     *        TGSqlParser sqlparser = new TGSqlParser(EDbVendor.dbvoracle);
     *        sqlparser.sqltext = "select f from t\n" +
     *                "where f>1\n";
     *        assertTrue(sqlparser.parse() == 0);
     *        for (int i=0;i<sqlparser.sourcetokenlist.size();i++){
     *            TSourceToken st = sqlparser.sourcetokenlist.get(i);
     *            String textFromOffset = sqlparser.sqltext.toString().substring((int)st.offset,(int)st.offset+st.toString().length());
     *            assertTrue(st.toString().equalsIgnoreCase(textFromOffset));
     *        }
     *    }
     *     }
     * </pre>
     */
    public long offset;

    /**
     * Uniquely identify the token type in a more meaningful way. It's more easier to use
     * this field in your program than tokencode.
     * check available value in {@link gudusoft.gsqlparser.ETokenType ETokenType}
     */
    public ETokenType tokentype;

    /**
     * Container for this token which is a list of source token, this is the reference to {@link gudusoft.gsqlparser.TGSqlParser#sourcetokenlist}
     */
    public TSourceTokenList container;

    /**
     * When a vendor tokenizer replaces one source token by several (BigQuery
     * splits {@code `project.dataset.table`} into {@code `project` . `dataset` . `table`}
     * so the grammar sees the parts), every generated token points here at the
     * token it was split from; {@code null} for ordinary tokens. Consumers that
     * must reproduce the user's spelling (the SQL formatter) print the original
     * once for the whole run instead of the parts.
     *
     * @since 4.2.9
     */
    public TSourceToken splitFrom;
    
    /**
     * Index of this token in the {@link #container}, start from 0
     *
     * <pre>
     *     {@code
     *    public void testPosinList(){
     *        TGSqlParser sqlparser = new TGSqlParser(EDbVendor.dbvoracle);
     *        sqlparser.sqltext = "select f from t\n" +
     *                "where f>1\n";
     *        assertTrue(sqlparser.parse() == 0);
     *        for (int i=0;i<sqlparser.sourcetokenlist.size();i++){
     *            assertTrue(i == sqlparser.sourcetokenlist.get(i).posinlist);
     *        }
     *    }
     *     }
     * </pre>
     */
    public int posinlist;

    /**
     * The text content of this token.
     *
     * <p>This public field is maintained for backwards compatibility with existing code.
     * New code should use getter/setter methods instead of direct field access.</p>
     *
     * <h3>Recommended Usage:</h3>
     * <ul>
     *   <li><b>Reading text:</b> Use {@link #toString()} method</li>
     *   <li><b>Writing text:</b> Use {@link #setAstext(String)} method</li>
     * </ul>
     *
     * @see #toString() - Safe way to read token text
     * @see #getAstext() - Alternative getter method
     * @see #setAstext(String) - Proper way to set token text
     * @since 1.0 (public field maintained for backwards compatibility)
     */
    public String astext;

    public void appendText(TSourceToken st){

        if (this.toString().startsWith(".")){
            // dataset_id.3_ST_LEAK_ORDERS, .3_ST_LEAK_ORDERS 是由 .3 和_ST_LEAK_ORDERS组成
            // 在拼接 .3 和_ST_LEAK_ORDERS 时，需要把 .3 中的 . 去掉
            this.setAstext(this.toString().substring(1,this.toString().length()));
            this.insertANewTokenBeforeMe(new TSourceToken("."));
        }
        if (st.toString().endsWith(".")){
            this.setAstext(this.getAstext() +st.toString().substring(0,st.toString().length()-1));
            //st.tokenstatus = ETokenStatus.tsdeleted; // make sure this token don't appear in toString()

            // 以下代码确保 920778. 后面的 . 在 TObjectName.toString() 中出现
            //  prod-gcp-data-lakehouse-920778.EXTERNALDATA.SMS_LOCATION

            st.tokencode = '.';
            st.setAstext(".");
            st.tokentype = ETokenType.ttperiod;
        }else{
            this.setAstext(this.getAstext() +st.toString());
            st.tokenstatus = ETokenStatus.tsdeleted;
        }
    }

    public void appendText(String text){
        this.setAstext(this.getAstext() +text);
    }

    public void insertText(TSourceToken st){
        this.setAstext(st.toString()+ this.getAstext());
        st.tokenstatus = ETokenStatus.tsdeleted;
    }
    public void setTextWithBackup(String newText){

        prevsourcecode = getAstext();
        tag = TBaseType.tag_token_value_changed_in_on_canonical;

        setAstext(newText);
    }

    public boolean isChangedInAsCanonical(){
        return tag == TBaseType.tag_token_value_changed_in_on_canonical;
    }

    public void setTokenstatus(ETokenStatus tokenstatus) {
        this.tokenstatus = tokenstatus;
    }

    // private ETokenStatus statusForRewrite = ETokenStatus.tsoriginal;

    /**
     * Maintenance the status of this token during lex and parsing.
     * Used by the parser internally.
     */
    public ETokenStatus tokenstatus;

    /**
     * Start part of Dollar-quoted String Constants of PostgreSQL.
     *
     * While the standard syntax for specifying string constants is usually convenient,
     * it can be difficult to understand when the desired string contains many single quotes or backslashes,
     * since each of those must be doubled. To allow more readable queries in such situations,
     * PostgreSQL provides another way, called "dollar quoting", to write string constants.
     * A dollar-quoted string constant consists of a dollar sign ($), an optional "tag" of zero or more characters,
     * another dollar sign, an arbitrary sequence of characters that makes up the string content, a dollar sign,
     * the same tag that began this dollar quote, and a dollar sign.
     * <p></p>
     * For example, here are two different ways to specify the string "Dianne's horse" using dollar quoting:
     * <pre>
     *     $$Dianne's horse$$
     *     $SomeTag$Dianne's horse$SomeTag$
     * </pre>
     *
     * This field will return $$ and $SomeTag$ accordingly.
     */
    public String  dolqstart;//postgresql, start part of Dollar-quoted String Constants

    private String prevsourcecode;

    public void restoreText(){
        setAstext(prevsourcecode);
        tag = 0;
    }

    public boolean insqlpluscmd;

    /*
     * source token can be end token of one or more parse tree nodes
     * NodesEndWithThisToken includes all those parse tree nodes
     */
    private Stack<TParseTreeNode> NodesEndWithThisToken = null;

    /**
     *
     *
     * A list of nodes whose end token is this token.
     *
     * @return A list of nodes whose end token is this token.
     */
    public Stack<TParseTreeNode> getNodesEndWithThisToken() {
        if (this.NodesEndWithThisToken == null){
            this.NodesEndWithThisToken = new Stack<TParseTreeNode>();
        }
        return NodesEndWithThisToken;
    }

    /*
     * source token can be start token of one or more parse tree nodes,
     * NodesStartFromThisToken includes those parse tree nodes.
     */
    private Stack<TParseTreeNode> NodesStartFromThisToken = null;

    /**
     *
     * A list of node whose start token is this token
     *
     * @return A list of node whose start token is this token
     */
    public Stack<TParseTreeNode> getNodesStartFromThisToken() {
        if (this.NodesStartFromThisToken == null){
            this.NodesStartFromThisToken = new Stack<TParseTreeNode>();
        }
        return NodesStartFromThisToken;
    }


    /**
     * SQL statement that owns this token.
     */
    public TCustomSqlStatement stmt;

    /**
     * Space to save a value for temporary use
     */
    public int tag;

    /**
     * @deprecated use {@link #setDbObjectType} instead.
     *
     * @param dbObjType the database object type
     */
    public void setDbObjType(int dbObjType) {
        this.dbObjType = dbObjType;
    }

    /**
     * Token in a {@link TObjectName} has the same database object type as the objectName.
     * Please use {@link gudusoft.gsqlparser.nodes.TObjectName#getDbObjectType} instead of this method if possible.
     *
     * @return the type of the database object
     */
    public int getDbObjType() {

        return dbObjType;
    }

    /**
     * Set the database object type of this token
     *
     * @param dbObjectType database object type
     */
    public void setDbObjectType(EDbObjectType dbObjectType) {
        this.dbObjectType = dbObjectType;
    }

    /**
     * Token in a {@link TObjectName} has the same database object type as the objectName.
     * Please use {@link gudusoft.gsqlparser.nodes.TObjectName#getDbObjectType} instead of this method if possible.
     *
     * @return the type of the database object
     */
    public EDbObjectType getDbObjectType() {

        return dbObjectType;
    }

    private EDbObjectType dbObjectType = EDbObjectType.unknown;
    private int dbObjType = TObjectName.ttobjUnknown;



    /**
     * The database vendor which the SQL script includes this token will run against
     *
     * @param dbvendor the database vendor such as Oracle, DB2 and so on.
     */
    public void setDbvendor(EDbVendor dbvendor) {
        this.dbvendor = dbvendor;
    }

    /**
     * The database vendor which the SQL script includes this token will run against
     * @return dbvendor the database vendor such as Oracle, DB2 and so on.
     */
    public EDbVendor getDbvendor() {

        return dbvendor;
    }

    private EDbVendor dbvendor;

    /**
     * set new string of this token
     *
     * @param str the new string text
     */
    public void setString(String str){
        setAstext(str);
    }

    /**
     * The original string text for this token.
     * @return  the string text
     */
    public String toString(){
        return astext != null ? astext : "";
    }
    
    

    /**
     * String text with the debug information such as coordinate, token code, token type
     *
     * @return the string value with full debug info
     */
    public String toStringDebug(){
      String ret = lineNo +","+ columnNo +","+ getAstext().length()+","+offset+","+tokencode+" "+tokentype;
      if (tokencode == TBaseType.cmtslashstar)
        {ret = ret +" multi line comment";}
      else if (tokencode == TBaseType.cmtdoublehyphen)
        {ret = ret +" single line comment";}
      else if (tokencode == TBaseType.lexspace)
        {ret = ret +" space"; }
      else if (tokencode == TBaseType.lexnewline)
        {ret = ret +" newline"; }
      else
        {ret = ret +" "+ getAstext();}
      return ret;
    }

    /**
     * Space, return, comments are treated as non-solid token by default
     *
     * @param tokentype token type
     * @return true if token type is not one of ttwhitespace,ttreturn,ttsimplecomment,ttbracketedcomment
     */
    public  static boolean isnonsolidtoken(ETokenType tokentype){
        return ( (tokentype == ETokenType.ttwhitespace) || (tokentype == ETokenType.ttreturn)
                ||(tokentype == ETokenType.ttsimplecomment)||(tokentype == ETokenType.ttbracketedcomment));
    }

    /**
     *  Is this token a solid token or not.
     *
     * @return true if it's a non-solid token.
     */
    public  boolean isnonsolidtoken(){
        return !issolidtoken();
    }

    /**
     * Is this token a non-solid token or not.
     *
     * @return true if it's a solid token.
     */
    public boolean issolidtoken(){
        return !isnonsolidtoken(this.tokentype);
    }

    private TSourceTokenList tokensBefore = null;
    private TSourceTokenList tokensAfter = null;

    /**
     * Used in sql formatter package only.
     *
     * @return source token list
     */
    public TSourceTokenList getTokensAfter() {
        if (this.tokensAfter == null){
            this.tokensAfter = new TSourceTokenList();
        }
        return tokensAfter;
    }

    /**
     * Used in sql formatter package only
     *
     * @return source token list
     */
    public TSourceTokenList getTokensBefore() {
        if (this.tokensBefore == null){
            this.tokensBefore = new TSourceTokenList();
        }
        return tokensBefore;
    }

    private TSourceToken replaceToken = null;

    /**
     * Used in sql formatter package only
     *
     * @param replaceToken replaced token
     */
    public void setReplaceToken(TSourceToken replaceToken) {
        this.replaceToken = replaceToken;
    }

    /**
     * Used in sql formatter package only
     *
     * @return replaced token
     */
    public TSourceToken getReplaceToken() {

        return replaceToken;
    }

    public  TSourceToken nextToken(){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        if (this.posinlist >= this.container.size() - 1) return null;
        return this.container.get(this.posinlist+1);
    }


    public TSourceToken searchTokenAtTheEndOfSameLine(){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        int i = this.container.searchLastTokenAtTheSameLine(this.posinlist);
        if (i == -1) return null;
        return this.container.get(i);
    }
    /**
     * Search a token before or after this token in the same source token list.
     * The result token should has the tokencode equals to the targetTokenCode
     * in a specified range.
     *
     * @param targetTokenCode, the token code need to be searched
     * @param range, &gt; 0, search token start from the next token and forward,
     * = 0, just compare with this token,
     * &lt; 0, search from the previous token and backword.
     * @return the token with the same token code, otherwise, return null.
     */
    public TSourceToken searchToken(int targetTokenCode,int range, int stopTokenCode, boolean stopAtSemiColon){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.searchToken(targetTokenCode,"",this,range,stopTokenCode,stopAtSemiColon);
    }

    public TSourceToken searchToken(int targetTokenCode,int range){
        return searchToken(targetTokenCode,range,0,false);
    }

    /**
     * Search a token before or after this token in the same source token list.
     * The result token should has the string text equals to the targetTokenText
     * in a specified range.
     *
     * @param targetTokenText, the target string text
     * @param range, &gt; 0, search token start from the next token and forward,
     * = 0, just compare with this token,
     * &lt; 0, search from the previous token and backword.
     * @return the token with the same token code, otherwise, return null.
     */
    public TSourceToken searchToken(String targetTokenText,int range, int stopTokenCode, boolean stopAtSemiColon){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.searchToken(0,targetTokenText,this,range,stopTokenCode,stopAtSemiColon);
    }

    public TSourceToken searchToken(String targetTokenText,int range) {
            return searchToken(targetTokenText,range,0,false);
    }
    /**
     * Search the first non-solid token after the next objectName.
     * <p></p>
     * Take this SQL for example:
     * <pre>
     * return new scott.func(x1);
     * </pre>
     * If this token is <code>new</code>, then call searchTokenAfterObjectName will return <code>(</code> token.
     *
     * @return solid token after the next objectName
     */
    public TSourceToken searchTokenAfterObjectName(){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        int i = container.nextObjectNameToken(posinlist,1,false);
        if (i == -1) return  ret;
        return container.get(i).nextSolidToken();
    }

    public  TSourceToken nextSolidToken(int pstep){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.nextsolidtoken(this,pstep,false);
    }


    /**
     * The next token whose {@link #tokentype} is not ttreturn,ttwhitespace,ttsimplecomment and ttbracketedcomment.
     *
     * @return the next solid token, returns null if not found.
     */
    public  TSourceToken nextSolidToken(){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.nextsolidtoken(this,1,false);
    }

    /**
     * The next token whose {@link #tokentype} is not ttreturn,ttwhitespace,ttsimplecomment and ttbracketedcomment.
     *
     * @param treatCommentAsSolidToken, set to true will treat comment token as a solid token
     * @return the solid token if found, otherwise, return null
     */
    public  TSourceToken nextSolidToken(boolean treatCommentAsSolidToken){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.nextsolidtoken(this,1,treatCommentAsSolidToken);
    }


    /**
     * The previous token whose {@link #tokentype} is not ttreturn,ttwhitespace,ttsimplecomment and ttbracketedcomment.
     *
     * @return the solid token if found, otherwise, return null
     */
    public  TSourceToken prevSolidToken(){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.nextsolidtoken(this,-1,false);
    }

    /**
     * The previous token whose {@link #tokentype} is not ttreturn,ttwhitespace,ttsimplecomment and ttbracketedcomment
     *
     * @param treatCommentAsSolidToken set to true will treat comment token as a solid token
     * @return the solid token if found, otherwise, return null
     */
    public  TSourceToken prevSolidToken(boolean treatCommentAsSolidToken){
        TSourceToken ret = null;
        if (this.container == null) return ret;
        return this.container.nextsolidtoken(this,-1,treatCommentAsSolidToken);
    }

    /**
     * Check to see if this token is the first token in a line of the input SQL
     *
     * @return true if this is the first token of a line, otherwise, return false
     */
    public boolean isFirstTokenOfLine(){
        TSourceToken st = prevSolidToken();
        if (st == null) return true;
        return  (st.lineNo != this.lineNo);
    }

    /**
     * Check to see if this token is the last token of in a line in the input SQL
     *
     * @return true if this is the last token of a line, otherwise, return false
     */
    public boolean isLastTokenOfLine(){
        TSourceToken st = nextSolidToken();
        if (st == null) return true;
        return  (st.lineNo != this.lineNo);
    }


    private TSourceToken linkToken = null;

    /**
     * Create a link between two tokens. Make it easy to access another linked token.
     * Usually, those are two tokens like the parenthesis in this SQL: <code>(select * from t)</code>
     *
     * @param linkToken the token need to be linked
     */
    public void setLinkToken(TSourceToken linkToken) {
        this.linkToken = linkToken;
        linkToken.linkToken = this;
    }

    /**
     * Gets the linked token.
     * Take this SQL for example:
     * <code>(select * from t)</code>, if this token is '(', then you call this method will return ')' token.
     *
     * @return the paired parenthesis in select, expression
     */
    public TSourceToken getLinkToken() {

        return linkToken;
    }

    /**
     * Remove double quote <code>""</code>, bracket quote <code>[]</code> , left/right brace <code>{}</code>
     * from a delimited identifier and return string text of this identifier.
     *
     * @return string text of this token
     *
     * @deprecated since 2.5.3.4
     */
    public String toUnQuotedString(){
        if ((tokentype == ETokenType.ttdqstring)
                ||(tokentype == ETokenType.ttdbstring)
                ||(tokentype == ETokenType.ttbrstring)
        ){
                  return toString().substring(1,toString().length() - 1);
        }else if ((dbvendor == EDbVendor.dbvmysql)&&(toString().startsWith("`"))){
            return toString().substring(1,toString().length() - 1);
        }else {
            return toString();
        }
    }

    /**
     * Text representation for this token.
     */
    public String getAstext() {
        return  toString(); //astext;
    }

    public void setAstext(String astext) {
        this.astext = astext;
    }
}