@deepagents/text2sql 7.0.2 → 7.1.1

package/dist/lib/adapters/sqlserver/index.js

@@ -1,5 +1,6 @@
 // packages/text2sql/src/lib/adapters/adapter.ts
 import { format as formatSql } from "sql-formatter";
+import { z } from "zod";
 
 // packages/text2sql/src/lib/agents/exceptions.ts
 var sqlValidationMarker = /* @__PURE__ */ Symbol("SQLValidationError");
@@ -172,6 +173,16 @@ function createGroundingContext(options = {}) {
 }
 
 // packages/text2sql/src/lib/adapters/adapter.ts
+function groundingFor(adapterType, create) {
+  return (adapter) => {
+    if (!(adapter instanceof adapterType)) {
+      throw new Error(
+        `A ${adapterType.name} grounding needs a ${adapterType.name} adapter, not ${adapter.constructor.name}.`
+      );
+    }
+    return create(adapter);
+  };
+}
 var Adapter = class {
   #policyAnalyzer;
   /**
@@ -432,6 +443,40 @@ var Adapter = class {
     }
     return decoded;
   }
+  /**
+   * Run an introspection query and check every row against `row`, the shape
+   * the driver returns for that query. A row of any other shape throws.
+   */
+  async runQuery(sql, row) {
+    const rows = z.array(row).safeParse(await this.queryRows(sql));
+    if (!rows.success) {
+      throw new Error(
+        `${this.constructor.name} introspection query returned rows of an unexpected shape:
+${z.prettifyError(rows.error)}
+SQL: ${sql.trim()}`,
+        { cause: rows.error }
+      );
+    }
+    return rows.data;
+  }
+  /**
+   * The rows in a driver's execute() result: the result itself when it is an
+   * array, otherwise the first array found at one of `paths` (dot-separated,
+   * so `recordsets.0` reads `result.recordsets[0]`).
+   */
+  rowsFrom(result, paths) {
+    if (Array.isArray(result)) return result;
+    for (const path of paths) {
+      const rows = path.split(".").reduce(
+        (value, key) => typeof value === "object" && value !== null ? Reflect.get(value, key) : void 0,
+        result
+      );
+      if (Array.isArray(rows)) return rows;
+    }
+    throw new Error(
+      `${this.constructor.name} execute() must return an array of rows or an object holding one at ${paths.map((path) => `result.${path}`).join(", ")}.`
+    );
+  }
   /**
    * Convert unknown database value to number.
    * Handles number, bigint, and string types.
@@ -992,6 +1037,32 @@ var TableGrounding = class extends AbstractGrounding {
 };
 
 // packages/text2sql/src/lib/adapters/sqlserver/column-stats.sqlserver.grounding.ts
+import { z as z3 } from "zod";
+
+// packages/text2sql/src/lib/adapters/groundings/rows.ts
+import { z as z2 } from "zod";
+var nameRow = z2.object({ name: z2.string() });
+var versionRow = z2.object({ version: z2.string() });
+var databaseRow = z2.object({ db: z2.string() });
+var viewDefinitionRow = z2.object({
+  definition: z2.string().nullable()
+});
+var distinctValueRow = z2.object({ value: z2.unknown() });
+var textValueRow = z2.object({ value: z2.string() });
+var numericValue = z2.union([z2.number(), z2.bigint(), z2.string()]);
+
+// packages/text2sql/src/lib/adapters/sqlserver/column-stats.sqlserver.grounding.ts
+var nDistinctRow = z3.object({
+  schema_name: z3.string().nullable(),
+  table_name: z3.string().nullable(),
+  column_name: z3.string().nullable(),
+  approx_n_distinct: numericValue
+});
+var statsRow = z3.object({
+  min_value: z3.string().nullable(),
+  max_value: z3.string().nullable(),
+  null_fraction: numericValue.nullable()
+});
 var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
   #adapter;
   #nDistinctCache = /* @__PURE__ */ new Map();
@@ -1010,7 +1081,8 @@ var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
       return `OBJECT_ID('[${this.#adapter.escape(schema)}].[${this.#adapter.escape(table2)}]')`;
     });
     try {
-      const rows = await this.#adapter.runQuery(`
+      const rows = await this.#adapter.runQuery(
+        `
         SELECT
           OBJECT_SCHEMA_NAME(s.object_id) AS schema_name,
           OBJECT_NAME(s.object_id) AS table_name,
@@ -1026,8 +1098,12 @@ var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
         WHERE sc.stats_column_id = 1
           AND sp.rows > 0
           AND s.object_id IN (${objectIds.join(", ")})
-      `);
+      `,
+        nDistinctRow
+      );
       for (const row of rows) {
+        const nDistinct = this.#adapter.toNumber(row.approx_n_distinct);
+        if (row.column_name === null || nDistinct === void 0) continue;
         const tableName = ctx.tables.find((t) => {
           const { schema, table: table2 } = this.#adapter.parseTableName(t.name);
           return schema === row.schema_name && table2 === row.table_name;
@@ -1038,7 +1114,7 @@ var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
           map = /* @__PURE__ */ new Map();
           this.#nDistinctCache.set(tableName, map);
         }
-        map.set(row.column_name, row.approx_n_distinct);
+        map.set(row.column_name, nDistinct);
       }
     } catch {
     }
@@ -1061,7 +1137,7 @@ var SqlServerColumnStatsGrounding = class extends ColumnStatsGrounding {
         AVG(CASE WHEN ${columnIdentifier} IS NULL THEN 1.0 ELSE 0.0 END) AS null_fraction
       FROM ${tableIdentifier}
     `;
-    const rows = await this.#adapter.runQuery(sql);
+    const rows = await this.#adapter.runQuery(sql, statsRow);
     if (!rows.length) {
       if (cachedNDistinct != null) {
         return { nDistinct: cachedNDistinct };
@@ -1128,22 +1204,36 @@ var SqlServerColumnValuesGrounding = class extends ColumnValuesGrounding {
       FROM ${tableIdentifier}
       WHERE ${columnIdentifier} IS NOT NULL
     `;
-    const rows = await this.#adapter.runQuery(sql);
+    const rows = await this.#adapter.runQuery(sql, textValueRow);
     if (!rows.length || rows.length > this.lowCardinalityLimit) {
       return void 0;
     }
-    const values = [];
-    for (const row of rows) {
-      if (row.value == null) {
-        return void 0;
-      }
-      values.push(row.value);
-    }
-    return values.length ? values : void 0;
+    return rows.map((row) => row.value);
   }
 };
 
 // packages/text2sql/src/lib/adapters/sqlserver/constraint.sqlserver.grounding.ts
+import { z as z4 } from "zod";
+var keyColumnRow = z4.object({
+  constraint_name: z4.string(),
+  column_name: z4.string()
+});
+var foreignKeyRow = z4.object({
+  constraint_name: z4.string(),
+  column_name: z4.string(),
+  ref_schema: z4.string(),
+  ref_table: z4.string(),
+  ref_column: z4.string()
+});
+var checkConstraintRow = z4.object({
+  constraint_name: z4.string(),
+  definition: z4.string().nullable()
+});
+var columnDefaultRow = z4.object({
+  column_name: z4.string(),
+  default_definition: z4.string().nullable(),
+  is_nullable: z4.boolean()
+});
 var SqlServerConstraintGrounding = class extends ConstraintGrounding {
   #adapter;
   constructor(adapter, config = {}) {
@@ -1153,7 +1243,8 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
   async getConstraints(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
     const constraints2 = [];
-    const pkRows = await this.#adapter.runQuery(`
+    const pkRows = await this.#adapter.runQuery(
+      `
       SELECT
         kc.name AS constraint_name,
         COL_NAME(ic.object_id, ic.column_id) AS column_name
@@ -1165,7 +1256,9 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         AND t.name = '${this.#adapter.escapeString(table2)}'
         AND kc.type = 'PK'
       ORDER BY ic.key_ordinal
-    `);
+    `,
+      keyColumnRow
+    );
     if (pkRows.length > 0) {
       constraints2.push({
         name: pkRows[0].constraint_name,
@@ -1173,7 +1266,8 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         columns: pkRows.map((r) => r.column_name)
       });
     }
-    const fkRows = await this.#adapter.runQuery(`
+    const fkRows = await this.#adapter.runQuery(
+      `
       SELECT
         fk.name AS constraint_name,
         COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS column_name,
@@ -1189,7 +1283,9 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
       WHERE s.name = '${this.#adapter.escapeString(schema)}'
         AND t.name = '${this.#adapter.escapeString(table2)}'
       ORDER BY fk.name, fkc.constraint_column_id
-    `);
+    `,
+      foreignKeyRow
+    );
     const fkMap = /* @__PURE__ */ new Map();
     for (const row of fkRows) {
       const existing = fkMap.get(row.constraint_name);
@@ -1214,7 +1310,8 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         referencedColumns: data.refColumns
       });
     }
-    const checkRows = await this.#adapter.runQuery(`
+    const checkRows = await this.#adapter.runQuery(
+      `
       SELECT
         cc.name AS constraint_name,
         cc.definition
@@ -1223,7 +1320,9 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
       JOIN sys.schemas s ON t.schema_id = s.schema_id
       WHERE s.name = '${this.#adapter.escapeString(schema)}'
         AND t.name = '${this.#adapter.escapeString(table2)}'
-    `);
+    `,
+      checkConstraintRow
+    );
     for (const row of checkRows) {
       constraints2.push({
         name: row.constraint_name,
@@ -1231,7 +1330,8 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         definition: row.definition?.replace(/^\(/, "").replace(/\)$/, "")
       });
     }
-    const uniqueRows = await this.#adapter.runQuery(`
+    const uniqueRows = await this.#adapter.runQuery(
+      `
       SELECT
         i.name AS constraint_name,
         COL_NAME(ic.object_id, ic.column_id) AS column_name
@@ -1243,7 +1343,9 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         AND t.name = '${this.#adapter.escapeString(table2)}'
         AND i.is_unique_constraint = 1
       ORDER BY i.name, ic.key_ordinal
-    `);
+    `,
+      keyColumnRow
+    );
     const uniqueMap = /* @__PURE__ */ new Map();
     for (const row of uniqueRows) {
       const existing = uniqueMap.get(row.constraint_name);
@@ -1260,7 +1362,8 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
         columns
       });
     }
-    const columnRows = await this.#adapter.runQuery(`
+    const columnRows = await this.#adapter.runQuery(
+      `
       SELECT
         c.name AS column_name,
         dc.definition AS default_definition,
@@ -1271,11 +1374,13 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
       LEFT JOIN sys.default_constraints dc ON c.default_object_id = dc.object_id
       WHERE s.name = '${this.#adapter.escapeString(schema)}'
         AND t.name = '${this.#adapter.escapeString(table2)}'
-    `);
+    `,
+      columnDefaultRow
+    );
     const pkConstraint = constraints2.find((c) => c.type === "PRIMARY_KEY");
     const pkColumns = new Set(pkConstraint?.columns ?? []);
     for (const col of columnRows) {
-      if (col.is_nullable === 0 && !pkColumns.has(col.column_name)) {
+      if (!col.is_nullable && !pkColumns.has(col.column_name)) {
         constraints2.push({
           name: `${table2}_${col.column_name}_notnull`,
           type: "NOT_NULL",
@@ -1296,17 +1401,24 @@ var SqlServerConstraintGrounding = class extends ConstraintGrounding {
 };
 
 // packages/text2sql/src/lib/adapters/sqlserver/indexes.sqlserver.grounding.ts
+import { z as z5 } from "zod";
+var indexRow = z5.object({
+  index_name: z5.string(),
+  column_name: z5.string(),
+  is_unique: z5.boolean(),
+  index_type: z5.string(),
+  key_ordinal: z5.number()
+});
 var SqlServerIndexesGrounding = class extends IndexesGrounding {
   #adapter;
-  #schemas;
   constructor(adapter, config = {}) {
     super(config);
     this.#adapter = adapter;
-    this.#schemas = config.schemas;
   }
   async getIndexes(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
-    const rows = await this.#adapter.runQuery(`
+    const rows = await this.#adapter.runQuery(
+      `
       SELECT
         i.name AS index_name,
         COL_NAME(ic.object_id, ic.column_id) AS column_name,
@@ -1326,7 +1438,9 @@ var SqlServerIndexesGrounding = class extends IndexesGrounding {
         AND i.name IS NOT NULL
         AND ic.is_included_column = 0
       ORDER BY i.name, ic.key_ordinal
-    `);
+    `,
+      indexRow
+    );
     return this.#groupIndexes(rows);
   }
   #groupIndexes(rows) {
@@ -1358,10 +1472,8 @@ var SqlServerInfoGrounding = class extends InfoGrounding {
   }
   async collectInfo() {
     const [versionRows, dbRows] = await Promise.all([
-      this.#adapter.runQuery(
-        "SELECT @@VERSION AS version"
-      ),
-      this.#adapter.runQuery("SELECT DB_NAME() AS db")
+      this.#adapter.runQuery("SELECT @@VERSION AS version", versionRow),
+      this.#adapter.runQuery("SELECT DB_NAME() AS db", databaseRow)
     ]);
     return {
       dialect: "sqlserver",
@@ -1376,6 +1488,8 @@ var SqlServerInfoGrounding = class extends InfoGrounding {
 };
 
 // packages/text2sql/src/lib/adapters/sqlserver/row-count.sqlserver.grounding.ts
+import { z as z6 } from "zod";
+var countRow = z6.object({ count: numericValue });
 var SqlServerRowCountGrounding = class extends RowCountGrounding {
   #adapter;
   constructor(adapter, config = {}) {
@@ -1386,7 +1500,8 @@ var SqlServerRowCountGrounding = class extends RowCountGrounding {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
     const tableIdentifier = `[${this.#adapter.escape(schema)}].[${this.#adapter.escape(table2)}]`;
     const rows = await this.#adapter.runQuery(
-      `SELECT COUNT(*) as count FROM ${tableIdentifier}`
+      `SELECT COUNT(*) as count FROM ${tableIdentifier}`,
+      countRow
     );
     return this.#adapter.toNumber(rows[0]?.count);
   }
@@ -1760,9 +1875,6 @@ var SQL_SERVER_ERROR_MAP = {
     hint: "The query violates a constraint. Re-check join logic and filtering."
   }
 };
-var LOW_CARDINALITY_LIMIT = 20;
-var noopProgress2 = () => {
-};
 function getErrorCode(error) {
   if (typeof error === "object" && error !== null && "number" in error && typeof error.number === "number") {
     return String(error.number);
@@ -1823,9 +1935,6 @@ var SqlServer = class extends Adapter {
       return JSON.stringify(formatSqlServerError(sql, error));
     }
   }
-  async runQuery(sql) {
-    return this.#runIntrospectionQuery(sql);
-  }
   quoteIdentifier(name) {
     return `[${name.replace(/]/g, "]]")}]`;
   }
@@ -1838,435 +1947,75 @@ var SqlServer = class extends Adapter {
     const columnList = columns?.length ? columns.map((c) => this.quoteIdentifier(c)).join(", ") : "*";
     return `SELECT TOP ${limit} ${columnList} FROM ${tableIdentifier}`;
   }
-  async #loadTables() {
-    const rows = await this.#runIntrospectionQuery(`
-      SELECT
-        c.TABLE_SCHEMA AS table_schema,
-        c.TABLE_NAME AS table_name,
-        c.COLUMN_NAME AS column_name,
-        c.DATA_TYPE AS data_type
-      FROM INFORMATION_SCHEMA.COLUMNS AS c
-      JOIN INFORMATION_SCHEMA.TABLES AS t
-        ON c.TABLE_SCHEMA = t.TABLE_SCHEMA
-        AND c.TABLE_NAME = t.TABLE_NAME
-      WHERE t.TABLE_TYPE = 'BASE TABLE'
-        ${this.#buildSchemaFilter("c.TABLE_SCHEMA")}
-      ORDER BY c.TABLE_SCHEMA, c.TABLE_NAME, c.ORDINAL_POSITION
-    `);
-    const tables2 = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      if (!row.table_name) {
-        continue;
-      }
-      const schema = row.table_schema ?? "dbo";
-      const tableName = row.table_name;
-      const qualifiedName = `${schema}.${tableName}`;
-      const table2 = tables2.get(qualifiedName) ?? {
-        name: qualifiedName,
-        schema,
-        rawName: tableName,
-        columns: []
-      };
-      table2.columns.push({
-        name: row.column_name ?? "unknown",
-        type: row.data_type ?? "unknown"
-      });
-      tables2.set(qualifiedName, table2);
-    }
-    return Array.from(tables2.values());
-  }
-  async #loadRelationships(filterTableNames) {
-    const tableFilter = this.#buildTableNamesFilter(filterTableNames);
-    const rows = await this.#runIntrospectionQuery(`
-      SELECT
-        fk.CONSTRAINT_NAME AS constraint_name,
-        fk.TABLE_SCHEMA AS table_schema,
-        fk.TABLE_NAME AS table_name,
-        fk.COLUMN_NAME AS column_name,
-        pk.TABLE_SCHEMA AS referenced_table_schema,
-        pk.TABLE_NAME AS referenced_table_name,
-        pk.COLUMN_NAME AS referenced_column_name
-      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
-        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
-        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
-        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
-      WHERE 1 = 1
-        ${this.#buildSchemaFilter("fk.TABLE_SCHEMA")}
-        ${tableFilter}
-      ORDER BY fk.TABLE_SCHEMA, fk.TABLE_NAME, fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
-    `);
-    const relationships = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      if (!row.constraint_name || !row.table_name || !row.referenced_table_name) {
-        continue;
-      }
-      const schema = row.table_schema ?? "dbo";
-      const referencedSchema = row.referenced_table_schema ?? "dbo";
-      const key = `${schema}.${row.table_name}:${row.constraint_name}`;
-      const relationship2 = relationships.get(key) ?? {
-        table: `${schema}.${row.table_name}`,
-        from: [],
-        referenced_table: `${referencedSchema}.${row.referenced_table_name}`,
-        to: []
-      };
-      relationship2.from.push(row.column_name ?? "unknown");
-      relationship2.to.push(row.referenced_column_name ?? "unknown");
-      relationships.set(key, relationship2);
-    }
-    return Array.from(relationships.values());
-  }
-  async #annotateRowCounts(tables2, onProgress = noopProgress2) {
-    const total = tables2.length;
-    for (let i = 0; i < tables2.length; i++) {
-      const table2 = tables2[i];
-      const tableIdentifier = this.#formatQualifiedTableName(table2);
-      onProgress({
-        type: "phase:progress",
-        phase: "row_counts",
-        table: table2.name,
-        message: `Counting rows in ${table2.name}...`,
-        current: i + 1,
-        total
-      });
-      try {
-        const rows = await this.#runIntrospectionQuery(`SELECT COUNT(*) as count FROM ${tableIdentifier}`);
-        const rowCount2 = this.#toNumber(rows[0]?.count);
-        if (rowCount2 != null) {
-          table2.rowCount = rowCount2;
-          table2.sizeHint = this.#classifyRowCount(rowCount2);
-        }
-      } catch {
-        continue;
-      }
-    }
-  }
-  async #annotateIndexes(tables2) {
-    if (!tables2.length) {
-      return;
-    }
-    const tableMap = new Map(tables2.map((table2) => [table2.name, table2]));
-    const rows = await this.#runIntrospectionQuery(`
-      SELECT
-        sch.name AS schema_name,
-        t.name AS table_name,
-        ind.name AS index_name,
-        col.name AS column_name,
-        ind.is_unique,
-        ind.is_primary_key,
-        ind.type_desc,
-        ic.is_included_column
-      FROM sys.indexes AS ind
-      JOIN sys.tables AS t ON ind.object_id = t.object_id
-      JOIN sys.schemas AS sch ON t.schema_id = sch.schema_id
-      JOIN sys.index_columns AS ic
-        ON ind.object_id = ic.object_id
-        AND ind.index_id = ic.index_id
-      JOIN sys.columns AS col
-        ON ic.object_id = col.object_id
-        AND ic.column_id = col.column_id
-      WHERE ind.is_hypothetical = 0
-        AND ind.name IS NOT NULL
-        ${this.#buildSchemaFilter("sch.name")}
-      ORDER BY sch.name, t.name, ind.name, ic.key_ordinal
-    `);
-    const indexMap = /* @__PURE__ */ new Map();
-    for (const row of rows) {
-      if (!row.table_name || !row.index_name) {
-        continue;
-      }
-      const schema = row.schema_name ?? "dbo";
-      const tableKey = `${schema}.${row.table_name}`;
-      const table2 = tableMap.get(tableKey);
-      if (!table2) {
-        continue;
-      }
-      const indexKey = `${tableKey}:${row.index_name}`;
-      let index2 = indexMap.get(indexKey);
-      if (!index2) {
-        index2 = {
-          name: row.index_name,
-          columns: [],
-          unique: Boolean(row.is_unique),
-          type: row.type_desc ?? void 0
-        };
-        indexMap.set(indexKey, index2);
-        if (!table2.indexes) {
-          table2.indexes = [];
-        }
-        table2.indexes.push(index2);
-      }
-      if (row.is_included_column) {
-        continue;
-      }
-      if (row.column_name) {
-        index2.columns.push(row.column_name);
-        const column2 = table2.columns.find(
-          (col) => col.name === row.column_name
-        );
-        if (column2) {
-          column2.isIndexed = true;
-        }
-      }
-    }
-  }
-  async #annotateColumnStats(tables2, onProgress = noopProgress2) {
-    if (!tables2.length) {
-      return;
-    }
-    const total = tables2.length;
-    for (let i = 0; i < tables2.length; i++) {
-      const table2 = tables2[i];
-      const tableIdentifier = this.#formatQualifiedTableName(table2);
-      onProgress({
-        type: "phase:progress",
-        phase: "column_stats",
-        table: table2.name,
-        message: `Collecting stats for ${table2.name}...`,
-        current: i + 1,
-        total
-      });
-      for (const column2 of table2.columns) {
-        if (!this.#shouldCollectStats(column2.type)) {
-          continue;
-        }
-        const columnIdentifier = this.#quoteIdentifier(column2.name);
-        const sql = `
-          SELECT
-            CONVERT(NVARCHAR(4000), MIN(${columnIdentifier})) AS min_value,
-            CONVERT(NVARCHAR(4000), MAX(${columnIdentifier})) AS max_value,
-            AVG(CASE WHEN ${columnIdentifier} IS NULL THEN 1.0 ELSE 0.0 END) AS null_fraction
-          FROM ${tableIdentifier}
-        `;
-        try {
-          const rows = await this.#runIntrospectionQuery(sql);
-          if (!rows.length) {
-            continue;
-          }
-          const nullFraction = this.#toNumber(rows[0]?.null_fraction);
-          if (rows[0]?.min_value != null || rows[0]?.max_value != null || nullFraction != null) {
-            column2.stats = {
-              min: rows[0]?.min_value ?? void 0,
-              max: rows[0]?.max_value ?? void 0,
-              nullFraction: nullFraction != null && Number.isFinite(nullFraction) ? Math.max(0, Math.min(1, nullFraction)) : void 0
-            };
-          }
-        } catch {
-          continue;
-        }
-      }
-    }
-  }
-  async #annotateLowCardinalityColumns(tables2, onProgress = noopProgress2) {
-    const total = tables2.length;
-    for (let i = 0; i < tables2.length; i++) {
-      const table2 = tables2[i];
-      const tableIdentifier = this.#formatQualifiedTableName(table2);
-      onProgress({
-        type: "phase:progress",
-        phase: "low_cardinality",
-        table: table2.name,
-        message: `Analyzing cardinality in ${table2.name}...`,
-        current: i + 1,
-        total
-      });
-      for (const column2 of table2.columns) {
-        const columnIdentifier = this.#quoteIdentifier(column2.name);
-        const limit = LOW_CARDINALITY_LIMIT + 1;
-        const sql = `
-          SELECT DISTINCT TOP (${limit}) ${columnIdentifier} AS value
-          FROM ${tableIdentifier}
-          WHERE ${columnIdentifier} IS NOT NULL
-        `;
-        let rows = [];
-        try {
-          rows = await this.#runIntrospectionQuery(sql);
-        } catch {
-          continue;
-        }
-        if (!rows.length || rows.length > LOW_CARDINALITY_LIMIT) {
-          continue;
-        }
-        const values = [];
-        let shouldSkip = false;
-        for (const row of rows) {
-          const formatted = this.#normalizeValue(row.value);
-          if (formatted == null) {
-            shouldSkip = true;
-            break;
-          }
-          values.push(formatted);
-        }
-        if (shouldSkip || !values.length) {
-          continue;
-        }
-        column2.kind = "LowCardinality";
-        column2.values = values;
-      }
-    }
-  }
-  #buildSchemaFilter(columnName) {
-    if (this.#options.schemas && this.#options.schemas.length > 0) {
-      const values = this.#options.schemas.map((schema) => `'${schema.replace(/'/g, "''")}'`).join(", ");
-      return `AND ${columnName} IN (${values})`;
-    }
-    return `AND ${columnName} NOT IN ('INFORMATION_SCHEMA', 'sys')`;
-  }
   /**
-   * Build a filter for table names (qualified as schema.table).
-   * Matches if either the source table or referenced table is in the list.
+   * The schemas introspection is limited to; table and view discovery use
+   * them unless a grounding lists its own.
    */
-  #buildTableNamesFilter(tableNames) {
-    if (!tableNames || tableNames.length === 0) {
-      return "";
-    }
-    const conditions = [];
-    for (const name of tableNames) {
-      const escaped = name.replace(/'/g, "''");
-      if (name.includes(".")) {
-        const [schema, ...rest] = name.split(".");
-        const tableName = rest.join(".");
-        const escapedSchema = schema.replace(/'/g, "''");
-        const escapedTable = tableName.replace(/'/g, "''");
-        conditions.push(
-          `(fk.TABLE_SCHEMA = '${escapedSchema}' AND fk.TABLE_NAME = '${escapedTable}')`
-        );
-        conditions.push(
-          `(pk.TABLE_SCHEMA = '${escapedSchema}' AND pk.TABLE_NAME = '${escapedTable}')`
-        );
-      } else {
-        conditions.push(`fk.TABLE_NAME = '${escaped}'`);
-        conditions.push(`pk.TABLE_NAME = '${escaped}'`);
-      }
-    }
-    return `AND (${conditions.join(" OR ")})`;
-  }
-  async #runIntrospectionQuery(sql) {
-    const result = await this.#options.execute(sql);
-    if (Array.isArray(result)) {
-      return result;
-    }
-    if (result && typeof result === "object") {
-      if ("rows" in result && Array.isArray(result.rows)) {
-        return result.rows;
-      }
-      if ("recordset" in result && Array.isArray(result.recordset)) {
-        return result.recordset;
-      }
-      if ("recordsets" in result && Array.isArray(result.recordsets) && Array.isArray(result.recordsets[0])) {
-        return result.recordsets[0];
-      }
-    }
-    throw new Error(
-      "SqlServer adapter execute() must return an array of rows or an object with rows/recordset properties when introspecting."
-    );
-  }
-  #quoteIdentifier(name) {
-    return `[${name.replace(/]/g, "]]")}]`;
-  }
-  #formatQualifiedTableName(table2) {
-    if (table2.schema && table2.rawName) {
-      return `${this.#quoteIdentifier(table2.schema)}.${this.#quoteIdentifier(table2.rawName)}`;
-    }
-    if (table2.name.includes(".")) {
-      const [schemaPart, ...rest] = table2.name.split(".");
-      const tablePart = rest.join(".") || schemaPart;
-      if (rest.length === 0) {
-        return this.#quoteIdentifier(schemaPart);
-      }
-      return `${this.#quoteIdentifier(schemaPart)}.${this.#quoteIdentifier(tablePart)}`;
-    }
-    return this.#quoteIdentifier(table2.name);
-  }
-  #toNumber(value) {
-    if (typeof value === "number" && Number.isFinite(value)) {
-      return value;
-    }
-    if (typeof value === "bigint") {
-      return Number(value);
-    }
-    if (typeof value === "string" && value.trim() !== "") {
-      const parsed = Number(value);
-      return Number.isFinite(parsed) ? parsed : null;
-    }
-    return null;
-  }
-  #classifyRowCount(count) {
-    if (count < 100) {
-      return "tiny";
-    }
-    if (count < 1e3) {
-      return "small";
-    }
-    if (count < 1e4) {
-      return "medium";
-    }
-    if (count < 1e5) {
-      return "large";
-    }
-    return "huge";
-  }
-  #shouldCollectStats(type) {
-    if (!type) {
-      return false;
-    }
-    const normalized = type.toLowerCase();
-    return /int|numeric|decimal|float|real|money|date|time|timestamp|bool/.test(
-      normalized
-    );
-  }
-  #normalizeValue(value) {
-    if (value === null || value === void 0) {
-      return null;
-    }
-    if (typeof value === "string") {
-      return value;
-    }
-    if (typeof value === "number" || typeof value === "bigint") {
-      return String(value);
-    }
-    if (typeof value === "boolean") {
-      return value ? "true" : "false";
-    }
-    if (value instanceof Date) {
-      return value.toISOString();
-    }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
-      return value.toString("utf-8");
-    }
-    return null;
+  get schemas() {
+    return this.#options.schemas;
+  }
+  async queryRows(sql) {
+    return this.rowsFrom(await this.#options.execute(sql), [
+      "rows",
+      "recordset",
+      "recordsets.0"
+    ]);
   }
 };
 
 // packages/text2sql/src/lib/adapters/sqlserver/table.sqlserver.grounding.ts
+import { z as z8 } from "zod";
+
+// packages/text2sql/src/lib/adapters/sqlserver/sqlserver-rows.ts
+import { z as z7 } from "zod";
+var columnRow = z7.object({
+  column_name: z7.string().nullable(),
+  data_type: z7.string().nullable()
+});
+
+// packages/text2sql/src/lib/adapters/sqlserver/table.sqlserver.grounding.ts
+var relationshipRow = z8.object({
+  constraint_name: z8.string(),
+  table_schema: z8.string(),
+  table_name: z8.string(),
+  column_name: z8.string(),
+  referenced_table_schema: z8.string(),
+  referenced_table_name: z8.string(),
+  referenced_column_name: z8.string()
+});
 var SqlServerTableGrounding = class extends TableGrounding {
   #adapter;
   #schemas;
   constructor(adapter, config = {}) {
     super(config);
     this.#adapter = adapter;
-    this.#schemas = config.schemas;
+    this.#schemas = config.schemas ?? adapter.schemas;
   }
   async getAllTableNames() {
-    const rows = await this.#adapter.runQuery(`
+    const rows = await this.#adapter.runQuery(
+      `
       SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS name
       FROM INFORMATION_SCHEMA.TABLES
       WHERE TABLE_TYPE = 'BASE TABLE'
         ${this.#adapter.buildSchemaFilter("TABLE_SCHEMA", this.#schemas)}
       ORDER BY name
-    `);
+    `,
+      nameRow
+    );
     return rows.map((r) => r.name);
   }
   async getTable(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
-    const columns = await this.#adapter.runQuery(`
+    const columns = await this.#adapter.runQuery(
+      `
       SELECT COLUMN_NAME AS column_name, DATA_TYPE AS data_type
       FROM INFORMATION_SCHEMA.COLUMNS
       WHERE TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
         AND TABLE_NAME = '${this.#adapter.escapeString(table2)}'
       ORDER BY ORDINAL_POSITION
-    `);
+    `,
+      columnRow
+    );
     return {
       name: tableName,
       schema,
@@ -2279,68 +2028,58 @@ var SqlServerTableGrounding = class extends TableGrounding {
   }
   async findOutgoingRelations(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
-    const rows = await this.#adapter.runQuery(`
-      SELECT
-        fk.CONSTRAINT_NAME AS constraint_name,
-        fk.TABLE_SCHEMA AS table_schema,
-        fk.TABLE_NAME AS table_name,
-        fk.COLUMN_NAME AS column_name,
-        pk.TABLE_SCHEMA AS referenced_table_schema,
-        pk.TABLE_NAME AS referenced_table_name,
-        pk.COLUMN_NAME AS referenced_column_name
-      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
-        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
-        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
-        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
-      WHERE fk.TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
-        AND fk.TABLE_NAME = '${this.#adapter.escapeString(table2)}'
-      ORDER BY fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
-    `);
-    return this.#groupRelationships(rows);
+    return this.#foreignKeys(
+      `s.name = '${this.#adapter.escapeString(schema)}'
+        AND t.name = '${this.#adapter.escapeString(table2)}'`
+    );
   }
   async findIncomingRelations(tableName) {
     const { schema, table: table2 } = this.#adapter.parseTableName(tableName);
-    const rows = await this.#adapter.runQuery(`
+    return this.#foreignKeys(
+      `ref_s.name = '${this.#adapter.escapeString(schema)}'
+        AND ref_t.name = '${this.#adapter.escapeString(table2)}'`
+    );
+  }
+  /**
+   * The foreign keys matching `where`. sys.foreign_key_columns holds one row
+   * per column pair in the key's own order, and every join goes by object id,
+   * so a key comes back whole even when it references a unique index or
+   * another schema repeats its constraint names.
+   */
+  async #foreignKeys(where) {
+    const rows = await this.#adapter.runQuery(
+      `
       SELECT
-        fk.CONSTRAINT_NAME AS constraint_name,
-        fk.TABLE_SCHEMA AS table_schema,
-        fk.TABLE_NAME AS table_name,
-        fk.COLUMN_NAME AS column_name,
-        pk.TABLE_SCHEMA AS referenced_table_schema,
-        pk.TABLE_NAME AS referenced_table_name,
-        pk.COLUMN_NAME AS referenced_column_name
-      FROM INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS AS rc
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS fk
-        ON fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-      JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE AS pk
-        ON pk.CONSTRAINT_NAME = rc.UNIQUE_CONSTRAINT_NAME
-        AND pk.ORDINAL_POSITION = fk.ORDINAL_POSITION
-      WHERE pk.TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
-        AND pk.TABLE_NAME = '${this.#adapter.escapeString(table2)}'
-      ORDER BY fk.CONSTRAINT_NAME, fk.ORDINAL_POSITION
-    `);
-    return this.#groupRelationships(rows);
-  }
-  #groupRelationships(rows) {
+        fk.name AS constraint_name,
+        s.name AS table_schema,
+        t.name AS table_name,
+        COL_NAME(fkc.parent_object_id, fkc.parent_column_id) AS column_name,
+        ref_s.name AS referenced_table_schema,
+        ref_t.name AS referenced_table_name,
+        COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) AS referenced_column_name
+      FROM sys.foreign_keys AS fk
+      JOIN sys.foreign_key_columns AS fkc ON fkc.constraint_object_id = fk.object_id
+      JOIN sys.tables AS t ON t.object_id = fk.parent_object_id
+      JOIN sys.schemas AS s ON s.schema_id = t.schema_id
+      JOIN sys.tables AS ref_t ON ref_t.object_id = fk.referenced_object_id
+      JOIN sys.schemas AS ref_s ON ref_s.schema_id = ref_t.schema_id
+      WHERE ${where}
+      ORDER BY s.name, t.name, fk.name, fkc.constraint_column_id
+    `,
+      relationshipRow
+    );
     const relationships = /* @__PURE__ */ new Map();
-    const defaultSchema = this.#adapter.defaultSchema ?? "dbo";
     for (const row of rows) {
-      if (!row.constraint_name || !row.table_name || !row.referenced_table_name) {
-        continue;
-      }
-      const schema = row.table_schema ?? defaultSchema;
-      const referencedSchema = row.referenced_table_schema ?? defaultSchema;
-      const key = `${schema}.${row.table_name}:${row.constraint_name}`;
+      const table2 = `${row.table_schema}.${row.table_name}`;
+      const key = `${table2}:${row.constraint_name}`;
       const relationship2 = relationships.get(key) ?? {
-        table: `${schema}.${row.table_name}`,
+        table: table2,
         from: [],
-        referenced_table: `${referencedSchema}.${row.referenced_table_name}`,
+        referenced_table: `${row.referenced_table_schema}.${row.referenced_table_name}`,
         to: []
       };
-      relationship2.from.push(row.column_name ?? "unknown");
-      relationship2.to.push(row.referenced_column_name ?? "unknown");
+      relationship2.from.push(row.column_name);
+      relationship2.to.push(row.referenced_column_name);
       relationships.set(key, relationship2);
     }
     return Array.from(relationships.values());
@@ -2409,39 +2148,48 @@ var SqlServerViewGrounding = class extends ViewGrounding {
   constructor(adapter, config = {}) {
     super(config);
     this.#adapter = adapter;
-    this.#schemas = config.schemas;
+    this.#schemas = config.schemas ?? adapter.schemas;
   }
   async getAllViewNames() {
-    const rows = await this.#adapter.runQuery(`
+    const rows = await this.#adapter.runQuery(
+      `
       SELECT TABLE_SCHEMA + '.' + TABLE_NAME AS name
       FROM INFORMATION_SCHEMA.VIEWS
       WHERE 1=1
         ${this.#adapter.buildSchemaFilter("TABLE_SCHEMA", this.#schemas)}
       ORDER BY name
-    `);
+    `,
+      nameRow
+    );
     return rows.map((r) => r.name);
   }
   async getView(viewName) {
     const { schema, table: view2 } = this.#adapter.parseTableName(viewName);
     let definition;
     if (this.includeDefinition) {
-      const defRows = await this.#adapter.runQuery(`
+      const defRows = await this.#adapter.runQuery(
+        `
         SELECT m.definition
         FROM sys.views v
         JOIN sys.schemas s ON v.schema_id = s.schema_id
         JOIN sys.sql_modules m ON v.object_id = m.object_id
         WHERE s.name = '${this.#adapter.escapeString(schema)}'
           AND v.name = '${this.#adapter.escapeString(view2)}'
-      `);
+      `,
+        viewDefinitionRow
+      );
       definition = defRows[0]?.definition ?? void 0;
     }
-    const columns = await this.#adapter.runQuery(`
+    const columns = await this.#adapter.runQuery(
+      `
       SELECT COLUMN_NAME AS column_name, DATA_TYPE AS data_type
       FROM INFORMATION_SCHEMA.COLUMNS
       WHERE TABLE_SCHEMA = '${this.#adapter.escapeString(schema)}'
         AND TABLE_NAME = '${this.#adapter.escapeString(view2)}'
       ORDER BY ORDINAL_POSITION
-    `);
+    `,
+      columnRow
+    );
     return {
       name: viewName,
       schema,
@@ -2457,15 +2205,19 @@ var SqlServerViewGrounding = class extends ViewGrounding {
 
 // packages/text2sql/src/lib/adapters/sqlserver/index.ts
 function tables(config = {}) {
-  return (adapter) => new SqlServerTableGrounding(adapter, config);
+  return groundingFor(
+    SqlServer,
+    (adapter) => new SqlServerTableGrounding(adapter, config)
+  );
 }
 function info(config = {}) {
   return (adapter) => new SqlServerInfoGrounding(adapter, config);
 }
 function views(config = {}) {
-  return (adapter) => {
-    return new SqlServerViewGrounding(adapter, config);
-  };
+  return groundingFor(
+    SqlServer,
+    (adapter) => new SqlServerViewGrounding(adapter, config)
+  );
 }
 function columnStats(config = {}) {
   return (adapter) => {