datapeek 0.1.10 → 0.1.12

package/dist/server/index.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" });
@@ -214,62 +247,230 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const sortDirection = req.query.sortDirection || "asc";
     const fkDisplayMode = req.query.fkDisplayMode || "key-only";
     const offset = (page - 1) * pageSize;
-    const filters = {};
+    const parsedFilters = [];
+    const seenFilterColumns = /* @__PURE__ */ new Set();
+    const parseFilterEntry = (columnName, rawValue) => {
+      if (!columnName || rawValue === null || rawValue === void 0 || seenFilterColumns.has(columnName)) {
+        return;
+      }
+      const filterValue = String(rawValue).trim();
+      if (!filterValue) return;
+      try {
+        const parsed = JSON.parse(filterValue);
+        if (parsed && typeof parsed === "object" && parsed.operator) {
+          parsedFilters.push({
+            column: columnName,
+            operator: parsed.operator,
+            value: parsed.value,
+            dataType: parsed.dataType
+          });
+        } else {
+          parsedFilters.push({
+            column: columnName,
+            operator: "contains",
+            value: filterValue
+          });
+        }
+      } catch {
+        parsedFilters.push({
+          column: columnName,
+          operator: "contains",
+          value: filterValue
+        });
+      }
+      seenFilterColumns.add(columnName);
+    };
     Object.keys(req.query).forEach((key) => {
       const match = key.match(/^filter\[(.+)\]$/);
-      if (match && req.query[key] && String(req.query[key]).trim()) {
-        filters[match[1]] = String(req.query[key]).trim();
+      if (match) {
+        const columnName = match[1];
+        parseFilterEntry(columnName, req.query[key]);
       }
     });
-    console.log("Received filters from query:", filters);
-    console.log("All query params:", req.query);
+    const nestedFilters = req.query.filter;
+    if (nestedFilters && typeof nestedFilters === "object" && !Array.isArray(nestedFilters)) {
+      Object.entries(nestedFilters).forEach(([columnName, rawValue]) => {
+        parseFilterEntry(columnName, rawValue);
+      });
+    }
+    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 filterColumns = [];
-    if (Object.keys(filters).length > 0) {
+    const dialect = getDialect();
+    const columnMetadata = {};
+    if (parsedFilters.length > 0) {
       try {
-        const columnNames = Object.keys(filters);
-        const placeholders = columnNames.map((_, i) => `@col${i}`).join(", ");
+        const columnNames = [...new Set(parsedFilters.map((f) => f.column))];
+        const placeholders = columnNames.map((_, i) => dialect.param(i + 3)).join(", ");
         const validateQuery = `
-          SELECT COLUMN_NAME 
-          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);
-        filterColumns.push(...validateResult.map((r) => r.COLUMN_NAME));
-        console.log("Validated filter columns:", filterColumns, "from filters:", filters);
+        validateResult.forEach((r) => {
+          const colName = r.column_name || r.COLUMN_NAME;
+          const dataType = r.data_type || r.DATA_TYPE;
+          columnMetadata[colName] = {
+            dataType,
+            exists: true
+          };
+        });
+        console.log("Column metadata:", columnMetadata);
       } catch (e) {
         console.error("Error validating filter columns:", e);
-        console.error("Filters that failed validation:", filters);
       }
     }
     let whereClause = "";
     const filterParams = [];
-    if (filterColumns.length > 0) {
-      const validFilters = filterColumns.filter((col) => {
-        const filterValue = filters[col];
-        return filterValue && filterValue.trim() !== "";
+    let paramIndex = 1;
+    if (parsedFilters.length > 0) {
+      const whereConditions = [];
+      parsedFilters.forEach((filter) => {
+        const columnName = filter.column;
+        const metadata = columnMetadata[columnName];
+        if (!metadata || !metadata.exists) {
+          console.warn(`Filter column ${columnName} not found, skipping`);
+          return;
+        }
+        const dataType = filter.dataType || metadata.dataType;
+        const operator = filter.operator;
+        const value = filter.value;
+        if (value === null || value === void 0 || value === "") {
+          return;
+        }
+        const quotedColumn = dialect.quoteId(columnName);
+        try {
+          let condition = "";
+          switch (operator) {
+            // Text operators
+            case "contains":
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
+              break;
+            case "equals":
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
+              break;
+            case "startsWith":
+              filterParams.push({ name: `filter${paramIndex}`, value: `${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
+              break;
+            case "endsWith":
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
+              break;
+            case "notContains":
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} NOT LIKE ${dialect.param(paramIndex)}`;
+              break;
+            // Number operators
+            case "eq":
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} = ${dialect.param(paramIndex)}`;
+              break;
+            case "gt":
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} > ${dialect.param(paramIndex)}`;
+              break;
+            case "gte":
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} >= ${dialect.param(paramIndex)}`;
+              break;
+            case "lt":
+              filterParams.push({ name: `filter${paramIndex}`, value: Number(value) });
+              condition = `${quotedColumn} < ${dialect.param(paramIndex)}`;
+              break;
+            case "lte":
+              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 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: `filter${paramIndex}`, value: String(value) });
+              condition = `${dialect.castToDate(quotedColumn)} = ${dialect.castToDate(dialect.param(paramIndex))}`;
+              break;
+            case "dateAfter":
+              filterParams.push({ name: `filter${paramIndex}`, value: String(value) });
+              condition = `${dialect.castToDate(quotedColumn)} > ${dialect.castToDate(dialect.param(paramIndex))}`;
+              break;
+            case "dateBefore":
+              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 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;
+            // Multiple select operators
+            case "in":
+            case "notIn":
+              if (Array.isArray(value) && value.length > 0) {
+                const placeholders = [];
+                value.forEach((val, i) => {
+                  const currentIndex = paramIndex + i;
+                  filterParams.push({ name: `filter${currentIndex}`, value: val });
+                  placeholders.push(dialect.param(currentIndex));
+                });
+                const inOperator = operator === "in" ? "IN" : "NOT IN";
+                condition = `${quotedColumn} ${inOperator} (${placeholders.join(", ")})`;
+                paramIndex += value.length - 1;
+              }
+              break;
+            default:
+              console.warn(`Unknown filter operator: ${operator}, falling back to contains`);
+              filterParams.push({ name: `filter${paramIndex}`, value: `%${String(value)}%` });
+              condition = `${quotedColumn} LIKE ${dialect.param(paramIndex)}`;
+          }
+          if (condition) {
+            whereConditions.push(condition);
+            paramIndex++;
+          }
+        } catch (error) {
+          console.error(`Error building filter condition for ${columnName}:`, error);
+        }
       });
-      if (validFilters.length > 0) {
-        const whereConditions = validFilters.map((col, index) => {
-          const filterValue = filters[col];
-          filterParams.push({ name: `filter${index}`, value: `%${filterValue.trim()}%`, type: sql.NVarChar });
-          return `[${col}] LIKE @filter${index}`;
-        });
+      if (whereConditions.length > 0) {
         whereClause = `WHERE ${whereConditions.join(" AND ")}`;
         console.log("Applying WHERE clause:", whereClause);
-        console.log("Filter params:", filterParams);
-        console.log("Valid filters:", validFilters);
+        console.log("Filter params:", filterParams.map((p) => ({ name: p.name, value: p.value })));
       }
     }
-    const countQuery = `SELECT COUNT(*) as total FROM [${schema}].[${table}]${whereClause ? " " + whereClause : ""}`;
+    const qualifiedDataWhereClause = parsedFilters.reduce((clause, filter) => {
+      const quotedColumn = dialect.quoteId(filter.column);
+      const quotedTableColumn = `${dialect.quoteId("t")}.${quotedColumn}`;
+      return clause.replace(new RegExp(quotedColumn.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), quotedTableColumn);
+    }, 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 || "";
@@ -277,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 = "";
@@ -295,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) {
       }
@@ -314,93 +519,97 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
     const fkJoins = [];
     const fkSelects = [];
     const fkDisplayColumns = {};
-    if (fkDisplayMode === "key-display" || fkDisplayMode === "display-only") {
-      const fkQuery = `
+    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 }
-      ]);
-      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}`))
-        );
-        const tableConditions = uniqueRefTables.map((tableRef, idx) => {
-          const [refSchema, refTable] = tableRef.split(".");
-          return `(TABLE_SCHEMA = @refSchema${idx} AND TABLE_NAME = @refTable${idx})`;
-        }).join(" OR ");
-        const batchColumnsQuery = `
-        SELECT TABLE_SCHEMA, TABLE_NAME, COLUMN_NAME, DATA_TYPE, ORDINAL_POSITION
-        FROM INFORMATION_SCHEMA.COLUMNS
+    console.log("Fetching foreign keys with query:", fkQuery);
+    const foreignKeys = await executeQuery(fkQuery, [
+      { 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.referenced_schema}.${fk.referencedTable || fk.referenced_table}`))
+      );
+      const tableConditions = uniqueRefTables.map((tableRef, idx) => {
+        const [refSchema, refTable] = tableRef.split(".");
+        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
         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 [refSchema, refTable] = tableRef.split(".");
-          return [
-            { name: `refSchema${idx}`, value: refSchema, type: sql.NVarChar },
-            { name: `refTable${idx}`, value: refTable, type: sql.NVarChar }
-          ];
-        });
-        console.log("Fetching referenced table columns with query:", batchColumnsQuery);
-        console.log("Batch parameters:", batchParams.map((p) => ({ name: p.name, value: p.value })));
-        const allRefColumns = await executeQuery(batchColumnsQuery, batchParams);
-        console.log(`Found columns for ${uniqueRefTables.length} referenced table(s)`);
-        const columnsByTable = {};
-        allRefColumns.forEach((col) => {
-          const key = `${col.TABLE_SCHEMA}.${col.TABLE_NAME}`;
-          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 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()
-            );
-            if (found) {
-              displayColumn = found.COLUMN_NAME;
-              break;
-            }
+      const batchParams = uniqueRefTables.flatMap((tableRef) => {
+        const [refSchema, refTable] = tableRef.split(".");
+        return [
+          { name: "refSchema", value: refSchema },
+          { name: "refTable", value: refTable }
+        ];
+      });
+      console.log("Fetching referenced table columns with query:", batchColumnsQuery);
+      console.log("Batch parameters:", batchParams.map((p) => ({ name: p.name, value: p.value })));
+      const allRefColumns = await executeQuery(batchColumnsQuery, batchParams);
+      console.log(`Found columns for ${uniqueRefTables.length} referenced table(s)`);
+      const columnsByTable = {};
+      allRefColumns.forEach((col) => {
+        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 || 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) => {
+            const colName = col.column_name || col.COLUMN_NAME;
+            return colName.toLowerCase() === preferredName.toLowerCase();
+          });
+          if (found) {
+            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))
-            );
-            if (found) {
-              displayColumn = found.COLUMN_NAME;
-            }
+        }
+        if (!displayColumn) {
+          const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
+          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 || found.COLUMN_NAME;
           }
-          if (displayColumn) {
+        }
+        if (displayColumn) {
+          if (fkDisplayMode === "key-display" || fkDisplayMode === "display-only") {
             const alias = `fk_${fkColumn}`;
             fkJoins.push({
               alias,
@@ -410,89 +619,79 @@ tableRoutes.get("/:schema/:table/data", async (req, res) => {
               refColumn,
               displayColumn
             });
-            fkSelects.push(`${alias}.[${displayColumn}] as [${fkColumn}_display]`);
-            fkDisplayColumns[fkColumn] = displayColumn;
+            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)}
-        ${whereClause}
-        ORDER BY ${baseTableAlias}.[${orderByColumn}] ${orderByDirection}
-        OFFSET @offset ROWS
-        FETCH NEXT @pageSize ROWS ONLY
+        ${qualifiedDataWhereClause}
+        ORDER BY ${quotedTableAlias}.${quotedOrderByColumn} ${orderByDirection}
+        ${limitOffsetClause}
       `;
       generatedQuery = `SELECT ${allSelects}
-FROM [${schema}].[${table}] ${baseTableAlias}${fkJoins.length > 0 ? "\n" + buildJoinClauses(baseTableAlias) : ""}${whereClause ? "\n" + whereClause : ""}
-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);
@@ -509,6 +708,34 @@ ORDER BY ${baseTableAlias}.rn`;
         return filteredRow;
       });
     }
+    if (generatedQuery && filterParams.length > 0) {
+      const formatSqlLiteral = (value) => {
+        if (value === null || value === void 0) return "NULL";
+        if (typeof value === "number") return Number.isFinite(value) ? String(value) : "NULL";
+        if (typeof value === "boolean") return value ? "1" : "0";
+        if (value instanceof Date) return `'${value.toISOString().replace("T", " ").slice(0, 19)}'`;
+        return `'${String(value).replace(/'/g, "''")}'`;
+      };
+      const paramValues = new Map(
+        filterParams.map((p) => [p.name, p.value])
+      );
+      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,
       query: generatedQuery,
@@ -524,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";
@@ -552,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 = {};
@@ -630,37 +852,223 @@ 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" });
   }
 });
+tableRoutes.get("/:schema/:table/distinct-values/:column", async (req, res) => {
+  try {
+    const { schema, table, column } = req.params;
+    const searchQuery = req.query.search;
+    const columnsParam = req.query.columns;
+    const pool = getConnection();
+    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
+      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 = ${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 },
+      { 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.referenced_schema) && !!(columnInfo.referencedTable || columnInfo.referenced_table);
+    let query = "";
+    const params = [];
+    let displayColumn = null;
+    if (isForeignKey) {
+      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) => dialect.quoteId(col)).join(", ");
+        query = `SELECT DISTINCT ${selectCols} FROM ${quotedRefSchema}.${quotedRefTable}`;
+        if (searchQuery && searchQuery.trim()) {
+          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 ${quotedRefColumn} IS NOT NULL`;
+        }
+        const orderByCol = columnsToSelect.length > 1 ? columnsToSelect[1] : columnsToSelect[0];
+        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 = ${dialect.param(1)} AND table_name = ${dialect.param(2)}
+          ORDER BY ordinal_position
+        `;
+        const refColumns = await executeQuery(refColumnsQuery, [
+          { name: "refSchema", value: refSchema },
+          { name: "refTable", value: refTable }
+        ]);
+        const preferredNames = ["name", "title", "description", "code"];
+        for (const preferredName of preferredNames) {
+          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 || found.COLUMN_NAME;
+            break;
+          }
+        }
+        if (!displayColumn) {
+          const stringTypes = ["varchar", "nvarchar", "char", "nchar", "text", "ntext"];
+          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 || found.COLUMN_NAME;
+          }
+        }
+        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 ${quotedDisplayColumn} LIKE ${dialect.param(1)} OR ${quotedRefColumn} LIKE ${dialect.param(1)}`;
+          } else {
+            query += ` WHERE ${quotedRefColumn} LIKE ${dialect.param(1)}`;
+          }
+          params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+          query += ` AND ${quotedRefColumn} IS NOT NULL`;
+        } else {
+          query += ` WHERE ${quotedRefColumn} IS NOT NULL`;
+        }
+        query += ` ORDER BY ${displayColumn ? quotedDisplayColumn : quotedRefColumn} ${dialect.limitOffset(0, 1e3)}`;
+      }
+    } else {
+      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 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 = 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 += ` ORDER BY ${orderByColumn} ${dialect.limitOffset(0, 1e3)}`;
+      } else {
+        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 ${quotedColumn} LIKE ${dialect.param(1)}`;
+            params.push({ name: "search", value: `%${searchQuery.trim()}%` });
+            query += ` AND ${quotedColumn} IS NOT NULL`;
+          } else {
+            query += ` WHERE ${quotedColumn} IS NOT NULL`;
+          }
+        } else {
+          query += ` WHERE ${quotedColumn} IS NOT NULL`;
+        }
+        query += ` ORDER BY ${quotedColumn} ${dialect.limitOffset(0, 1e3)}`;
+      }
+    }
+    const result = await executeQuery(query, params);
+    res.json(result);
+  } catch (error) {
+    console.error("Error fetching distinct values:", error);
+    const errorMessage = error.message || "";
+    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" });
+  }
+});
 
 // src/server/routes/query.ts
 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({
@@ -669,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);