@connorbritain/mssql-mcp-server 0.1.0

package/dist/tools/InsertDataTool.js

@@ -0,0 +1,144 @@
+import sql from "mssql";
+export class InsertDataTool {
+    constructor() {
+        this.name = "insert_data";
+        this.description = `Inserts data into an MSSQL Database table. Supports both single record insertion and multiple record insertion using standard SQL INSERT with VALUES clause.
+FORMAT EXAMPLES:
+Single Record Insert:
+{
+  "tableName": "Users",
+  "data": {
+    "name": "John Doe",
+    "email": "john@example.com",
+    "age": 30,
+    "isActive": true,
+    "createdDate": "2023-01-15"
+  }
+}
+Multiple Records Insert:
+{
+  "tableName": "Users", 
+  "data": [
+    {
+      "name": "John Doe",
+      "email": "john@example.com", 
+      "age": 30,
+      "isActive": true,
+      "createdDate": "2023-01-15"
+    },
+    {
+      "name": "Jane Smith",
+      "email": "jane@example.com",
+      "age": 25, 
+      "isActive": false,
+      "createdDate": "2023-01-16"
+    }
+  ]
+}
+GENERATED SQL FORMAT:
+- Single: INSERT INTO table (col1, col2) VALUES (@param1, @param2)
+- Multiple: INSERT INTO table (col1, col2) VALUES (@param1, @param2), (@param3, @param4), ...
+IMPORTANT RULES:
+- For single record: Use a single object for the 'data' field
+- For multiple records: Use an array of objects for the 'data' field
+- All objects in array must have identical column names
+- Column names must match the actual database table columns exactly
+- Values should match the expected data types (string, number, boolean, date)
+- Use proper date format for date columns (YYYY-MM-DD or ISO format)`;
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                tableName: {
+                    type: "string",
+                    description: "Name of the table to insert data into"
+                },
+                data: {
+                    oneOf: [
+                        {
+                            type: "object",
+                            description: "Single record data object with column names as keys and values as the data to insert. Example: {\"name\": \"John\", \"age\": 30}"
+                        },
+                        {
+                            type: "array",
+                            items: { type: "object" },
+                            description: "Array of data objects for multiple record insertion. Each object must have identical column structure. Example: [{\"name\": \"John\", \"age\": 30}, {\"name\": \"Jane\", \"age\": 25}]"
+                        }
+                    ]
+                },
+            },
+            required: ["tableName", "data"],
+        };
+    }
+    async run(params) {
+        try {
+            const { tableName, data } = params;
+            // Check if data is an array (multiple records) or single object
+            const isMultipleRecords = Array.isArray(data);
+            const records = isMultipleRecords ? data : [data];
+            if (records.length === 0) {
+                return {
+                    success: false,
+                    message: "No data provided for insertion",
+                };
+            }
+            // Validate that all records have the same columns
+            const firstRecordColumns = Object.keys(records[0]).sort();
+            for (let i = 1; i < records.length; i++) {
+                const currentColumns = Object.keys(records[i]).sort();
+                if (JSON.stringify(firstRecordColumns) !== JSON.stringify(currentColumns)) {
+                    return {
+                        success: false,
+                        message: `Column mismatch: Record ${i + 1} has different columns than the first record. Expected columns: [${firstRecordColumns.join(', ')}], but got: [${currentColumns.join(', ')}]`,
+                    };
+                }
+            }
+            const columns = firstRecordColumns.join(", ");
+            const request = new sql.Request();
+            if (isMultipleRecords) {
+                // Multiple records insert using VALUES clause - works for 1 or more records
+                const valueClauses = [];
+                records.forEach((record, recordIndex) => {
+                    const valueParams = firstRecordColumns
+                        .map((column, columnIndex) => `@value${recordIndex}_${columnIndex}`)
+                        .join(", ");
+                    valueClauses.push(`(${valueParams})`);
+                    // Add parameters for this record
+                    firstRecordColumns.forEach((column, columnIndex) => {
+                        request.input(`value${recordIndex}_${columnIndex}`, record[column]);
+                    });
+                });
+                const query = `INSERT INTO ${tableName} (${columns}) VALUES ${valueClauses.join(", ")}`;
+                await request.query(query);
+                return {
+                    success: true,
+                    message: `Successfully inserted ${records.length} record${records.length > 1 ? 's' : ''} into ${tableName}`,
+                    recordsInserted: records.length,
+                };
+            }
+            else {
+                // Single record insert (when data is passed as single object)
+                const values = firstRecordColumns
+                    .map((column, index) => `@value${index}`)
+                    .join(", ");
+                firstRecordColumns.forEach((column, index) => {
+                    request.input(`value${index}`, records[0][column]);
+                });
+                const query = `INSERT INTO ${tableName} (${columns}) VALUES (${values})`;
+                await request.query(query);
+                return {
+                    success: true,
+                    message: `Successfully inserted 1 record into ${tableName}`,
+                    recordsInserted: 1,
+                };
+            }
+        }
+        catch (error) {
+            console.error("Error inserting data:", error);
+            return {
+                success: false,
+                message: `Failed to insert data: ${error}`,
+            };
+        }
+    }
+}
+//# sourceMappingURL=InsertDataTool.js.map

package/dist/tools/InsertDataTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"InsertDataTool.js","sourceRoot":"","sources":["../../src/tools/InsertDataTool.ts"],"names":[],"mappings":"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"}

package/dist/tools/ListTableTool.d.ts

@@ -0,0 +1,18 @@
+import sql from "mssql";
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+export declare class ListTableTool implements Tool {
+    [key: string]: any;
+    name: string;
+    description: string;
+    inputSchema: any;
+    run(params: any): Promise<{
+        success: boolean;
+        message: string;
+        items: sql.IRecordSet<any>;
+    } | {
+        success: boolean;
+        message: string;
+        items?: undefined;
+    }>;
+}
+//# sourceMappingURL=ListTableTool.d.ts.map

package/dist/tools/ListTableTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListTableTool.d.ts","sourceRoot":"","sources":["../../src/tools/ListTableTool.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,OAAO,CAAC;AACxB,OAAO,EAAE,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAE1D,qBAAa,aAAc,YAAW,IAAI;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;IACnB,IAAI,SAAgB;IACpB,WAAW,SAA2E;IACtF,WAAW,EAaN,GAAG,CAAC;IAEH,GAAG,CAAC,MAAM,EAAE,GAAG;;;;;;;;;CAoBtB"}

package/dist/tools/ListTableTool.js

@@ -0,0 +1,43 @@
+import sql from "mssql";
+export class ListTableTool {
+    constructor() {
+        this.name = "list_table";
+        this.description = "Lists tables in an MSSQL Database, or list tables in specific schemas";
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                parameters: {
+                    type: "array",
+                    description: "Schemas to filter by (optional)",
+                    items: {
+                        type: "string"
+                    },
+                    minItems: 0
+                },
+            },
+            required: [],
+        };
+    }
+    async run(params) {
+        try {
+            const { parameters } = params;
+            const request = new sql.Request();
+            const schemaFilter = parameters && parameters.length > 0 ? `AND TABLE_SCHEMA IN (${parameters.map((p) => `'${p}'`).join(", ")})` : "";
+            const query = `SELECT TABLE_SCHEMA + '.' + TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE' ${schemaFilter} ORDER BY TABLE_SCHEMA, TABLE_NAME`;
+            const result = await request.query(query);
+            return {
+                success: true,
+                message: `List tables executed successfully`,
+                items: result.recordset,
+            };
+        }
+        catch (error) {
+            console.error("Error listing tables:", error);
+            return {
+                success: false,
+                message: `Failed to list tables: ${error}`,
+            };
+        }
+    }
+}
+//# sourceMappingURL=ListTableTool.js.map

package/dist/tools/ListTableTool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ListTableTool.js","sourceRoot":"","sources":["../../src/tools/ListTableTool.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,OAAO,CAAC;AAGxB,MAAM,OAAO,aAAa;IAA1B;QAEE,SAAI,GAAG,YAAY,CAAC;QACpB,gBAAW,GAAG,uEAAuE,CAAC;QACtF,gBAAW,GAAG;YACZ,IAAI,EAAE,QAAQ;YACd,UAAU,EAAE;gBACV,UAAU,EAAE;oBACV,IAAI,EAAE,OAAO;oBACb,WAAW,EAAE,iCAAiC;oBAC9C,KAAK,EAAE;wBACL,IAAI,EAAE,QAAQ;qBACf;oBACD,QAAQ,EAAE,CAAC;iBACZ;aACF;YACD,QAAQ,EAAE,EAAE;SACN,CAAC;IAsBX,CAAC;IApBC,KAAK,CAAC,GAAG,CAAC,MAAW;QACnB,IAAI,CAAC;YACH,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,CAAC;YAC9B,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,OAAO,EAAE,CAAC;YAClC,MAAM,YAAY,GAAG,UAAU,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,wBAAwB,UAAU,CAAC,GAAG,CAAC,CAAC,CAAS,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC;YAC9I,MAAM,KAAK,GAAG,yGAAyG,YAAY,oCAAoC,CAAC;YACxK,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;YAC1C,OAAO;gBACL,OAAO,EAAE,IAAI;gBACb,OAAO,EAAE,mCAAmC;gBAC5C,KAAK,EAAE,MAAM,CAAC,SAAS;aACxB,CAAC;QACJ,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;YAC9C,OAAO;gBACL,OAAO,EAAE,KAAK;gBACd,OAAO,EAAE,0BAA0B,KAAK,EAAE;aAC3C,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}

package/dist/tools/ProfileTableTool.d.ts

@@ -0,0 +1,78 @@
+import { Tool } from "@modelcontextprotocol/sdk/types.js";
+type ProfileParams = {
+    tableName: string;
+    schemaName?: string;
+    sampleSize?: number;
+    includeDistributions?: boolean;
+    topValuesLimit?: number;
+    columnsToProfile?: string[];
+    includeSamples?: boolean;
+};
+type NumericStats = {
+    min: number;
+    max: number;
+    avg: number;
+    median?: number;
+    p90?: number;
+};
+type StringStats = {
+    minLength: number;
+    maxLength: number;
+    avgLength: number;
+    emptyCount: number;
+};
+type DateStats = {
+    earliest: string;
+    latest: string;
+    range: string;
+};
+type TopValue = {
+    value: any;
+    count: number;
+    percentage: number;
+};
+type ColumnProfile = {
+    columnName: string;
+    dataType: string;
+    isNullable: boolean;
+    nullCount: number;
+    nullPercentage: number;
+    distinctCount: number;
+    cardinality: "unique" | "high" | "medium" | "low";
+    numericStats?: NumericStats;
+    stringStats?: StringStats;
+    dateStats?: DateStats;
+    topValues?: TopValue[];
+};
+type ProfileResult = {
+    success: boolean;
+    message?: string;
+    tableName?: string;
+    schemaName?: string;
+    rowCount?: number;
+    columnCount?: number;
+    sampleSize?: number;
+    columns?: ColumnProfile[];
+    samples?: Record<string, unknown>[];
+};
+export declare class ProfileTableTool implements Tool {
+    [key: string]: any;
+    name: string;
+    description: string;
+    inputSchema: any;
+    private static readonly SKIP_TYPES;
+    private static readonly NUMERIC_TYPES;
+    private static readonly STRING_TYPES;
+    private static readonly DATE_TYPES;
+    private normalizeLimit;
+    private classifyCardinality;
+    private formatDateRange;
+    private escapeIdentifier;
+    private isNumericType;
+    private isStringType;
+    private isDateType;
+    private shouldSkipType;
+    run(params: ProfileParams): Promise<ProfileResult>;
+}
+export {};
+//# sourceMappingURL=ProfileTableTool.d.ts.map

package/dist/tools/ProfileTableTool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProfileTableTool.d.ts","sourceRoot":"","sources":["../../src/tools/ProfileTableTool.ts"],"names":[],"mappings":"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"}

package/dist/tools/ProfileTableTool.js

@@ -0,0 +1,372 @@
+import sql from "mssql";
+const clampEnvInt = (value, fallback, min, max) => {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        return fallback;
+    }
+    return Math.min(Math.max(parsed, min), max);
+};
+const DEFAULT_SAMPLE_SIZE = clampEnvInt(process.env.PROFILE_SAMPLE_SIZE_DEFAULT, 50, 1, 1000);
+const SAMPLE_RETURN_LIMIT = clampEnvInt(process.env.PROFILE_SAMPLE_RETURN_LIMIT, 10, 1, 100);
+export class ProfileTableTool {
+    constructor() {
+        this.name = "profile_table";
+        this.description = "Profiles a table by analyzing column statistics, data distributions, and sample records. Returns metadata, cardinality info, null counts, and representative samples for each column.";
+        this.inputSchema = {
+            type: "object",
+            properties: {
+                tableName: {
+                    type: "string",
+                    description: "Name of table to profile (schema.table or table)",
+                },
+                schemaName: {
+                    type: "string",
+                    description: "Explicit schema (defaults to 'dbo')",
+                },
+                sampleSize: {
+                    type: "number",
+                    description: "Number of sample rows (default 100, max 1000)",
+                },
+                includeSamples: {
+                    type: "boolean",
+                    description: "Return sampled rows used for profiling (default false)",
+                },
+                includeDistributions: {
+                    type: "boolean",
+                    description: "Include top value frequencies (default true)",
+                },
+                topValuesLimit: {
+                    type: "number",
+                    description: "Max distinct values per column (default 10, max 50)",
+                },
+                columnsToProfile: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Specific columns to profile (default: all)",
+                },
+            },
+            required: ["tableName"],
+        };
+    }
+    normalizeLimit(value, defaultVal, max) {
+        if (typeof value !== "number" || Number.isNaN(value) || value <= 0) {
+            return defaultVal;
+        }
+        return Math.min(Math.floor(value), max);
+    }
+    classifyCardinality(distinctCount, rowCount) {
+        if (rowCount === 0)
+            return "low";
+        const ratio = distinctCount / rowCount;
+        if (ratio > 0.95)
+            return "unique";
+        if (ratio > 0.5)
+            return "high";
+        if (ratio > 0.1)
+            return "medium";
+        return "low";
+    }
+    formatDateRange(earliest, latest) {
+        const diffMs = latest.getTime() - earliest.getTime();
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffDays < 1)
+            return "less than 1 day";
+        if (diffDays < 30)
+            return `${diffDays} day${diffDays > 1 ? "s" : ""}`;
+        const diffMonths = Math.floor(diffDays / 30);
+        if (diffMonths < 12)
+            return `${diffMonths} month${diffMonths > 1 ? "s" : ""}`;
+        const years = Math.floor(diffMonths / 12);
+        const remainingMonths = diffMonths % 12;
+        if (remainingMonths === 0)
+            return `${years} year${years > 1 ? "s" : ""}`;
+        return `${years} year${years > 1 ? "s" : ""}, ${remainingMonths} month${remainingMonths > 1 ? "s" : ""}`;
+    }
+    escapeIdentifier(name) {
+        return `[${name.replace(/\]/g, "]]")}]`;
+    }
+    isNumericType(dataType) {
+        return ProfileTableTool.NUMERIC_TYPES.includes(dataType.toLowerCase());
+    }
+    isStringType(dataType) {
+        return ProfileTableTool.STRING_TYPES.includes(dataType.toLowerCase());
+    }
+    isDateType(dataType) {
+        return ProfileTableTool.DATE_TYPES.includes(dataType.toLowerCase());
+    }
+    shouldSkipType(dataType) {
+        return ProfileTableTool.SKIP_TYPES.includes(dataType.toLowerCase());
+    }
+    async run(params) {
+        try {
+            const tableName = params.tableName?.trim();
+            if (!tableName) {
+                return { success: false, message: "tableName is required." };
+            }
+            const schemaName = params.schemaName?.trim() || "dbo";
+            const sampleSize = this.normalizeLimit(params.sampleSize, DEFAULT_SAMPLE_SIZE, 1000);
+            const includeDistributions = params.includeDistributions !== false;
+            const includeSamples = params.includeSamples === true;
+            const topValuesLimit = this.normalizeLimit(params.topValuesLimit, 10, 50);
+            const columnsToProfile = params.columnsToProfile?.map((c) => c.trim()).filter(Boolean);
+            // 1. Validate table exists and get columns
+            const metaRequest = new sql.Request();
+            metaRequest.input("schemaName", sql.NVarChar, schemaName);
+            metaRequest.input("tableName", sql.NVarChar, tableName);
+            const metaResult = await metaRequest.query(`
+        SELECT 
+          c.COLUMN_NAME AS columnName,
+          c.DATA_TYPE AS dataType,
+          CASE WHEN c.IS_NULLABLE = 'YES' THEN 1 ELSE 0 END AS isNullable
+        FROM INFORMATION_SCHEMA.COLUMNS c
+        INNER JOIN INFORMATION_SCHEMA.TABLES t
+          ON c.TABLE_SCHEMA = t.TABLE_SCHEMA AND c.TABLE_NAME = t.TABLE_NAME
+        WHERE c.TABLE_SCHEMA = @schemaName AND c.TABLE_NAME = @tableName
+        ORDER BY c.ORDINAL_POSITION
+      `);
+            if (!metaResult.recordset.length) {
+                return {
+                    success: false,
+                    message: `Table [${schemaName}].[${tableName}] not found or has no columns.`,
+                };
+            }
+            // Filter columns if requested
+            let columns = [...metaResult.recordset];
+            if (columnsToProfile && columnsToProfile.length) {
+                const requested = new Set(columnsToProfile.map((c) => c.toLowerCase()));
+                columns = columns.filter((c) => requested.has(c.columnName.toLowerCase()));
+                if (!columns.length) {
+                    return {
+                        success: false,
+                        message: `None of the requested columns exist in [${schemaName}].[${tableName}].`,
+                    };
+                }
+            }
+            // Filter out binary/blob types
+            columns = columns.filter((c) => !this.shouldSkipType(c.dataType));
+            // 2. Get total row count
+            const countRequest = new sql.Request();
+            const fqTable = `${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}`;
+            const countResult = await countRequest.query(`SELECT COUNT(*) AS cnt FROM ${fqTable}`);
+            const rowCount = countResult.recordset[0]?.cnt ?? 0;
+            let sampleRows;
+            if (rowCount === 0) {
+                return {
+                    success: true,
+                    tableName,
+                    schemaName,
+                    rowCount: 0,
+                    columnCount: columns.length,
+                    sampleSize: 0,
+                    columns: columns.map((c) => ({
+                        columnName: c.columnName,
+                        dataType: c.dataType,
+                        isNullable: Boolean(c.isNullable),
+                        nullCount: 0,
+                        nullPercentage: 0,
+                        distinctCount: 0,
+                        cardinality: "low",
+                    })),
+                };
+            }
+            if (includeSamples) {
+                const sampleRequest = new sql.Request();
+                const sampleQuery = `
+          SELECT TOP (${sampleSize}) *
+          FROM ${fqTable}
+          ORDER BY NEWID()
+        `;
+                const sampleResult = await sampleRequest.query(sampleQuery);
+                sampleRows = (sampleResult.recordset ?? []).slice(0, SAMPLE_RETURN_LIMIT);
+            }
+            // 3. Profile each column
+            const columnProfiles = [];
+            for (const col of columns) {
+                const colName = this.escapeIdentifier(col.columnName);
+                const profile = {
+                    columnName: col.columnName,
+                    dataType: col.dataType,
+                    isNullable: Boolean(col.isNullable),
+                    nullCount: 0,
+                    nullPercentage: 0,
+                    distinctCount: 0,
+                    cardinality: "low",
+                };
+                // Base stats: null count and distinct count
+                const baseRequest = new sql.Request();
+                const baseResult = await baseRequest.query(`
+          SELECT 
+            SUM(CASE WHEN ${colName} IS NULL THEN 1 ELSE 0 END) AS nullCount,
+            COUNT(DISTINCT ${colName}) AS distinctCount
+          FROM ${fqTable}
+        `);
+                const baseRow = baseResult.recordset[0];
+                profile.nullCount = baseRow?.nullCount ?? 0;
+                profile.nullPercentage = rowCount > 0 ? Number(((profile.nullCount / rowCount) * 100).toFixed(2)) : 0;
+                profile.distinctCount = baseRow?.distinctCount ?? 0;
+                profile.cardinality = this.classifyCardinality(profile.distinctCount, rowCount);
+                // Type-specific stats
+                if (this.isNumericType(col.dataType)) {
+                    const numRequest = new sql.Request();
+                    const numResult = await numRequest.query(`
+            SELECT 
+              MIN(${colName}) AS minVal,
+              MAX(${colName}) AS maxVal,
+              AVG(CAST(${colName} AS FLOAT)) AS avgVal
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const numRow = numResult.recordset[0];
+                    if (numRow && numRow.minVal !== null) {
+                        profile.numericStats = {
+                            min: numRow.minVal,
+                            max: numRow.maxVal,
+                            avg: Number(Number(numRow.avgVal).toFixed(4)),
+                        };
+                        const percentileRequest = new sql.Request();
+                        const percentileResult = await percentileRequest.query(`
+              SELECT TOP 1
+                PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY ${colName}) OVER () AS medianVal,
+                PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY ${colName}) OVER () AS p90Val
+              FROM ${fqTable}
+              WHERE ${colName} IS NOT NULL
+            `);
+                        const percentileRow = percentileResult.recordset[0];
+                        if (percentileRow) {
+                            if (percentileRow.medianVal !== null && percentileRow.medianVal !== undefined) {
+                                profile.numericStats.median = Number(Number(percentileRow.medianVal).toFixed(4));
+                            }
+                            if (percentileRow.p90Val !== null && percentileRow.p90Val !== undefined) {
+                                profile.numericStats.p90 = Number(Number(percentileRow.p90Val).toFixed(4));
+                            }
+                        }
+                    }
+                }
+                else if (this.isStringType(col.dataType)) {
+                    const strRequest = new sql.Request();
+                    const strResult = await strRequest.query(`
+            SELECT 
+              MIN(LEN(${colName})) AS minLength,
+              MAX(LEN(${colName})) AS maxLength,
+              AVG(CAST(LEN(${colName}) AS FLOAT)) AS avgLength,
+              SUM(CASE WHEN ${colName} = '' THEN 1 ELSE 0 END) AS emptyCount
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const strRow = strResult.recordset[0];
+                    if (strRow && strRow.minLength !== null) {
+                        profile.stringStats = {
+                            minLength: strRow.minLength,
+                            maxLength: strRow.maxLength,
+                            avgLength: Number(Number(strRow.avgLength).toFixed(2)),
+                            emptyCount: strRow.emptyCount ?? 0,
+                        };
+                    }
+                }
+                else if (this.isDateType(col.dataType)) {
+                    const dateRequest = new sql.Request();
+                    const dateResult = await dateRequest.query(`
+            SELECT 
+              MIN(${colName}) AS earliest,
+              MAX(${colName}) AS latest
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+          `);
+                    const dateRow = dateResult.recordset[0];
+                    if (dateRow && dateRow.earliest !== null) {
+                        const earliest = new Date(dateRow.earliest);
+                        const latest = new Date(dateRow.latest);
+                        profile.dateStats = {
+                            earliest: earliest.toISOString(),
+                            latest: latest.toISOString(),
+                            range: this.formatDateRange(earliest, latest),
+                        };
+                    }
+                }
+                // Top values distribution
+                if (includeDistributions && profile.distinctCount > 0 && profile.distinctCount <= rowCount) {
+                    const topRequest = new sql.Request();
+                    topRequest.input("topLimit", sql.Int, topValuesLimit);
+                    const topResult = await topRequest.query(`
+            SELECT TOP (@topLimit)
+              ${colName} AS value,
+              COUNT(*) AS cnt
+            FROM ${fqTable}
+            WHERE ${colName} IS NOT NULL
+            GROUP BY ${colName}
+            ORDER BY cnt DESC
+          `);
+                    if (topResult.recordset.length) {
+                        profile.topValues = topResult.recordset.map((r) => ({
+                            value: r.value,
+                            count: r.cnt,
+                            percentage: Number(((r.cnt / rowCount) * 100).toFixed(2)),
+                        }));
+                    }
+                }
+                columnProfiles.push(profile);
+            }
+            return {
+                success: true,
+                tableName,
+                schemaName,
+                rowCount,
+                columnCount: columnProfiles.length,
+                sampleSize: includeSamples ? sampleRows?.length ?? 0 : sampleSize,
+                columns: columnProfiles,
+                samples: includeSamples ? sampleRows : undefined,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Failed to profile table: ${error}`,
+            };
+        }
+    }
+}
+// Binary/blob types to skip
+ProfileTableTool.SKIP_TYPES = [
+    "image",
+    "varbinary",
+    "binary",
+    "timestamp",
+    "rowversion",
+    "sql_variant",
+    "xml",
+    "geography",
+    "geometry",
+    "hierarchyid",
+];
+ProfileTableTool.NUMERIC_TYPES = [
+    "int",
+    "bigint",
+    "smallint",
+    "tinyint",
+    "decimal",
+    "numeric",
+    "float",
+    "real",
+    "money",
+    "smallmoney",
+];
+ProfileTableTool.STRING_TYPES = [
+    "char",
+    "varchar",
+    "nchar",
+    "nvarchar",
+    "text",
+    "ntext",
+];
+ProfileTableTool.DATE_TYPES = [
+    "date",
+    "datetime",
+    "datetime2",
+    "smalldatetime",
+    "datetimeoffset",
+    "time",
+];
+//# sourceMappingURL=ProfileTableTool.js.map