package gudusoft.gsqlparser.util;


import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.resolver2.format.DisplayNameMode;
import gudusoft.gsqlparser.resolver2.format.DisplayNameNormalizer;
import gudusoft.gsqlparser.resolver2.format.DisplayNamePolicy;
import gudusoft.gsqlparser.resolver2.format.IdentityLineSet;
import gudusoft.gsqlparser.resolver2.format.IdentityNameList;
import gudusoft.gsqlparser.resolver2.format.StarRedundancyLedger;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
import gudusoft.gsqlparser.util.joinRelationAnalyze;


import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Stack;

class myMetaDB implements IMetaDatabase {

    String columns[][] = {
        {"server","db","DW","AcctInfo_PT","ACCT_ID"},
        {"server","db","DW","ImSysInfo_BC","ACCT_ID"},
        {"server","db","DW","AcctInfo_PT","SystemOfRec"},
        {"server","db","DW","ImSysInfo_BC","SystemOfRec"},
        {"server","db","DW","AcctInfo_PT","OfficerCode"},
        {"server","db","DW","ImSysInfo_BC","OpeningDate"},
    };

    public boolean checkColumn(String server, String database,String schema, String table, String column){
       boolean bServer,bDatabase,bSchema,bTable,bColumn,bRet = false;
        for (int i=0; i<columns.length;i++){
            if ((server == null)||(server.length() == 0)){
                bServer = true;
            }else{
                bServer = columns[i][0].equalsIgnoreCase(server);
            }
            if (!bServer) continue;

            if ((database == null)||(database.length() == 0)){
                bDatabase = true;
            }else{
                bDatabase = columns[i][1].equalsIgnoreCase(database);
            }
            if (!bDatabase) continue;

            if ((schema == null)||(schema.length() == 0)){
                bSchema = true;
            }else{
                bSchema = columns[i][2].equalsIgnoreCase(schema);
            }

            if (!bSchema) continue;

            bTable = columns[i][3].equalsIgnoreCase(table);
            if (!bTable) continue;

            bColumn = columns[i][4].equalsIgnoreCase(column);
            if (!bColumn) continue;

            bRet =true;
            break;

        }

        return bRet;
    }

}

class TInfoRecord {

    public String getSPString(){
        if (getSPName() == null) return "N/A";
        else return getSPName().toString();
    }

    String getTableStr(gudusoft.gsqlparser.nodes.TTable table){
        String tableName ="";
        if (table.getTableType() == ETableSource.subquery) {
            tableName = "(subquery, alias:" + table.getAliasName() + ")";
        }else{
            tableName = table.getTableName().toString();
            if (table.isLinkTable()){
                tableName = tableName+"("+table.getLinkTable().getTableName().toString()+")";
            }else if (table.isCTEName()){
                tableName = tableName+"(CTE)";
            }
        }

        return tableName;
    }

    public String getFullColumnName(){
        if (dbObjectType != EDbObjectType.column) return "";
        String columnName = getColumn().getColumnNameOnly();

        if (getTable() != null 
                        && getTable( ).getObjectNameReferences( ).searchColumnReference( getColumn() )!=-1){
            if (getTableStr(getTable()).length() > 0){
                columnName = getTableStr(getTable())+"."+columnName;
            }
            schemaName = getTable().getPrefixSchema();
            if (schemaName.length() > 0) {
                columnName = schemaName+"."+columnName;
            }
            return columnName;
        }
        
       return getColumn().toString( );
    }

    public String printMe(boolean includingTitle){
        String spTitle="\nfilename|spname|object type\n";
        String tableTitle="\nfilename|spname|object type|schema|table|table effect\n";
        String columnTitle="\nfilename|spname|object type|schema|table|column|location|coordinate|datatype\n";
        String indexTitle="\nfilename|spname|object type|schema|index|table|column|location|coordinate\n";

        String schemaName = "N/A";
        String tableName = "unknownTable";
        String indexName = "unknownIndex";

        StringBuffer  sb = new StringBuffer (1024);
        switch (dbObjectType){
            case procedure:
                if (includingTitle) sb.append(spTitle);
                sb.append(getFileName()+"|"+getSPName().toString()+"|"+dbObjectType);
                break;
            case table:
                if (includingTitle) sb.append(tableTitle);

                tableName = getTableStr(getTable());
                schemaName = getTable().getPrefixSchema();
                if (schemaName.length() == 0) schemaName ="N/A";

                sb.append(getFileName()+"|"+getSPString()+"|"+dbObjectType+"|"+schemaName+"|"+tableName+"|"+getTable().getEffectType());
                break;
            case column:
                if (includingTitle) sb.append(columnTitle);
                if (getTable() != null){
                    //it's an orphan column
                    tableName = getTableStr(getTable());
                    schemaName = getTable().getPrefixSchema();
                    if (schemaName.length() == 0) schemaName ="N/A";
                }else{
                    tableName = "missed";
                }

                String datatypeStr = "";
                if ((getColumn().getLinkedColumnDef() != null)){
                    //column in create table, add datatype information as well
                    TTypeName datatype = getColumn().getLinkedColumnDef().getDatatype();
                    datatypeStr = datatype.getDataTypeName();
                    if (datatype.getLength() != null){
                        datatypeStr = datatypeStr+":"+datatype.getLength().toString();
                    } else if (datatype.getPrecision() != null){
                        datatypeStr = datatypeStr+":"+datatype.getPrecision().toString();
                        if (datatype.getScale() != null){
                            datatypeStr = datatypeStr+":"+datatype.getScale().toString();
                        }
                    }
                }
                sb.append(getFileName()+"|"+getSPString()+"|"+dbObjectType+"|"+schemaName+"|"+tableName+"|"+getColumn().toString()+"|"+getColumn().getLocation()+"|("+getColumn().coordinate()+")|"+datatypeStr);
                break;
            case index:
                if (includingTitle) sb.append(indexTitle);
                if (getTable() != null){
                    schemaName = getTable().getPrefixSchema();
                    if (schemaName.length() == 0) schemaName ="N/A";
                    tableName = getTable().getTableName().toString();
                }
                if (getIndex() != null){
                    indexName = getIndex().toString();
                }
                sb.append(getFileName()+"|"+getSPString()+"|"+dbObjectType+"|"+schemaName+"|"+indexName+"|"+tableName+"|"+getColumn().toString()+"|"+getColumn().getLocation()+"|("+getColumn().coordinate()+")");
                break;
        }

        return sb.toString();
    }

    private TObjectName index;

    public void setIndex(TObjectName index) {
        this.index = index;
    }

    public TObjectName getIndex() {

        return index;
    }

    private EDbObjectType dbObjectType;

    public void setDbObjectType(EDbObjectType dbObjectType) {
        this.dbObjectType = dbObjectType;
    }

    public EDbObjectType getDbObjectType() {

        return dbObjectType;
    }

    public TInfoRecord(){

    }

    public TInfoRecord(EDbObjectType dbObjectType){
        this.dbObjectType = dbObjectType;
    }

    public TInfoRecord(gudusoft.gsqlparser.nodes.TTable  table){
      this.table = table;
        this.dbObjectType = EDbObjectType.table;
    }

    public TInfoRecord(TInfoRecord clone, EDbObjectType dbObjectType){
        this.fileName = clone.fileName;
        this.SPName = clone.SPName;
        this.table = clone.table;
        this.column = clone.column;
        this.dbObjectType = dbObjectType;
    }

    private String fileName = "N/A";
    private TObjectName SPName ; //stored procedure name

    public void setFileName(String fileName) {
        this.fileName = fileName;
    }

    public void setSPName(TObjectName SPName) {
        this.SPName = SPName;
    }

    public void setSchemaName(String schemaName) {
        this.schemaName = schemaName;
    }

    public String getFileName() {

        return fileName;
    }

    public TObjectName getSPName() {
        return SPName;
    }

    public String getSchemaName() {
        return schemaName;
    }

    private String schemaName;

//    public String tableName;
//    public String columnName;

    private gudusoft.gsqlparser.nodes.TTable  table;

    public void setTable(gudusoft.gsqlparser.nodes.TTable  table) {
        this.table = table;
    }

    public void setColumn(TObjectName column) {
        this.column = column;
    }

    public gudusoft.gsqlparser.nodes.TTable  getTable() {

        return table;
    }

    public TObjectName getColumn() {
        return column;
    }

    private TObjectName column;
}

/**
 * 用于从SQL语句中提取表和列信息的工具类。
 *
 * <h2>表输出规则（基于 ETableSource 类型）</h2>
 *
 * <h3>默认行为</h3>
 * <p>默认情况下，此工具<b>仅输出具有表名（getTableName() != null）且不在排除列表中的表</b>。
 * 以下 {@link ETableSource} 类型的表在默认情况下<b>不会</b>出现在输出的表列表中：</p>
 * <ul>
 *   <li>{@link ETableSource#subquery} - 子查询（始终排除）</li>
 *   <li>{@link ETableSource#openquery} - OPENQUERY 表（始终排除）</li>
 *   <li>{@link ETableSource#function} - 表值函数（始终排除）</li>
 *   <li>{@link ETableSource#unnest} - UNNEST 表（因为 getTableName() 为 null，使用别名）</li>
 *   <li>{@link ETableSource#tableExpr} - 表表达式（因为 getTableName() 为 null，使用别名）</li>
 *   <li>CTE（公用表表达式）引用的表 - 默认排除，可通过 {@link #showCTE} 控制</li>
 * </ul>
 *
 * <p>以下 {@link ETableSource} 类型的表<b>会</b>出现在默认输出中（如果 getTableName() 不为 null）：</p>
 * <ul>
 *   <li>{@link ETableSource#objectname} - 普通基础表（始终输出）</li>
 *   <li>{@link ETableSource#pivoted_table} - PIVOT 表</li>
 *   <li>{@link ETableSource#lateralView} - LATERAL VIEW 表</li>
 * </ul>
 *
 * <h3>控制选项</h3>
 *
 * <h4>1. showCTE 选项</h4>
 * <p>控制是否输出 CTE（公用表表达式）相关的表：</p>
 * <ul>
 *   <li>{@code showCTE = false}（默认）：CTE 表不会出现在输出中</li>
 *   <li>{@code showCTE = true}：CTE 表会出现在输出中</li>
 * </ul>
 *
 * <h4>2. onlyPhysicalTables 选项</h4>
 * <p>控制是否仅输出物理表（与 {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter} 的 onlyPhysicalTables 选项兼容）：</p>
 * <ul>
 *   <li>{@code onlyPhysicalTables = false}（默认）：输出所有符合条件的表</li>
 *   <li>{@code onlyPhysicalTables = true}：<b>仅输出 {@link ETableSource#objectname} 类型的物理表</b>，
 *       排除以下内容：
 *       <ul>
 *         <li>{@link ETableSource#unnest} - UNNEST 表</li>
 *         <li>{@link ETableSource#pivoted_table} - PIVOT 表</li>
 *         <li>{@link ETableSource#lateralView} - LATERAL VIEW 表</li>
 *         <li>CTE（公用表表达式）引用的表</li>
 *       </ul>
 *   </li>
 * </ul>
 *
 * <h3>如何输出所有类型的表</h3>
 * <p>要在输出中包含CTE表，请设置 {@link #showCTE} = true：</p>
 * <pre>{@code
 * TGetTableColumn getTableColumn = new TGetTableColumn(EDbVendor.dbvoracle);
 * getTableColumn.showCTE = true;  // 启用CTE表的输出
 * getTableColumn.runText(sql);
 * }</pre>
 *
 * <p><b>注意：</b>即使设置了 showCTE = true，以下类型的表仍然不会出现在表列表中：</p>
 * <ul>
 *   <li>{@link ETableSource#subquery} - 子查询（不是真正的物理表）</li>
 *   <li>{@link ETableSource#openquery} - OPENQUERY 表</li>
 *   <li>{@link ETableSource#function} - 表值函数</li>
 *   <li>{@link ETableSource#unnest} - UNNEST 表（getTableName() 为 null）</li>
 *   <li>{@link ETableSource#tableExpr} - 表表达式（getTableName() 为 null）</li>
 * </ul>
 *
 * <h3>ETableSource 类型与输出对照表</h3>
 * <p><b>注意：</b>此表显示的是默认配置下的行为。showUnnest、showPivotTable、showLateralView 默认都为 true，
 * 所以即使 onlyPhysicalTables=true，这三种表类型默认也会被输出。</p>
 * <table border="1">
 *   <tr><th>ETableSource 类型</th><th>默认输出</th><th>showCTE=true</th><th>onlyPhysicalTables=true (默认 show*=true)</th><th>原因</th></tr>
 *   <tr><td>objectname</td><td>✓ 输出</td><td>✓ 输出</td><td>✓ 输出</td><td>普通基础表</td></tr>
 *   <tr><td>subquery</td><td>✗ 不输出</td><td>✗ 不输出</td><td>✗ 不输出</td><td>显式排除</td></tr>
 *   <tr><td>openquery</td><td>✗ 不输出</td><td>✗ 不输出</td><td>✗ 不输出</td><td>显式排除</td></tr>
 *   <tr><td>function</td><td>✗ 不输出</td><td>✗ 不输出</td><td>✗ 不输出</td><td>显式排除</td></tr>
 *   <tr><td>CTE 表</td><td>✗ 不输出</td><td>✓ 输出</td><td>✗ 不输出</td><td>由 showCTE 控制，onlyPhysicalTables 排除</td></tr>
 *   <tr><td>unnest</td><td>✗ 不输出</td><td>✗ 不输出</td><td>✓ 输出</td><td>由 showUnnest 控制（默认 true）</td></tr>
 *   <tr><td>tableExpr</td><td>✗ 不输出</td><td>✗ 不输出</td><td>✗ 不输出</td><td>getTableName() 为 null</td></tr>
 *   <tr><td>pivoted_table</td><td>✓ 输出</td><td>✓ 输出</td><td>✓ 输出</td><td>由 showPivotTable 控制（默认 true）</td></tr>
 *   <tr><td>lateralView</td><td>✓ 输出</td><td>✓ 输出</td><td>✓ 输出</td><td>由 showLateralView 控制（默认 true）</td></tr>
 * </table>
 *
 * <h3>其他相关选项</h3>
 * <ul>
 *   <li>{@link #showCTE} - 设置为 true 时，CTE表会包含在输出中</li>
 *   <li>{@link #onlyPhysicalTables} - 设置为 true 时，仅输出 objectname 类型的物理表</li>
 *   <li>{@link #showUnnest} - 设置为 true 时（默认），即使 onlyPhysicalTables=true，UNNEST 表也会被输出</li>
 *   <li>{@link #showPivotTable} - 设置为 true 时（默认），即使 onlyPhysicalTables=true，PIVOT 表也会被输出</li>
 *   <li>{@link #showLateralView} - 设置为 true 时（默认），即使 onlyPhysicalTables=true，LATERAL VIEW 表也会被输出</li>
 *   <li>{@link #showColumnsOfCTE} - 设置为 true 时，显示CTE中的列</li>
 *   <li>{@link #showTableEffect} - 设置为 true 时，显示表的操作类型（SELECT、INSERT、UPDATE、DELETE等）</li>
 *   <li>{@link #showDetail} - 设置为 true 时，显示详细信息</li>
 *   <li>{@link #showSummary} - 设置为 true 时（默认），显示汇总信息</li>
 * </ul>
 *
 * <h3>示例</h3>
 * <pre>{@code
 * // 示例1：仅获取物理表（默认行为）
 * TGetTableColumn gtc = new TGetTableColumn(EDbVendor.dbvoracle);
 * gtc.runText("SELECT * FROM employees e, (SELECT * FROM departments) d");
 * // 输出仅包含: employees（子查询 departments 不会出现）
 *
 * // 示例2：包含CTE表
 * TGetTableColumn gtc2 = new TGetTableColumn(EDbVendor.dbvoracle);
 * gtc2.showCTE = true;
 * gtc2.runText("WITH cte AS (SELECT * FROM t1) SELECT * FROM cte, t2");
 * // 输出包含: t1, t2, cte（因为 showCTE = true）
 *
 * // 示例3：仅输出物理表，但保留 PIVOT 表（默认行为）
 * TGetTableColumn gtc3 = new TGetTableColumn(EDbVendor.dbvoracle);
 * gtc3.onlyPhysicalTables = true;
 * gtc3.runText("SELECT * FROM t1 PIVOT (SUM(amount) FOR month IN ('Jan', 'Feb'))");
 * // 输出包含: t1 和 PIVOT 表（因为 showPivotTable 默认为 true）
 *
 * // 示例4：仅输出物理表，排除 PIVOT 表
 * TGetTableColumn gtc4 = new TGetTableColumn(EDbVendor.dbvoracle);
 * gtc4.onlyPhysicalTables = true;
 * gtc4.showPivotTable = false;  // 排除 PIVOT 表
 * gtc4.runText("SELECT * FROM t1 PIVOT (SUM(amount) FOR month IN ('Jan', 'Feb'))");
 * // 输出仅包含: t1（PIVOT 表被排除）
 * }</pre>
 *
 * @see ETableSource
 * @see ETableSource#objectname
 */
public class TGetTableColumn{


    private EDbVendor dbVendor;
    private String queryStr;
    private TGSqlParser sqlParser;
    private EResolverType resolverType = EResolverType.RESOLVER; //default to resolver

    public void setResolverType(EResolverType resolverType) {
        this.resolverType = resolverType;
    }

    private IMetaDatabase metaDatabase = null;

    public void setMetaDatabase(IMetaDatabase metaDatabase) {
        this.metaDatabase = metaDatabase;
        sqlParser.setMetaDatabase(metaDatabase);
    }

    private TSQLEnv sqlEnv = null;

    public void setSqlEnv(TSQLEnv sqlEnv) {
        this.sqlEnv = sqlEnv;
        sqlParser.setSqlEnv(sqlEnv);
    }

    private StringBuffer functionlist,schemalist,
    triggerlist,sequencelist,databaselist;

    public StringBuffer infos;

    public StringBuffer outList;

    private ArrayList<TInfoRecord> infoList;

    private ArrayList<String> fieldlist,tablelist,indexList,cteList;

    /**
     * Star entries held back from {@link #fieldlist} until the list is complete, and the proof
     * ledger that decides which of them the finished list has made redundant. Kept apart from
     * the column entries so that pruning can never touch a column, whatever it renders as.
     */
    private final java.util.List<String> pendingStarEntries = new java.util.ArrayList<String>();
    private StarRedundancyLedger starLedger;

    private StringBuffer tableColumnList;

    private String newline  = "\n";

    private String sqlFileName ="N/A";

    public boolean isConsole;
    /**
     * Include star columns (*) in output.
     *
     * <p>{@code false} mutes a table's own {@code t.*} entry outright. {@code true} does not
     * force it: the entry then appears only while the star cannot be expanded, i.e. while the
     * table's columns are not known from metadata. See {@code starEntryShouldBeListed}. That
     * narrowing needs resolver2; under {@code EResolverType.RESOLVER}/{@code NONE} this flag
     * alone decides.
     *
     * <p>Note the default here is {@code false} while
     * {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter} defaults its own
     * {@code listStarColumn} to {@code true}; set it explicitly on both before comparing the
     * two APIs.
     */
    public boolean listStarColumn;

    public boolean showTableEffect;
    public boolean showColumnLocation;
    public boolean showDatatype;
    public boolean showIndex;
    public boolean showColumnsOfCTE;
    public boolean showStarColumnOfCTE;
        public boolean linkOrphanColumnToFirstTable;
    public boolean showDetail = false;
    public boolean showSummary = true;
    public boolean showTreeStructure = false;
    public boolean showBySQLClause = false;
    public boolean showJoin = false;
    public boolean showCTE = false;
    /**
     * 控制是否仅输出物理表（与 {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter} 的 onlyPhysicalTables 选项兼容）。
     * <p>
     * 当设置为 {@code true} 时，<b>仅输出 {@link ETableSource#objectname} 类型的物理表</b>，
     * 排除以下类型：
     * <ul>
     *   <li>{@link ETableSource#unnest} - UNNEST 表</li>
     *   <li>{@link ETableSource#pivoted_table} - PIVOT 表</li>
     *   <li>{@link ETableSource#lateralView} - LATERAL VIEW 表</li>
     *   <li>CTE（公用表表达式）引用的表</li>
     * </ul>
     * </p>
     * <p>默认值：{@code false}（输出所有符合条件的表，包括 unnest、pivoted_table、lateralView 等）</p>
     *
     * @see gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter#setOnlyPhysicalTables(boolean)
     */
    public boolean onlyPhysicalTables = false;

    /**
     * 当设置为 {@code true}（默认）时，即使 {@code onlyPhysicalTables=true}，UNNEST 表也会被输出。
     * 当设置为 {@code false} 时，如果 {@code onlyPhysicalTables=true}，UNNEST 表会被排除。
     *
     * @see gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter#setShowUnnest(boolean)
     */
    public boolean showUnnest = true;

    /**
     * 当设置为 {@code true}（默认）时，即使 {@code onlyPhysicalTables=true}，PIVOT 表也会被输出。
     * 当设置为 {@code false} 时，如果 {@code onlyPhysicalTables=true}，PIVOT 表会被排除。
     *
     * @see gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter#setShowPivotTable(boolean)
     */
    public boolean showPivotTable = true;

    /**
     * 当设置为 {@code true}（默认）时，即使 {@code onlyPhysicalTables=true}，LATERAL VIEW 表也会被输出。
     * 当设置为 {@code false} 时，如果 {@code onlyPhysicalTables=true}，LATERAL VIEW 表会被排除。
     *
     * @see gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter#setShowLateralView(boolean)
     */
    public boolean showLateralView = true;

    private Stack<TStoredProcedureSqlStatement> spList;

    /** Display name normalizer for stripping delimiters (same as TSQLResolver2ResultFormatter) */
    private final DisplayNameNormalizer displayNameNormalizer;

    /** Display name mode (DISPLAY, SQL_RENDER, CANONICAL) - can be changed after instantiation */
    private DisplayNameMode displayNameMode = DisplayNameMode.SQL_RENDER;

    /** Which spelling to print when one table is written several ways. */
    private DisplayNamePolicy displayNamePolicy = DisplayNamePolicy.PREFER_DEFINITION_SITE;

    /**
     * Table names headed for the {@code Tables:} list, de-duplicated by object identity rather
     * than by rendered text. {@link #tablelist} is filled from it when the summary prints.
     */
    private IdentityNameList tableNames;

    /**
     * What each {@link #fieldlist} line stands for, index for index (null when the line has no
     * stated object). Kept beside the list so the summary can refuse to fold two different
     * objects into one line; every write to {@link #fieldlist} goes through {@link #addField}.
     */
    private final ArrayList<Object> fieldIdentities = new ArrayList<Object>();

    private void addField(String line, Object identity) {
        fieldlist.add(line);
        fieldIdentities.add(identity);
    }

    class myTokenListHandle implements ITokenListHandle {
        // 把 ${tx_date_yyyymm} 合并为一个token，token code为 TBasetype.ident
        public boolean processTokenList(TSourceTokenList sourceTokenList){
            int startIndex = -1;
            int endIndex = -1;

            for(int i=0;i< sourceTokenList.size();i++) {
                TSourceToken token = sourceTokenList.get(i);

                // Check for '$' followed immediately by '{'
                if (token.tokencode == 36) { // Check for '$'
                    if (i + 1 < sourceTokenList.size() && sourceTokenList.get(i + 1).tokencode == 123) { // Check for '{' immediately after '$'
                        startIndex = i;
                    }
                } else if (token.tokencode == 125 && startIndex != -1) { // Check for '}'
                    endIndex = i;

                }


                if (startIndex != -1 && endIndex != -1) {
                    TSourceToken firstToken = sourceTokenList.get(startIndex);
                    firstToken.tokencode = TBaseType.ident;
                    for (int j = startIndex + 1; j <= endIndex; j++) {
                        TSourceToken st = sourceTokenList.get(j);
                        st.tokenstatus = ETokenStatus.tsdeleted;
                        firstToken.setString(firstToken.getAstext() + st.getAstext());
                    }

                    //System.out.println("Found variable token: " + firstToken.toStringDebug());

                    startIndex = -1;
                    endIndex = -1;
                }
            }
            return true;
        }
    }

    String dotChar = ".";
    public  TGetTableColumn(EDbVendor pDBVendor){
       dbVendor = pDBVendor;

        sqlParser = new TGSqlParser(dbVendor);
        // sqlParser.setTokenListHandle(new myTokenListHandle());
        //sqlParser.setMetaDatabase(new myMetaDB());

        if (TBaseType.isEnableResolver2()) {
            resolverType = EResolverType.RESOLVER2;
        } else if (TBaseType.isEnableResolver()) {
            resolverType = EResolverType.RESOLVER;
        }

        if (dbVendor == EDbVendor.dbvdax){
            dotChar = "";
        }
        tablelist = new ArrayList<String>();
        fieldlist = new ArrayList<String>();
        indexList = new ArrayList<String>();
        cteList = new ArrayList<String>();
        infoList = new ArrayList<TInfoRecord>();

        spList = new Stack<TStoredProcedureSqlStatement>();

         infos = new StringBuffer();
         functionlist = new StringBuffer();
         schemalist = new StringBuffer();
         triggerlist = new StringBuffer();
         sequencelist = new StringBuffer();
         databaselist  = new StringBuffer();
        tableColumnList  = new StringBuffer();
        outList  = new StringBuffer();

        isConsole = true;
        listStarColumn = false;
        showTreeStructure = false;
        showTableEffect = false;
        showColumnLocation = false;
        linkOrphanColumnToFirstTable = true;
        showDatatype = false;
        showIndex = false;
        showCTE = false;
        showColumnsOfCTE = false;
        showColumnsOfCTE = false;

        // Initialize display name normalizer for consistent identifier formatting
        displayNameNormalizer = new DisplayNameNormalizer(dbVendor);
        displayNameNormalizer.setMode(displayNameMode);
        displayNameNormalizer.setStripDelimiters(true);
    }

    // ========== Display Name Mode Configuration ==========

    /**
     * Get the current display name mode.
     *
     * @return the current DisplayNameMode
     */
    public DisplayNameMode getDisplayNameMode() {
        return displayNameMode;
    }

    /**
     * Set the display name mode for identifier formatting.
     *
     * <p>This controls how identifiers (table names, column names) are formatted in output:</p>
     * <ul>
     *   <li>{@link DisplayNameMode#DISPLAY} - Strip delimiters, preserve original case
     *       (e.g., {@code [OrderID]} → {@code OrderID})</li>
     *   <li>{@link DisplayNameMode#SQL_RENDER} - Preserve delimiters for valid SQL regeneration
     *       (e.g., {@code [Order ID]} → {@code [Order ID]})</li>
     *   <li>{@link DisplayNameMode#CANONICAL} - Apply vendor-specific case folding
     *       (e.g., Oracle: {@code MyTable} → {@code MYTABLE})</li>
     * </ul>
     *
     * <p>This method can be called after instantiation to change the mode for each SQL text
     * being processed.</p>
     *
     * @param mode the DisplayNameMode to use
     * @return this instance for method chaining
     */
    /**
     * Choose how much delimiting {@link DisplayNameMode#SQL_RENDER} writes. Valid SQL for one
     * object is a set of spellings ({@code dbo}, {@code [dbo]}), and this picks one:
     * {@code WHEN_NEEDED} (default) delimits only what must be, {@code ALWAYS} delimits every
     * segment. Has no effect in the other modes.
     */
    public TGetTableColumn setQuotePolicy(gudusoft.gsqlparser.sqlenv.SqlNameGenerator.QuotePolicy policy) {
        displayNameNormalizer.setQuotePolicy(policy);
        return this;
    }

    public gudusoft.gsqlparser.sqlenv.SqlNameGenerator.QuotePolicy getQuotePolicy() {
        return displayNameNormalizer.getQuotePolicy();
    }

    public DisplayNamePolicy getDisplayNamePolicy() {
        return displayNamePolicy;
    }

    /**
     * Choose which spelling the {@code Tables:} list prints when the same table is written
     * several ways (Oracle {@code Sales}, {@code SALES}, {@code "SALES"}). The default,
     * {@link DisplayNamePolicy#PREFER_DEFINITION_SITE}, falls back to catalog metadata and then
     * to the first occurrence. A table that is only ever written one way is unaffected.
     */
    public TGetTableColumn setDisplayNamePolicy(DisplayNamePolicy policy) {
        this.displayNamePolicy = policy != null ? policy : DisplayNamePolicy.PREFER_DEFINITION_SITE;
        return this;
    }

    public TGetTableColumn setDisplayNameMode(DisplayNameMode mode) {
        this.displayNameMode = mode != null ? mode : DisplayNameMode.DISPLAY;
        this.displayNameNormalizer.setMode(this.displayNameMode);
        return this;
    }

    public void runText(String pQuery){
        run(pQuery,false);
    }

    public void runFile(String pFileName){
        sqlFileName = pFileName;
        run(pFileName,true);
    }

    String numberOfSpace(int pNum){
        String ret="";
        for(int i=0;i<pNum;i++){
            ret = ret+" ";
        }
        return ret;
    }

    public StringBuffer getInfos() {
        return infos;
    }


    protected void run(String pQuery, boolean isFile){
        queryStr = pQuery;
        if (isFile) sqlParser.sqlfilename = pQuery;
        else sqlParser.sqltext = pQuery;
        sqlParser.setResolverType(this.resolverType);

        int iRet = sqlParser.parse();
        if (iRet != 0){
                if(isConsole)
                        System.out.println(sqlParser.getErrormessage());
                else 
                        throw new RuntimeException(sqlParser.getErrormessage());
            return;
        }

        outList.setLength(0);
        tablelist.clear();
        tableNames = new IdentityNameList(dbVendor, displayNamePolicy);
        fieldlist.clear();
        fieldIdentities.clear();
        pendingStarEntries.clear();
        starLedger = null;
        indexList.clear();
        cteList.clear();

        for(int i=0;i<sqlParser.sqlstatements.size();i++){
            analyzeStmt(sqlParser.sqlstatements.get(i),0);
        }


       // print detailed info
        if (showDetail){
            boolean includingTitle = true;
            for(int i=0;i<infoList.size();i++){
                if (i>0){
                    includingTitle = !(infoList.get(i).getDbObjectType() == infoList.get(i-1).getDbObjectType());
                }
                                outputResult( infoList.get( i ).printMe( includingTitle ) );
            }
        }

        pruneFullyExpandedStars();

        // print summary info
        if (showSummary){
            // Tables are de-duplicated by identity: comparing rendered text case-insensitively
            // dropped BigQuery's SALES next to Sales (two tables) and split Oracle's "SALES"
            // from Sales (one table).
            tablelist.clear();
            tablelist.addAll(tableNames.resolve(displayNameMode));
            // Fields fold as before EXCEPT that lines standing for different objects stay
            // apart (BigQuery Sales.amount and SALES.amount are two columns).
            IdentityLineSet fieldLines = new IdentityLineSet();
            for (int i = 0; i < fieldlist.size(); i++) {
                fieldLines.add(fieldlist.get(i), i < fieldIdentities.size() ? fieldIdentities.get(i) : null);
            }
            fieldlist.clear();
            fieldIdentities.clear();
            fieldlist.addAll(fieldLines);
            removeDuplicateAndSort(indexList);
            removeDuplicateAndSort(cteList);

            printArray("Tables:", tablelist);
            outputResult("");
            printArray("Fields:",fieldlist);
            if(showIndex && (indexList.size() > 0)){
                printArray("Indexs:",indexList);
            }

            if(showColumnsOfCTE && (cteList.size() > 0)){
                outputResult("");
                printArray("Ctes:",cteList);
            }
        }

        // print tree structure
        if (showTreeStructure){
                        outputResult( infos.toString( ) );
        }

        if (showBySQLClause){
            ArrayList<ETableEffectType> tableEffectTypes = new ArrayList<ETableEffectType>();
            ArrayList<ESqlClause> columnClauses = new ArrayList<ESqlClause>();

            for(int i=0;i<infoList.size();i++){
                if (infoList.get(i).getDbObjectType() == EDbObjectType.table){
                    if (!tableEffectTypes.contains(infoList.get(i).getTable().getEffectType())){
                        tableEffectTypes.add(infoList.get(i).getTable().getEffectType());
                    }
                }
            }
            outputResult("Tables:");
            for(int j=0;j<tableEffectTypes.size();j++){
                outputResult("\t"+tableEffectTypes.get(j).toString());

                for(int i=0;i<infoList.size();i++){
                    if (infoList.get(i).getDbObjectType() == EDbObjectType.table){
                        gudusoft.gsqlparser.nodes.TTable  lcTable = infoList.get(i).getTable();
                        if (lcTable.getEffectType() == tableEffectTypes.get(j) && lcTable.getSubquery()==null && lcTable.getTableName()!=null){
                                outputResult("\t\t" + lcTable.toString()+ "("+lcTable.getTableName().coordinate()+")");
                        }
                    }
                }
            }

            // column
            for(int i=0;i<infoList.size();i++){
                if (infoList.get(i).getDbObjectType() == EDbObjectType.column){
                    if (!columnClauses.contains(infoList.get(i).getColumn().getLocation())){
                        columnClauses.add(infoList.get(i).getColumn().getLocation());
                    }
                }
            }
            outputResult("");
            outputResult("Columns:");
            for(int j=0;j<columnClauses.size();j++){
                outputResult("\t"+columnClauses.get(j).toString());

                for(int i=0;i<infoList.size();i++){
                    if (infoList.get(i).getDbObjectType() == EDbObjectType.column){
                        TObjectName lcColumn = infoList.get(i).getColumn();
                        if (lcColumn.getLocation() == columnClauses.get(j)){
                                outputResult("\t\t" +  infoList.get(i).getFullColumnName()+ "("+lcColumn.coordinate()+")");
                        }
                    }
                }
            }


        }
        
        if(showJoin){
                joinRelationAnalyze analysis = new joinRelationAnalyze( sqlParser, showColumnLocation );
                        outputResult( analysis.getAnalysisResult( ) );
        }

      //  System.out.println("Fields:"+newline+fieldlist.toString());
    }


        private void outputResult( String result)
        {
                if (isConsole){
                     System.out.println(result);
             //System.out.println(TBaseType.toHex(result,"UTF-8"));
                 }else {
                        //if(outList.length()>0)
                        //      outList.append(newline);
                     outList.append(result).append( newline);
                 }
        }


    void printArray(String pTitle,ArrayList<String> pList){
                outputResult( pTitle );
                Object str[] = pList.toArray( );
                for ( int i = 0; i < str.length; i++ )
                {
                        outputResult( str[i].toString( ) );
                }
    }


    void removeDuplicateAndSort(ArrayList <String>  pList){
        Collections.sort(pList, new SortIgnoreCase() );

        for ( int i = 0 ; i < pList.size() - 1 ; i ++ ) {
             for ( int j = pList.size() - 1 ; j > i; j -- ) {
               if (pList.get(j).equalsIgnoreCase((pList.get(i)))) {
                 pList.remove(j);
               }
              }
            }
    }

    protected void analyzeStmt(TCustomSqlStatement stmt, int pNest){
        gudusoft.gsqlparser.nodes.TTable  lcTable = null;
        TObjectName lcColumn = null;
        String tn = "",cn="";

        if (stmt instanceof  TStoredProcedureSqlStatement){
            spList.push((TStoredProcedureSqlStatement)stmt);
            TInfoRecord spRecord = new TInfoRecord(EDbObjectType.procedure);
            spRecord.setSPName(spList.peek().getStoredProcedureName());
        }
        //System.out.println( numberOfSpace(pNest)+ stmt.sqlstatementtype);
        infos.append(numberOfSpace(pNest) + stmt.sqlstatementtype+newline);

        for(int i=0;i<stmt.tables.size();i++){
            //if  (stmt.tables.getTable(i).isBaseTable())
            //{
             lcTable = stmt.tables.getTable(i);
             if (showColumnsOfCTE && lcTable.isCTEName()){
                 for(TAttributeNode node:lcTable.getAttributes()){
                     if ((node.getName().endsWith("*")) && (!showStarColumnOfCTE)) continue;
                     cteList.add(displayNameNormalizer.normalizeQualifiedName(node.getName()));
                 }
             }
             TInfoRecord tableRecord = new TInfoRecord(lcTable);
            tableRecord.setFileName(this.sqlFileName);
            if (spList.size() > 0){
                tableRecord.setSPName(spList.peek().getStoredProcedureName());
            }
            infoList.add(tableRecord);

                        if ( lcTable.getTableType( ) == ETableSource.subquery )
                        {
                                tn = "(subquery, alias:" + lcTable.getAliasName( ) + ")";
                        }
                        else if ( lcTable.getTableType( ) == ETableSource.tableExpr )
                        {
                                tn = "(table expression, alias:"
                                                + lcTable.getAliasName( )
                                                + ")";
                        }
            else if ( lcTable.getTableType( ) == ETableSource.openquery )
            {
                tn = "(table openquery, alias:"
                        + lcTable.getAliasName( )
                        + ")";

                if (lcTable.getSubquery() != null){
                    analyzeStmt(lcTable.getSubquery(),pNest++);
                }
            }else if (lcTable.getTableType() == ETableSource.function){
                tn = "(table-valued function:"
                        + normalizeTableName(lcTable.getTableName())
                        + ")";
            }
            else if (lcTable.getTableType() == ETableSource.pivoted_table){
                // Check if this is UNPIVOT or PIVOT
                boolean isUnpivot = false;
                // First try to get from TPivotClause
                if (lcTable.getPivotedTable() != null && lcTable.getPivotedTable().getPivotClause() != null) {
                    isUnpivot = (lcTable.getPivotedTable().getPivotClause().getType() == TPivotClause.unpivot);
                } else {
                    // Fallback: check if the table alias suggests UNPIVOT
                    // When no explicit alias is provided, TPivotClause.doParse() uses "unpivot_alias"
                    String tableName = lcTable.getTableName() != null ? lcTable.getTableName().toString() : "";
                    String aliasName = lcTable.getAliasName() != null ? lcTable.getAliasName() : "";
                    isUnpivot = tableName.startsWith("unpivot_") || aliasName.startsWith("unpivot_");
                }
                String prefix = isUnpivot ? "(unpivot-table:" : "(pivot-table:";
                tn = prefix + normalizeTableName(lcTable.getTableName()) + ")";
            }
            else if (lcTable.getTableType() == ETableSource.unnest){
                tn = "(unnest-table:"
                        + lcTable.getAliasName( )
                        + ")";
            }
            else if (lcTable.getTableType() == ETableSource.lateralView){
                tn = "(lateral_view:"
                        + normalizeTableName(lcTable.getTableName())
                        + ")";
            }
                        else if ( lcTable.getTableName( ) != null )
                        {
                                tn = normalizeTableName(lcTable.getTableName());
                                if ( lcTable.isLinkTable( ) )
                                {
                                        tn = tn
                                                        + "("
                                                        + normalizeTableName(lcTable.getLinkTable().getTableName())
                                                        + ")";
                                }
                                else if ( lcTable.isCTEName( ) )
                                {
                                        tn = tn + "(CTE)";
                                }
                        }
                //System.out.println(numberOfSpace(pNest+1)+tn.getName());
                if ((showTableEffect) &&(lcTable.isBaseTable())){
                    infos.append(numberOfSpace(pNest+1)+ tn+"("+lcTable.getEffectType()+")"+newline);
                }else{
                    infos.append(numberOfSpace(pNest+1)+ tn+newline);
                }

                tableColumnList.append(","+tn);

                // Determine if this table should be added to the tablelist
                // When onlyPhysicalTables=true, only ETableSource.objectname tables (non-CTE) are included
                // unless showUnnest/showPivotTable/showLateralView are true for those types
                boolean shouldAddTable;
                if (shouldSkipTableForPhysicalFilter(lcTable)) {
                    shouldAddTable = false;
                } else {
                    shouldAddTable = !((lcTable.getTableType() == ETableSource.subquery)
                            || (lcTable.isCTEName()&&(!showCTE))
                            ||(lcTable.getTableType() == ETableSource.openquery)
                            ||(lcTable.getTableType() == ETableSource.function)) && lcTable.getTableName()!=null;
                }

                if (shouldAddTable) {
                   TObjectName listedName = lcTable.isLinkTable()
                           ? lcTable.getLinkTable().getTableName() : lcTable.getTableName();
                   String tableName = normalizeTableName(listedName);
                   // Add table effect type if showTableEffect is enabled and it's a base table
                   String decoration = null;
                   if (showTableEffect && lcTable.isBaseTable()) {
                       decoration = "(" + lcTable.getEffectType() + ")";
                       tableName = tableName + decoration;
                   }
                   boolean definitionSite = lcTable.getEffectType() == ETableEffectType.tetCreate
                           || lcTable.getEffectType() == ETableEffectType.tetCreateAs;
                   tableNames.add(tableName, listedName.toString(), ESQLDataObjectType.dotTable,
                           decoration, definitionSite, catalogRenderedTableName(listedName, decoration));
                }


                for (int j=0;j<stmt.tables.getTable(i).getLinkedColumns().size();j++){
                    lcColumn = stmt.tables.getTable(i).getLinkedColumns().getObjectName(j);
                    if (lcColumn.getValidate_column_status() == TBaseType.MARKED_NOT_A_COLUMN_IN_COLUMN_RESOLVER) continue;
                    TInfoRecord columnRecord = new TInfoRecord(tableRecord,EDbObjectType.column);
                    columnRecord.setColumn(lcColumn);
                    infoList.add(columnRecord);
                    cn = normalizeColumnName(lcColumn.getColumnNameOnly());
                    if ((showDatatype)&&(lcColumn.getLinkedColumnDef() != null)){
                        //column in create table, add datatype information as well
                        TTypeName datatype = lcColumn.getLinkedColumnDef().getDatatype();
                        cn = cn + ":"+datatype.getDataTypeName();
                        if (datatype.getLength() != null){
                            cn = cn+":"+datatype.getLength().toString();
                        } else if (datatype.getPrecision() != null){
                            cn = cn+":"+datatype.getPrecision().toString();
                            if (datatype.getScale() != null){
                                cn = cn+":"+datatype.getScale().toString();
                            }
                        } else if (datatype.getDisplayLength() != null){
                            cn = cn+":"+datatype.getDisplayLength().toString();
                        }
                    }
                    //System.out.println(numberOfSpace(pNest+2)+cn.getColumnNameOnly());
                    if (showColumnLocation){
                        String  posStr = "";
//                        if ( lcColumn.getColumnToken() != null) {
//                            TSourceToken lcStartToken = lcColumn.getColumnToken();
//                            posStr ="("+ lcStartToken.lineNo+","+lcStartToken.columnNo+ ")";
//                        }
                        infos.append(numberOfSpace(pNest+3)+ lcColumn.getColumnNameOnly()+posStr+"("+lcColumn.getLocation()+")"+newline);
                    }else{
                        infos.append(numberOfSpace(pNest+3)+ lcColumn.getColumnNameOnly()+newline);
                    }

                    // Determine if this field should be added to the fieldlist
                    // When onlyPhysicalTables=true, only include fields from physical tables
                    // unless showUnnest/showPivotTable/showLateralView are true for those types
                    boolean shouldAddField;
                    if (shouldSkipTableForPhysicalFilter(lcTable)) {
                        shouldAddField = false;
                    } else {
                        shouldAddField = !((lcTable.getTableType() == ETableSource.subquery)||(lcTable.isCTEName()&&(!showCTE)));
                    }

                    if (shouldAddField){
                         // Skip star columns for PIVOT tables - individual columns are output via namespace
                         // The wildcard is told by its TOKEN, never by its text: a column may
                         // legally be named "*" (Oracle, or [*] on SQL Server), and its display
                         // name is bare.
                         TSourceToken columnPart = lcColumn.getPartToken();
                         boolean isStarColumn = columnPart != null && columnPart.tokentype == ETokenType.ttasterisk;
                         boolean isPivotTable = lcTable.getTableType() == ETableSource.pivoted_table;
                         if (isStarColumn && isPivotTable) {
                             // Skip star for pivot tables
                         } else if ((listStarColumn) || (!isStarColumn)){
                             String fieldName;
                             if (lcTable.isLinkTable()){
                                 fieldName = normalizeTableName(lcTable.getLinkTable().getTableName()) + dotChar + cn;
                             }else{
                                 fieldName = tn + dotChar + cn;
                             }
                             // Add column location if showColumnLocation is enabled
                             if (showColumnLocation) {
                                 fieldName = fieldName + "(" + lcColumn.getLocation() + ")";
                             }
                             String fieldPrefix = lcTable.isLinkTable()
                                     ? normalizeTableName(lcTable.getLinkTable().getTableName()) : tn;
                             if (isStarColumn) {
                                 pendingStarEntries.add(fieldName);
                                 starLedger().recordStar(fieldName, fieldPrefix, lcTable);
                             } else {
                                 TObjectName ownerName = lcTable.isLinkTable()
                                         ? lcTable.getLinkTable().getTableName() : lcTable.getTableName();
                                 addField(fieldName, IdentityLineSet.fieldIdentity(dbVendor,
                                         ownerName != null ? ownerName.toString() : null, fieldPrefix,
                                         lcColumn.getColumnNameOnly()));
                                 starLedger().recordColumn(fieldPrefix, fieldName, lcColumn, lcTable);
                             }
                         }
                    }
                    tableColumnList.append(","+tn+dotChar+ cn);
                }
                //add by grq 2023.07.09 issue=I7ITBQ

//                if(stmt.sqlstatementtype.equals(ESqlStatementType.sstinsert)){
//                    TInsertSqlStatement insertStmt = (TInsertSqlStatement) stmt;
//                    if(insertStmt.getColumnList() == null || insertStmt.getColumnList().size()<=0){
//                        TSelectSqlStatement selectStmt = insertStmt.getSubQuery();
//                        if(selectStmt != null){
//                            for (int j=0;j<selectStmt.getResultColumnList().size();j++){
//                                TResultColumn rsColumn = selectStmt.getResultColumnList().getResultColumn(j);
//                                if(rsColumn.getLocation().equals(ESqlClause.unknown)){
//                                    rsColumn.setLocation(ESqlClause.selectList);
//                                }
//                                TInfoRecord columnRecord = new TInfoRecord(tableRecord,EDbObjectType.column);
//                                TObjectName objectCloumn = rsColumn.getAliasClause()==null? null: rsColumn.getAliasClause().getAliasName();
//                                if(objectCloumn == null){
//                                    objectCloumn = rsColumn.getColumnFullname();
//                                }
//                                columnRecord.setColumn(objectCloumn);
//                                infoList.add(columnRecord);
//                                cn = rsColumn.getColumnAlias();
//                                if(StringUtils.isEmpty(cn)){
//                                    cn = rsColumn.getColumnNameOnly();
//                                }
//                                if (showColumnLocation){
//                                    String  posStr = "";
//                                    infos.append(numberOfSpace(pNest+3)+ cn + posStr+"("+rsColumn.getLocation()+")"+newline);
//                                }else{
//                                    infos.append(numberOfSpace(pNest+3)+ cn + newline);
//                                }
//
//                                if (!((lcTable.getTableType() == ETableSource.subquery)||(lcTable.isCTEName()&&(!showCTE)))){
//                                    if ((listStarColumn) || (!(rsColumn.getColumnNameOnly().equals("*")))){
//                                        if (lcTable.isLinkTable()){
//                                            fieldlist.add(lcTable.getLinkTable().getTableName() + dotChar + cn );
//                                        }else{
//                                            fieldlist.add(tn + dotChar + cn );
//                                        }
//                                    }
//                                }
//                                tableColumnList.append(","+tn+dotChar+ cn);
//                            }
//                        }
//                    }
//                }
                //end by grq
            //}
        }

        if (stmt.getOrphanColumns().size() > 0){
           // infos.append(numberOfSpace(pNest+1)+" orphan columns:"+newline);
            String oc = "";
            for (int k=0;k<stmt.getOrphanColumns().size();k++){
                TObjectName orphanCol = stmt.getOrphanColumns().getObjectName(k);
                // Skip if already resolved
                if (orphanCol.getResolveStatus() == TBaseType.RESOLVED_AND_FOUND)
                    continue;
                // Skip if column already has a sourceTable (it's been resolved to a table)
                // This handles cases like UNNEST where the table is virtual, not physical
                if (orphanCol.getSourceTable() != null)
                    continue;
                TInfoRecord columnRecord = new TInfoRecord(EDbObjectType.column);
                columnRecord.setColumn(stmt.getOrphanColumns().getObjectName(k));
                columnRecord.setFileName(this.sqlFileName);
                infoList.add(columnRecord);

                oc = normalizeColumnName(stmt.getOrphanColumns().getObjectName(k).getColumnNameOnly());// stmt.getOrphanColumns().getObjectName(k).toString();
                if (showColumnLocation){
                    infos.append(numberOfSpace(pNest+3)+oc+"("+stmt.getOrphanColumns().getObjectName(k).getLocation()+")"+newline);
                }else{
                    infos.append(numberOfSpace(pNest+3)+oc+newline);
                }

                if ((linkOrphanColumnToFirstTable)&&(stmt.getFirstPhysicalTable() != null)){
                    if ((listStarColumn) ||(!(oc.equalsIgnoreCase("*")))) {
                        String fieldName = normalizeTableName(stmt.getFirstPhysicalTable().getTableName()) + dotChar + oc;
                        // Add column location if showColumnLocation is enabled
                        if (showColumnLocation) {
                            fieldName = fieldName + "(" + stmt.getOrphanColumns().getObjectName(k).getLocation() + ")";
                        }
                        addOutsideLedger(fieldName);
                    }
                    columnRecord.setTable(stmt.getFirstPhysicalTable());
                }else {
                    String fieldName = "missed" + dotChar + oc + "(" + stmt.getOrphanColumns().getObjectName(k).coordinate() + ")";
                    // Add column location if showColumnLocation is enabled (for orphan columns)
                    if (showColumnLocation) {
                        fieldName = fieldName + "(" + stmt.getOrphanColumns().getObjectName(k).getLocation() + ")";
                    }
                    addOutsideLedger(fieldName);
                }
                tableColumnList.append(",missed"+dotChar+oc+newline);

                TObjectName column = stmt.getOrphanColumns().getObjectName(k);
//                if (column.isOrphanColumn()){
//                    System.out.println("Candidate table size of column: "+ column.toString()+" ,"+ column.getCandidateTables().size());
//                }

            }
        }

        for(int i=0;i<stmt.getIndexColumns().size();i++){
            TColumnWithSortOrder indexColumn = stmt.getIndexColumns().getElement(i);
            TInfoRecord indexRecord = new TInfoRecord(EDbObjectType.index);
            indexRecord.setColumn(indexColumn.getColumnName());
            indexRecord.setFileName(this.sqlFileName);
            infoList.add(indexRecord);


            String tableName = "unknownTable";
            String indexName = "unknownIndex";
            if (indexColumn.getOwnerTable() != null){
                tableName = normalizeTableName(indexColumn.getOwnerTable().getTableName());
                indexRecord.setTable(indexColumn.getOwnerTable());
            }
            if (indexColumn.getOwnerConstraint() != null){
                if (indexColumn.getOwnerConstraint().getConstraintName() != null){
                    indexName = normalizeColumnName(indexColumn.getOwnerConstraint().getConstraintName().toString());
                    indexRecord.setIndex(indexColumn.getOwnerConstraint().getConstraintName());
                }
            }
            indexList.add(tableName + ":" + normalizeColumnName(indexColumn.getColumnName().toString())+":"+indexName);
        }

        for (int i=0;i<stmt.getStatements().size();i++){
            analyzeStmt(stmt.getStatements().get(i),pNest+1);
        }

        if (stmt instanceof  TStoredProcedureSqlStatement){
            TStoredProcedureSqlStatement p = (TStoredProcedureSqlStatement)stmt;
            for(int i=0;i<p.getBodyStatements().size();i++){
                analyzeStmt(p.getBodyStatements().get(i),pNest+1);
            }
            spList.pop();
        }

    }

    /**
     * 判断表是否为物理表（基于 {@link ETableSource#objectname} 类型）。
     * <p>
     * 仅当表类型为 {@link ETableSource#objectname} 且不是 CTE 引用时，返回 true。
     * 这与 {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter#isPhysicalTable} 的行为一致。
     * </p>
     *
     * @param table 要检查的表
     * @return 如果是物理表返回 true，否则返回 false
     */
    private boolean isPhysicalTable(gudusoft.gsqlparser.nodes.TTable table) {
        if (table == null) return false;

        // Only objectname type tables can be physical tables
        // This filters out subqueries, joins, functions, pivoted tables, unnest, lateralView, etc.
        if (table.getTableType() != ETableSource.objectname) {
            return false;
        }

        // Tables from CTE are considered virtual, not physical
        if (table.isCTEName()) {
            return false;
        }

        return true;
    }

    /**
     * 检查表是否应该被跳过，基于 onlyPhysicalTables 和 show* 选项。
     *
     * <p>当 onlyPhysicalTables=true 时，表会被跳过，除非：</p>
     * <ul>
     *   <li>它是物理表（isPhysicalTable 返回 true）且不是 CTAS 目标表</li>
     *   <li>它是 UNNEST 表且 showUnnest=true</li>
     *   <li>它是 PIVOT 表且 showPivotTable=true</li>
     *   <li>它是 LATERAL VIEW 表且 showLateralView=true</li>
     * </ul>
     *
     * @param table 要检查的表
     * @return 如果表应该被跳过返回 true，如果应该包含返回 false
     */
    private boolean shouldSkipTableForPhysicalFilter(gudusoft.gsqlparser.nodes.TTable table) {
        if (!onlyPhysicalTables) {
            return false; // Not filtering, don't skip
        }

        // CTAS target tables are DDL targets, not existing physical tables
        // They have ETableEffectType.tetCreateAs effect type
        if (table.getEffectType() == ETableEffectType.tetCreateAs) {
            return true;
        }

        // Physical tables are always included when onlyPhysicalTables=true
        if (isPhysicalTable(table)) {
            return false;
        }

        // Check if table type should be included based on show* options
        ETableSource tableType = table.getTableType();
        if (tableType == ETableSource.unnest && showUnnest) {
            return false;
        }
        if (tableType == ETableSource.pivoted_table && showPivotTable) {
            return false;
        }
        if (tableType == ETableSource.lateralView && showLateralView) {
            return false;
        }

        // All other non-physical tables are skipped when onlyPhysicalTables=true
        return true;
    }

    // ========== Identifier Normalization Methods ==========

    /**
     * Normalize a table name for consistent output formatting.
     *
     * <p>This uses the same normalization mechanism as
     * {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter} to ensure
     * uniform identifier formatting across both tools.</p>
     *
     * <p>The normalization strips delimiters (quotes, brackets, backticks) while
     * preserving the original case. This handles:</p>
     * <ul>
     *   <li>Double quotes: {@code "table_name"} → {@code table_name}</li>
     *   <li>Square brackets: {@code [table_name]} → {@code table_name}</li>
     *   <li>Backticks: {@code `table_name`} → {@code table_name}</li>
     *   <li>Multi-part names: {@code [schema].[table]} → {@code schema.table}</li>
     * </ul>
     *
     * @param tableName The TObjectName representing the table name
     * @return The normalized table name string
     */
    /** The catalog rung of the display-name policy; see {@link IdentityNameList#renderCatalogTableName}. */
    private String catalogRenderedTableName(TObjectName tableName, String decoration) {
        String rendered = IdentityNameList.renderCatalogTableName(dbVendor, sqlEnv, tableName, displayNameMode,
                displayNameNormalizer.getQuotePolicy());
        if (rendered == null) return null;
        return decoration == null ? rendered : rendered + decoration;
    }

    private String normalizeTableName(TObjectName tableName) {
        if (tableName == null) return "";
        String fullName = tableName.toString();
        if (fullName == null || fullName.isEmpty()) return "";
        return displayNameNormalizer.normalizeQualifiedName(fullName, ESQLDataObjectType.dotTable);
    }

    /**
     * Normalize a column name for consistent output formatting.
     *
     * <p>This uses the same normalization mechanism as
     * {@link gudusoft.gsqlparser.resolver2.TSQLResolver2ResultFormatter} to ensure
     * uniform identifier formatting across both tools.</p>
     *
     * @param columnName The raw column name which may include quotes
     * @return The normalized column name
     */
    private String normalizeColumnName(String columnName) {
        if (columnName == null || columnName.isEmpty()) return columnName;
        return displayNameNormalizer.normalizeIdentifier(columnName);
    }

    /**
     * Release the held-back star entries into {@link #fieldlist}, minus the ones the finished
     * list has made redundant.
     *
     * <p>A {@code t.*} entry is dropped only once every one of that table's known columns
     * reached the list under the same prefix, proven by identity of what was emitted — see
     * {@link StarRedundancyLedger}. Metadata alone is not enough: a table with a column the
     * query never names keeps its star, since the star is then the only remaining record that
     * the table has more columns. Expandability can only be judged from resolver2's scope
     * build; without it ({@code EResolverType.RESOLVER} / {@code NONE}) nothing is pruned and
     * {@link #listStarColumn} alone decides, as before.
     */
    private void pruneFullyExpandedStars() {
        if (!pendingStarEntries.isEmpty()) {
            java.util.Set<String> redundant = starLedger().redundantStarEntries(fieldlist);
            for (String starEntry : pendingStarEntries) {
                if (!redundant.contains(starEntry)) addField(starEntry, null);
            }
            pendingStarEntries.clear();
        }
        if (starLedger != null) starLedger.clear();
    }

    /**
     * Put a line into {@link #fieldlist} that no ledger record accounts for (an orphan linked to
     * the first table, a {@code missed.} line), and tell the ledger so: the line still folds
     * with recorded lines in the list's de-duplication, and a member whose only line it
     * swallowed has not reached the reader.
     */
    private void addOutsideLedger(String line) {
        addField(line, null);
        starLedger().recordForeignLine(line);
    }

    private StarRedundancyLedger starLedger() {
        if (starLedger == null) {
            starLedger = new StarRedundancyLedger(
                    sqlParser == null ? null : sqlParser.getResolver2(), dbVendor);
        }
        return starLedger;
    }

}

 class SortIgnoreCase implements Comparator<Object> {
        public int compare(Object o1, Object o2) {
            String s1 = (String) o1;
            String s2 = (String) o2;
            return s1.toLowerCase(java.util.Locale.ROOT).compareTo(s2.toLowerCase(java.util.Locale.ROOT));
        }
    }