package gudusoft.gsqlparser.util;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.dlineage.dataflow.model.ModelBindingManager;
import gudusoft.gsqlparser.dlineage.dataflow.model.SubType;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.table;
import gudusoft.gsqlparser.pp.para.GFmtOpt;
import gudusoft.gsqlparser.pp.para.GFmtOptFactory;
import gudusoft.gsqlparser.pp.para.styleenums.TCaseOption;
import gudusoft.gsqlparser.pp.stmtformatter.FormatterFactory;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

import java.io.*;
import java.nio.charset.Charset;
import java.security.MessageDigest;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class SQLUtil {
    private static final Logger logger = LoggerFactory.getLogger(SQLUtil.class);


    public static String formatSql( EDbVendor dbVendor, String inputQuery )
    {
        String Result = inputQuery;
        TGSqlParser sqlparser = new TGSqlParser( dbVendor );
        sqlparser.sqltext = inputQuery;
        int ret = sqlparser.parse( );
        if ( ret == 0 )
        {
            GFmtOpt option = GFmtOptFactory.newInstance();
            option.caseFuncname = TCaseOption.CoNoChange;
            Result = FormatterFactory.pp(sqlparser, option);
        }
        return Result;
    }

    public static boolean isEmpty(String value) {
        return value == null || value.trim().length() == 0;
    }

    public static String getFileContent(File file) {
        String charset = null;
        String sqlfilename = file.getAbsolutePath();
        int read = 0;
        try {
            FileInputStream fr = new FileInputStream(sqlfilename);
            byte[] bom = new byte[4];
            fr.read(bom, 0, bom.length);

            if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE)
                    && (bom[3] == (byte) 0xFF)) {
                charset = "UTF-32BE";
                read = 4;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
                    && (bom[3] == (byte) 0x00)) {
                charset = "UTF-32LE";
                read = 4;
            } else if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
                charset = "UTF-8";
                read = 3;
            } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
                charset = "UTF-16BE";
                read = 2;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
                charset = "UTF-16LE";
                read = 2;
            } else {
                charset = "UTF-8";
                read = 0;
            }

            fr.close();
        } catch (IOException e) {
            logger.error("Check file encoding failed.", e);
        }

        Long filelength = file.length();
        byte[] filecontent = new byte[filelength.intValue()];
        try {
            InputStream in = new BufferedInputStream(new FileInputStream(sqlfilename));
            in.read(filecontent);
            in.close();
        } catch (IOException e) {
            logger.error("read file content failed.", e);
        }

        byte[] content = new byte[filelength.intValue() - read];
        System.arraycopy(filecontent, read, content, 0, content.length);

        try {
            String fileContent = new String(content, charset == null ? Charset.defaultCharset().name() : charset);
            return fileContent.replace((char) 160, (char) 32);
        } catch (UnsupportedEncodingException e) {
            logger.error("The OS does not support " + charset == null ? Charset.defaultCharset().name() : charset, e);
            return null;
        }
    }

    public static String getInputStreamContent(InputStream is, boolean close) {
        try {
            ByteArrayOutputStream out = new ByteArrayOutputStream(4096);
            byte[] tmp = new byte[4096];
            while (true) {
                int r = is.read(tmp);
                if (r == -1)
                    break;
                out.write(tmp, 0, r);
            }
            byte[] bytes = out.toByteArray();
            if (close) {
                is.close();
            }
            out.close();
            String content = new String(bytes);
            return content;
        } catch (IOException e) {
            logger.error("read inputStream failed.", e);
        }
        return null;
    }

    public static String getFileContent(String filePath) {
        if (filePath == null)
            return "";
        File file = new File(filePath);
        if (!file.exists() || file.isDirectory())
            return "";
        return getFileContent(file);
    }

    public static String trimColumnStringQuote(String string) {
        try {
            if (string == null)
                return string;

            if (string.indexOf('.') != -1) {
                List<String> splits = parseNames(string);
                if (splits.size() > 1) {
                    StringBuilder buffer = new StringBuilder();
                    for (int i = 0; i < splits.size(); i++) {
                        String segment = splits.get(i);
                        if (parseNames(trimColumnStringQuote(segment)).size() > 1) {
                            buffer.append(segment);
                        } else {
                            buffer.append(trimColumnStringQuote(segment));
                        }
                        if (i < splits.size() - 1) {
                            buffer.append(".");
                        }
                    }
                    string = buffer.toString();
                    return string;
                }
            }
            if (string.length() < 2) {
                return string;
            }
            if (string.startsWith("'") && string.endsWith("'"))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("\"") && string.endsWith("\""))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("`") && string.endsWith("`"))
                return string.substring(1, string.length() - 1);
            else if (string.startsWith("[") && string.endsWith("]"))
                return string.substring(1, string.length() - 1);
            return string;
        }catch (Exception e){
            return string;
        }
    }

//    public static List<String> parseNames(String nameString, EDbVendor vendor) {
//        List<String> names = new ArrayList<String>();
//        if (nameString.startsWith("`") && nameString.endsWith("`")){
//            nameString = nameString.substring(1,nameString.length()-1);
//        }
//        String[] splits = nameString.trim().split("\\.");
//
//        for (int i = 0; i < splits.length; i++) {
//            String split = splits[i].trim();
//            if (TSQLEnv.isDelimitedIdentifier(vendor, split) && !TSQLEnv.endsWithDelimitedIdentifier(vendor, split)) {
//                StringBuilder buffer = new StringBuilder();
//                buffer.append(splits[i]);
//                while (i < splits.length - 1
//                        && !TSQLEnv.endsWithDelimitedIdentifier(vendor, split = splits[++i].trim())) {
//                    buffer.append(".");
//                    buffer.append(splits[i]);
//                }
//
//                buffer.append(".");
//                buffer.append(splits[i]);
//
//                names.add(buffer.toString());
//                continue;
//            }
//            names.add(splits[i]);
//        }
//        return names;
//    }

    public static List<String> parseNames(String nameString) {
        return parseNames(nameString, null);
    }

    // Pre-compiled patterns for better performance
    private static final java.util.regex.Pattern DOT_PATTERN = java.util.regex.Pattern.compile("\\s*\\.\\s*");
    
//    // LRU Cache for parseNames results - thread-safe with limited size
    private static final java.util.Map<String, List<String>> PARSE_NAMES_CACHE =
        Collections.synchronizedMap(new java.util.LinkedHashMap<String, List<String>>(256, 0.75f, true) {
            @Override
            protected boolean removeEldestEntry(java.util.Map.Entry<String, List<String>> eldest) {
                return size() > 10000; // Keep cache under 10000 entries
            }
        });

    /**
     * 解析以点号分隔的 SQL 标识符或表达式，并返回各层级片段。
     * <p>
     * 用途：
     * <ul>
     *   <li>将类似 catalog.schema.table.column 的全限定名拆分为有序片段；</li>
     *   <li>在拆分时识别并保留引号/括号内的点号，不做误分割；</li>
     *   <li>根据不同数据库厂商（如 BigQuery）的定界符规则进行处理。</li>
     * </ul>
     * 工作机制：
     * <ol>
     *   <li>按「可选空格 + '.' + 可选空格」初步切分；</li>
     *   <li>对以下情况进行片段合并直至遇到闭合符号：
     *     <ul>
     *       <li>单引号字符串：'...'</li>
     *       <li>双引号定界标识符："..."</li>
     *       <li>反引号定界标识符：`...`</li>
     *       <li>方括号定界标识符：[...]</li>
     *       <li>函数/表达式括号：(...)</li>
     *     </ul>
     *   </li>
     *   <li>BigQuery（vendor == dbvbigquery）且包含反引号时，会先去除反引号再进行切分。</li>
     *   <li>入参为 null 返回空列表；发生异常时返回仅包含原始字符串的列表。</li>
     * </ol>
     * 示例：
     * <pre>
     *  "dbo.Employee.Name"                    -> ["dbo", "Employee", "Name"]
     *  "[Sales DB].[Employee].[Name]"        -> ["[Sales DB]", "[Employee]", "[Name]"]
     *  "\"My.Schema\".\"My.Table\""       -> ["\"My.Schema\"", "\"My.Table\""]
     *  "`project.dataset.table`" (BigQuery)  -> ["project", "dataset", "table"]
     *  "OPENJSON(aptd.test.ActiviteTypeIDs)" -> ["OPENJSON(aptd.test.ActiviteTypeIDs)"]
     * </pre>
     *
     * @param nameString 待解析的标识符或表达式字符串
     * @param vendor 数据库厂商（用于处理厂商特定定界符，如 BigQuery 的反引号），可为 null
     * @return 解析后的片段列表；顺序与层级一致
     */
    public static List<String> parseNames(String nameString, EDbVendor vendor) {
        if(nameString == null){
            return Collections.emptyList();
        }
        
        // Cache lookup - use a simple cache key
        String cacheKey = vendor == null ? nameString : (vendor.ordinal() + ":" + nameString);
        List<String> cached = PARSE_NAMES_CACHE.get(cacheKey);
        if (cached != null) {
            return new ArrayList<String>(cached);
        }
        
        String name = nameString.trim();
        
        // Fast path: simple names without special characters
        // Check once for all special characters in a single pass
        boolean hasSpecialChar = false;
        boolean hasSingleQuote = false;
        boolean hasDoubleQuote = false;
        boolean hasBacktick = false;
        boolean hasParenthesis = false;
        boolean hasBracket = false;
        
        for (int i = 0, len = name.length(); i < len; i++) {
            char c = name.charAt(i);
            switch (c) {
                case '\'':
                    hasSingleQuote = true;
                    hasSpecialChar = true;
                    break;
                case '"':
                    hasDoubleQuote = true;
                    hasSpecialChar = true;
                    break;
                case '`':
                    hasBacktick = true;
                    hasSpecialChar = true;
                    break;
                case '(':
                case ')':
                    hasParenthesis = true;
                    hasSpecialChar = true;
                    break;
                case '[':
                case ']':
                    hasBracket = true;
                    hasSpecialChar = true;
                    break;
            }
        }
        
        List<String> names = new ArrayList<String>(4); // Pre-size for typical case
        
        // Handle BigQuery special case
        if (vendor == EDbVendor.dbvbigquery && hasBacktick) {
            String[] parts = DOT_PATTERN.split(name.replace("`", ""));
            for (String part : parts) {
                names.add(part);
            }
            putCache(cacheKey, names);
            return names;
        }
        
        try {
            String[] splits = DOT_PATTERN.split(nameString);
            
            // Fast path: no special characters
            if (!hasSpecialChar) {
                for (String split : splits) {
                    names.add(split);
                }
                putCache(cacheKey, names);
                return names;
            }
            
            // Handle special character cases
            if (hasSingleQuote) {
                if ("'.'".equals(name)) {
                    names = Arrays.asList(".");
                    putCache(cacheKey, names);
                    return names;
                }
                parseWithDelimiter(splits, names, '\'', '\'');
            } else if (hasParenthesis) {
                parseWithParenthesis(splits, names);
            } else if (hasBacktick) {
                if ("`.`".equals(name)) {
                    names = Arrays.asList(".");
                    putCache(cacheKey, names);
                    return names;
                }
                parseWithDelimiter(splits, names, '`', '`');
            } else if (hasDoubleQuote) {
                if ("\".\"".equals(name)) {
                    names = Arrays.asList(".");
                    putCache(cacheKey, names);
                    return names;
                }
                parseWithDelimiter(splits, names, '"', '"');
            } else if (hasBracket) {
                if ("[.]".equals(name)) {
                    names = Arrays.asList(".");
                    putCache(cacheKey, names);
                    return names;
                }
                parseWithDelimiter(splits, names, '[', ']');
            } else {
                for (String split : splits) {
                    names.add(split);
                }
            }
        } catch (Throwable e) {
            names.clear();
            names.add(nameString);
        }
        
        putCache(cacheKey, names);
        return names;
    }

        protected static List<String> putCache(String cacheKey, List<String> names) {
                return PARSE_NAMES_CACHE.put(cacheKey, new ArrayList<String>(names));
        }
    
    /**
     * Helper method to parse name segments with paired delimiters (quotes, brackets, etc.)
     */
    private static void parseWithDelimiter(String[] splits, List<String> names, char startDelim, char endDelim) {
        for (int i = 0; i < splits.length; i++) {
            String split = splits[i].trim();
            if (split.length() > 0 && split.charAt(0) == startDelim && 
                (split.length() == 1 || split.charAt(split.length() - 1) != endDelim)) {
                // Found start delimiter without matching end - need to merge segments
                StringBuilder buffer = new StringBuilder(split.length() * 2);
                buffer.append(splits[i]);
                
                while (i < splits.length - 1) {
                    split = splits[++i].trim();
                    buffer.append(".").append(splits[i]);
                    if (split.length() > 0 && split.charAt(split.length() - 1) == endDelim) {
                        break;
                    }
                }
                names.add(buffer.toString());
            } else {
                names.add(splits[i]);
            }
        }
    }
    
    /**
     * Helper method to parse name segments with parentheses
     */
    private static void parseWithParenthesis(String[] splits, List<String> names) {
        for (int i = 0; i < splits.length; i++) {
            String split = splits[i].trim();
            int openParen = split.indexOf('(');
            int closeParen = split.indexOf(')');
            
            if (openParen != -1 && closeParen == -1) {
                // Found opening parenthesis without closing - need to merge segments
                StringBuilder buffer = new StringBuilder(split.length() * 2);
                buffer.append(splits[i]);
                
                while (i < splits.length - 1) {
                    split = splits[++i].trim();
                    buffer.append(".").append(splits[i]);
                    if (split.indexOf(')') != -1) {
                        break;
                    }
                }
                names.add(buffer.toString());
            } else {
                names.add(splits[i]);
            }
        }
    }
        
        public static void main(String[] args) {
                SQLUtil.parseNames("OPENJSON(aptd.test.ActiviteTypeIDs)");
        }

    public static void writeToFile(File file, InputStream source, boolean close) {
        BufferedInputStream bis = null;
        BufferedOutputStream fouts = null;
        try {
            bis = new BufferedInputStream(source);
            if (!file.exists()) {
                if (!file.getParentFile().exists()) {
                    file.getParentFile().mkdirs();
                }
                file.createNewFile();
            }
            fouts = new BufferedOutputStream(new FileOutputStream(file));
            byte b[] = new byte[1024];
            int i = 0;
            while ((i = bis.read(b)) != -1) {
                fouts.write(b, 0, i);
            }
            fouts.flush();
            fouts.close();
            if (close)
                bis.close();
        } catch (IOException e) {
            logger.error("Write file failed.", e);
            try {
                if (fouts != null)
                    fouts.close();
            } catch (IOException f) {
                logger.error("Close output stream failed.", f);
            }
            if (close) {
                try {
                    if (bis != null)
                        bis.close();
                } catch (IOException f) {
                    logger.error("Close input stream failed.", f);
                }
            }
        }
    }

    public static void writeToFile(File file, String string) throws IOException {

        if (!file.exists()) {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            file.createNewFile();
        }
        PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file)));
        if (string != null)
            out.print(string);
        out.close();
    }

    public static void appendToFile(File file, String string) throws IOException {

        if (!file.exists()) {
            if (!file.getParentFile().exists()) {
                file.getParentFile().mkdirs();
            }
            file.createNewFile();
        }
        PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file, true)));
        if (string != null)
            out.println(string);
        out.close();
    }

    public static void deltree(File root) {
        if (root == null || !root.exists()) {
            return;
        }

        if (root.isFile()) {
            root.delete();
            return;
        }

        File[] children = root.listFiles();
        if (children != null) {
            for (int i = 0; i < children.length; i++) {
                deltree(children[i]);
            }
        }

        root.delete();
    }

    public static InputStream getInputStreamWithoutBom(String file) throws IOException {
        UnicodeInputStream stream = null;
        FileInputStream fis = new FileInputStream(file);
        stream = new UnicodeInputStream(fis, null);
        return stream;
    }

    public static class UnicodeInputStream extends InputStream {
        PushbackInputStream internalIn;
        boolean isInited = false;
        String defaultEnc;
        String encoding;

        private static final int BOM_SIZE = 4;

        public UnicodeInputStream(InputStream in, String defaultEnc) {
            internalIn = new PushbackInputStream(in, BOM_SIZE);
            this.defaultEnc = defaultEnc;
        }

        public String getDefaultEncoding() {
            return defaultEnc;
        }

        public String getEncoding() {
            if (!isInited) {
                try {
                    init();
                } catch (IOException ex) {
                    IllegalStateException ise = new IllegalStateException("Init method failed.");
                    ise.initCause(ise);
                    throw ise;
                }
            }
            return encoding;
        }

        protected void init() throws IOException {
            if (isInited)
                return;

            byte bom[] = new byte[BOM_SIZE];
            int n, unread;
            n = internalIn.read(bom, 0, bom.length);

            if ((bom[0] == (byte) 0x00) && (bom[1] == (byte) 0x00) && (bom[2] == (byte) 0xFE)
                    && (bom[3] == (byte) 0xFF)) {
                encoding = "UTF-32BE";
                unread = n - 4;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE) && (bom[2] == (byte) 0x00)
                    && (bom[3] == (byte) 0x00)) {
                encoding = "UTF-32LE";
                unread = n - 4;
            } else if ((bom[0] == (byte) 0xEF) && (bom[1] == (byte) 0xBB) && (bom[2] == (byte) 0xBF)) {
                encoding = "UTF-8";
                unread = n - 3;
            } else if ((bom[0] == (byte) 0xFE) && (bom[1] == (byte) 0xFF)) {
                encoding = "UTF-16BE";
                unread = n - 2;
            } else if ((bom[0] == (byte) 0xFF) && (bom[1] == (byte) 0xFE)) {
                encoding = "UTF-16LE";
                unread = n - 2;
            } else {
                encoding = defaultEnc;
                unread = n;
            }

            if (unread > 0)
                internalIn.unread(bom, (n - unread), unread);

            isInited = true;
        }

        public void close() throws IOException {
            internalIn.close();
        }

        public int read() throws IOException {
            return internalIn.read();
        }
    }

    public static boolean compareIdentifier(EDbVendor dbVendor, ESQLDataObjectType sqlDataObjectType,
                                            String identifier1, String identifier2) {
        List<String> segments1 = parseNames(identifier1);
        List<String> segments2 = parseNames(identifier2);

        if (segments1.size() != segments2.size())
            return false;

        boolean supportCatalog = TSQLEnv.supportCatalog(dbVendor);
        boolean supportSchema = TSQLEnv.supportSchema(dbVendor);

        if(supportCatalog && supportSchema) {
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 4) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(2),
                            segments2.get(2))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 3),
                            mergeSegments(segments2, 3));
                } else if (segments1.size() == 4) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(2),
                            segments2.get(2))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(3),
                            segments2.get(3));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 2), mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(2), segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            }
        }
        else if(supportCatalog){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 2),
                            mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog || sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments1.get(0), segments2.get(0));
                }
            }
        }
        else if(supportSchema){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments1.size() > 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments1, 2),
                            mergeSegments(segments2, 2));
                } else if (segments1.size() == 3) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(1),
                            segments2.get(1))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(2),
                            segments2.get(2));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(1),
                            segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments1.get(0),
                            segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments1.size() > 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments1, 1), mergeSegments(segments2, 1));
                } else if (segments1.size() == 2) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0),
                            segments2.get(0))
                            && TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(1), segments2.get(1));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, sqlDataObjectType, segments1.get(0), segments2.get(0));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog || sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments1.size() > 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, mergeSegments(segments1, 0), mergeSegments(segments2, 0));
                } else if (segments1.size() == 1) {
                    return TSQLEnv.compareIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments1.get(0), segments2.get(0));
                }
            }
        }
        return false;
    }

    public static String normalizeIdentifier(EDbVendor dbVendor, ESQLDataObjectType objectType, String identifier) {
        if (identifier == null)
            return null;
        String originIdentifier = identifier;
        identifier = IdentifierService.normalizeStatic(dbVendor, objectType, identifier);
        boolean collationSensitive = false;
        switch (objectType) {
            case dotCatalog:
            case dotSchema:
                collationSensitive = TSQLEnv.catalogCollationCaseSensitive.get(dbVendor);
                break;
            case dotFunction:
            case dotProcedure:
            case dotTrigger:
            case dotTable:
            case dotOraclePackage:
                collationSensitive = TSQLEnv.tableCollationCaseSensitive.get(dbVendor);
                break;
            case dotColumn:
                collationSensitive = TSQLEnv.columnCollationCaseSensitive.get(dbVendor);
                break;
            default:
                collationSensitive = TSQLEnv.defaultCollationCaseSensitive.get(dbVendor);
                break;
        }
        if(parseNames(identifier).size()>1) {
            return collationSensitive ? originIdentifier : originIdentifier.toUpperCase();
        }
        else {
            return collationSensitive ? identifier : identifier.toUpperCase();
        }
    }

    public static String getIdentifierNormalColumnName(EDbVendor dbVendor, String name) {
        return getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotColumn);
    }

    public static String getIdentifierNormalTableName(String name) {
        return getIdentifierNormalName(ModelBindingManager.getGlobalVendor(), name, ESQLDataObjectType.dotTable);
    }
    
    public static String getIdentifierNormalTableName(EDbVendor dbVendor, String name) {
        return getIdentifierNormalName(dbVendor, name, ESQLDataObjectType.dotTable);
    }

  /**
   * 规范化多段限定名（Multi-Segment Qualified Name）并返回规范化后的完整限定名。
   *
   * <h3>核心功能</h3>
   * <p>本方法是 SQL 标识符规范化的<b>多段名处理版本</b>，接受包含多段（catalog.schema.table.column）的限定名，
   * 根据数据库厂商特性、层级支持能力和对象类型，智能解析和规范化每个段，最后返回用点号连接的完整规范化名称。</p>
   *
   * <h3>处理流程</h3>
   * <ol>
   *   <li><b>厂商特定语法展开</b>：
   *       <ul>
   *         <li>MSSQL/Azure SQL: 将 ".." 语法展开为 ".dbo." 或全局配置的 schema</li>
   *         <li>示例：{@code "db..table"} → {@code "db.dbo.table"}</li>
   *       </ul>
   *   </li>
   *   <li><b>解析多段名</b>：使用 {@link #parseNames(String)} 将限定名按点号分割成段列表</li>
   *   <li><b>智能段类型推断</b>：根据以下因素决定每段的实际类型：
   *       <ul>
   *         <li>数据库厂商的层级支持能力（supportCatalog/supportSchema）</li>
   *         <li>目标对象类型（{@code sqlDataObjectType}）</li>
   *         <li>实际段数</li>
   *       </ul>
   *   </li>
   *   <li><b>逐段规范化</b>：对每段调用 {@link #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)}，
   *       应用厂商特定的大小写规则、引号处理等</li>
   *   <li><b>重组限定名</b>：用点号连接所有规范化后的段，返回完整的规范化限定名</li>
   * </ol>
   *
   * <h3>智能段类型推断示例</h3>
   * <p>假设数据库<b>同时支持 catalog 和 schema</b>，目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>3段名 {@code "a.b.c"} → 解析为 {@code catalog.schema.table}</li>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code schema.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <p>假设数据库<b>仅支持 catalog</b>（如 MySQL），目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code catalog.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <p>假设数据库<b>仅支持 schema</b>（如 PostgreSQL），目标类型为 {@code dotTable}：</p>
   * <ul>
   *   <li>2段名 {@code "a.b"} → 解析为 {@code schema.table}</li>
   *   <li>1段名 {@code "a"} → 解析为 {@code table}</li>
   * </ul>
   *
   * <h3>对于 dotColumn 类型的特殊处理</h3>
   * <p>列名可能有4段（catalog.schema.table.column），方法会根据实际段数自动调整解析策略：</p>
   * <ul>
   *   <li>4段名 {@code "db.sch.tbl.col"} → {@code catalog.schema.table.column}</li>
   *   <li>3段名 {@code "sch.tbl.col"} → {@code schema.table.column}</li>
   *   <li>2段名 {@code "tbl.col"} → {@code table.column}</li>
   *   <li>1段名 {@code "col"} → {@code column}</li>
   * </ul>
   *
   * <h3>处理超长限定名</h3>
   * <p>当段数超过标准层级时（如表名有4段或更多），方法会使用 {@link #mergeSegments(List, int)}
   * 将多余的尾部段合并为单个段（保留点号），然后作为最后一段进行规范化。</p>
   * <p>示例：5段列名 {@code "db.sch.tbl.nested.col"} → 合并后4段处理：
   * {@code "db.sch.tbl.nested.col"} (最后两段合并为 {@code "nested.col"})</p>
   *
   * <h3>方法目的与使用场景</h3>
   * <ul>
   *   <li><b>目的</b>：为多段限定名提供统一的规范化接口，生成可用于比较、索引和查找的标准化名称</li>
   *   <li><b>输出特性</b>：返回<b>多段名</b>（用点号连接），保留层级结构信息</li>
   *   <li><b>使用场景</b>：
   *       <ul>
   *         <li>环境层（TSQLEnv）处理完整限定名</li>
   *         <li>名称比较和匹配（需要保留层级信息）</li>
   *         <li>快速索引查找（NameKey 构造）</li>
   *       </ul>
   *   </li>
   * </ul>
   *
   * <h3>与相关方法的区别</h3>
   * <ul>
   *   <li><b>{@link #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)}</b>：
   *       单段规范化，不解析限定名，直接处理引号和大小写，返回单段名</li>
   *   <li><b>{@code IdentifierService.keyForMap(String, ESQLDataObjectType)}</b>：
   *       仅接受单段名，用于生成 Map 的 key，会抛出异常如果输入是多段名</li>
   *   <li><b>{@code IdentifierService.normalizeQualifiedName(String, ESQLDataObjectType)}</b>：
   *       新架构中的等价方法，提供相同的多段名规范化功能</li>
   * </ul>
   *
   * <h3>厂商特定行为</h3>
   * <ul>
   *   <li><b>MySQL</b>: 仅支持 catalog（即 database），反引号引用，大小写根据系统变量决定</li>
   *   <li><b>PostgreSQL</b>: 仅支持 schema，双引号引用，未加引号的标识符转小写</li>
   *   <li><b>SQL Server</b>: 支持 catalog+schema，方括号或双引号引用，".." 展开为 ".dbo."</li>
   *   <li><b>Oracle</b>: 仅支持 schema，双引号引用，未加引号的标识符转大写</li>
   *   <li><b>Snowflake</b>: 支持 catalog+schema，双引号引用，大小写保留但匹配不敏感</li>
   *   <li><b>BigQuery</b>: 支持 catalog+schema（项目+数据集），反引号引用，大小写不敏感，可能内部转小写</li>
   * </ul>
   *
   * @param dbVendor 数据库厂商类型（决定层级支持、引号风格、大小写规则）
   * @param name 原始标识符或多段限定名（可能包含引号/反引号；可能包含 catalog/schema 前缀；
   *             可能包含厂商特定语法如 MSSQL 的 ".."）
   * @param sqlDataObjectType 期望的对象类型（例如 dotTable, dotColumn, dotSchema, dotCatalog），
   *                          用于指导段类型推断和规范化规则应用
   * @return 规范化后的完整限定名，用点号连接各段；如果输入为 {@code null}，返回 {@code null}；
   *         如果输入为空字符串或无法解析，返回空字符串
   *
   * @see #normalizeIdentifier(EDbVendor, ESQLDataObjectType, String) 单段规范化方法
   * @see #parseNames(String) 多段名解析方法
   * @see #mergeSegments(List, int) 段合并工具方法
   * @see TSQLEnv#normalizeIdentifier(EDbVendor, ESQLDataObjectType, String)
   * @see IdentifierService#normalizeQualifiedName(String, ESQLDataObjectType) Phase 0 新架构中的等价方法
   *
   * @since 3.1.0.8
   */
    public static String getIdentifierNormalName(EDbVendor dbVendor, String name,
                                                 ESQLDataObjectType sqlDataObjectType) {
        if (name == null) {
            return null;
        }
        if (dbVendor == EDbVendor.dbvmssql || dbVendor == EDbVendor.dbvazuresql) {
            if (name.indexOf("..") != -1) {
                if (ModelBindingManager.getGlobalSchema() != null) {
                    name = name.replace("..", "." + ModelBindingManager.getGlobalSchema() + ".");
                } else {
                    name = name.replace("..", ".dbo.");
                }
            }
        }
        List<String> segments = parseNames(name);
        StringBuilder builder = new StringBuilder();
        boolean supportCatalog = TSQLEnv.supportCatalog(dbVendor);
        boolean supportSchema = TSQLEnv.supportSchema(dbVendor);

        if(supportCatalog && supportSchema) {
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 4) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(2)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 3)));
                } else if (segments.size() == 4) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(2)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(3)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(1)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            }
        }
        else if(supportCatalog){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema || sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotCatalog, segments.get(0)));
                }
            }
        }
        else if(supportSchema){
            if (sqlDataObjectType == ESQLDataObjectType.dotColumn) {
                if (segments.size() > 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, mergeSegments(segments, 2)));
                } else if (segments.size() == 3) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(1)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(2)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotTable, segments.get(0)))
                            .append(".")
                            .append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotColumn, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotTable
                    || sqlDataObjectType == ESQLDataObjectType.dotOraclePackage
                    || sqlDataObjectType == ESQLDataObjectType.dotFunction
                    || sqlDataObjectType == ESQLDataObjectType.dotProcedure
                    || sqlDataObjectType == ESQLDataObjectType.dotTrigger) {
                if (segments.size() > 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, mergeSegments(segments, 1)));
                } else if (segments.size() == 2) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)))
                            .append(".").append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(1)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, sqlDataObjectType, segments.get(0)));
                }
            } else if (sqlDataObjectType == ESQLDataObjectType.dotSchema || sqlDataObjectType == ESQLDataObjectType.dotCatalog) {
                if (segments.size() > 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, mergeSegments(segments, 0)));
                } else if (segments.size() == 1) {
                    builder.append(normalizeIdentifier(dbVendor, ESQLDataObjectType.dotSchema, segments.get(0)));
                }
            }
        }
        return builder.toString();
    }

    public static String mergeSegments(List<String> segments, int index) {
        StringBuilder buffer = new StringBuilder();
                for (int i = index; i < segments.size(); i++) {
                        buffer.append(segments.get(i));
                        if(i<segments.size()-1) {
                                buffer.append(".");
                        }
                }
                return buffer.toString();
        }

//      public static String getIdentifierNormalName(EDbVendor vendor, String name) {
//              if (isEmpty(name)) {
//                      return null;
//              }
//              name = name.replaceAll("(?i)null\\.", "");
//              switch (vendor) {
//              case dbvbigquery:
//                      return replaceIdentifierNormalName(name, "`.*?`", "`", true).replaceAll("\\.\\s+", ".");
//              case dbvcouchbase:
//              case dbvhive:
//              case dbvimpala:
//              case dbvmysql:
//                      return replaceIdentifierNormalName(name, "`.*?`", "`", true).replaceAll("\\.\\s+", ".");
//              case dbvdax:
//                      return replaceIdentifierNormalName(name, "'.*?'", "'", true).replaceAll("\\.\\s+", ".");
//              case dbvdb2:
//              case dbvhana:
//              case dbvinformix:
//              case dbvnetezza:
//              case dbvoracle:
//              case dbvsnowflake:
//              case dbvsybase:
//              case dbvteradata:
//              case dbvvertica:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", true).replaceAll("\\.\\s+", ".");
//              case dbvpostgresql:
//              case dbvgreenplum:
//              case dbvredshift:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", false).replaceAll("\\.\\s+", ".");
//              case dbvmssql:
//                      return replaceIdentifierNormalName(name, "([\"\\[']).*?([\"\\]'])", "[\"\\[\\]']", true)
//                                      .replaceAll("\\.\\s+", ".");
//              default:
//                      return replaceIdentifierNormalName(name, "\".*?\"", "\"", true).replaceAll("\\.\\s+", ".");
//              }
//      }
//
//      private static String replaceIdentifierNormalName(String content, String match, String replace, boolean toUpper) {
//              Pattern pattern = Pattern.compile(match, Pattern.CASE_INSENSITIVE | Pattern.DOTALL);
//              Matcher matcher = pattern.matcher(content);
//              StringBuilder buffer = new StringBuilder();
//              int start = 0;
//              while (matcher.find()) {
//                      int matchStart = matcher.start();
//                      int macthEnd = matcher.end();
//                      if (start < matchStart) {
//                              if (toUpper) {
//                                      buffer.append(content.substring(start, matchStart).toUpperCase());
//                              } else {
//                                      buffer.append(content.substring(start, matchStart).toLowerCase());
//                              }
//                      }
//                      buffer.append(matcher.group().replaceAll(replace, ""));
//                      start = macthEnd;
//              }
//              if (start < content.length()) {
//                      if (toUpper) {
//                              buffer.append(content.substring(start).toUpperCase());
//                      } else {
//                              buffer.append(content.substring(start).toLowerCase());
//                      }
//              }
//              return buffer.toString();
//      }

    public static boolean isTempTable(table table) {
        if(SubType.temp_table.name().equals(table.getSubType())) {
                return true;
        }
        String tableName = table.getName();
        List<String> segments = parseNames(tableName);
        if (tableName.startsWith("@") || segments.get(segments.size() - 1).startsWith("@")) {
            return true;
        }
        if (tableName.startsWith("#") || segments.get(segments.size() - 1).startsWith("#")) {
            return true;
        }
        return false;
    }
    
//    public static boolean isTempTable(String tableName) {
//        List<String> segments = parseNames(tableName);
//        if (tableName.startsWith("@") || segments.get(segments.size() - 1).startsWith("@")) {
//            return true;
//        }
//        if (tableName.startsWith("#") || segments.get(segments.size() - 1).startsWith("#")) {
//            return true;
//        }
//        return false;
//    }

//    public static boolean isTempTable(TTable table, EDbVendor vendor) {
//        switch (vendor) {
//            case dbvmssql:
//                return table.getName().startsWith("#");
//            default:
//                return false;
//        }
//    }

    public static File[] listFiles(File sqlFiles) {
        List<File> children = new ArrayList<File>();
        if (sqlFiles != null)
            listFiles(sqlFiles, children);
        Collections.sort(children);
        return children.toArray(new File[0]);
    }

    public static File[] listFiles(File sqlFiles, FileFilter filter) {
        List<File> children = new ArrayList<File>();
        if (sqlFiles != null)
            listFiles(sqlFiles, children, filter);
        Collections.sort(children);
        return children.toArray(new File[0]);
    }

    public static void listFiles(File rootFile, List<File> children) {
        if (rootFile.isFile())
            children.add(rootFile);
        else {
            File[] files = rootFile.listFiles();
            if (files != null) {
                for (int i = 0; i < files.length; i++) {
                    listFiles(files[i], children);
                }
            }
        }
    }

    public static void listFiles(File rootFile, List<File> children, FileFilter filter) {
        if (rootFile.isFile() && filter.accept(rootFile))
            children.add(rootFile);
        else {
            File[] files = rootFile.listFiles(filter);
            if (files != null) {
                for (int i = 0; i < files.length; i++) {
                    listFiles(files[i], children, filter);
                }
            }
        }
    }

    public static String readFile(File file) {
        StringBuilder stringBuilder = new StringBuilder();
        BufferedReader reader = null;
        try {
            reader = new BufferedReader(new FileReader(file));

            String line = null;
            String ls = System.getProperty("line.separator");
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
                stringBuilder.append(ls);
            }
            stringBuilder.deleteCharAt(stringBuilder.length() - 1);
        } catch (IOException e) {
            logger.error("read file failed.", e);
        } finally {
            if (reader != null) {
                try {
                    reader.close();
                } catch (IOException e) {
                    logger.error("close reader failed.", e);
                }
            }
        }
        return stringBuilder.toString();
    }

        public static String stringToMD5(String plainText) {
                byte[] secretBytes = null;
                try {
                        secretBytes = MessageDigest.getInstance("md5").digest(plainText.getBytes("UTF-8"));
                        StringBuffer sb = new StringBuffer();
                        for (int i = 0; i < secretBytes.length; ++i) {
                                sb.append(Integer.toHexString((secretBytes[i] & 0xFF) | 0x100).substring(1, 3));
                        }
                        return sb.toString();
                } catch (Exception e) {
                        logger.error("get text md5 value failed.", e);
                }
                return null;
        }

        public static String trimSingleQuote(String columnAlias) {
                if(columnAlias.startsWith("'") && columnAlias.endsWith("'")) {
                        return columnAlias.substring(1, columnAlias.length() - 1);
                }
                return columnAlias;
        }
        
    public static String endTrim(String input) {
        if (input == null) {
            return null;
        }

        int end = input.length();
        while (end > 0 && Character.isWhitespace(input.charAt(end - 1))) {
            end--;
        }

        return input.substring(0, end);
    }
        
    public static void endTrim(StringBuilder buffer) {
        int length = buffer.length();
        while (length > 0 && Character.isWhitespace(buffer.charAt(length - 1))) {
            length--; // 逐步减少长度
        }
        buffer.setLength(length); // 直接截断尾部空白字符
    }
}