translatesql.cpp

#include "translateSQL.h"
#include <QStringList>

using Qt::CaseInsensitive;

translateSQL::translateSQL()
{
    using RO = QRegularExpression::PatternOption;

    // ===== ORACLE → POSTGRES =====
    rulesO2P_ = {

    // Типы данных
    {
        QRegularExpression(R"(\bNUMBER\b(\s*\(\s*\d+\s*(?:,\s*\d+)?\s*\))?)", RO::CaseInsensitiveOption),
        [](const QRegularExpressionMatch &m){
            const QString paren = m.captured(1);
            return QString("NUMERIC%1").arg(paren);
        },
        "NUMBER→NUMERIC"
    },
        {
            QRegularExpression(R"(\bVARCHAR2\s*\(\s*(\d+)(?:\s+(?:BYTE|CHAR))?\s*\))", RO::CaseInsensitiveOption),
            [](const QRegularExpressionMatch &m){ return QString("VARCHAR(%1)").arg(m.captured(1)); },
            "VARCHAR2→VARCHAR"
        },
        {
            QRegularExpression(R"(\bNVARCHAR2\s*\(\s*(\d+)\s*\))", RO::CaseInsensitiveOption),
            [](const QRegularExpressionMatch &m){ return QString("VARCHAR(%1)").arg(m.captured(1)); },
            "NVARCHAR2→VARCHAR"
        },
        {
            // Осторожно: заменяем тип DATE, а не ключевые слова в выражениях
            QRegularExpression(R"(\bDATE\b)", RO::CaseInsensitiveOption),
            [](const QRegularExpressionMatch &){ return QString("TIMESTAMP"); },
            "DATE(type)→TIMESTAMP"
        },
        { QRegularExpression(R"(\bBLOB\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "BYTEA"; }, "BLOB→BYTEA" },
        { QRegularExpression(R"(\bCLOB\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "TEXT"; }, "CLOB→TEXT" },
        { QRegularExpression(R"(\bRAW\s*\(\s*\d+\s*\))", RO::CaseInsensitiveOption),
         [](auto&){ return "BYTEA"; }, "RAW(n)→BYTEA" },
        { QRegularExpression(R"(\bLONG\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "TEXT"; }, "LONG→TEXT" },
        { QRegularExpression(R"(\bNCHAR\s*(\(\s*\d+\s*\))?)", RO::CaseInsensitiveOption),
         [](const auto &m){ return QString("CHAR%1").arg(m.captured(1)); }, "NCHAR→CHAR" },
        { QRegularExpression(R"(\bNCLOB\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "TEXT"; }, "NCLOB→TEXT" },
        { QRegularExpression(R"(INTERVAL\s+DAY\s+TO\s+SECOND)", RO::CaseInsensitiveOption),
         [](auto&){ return "INTERVAL"; }, "INTERVAL DAY TO SECOND→INTERVAL" },
        { QRegularExpression(R"(INTERVAL\s+YEAR\s+TO\s+MONTH)", RO::CaseInsensitiveOption),
         [](auto&){ return "INTERVAL"; }, "INTERVAL YEAR TO MONTH→INTERVAL" },

        // Датавремя и константы
        { QRegularExpression(R"(\bSYSTIMESTAMP\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "CURRENT_TIMESTAMP"; }, "SYSTIMESTAMP→CURRENT_TIMESTAMP" },
        { QRegularExpression(R"(\bSYSDATE\b)", RO::CaseInsensitiveOption),
         [](auto&){ return "CURRENT_TIMESTAMP"; }, "SYSDATE→CURRENT_TIMESTAMP" },

        // Функции
        { // NVL(a,b) → COALESCE(a,b)
            QRegularExpression(R"(NVL\s*\(\s*([^,()]+)\s*,\s*([^)]+)\))", RO::CaseInsensitiveOption),
            [](const auto &m){ return QString("COALESCE(%1, %2)").arg(m.captured(1), m.captured(2)); },
            "NVL→COALESCE"
        },
        { // DECODE(...) → CASE ...
            QRegularExpression(R"(DECODE\s*\(\s*([^)]+)\))", RO::CaseInsensitiveOption),
            [](const auto &m){ return translateSQL::decodeToCase(m.captured(1)); },
            "DECODE→CASE"
        },
        { // TO_NUMBER(x[,fmt]) → to_number(x[,fmt])  (у Postgres есть такая функция)
            QRegularExpression(R"(TO_NUMBER\s*\(\s*([^)]+)\))", RO::CaseInsensitiveOption),
            [](const auto &m){ return QString("to_number(%1)").arg(m.captured(1)); },
            "TO_NUMBER→to_number"
        },
        { // TO_DATE(str, fmt) → to_date(...) | to_timestamp(...) (по наличию HH/MI/SS)
            QRegularExpression(R"(TO_DATE\s*\(\s*([^)]+)\))", RO::CaseInsensitiveOption),
            [](const auto &m){
                const QString inside = m.captured(1);
                auto args = translateSQL::splitTopLevelArgs(inside);
                if (args.size() >= 2 && translateSQL::fmtHasTimeTokens(args[1])) {
                    return QString("to_timestamp(%1)").arg(inside);
                }
                return QString("to_date(%1)").arg(inside);
            },
            "TO_DATE→to_date/to_timestamp"
        },
        { // TRUNC(date [, 'unit']) → date_trunc('unit', date)
            QRegularExpression(R"(TRUNC\s*\(\s*([^,()]+)(?:\s*,\s*'([^']+)')?\s*\))", RO::CaseInsensitiveOption),
            [](const auto &m){
                const QString expr = m.captured(1).trimmed();
                const QString unit = m.captured(2).isEmpty() ? "day" : m.captured(2).toLower();
                return QString("date_trunc('%1', %2)").arg(unit, expr);
            },
            "TRUNC→date_trunc"
        },
        { // SUBSTR(s, n [, m]) → SUBSTRING(s FROM n [FOR m])
            QRegularExpression(R"(SUBSTR\s*\(\s*([^,()]+)\s*,\s*([^,()]+)(?:\s*,\s*([^)]+))?\s*\))", RO::CaseInsensitiveOption),
            [](const auto &m){
                const QString s = m.captured(1).trimmed();
                const QString n = m.captured(2).trimmed();
                const QString mlen = m.captured(3).trimmed();
                return mlen.isEmpty()
                           ? QString("SUBSTRING(%1 FROM %2)").arg(s, n)
                           : QString("SUBSTRING(%1 FROM %2 FOR %3)").arg(s, n, mlen);
            },
            "SUBSTR→SUBSTRING"
        },
        { // INSTR(s, sub) → POSITION(sub IN s)
            QRegularExpression(R"(INSTR\s*\(\s*([^,()]+)\s*,\s*([^)]+)\s*\))", RO::CaseInsensitiveOption),
            [](const auto &m){
                return QString("POSITION(%1 IN %2)").arg(m.captured(2).trimmed(),
                                                         m.captured(1).trimmed());
            },
            "INSTR→POSITION"
        },

        // Иерархия / план / язык
        { QRegularExpression(R"(\bLEVEL\b)", RO::CaseInsensitiveOption),
            [](auto&){ return "/* LEVEL: переписать через рекурсивный CTE */"; },
            "LEVEL→комментарий"
        },
        { QRegularExpression(R"(CONNECT\s+BY)", RO::CaseInsensitiveOption),
            [](auto&){ return "/* CONNECT BY → WITH RECURSIVE (требуется ручная правка) */"; },
            "CONNECT BY→комментарий"
        },
        { QRegularExpression(R"(EXPLAIN\s+PLAN\s+FOR)", RO::CaseInsensitiveOption),
         [](auto&){ return "EXPLAIN"; }, "EXPLAIN PLAN FOR→EXPLAIN" },
        { QRegularExpression(R"(PL/SQL)", RO::CaseInsensitiveOption),
         [](auto&){ return "PL/pgSQL"; }, "PL/SQL→PL/pgSQL" },
        {
            // Удаляем FROM DUAL (и вариант с префиксом схемы)
            QRegularExpression(R"(\bFROM\s+(?:\w+\.)?DUAL\b)", QRegularExpression::CaseInsensitiveOption),
            [](auto&){ return ""; },
            "FROM DUAL→(drop)"
        },
        };

// ===== POSTGRES → ORACLE =====
rulesP2O_ = {
    // Типы данных
    {
        QRegularExpression(R"(\bNUMERIC\b(\s*\(\s*\d+\s*(?:,\s*\d+)?\s*\))?)", RO::CaseInsensitiveOption),
        [](const QRegularExpressionMatch &m){
            const QString paren = m.captured(1);
            return QString("NUMBER%1").arg(paren);
        },
        "NUMERIC→NUMBER"
    },
    { QRegularExpression(R"(\bVARCHAR\s*\(\s*(\d+)\s*\))", RO::CaseInsensitiveOption),
        [](const auto &m){ return QString("VARCHAR2(%1)").arg(m.captured(1)); },
        "VARCHAR→VARCHAR2"
    },
    { // TIMESTAMP [WITH/WITHOUT TIME ZONE] → TIMESTAMP[/WITH TIME ZONE]
        QRegularExpression(R"(\bTIMESTAMP\b(\s+(WITH|WITHOUT)\s+TIME\s+ZONE)?)", RO::CaseInsensitiveOption),
        [](const auto &m){
            const QString tz = m.captured(1).toUpper();
            if (tz.contains("WITH")) return "TIMESTAMP WITH TIME ZONE";
            return "TIMESTAMP"; // Oracle TIMESTAMP без TZ
        },
        "TIMESTAMP→TIMESTAMP"
    },
    { QRegularExpression(R"(\bBYTEA\b)", RO::CaseInsensitiveOption),
     [](auto&){ return "BLOB"; }, "BYTEA→BLOB" },
    { QRegularExpression(R"(\bTEXT\b)", RO::CaseInsensitiveOption),
     [](auto&){ return "CLOB"; }, "TEXT→CLOB" },
    { QRegularExpression(R"(\bINTERVAL\b)", RO::CaseInsensitiveOption),
     [](auto&){ return "INTERVAL DAY TO SECOND"; }, "INTERVAL→INTERVAL DAY TO SECOND" },

    {
        QRegularExpression(
            R"((^|;|\))\s*(SELECT\s+)((?:(?!\bFROM\b|\bWHERE\b|\bGROUP\b|\bORDER\b|\bUNION\b|\bINTERSECT\b|\bEXCEPT\b|\bLIMIT\b|\bOFFSET\b|\)|;).)+))",
            QRegularExpression::CaseInsensitiveOption
                | QRegularExpression::DotMatchesEverythingOption
                | QRegularExpression::MultilineOption),
        [](const QRegularExpressionMatch &m){
            // prefix (1) + "SELECT " (2) + список выражений (3) + " FROM DUAL"
            return QString("%1%2%3 FROM DUAL")
                .arg(m.captured(1), m.captured(2), m.captured(3));
        },
        "SELECT(no FROM)→SELECT ... FROM DUAL"
    },

    // 2) SELECT без FROM после UNION / INTERSECT / EXCEPT → тоже добавить FROM DUAL
    {
        QRegularExpression(
            R"(\b(UNION(?:\s+ALL)?|INTERSECT|EXCEPT)\s+(SELECT\s+)((?:(?!\bFROM\b|\bWHERE\b|\bGROUP\b|\bORDER\b|\bUNION\b|\bINTERSECT\b|\bEXCEPT\b|\bLIMIT\b|\bOFFSET\b|\)|;).)+))",
            QRegularExpression::CaseInsensitiveOption
                | QRegularExpression::DotMatchesEverythingOption
                | QRegularExpression::MultilineOption),
        [](const QRegularExpressionMatch &m){
            // "UNION/..." (1) + пробел + "SELECT " (2) + список выражений (3) + " FROM DUAL"
            return QString("%1 %2%3 FROM DUAL")
                .arg(m.captured(1), m.captured(2), m.captured(3));
        },
        "SET-ops SELECT(no FROM)→... FROM DUAL"
    },

    // Датавремя и константы
    { QRegularExpression(R"(\bCURRENT_TIMESTAMP\b)", RO::CaseInsensitiveOption),
     [](auto&){ return "SYSTIMESTAMP"; }, "CURRENT_TIMESTAMP→SYSTIMESTAMP" },

    // Функции
    { // Только для 2 аргументов — у Oracle есть COALESCE, но просили NVL
        QRegularExpression(R"(COALESCE\s*\(\s*([^,()]+)\s*,\s*([^)]+)\))", RO::CaseInsensitiveOption),
        [](const auto &m){ return QString("NVL(%1, %2)").arg(m.captured(1), m.captured(2)); },
        "COALESCE(2 args)→NVL"
    },
    { // to_timestamp в обе стороны есть
        QRegularExpression(R"(TO_TIMESTAMP\s*\(\s*([^)]+)\))", RO::CaseInsensitiveOption),
        [](const auto &m){ return QString("TO_TIMESTAMP(%1)").arg(m.captured(1)); },
        "TO_TIMESTAMP→TO_TIMESTAMP"
    },
    { // date_trunc('unit', expr) → TRUNC(expr [, 'unit'])
        QRegularExpression(R"(DATE_TRUNC\s*\(\s*'([^']+)'\s*,\s*([^)]+)\))", RO::CaseInsensitiveOption),
        [](const auto &m){
            const QString unit = m.captured(1).toLower();
            const QString expr = m.captured(2).trimmed();
            if (unit == "day" || unit == "dd")
                return QString("TRUNC(%1)").arg(expr);
            return QString("TRUNC(%1, '%2')").arg(expr, unit);
        },
        "date_trunc→TRUNC"
    },
    { // SUBSTRING(s FROM n [FOR m]) → SUBSTR(s,n[,m])
        QRegularExpression(R"(SUBSTRING\s*\(\s*([^,()]+)\s+FROM\s+([^ )]+)(?:\s+FOR\s+([^)]+))?\s*\))", RO::CaseInsensitiveOption),
        [](const auto &m){
            const QString s = m.captured(1).trimmed();
            const QString n = m.captured(2).trimmed();
            const QString len = m.captured(3).trimmed();
            return len.isEmpty()
                       ? QString("SUBSTR(%1, %2)").arg(s, n)
                       : QString("SUBSTR(%1, %2, %3)").arg(s, n, len);
        },
        "SUBSTRING→SUBSTR"
    },
    { // POSITION(sub IN s) → INSTR(s, sub)
        QRegularExpression(R"(POSITION\s*\(\s*([^,()]+)\s+IN\s+([^)]+)\))", RO::CaseInsensitiveOption),
        [](const auto &m){
            return QString("INSTR(%1, %2)").arg(m.captured(2).trimmed(),
                                                m.captured(1).trimmed());
        },
        "POSITION→INSTR"
    },

    // Иерархия / план / язык
    { QRegularExpression(R"(\bWITH\s+RECURSIVE\b)", RO::CaseInsensitiveOption),
        [](auto&){ return "/* WITH RECURSIVE → CONNECT BY/рекурсивный WITH в Oracle (ручная правка) */"; },
        "WITH RECURSIVE→комментарий"
    },
    { QRegularExpression(R"(\bEXPLAIN\b)", RO::CaseInsensitiveOption),
     [](auto&){ return "EXPLAIN PLAN FOR"; }, "EXPLAIN→EXPLAIN PLAN FOR" },
    { QRegularExpression(R"(PL/pgSQL)", RO::CaseInsensitiveOption),
     [](auto&){ return "PL/SQL"; }, "PL/pgSQL→PL/SQL" }
};
}

QString translateSQL::applyRule(const QString &in, const Rule &rule)
{
    QString out;
    out.reserve(in.size());
    int last = 0;
    auto it = rule.pattern.globalMatch(in);
    while (it.hasNext()) {
        auto m = it.next();
        out += in.mid(last, m.capturedStart() - last);
        out += rule.repl(m);
        last = m.capturedEnd();
    }
    out += in.mid(last);
    return out;
}

QString translateSQL::translateString(QString &input, DictionaryType dictType)
{
    const auto &rules = (dictType == oracleToPostgres) ? rulesO2P_ : rulesP2O_;
    QString result = input;

    for (const auto &r : rules) {
        result = applyRule(result, r);
    }

    input = result;
    return input;
}

// ===== helpers =====

QStringList translateSQL::splitTopLevelArgs(const QString &args)
{
    QStringList out;
    QString cur;
    int depth = 0;
    bool inStr = false;
    const int n = args.size();

    for (int i = 0; i < n; ++i) {
        const QChar c = args.at(i);
        if (inStr) {
            cur += c;
            if (c == '\'') {
                // SQL-экранирование одинарной кавычки — удвоением
                bool doubled = (i + 1 < n && args.at(i + 1) == '\'');
                if (doubled) { cur += '\''; ++i; }
                else inStr = false;
            }
            continue;
        }

        if (c == '\'') { inStr = true; cur += c; continue; }
        if (c == '(') { ++depth; cur += c; continue; }
        if (c == ')') { --depth; cur += c; continue; }

        if (c == ',' && depth == 0) {
            out << cur.trimmed();
            cur.clear();
            continue;
        }

        cur += c;
    }
    if (!cur.trimmed().isEmpty()) out << cur.trimmed();
    return out;
}

bool translateSQL::fmtHasTimeTokens(const QString &fmt)
{
    const QString F = fmt.toUpper();
    return F.contains("HH") || F.contains("MI") || F.contains("SS");
}

QString translateSQL::decodeToCase(const QString &inside)
{
    // DECODE(expr, search, result, [search, result]..., [default])
    auto parts = splitTopLevelArgs(inside);
    if (parts.size() < 3) {
        // fallback — не ломаем исходник
        return QString("/* unsupported DECODE */ DECODE(%1)").arg(inside);
    }
    const QString expr = parts.takeFirst();

    QStringList whens;
    int i = 0;
    for (; i + 1 < parts.size(); i += 2) {
        const QString search = parts[i];
        const QString result = parts[i + 1];
        whens << QString("WHEN %1 = %2 THEN %3").arg(expr, search, result);
    }
    QString els;
    if (i < parts.size()) {
        els = QString(" ELSE %1").arg(parts[i]);
    }
    return QString("CASE %1 %2 END")
        .arg(expr, whens.join(' ') + els);
}