datapeek 0.1.11 → 0.1.13

package/dist/server/dev.js

@@ -4,8 +4,15 @@ import {
   executeQuery,
   executeQueryMultiple,
   getConnection,
+  getDbType,
+  getDialect,
+  setDbType,
   testConnection
-} from "./chunk-VEX42Z2L.js";
+} from "./chunk-26GSUAI4.js";
+import {
+  cancelQuery,
+  generateQueryId
+} from "./chunk-3DAIYH42.js";
 
 // src/server/index.ts
 import express from "express";
@@ -25,9 +32,12 @@ connectionRoutes.post("/test", async (req, res) => {
         message: "Connection test timeout"
       });
     }
-  }, 1e4);
+  }, 18e5);
   try {
     const config = req.body;
+    if (config.dbType) {
+      setDbType(config.dbType);
+    }
     await testConnection(config);
     clearTimeout(timeout);
     if (!res.headersSent) {
@@ -55,9 +65,12 @@ connectionRoutes.post("/", async (req, res) => {
         message: "Connection timeout"
       });
     }
-  }, 15e3);
+  }, 18e5);
   try {
     const config = req.body;
+    if (config.dbType) {
+      setDbType(config.dbType);
+    }
     await connect(config);
     clearTimeout(timeout);
     if (!res.headersSent) {
@@ -86,19 +99,28 @@ connectionRoutes.delete("/", async (req, res) => {
 });
 connectionRoutes.get("/status", async (req, res) => {
   try {
-    const { getConnection: getConnection2, executeQuery: executeQuery3 } = await import("./mssql-UZUN227W.js");
-    const pool = getConnection2();
-    if (pool && pool.connected) {
-      try {
-        const result = await executeQuery3("SELECT DB_NAME() as databaseName");
-        const databaseName = result[0]?.databaseName || null;
-        res.json({ connected: true, databaseName });
-      } catch (error) {
-        const errorMessage = error.message || "";
-        if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-          const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
-          await disconnect2();
+    const pool = getConnection();
+    if (pool) {
+      let isConnected = false;
+      if ("connected" in pool) {
+        isConnected = pool.connected === true;
+      } else {
+        isConnected = !pool.ended;
+      }
+      if (isConnected) {
+        try {
+          const dialect = getDialect();
+          const result = await executeQuery(dialect.currentDbQuery());
+          const databaseName = result[0]?.databaseName || null;
+          res.json({ connected: true, databaseName });
+        } catch (error) {
+          const errorMessage = error.message || "";
+          if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+            await disconnect();
+          }
+          res.json({ connected: false });
         }
+      } else {
         res.json({ connected: false });
       }
     } else {
@@ -111,28 +133,34 @@ connectionRoutes.get("/status", async (req, res) => {
 
 // src/server/routes/tables.ts
 import { Router as Router2 } from "express";
-import sql from "mssql";
 var tableRoutes = Router2();
 tableRoutes.get("/", async (req, res) => {
   try {
     const pool = getConnection();
-    if (!pool || !pool.connected) {
+    if (!pool) {
       return res.status(400).json({ error: "Not connected to database" });
     }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const dialect = getDialect();
+    const dbType = getDbType();
+    const schemaFilter = dbType === "postgres" ? `AND table_schema NOT IN ('pg_catalog', 'information_schema')` : "";
     const query = `
       SELECT 
-        TABLE_SCHEMA as schemaName,
-        TABLE_NAME as tableName
-      FROM INFORMATION_SCHEMA.TABLES
-      WHERE TABLE_TYPE = 'BASE TABLE'
-      ORDER BY TABLE_SCHEMA, TABLE_NAME
+        table_schema as "schemaName",
+        table_name as "tableName"
+      FROM information_schema.tables
+      WHERE table_type = 'BASE TABLE'${schemaFilter}
+      ORDER BY table_schema, table_name
     `;
     const result = await executeQuery(query);
     res.json(result);
   } catch (error) {
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch tables" });
@@ -142,64 +170,69 @@ tableRoutes.get("/:schema/:table", async (req, res) => {
   try {
     const { schema, table } = req.params;
     const pool = getConnection();
-    if (!pool || !pool.connected) {
+    if (!pool) {
       return res.status(400).json({ error: "Not connected to database" });
     }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const dialect = getDialect();
     const query = `
       SELECT 
-        c.COLUMN_NAME as columnName,
-        c.DATA_TYPE as dataType,
-        c.CHARACTER_MAXIMUM_LENGTH as maxLength,
-        c.IS_NULLABLE as isNullable,
-        c.COLUMN_DEFAULT as defaultValue,
-        CASE WHEN pk.COLUMN_NAME IS NOT NULL THEN 1 ELSE 0 END as isPrimaryKey,
-        fk.REFERENCED_TABLE_SCHEMA as referencedSchema,
-        fk.REFERENCED_TABLE_NAME as referencedTable,
-        fk.REFERENCED_COLUMN_NAME as referencedColumn
-      FROM INFORMATION_SCHEMA.COLUMNS c
+        c.column_name as "columnName",
+        c.data_type as "dataType",
+        c.character_maximum_length as "maxLength",
+        c.is_nullable as "isNullable",
+        c.column_default as "defaultValue",
+        CASE WHEN pk.column_name IS NOT NULL THEN 1 ELSE 0 END as "isPrimaryKey",
+        fk.referenced_table_schema as "referencedSchema",
+        fk.referenced_table_name as "referencedTable",
+        fk.referenced_column_name as "referencedColumn"
+      FROM information_schema.columns c
       LEFT JOIN (
-        SELECT ku.TABLE_SCHEMA, ku.TABLE_NAME, ku.COLUMN_NAME
-        FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE ku
-          ON tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
-          AND tc.CONSTRAINT_NAME = ku.CONSTRAINT_NAME
-      ) pk ON c.TABLE_SCHEMA = pk.TABLE_SCHEMA
-        AND c.TABLE_NAME = pk.TABLE_NAME
-        AND c.COLUMN_NAME = pk.COLUMN_NAME
+        SELECT ku.table_schema, ku.table_name, ku.column_name
+        FROM information_schema.table_constraints tc
+        INNER JOIN information_schema.key_column_usage ku
+          ON tc.constraint_type = 'PRIMARY KEY'
+          AND tc.constraint_name = ku.constraint_name
+      ) pk ON c.table_schema = pk.table_schema
+        AND c.table_name = pk.table_name
+        AND c.column_name = pk.column_name
       LEFT JOIN (
         SELECT 
-          kcu1.TABLE_SCHEMA,
-          kcu1.TABLE_NAME,
-          kcu1.COLUMN_NAME,
-          kcu2.TABLE_SCHEMA as REFERENCED_TABLE_SCHEMA,
-          kcu2.TABLE_NAME as REFERENCED_TABLE_NAME,
-          kcu2.COLUMN_NAME as REFERENCED_COLUMN_NAME
-        FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu1
-          ON rc.CONSTRAINT_CATALOG = kcu1.CONSTRAINT_CATALOG
-          AND rc.CONSTRAINT_SCHEMA = kcu1.CONSTRAINT_SCHEMA
-          AND rc.CONSTRAINT_NAME = kcu1.CONSTRAINT_NAME
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu2
-          ON rc.UNIQUE_CONSTRAINT_CATALOG = kcu2.CONSTRAINT_CATALOG
-          AND rc.UNIQUE_CONSTRAINT_SCHEMA = kcu2.CONSTRAINT_SCHEMA
-          AND rc.UNIQUE_CONSTRAINT_NAME = kcu2.CONSTRAINT_NAME
-          AND kcu1.ORDINAL_POSITION = kcu2.ORDINAL_POSITION
-      ) fk ON c.TABLE_SCHEMA = fk.TABLE_SCHEMA
-        AND c.TABLE_NAME = fk.TABLE_NAME
-        AND c.COLUMN_NAME = fk.COLUMN_NAME
-      WHERE c.TABLE_SCHEMA = @schema
-        AND c.TABLE_NAME = @table
-      ORDER BY c.ORDINAL_POSITION
+          kcu1.table_schema,
+          kcu1.table_name,
+          kcu1.column_name,
+          kcu2.table_schema as referenced_table_schema,
+          kcu2.table_name as referenced_table_name,
+          kcu2.column_name as referenced_column_name
+        FROM information_schema.referential_constraints rc
+        INNER JOIN information_schema.key_column_usage kcu1
+          ON rc.constraint_catalog = kcu1.constraint_catalog
+          AND rc.constraint_schema = kcu1.constraint_schema
+          AND rc.constraint_name = kcu1.constraint_name
+        INNER JOIN information_schema.key_column_usage kcu2
+          ON rc.unique_constraint_catalog = kcu2.constraint_catalog
+          AND rc.unique_constraint_schema = kcu2.constraint_schema
+          AND rc.unique_constraint_name = kcu2.constraint_name
+          AND kcu1.ordinal_position = kcu2.ordinal_position
+      ) fk ON c.table_schema = fk.table_schema
+        AND c.table_name = fk.table_name
+        AND c.column_name = fk.column_name
+      WHERE c.table_schema = @schema
+        AND c.table_name = @table
+      ORDER BY c.ordinal_position
     `;
     const result = await executeQuery(query, [
-      { name: "schema", value: schema, type: sql.NVarChar },
-      { name: "table", value: table, type: sql.NVarChar }
+      { name: "schema", value: schema },
+      { name: "table", value: table }
     ]);
     res.json(result);
   } catch (error) {
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch table structure" });
@@ -262,28 +295,35 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     }
     console.log("Parsed filters:", parsedFilters);
     const pool = getConnection();
-    if (!pool || !pool.connected) {
+    if (!pool) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
       return res.status(400).json({ error: "Not connected to database" });
     }
+    const dialect = getDialect();
     const columnMetadata = {};
     if (parsedFilters.length > 0) {
       try {
         const columnNames = [...new Set(parsedFilters.map((f) => f.column))];
-        const placeholders = columnNames.map((_, i) => `@col${i}`).join(", ");
+        const placeholders = columnNames.map((_, i) => dialect.param(i + 3)).join(", ");
         const validateQuery = `
-          SELECT COLUMN_NAME, DATA_TYPE
-          FROM INFORMATION_SCHEMA.COLUMNS 
-          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND COLUMN_NAME IN (${placeholders})
+          SELECT column_name, data_type
+          FROM information_schema.columns 
+          WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)} AND column_name IN (${placeholders})
         `;
         const validateParams = [
-          { name: "schema", value: schema, type: sql.NVarChar },
-          { name: "table", value: table, type: sql.NVarChar },
-          ...columnNames.map((col, i) => ({ name: `col${i}`, value: col, type: sql.NVarChar }))
+          { name: "schema", value: schema },
+          { name: "table", value: table },
+          ...columnNames.map((col) => ({ name: "col", value: col }))
         ];
         const validateResult = await executeQuery(validateQuery, validateParams);
         validateResult.forEach((r) => {
-          columnMetadata[r.COLUMN_NAME] = {
-            dataType: r.DATA_TYPE,
+          const colName = r.column_name || r.COLUMN_NAME;
+          const dataType = r.data_type || r.DATA_TYPE;
+          columnMetadata[colName] = {
+            dataType,
             exists: true
           };
         });
@@ -292,24 +332,9 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
         console.error("Error validating filter columns:", e);
       }
     }
-    const getSqlType = (dataType) => {
-      const dt = dataType.toLowerCase();
-      if (dt === "int" || dt === "integer") return sql.Int;
-      if (dt === "bigint") return sql.BigInt;
-      if (dt === "smallint") return sql.SmallInt;
-      if (dt === "tinyint") return sql.TinyInt;
-      if (dt === "bit") return sql.Bit;
-      if (dt === "float" || dt === "real" || dt === "double precision") return sql.Float;
-      if (dt === "decimal" || dt === "numeric" || dt === "money" || dt === "smallmoney") return sql.Decimal(18, 2);
-      if (dt === "datetime" || dt === "datetime2" || dt === "smalldatetime") return sql.DateTime;
-      if (dt === "date") return sql.Date;
-      if (dt === "time") return sql.Time;
-      if (dt === "uniqueidentifier") return sql.UniqueIdentifier;
-      return sql.NVarChar;
-    };
     let whereClause = "";
     const filterParams = [];
-    let paramIndex = 0;
+    let paramIndex = 1;
     if (parsedFilters.length > 0) {
       const whereConditions = [];
       parsedFilters.forEach((filter) => {
@@ -325,83 +350,82 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
         if (value === null || value === void 0 || value === "") {
           return;
         }
-        const sqlType = getSqlType(dataType);
-        const paramName = `filter${paramIndex}`;
+        const quotedColumn = dialect.quoteId(columnName);
         try {
           let condition = "";
           switch (operator) {
             // Text operators
             case "contains":
-              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
-              condition = `[${columnName}] LIKE @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "equals":
-              filterParams.push({ name: paramName, value: String(value), type: sqlType });
-              condition = `[${columnName}] = @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
               break;
             case "startsWith":
-              filterParams.push({ name: paramName, value: `${String(value)}%`, type: sql.NVarChar });
-              condition = `[${columnName}] LIKE @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: `${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "endsWith":
-              filterParams.push({ name: paramName, value: `%${String(value)}`, type: sql.NVarChar });
-              condition = `[${columnName}] LIKE @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
               break;
             case "notContains":
-              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
-              condition = `[${columnName}] NOT LIKE @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} NOT LIKE ${dialect.param(paramIndex)}`;
               break;
             // Number operators
             case "eq":
-              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
-              condition = `[${columnName}] = @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
               break;
             case "gt":
-              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
-              condition = `[${columnName}] > @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} > ${dialect.param(paramIndex)}`;
               break;
             case "gte":
-              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
-              condition = `[${columnName}] >= @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} >= ${dialect.param(paramIndex)}`;
               break;
             case "lt":
-              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
-              condition = `[${columnName}] < @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} < ${dialect.param(paramIndex)}`;
               break;
             case "lte":
-              filterParams.push({ name: paramName, value: Number(value), type: sqlType });
-              condition = `[${columnName}] <= @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} <= ${dialect.param(paramIndex)}`;
               break;
             case "between":
               if (typeof value === "object" && "from" in value && "to" in value) {
-                const fromParam = `filter${paramIndex}`;
-                const toParam = `filter${paramIndex + 1}`;
-                filterParams.push({ name: fromParam, value: Number(value.from), type: sqlType });
-                filterParams.push({ name: toParam, value: Number(value.to), type: sqlType });
-                condition = `[${columnName}] BETWEEN @${fromParam} AND @${toParam}`;
+                const fromParamIndex = paramIndex;
+                const toParamIndex = paramIndex + 1;
+                filterParams.push({ name: `filter${fromParamIndex}`, value: Number(value.from) });
+                filterParams.push({ name: `filter${toParamIndex}`, value: Number(value.to) });
+                condition = `${quotedColumn} BETWEEN ${dialect.param(fromParamIndex)} AND ${dialect.param(toParamIndex)}`;
                 paramIndex++;
               }
               break;
             // Date operators
             case "dateEq":
-              filterParams.push({ name: paramName, value: String(value), type: sqlType });
-              condition = `CAST([${columnName}] AS DATE) = CAST(@${paramName} AS DATE)`;
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${dialect.castToDate(quotedColumn)} = ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateAfter":
-              filterParams.push({ name: paramName, value: String(value), type: sqlType });
-              condition = `CAST([${columnName}] AS DATE) > CAST(@${paramName} AS DATE)`;
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${dialect.castToDate(quotedColumn)} > ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateBefore":
-              filterParams.push({ name: paramName, value: String(value), type: sqlType });
-              condition = `CAST([${columnName}] AS DATE) < CAST(@${paramName} AS DATE)`;
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${dialect.castToDate(quotedColumn)} < ${dialect.castToDate(dialect.param(paramIndex))}`;
               break;
             case "dateBetween":
               if (typeof value === "object" && "from" in value && "to" in value) {
-                const fromParam = `filter${paramIndex}`;
-                const toParam = `filter${paramIndex + 1}`;
-                filterParams.push({ name: fromParam, value: String(value.from), type: sqlType });
-                filterParams.push({ name: toParam, value: String(value.to), type: sqlType });
-                condition = `CAST([${columnName}] AS DATE) BETWEEN CAST(@${fromParam} AS DATE) AND CAST(@${toParam} AS DATE)`;
+                const fromParamIndex = paramIndex;
+                const toParamIndex = paramIndex + 1;
+                filterParams.push({ name: `filter${fromParamIndex}`, value: String(value.from) });
+                filterParams.push({ name: `filter${toParamIndex}`, value: String(value.to) });
+                condition = `${dialect.castToDate(quotedColumn)} BETWEEN ${dialect.castToDate(dialect.param(fromParamIndex))} AND ${dialect.castToDate(dialect.param(toParamIndex))}`;
                 paramIndex++;
               }
               break;
@@ -409,19 +433,21 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
             case "in":
             case "notIn":
               if (Array.isArray(value) && value.length > 0) {
-                const placeholders = value.map((_, i) => `@${paramName}_${i}`).join(", ");
+                const placeholders = [];
                 value.forEach((val, i) => {
-                  filterParams.push({ name: `${paramName}_${i}`, value: val, type: sqlType });
+                  const currentIndex = paramIndex + i;
+                  filterParams.push({ name: `filter${currentIndex}`, value: val });
+                  placeholders.push(dialect.param(currentIndex));
                 });
                 const inOperator = operator === "in" ? "IN" : "NOT IN";
-                condition = `[${columnName}] ${inOperator} (${placeholders})`;
+                condition = `${quotedColumn} ${inOperator} (${placeholders.join(", ")})`;
                 paramIndex += value.length - 1;
               }
               break;
             default:
               console.warn(`Unknown filter operator: ${operator}, falling back to contains`);
-              filterParams.push({ name: paramName, value: `%${String(value)}%`, type: sql.NVarChar });
-              condition = `[${columnName}] LIKE @${paramName}`;
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
           }
           if (condition) {
             whereConditions.push(condition);
@@ -438,11 +464,13 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
       }
     }
     const qualifiedDataWhereClause = parsedFilters.reduce((clause, filter) => {
-      const escapedColumn = filter.column.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const pattern = new RegExp(`\\[${escapedColumn}\\]`, "g");
-      return clause.replace(pattern, `[t].[${filter.column}]`);
+      const quotedColumn = dialect.quoteId(filter.column);
+      const quotedTableColumn = `${dialect.quoteId("t")}.${quotedColumn}`;
+      return clause.replace(new RegExp(quotedColumn.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), quotedTableColumn);
     }, whereClause);
-    const countQuery = `SELECT COUNT(*) as total FROM [${schema}].[${table}]${whereClause ? " " + whereClause : ""}`;
+    const quotedSchema = dialect.quoteId(schema);
+    const quotedTable = dialect.quoteId(table);
+    const countQuery = `SELECT COUNT(*) as total FROM ${quotedSchema}.${quotedTable}${whereClause ? " " + whereClause : ""}`;
     const countResult = await executeQuery(countQuery, filterParams.length > 0 ? filterParams : []);
     const total = countResult[0]?.total || 0;
     let orderByColumn = sortColumn || "";
@@ -450,17 +478,19 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     if (orderByColumn) {
       try {
         const validateQuery = `
-          SELECT COLUMN_NAME 
-          FROM INFORMATION_SCHEMA.COLUMNS 
-          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table AND COLUMN_NAME = @column
+          SELECT column_name 
+          FROM information_schema.columns 
+          WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)} AND column_name = ${dialect.param(3)}
         `;
         const validateResult = await executeQuery(validateQuery, [
-          { name: "schema", value: schema, type: sql.NVarChar },
-          { name: "table", value: table, type: sql.NVarChar },
-          { name: "column", value: orderByColumn, type: sql.NVarChar }
+          { name: "schema", value: schema },
+          { name: "table", value: table },
+          { name: "column", value: orderByColumn }
         ]);
         if (validateResult.length === 0) {
           orderByColumn = "";
+        } else {
+          orderByColumn = validateResult[0].column_name || validateResult[0].COLUMN_NAME || orderByColumn;
         }
       } catch (e) {
         orderByColumn = "";
@@ -468,18 +498,20 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     }
     if (!orderByColumn) {
       try {
+        const topClause = dialect.topN(1);
         const structureQuery = `
-          SELECT TOP 1 COLUMN_NAME 
-          FROM INFORMATION_SCHEMA.COLUMNS 
-          WHERE TABLE_SCHEMA = @schema AND TABLE_NAME = @table
-          ORDER BY ORDINAL_POSITION
+          SELECT ${topClause ? topClause + " " : ""}column_name 
+          FROM information_schema.columns 
+          WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)}
+          ORDER BY ordinal_position
+          ${!topClause ? dialect.limitOffset(0, 1) : ""}
         `;
         const structureResult = await executeQuery(structureQuery, [
-          { name: "schema", value: schema, type: sql.NVarChar },
-          { name: "table", value: table, type: sql.NVarChar }
+          { name: "schema", value: schema },
+          { name: "table", value: table }
         ]);
         if (structureResult.length > 0) {
-          orderByColumn = structureResult[0].COLUMN_NAME;
+          orderByColumn = structureResult[0].column_name || structureResult[0].COLUMN_NAME;
         }
       } catch (e) {
       }
@@ -489,48 +521,48 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const fkDisplayColumns = {};
     const fkQuery = `
         SELECT 
-          kcu1.COLUMN_NAME as fkColumnName,
-          kcu2.TABLE_SCHEMA as referencedSchema,
-          kcu2.TABLE_NAME as referencedTable,
-          kcu2.COLUMN_NAME as referencedColumn
-        FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu1
-          ON rc.CONSTRAINT_CATALOG = kcu1.CONSTRAINT_CATALOG
-          AND rc.CONSTRAINT_SCHEMA = kcu1.CONSTRAINT_SCHEMA
-          AND rc.CONSTRAINT_NAME = kcu1.CONSTRAINT_NAME
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu2
-          ON rc.UNIQUE_CONSTRAINT_CATALOG = kcu2.CONSTRAINT_CATALOG
-          AND rc.UNIQUE_CONSTRAINT_SCHEMA = kcu2.CONSTRAINT_SCHEMA
-          AND rc.UNIQUE_CONSTRAINT_NAME = kcu2.CONSTRAINT_NAME
-          AND kcu1.ORDINAL_POSITION = kcu2.ORDINAL_POSITION
-        WHERE kcu1.TABLE_SCHEMA = @schema
-          AND kcu1.TABLE_NAME = @table
+          kcu1.column_name as "fkColumnName",
+          kcu2.table_schema as "referencedSchema",
+          kcu2.table_name as "referencedTable",
+          kcu2.column_name as "referencedColumn"
+        FROM information_schema.referential_constraints rc
+        INNER JOIN information_schema.key_column_usage kcu1
+          ON rc.constraint_catalog = kcu1.constraint_catalog
+          AND rc.constraint_schema = kcu1.constraint_schema
+          AND rc.constraint_name = kcu1.constraint_name
+        INNER JOIN information_schema.key_column_usage kcu2
+          ON rc.unique_constraint_catalog = kcu2.constraint_catalog
+          AND rc.unique_constraint_schema = kcu2.constraint_schema
+          AND rc.unique_constraint_name = kcu2.constraint_name
+          AND kcu1.ordinal_position = kcu2.ordinal_position
+        WHERE kcu1.table_schema = ${dialect.param(1)}
+          AND kcu1.table_name = ${dialect.param(2)}
       `;
     console.log("Fetching foreign keys with query:", fkQuery);
     const foreignKeys = await executeQuery(fkQuery, [
-      { name: "schema", value: schema, type: sql.NVarChar },
-      { name: "table", value: table, type: sql.NVarChar }
+      { name: "schema", value: schema },
+      { name: "table", value: table }
     ]);
     console.log(`Found ${foreignKeys.length} foreign key(s)`);
     if (foreignKeys.length > 0) {
       const uniqueRefTables = Array.from(
-        new Set(foreignKeys.map((fk) => `${fk.referencedSchema}.${fk.referencedTable}`))
+        new Set(foreignKeys.map((fk) => `${fk.referencedSchema || fk.referenced_schema}.${fk.referencedTable || fk.referenced_table}`))
       );
       const tableConditions = uniqueRefTables.map((tableRef, idx) => {
         const [refSchema, refTable] = tableRef.split(".");
-        return `(TABLE_SCHEMA = @refSchema${idx} AND TABLE_NAME = @refTable${idx})`;
+        return `(table_schema = ${dialect.param(idx * 2 + 1)} AND table_name = ${dialect.param(idx * 2 + 2)})`;
       }).join(" OR ");
       const batchColumnsQuery = `
-        SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION
-        FROM INFORMATION_SCHEMA.COLUMNS
+        SELECT table_schema, table_name, column_name, data_type, ordinal_position
+        FROM information_schema.columns
         WHERE ${tableConditions}
-        ORDER BY TABLE_SCHEMA, TABLE_NAME, ORDINAL_POSITION
+        ORDER BY table_schema, table_name, ordinal_position
       `;
-      const batchParams = uniqueRefTables.flatMap((tableRef, idx) => {
+      const batchParams = uniqueRefTables.flatMap((tableRef) => {
         const [refSchema, refTable] = tableRef.split(".");
         return [
-          { name: `refSchema${idx}`, value: refSchema, type: sql.NVarChar },
-          { name: `refTable${idx}`, value: refTable, type: sql.NVarChar }
+          { name: "refSchema", value: refSchema },
+          { name: "refTable", value: refTable }
         ];
       });
       console.log("Fetching referenced table columns with query:", batchColumnsQuery);
@@ -539,37 +571,41 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
       console.log(`Found columns for ${uniqueRefTables.length} referenced table(s)`);
       const columnsByTable = {};
       allRefColumns.forEach((col) => {
-        const key = `${col.TABLE_SCHEMA}.${col.TABLE_NAME}`;
+        const schemaName = col.table_schema || col.TABLE_SCHEMA;
+        const tableName = col.table_name || col.TABLE_NAME;
+        const key = `${schemaName}.${tableName}`;
         if (!columnsByTable[key]) {
           columnsByTable[key] = [];
         }
         columnsByTable[key].push(col);
       });
       for (const fk of foreignKeys) {
-        const fkColumn = fk.fkColumnName;
-        const refSchema = fk.referencedSchema;
-        const refTable = fk.referencedTable;
-        const refColumn = fk.referencedColumn;
+        const fkColumn = fk.fkColumnName || fk.fk_column_name;
+        const refSchema = fk.referencedSchema || fk.referenced_schema;
+        const refTable = fk.referencedTable || fk.referenced_table;
+        const refColumn = fk.referencedColumn || fk.referenced_column;
         const tableKey = `${refSchema}.${refTable}`;
         const refColumns = columnsByTable[tableKey] || [];
         const preferredNames = ["name", "title", "description", "code"];
         let displayColumn = null;
         for (const preferredName of preferredNames) {
-          const found = refColumns.find(
-            (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase()
-          );
+          const found = refColumns.find((col) => {
+            const colName = col.column_name || col.COLUMN_NAME;
+            return colName.toLowerCase() === preferredName.toLowerCase();
+          });
           if (found) {
-            displayColumn = found.COLUMN_NAME;
+            displayColumn = found.column_name || found.COLUMN_NAME;
             break;
           }
         }
         if (!displayColumn) {
           const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
-          const found = refColumns.find(
-            (col) => stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
-          );
+          const found = refColumns.find((col) => {
+            const dataType = col.data_type || col.DATA_TYPE;
+            return stringTypes.some((type) => dataType.toLowerCase().includes(type));
+          });
           if (found) {
-            displayColumn = found.COLUMN_NAME;
+            displayColumn = found.column_name || found.COLUMN_NAME;
           }
         }
         if (displayColumn) {
@@ -583,89 +619,79 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
               refColumn,
               displayColumn
             });
-            fkSelects.push(`${alias}.[${displayColumn}] as [${fkColumn}_display]`);
+            fkSelects.push(`${dialect.quoteId(alias)}.${dialect.quoteId(displayColumn)} as ${dialect.quoteId(`${fkColumn}_display`)}`);
           }
           fkDisplayColumns[fkColumn] = displayColumn;
         }
       }
     }
     const baseTableAlias = "t";
-    let baseSelects = `[${baseTableAlias}].*`;
+    const quotedTableAlias = dialect.quoteId(baseTableAlias);
+    let baseSelects = `${quotedTableAlias}.*`;
     if (fkDisplayMode === "display-only") {
       const fkColumnNames = fkJoins.map((fk) => fk.fkColumn);
       if (fkColumnNames.length > 0) {
-        baseSelects = `[${baseTableAlias}].*`;
+        baseSelects = `${quotedTableAlias}.*`;
       }
     }
     const allSelects = `${baseSelects}${fkSelects.length > 0 ? ", " + fkSelects.join(", ") : ""}`;
     const buildJoinClauses = (tableAlias) => {
-      return fkJoins.map(
-        (fk) => `LEFT JOIN [${fk.refSchema}].[${fk.refTable}] ${fk.alias} ON [${tableAlias}].[${fk.fkColumn}] = ${fk.alias}.[${fk.refColumn}]`
-      ).join("\n        ");
+      const quotedAlias = dialect.quoteId(tableAlias);
+      return fkJoins.map((fk) => {
+        const quotedRefSchema = dialect.quoteId(fk.refSchema);
+        const quotedRefTable = dialect.quoteId(fk.refTable);
+        const quotedAliasName = dialect.quoteId(fk.alias);
+        const quotedFkColumn = dialect.quoteId(fk.fkColumn);
+        const quotedRefColumn = dialect.quoteId(fk.refColumn);
+        return `LEFT JOIN ${quotedRefSchema}.${quotedRefTable} ${quotedAliasName} ON ${quotedAlias}.${quotedFkColumn} = ${quotedAliasName}.${quotedRefColumn}`;
+      }).join("\n        ");
     };
     let data;
     let generatedQuery = "";
+    const offsetParamIndex = filterParams.length + 1;
+    const pageSizeParamIndex = filterParams.length + 2;
     if (orderByColumn) {
+      const quotedOrderByColumn = dialect.quoteId(orderByColumn);
+      const limitOffsetClause = dialect.limitOffset(offset, pageSize);
       const dataQuery = `
         SELECT ${allSelects}
-        FROM [${schema}].[${table}] ${baseTableAlias}
+        FROM ${quotedSchema}.${quotedTable} ${quotedTableAlias}
         ${buildJoinClauses(baseTableAlias)}
         ${qualifiedDataWhereClause}
-        ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
-        OFFSET @offset ROWS
-        FETCH NEXT @pageSize ROWS ONLY
+        ORDER BY ${quotedTableAlias}.${quotedOrderByColumn} ${orderByDirection}
+        ${limitOffsetClause}
       `;
       generatedQuery = `SELECT ${allSelects}
-FROM [${schema}].[${table}] ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${qualifiedDataWhereClause ? "\n" + qualifiedDataWhereClause : ""}
-ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
-OFFSET ${offset} ROWS
-FETCH NEXT ${pageSize} ROWS ONLY`;
+FROM ${quotedSchema}.${quotedTable} ${quotedTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${qualifiedDataWhereClause ? "\n" + qualifiedDataWhereClause : ""}
+ORDER BY ${quotedTableAlias}.${quotedOrderByColumn} ${orderByDirection}
+${limitOffsetClause}`;
       console.log("Executing SQL query:", dataQuery);
       console.log("Query parameters:", {
         offset,
         pageSize,
         filterParams: filterParams.map((p) => ({ name: p.name, value: p.value }))
       });
-      data = await executeQuery(dataQuery, [
-        { name: "offset", value: offset, type: sql.Int },
-        { name: "pageSize", value: pageSize, type: sql.Int },
-        ...filterParams
-      ]);
+      data = await executeQuery(dataQuery, filterParams);
     } else {
-      const innerQuery = `
-        SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
-        FROM [${schema}].[${table}]
-        ${whereClause}
-      `;
+      const dbType = getDbType();
+      const limitOffsetClause = dialect.limitOffset(offset, pageSize);
       const dataQuery = `
         SELECT ${allSelects}
-        FROM (${innerQuery}) ${baseTableAlias}
+        FROM ${quotedSchema}.${quotedTable} ${quotedTableAlias}
         ${buildJoinClauses(baseTableAlias)}
-        WHERE ${baseTableAlias}.rn > @offset AND ${baseTableAlias}.rn <= @offset + @pageSize
-        ORDER BY ${baseTableAlias}.rn
+        ${qualifiedDataWhereClause}
+        ${limitOffsetClause}
       `;
       generatedQuery = `SELECT ${allSelects}
-FROM (
-  SELECT *, ROW_NUMBER() OVER (ORDER BY (SELECT NULL)) as rn
-  FROM [${schema}].[${table}]${whereClause ? "\n  " + whereClause : ""}
-) ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}
-WHERE ${baseTableAlias}.rn > ${offset} AND ${baseTableAlias}.rn <= ${offset + pageSize}
-ORDER BY ${baseTableAlias}.rn`;
+FROM ${quotedSchema}.${quotedTable} ${quotedTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${qualifiedDataWhereClause ? "\n" + qualifiedDataWhereClause : ""}
+${limitOffsetClause}`;
       console.log("Executing SQL query:", dataQuery);
       console.log("Query parameters:", {
         offset,
         pageSize,
         filterParams: filterParams.map((p) => ({ name: p.name, value: p.value }))
       });
-      data = await executeQuery(dataQuery, [
-        { name: "offset", value: offset, type: sql.Int },
-        { name: "pageSize", value: pageSize, type: sql.Int },
-        ...filterParams
-      ]);
-      data = data.map((row) => {
-        const { rn, ...rest } = row;
-        return rest;
-      });
+      data = await executeQuery(dataQuery, filterParams);
     }
     if (fkDisplayMode === "display-only") {
       const fkColumnNames = fkJoins.map((fk) => fk.fkColumn);
@@ -693,10 +719,22 @@ ORDER BY ${baseTableAlias}.rn`;
       const paramValues = new Map(
         filterParams.map((p) => [p.name, p.value])
       );
-      generatedQuery = generatedQuery.replace(/@([A-Za-z0-9_]+)/g, (full, name) => {
-        if (!paramValues.has(name)) return full;
-        return formatSqlLiteral(paramValues.get(name));
-      });
+      const dbType = getDbType();
+      if (dbType === "postgres") {
+        let paramIndex2 = 1;
+        generatedQuery = generatedQuery.replace(/\$(\d+)/g, (full, index) => {
+          const idx = parseInt(index, 10) - 1;
+          if (idx < filterParams.length) {
+            return formatSqlLiteral(filterParams[idx].value);
+          }
+          return full;
+        });
+      } else {
+        generatedQuery = generatedQuery.replace(/@([A-Za-z0-9_]+)/g, (full, name) => {
+          if (!paramValues.has(name)) return full;
+          return formatSqlLiteral(paramValues.get(name));
+        });
+      }
     }
     res.json({
       data,
@@ -713,8 +751,8 @@ ORDER BY ${baseTableAlias}.rn`;
   } catch (error) {
     console.error("Error fetching table data:", error);
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     const isTimeout = error.code === "ETIMEOUT" || error.code === "ESOCKET" || error.message?.includes("timeout") || error.message?.includes("ETIMEDOUT") || error.originalError?.code === "ETIMEOUT" || error.originalError?.code === "ESOCKET";
@@ -741,73 +779,68 @@ tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
       return res.status(400).json({ error: "Missing required parameters" });
     }
     const pool = getConnection();
-    if (!pool || !pool.connected) {
+    if (!pool) {
       return res.status(400).json({ error: "Not connected to database" });
     }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const dialect = getDialect();
     const columnsQuery = `
-      SELECT COLUMN_NAME, DATA_TYPE, CHARACTER_MAXIMUM_LENGTH
-      FROM INFORMATION_SCHEMA.COLUMNS
-      WHERE TABLE_SCHEMA = @refSchema
-        AND TABLE_NAME = @refTable
-      ORDER BY ORDINAL_POSITION
+      SELECT column_name, data_type, character_maximum_length
+      FROM information_schema.columns
+      WHERE table_schema = ${dialect.param(1)}
+        AND table_name = ${dialect.param(2)}
+      ORDER BY ordinal_position
     `;
     const columns = await executeQuery(columnsQuery, [
-      { name: "refSchema", value: referencedSchema, type: sql.NVarChar },
-      { name: "refTable", value: referencedTable, type: sql.NVarChar }
+      { name: "refSchema", value: referencedSchema },
+      { name: "refTable", value: referencedTable }
     ]);
-    const referencedColInfo = columns.find(
-      (col) => col.COLUMN_NAME === referencedColumn
-    );
+    const referencedColInfo = columns.find((col) => {
+      const colName = col.column_name || col.COLUMN_NAME;
+      return colName === referencedColumn;
+    });
     if (!referencedColInfo) {
       return res.status(400).json({ error: `Referenced column '${referencedColumn}' not found` });
     }
-    const getSqlType = (dataType) => {
-      const dt = dataType.toLowerCase();
-      if (dt === "int" || dt === "integer") return sql.Int;
-      if (dt === "bigint") return sql.BigInt;
-      if (dt === "smallint") return sql.SmallInt;
-      if (dt === "tinyint") return sql.TinyInt;
-      if (dt === "bit") return sql.Bit;
-      if (dt === "float" || dt === "real" || dt === "double precision") return sql.Float;
-      if (dt === "decimal" || dt === "numeric" || dt === "money" || dt === "smallmoney") return sql.Decimal(18, 0);
-      if (dt === "datetime" || dt === "datetime2" || dt === "smalldatetime") return sql.DateTime;
-      if (dt === "date") return sql.Date;
-      if (dt === "time") return sql.Time;
-      if (dt === "uniqueidentifier") return sql.UniqueIdentifier;
-      return sql.NVarChar;
-    };
-    const referencedColumnType = getSqlType(referencedColInfo.DATA_TYPE);
     const preferredNames = ["name", "title", "description", "code"];
     let displayColumn = null;
     for (const preferredName of preferredNames) {
-      const found = columns.find(
-        (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase()
-      );
+      const found = columns.find((col) => {
+        const colName = col.column_name || col.COLUMN_NAME;
+        return colName.toLowerCase() === preferredName.toLowerCase();
+      });
       if (found) {
-        displayColumn = found.COLUMN_NAME;
+        displayColumn = found.column_name || found.COLUMN_NAME;
         break;
       }
     }
     if (!displayColumn) {
       const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
-      const found = columns.find(
-        (col) => stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
-      );
+      const found = columns.find((col) => {
+        const dataType = col.data_type || col.DATA_TYPE;
+        return stringTypes.some((type) => dataType.toLowerCase().includes(type));
+      });
       if (found) {
-        displayColumn = found.COLUMN_NAME;
+        displayColumn = found.column_name || found.COLUMN_NAME;
       }
     }
-    const placeholders = ids.map((_, i) => `@id${i}`).join(", ");
-    const selectColumns = displayColumn ? `[${referencedColumn}], [${displayColumn}]` : `[${referencedColumn}]`;
+    const quotedRefSchema = dialect.quoteId(referencedSchema);
+    const quotedRefTable = dialect.quoteId(referencedTable);
+    const quotedRefColumn = dialect.quoteId(referencedColumn);
+    const quotedDisplayColumn = displayColumn ? dialect.quoteId(displayColumn) : null;
+    const placeholders = ids.map((_, i) => dialect.param(i + 1)).join(", ");
+    const selectColumns = displayColumn ? `${quotedRefColumn}, ${quotedDisplayColumn}` : quotedRefColumn;
     const dataQuery = `
       SELECT ${selectColumns}
-      FROM [${referencedSchema}].[${referencedTable}]
-      WHERE [${referencedColumn}] IN (${placeholders})
+      FROM ${quotedRefSchema}.${quotedRefTable}
+      WHERE ${quotedRefColumn} IN (${placeholders})
     `;
-    const params = ids.map((id, i) => ({
-      name: `id${i}`,
-      value: id,
-      type: referencedColumnType
+    const params = ids.map((id) => ({
+      name: "id",
+      value: id
     }));
     const result = await executeQuery(dataQuery, params);
     const dataMap = {};
@@ -819,8 +852,8 @@ tableRoutes.post("/:schema/:table/related-data", async (req, res) => {
   } catch (error) {
     console.error("Error fetching related data:", error);
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch related data" });
@@ -832,148 +865,163 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
     const searchQuery = req.query.search;
     const columnsParam = req.query.columns;
     const pool = getConnection();
-    if (!pool || !pool.connected) {
+    if (!pool) {
+      return res.status(400).json({ error: "Not connected to database" });
+    }
+    const isConnected = "connected" in pool ? pool.connected === true : !pool.ended;
+    if (!isConnected) {
       return res.status(400).json({ error: "Not connected to database" });
     }
+    const dialect = getDialect();
     const columnQuery = `
       SELECT 
-        c.COLUMN_NAME,
-        c.DATA_TYPE,
-        fk.REFERENCED_TABLE_SCHEMA as referencedSchema,
-        fk.REFERENCED_TABLE_NAME as referencedTable,
-        fk.REFERENCED_COLUMN_NAME as referencedColumn
-      FROM INFORMATION_SCHEMA.COLUMNS c
+        c.column_name,
+        c.data_type,
+        fk.referenced_table_schema as "referencedSchema",
+        fk.referenced_table_name as "referencedTable",
+        fk.referenced_column_name as "referencedColumn"
+      FROM information_schema.columns c
       LEFT JOIN (
         SELECT 
-          kcu1.TABLE_SCHEMA,
-          kcu1.TABLE_NAME,
-          kcu1.COLUMN_NAME,
-          kcu2.TABLE_SCHEMA as REFERENCED_TABLE_SCHEMA,
-          kcu2.TABLE_NAME as REFERENCED_TABLE_NAME,
-          kcu2.COLUMN_NAME as REFERENCED_COLUMN_NAME
-        FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu1
-          ON rc.CONSTRAINT_CATALOG = kcu1.CONSTRAINT_CATALOG
-          AND rc.CONSTRAINT_SCHEMA = kcu1.CONSTRAINT_SCHEMA
-          AND rc.CONSTRAINT_NAME = kcu1.CONSTRAINT_NAME
-        INNER JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu2
-          ON rc.UNIQUE_CONSTRAINT_CATALOG = kcu2.CONSTRAINT_CATALOG
-          AND rc.UNIQUE_CONSTRAINT_SCHEMA = kcu2.CONSTRAINT_SCHEMA
-          AND rc.UNIQUE_CONSTRAINT_NAME = kcu2.CONSTRAINT_NAME
-          AND kcu1.ORDINAL_POSITION = kcu2.ORDINAL_POSITION
-      ) fk ON c.TABLE_SCHEMA = fk.TABLE_SCHEMA
-        AND c.TABLE_NAME = fk.TABLE_NAME
-        AND c.COLUMN_NAME = fk.COLUMN_NAME
-      WHERE c.TABLE_SCHEMA = @schema AND c.TABLE_NAME = @table AND c.COLUMN_NAME = @column
+          kcu1.table_schema,
+          kcu1.table_name,
+          kcu1.column_name,
+          kcu2.table_schema as referenced_table_schema,
+          kcu2.table_name as referenced_table_name,
+          kcu2.column_name as referenced_column_name
+        FROM information_schema.referential_constraints rc
+        INNER JOIN information_schema.key_column_usage kcu1
+          ON rc.constraint_catalog = kcu1.constraint_catalog
+          AND rc.constraint_schema = kcu1.constraint_schema
+          AND rc.constraint_name = kcu1.constraint_name
+        INNER JOIN information_schema.key_column_usage kcu2
+          ON rc.unique_constraint_catalog = kcu2.constraint_catalog
+          AND rc.unique_constraint_schema = kcu2.constraint_schema
+          AND rc.unique_constraint_name = kcu2.constraint_name
+          AND kcu1.ordinal_position = kcu2.ordinal_position
+      ) fk ON c.table_schema = fk.table_schema
+        AND c.table_name = fk.table_name
+        AND c.column_name = fk.column_name
+      WHERE c.table_schema = ${dialect.param(1)} AND c.table_name = ${dialect.param(2)} AND c.column_name = ${dialect.param(3)}
     `;
     const columnResult = await executeQuery(columnQuery, [
-      { name: "schema", value: schema, type: sql.NVarChar },
-      { name: "table", value: table, type: sql.NVarChar },
-      { name: "column", value: column, type: sql.NVarChar }
+      { name: "schema", value: schema },
+      { name: "table", value: table },
+      { name: "column", value: column }
     ]);
     if (columnResult.length === 0) {
       return res.status(400).json({ error: "Column not found" });
     }
     const columnInfo = columnResult[0];
-    const isForeignKey = !!columnInfo.referencedSchema && !!columnInfo.referencedTable;
+    const isForeignKey = !!(columnInfo.referencedSchema || columnInfo.referenced_schema) && !!(columnInfo.referencedTable || columnInfo.referenced_table);
     let query = "";
     const params = [];
     let displayColumn = null;
     if (isForeignKey) {
-      const refSchema = columnInfo.referencedSchema;
-      const refTable = columnInfo.referencedTable;
-      const refColumn = columnInfo.referencedColumn;
+      const refSchema = columnInfo.referencedSchema || columnInfo.referenced_schema;
+      const refTable = columnInfo.referencedTable || columnInfo.referenced_table;
+      const refColumn = columnInfo.referencedColumn || columnInfo.referenced_column;
+      const quotedRefSchema = dialect.quoteId(refSchema);
+      const quotedRefTable = dialect.quoteId(refTable);
+      const quotedRefColumn = dialect.quoteId(refColumn);
       let columnsToSelect = [];
       if (columnsParam) {
         columnsToSelect = columnsParam.split(",").map((c) => c.trim()).filter((c) => c);
       }
       if (columnsToSelect.length > 0) {
-        const selectCols = columnsToSelect.map((col) => `[${col}]`).join(", ");
-        query = `SELECT DISTINCT ${selectCols} FROM [${refSchema}].[${refTable}]`;
+        const selectCols = columnsToSelect.map((col) => dialect.quoteId(col)).join(", ");
+        query = `SELECT DISTINCT ${selectCols} FROM ${quotedRefSchema}.${quotedRefTable}`;
         if (searchQuery && searchQuery.trim()) {
-          const searchCols = columnsToSelect.map((col) => `[${col}] LIKE @search`).join(" OR ");
-          query += ` WHERE (${searchCols}) AND [${refColumn}] IS NOT NULL`;
-          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+          const searchCols = columnsToSelect.map((col) => `${dialect.quoteId(col)} LIKE ${dialect.param(1)}`).join(" OR ");
+          query += ` WHERE (${searchCols}) AND ${quotedRefColumn} IS NOT NULL`;
+          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
         } else {
-          query += ` WHERE [${refColumn}] IS NOT NULL`;
+          query += ` WHERE ${quotedRefColumn} IS NOT NULL`;
         }
         const orderByCol = columnsToSelect.length > 1 ? columnsToSelect[1] : columnsToSelect[0];
-        query += ` ORDER BY [${orderByCol}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+        query += ` ORDER BY ${dialect.quoteId(orderByCol)} ${dialect.limitOffset(0, 1e3)}`;
       } else {
         const refColumnsQuery = `
-          SELECT COLUMN_NAME, DATA_TYPE
-          FROM INFORMATION_SCHEMA.COLUMNS
-          WHERE TABLE_SCHEMA = @refSchema AND TABLE_NAME = @refTable
-          ORDER BY ORDINAL_POSITION
+          SELECT column_name, data_type
+          FROM information_schema.columns
+          WHERE table_schema = ${dialect.param(1)} AND table_name = ${dialect.param(2)}
+          ORDER BY ordinal_position
         `;
         const refColumns = await executeQuery(refColumnsQuery, [
-          { name: "refSchema", value: refSchema, type: sql.NVarChar },
-          { name: "refTable", value: refTable, type: sql.NVarChar }
+          { name: "refSchema", value: refSchema },
+          { name: "refTable", value: refTable }
         ]);
         const preferredNames = ["name", "title", "description", "code"];
         for (const preferredName of preferredNames) {
-          const found = refColumns.find(
-            (col) => col.COLUMN_NAME.toLowerCase() === preferredName.toLowerCase() && col.COLUMN_NAME.toLowerCase() !== refColumn.toLowerCase()
-          );
+          const found = refColumns.find((col) => {
+            const colName = col.column_name || col.COLUMN_NAME;
+            return colName.toLowerCase() === preferredName.toLowerCase() && colName.toLowerCase() !== refColumn.toLowerCase();
+          });
           if (found) {
-            displayColumn = found.COLUMN_NAME;
+            displayColumn = found.column_name || found.COLUMN_NAME;
             break;
           }
         }
         if (!displayColumn) {
           const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
-          const found = refColumns.find(
-            (col) => col.COLUMN_NAME.toLowerCase() !== refColumn.toLowerCase() && stringTypes.some((type) => col.DATA_TYPE.toLowerCase().includes(type))
-          );
+          const found = refColumns.find((col) => {
+            const colName = col.column_name || col.COLUMN_NAME;
+            const dataType = col.data_type || col.DATA_TYPE;
+            return colName.toLowerCase() !== refColumn.toLowerCase() && stringTypes.some((type) => dataType.toLowerCase().includes(type));
+          });
           if (found) {
-            displayColumn = found.COLUMN_NAME;
+            displayColumn = found.column_name || found.COLUMN_NAME;
           }
         }
-        const selectCols = displayColumn ? `[${refColumn}], [${displayColumn}]` : `[${refColumn}]`;
-        query = `SELECT DISTINCT ${selectCols} FROM [${refSchema}].[${refTable}]`;
+        const quotedDisplayColumn = displayColumn ? dialect.quoteId(displayColumn) : null;
+        const selectCols = displayColumn ? `${quotedRefColumn}, ${quotedDisplayColumn}` : quotedRefColumn;
+        query = `SELECT DISTINCT ${selectCols} FROM ${quotedRefSchema}.${quotedRefTable}`;
         if (searchQuery && searchQuery.trim()) {
           if (displayColumn) {
-            query += ` WHERE [${displayColumn}] LIKE @search OR [${refColumn}] LIKE @search`;
+            query += ` WHERE ${quotedDisplayColumn} LIKE ${dialect.param(1)} OR ${quotedRefColumn} LIKE ${dialect.param(1)}`;
           } else {
-            query += ` WHERE [${refColumn}] LIKE @search`;
+            query += ` WHERE ${quotedRefColumn} LIKE ${dialect.param(1)}`;
           }
-          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
-          query += ` AND [${refColumn}] IS NOT NULL`;
+          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+          query += ` AND ${quotedRefColumn} IS NOT NULL`;
         } else {
-          query += ` WHERE [${refColumn}] IS NOT NULL`;
+          query += ` WHERE ${quotedRefColumn} IS NOT NULL`;
         }
-        query += ` ORDER BY ${displayColumn ? `[${displayColumn}]` : `[${refColumn}]`} OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+        query += ` ORDER BY ${displayColumn ? quotedDisplayColumn : quotedRefColumn} ${dialect.limitOffset(0, 1e3)}`;
       }
     } else {
-      const dataType = columnInfo.DATA_TYPE.toLowerCase();
+      const dataType = (columnInfo.data_type || columnInfo.DATA_TYPE || "").toLowerCase();
+      const quotedSchema = dialect.quoteId(schema);
+      const quotedTable = dialect.quoteId(table);
+      const quotedColumn = dialect.quoteId(column);
       const columnsToSelect = columnsParam ? columnsParam.split(",").map((c) => c.trim()).filter((c) => c) : [];
       if (columnsToSelect.length > 0) {
-        const escapedColumns = columnsToSelect.map((col) => col.replace(/]/g, "]]"));
-        const keyColumn = escapedColumns[0];
-        const orderByColumn = escapedColumns.length > 1 ? escapedColumns[1] : keyColumn;
-        query = `SELECT DISTINCT ${escapedColumns.map((col) => `[${col}]`).join(", ")} FROM [${schema}].[${table}]`;
+        const quotedColumns = columnsToSelect.map((col) => dialect.quoteId(col));
+        const keyColumn = quotedColumns[0];
+        const orderByColumn = quotedColumns.length > 1 ? quotedColumns[1] : quotedColumns[0];
+        query = `SELECT DISTINCT ${quotedColumns.join(", ")} FROM ${quotedSchema}.${quotedTable}`;
         if (searchQuery && searchQuery.trim()) {
-          const searchCols = escapedColumns.map((col) => `TRY_CAST([${col}] AS NVARCHAR(4000)) LIKE @search`).join(" OR ");
-          query += ` WHERE (${searchCols}) AND [${keyColumn}] IS NOT NULL`;
-          params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
+          const searchCols = quotedColumns.map((col) => `${dialect.tryCastToNVarChar(col)} LIKE ${dialect.param(1)}`).join(" OR ");
+          query += ` WHERE (${searchCols}) AND ${keyColumn} IS NOT NULL`;
+          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
         } else {
-          query += ` WHERE [${keyColumn}] IS NOT NULL`;
+          query += ` WHERE ${keyColumn} IS NOT NULL`;
         }
-        query += ` ORDER BY [${orderByColumn}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+        query += ` ORDER BY ${orderByColumn} ${dialect.limitOffset(0, 1e3)}`;
       } else {
-        query = `SELECT DISTINCT [${column}] FROM [${schema}].[${table}]`;
+        query = `SELECT DISTINCT ${quotedColumn} FROM ${quotedSchema}.${quotedTable}`;
         if (searchQuery && searchQuery.trim()) {
           if (["varchar", "nvarchar", "char", "nchar", "text", "ntext"].some((t) => dataType.includes(t))) {
-            query += ` WHERE [${column}] LIKE @search`;
-            params.push({ name: "search", value: `%${searchQuery.trim()}%`, type: sql.NVarChar });
-            query += ` AND [${column}] IS NOT NULL`;
+            query += ` WHERE ${quotedColumn} LIKE ${dialect.param(1)}`;
+            params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+            query += ` AND ${quotedColumn} IS NOT NULL`;
           } else {
-            query += ` WHERE [${column}] IS NOT NULL`;
+            query += ` WHERE ${quotedColumn} IS NOT NULL`;
           }
         } else {
-          query += ` WHERE [${column}] IS NOT NULL`;
+          query += ` WHERE ${quotedColumn} IS NOT NULL`;
         }
-        query += ` ORDER BY [${column}] OFFSET 0 ROWS FETCH NEXT 1000 ROWS ONLY`;
+        query += ` ORDER BY ${quotedColumn} ${dialect.limitOffset(0, 1e3)}`;
       }
     }
     const result = await executeQuery(query, params);
@@ -981,8 +1029,8 @@ tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
   } catch (error) {
     console.error("Error fetching distinct values:", error);
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     res.status(500).json({ error: error.message || "Failed to fetch distinct values" });
@@ -994,24 +1042,33 @@ import { Router as Router3 } from "express";
 var queryRoutes = Router3();
 queryRoutes.post("/", async (req, res) => {
   try {
-    const { query: sqlQuery } = req.body;
+    const { query: sqlQuery, queryId } = req.body;
     if (!sqlQuery || typeof sqlQuery !== "string") {
       return res.status(400).json({ error: "Query is required" });
     }
+    const activeQueryId = queryId || generateQueryId();
     const startTime = Date.now();
-    const { recordsets: resultSets, columnMetadata } = await executeQueryMultiple(sqlQuery);
+    const { recordsets: resultSets, columnMetadata } = await executeQueryMultiple(sqlQuery, void 0, activeQueryId);
     const executionTime = Date.now() - startTime;
     res.json({
       data: resultSets[0] || [],
       resultSets: resultSets.length > 0 ? resultSets : [],
       executionTime,
-      columnMetadata
+      columnMetadata,
       // Include column metadata for empty result sets
+      queryId: activeQueryId
+      // Return queryId so client can track it
     });
   } catch (error) {
+    if (error.cancelled || error.code === "ECANCEL") {
+      return res.status(499).json({
+        error: "Query was cancelled",
+        cancelled: true
+      });
+    }
     const errorMessage = error.message || "";
-    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication")) {
-      const { disconnect: disconnect2 } = await import("./mssql-UZUN227W.js");
+    if (errorMessage.includes("Login failed") || errorMessage.includes("authentication") || errorMessage.includes("password authentication")) {
+      const { disconnect: disconnect2 } = await import("./db-CJPCGHL3.js");
       await disconnect2();
     }
     res.status(500).json({
@@ -1020,6 +1077,24 @@ queryRoutes.post("/", async (req, res) => {
     });
   }
 });
+queryRoutes.post("/cancel", async (req, res) => {
+  try {
+    const { queryId } = req.body;
+    if (!queryId || typeof queryId !== "string") {
+      return res.status(400).json({ error: "Query ID is required" });
+    }
+    const cancelled = cancelQuery(queryId);
+    if (cancelled) {
+      res.json({ success: true, message: "Query cancellation requested" });
+    } else {
+      res.status(404).json({ error: "Query not found or already completed" });
+    }
+  } catch (error) {
+    res.status(500).json({
+      error: error.message || "Failed to cancel query"
+    });
+  }
+});
 
 // src/server/index.ts
 var __filename = fileURLToPath(import.meta.url);