@memberjunction/db-auto-doc 2.117.0 → 2.119.0

package/dist/drivers/MySQLDriver.js

@@ -0,0 +1,668 @@
+"use strict";
+/**
+ * MySQL implementation of the BaseAutoDocDriver
+ * Uses mysql2 driver for database connectivity
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MySQLDriver = void 0;
+const promise_1 = __importDefault(require("mysql2/promise"));
+const global_1 = require("@memberjunction/global");
+const BaseAutoDocDriver_js_1 = require("./BaseAutoDocDriver.js");
+/**
+ * MySQL driver implementation
+ * Registered with MJGlobal for factory instantiation
+ */
+let MySQLDriver = class MySQLDriver extends BaseAutoDocDriver_js_1.BaseAutoDocDriver {
+    constructor(config) {
+        super(config);
+        this.pool = null;
+        // Map generic config to MySQL specific config
+        this.mysqlConfig = {
+            host: config.host,
+            port: config.port || 3306,
+            database: config.database,
+            user: config.user || config.username,
+            password: config.password,
+            socketPath: config.socketPath,
+            connectionLimit: config.maxConnections || 10,
+            connectTimeout: config.connectionTimeout || 30000,
+            waitForConnections: true,
+            queueLimit: 0,
+            enableKeepAlive: true,
+            keepAliveInitialDelay: 0,
+            // MySQL 8+ requires explicit configuration
+            authPlugins: {
+                mysql_native_password: () => () => Buffer.from(''),
+                caching_sha2_password: () => () => Buffer.from('')
+            }
+        };
+    }
+    // ============================================================================
+    // CONNECTION MANAGEMENT
+    // ============================================================================
+    async connect() {
+        if (this.pool) {
+            return;
+        }
+        this.pool = promise_1.default.createPool(this.mysqlConfig);
+    }
+    async test() {
+        try {
+            await this.connect();
+            const result = await this.executeQuery(`
+        SELECT
+          1 as test,
+          VERSION() as version,
+          DATABASE() as db
+      `);
+            if (result.success && result.data && result.data.length > 0) {
+                return {
+                    success: true,
+                    message: `Successfully connected to ${result.data[0].db} on ${this.config.host}`,
+                    serverVersion: result.data[0].version,
+                    databaseName: result.data[0].db
+                };
+            }
+            return {
+                success: false,
+                message: 'Connection established but test query failed'
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                message: `Connection failed: ${error.message}`
+            };
+        }
+    }
+    async close() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+        }
+    }
+    // ============================================================================
+    // SCHEMA INTROSPECTION
+    // ============================================================================
+    async getSchemas(schemaFilter, tableFilter) {
+        // Get all tables grouped by schema
+        const tablesQuery = this.buildTablesQuery(schemaFilter, tableFilter);
+        const tablesResult = await this.executeQuery(tablesQuery);
+        if (!tablesResult.success || !tablesResult.data) {
+            throw new Error(`Failed to get tables: ${tablesResult.errorMessage}`);
+        }
+        // Group tables by schema
+        const schemaMap = new Map();
+        for (const row of tablesResult.data) {
+            if (!schemaMap.has(row.schema_name)) {
+                schemaMap.set(row.schema_name, []);
+            }
+            schemaMap.get(row.schema_name).push({
+                tableName: row.table_name,
+                rowCount: row.row_count
+            });
+        }
+        // Build schemas with full table details
+        const schemas = [];
+        for (const [schemaName, tableSummaries] of schemaMap) {
+            const tables = [];
+            for (const { tableName, rowCount } of tableSummaries) {
+                const [columns, foreignKeys, primaryKeys] = await Promise.all([
+                    this.getColumns(schemaName, tableName),
+                    this.getForeignKeys(schemaName, tableName),
+                    this.getPrimaryKeys(schemaName, tableName)
+                ]);
+                tables.push({
+                    schemaName,
+                    tableName,
+                    rowCount,
+                    columns,
+                    foreignKeys,
+                    primaryKeys
+                });
+            }
+            schemas.push({
+                name: schemaName,
+                tables
+            });
+        }
+        return schemas;
+    }
+    async getTables(schemaName, tableFilter) {
+        const query = this.buildTablesQuery({ include: [schemaName] }, tableFilter);
+        const result = await this.executeQuery(query);
+        if (!result.success || !result.data) {
+            return [];
+        }
+        const tables = [];
+        for (const row of result.data) {
+            const [columns, foreignKeys, primaryKeys] = await Promise.all([
+                this.getColumns(row.schema_name, row.table_name),
+                this.getForeignKeys(row.schema_name, row.table_name),
+                this.getPrimaryKeys(row.schema_name, row.table_name)
+            ]);
+            tables.push({
+                schemaName: row.schema_name,
+                tableName: row.table_name,
+                rowCount: row.row_count,
+                columns,
+                foreignKeys,
+                primaryKeys
+            });
+        }
+        return tables;
+    }
+    async getColumns(schemaName, tableName) {
+        const query = `
+      SELECT
+        c.COLUMN_NAME as column_name,
+        c.DATA_TYPE as data_type,
+        c.IS_NULLABLE as is_nullable,
+        c.CHARACTER_MAXIMUM_LENGTH as max_length,
+        c.NUMERIC_PRECISION as precision,
+        c.NUMERIC_SCALE as scale,
+        c.COLUMN_KEY as column_key,
+        c.COLUMN_DEFAULT as default_value,
+        c.EXTRA as extra,
+        CASE
+          WHEN c.COLUMN_KEY = 'PRI' THEN 1
+          ELSE 0
+        END as is_primary_key,
+        CASE
+          WHEN c.COLUMN_KEY = 'MUL' THEN 1
+          ELSE 0
+        END as is_foreign_key
+      FROM INFORMATION_SCHEMA.COLUMNS c
+      WHERE c.TABLE_SCHEMA = ?
+        AND c.TABLE_NAME = ?
+      ORDER BY c.ORDINAL_POSITION
+    `;
+        const result = await this.executeQuery(query, 3, [schemaName, tableName]);
+        if (!result.success || !result.data) {
+            return [];
+        }
+        return result.data.map(row => ({
+            name: row.column_name,
+            dataType: row.data_type,
+            isNullable: row.is_nullable === 'YES',
+            isPrimaryKey: row.is_primary_key === 1,
+            isForeignKey: row.is_foreign_key === 1,
+            defaultValue: row.default_value || undefined,
+            maxLength: row.max_length != null ? row.max_length : undefined,
+            precision: row.precision != null ? row.precision : undefined,
+            scale: row.scale != null ? row.scale : undefined
+        }));
+    }
+    async getExistingDescriptions(schemaName, tableName) {
+        // MySQL stores comments in INFORMATION_SCHEMA
+        const tableQuery = `
+      SELECT TABLE_COMMENT as description
+      FROM INFORMATION_SCHEMA.TABLES
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND TABLE_COMMENT != ''
+    `;
+        const columnQuery = `
+      SELECT
+        COLUMN_NAME as column_name,
+        COLUMN_COMMENT as description
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND COLUMN_COMMENT != ''
+    `;
+        const [tableResult, columnResult] = await Promise.all([
+            this.executeQuery(tableQuery, 3, [schemaName, tableName]),
+            this.executeQuery(columnQuery, 3, [schemaName, tableName])
+        ]);
+        const descriptions = [];
+        // Add table description
+        if (tableResult.success && tableResult.data && tableResult.data.length > 0) {
+            descriptions.push({
+                target: 'table',
+                targetName: '',
+                description: tableResult.data[0].description
+            });
+        }
+        // Add column descriptions
+        if (columnResult.success && columnResult.data) {
+            for (const row of columnResult.data) {
+                descriptions.push({
+                    target: 'column',
+                    targetName: row.column_name,
+                    description: row.description
+                });
+            }
+        }
+        return descriptions;
+    }
+    // ============================================================================
+    // DATA SAMPLING AND STATISTICS
+    // ============================================================================
+    async getColumnStatistics(schemaName, tableName, columnName, dataType, cardinalityThreshold, sampleSize) {
+        const stats = {
+            totalRows: 0,
+            distinctCount: 0,
+            uniquenessRatio: 0,
+            nullCount: 0,
+            nullPercentage: 0,
+            sampleValues: []
+        };
+        // Get cardinality and null statistics
+        const cardinalityStats = await this.getCardinalityStats(schemaName, tableName, columnName);
+        Object.assign(stats, cardinalityStats);
+        // Get value distribution for low-cardinality columns
+        if (stats.distinctCount <= cardinalityThreshold && stats.distinctCount > 0) {
+            const distribution = await this.getValueDistribution(schemaName, tableName, columnName, 100);
+            stats.valueDistribution = distribution.map(d => ({
+                ...d,
+                percentage: (d.frequency / (cardinalityStats.totalCount || 1)) * 100
+            }));
+        }
+        // Get type-specific statistics
+        if (this.isNumericType(dataType)) {
+            const numericStats = await this.getNumericStats(schemaName, tableName, columnName);
+            Object.assign(stats, numericStats);
+        }
+        else if (this.isDateType(dataType)) {
+            const dateStats = await this.getDateStats(schemaName, tableName, columnName);
+            Object.assign(stats, dateStats);
+        }
+        else if (this.isStringType(dataType)) {
+            const stringStats = await this.getStringStats(schemaName, tableName, columnName);
+            Object.assign(stats, stringStats);
+        }
+        // Get sample values
+        stats.sampleValues = await this.getSampleValues(schemaName, tableName, columnName, sampleSize);
+        return stats;
+    }
+    async getDistinctCount(schemaName, tableName, columnName) {
+        const query = `
+      SELECT COUNT(DISTINCT ${this.escapeIdentifier(columnName)}) as distinct_count
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+    `;
+        const result = await this.executeQuery(query);
+        return result.success && result.data && result.data.length > 0 ? Number(result.data[0].distinct_count) : 0;
+    }
+    async getValueDistribution(schemaName, tableName, columnName, limit) {
+        const query = `
+      SELECT
+        ${this.escapeIdentifier(columnName)} as value,
+        COUNT(*) as frequency
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+      WHERE ${this.escapeIdentifier(columnName)} IS NOT NULL
+      GROUP BY ${this.escapeIdentifier(columnName)}
+      ORDER BY COUNT(*) DESC
+      LIMIT ${limit}
+    `;
+        const result = await this.executeQuery(query);
+        return result.success && result.data ? result.data.map(r => ({
+            value: r.value,
+            frequency: Number(r.frequency)
+        })) : [];
+    }
+    async getSampleValues(schemaName, tableName, columnName, sampleSize) {
+        // Limit sample size to max 20 to reduce JSON size
+        const limitedSampleSize = Math.min(sampleSize, 20);
+        const query = `
+      SELECT ${this.escapeIdentifier(columnName)} as value
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+      WHERE ${this.escapeIdentifier(columnName)} IS NOT NULL
+      ORDER BY RAND()
+      LIMIT ${limitedSampleSize}
+    `;
+        const result = await this.executeQuery(query);
+        return result.success && result.data ? result.data.map(r => r.value) : [];
+    }
+    // ============================================================================
+    // QUERY EXECUTION
+    // ============================================================================
+    async executeQuery(query, maxRetries = 3, params) {
+        let lastError = null;
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                if (!this.pool) {
+                    await this.connect();
+                }
+                const [rows] = params
+                    ? await this.pool.execute(query, params)
+                    : await this.pool.query(query);
+                return {
+                    success: true,
+                    data: rows,
+                    rowCount: Array.isArray(rows) ? rows.length : 0
+                };
+            }
+            catch (error) {
+                lastError = error;
+                // Check if error is transient
+                if (this.isTransientError(error) && attempt < maxRetries) {
+                    await this.sleep(Math.pow(2, attempt) * 1000);
+                    continue;
+                }
+                break;
+            }
+        }
+        return {
+            success: false,
+            errorMessage: lastError?.message || 'Unknown error'
+        };
+    }
+    // ============================================================================
+    // PROVIDER-SPECIFIC HELPERS
+    // ============================================================================
+    escapeIdentifier(identifier) {
+        return `\`${identifier}\``;
+    }
+    getLimitClause(limit) {
+        return `LIMIT ${limit}`;
+    }
+    // ============================================================================
+    // PRIVATE HELPER METHODS
+    // ============================================================================
+    buildTablesQuery(schemaFilter, tableFilter) {
+        let whereClause = 'WHERE t.TABLE_TYPE = \'BASE TABLE\'';
+        whereClause += this.buildSchemaFilterClause(schemaFilter, 't.TABLE_SCHEMA');
+        whereClause += this.buildTableFilterClause(tableFilter, 't.TABLE_NAME');
+        return `
+      SELECT
+        t.TABLE_SCHEMA as schema_name,
+        t.TABLE_NAME as table_name,
+        COALESCE(t.TABLE_ROWS, 0) as row_count
+      FROM INFORMATION_SCHEMA.TABLES t
+      ${whereClause}
+      ORDER BY t.TABLE_SCHEMA, t.TABLE_NAME
+    `;
+    }
+    async getForeignKeys(schemaName, tableName) {
+        const query = `
+      SELECT
+        kcu.COLUMN_NAME as column_name,
+        kcu.REFERENCED_TABLE_SCHEMA as referenced_schema,
+        kcu.REFERENCED_TABLE_NAME as referenced_table,
+        kcu.REFERENCED_COLUMN_NAME as referenced_column,
+        kcu.CONSTRAINT_NAME as constraint_name
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+      WHERE kcu.TABLE_SCHEMA = ?
+        AND kcu.TABLE_NAME = ?
+        AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
+      ORDER BY kcu.ORDINAL_POSITION
+    `;
+        const result = await this.executeQuery(query, 3, [schemaName, tableName]);
+        if (!result.success || !result.data) {
+            return [];
+        }
+        return result.data.map(row => ({
+            columnName: row.column_name,
+            referencedSchema: row.referenced_schema,
+            referencedTable: row.referenced_table,
+            referencedColumn: row.referenced_column,
+            constraintName: row.constraint_name
+        }));
+    }
+    async getPrimaryKeys(schemaName, tableName) {
+        const query = `
+      SELECT
+        kcu.COLUMN_NAME as column_name,
+        kcu.ORDINAL_POSITION as ordinal_position,
+        kcu.CONSTRAINT_NAME as constraint_name
+      FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
+      INNER JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
+        ON kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+        AND kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA
+        AND kcu.TABLE_NAME = tc.TABLE_NAME
+      WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
+        AND kcu.TABLE_SCHEMA = ?
+        AND kcu.TABLE_NAME = ?
+      ORDER BY kcu.ORDINAL_POSITION
+    `;
+        const result = await this.executeQuery(query, 3, [schemaName, tableName]);
+        if (!result.success || !result.data) {
+            return [];
+        }
+        return result.data.map(row => ({
+            columnName: row.column_name,
+            ordinalPosition: Number(row.ordinal_position),
+            constraintName: row.constraint_name
+        }));
+    }
+    async getCardinalityStats(schemaName, tableName, columnName) {
+        const query = `
+      SELECT
+        COUNT(DISTINCT ${this.escapeIdentifier(columnName)}) as distinct_count,
+        COUNT(*) as total_count,
+        SUM(CASE WHEN ${this.escapeIdentifier(columnName)} IS NULL THEN 1 ELSE 0 END) as null_count
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+    `;
+        const result = await this.executeQuery(query);
+        if (result.success && result.data && result.data.length > 0) {
+            const row = result.data[0];
+            const totalCount = Number(row.total_count) || 1;
+            const distinctCount = Number(row.distinct_count);
+            const nullCount = Number(row.null_count);
+            return {
+                distinctCount,
+                uniquenessRatio: distinctCount / totalCount,
+                nullCount,
+                nullPercentage: (nullCount / totalCount) * 100,
+                totalCount
+            };
+        }
+        return {
+            distinctCount: 0,
+            uniquenessRatio: 0,
+            nullCount: 0,
+            nullPercentage: 0,
+            totalCount: 0
+        };
+    }
+    async getNumericStats(schemaName, tableName, columnName) {
+        const query = `
+      SELECT
+        MIN(${this.escapeIdentifier(columnName)}) as min_value,
+        MAX(${this.escapeIdentifier(columnName)}) as max_value,
+        AVG(${this.escapeIdentifier(columnName)}) as avg_value,
+        STDDEV(${this.escapeIdentifier(columnName)}) as std_dev
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+      WHERE ${this.escapeIdentifier(columnName)} IS NOT NULL
+    `;
+        const result = await this.executeQuery(query);
+        if (result.success && result.data && result.data.length > 0) {
+            const row = result.data[0];
+            return {
+                min: row.min_value,
+                max: row.max_value,
+                avg: row.avg_value != null ? Number(row.avg_value) : undefined,
+                stdDev: row.std_dev != null ? Number(row.std_dev) : undefined
+            };
+        }
+        return {};
+    }
+    async getDateStats(schemaName, tableName, columnName) {
+        const query = `
+      SELECT
+        MIN(${this.escapeIdentifier(columnName)}) as min_value,
+        MAX(${this.escapeIdentifier(columnName)}) as max_value
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+      WHERE ${this.escapeIdentifier(columnName)} IS NOT NULL
+    `;
+        const result = await this.executeQuery(query);
+        if (result.success && result.data && result.data.length > 0) {
+            const row = result.data[0];
+            return {
+                min: row.min_value,
+                max: row.max_value
+            };
+        }
+        return {};
+    }
+    async getStringStats(schemaName, tableName, columnName) {
+        const query = `
+      SELECT
+        AVG(LENGTH(${this.escapeIdentifier(columnName)})) as avg_length,
+        MAX(LENGTH(${this.escapeIdentifier(columnName)})) as max_length,
+        MIN(LENGTH(${this.escapeIdentifier(columnName)})) as min_length
+      FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+      WHERE ${this.escapeIdentifier(columnName)} IS NOT NULL
+    `;
+        const result = await this.executeQuery(query);
+        if (result.success && result.data && result.data.length > 0) {
+            const row = result.data[0];
+            return {
+                avgLength: row.avg_length != null ? Number(row.avg_length) : undefined,
+                maxLength: row.max_length != null ? Number(row.max_length) : undefined,
+                minLength: row.min_length != null ? Number(row.min_length) : undefined
+            };
+        }
+        return {};
+    }
+    isTransientError(error) {
+        const transientMessages = [
+            'connection',
+            'timeout',
+            'deadlock',
+            'network',
+            'ECONNRESET',
+            'ETIMEDOUT',
+            'PROTOCOL_CONNECTION_LOST'
+        ];
+        const message = error.message.toLowerCase();
+        return transientMessages.some(msg => message.includes(msg));
+    }
+    // ============================================================================
+    // RELATIONSHIP DISCOVERY METHODS
+    // ============================================================================
+    /**
+     * Get column information for relationship discovery
+     */
+    async getColumnInfo(schemaName, tableName, columnName) {
+        const query = `
+      SELECT
+        COLUMN_NAME as name,
+        DATA_TYPE as type,
+        IS_NULLABLE as nullable
+      FROM INFORMATION_SCHEMA.COLUMNS
+      WHERE TABLE_SCHEMA = ?
+        AND TABLE_NAME = ?
+        AND COLUMN_NAME = ?
+    `;
+        const result = await this.executeQuery(query, 3, [schemaName, tableName, columnName]);
+        if (!result.success || !result.data || result.data.length === 0) {
+            throw new Error(`Column ${schemaName}.${tableName}.${columnName} not found`);
+        }
+        return {
+            name: result.data[0].name,
+            type: result.data[0].type,
+            nullable: result.data[0].nullable === 'YES'
+        };
+    }
+    /**
+     * Test value overlap between source and target columns
+     */
+    async testValueOverlap(sourceTable, sourceColumn, targetTable, targetColumn, sampleSize) {
+        try {
+            const [sourceSchema, sourceTableName] = this.parseTableIdentifier(sourceTable);
+            const [targetSchema, targetTableName] = this.parseTableIdentifier(targetTable);
+            const query = `
+        WITH SourceSample AS (
+          SELECT DISTINCT ${this.escapeIdentifier(sourceColumn)} as value
+          FROM ${this.escapeIdentifier(sourceSchema)}.${this.escapeIdentifier(sourceTableName)}
+          WHERE ${this.escapeIdentifier(sourceColumn)} IS NOT NULL
+          ORDER BY RAND()
+          LIMIT ${sampleSize}
+        ),
+        TargetValues AS (
+          SELECT DISTINCT ${this.escapeIdentifier(targetColumn)} as value
+          FROM ${this.escapeIdentifier(targetSchema)}.${this.escapeIdentifier(targetTableName)}
+          WHERE ${this.escapeIdentifier(targetColumn)} IS NOT NULL
+        )
+        SELECT
+          COUNT(*) as total_source,
+          SUM(CASE WHEN tv.value IS NOT NULL THEN 1 ELSE 0 END) as matching_count
+        FROM SourceSample ss
+        LEFT JOIN TargetValues tv ON ss.value = tv.value
+      `;
+            const result = await this.executeQuery(query);
+            if (!result.success || !result.data || result.data.length === 0) {
+                return 0;
+            }
+            const row = result.data[0];
+            const totalSource = Number(row.total_source);
+            const matchingCount = Number(row.matching_count);
+            if (totalSource === 0) {
+                return 0;
+            }
+            return matchingCount / totalSource;
+        }
+        catch (error) {
+            return 0;
+        }
+    }
+    /**
+     * Check if combination of columns is unique
+     */
+    async checkColumnCombinationUniqueness(schemaName, tableName, columnNames, sampleSize) {
+        try {
+            if (columnNames.length === 0) {
+                return false;
+            }
+            const escapedColumns = columnNames.map(col => this.escapeIdentifier(col));
+            const columnList = escapedColumns.join(', ');
+            const query = `
+        WITH SampledData AS (
+          SELECT
+            ${columnList}
+          FROM ${this.escapeIdentifier(schemaName)}.${this.escapeIdentifier(tableName)}
+          WHERE ${escapedColumns.map(col => `${col} IS NOT NULL`).join(' AND ')}
+          LIMIT ${sampleSize}
+        ),
+        GroupedData AS (
+          SELECT
+            ${columnList},
+            COUNT(*) as occurrence_count
+          FROM SampledData
+          GROUP BY ${columnList}
+          HAVING COUNT(*) > 1
+        )
+        SELECT COUNT(*) as duplicate_count
+        FROM GroupedData
+      `;
+            const result = await this.executeQuery(query);
+            if (!result.success || !result.data || result.data.length === 0) {
+                return false;
+            }
+            return Number(result.data[0].duplicate_count) === 0;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Parse table identifier in format "schema.table"
+     */
+    parseTableIdentifier(tableIdentifier) {
+        const parts = tableIdentifier.split('.');
+        if (parts.length !== 2) {
+            throw new Error(`Invalid table identifier format: ${tableIdentifier}. Expected "schema.table"`);
+        }
+        return [parts[0], parts[1]];
+    }
+};
+exports.MySQLDriver = MySQLDriver;
+exports.MySQLDriver = MySQLDriver = __decorate([
+    (0, global_1.RegisterClass)(BaseAutoDocDriver_js_1.BaseAutoDocDriver, 'MySQL'),
+    __metadata("design:paramtypes", [Object])
+], MySQLDriver);
+//# sourceMappingURL=MySQLDriver.js.map