db-crud-api 0.3.19 → 0.3.25

package/lib/db-operations.js.bak

@@ -0,0 +1,486 @@
+'use strict';
+
+// import modules
+import schema from './schema.js'
+import * as mssql from './mssql.js';
+import * as mysql from './mysql.js';
+
+// Common
+const defautlFields = ['*'];
+export const serverType = Object.freeze({ mssql:  'ms-sql', mysql: 'my-sql', mongodb: 'mongo-db' });
+export const objectType = Object.freeze({ table:  'T', procedure: 'P' });
+
+// Exported functions 
+export function idField(tSchema) {
+    return tSchema.table?.idField ?? 'id';
+}
+
+export function autoId(tSchema) {
+    return tSchema.table?.autoId;
+}
+
+export function getProperty(obj, keyToFind) {
+    if (typeof obj !== 'object' || obj === null || !keyToFind) {
+        return undefined;
+    }
+
+    const lowerKeyToFind = keyToFind.toLowerCase();
+
+    for (const key in obj) {
+        // Usa hasOwnProperty per escludere le proprietà ereditate
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+
+            if (key.toLowerCase() === lowerKeyToFind) {
+                return obj[key];
+            }
+        }
+    }
+
+    return undefined;
+}
+
+export function upsertProperty(obj, keyToUpdate, newValue) {
+    if (typeof obj !== 'object' || obj === null) {
+        // Non è un oggetto valido
+        return false;
+    }
+
+    const lowerKeyToUpdate = keyToUpdate.toLowerCase();
+    let propertyFound = false;
+
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if (key.toLowerCase() === lowerKeyToUpdate) {
+                obj[key] = newValue;
+                propertyFound = true;
+                break;
+            }
+        }
+    }
+
+    if (!propertyFound) {
+        obj[keyToUpdate] = newValue;
+    }
+
+    return true;
+}
+
+export async function runQuery(dbOpes) {
+
+    // all connections must have same id
+    const _connection = Array.isArray(dbOpes) ? dbOpes[0].connection : dbOpes.connection;
+    if (Array.isArray(dbOpes)) {
+        for (let i = 1; i < dbOpes.length; i++) {
+            if (dbOpes[i].connection?.id !== _connection.id) throw new TypeError('runQuery: for multiple operations, connection must be the same');
+        }
+    }
+    
+    // MSSQL
+    if (_connection.serverType === serverType.mssql) {
+        return await mssql.query(_connection, dbOpes);
+    }
+
+    // MySQL
+    else if (_connection.serverType === serverType.mysql) {
+        return await mysql.query(_connection, dbOpes);
+    }
+    
+    // server type not supported
+    else throw new TypeError('server type not supported');
+    
+}
+
+export function prepareConnection(schema) {
+    // MySQL
+    if (schema.server.type === serverType.mysql) {
+        const _return = mysql.prepareConnection(schema);
+        _return.serverType = serverType.mysql;  // append 'serverType' to connection
+        return _return;
+    }
+    // MSSQL is also the default
+    if (!schema.server.type || schema.server.type === serverType.mssql) { 
+        const _return = mssql.prepareConnection(schema);
+        _return.serverType = serverType.mssql;  // append 'serverType' to connection
+        return _return;
+    }
+    throw new TypeError('server type not supported');
+}
+
+export function closeConnection(connection) {
+    // MSSQL
+    if (connection.serverType === serverType.mssql) { return mssql.closeConnection(connection); }
+    // MySQL
+    if (connection.serverType === serverType.mysql) { return mysql.closeConnection(connection); }
+}
+
+export function closeAllConnections() {
+    // MSSQL
+    mssql.closeAllConnections();
+    // MySQL
+    mysql.closeAllConnections();
+
+    return;
+}
+
+export function testConnection() {
+    const _connection = prepareConnection(prepareSchema("test", objectType.procedure));
+    // MSSQL
+    if (_connection.serverType === serverType.mssql) { return mssql.testConnection(_connection); }
+    // MySQL
+    if (_connection.serverType === serverType.mysql) { return mysql.testConnection(_connection); }
+    // server type not supported
+    throw new TypeError('server type not supported');
+}
+
+export function toStringValue(value) {
+    if (!value) return 'null';
+    if (value.trimStart().charAt(0) === '\'') return value;
+    return `\'${value}\'`;
+}
+
+export function prepareSchema(obj, objType) {
+    // objType = 'objectType.' (Table or StoreProcedure)
+    //     obj = 'systemName.dbName.objName' or 'dbName.objName' or 'objName' or 'systemNme..objName'
+
+    if (obj == undefined || typeof obj !== 'string') throw new TypeError('prepareSchema: wrong obj');
+    if (objType !== undefined && objType !== objectType.table && objType !== objectType.procedure) throw new TypeError(`prepareSchema: wrong objType, must be ${objectType.join(', ')}`);
+    const objPath = obj.trimStart().split(' ')[0];
+
+    // split objPath to serverName,dbName,objName
+    let serverName = undefined;
+    let dbName = undefined;
+    let objName = undefined;
+    const objPathArray = objPath.split('.');
+    if (objPathArray.length > 2) {
+        serverName = objPathArray[0]
+        dbName = objPathArray[1]
+        objName = objPathArray[2]
+    }
+    else if (objPathArray.length > 1) {
+        dbName = objPathArray[0]
+        objName = objPathArray[1]
+    }
+    else if (objPathArray.length > 0) {
+        objName = objPathArray[0]
+    }
+
+    // server
+    if (!serverName || serverName.length == 0) {
+        if (!schema.servers || !Object.keys(schema.servers)[0]) throw new TypeError('missing default server in dbSchema');
+        serverName = Object.keys(schema.servers)[0];
+    }
+    else { // add server to schema 
+        if (!schema.servers) { schema.servers = {} };
+        if (!schema.servers[serverName]) { schema.servers[serverName] = {} };
+    }
+    if (!schema.servers[serverName].realName) { schema.servers[serverName].realName = serverName } // add realName
+
+    // database
+    if (!dbName || dbName.length == 0) {
+        if (!schema.servers[serverName].databases || !Object.keys(schema.servers[serverName].databases)[0]) throw new TypeError('missing default database in dbSchema');
+        dbName = Object.keys(schema.servers[serverName].databases)[0];
+    }
+    else { // add db to schema
+        if (!schema.servers[serverName].databases) { schema.servers[serverName].databases = {} };
+        if (!schema.servers[serverName].databases[dbName]) { schema.servers[serverName].databases[dbName] = {} };
+    }
+    if (!schema.servers[serverName].databases[dbName].realName) { schema.servers[serverName].databases[dbName].realName = dbName } // add realName
+
+    // table
+    if (objType === objectType.table || objType == undefined) {
+        if (!objName || objName.length == 0) {
+            if (!schema.servers[serverName].databases[dbName] || !Object.keys(schema.servers[serverName].databases[dbName].tables)[0]) throw new TypeError('missing default table in dbSchema');
+            objName = Object.keys(schema.servers[serverName].databases[dbName].tables)[0];
+        }
+        else { // add table to schema
+            if (!schema.servers[serverName].databases[dbName].tables) { schema.servers[serverName].databases[dbName].tables = {} };
+            if (!schema.servers[serverName].databases[dbName].tables[objName]) { schema.servers[serverName].databases[dbName].tables[objName] = {} }
+        }
+        if (!schema.servers[serverName].databases[dbName].tables[objName].realName) { schema.servers[serverName].databases[dbName].tables[objName].realName = objName } // add realName
+    }
+
+    // store procedure
+    if (objType === objectType.procedure) {
+        if (!objName || objName.length == 0) {
+            if (!schema.servers[serverName].databases[dbName] || !Object.keys(schema.servers[serverName].databases[dbName].procedures)[0]) throw new TypeError('missing default procedure in dbSchema');
+            objName = Object.keys(schema.servers[serverName].databases[dbName].procedures)[0];
+        }
+        else { // add storeprocedure to schema
+            if (!schema.servers[serverName].databases[dbName].procedures) { schema.servers[serverName].databases[dbName].procedures = {} };
+            if (!schema.servers[serverName].databases[dbName].procedures[objName]) { schema.servers[serverName].databases[dbName].procedures[objName] = {command: obj} }
+        }
+        if (!schema.servers[serverName].databases[dbName].procedures[objName].realName) { schema.servers[serverName].databases[dbName].procedures[objName].realName = objName } // add realName
+    }
+
+    // return Schema
+    return {
+        table: (objType == undefined || objType === objectType.table) ? schema.servers[serverName].databases[dbName].tables[objName] : undefined,
+        procedure:  (objType === objectType.procedure) ? schema.servers[serverName].databases[dbName].procedures[objName] : undefined,
+        database: schema.servers[serverName].databases[dbName],
+        server: schema.servers[serverName]
+    }
+
+}
+
+export function prepareRun(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.get) _result.push(prepareGet(tSchema, connection, _ope));
+        else if (_ope?.patch) _result.push(preparePatch(tSchema, connection, _ope));
+        else if (_ope?.put) _result.push(preparePut(tSchema, connection, _ope));
+        else if (_ope?.delete) _result.push(prepareDelete(tSchema, connection, _ope));
+        else if (_ope?.execute) _result.push(prepareExecute(connection, _ope));
+        else if (_ope?.begin) _result.push(prepareBegin(connection, _ope));
+        else if (_ope?.commit) _result.push(prepareCommit(connection, _ope));
+        else if (_ope?.rollback) _result.push(prepareRollback(connection, _ope));
+        else if (_ope?.passthrough) _result.push(preparePassthrough(connection, _ope));
+        else throw new Error('Request sintax error, missing property get/patch/put/delete/...');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+}
+
+export function prepareRunById(tSchema, connection, reqOpe, idValue) {
+    if (reqOpe?.get) return prepareGetById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.patch) return preparePatchById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.put) return preparePutById(tSchema, connection, reqOpe, idValue);
+    if (reqOpe?.delete) return prepareDeleteById(tSchema, connection, reqOpe, idValue);
+    else throw new Error('Request sintax error, missing property get/patch/put/delete...');
+}
+
+export function prepareGet(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        _result.push({
+            get: {
+                schema: tSchema,
+                options: _ope?.get?.options,
+                fields: _ope?.get?.fields ?? defautlFields,
+                filters: _ope?.get?.filters,
+                groups: _ope?.get?.groups,
+                groupsFilters: _ope?.get?.groupsFilters,
+                orderBy: _ope?.get?.orderBy,
+                params: _ope?.get?.params
+            },
+            connection: connection,
+            appLog: _ope?.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        });
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareGetById(tSchema, connection, reqOpe, idValue) {
+    const _filters = [idField(tSchema) + ' = ' + toStringValue(idValue)];
+    if (reqOpe?.get?.filters && reqOpe?.get?.filters.length > 0) {
+        _filters.push('and');
+        Array.isArray(reqOpe.get.filters) ? _filters.push(...reqOpe.get.filters) : _filters.push(reqOpe.get.filters);
+    }
+    return {
+        get: {
+            schema: tSchema,
+            options: reqOpe?.get?.options,
+            fields: reqOpe?.get?.fields ?? defautlFields,
+            filters: _filters
+        },
+        connection: connection,
+        appLog: reqOpe?.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function preparePatch(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.patch) {
+            if (!_ope.patch.sets) throw new Error('Request sintax error, missing "patch.sets" property.')
+            _result.push({
+                patch: {
+                    schema: tSchema,
+                    sets: _ope.patch.sets,
+                    filters: _ope.patch.filters,
+                    params: _ope.patch.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "patch" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePatchById(tSchema, connection, reqOpe, idValue) {
+    if (!reqOpe?.patch) throw new Error('Request sintax error, missing "patch" property.')
+    if (!reqOpe.patch.sets) throw new Error('Missing "patch.sets" in operation.')
+    const _filters = [idField(tSchema) + ' = ' + toStringValue(idValue)];
+    if (reqOpe?.patch?.filters && reqOpe?.patch?.filters.length > 0) {
+        _filters.push('and');
+        Array.isArray(reqOpe.patch.filters) ? _filters.push(...reqOpe.patch.filters) : _filters.push(reqOpe.patch.filters);
+    }
+    return {
+        patch: {
+            schema: tSchema,
+            sets: reqOpe.patch.sets,
+            filters: _filters
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function preparePut(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.put) {
+            if (!_ope.put.sets) throw new Error('Request sintax error, missing "put.sets" property.')
+            _result.push({
+                put: {
+                    schema: tSchema,
+                    sets: _ope.put.sets,
+                    params: _ope.put.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "put" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePutById(tSchema, connection, reqOpe, idValue) {
+    if (!reqOpe?.put) throw new Error('Request sintax error, missing "put" property.')
+    if (!reqOpe.put.sets) throw new Error('Missing "put.sets" in operation.')
+    upsertProperty(reqOpe.put.sets, idField(tSchema), idValue);
+    return {
+        put: {
+            schema: tSchema,
+            sets: reqOpe.put.sets,
+            params: reqOpe.put.params
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareDelete(tSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.delete) {
+            _result.push({
+                delete: {
+                    schema: tSchema,
+                    filters: _ope.delete.filters,
+                    params: _ope.delete.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "delete" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareDeleteById(tSchema, connection, reqOpe, idValue) {
+    return {
+        delete: {
+            schema: tSchema,
+            filters: [idField(tSchema) + ' = ' + toStringValue(idValue)]
+        },
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareExecute(pSchema, connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        _result.push({
+            execute: {
+                schema: pSchema,
+                arguments: _ope.execute?.arguments,
+                params: _ope.execute?.params
+            },
+            connection: connection,
+            appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+        });
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function preparePassthrough(connection, reqOpe) {
+    const _reqOpe = [];
+    const _result = [];
+    if (Array.isArray(reqOpe)) _reqOpe.push(...reqOpe);
+    else _reqOpe.push(reqOpe);
+    _reqOpe.forEach(function (_ope) {
+        if (_ope?.passthrough) {
+            if (!_ope.passthrough.command) throw new Error('Request sintax error, missing "passthrough.command" property.')
+            _result.push({
+                passthrough: {
+                    command: _ope.passthrough.command,
+                    params: _ope.passthrough.params
+                },
+                connection: connection,
+                appLog: _ope.hasOwnProperty('appLog') ? _ope.appLog : undefined
+            });
+        }
+        else throw new Error('Request sintax error, missing "passthrough" property.');
+    });
+    if (_result.length > 1) return _result;
+    if (_result.length = 1) return _result[0];
+    return undefined;
+};
+
+export function prepareBegin(connection, reqOpe) {
+    return {
+        begin: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareCommit(connection, reqOpe) {
+    return {
+        commit: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};
+
+export function prepareRollback(connection, reqOpe) {
+    return {
+        rollback: {},
+        connection: connection,
+        appLog: reqOpe.hasOwnProperty('appLog') ? reqOpe.appLog : undefined
+    }
+};

package/lib/mssql.js

@@ -11,24 +11,49 @@ const pools = {};
 
 // Common
 function stringifyValue(fieldName, value, tSchema) {
-    if (value == undefined) { return 'null' }
-    if (typeof value !== 'string' || value.trimStart().charAt(0) !== '[') {
-        if (tSchema.table.fields && tSchema.table.fields[fieldName] && tSchema.table.fields[fieldName].type) {
-            if (tSchema.table.fields[fieldName].type == 'datetime') {
-                if (typeof value == 'datetime' || typeof value == 'object') return `\'${value.toISOString()}\'`;
-                if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
-                return value;
-            }
-            if (tSchema.table.fields[fieldName].type == 'boolean' && typeof value == 'boolean') return `\'${value}\'`;
-            if (tSchema.table.fields[fieldName].type == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
-            if (tSchema.table.fields[fieldName].type == 'uuid' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
+
+    // null or undefined
+    if (value == undefined) 
+        return 'null';
+
+    // detect field type from schema
+    let _fieldType = undefined;
+    if (tSchema.table.fields && tSchema.table.fields[fieldName] && tSchema.table.fields[fieldName].type) {
+        _fieldType = tSchema.table.fields[fieldName].type;
+    }
+
+    // if datetime
+    if (_fieldType == 'datetime') {
+        // my-sql not accepts 'Z' at end of ISO string
+        if (value instanceof Date) return `\'${value.toISOString()}\'`;
+        if (typeof value == 'string') {
+            const valueDate = new Date(Date.parse(value));
+            return `\'${valueDate.toISOString()}\'`;
         }
-        else {
-            // if (typeof value == 'datetime') return `\'${value.toISOString()}\'`;
-            if (typeof value == 'boolean') return `\'${value}\'`;
-            if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') return `\'${value}\'`;
+        return value;
+    }
+                
+    // if boolean
+    if (_fieldType == 'boolean' && typeof value == 'boolean') 
+        return `\'${value}\'`;
+
+    // if string or uuid
+    if (_fieldType == 'string' || _fieldType == 'uuid') {
+        if (value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') {
+            return `\'${value}\'`;
         }
     }
+
+    // field not in schema
+    if (_fieldType == undefined) {
+        if (value instanceof Date) 
+            return `\'${value.toISOString()}\'`;
+        if (typeof value == 'boolean') 
+            return `\'${value}\'`;
+        if (typeof value == 'string' && value.trimStart().charAt(0) !== '\'' && value.trimStart().charAt(0) !== '\"') 
+            return `\'${value}\'`;
+    }
+
     return value;
 }
 
@@ -106,21 +131,34 @@ export async function query(connection, dbOpes) {
     // Prepare sql statement
     let sqlString = '';
     let sqlRequest = pool.request();
+    let appLog = true;
     // if exists, input params will be added to request
-    if (Array.isArray(dbOpes)) dbOpes.forEach((dbOpe, index) => { sqlString += ToSql(dbOpe, sqlRequest); });
-    else sqlString += ToSql(dbOpes, sqlRequest);
+    if (Array.isArray(dbOpes)) {
+        dbOpes.forEach((dbOpe, index) => { 
+            sqlString += ToSql(dbOpe, sqlRequest);
+            if (dbOpe.hasOwnProperty('appLog') && dbOpe.appLog === false) appLog = false; 
+        });
+    }
+    else {
+        sqlString += ToSql(dbOpes, sqlRequest);
+        if (dbOpes.hasOwnProperty('appLog') && dbOpes.appLog === false) appLog = false;
+    }
 
     sqlString = normalizeSpecialName(sqlString);
 
     // Log
-    log(sqlString, 50);
-    log(JSON.stringify(dbOpes), 60);
-    
+    if (appLog) {
+        log(sqlString, 50);
+        log(JSON.stringify(dbOpes), 60);
+    }
+
     // Run query
     const sqlresult = await sqlRequest.query(sqlString);
 
     // Log
-    log(`Query result: ${sqlresult.recordset ? sqlresult.recordset.length : 0} rows.`, 50);
+    if (appLog) {
+        log(`Query result: ${sqlresult.recordset ? sqlresult.recordset.length : 0} rows.`, 50);
+    }
 
     // normalize return object
     if (sqlresult.recordset == undefined) return;
@@ -129,14 +167,36 @@ export async function query(connection, dbOpes) {
     return sqlresult.recordset;
 }
 
-// Normalize SpecialName
-function normalizeSpecialName(name) {
-    let _odd = false;  // interpreted as 0
-    return name.replaceAll('\`', (_m) => {
-        _odd = !_odd;
-        if (_odd) return '[';
-        else return ']';
-    });
+// Normalize SQL to replace backticks with square brackets, considering quoted strings
+function normalizeSpecialName(sqlString) {
+    let result = "";
+    let inSingleQuote = false;
+    let inDoubleQuote = false;
+    let msSqlOpening = true; // Serve per alternare [ e ] in modalità mssql
+
+    for (let i = 0; i < sqlString.length; i++) {
+        const char = sqlString[i];
+
+        // Gestione delle stringhe (costanti)
+        if (char === "'" && !inDoubleQuote) {
+            inSingleQuote = !inSingleQuote;
+        } else if (char === '"' && !inSingleQuote) {
+            inDoubleQuote = !inDoubleQuote;
+        }
+
+        // Se siamo fuori dalle citazioni, applichiamo la logica di conversione
+        if (!inSingleQuote && !inDoubleQuote) {
+            if (char === '`') {
+                result += msSqlOpening ? '[' : ']';
+                msSqlOpening = !msSqlOpening; // Alterna per il prossimo backtick
+                continue;
+            }
+        }
+
+        result += char;
+    }
+
+    return result;
 }
 
 // Compose fully qualified table name