package gudusoft.gsqlparser.util;

import gudusoft.gsqlparser.EDbVendor;
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.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

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

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

    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*");

    public static List<String> parseNames(String nameString, EDbVendor vendor) {
        if(nameString == null){
            return Collections.EMPTY_LIST;
        }
        String name = nameString.trim();
        List<String> names = new ArrayList<String>();
        if (vendor == EDbVendor.dbvbigquery) {
            if (name.contains("`")) {
                // Use pre-compiled pattern and avoid unnecessary array creation
                String[] parts = DOT_PATTERN.split(name.replace("`", ""));
                for (String part : parts) {
                    names.add(part);
                }
                return names;
            }
        }
        try {
            // Use pre-compiled pattern instead of creating a new one each time
            String[] splits = DOT_PATTERN.split(nameString);
            if (name.contains("'")) {
                for (int i = 0; i < splits.length; i++) {
                    String split = splits[i].trim();
                    if (split.startsWith("'") && !split.endsWith("'")) {
                        StringBuilder buffer = new StringBuilder(split.length() * 2);
                        buffer.append(splits[i]);
                        while (!(split = splits[++i].trim()).endsWith("'")) {
                            buffer.append(".");
                            buffer.append(splits[i]);
                            if (i == splits.length - 1) {
                                break;
                            }
                        }

                        buffer.append(".");
                        buffer.append(splits[i]);

                        names.add(buffer.toString());
                        continue;
                    }
                    names.add(splits[i]);
                }
            } else if (name.contains("(")) {
                for (int i = 0; i < splits.length; i++) {
                    String split = splits[i].trim();
                    if (split.indexOf("(") != -1 && split.indexOf(")") == -1) {
                        StringBuilder buffer = new StringBuilder(split.length() * 2);
                        buffer.append(splits[i]);
                        while ((split = splits[++i].trim()).indexOf(")")==-1) {
                            buffer.append(".");
                            buffer.append(splits[i]);
                            if (i == splits.length - 1) {
                                break;
                            }
                        }

                        buffer.append(".");
                        buffer.append(splits[i]);

                        names.add(buffer.toString());
                        continue;
                    }
                    names.add(splits[i]);
                }
            } else if (name.contains("`")) {
                for (int i = 0; i < splits.length; i++) {
                    String split = splits[i].trim();
                    if (split.startsWith("`") && !split.endsWith("`")) {
                        StringBuilder buffer = new StringBuilder(split.length() * 2);
                        buffer.append(splits[i]);
                        while (!(split = splits[++i].trim()).endsWith("`")) {
                            buffer.append(".");
                            buffer.append(splits[i]);
                            if (i == splits.length - 1) {
                                break;
                            }
                        }

                        buffer.append(".");
                        buffer.append(splits[i]);

                        names.add(buffer.toString());
                        continue;
                    }
                    names.add(splits[i]);
                }
            } else if (name.contains("\"")) {
                for (int i = 0; i < splits.length; i++) {
                    String split = splits[i].trim();
                    if (split.startsWith("\"") && !split.endsWith("\"")) {
                        StringBuilder buffer = new StringBuilder(split.length() * 2);
                        buffer.append(splits[i]);
                        while (!(split = splits[++i].trim()).endsWith("\"")) {
                            buffer.append(".");
                            buffer.append(splits[i]);
                            if (i == splits.length - 1) {
                                break;
                            }
                        }

                        buffer.append(".");
                        buffer.append(splits[i]);

                        names.add(buffer.toString());
                        continue;
                    }
                    names.add(splits[i]);
                }
            } else if ((name.contains("[") && name.contains("]"))) {
                for (int i = 0; i < splits.length; i++) {
                    String split = splits[i].trim();
                    if (split.startsWith("[") && !split.endsWith("]")) {
                        StringBuilder buffer = new StringBuilder(split.length() * 2);
                        buffer.append(splits[i]);
                        if (i < splits.length - 1) {
                            while (!(split = splits[++i].trim()).endsWith("]")) {
                                buffer.append(".");
                                buffer.append(splits[i]);
                                if (i == splits.length - 1) {
                                    break;
                                }
                            }
                        }

                        buffer.append(".");
                        buffer.append(splits[i]);

                        names.add(buffer.toString());
                        continue;
                    }
                    names.add(splits[i]);
                }
            } else {
                // Avoid unnecessary object creation from Arrays.asList
                for (String split : splits) {
                    names.add(split);
                }
            }
        } catch (Throwable e) {
            names.clear();
            names.add(nameString);
        }
        return names;
    }
        
        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();
    }

    /**
     * @param file the filePath
     * @return the UTFFileHandler.UnicodeInputStream
     */
    public static InputStream getInputStreamWithoutBom(String file) throws IOException {
        UnicodeInputStream stream = null;
        FileInputStream fis = new FileInputStream(file);
        stream = new UnicodeInputStream(fis, null);
        return stream;
    }

    /**
     * This inputstream will recognize unicode BOM marks and will skip bytes if
     * getEncoding() method is called before any of the read(...) methods.
     * <p>
     * Usage pattern: String enc = "ISO-8859-1"; // or NULL to use systemdefault
     * FileInputStream fis = new FileInputStream(file); UnicodeInputStream uin =
     * new UnicodeInputStream(fis, enc); enc = uin.getEncoding(); // check and
     * skip possible BOM bytes InputStreamReader in; if (enc == null) in = new
     * InputStreamReader(uin); else in = new InputStreamReader(uin, enc);
     */
    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;
        }

        /**
         * Read-ahead four bytes and check for BOM marks. Extra bytes are unread
         * back to the stream, only BOM bytes are skipped.
         */
        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 = TSQLEnv.normalizeIdentifier(dbVendor, objectType, identifier);
        boolean collationSensitive = false;
        switch (objectType) {
            case dotCatalog:
            case dotSchema:
                collationSensitive = TSQLEnv.catalogCollationCaseSensitive[dbVendor.ordinal()];
                break;
            case dotFunction:
            case dotProcedure:
            case dotTrigger:
            case dotTable:
            case dotOraclePackage:
                collationSensitive = TSQLEnv.tableCollationCaseSensitive[dbVendor.ordinal()];
                break;
            case dotColumn:
                collationSensitive = TSQLEnv.columnCollationCaseSensitive[dbVendor.ordinal()];
                break;
            default:
                collationSensitive = TSQLEnv.defaultCollationCaseSensitive[dbVendor.ordinal()];
                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);
    }

    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); // 直接截断尾部空白字符
    }
}