@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/database/adapters/postgresql.adapter.js

@@ -1,7 +1,9 @@
 "use strict";
 /**
- * PostgreSQL Database Adapter
- * Implements database operations for PostgreSQL
+ * PostgreSQL Adapter
+ *
+ * Database adapter for PostgreSQL databases using the 'pg' library.
+ * Implements all methods from BaseAdapter with PostgreSQL-specific optimizations.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -39,1563 +41,1291 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgreSQLAdapter = void 0;
 const base_adapter_1 = require("./base.adapter");
-const database_types_1 = require("../types/database.types");
-const uuid_1 = require("uuid");
-const schema_types_1 = require("../types/schema.types");
-const migration_types_1 = require("../types/migration.types");
-/**
- * PostgreSQL Connection wrapper
- */
-class PostgreSQLConnection {
-    constructor(id, pool) {
-        this.id = id;
-        this.type = database_types_1.DatabaseType.POSTGRESQL;
-        this.status = database_types_1.ConnectionStatus.CONNECTED;
-        this.pool = pool;
-    }
-    async connect() {
-        this.status = database_types_1.ConnectionStatus.CONNECTED;
-    }
-    async disconnect() {
-        if (this.pool) {
-            await this.pool.end();
-            this.status = database_types_1.ConnectionStatus.DISCONNECTED;
-        }
-    }
-    isConnected() {
-        return this.status === database_types_1.ConnectionStatus.CONNECTED;
-    }
-    getClient() {
-        return this.pool;
-    }
-}
+const enums_1 = require("../types/enums");
+const database_error_1 = require("../utils/database-error");
 /**
- * PostgreSQL Savepoint implementation
+ * PostgreSQL database adapter
+ * Provides PostgreSQL-specific implementations for all database operations
  */
-class PostgreSQLSavepoint {
-    constructor(name, transaction, client) {
-        this.name = name;
-        this.transaction = transaction;
-        this.createdAt = new Date();
-        this.client = client;
-    }
-    async rollback() {
-        await this.client.query(`ROLLBACK TO SAVEPOINT ${this.name}`);
-    }
-    async release() {
-        await this.client.query(`RELEASE SAVEPOINT ${this.name}`);
-    }
-}
-/**
- * PostgreSQL Transaction implementation
- */
-class PostgreSQLTransaction {
-    constructor(connection, client, options) {
-        this.id = (0, uuid_1.v4)();
-        this.connection = connection;
-        this.status = database_types_1.TransactionStatus.ACTIVE;
-        this.isolationLevel = options === null || options === void 0 ? void 0 : options.isolationLevel;
-        this.createdAt = new Date();
-        this.client = client;
-        this.native = client;
-    }
-    async commit() {
-        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot commit transaction: status is ${this.status}`);
-        }
-        await this.client.query('COMMIT');
-        this.status = database_types_1.TransactionStatus.COMMITTED;
-    }
-    async rollback() {
-        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot rollback transaction: status is ${this.status}`);
-        }
-        await this.client.query('ROLLBACK');
-        this.status = database_types_1.TransactionStatus.ROLLED_BACK;
-    }
-    async savepoint(name) {
-        if (this.status !== database_types_1.TransactionStatus.ACTIVE) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Cannot create savepoint: transaction status is ${this.status}`);
-        }
-        await this.client.query(`SAVEPOINT ${name}`);
-        return new PostgreSQLSavepoint(name, this, this.client);
-    }
-    isActive() {
-        return this.status === database_types_1.TransactionStatus.ACTIVE;
-    }
-}
-/**
- * PostgreSQL Adapter
- */
-class PostgreSQLAdapter extends base_adapter_1.BaseDatabaseAdapter {
+class PostgreSQLAdapter extends base_adapter_1.BaseAdapter {
     constructor() {
         super(...arguments);
-        this.type = database_types_1.DatabaseType.POSTGRESQL;
-        this.connectionPool = new Map();
+        this.databaseType = enums_1.DatabaseType.POSTGRESQL;
+        this.pool = null;
     }
-    // ==================== Connection Methods ====================
-    async connect(config) {
+    // ==================== CONNECTION METHODS ====================
+    async connect(options) {
         try {
-            // Import pg library dynamically
+            // Dynamic import of pg to avoid bundling issues
             const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
-            // Extract connection options from config
-            const options = config.options || {};
-            // Create connection pool
-            const pool = new Pool({
-                host: options.host,
-                port: options.port || 5432,
-                database: config.database || options.database,
-                user: options.user || options.username,
-                password: options.password,
-                ssl: options.ssl,
+            this.connectionUrl = options.connectionUrl;
+            this.pool = new Pool({
+                connectionString: options.connectionUrl,
                 max: options.poolSize || 10,
-                connectionTimeoutMillis: options.connectionTimeout || 5000,
                 idleTimeoutMillis: options.idleTimeout || 30000,
+                connectionTimeoutMillis: options.connectionTimeout || 5000,
+                ssl: options.ssl ? { rejectUnauthorized: false } : undefined,
             });
-            // Test connection
-            await pool.query('SELECT 1');
-            // Create connection wrapper
-            const connectionId = `postgresql-${config.database}-${Date.now()}`;
-            const connection = new PostgreSQLConnection(connectionId, pool);
-            // Store in pool map
-            this.connectionPool.set(connectionId, connection);
-            return connection;
+            // Test the connection
+            const client = await this.pool.connect();
+            const versionResult = await client.query('SELECT version()');
+            client.release();
+            this.client = this.pool;
+            this.connected = true;
+            return {
+                connected: true,
+                version: versionResult.rows[0].version,
+            };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.CONNECTION_ERROR, `Failed to connect to PostgreSQL: ${error.message}`, error);
+            throw database_error_1.DatabaseError.connectionError(`Failed to connect to PostgreSQL: ${error.message}`, error);
         }
     }
-    async disconnect(connection) {
-        await connection.disconnect();
-        this.connectionPool.delete(connection.id);
-    }
-    async testConnection(connection) {
-        var _a;
-        const startTime = Date.now();
+    async testConnection(options) {
         try {
-            const pool = connection.getClient();
-            const result = await pool.query('SELECT version()');
-            const responseTime = Date.now() - startTime;
+            const { Pool } = await Promise.resolve().then(() => __importStar(require('pg')));
+            const pool = new Pool({
+                connectionString: options.connectionUrl,
+                max: 1,
+                connectionTimeoutMillis: options.connectionTimeout || 5000,
+            });
+            const client = await pool.connect();
+            const versionResult = await client.query('SELECT version()');
+            client.release();
+            await pool.end();
             return {
                 connected: true,
-                message: 'Successfully connected to PostgreSQL',
-                databaseType: 'PostgreSQL',
-                version: (_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.version,
-                responseTime,
+                version: versionResult.rows[0].version,
             };
         }
         catch (error) {
             return {
                 connected: false,
-                message: 'Failed to connect to PostgreSQL',
-                databaseType: 'PostgreSQL',
-                responseTime: Date.now() - startTime,
-                error: error.message,
             };
         }
     }
-    // ==================== Transaction Methods ====================
-    async beginTransaction(connection, options) {
-        try {
-            const pool = connection.getClient();
-            const client = await pool.connect();
-            // Set isolation level if specified
-            let beginStatement = 'BEGIN';
-            if (options === null || options === void 0 ? void 0 : options.isolationLevel) {
-                beginStatement += ` ISOLATION LEVEL ${options.isolationLevel.replace('_', ' ')}`;
-            }
-            if (options === null || options === void 0 ? void 0 : options.readOnly) {
-                beginStatement += ' READ ONLY';
-            }
-            if (options === null || options === void 0 ? void 0 : options.deferrable) {
-                beginStatement += ' DEFERRABLE';
-            }
-            await client.query(beginStatement);
-            return new PostgreSQLTransaction(connection, client, options);
-        }
-        catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.TRANSACTION_ERROR, `Failed to begin transaction: ${error.message}`, error);
+    async disconnect() {
+        if (this.pool) {
+            await this.pool.end();
+            this.pool = null;
+            this.client = null;
+            this.connected = false;
         }
     }
-    async commitTransaction(connection, transaction) {
-        await transaction.commit();
-    }
-    async rollbackTransaction(connection, transaction) {
-        await transaction.rollback();
-    }
-    async createSavepoint(connection, transaction, savepointName) {
-        return transaction.savepoint(savepointName);
-    }
-    async rollbackToSavepoint(_connection, _transaction, savepoint) {
-        await savepoint.rollback();
-    }
-    async releaseSavepoint(_connection, _transaction, savepoint) {
-        await savepoint.release();
-    }
-    // ==================== Query Methods ====================
-    async query(connection, options) {
-        const startTime = Date.now();
+    // ==================== QUERY METHODS ====================
+    async query(query) {
+        var _a, _b, _c;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildSelectQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            const executionTime = Date.now() - startTime;
+            const client = ((_a = query.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const result = await client.query(query.sql, query.params);
+            // Get total count if needed for pagination
+            let count = result.rows.length;
+            if (query.options.limit || query.options.offset) {
+                const countSql = this.buildCountQuery(query);
+                // Calculate how many params to remove based on actual pagination options
+                let paramsToRemove = 0;
+                if (query.options.limit !== undefined)
+                    paramsToRemove++;
+                if (query.options.offset !== undefined)
+                    paramsToRemove++;
+                const countParams = paramsToRemove > 0 ? (_b = query.params) === null || _b === void 0 ? void 0 : _b.slice(0, -paramsToRemove) : query.params;
+                const countResult = await client.query(countSql, countParams);
+                count = parseInt(countResult.rows[0].count, 10);
+            }
             return {
                 data: result.rows,
-                count: result.rowCount,
-                executionTime,
-                databaseType: 'PostgreSQL',
+                count,
+                fields: (_c = result.fields) === null || _c === void 0 ? void 0 : _c.map((f) => f.name),
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL query failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async insert(connection, options) {
-        const startTime = Date.now();
+    async raw(options) {
+        var _a, _b;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildInsertQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            const executionTime = Date.now() - startTime;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const result = await client.query(options.query, options.params);
             return {
-                insertedCount: result.rowCount,
-                insertedIds: result.rows.map((row) => row.id || row[Object.keys(row)[0]]),
-                data: options.returning ? result.rows : undefined,
-                executionTime,
-                success: true,
+                data: result.rows,
+                count: result.rowCount || result.rows.length,
+                fields: (_b = result.fields) === null || _b === void 0 ? void 0 : _b.map((f) => f.name),
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL insert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async update(connection, options) {
-        const startTime = Date.now();
+    // ==================== WRITE METHODS ====================
+    async insert(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildUpdateQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            const executionTime = Date.now() - startTime;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const data = Array.isArray(options.data) ? options.data : [options.data];
+            if (data.length === 0) {
+                return { data: [], count: 0, insertedIds: [] };
+            }
+            const columns = Object.keys(data[0]);
+            const values = [];
+            const valuePlaceholders = [];
+            data.forEach((record, rowIndex) => {
+                const rowPlaceholders = [];
+                columns.forEach((col, colIndex) => {
+                    values.push(record[col]);
+                    rowPlaceholders.push(`$${rowIndex * columns.length + colIndex + 1}`);
+                });
+                valuePlaceholders.push(`(${rowPlaceholders.join(', ')})`);
+            });
+            let sql = `INSERT INTO ${this.escapeIdentifier(options.table)} (${columns.map(c => this.escapeIdentifier(c)).join(', ')}) VALUES ${valuePlaceholders.join(', ')}`;
+            // Handle ON CONFLICT (upsert)
+            if (options.onConflict) {
+                const conflictColumns = options.onConflict.columns.map(c => this.escapeIdentifier(c)).join(', ');
+                if (options.onConflict.action === 'ignore') {
+                    sql += ` ON CONFLICT (${conflictColumns}) DO NOTHING`;
+                }
+                else if (options.onConflict.action === 'update' && options.onConflict.update) {
+                    const updates = options.onConflict.update.map(col => `${this.escapeIdentifier(col)} = EXCLUDED.${this.escapeIdentifier(col)}`).join(', ');
+                    sql += ` ON CONFLICT (${conflictColumns}) DO UPDATE SET ${updates}`;
+                }
+            }
+            // Always use RETURNING * to get all columns including the primary key
+            // This avoids assuming the primary key column is named 'id'
+            sql += ' RETURNING *';
+            const result = await client.query(sql, values);
+            // Try to extract the primary key value from returned rows
+            // Look for common primary key column names if 'id' doesn't exist
+            const insertedIds = result.rows.map((r) => {
+                // Try common primary key column names in order of likelihood
+                if (r.id !== undefined)
+                    return r.id;
+                if (r._id !== undefined)
+                    return r._id;
+                if (r.uuid !== undefined)
+                    return r.uuid;
+                // Fall back to first column value as a reasonable guess for serial PKs
+                const keys = Object.keys(r);
+                return keys.length > 0 ? r[keys[0]] : undefined;
+            });
             return {
-                updatedCount: result.rowCount,
-                matchedCount: result.rowCount,
-                data: options.returning ? result.rows : undefined,
-                executionTime,
-                success: true,
+                data: options.returning ? result.rows : [],
+                count: result.rowCount || data.length,
+                insertedIds,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL update failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async delete(connection, options) {
-        const startTime = Date.now();
+    async update(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildDeleteQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            const executionTime = Date.now() - startTime;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const setClauses = [];
+            const values = [];
+            let paramIndex = 1;
+            // Build SET clause
+            for (const [key, value] of Object.entries(options.data)) {
+                if (value && typeof value === 'object' && this.isUpdateOperator(value)) {
+                    // Handle update operators
+                    if ('$INC' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} + $${paramIndex}`);
+                        values.push(value.$INC);
+                        paramIndex++;
+                    }
+                    else if ('$DEC' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} - $${paramIndex}`);
+                        values.push(value.$DEC);
+                        paramIndex++;
+                    }
+                    else if ('$MUL' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = ${this.escapeIdentifier(key)} * $${paramIndex}`);
+                        values.push(value.$MUL);
+                        paramIndex++;
+                    }
+                    else if ('$MIN' in value) {
+                        // LEAST function for minimum
+                        setClauses.push(`${this.escapeIdentifier(key)} = LEAST(${this.escapeIdentifier(key)}, $${paramIndex})`);
+                        values.push(value.$MIN);
+                        paramIndex++;
+                    }
+                    else if ('$MAX' in value) {
+                        // GREATEST function for maximum
+                        setClauses.push(`${this.escapeIdentifier(key)} = GREATEST(${this.escapeIdentifier(key)}, $${paramIndex})`);
+                        values.push(value.$MAX);
+                        paramIndex++;
+                    }
+                    else if ('$SET' in value) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
+                        values.push(value.$SET);
+                        paramIndex++;
+                    }
+                    else if ('$UNSET' in value && value.$UNSET) {
+                        setClauses.push(`${this.escapeIdentifier(key)} = NULL`);
+                        // No paramIndex increment needed for NULL
+                    }
+                    else if ('$PUSH' in value) {
+                        // Array append for PostgreSQL (column must be array type)
+                        setClauses.push(`${this.escapeIdentifier(key)} = array_append(${this.escapeIdentifier(key)}, $${paramIndex})`);
+                        values.push(value.$PUSH);
+                        paramIndex++;
+                    }
+                    else if ('$PULL' in value) {
+                        // Array remove for PostgreSQL (column must be array type)
+                        setClauses.push(`${this.escapeIdentifier(key)} = array_remove(${this.escapeIdentifier(key)}, $${paramIndex})`);
+                        values.push(value.$PULL);
+                        paramIndex++;
+                    }
+                    else if ('$ADDTOSET' in value) {
+                        // Add unique value to array - use CASE to check existence first
+                        setClauses.push(`${this.escapeIdentifier(key)} = CASE WHEN $${paramIndex} = ANY(${this.escapeIdentifier(key)}) THEN ${this.escapeIdentifier(key)} ELSE array_append(${this.escapeIdentifier(key)}, $${paramIndex}) END`);
+                        values.push(value.$ADDTOSET);
+                        paramIndex++;
+                    }
+                }
+                else {
+                    setClauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
+                    values.push(value);
+                    paramIndex++;
+                }
+            }
+            let sql = `UPDATE ${this.escapeIdentifier(options.table)} SET ${setClauses.join(', ')}`;
+            // Build WHERE clause
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, paramIndex);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            // Add RETURNING if requested
+            if (options.returning) {
+                sql += ' RETURNING *';
+            }
+            const result = await client.query(sql, values);
             return {
-                deletedCount: result.rowCount,
-                data: options.returning ? result.rows : undefined,
-                executionTime,
-                success: true,
+                data: options.returning ? result.rows : [],
+                count: result.rowCount || 0,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL delete failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async upsert(connection, options) {
-        const startTime = Date.now();
+    async delete(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildUpsertQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            const executionTime = Date.now() - startTime;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `DELETE FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            // Build WHERE clause
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            // Add RETURNING if requested
+            if (options.returning) {
+                sql += ' RETURNING *';
+            }
+            const result = await client.query(sql, values);
             return {
-                insertedCount: 0, // PostgreSQL doesn't distinguish in upsert
-                updatedCount: 0,
-                affectedCount: result.rowCount,
+                count: result.rowCount || 0,
                 data: options.returning ? result.rows : undefined,
-                executionTime,
-                success: true,
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL upsert failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async executeRaw(connection, options) {
-        var _a;
-        const startTime = Date.now();
+    async upsert(options) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            const result = await client.query(options.query, options.params || []);
-            const executionTime = Date.now() - startTime;
+            const insertResult = await this.insert(Object.assign(Object.assign({}, options), { onConflict: {
+                    columns: options.conflictKeys,
+                    action: 'update',
+                    update: options.updateColumns || Object.keys(options.data).filter(k => !options.conflictKeys.includes(k)),
+                }, returning: true }));
+            // Determine if it was an insert or update
+            // PostgreSQL doesn't directly tell us, so we check xmax
+            const operation = 'upserted'; // Simplified - PostgreSQL doesn't easily distinguish
             return {
-                rows: result.rows,
-                rowCount: result.rowCount,
-                fields: (_a = result.fields) === null || _a === void 0 ? void 0 : _a.map((f) => ({
-                    name: f.name,
-                    type: f.dataTypeID,
-                })),
-                executionTime,
+                data: insertResult.data,
+                count: insertResult.count,
+                operation: insertResult.count > 0 ? 'inserted' : 'updated',
             };
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL raw query failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    // ==================== Aggregation Methods ====================
-    async count(connection, options) {
+    // ==================== AGGREGATION METHODS ====================
+    async count(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildCountQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const column = options.column ? this.escapeIdentifier(options.column) : '*';
+            const distinctPrefix = options.distinct ? 'DISTINCT ' : '';
+            let sql = `SELECT COUNT(${distinctPrefix}${column}) as count FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const result = await client.query(sql, values);
             return parseInt(result.rows[0].count, 10);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL count failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async sum(connection, options) {
+    async sum(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildAggregateQuery('SUM', options.column, options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return parseFloat(result.rows[0].result) || 0;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT COALESCE(SUM(${this.escapeIdentifier(options.column)}), 0) as sum FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const result = await client.query(sql, values);
+            return parseFloat(result.rows[0].sum);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL sum failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async avg(connection, options) {
+    async avg(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildAggregateQuery('AVG', options.column, options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return parseFloat(result.rows[0].result) || 0;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT COALESCE(AVG(${this.escapeIdentifier(options.column)}), 0) as avg FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const result = await client.query(sql, values);
+            return parseFloat(result.rows[0].avg);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL avg failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async min(connection, options) {
+    async min(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildAggregateQuery('MIN', options.column, options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return result.rows[0].result;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT MIN(${this.escapeIdentifier(options.column)}) as min FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const result = await client.query(sql, values);
+            return result.rows[0].min;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL min failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async max(connection, options) {
+    async max(options) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildAggregateQuery('MAX', options.column, options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return result.rows[0].result;
+            const client = ((_a = options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            let sql = `SELECT MAX(${this.escapeIdentifier(options.column)}) as max FROM ${this.escapeIdentifier(options.table)}`;
+            const values = [];
+            if (options.where) {
+                const { whereClause, whereParams } = this.buildWhereClause(options.where, 1);
+                sql += ` WHERE ${whereClause}`;
+                values.push(...whereParams);
+            }
+            const result = await client.query(sql, values);
+            return result.rows[0].max;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL max failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async groupBy(connection, options) {
+    async aggregate(builtAggregation) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildGroupByQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return result.rows;
+            const client = ((_a = builtAggregation.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const result = await client.query(builtAggregation.sql, builtAggregation.params);
+            return result.rows[0] || {};
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL groupBy failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    async aggregate(connection, options) {
+    async groupBy(builtGroupBy) {
+        var _a;
+        this.ensureConnected();
         try {
-            const { query, params } = this.buildMultiAggregateQuery(options);
-            const client = connection.getClient();
-            const result = await client.query(query, params);
-            return result.rows[0] || {};
+            const client = ((_a = builtGroupBy.options.transaction) === null || _a === void 0 ? void 0 : _a.client) || this.pool;
+            const result = await client.query(builtGroupBy.sql, builtGroupBy.params);
+            // Transform rows into IGroupByResult format
+            const options = builtGroupBy.options;
+            return result.rows.map((row) => {
+                var _a;
+                const group = {};
+                const aggregates = {};
+                for (const key of Object.keys(row)) {
+                    if ((_a = options.groupBy) === null || _a === void 0 ? void 0 : _a.includes(key)) {
+                        group[key] = row[key];
+                    }
+                    else {
+                        aggregates[key] = row[key];
+                    }
+                }
+                return { group, aggregates: aggregates };
+            });
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `PostgreSQL aggregate failed: ${error.message}`, error);
+            throw database_error_1.DatabaseError.fromDatabaseError(error, 'postgresql');
         }
     }
-    // ==================== Schema Methods ====================
-    async createTable(connection, schema, options) {
-        const startTime = Date.now();
+    // ==================== TRANSACTION METHODS ====================
+    async beginTransaction(isolationLevel, readOnly, timeout) {
+        this.ensureConnected();
         try {
-            const query = this.buildCreateTableQuery(schema, options);
-            const client = connection.getClient();
-            await client.query(query);
-            const executionTime = Date.now() - startTime;
+            const client = await this.pool.connect();
+            const id = `pg_txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+            // Build BEGIN statement with isolation level
+            let beginSql = 'BEGIN';
+            if (isolationLevel) {
+                beginSql += ` ISOLATION LEVEL ${this.mapIsolationLevel(isolationLevel)}`;
+            }
+            if (readOnly) {
+                beginSql += ' READ ONLY';
+            }
+            await client.query(beginSql);
+            // Set statement timeout if specified
+            if (timeout) {
+                await client.query(`SET LOCAL statement_timeout = ${timeout}`);
+            }
             return {
-                success: true,
-                operation: 'create',
-                table: schema.name,
-                executionTime,
+                id,
+                databaseType: 'postgresql',
+                isolationLevel: isolationLevel || enums_1.IsolationLevel.READ_COMMITTED,
+                readOnly: readOnly || false,
+                timeout,
+                startedAt: new Date(),
+                client,
+                savepoints: new Map(),
+                status: 'active',
             };
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'create',
-                table: schema.name,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            throw database_error_1.DatabaseError.transactionError(`Failed to begin transaction: ${error.message}`, error);
         }
     }
-    async dropTable(connection, tableName) {
-        const startTime = Date.now();
+    async commitTransaction(context) {
         try {
-            const client = connection.getClient();
-            await client.query(`DROP TABLE IF EXISTS "${tableName}"`);
-            return {
-                success: true,
-                operation: 'drop',
-                table: tableName,
-                executionTime: Date.now() - startTime,
-            };
+            await context.client.query('COMMIT');
+            context.client.release();
+            context.status = 'committed';
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                table: tableName,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            context.status = 'error';
+            context.client.release();
+            throw database_error_1.DatabaseError.transactionError(`Failed to commit transaction: ${error.message}`, error);
         }
     }
-    async alterTable(connection, tableName, alterations, options) {
-        const startTime = Date.now();
+    async rollbackTransaction(context) {
         try {
-            const queries = this.buildAlterTableQueries(tableName, alterations);
-            const client = connection.getClient();
-            for (const query of queries) {
-                await client.query(query);
-            }
-            return {
-                success: true,
-                operation: 'alter',
-                table: tableName,
-                executionTime: Date.now() - startTime,
-            };
+            await context.client.query('ROLLBACK');
+            context.client.release();
+            context.status = 'rolled_back';
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'alter',
-                table: tableName,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            context.status = 'error';
+            context.client.release();
+            throw database_error_1.DatabaseError.transactionError(`Failed to rollback transaction: ${error.message}`, error);
         }
     }
-    async getTableSchema(connection, tableName) {
+    async createSavepoint(context, name) {
         try {
-            const client = connection.getClient();
-            const query = `
-        SELECT
-          column_name,
-          data_type,
-          is_nullable,
-          column_default,
-          character_maximum_length,
-          numeric_precision,
-          numeric_scale
-        FROM information_schema.columns
-        WHERE table_name = $1
-        ORDER BY ordinal_position
-      `;
-            const result = await client.query(query, [tableName]);
-            const columns = result.rows.map((row) => ({
-                name: row.column_name,
-                type: this.mapPostgreSQLTypeToColumnType(row.data_type),
-                nullable: row.is_nullable === 'YES',
-                defaultValue: row.column_default,
-                length: row.character_maximum_length,
-                precision: row.numeric_precision,
-                scale: row.numeric_scale,
-            }));
-            return {
-                name: tableName,
-                columns,
+            await context.client.query(`SAVEPOINT ${this.escapeIdentifier(name)}`);
+            const savepoint = {
+                name,
+                release: async () => {
+                    await this.releaseSavepoint(context, savepoint);
+                },
+                rollback: async () => {
+                    await this.rollbackToSavepoint(context, savepoint);
+                },
             };
+            context.savepoints.set(name, savepoint);
+            return savepoint;
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.SCHEMA_ERROR, `Failed to get PostgreSQL table schema: ${error.message}`, error);
+            throw database_error_1.DatabaseError.transactionError(`Failed to create savepoint: ${error.message}`, error);
         }
     }
-    async listTables(connection) {
+    async releaseSavepoint(context, savepoint) {
         try {
-            const client = connection.getClient();
-            const query = `
-        SELECT tablename
-        FROM pg_tables
-        WHERE schemaname = 'public'
-        ORDER BY tablename
-      `;
-            const result = await client.query(query);
-            return result.rows.map((row) => row.tablename);
+            await context.client.query(`RELEASE SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
+            context.savepoints.delete(savepoint.name);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.QUERY_ERROR, `Failed to list PostgreSQL tables: ${error.message}`, error);
+            throw database_error_1.DatabaseError.transactionError(`Failed to release savepoint: ${error.message}`, error);
         }
     }
-    async tableExists(connection, tableName) {
+    async rollbackToSavepoint(context, savepoint) {
         try {
-            const client = connection.getClient();
-            const query = `
-        SELECT EXISTS (
-          SELECT FROM information_schema.tables
-          WHERE table_schema = 'public'
-          AND table_name = $1
-        )
-      `;
-            const result = await client.query(query, [tableName]);
-            return result.rows[0].exists;
+            await context.client.query(`ROLLBACK TO SAVEPOINT ${this.escapeIdentifier(savepoint.name)}`);
         }
         catch (error) {
-            return false;
+            throw database_error_1.DatabaseError.transactionError(`Failed to rollback to savepoint: ${error.message}`, error);
         }
     }
-    // ==================== Index Methods ====================
-    async createIndex(connection, options) {
-        const startTime = Date.now();
+    supportsSavepoints() {
+        return true;
+    }
+    // ==================== SCHEMA METHODS ====================
+    async createTable(definition, options) {
+        this.ensureConnected();
         try {
-            const query = this.buildCreateIndexQuery(options);
-            const client = connection.getClient();
-            await client.query(query);
-            return {
-                success: true,
-                operation: 'create',
-                indexName: options.index.name,
-                table: options.table,
-                executionTime: Date.now() - startTime,
-            };
+            const columnDefs = definition.columns.map(col => this.buildColumnDefinition(col)).join(', ');
+            let sql = 'CREATE';
+            if (options === null || options === void 0 ? void 0 : options.temporary)
+                sql += ' TEMPORARY';
+            if (options === null || options === void 0 ? void 0 : options.unlogged)
+                sql += ' UNLOGGED';
+            sql += ' TABLE';
+            if (options === null || options === void 0 ? void 0 : options.ifNotExists)
+                sql += ' IF NOT EXISTS';
+            sql += ` ${this.escapeIdentifier(definition.name)} (${columnDefs}`;
+            // Add table constraints
+            if (definition.constraints) {
+                const constraintDefs = definition.constraints.map(c => this.buildConstraintDefinition(c)).join(', ');
+                sql += `, ${constraintDefs}`;
+            }
+            sql += ')';
+            // Add inheritance
+            if (options === null || options === void 0 ? void 0 : options.inherits) {
+                sql += ` INHERITS (${this.escapeIdentifier(options.inherits)})`;
+            }
+            // Add tablespace
+            if (options === null || options === void 0 ? void 0 : options.tablespace) {
+                sql += ` TABLESPACE ${this.escapeIdentifier(options.tablespace)}`;
+            }
+            await this.pool.query(sql);
+            // Add table comment
+            if (definition.comment) {
+                await this.pool.query(`COMMENT ON TABLE ${this.escapeIdentifier(definition.name)} IS ${this.escapeValue(definition.comment)}`);
+            }
+            // Create indexes
+            if (definition.indexes) {
+                for (const index of definition.indexes) {
+                    await this.createIndex(index);
+                }
+            }
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'create',
-                indexName: options.index.name,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to create table: ${error.message}`, error);
         }
     }
-    async dropIndex(connection, options) {
-        const startTime = Date.now();
+    async alterTable(tableName, operations) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            await client.query(`DROP INDEX IF EXISTS "${options.indexName}"`);
-            return {
-                success: true,
-                operation: 'drop',
-                indexName: options.indexName,
-                table: options.table,
-                executionTime: Date.now() - startTime,
-            };
+            for (const op of operations) {
+                let sql = `ALTER TABLE ${this.escapeIdentifier(tableName)}`;
+                switch (op.type) {
+                    case 'ADD':
+                        if (op.column) {
+                            sql += ` ADD COLUMN ${this.buildColumnDefinition(op.column)}`;
+                        }
+                        else if (op.constraint) {
+                            sql += ` ADD ${this.buildConstraintDefinition(op.constraint)}`;
+                        }
+                        break;
+                    case 'DROP':
+                        if (op.columnName) {
+                            sql += ` DROP COLUMN ${this.escapeIdentifier(op.columnName)}`;
+                        }
+                        else if (op.constraintName) {
+                            sql += ` DROP CONSTRAINT ${this.escapeIdentifier(op.constraintName)}`;
+                        }
+                        break;
+                    case 'MODIFY':
+                        if (op.column) {
+                            // PostgreSQL uses ALTER COLUMN for modifications
+                            const col = op.column;
+                            if (col.type) {
+                                sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} TYPE ${this.getColumnTypeString(col.type, col)}`;
+                            }
+                            if (col.nullable !== undefined) {
+                                if (col.nullable) {
+                                    sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} DROP NOT NULL`;
+                                }
+                                else {
+                                    sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} SET NOT NULL`;
+                                }
+                            }
+                            if (col.defaultValue !== undefined) {
+                                sql += ` ALTER COLUMN ${this.escapeIdentifier(col.name)} SET DEFAULT ${this.escapeValue(col.defaultValue)}`;
+                            }
+                        }
+                        break;
+                    case 'RENAME':
+                        if (op.oldName && op.newName) {
+                            sql += ` RENAME COLUMN ${this.escapeIdentifier(op.oldName)} TO ${this.escapeIdentifier(op.newName)}`;
+                        }
+                        break;
+                }
+                await this.pool.query(sql);
+            }
         }
         catch (error) {
-            return {
-                success: false,
-                operation: 'drop',
-                indexName: options.indexName,
-                table: options.table,
-                error: error.message,
-                executionTime: Date.now() - startTime,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to alter table: ${error.message}`, error);
         }
     }
-    async listIndexes(connection, options) {
+    async dropTable(tableName, ifExists, cascade) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            const query = `
-        SELECT
-          i.relname as index_name,
-          a.attname as column_name,
-          ix.indisunique as is_unique,
-          am.amname as index_type
-        FROM
-          pg_class t,
-          pg_class i,
-          pg_index ix,
-          pg_attribute a,
-          pg_am am
-        WHERE
-          t.oid = ix.indrelid
-          AND i.oid = ix.indexrelid
-          AND a.attrelid = t.oid
-          AND a.attnum = ANY(ix.indkey)
-          AND t.relkind = 'r'
-          AND t.relname = $1
-          AND i.relam = am.oid
-        ORDER BY
-          i.relname,
-          a.attnum
-      `;
-            const result = await client.query(query, [options.table]);
-            // Group by index name
-            const indexMap = new Map();
-            result.rows.forEach((row) => {
-                if (!indexMap.has(row.index_name)) {
-                    indexMap.set(row.index_name, {
-                        name: row.index_name,
-                        table: options.table,
-                        columns: [],
-                        columnDetails: [],
-                        unique: row.is_unique,
-                        primaryKey: false,
-                        type: row.index_type,
-                    });
-                }
-                const indexInfo = indexMap.get(row.index_name);
-                indexInfo.columns.push(row.column_name);
-                indexInfo.columnDetails.push({
-                    name: row.column_name,
-                    order: 'ASC',
-                });
-            });
-            return Array.from(indexMap.values());
+            let sql = 'DROP TABLE';
+            if (ifExists)
+                sql += ' IF EXISTS';
+            sql += ` ${this.escapeIdentifier(tableName)}`;
+            if (cascade)
+                sql += ' CASCADE';
+            await this.pool.query(sql);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to list PostgreSQL indexes: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop table: ${error.message}`, error);
         }
     }
-    async getIndexStatistics(connection, tableName, indexName) {
+    async listTables() {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            let query = `
-        SELECT
-          schemaname,
-          tablename,
-          indexname,
-          idx_scan as scans,
-          idx_tup_read as tuples_read,
-          idx_tup_fetch as tuples_fetched
-        FROM
-          pg_stat_user_indexes
-        WHERE
-          tablename = $1
-      `;
-            const params = [tableName];
-            if (indexName) {
-                query += ` AND indexname = $2`;
-                params.push(indexName);
-            }
-            const result = await client.query(query, params);
-            return result.rows.map((row) => ({
-                indexName: row.indexname,
-                tableName: row.tablename,
-                scans: row.scans,
-                tuplesRead: row.tuples_read,
-                tuplesFetched: row.tuples_fetched,
-            }));
+            const result = await this.pool.query(`
+        SELECT tablename FROM pg_tables
+        WHERE schemaname = 'public'
+        ORDER BY tablename
+      `);
+            return result.rows.map((r) => r.tablename);
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.INDEX_ERROR, `Failed to get PostgreSQL index statistics: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list tables: ${error.message}`, error);
         }
     }
-    // ==================== Migration Methods ====================
-    /**
-     * Build SQL for a migration operation
-     */
-    async buildMigrationOperationSQL(operation) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
-        switch (operation.type) {
-            case migration_types_1.MigrationOperationType.RAW_SQL:
-                return operation.sql || null;
-            case migration_types_1.MigrationOperationType.CREATE_TABLE:
-                if ((_a = operation.params) === null || _a === void 0 ? void 0 : _a.schema) {
-                    const schema = operation.params.schema;
-                    const columns = schema.columns
-                        .map((col) => {
-                        let def = `"${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
-                        if (col.primaryKey)
-                            def += ' PRIMARY KEY';
-                        if (!col.nullable)
-                            def += ' NOT NULL';
-                        if (col.unique)
-                            def += ' UNIQUE';
-                        if (col.defaultValue !== undefined) {
-                            def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
-                        }
-                        return def;
-                    })
-                        .join(', ');
-                    return `CREATE TABLE "${schema.name}" (${columns})`;
-                }
-                return null;
-            case migration_types_1.MigrationOperationType.DROP_TABLE:
-                return operation.table ? `DROP TABLE IF EXISTS "${operation.table}"` : null;
-            case migration_types_1.MigrationOperationType.ADD_COLUMN:
-                if (operation.table && ((_b = operation.params) === null || _b === void 0 ? void 0 : _b.column)) {
-                    const col = operation.params.column;
-                    let def = `ALTER TABLE "${operation.table}" ADD COLUMN "${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
-                    if (!col.nullable)
-                        def += ' NOT NULL';
-                    if (col.defaultValue !== undefined) {
-                        def += ` DEFAULT ${this.escapeValue(col.defaultValue)}`;
-                    }
-                    return def;
-                }
-                return null;
-            case migration_types_1.MigrationOperationType.DROP_COLUMN:
-                return operation.table && ((_c = operation.params) === null || _c === void 0 ? void 0 : _c.columnName)
-                    ? `ALTER TABLE "${operation.table}" DROP COLUMN "${operation.params.columnName}"`
-                    : null;
-            case migration_types_1.MigrationOperationType.MODIFY_COLUMN:
-                if (operation.table && ((_d = operation.params) === null || _d === void 0 ? void 0 : _d.column)) {
-                    const col = operation.params.column;
-                    return `ALTER TABLE "${operation.table}" ALTER COLUMN "${col.name}" TYPE ${this.mapColumnTypeToPostgreSQL(col.type)}`;
-                }
-                return null;
-            case migration_types_1.MigrationOperationType.RENAME_COLUMN:
-                return operation.table && ((_e = operation.params) === null || _e === void 0 ? void 0 : _e.oldName) && ((_f = operation.params) === null || _f === void 0 ? void 0 : _f.newName)
-                    ? `ALTER TABLE "${operation.table}" RENAME COLUMN "${operation.params.oldName}" TO "${operation.params.newName}"`
-                    : null;
-            case migration_types_1.MigrationOperationType.ADD_INDEX:
-                if (operation.table && ((_g = operation.params) === null || _g === void 0 ? void 0 : _g.indexName) && ((_h = operation.params) === null || _h === void 0 ? void 0 : _h.columns)) {
-                    const unique = operation.params.unique ? 'UNIQUE ' : '';
-                    const columns = operation.params.columns.map((col) => `"${col}"`).join(', ');
-                    return `CREATE ${unique}INDEX "${operation.params.indexName}" ON "${operation.table}" (${columns})`;
-                }
-                return null;
-            case migration_types_1.MigrationOperationType.DROP_INDEX:
-                return ((_j = operation.params) === null || _j === void 0 ? void 0 : _j.indexName)
-                    ? `DROP INDEX IF EXISTS "${operation.params.indexName}"`
-                    : null;
-            case migration_types_1.MigrationOperationType.ADD_CONSTRAINT:
-                if (operation.table && ((_k = operation.params) === null || _k === void 0 ? void 0 : _k.constraintName) && ((_l = operation.params) === null || _l === void 0 ? void 0 : _l.definition)) {
-                    return `ALTER TABLE "${operation.table}" ADD CONSTRAINT "${operation.params.constraintName}" ${operation.params.definition}`;
-                }
-                return null;
-            case migration_types_1.MigrationOperationType.DROP_CONSTRAINT:
-                return operation.table && ((_m = operation.params) === null || _m === void 0 ? void 0 : _m.constraintName)
-                    ? `ALTER TABLE "${operation.table}" DROP CONSTRAINT IF EXISTS "${operation.params.constraintName}"`
-                    : null;
-            default:
-                return null;
-        }
-    }
-    async runMigration(connection, migration, options) {
-        const startTime = Date.now();
-        const statements = [];
+    async tableExists(tableName) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            await client.query('BEGIN');
-            try {
-                // Execute migration operations
-                for (const operation of migration.up) {
-                    const sql = await this.buildMigrationOperationSQL(operation);
-                    if (sql) {
-                        statements.push(sql);
-                        await client.query(sql);
-                    }
-                }
-                // Record migration in history table
-                await this.recordMigration(client, migration, migration_types_1.MigrationDirection.UP);
-                await client.query('COMMIT');
-                return {
-                    tag: migration.tag,
-                    status: migration_types_1.MigrationStatus.COMPLETED,
-                    direction: migration_types_1.MigrationDirection.UP,
-                    executedAt: new Date(),
-                    duration: Date.now() - startTime,
-                    statements,
-                };
-            }
-            catch (error) {
-                await client.query('ROLLBACK');
-                throw error;
-            }
+            const result = await this.pool.query(`
+        SELECT EXISTS (
+          SELECT FROM pg_tables
+          WHERE schemaname = 'public' AND tablename = $1
+        )
+      `, [tableName]);
+            return result.rows[0].exists;
         }
         catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to check table existence: ${error.message}`, error);
+        }
+    }
+    async getTableSchema(tableName) {
+        this.ensureConnected();
+        try {
+            // Get columns
+            const columnsResult = await this.pool.query(`
+        SELECT
+          column_name as name,
+          data_type as type,
+          is_nullable = 'YES' as nullable,
+          column_default as default_value,
+          character_maximum_length as max_length,
+          numeric_precision as precision,
+          numeric_scale as scale
+        FROM information_schema.columns
+        WHERE table_schema = 'public' AND table_name = $1
+        ORDER BY ordinal_position
+      `, [tableName]);
+            // Get primary key
+            const pkResult = await this.pool.query(`
+        SELECT a.attname as column_name
+        FROM pg_index i
+        JOIN pg_attribute a ON a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey)
+        WHERE i.indrelid = $1::regclass AND i.indisprimary
+      `, [tableName]);
+            const primaryKey = pkResult.rows.map((r) => r.column_name);
+            // Get indexes
+            const indexes = await this.listIndexes(tableName);
+            // Get constraints
+            const constraintsResult = await this.pool.query(`
+        SELECT
+          con.conname as name,
+          CASE con.contype
+            WHEN 'p' THEN 'PRIMARY KEY'
+            WHEN 'f' THEN 'FOREIGN KEY'
+            WHEN 'u' THEN 'UNIQUE'
+            WHEN 'c' THEN 'CHECK'
+          END as type,
+          ARRAY(
+            SELECT a.attname
+            FROM unnest(con.conkey) WITH ORDINALITY AS k(key, ord)
+            JOIN pg_attribute a ON a.attnum = k.key AND a.attrelid = con.conrelid
+            ORDER BY k.ord
+          ) as columns,
+          pg_get_constraintdef(con.oid) as definition
+        FROM pg_constraint con
+        JOIN pg_namespace nsp ON nsp.oid = con.connamespace
+        WHERE con.conrelid = $1::regclass AND nsp.nspname = 'public'
+      `, [tableName]);
+            const columns = columnsResult.rows.map((col) => {
+                var _a;
+                return ({
+                    name: col.name,
+                    type: col.type,
+                    nullable: col.nullable,
+                    defaultValue: col.default_value,
+                    isPrimaryKey: primaryKey.includes(col.name),
+                    isUnique: false, // Would need additional query
+                    isAutoIncrement: (_a = col.default_value) === null || _a === void 0 ? void 0 : _a.includes('nextval'),
+                    maxLength: col.max_length,
+                    precision: col.precision,
+                    scale: col.scale,
+                });
+            });
+            const constraints = constraintsResult.rows.map((c) => ({
+                name: c.name,
+                type: c.type,
+                columns: c.columns,
+                expression: c.definition,
+            }));
             return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.FAILED,
-                direction: migration_types_1.MigrationDirection.UP,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                error: error.message,
-                statements,
+                name: tableName,
+                schema: 'public',
+                columns,
+                indexes,
+                constraints,
+                primaryKey: primaryKey.length > 0 ? primaryKey : undefined,
             };
         }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get table schema: ${error.message}`, error);
+        }
     }
-    async rollbackMigration(connection, migration, options) {
-        const startTime = Date.now();
-        const statements = [];
+    async createIndex(index, ifNotExists, concurrent) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            await client.query('BEGIN');
-            try {
-                // Execute rollback operations
-                for (const operation of migration.down) {
-                    const sql = await this.buildMigrationOperationSQL(operation);
-                    if (sql) {
-                        statements.push(sql);
-                        await client.query(sql);
-                    }
-                }
-                // Remove migration from history table
-                await this.removeMigration(client, migration.tag);
-                await client.query('COMMIT');
-                return {
-                    tag: migration.tag,
-                    status: migration_types_1.MigrationStatus.ROLLED_BACK,
-                    direction: migration_types_1.MigrationDirection.DOWN,
-                    executedAt: new Date(),
-                    duration: Date.now() - startTime,
-                    statements,
-                };
+            let sql = 'CREATE';
+            if (index.unique)
+                sql += ' UNIQUE';
+            sql += ' INDEX';
+            if (concurrent)
+                sql += ' CONCURRENTLY';
+            if (ifNotExists)
+                sql += ' IF NOT EXISTS';
+            sql += ` ${this.escapeIdentifier(index.name)} ON ${this.escapeIdentifier(index.table)}`;
+            // Add index method
+            if (index.method) {
+                sql += ` USING ${index.method}`;
+            }
+            // Add columns
+            const columnDefs = index.columns.map(col => {
+                let def = this.escapeIdentifier(col.name);
+                if (col.order)
+                    def += ` ${col.order}`;
+                if (col.nulls)
+                    def += ` NULLS ${col.nulls}`;
+                if (col.opclass)
+                    def += ` ${col.opclass}`;
+                return def;
+            }).join(', ');
+            sql += ` (${columnDefs})`;
+            // Add include columns (covering index)
+            if (index.include && index.include.length > 0) {
+                sql += ` INCLUDE (${index.include.map(c => this.escapeIdentifier(c)).join(', ')})`;
             }
-            catch (error) {
-                await client.query('ROLLBACK');
-                throw error;
+            // Add partial index condition
+            if (index.where) {
+                sql += ` WHERE ${index.where}`;
+            }
+            await this.pool.query(sql);
+            // Add comment
+            if (index.comment) {
+                await this.pool.query(`COMMENT ON INDEX ${this.escapeIdentifier(index.name)} IS ${this.escapeValue(index.comment)}`);
             }
         }
         catch (error) {
-            return {
-                tag: migration.tag,
-                status: migration_types_1.MigrationStatus.FAILED,
-                direction: migration_types_1.MigrationDirection.DOWN,
-                executedAt: new Date(),
-                duration: Date.now() - startTime,
-                error: error.message,
-                statements,
-            };
+            throw database_error_1.DatabaseError.schemaError(`Failed to create index: ${error.message}`, error);
         }
     }
-    async getMigrationHistory(connection, options) {
+    async dropIndex(tableName, indexName, ifExists, concurrent, cascade) {
+        this.ensureConnected();
         try {
-            const client = connection.getClient();
-            // Ensure migration table exists
-            await this.ensureMigrationTable(client);
-            const query = `
-        SELECT tag, name, executed_at
-        FROM _ductape_migrations
-        ORDER BY executed_at DESC
+            let sql = 'DROP INDEX';
+            if (concurrent)
+                sql += ' CONCURRENTLY';
+            if (ifExists)
+                sql += ' IF EXISTS';
+            sql += ` ${this.escapeIdentifier(indexName)}`;
+            if (cascade)
+                sql += ' CASCADE';
+            await this.pool.query(sql);
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to drop index: ${error.message}`, error);
+        }
+    }
+    async listIndexes(tableName, includeSystem) {
+        this.ensureConnected();
+        try {
+            let sql = `
+        SELECT
+          i.relname as name,
+          t.relname as table,
+          ARRAY(
+            SELECT a.attname
+            FROM unnest(ix.indkey) WITH ORDINALITY AS k(key, ord)
+            JOIN pg_attribute a ON a.attnum = k.key AND a.attrelid = ix.indrelid
+            ORDER BY k.ord
+          ) as columns,
+          ix.indisunique as unique,
+          ix.indisprimary as primary_key,
+          am.amname as type,
+          pg_relation_size(i.oid) as size,
+          pg_get_indexdef(ix.indexrelid) as definition
+        FROM pg_index ix
+        JOIN pg_class i ON i.oid = ix.indexrelid
+        JOIN pg_class t ON t.oid = ix.indrelid
+        JOIN pg_am am ON am.oid = i.relam
+        JOIN pg_namespace n ON n.oid = t.relnamespace
+        WHERE t.relname = $1 AND n.nspname = 'public'
       `;
-            const result = await client.query(query);
+            if (!includeSystem) {
+                sql += ` AND NOT i.relname LIKE 'pg_%'`;
+            }
+            const result = await this.pool.query(sql, [tableName]);
             return result.rows.map((row) => ({
-                tag: row.tag,
                 name: row.name,
-                executedAt: row.executed_at,
+                table: row.table,
+                columns: row.columns,
+                unique: row.unique,
+                primaryKey: row.primary_key,
+                type: row.type,
+                size: parseInt(row.size, 10),
             }));
         }
         catch (error) {
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.MIGRATION_ERROR, `Failed to get migration history: ${error.message}`, error);
+            throw database_error_1.DatabaseError.schemaError(`Failed to list indexes: ${error.message}`, error);
         }
     }
-    // ==================== Helper Methods ====================
-    /**
-     * Build SELECT query from options
-     */
-    buildSelectQuery(options) {
-        const params = [];
-        let paramIndex = 1;
-        // Handle includes
-        const hasIncludes = options.include && (Array.isArray(options.include) ? options.include.length > 0 : true);
-        // SELECT clause
-        let selectColumns;
-        if (options.select && options.select.length > 0) {
-            // Prefix main table columns with table name
-            selectColumns = options.select.map((col) => `"${options.table}"."${col}"`).join(', ');
-        }
-        else {
-            // Select all from main table
-            selectColumns = hasIncludes ? `"${options.table}".*` : '*';
-        }
-        // Add included relation columns
-        if (hasIncludes) {
-            const includes = Array.isArray(options.include) ? options.include : [options.include];
-            includes.forEach((include) => {
-                const relationAlias = include.relation;
-                if (include.select && include.select.length > 0) {
-                    const relationCols = include.select.map((col) => `"${relationAlias}"."${col}" as "${relationAlias}_${col}"`).join(', ');
-                    selectColumns += `, ${relationCols}`;
-                }
-                else {
-                    // Use JSON aggregation for one-to-many
-                    if (include.type === 'one-to-many') {
-                        selectColumns += `, json_agg("${relationAlias}".*) as "${relationAlias}"`;
-                    }
-                    else {
-                        selectColumns += `, row_to_json("${relationAlias}".*) as "${relationAlias}"`;
-                    }
-                }
-            });
-        }
-        let query = `SELECT ${options.distinct ? 'DISTINCT ' : ''}${selectColumns} FROM "${options.table}"`;
-        // JOIN clauses for includes
-        if (hasIncludes) {
-            const includes = Array.isArray(options.include) ? options.include : [options.include];
-            includes.forEach((include) => {
-                const { joinClause } = this.buildIncludeJoin(options.table, include);
-                query += ` ${joinClause}`;
-            });
-        }
-        // WHERE clause
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-            paramIndex += values.length;
-        }
-        // GROUP BY clause
-        if (options.groupBy && options.groupBy.length > 0) {
-            query += ` GROUP BY ${options.groupBy.map((col) => `"${col}"`).join(', ')}`;
-        }
-        else if (hasIncludes) {
-            // Auto group by main table primary key for one-to-many relations
-            const includes = Array.isArray(options.include) ? options.include : [options.include];
-            const hasOneToMany = includes.some(inc => inc.type === 'one-to-many');
-            if (hasOneToMany) {
-                query += ` GROUP BY "${options.table}"."id"`;
+    async getIndexStatistics(tableName, indexName) {
+        this.ensureConnected();
+        try {
+            let sql = `
+        SELECT
+          indexrelname as index_name,
+          relname as table_name,
+          idx_scan as scans,
+          idx_tup_read as tuples_read,
+          idx_tup_fetch as tuples_fetched,
+          pg_relation_size(indexrelid) as size_bytes,
+          pg_size_pretty(pg_relation_size(indexrelid)) as size_formatted
+        FROM pg_stat_user_indexes
+        WHERE relname = $1
+      `;
+            const params = [tableName];
+            if (indexName) {
+                sql += ` AND indexrelname = $2`;
+                params.push(indexName);
             }
+            const result = await this.pool.query(sql, params);
+            return result.rows.map((row) => ({
+                indexName: row.index_name,
+                tableName: row.table_name,
+                scans: parseInt(row.scans, 10),
+                tuplesRead: parseInt(row.tuples_read, 10),
+                tuplesFetched: parseInt(row.tuples_fetched, 10),
+                sizeBytes: parseInt(row.size_bytes, 10),
+                sizeFormatted: row.size_formatted,
+            }));
+        }
+        catch (error) {
+            throw database_error_1.DatabaseError.schemaError(`Failed to get index statistics: ${error.message}`, error);
         }
-        // HAVING clause
-        if (options.having) {
-            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
-            query += ` HAVING ${clause}`;
-            params.push(...values);
-            paramIndex += values.length;
-        }
-        // ORDER BY clause
-        if (options.orderBy) {
-            const orderByArray = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];
-            const orderClauses = orderByArray.map((order) => `"${options.table}"."${order.column}" ${order.order || 'ASC'}`);
-            query += ` ORDER BY ${orderClauses.join(', ')}`;
-        }
-        // LIMIT clause
-        if (options.limit) {
-            query += ` LIMIT $${paramIndex++}`;
-            params.push(options.limit);
-        }
-        // OFFSET clause
-        if (options.offset) {
-            query += ` OFFSET $${paramIndex++}`;
-            params.push(options.offset);
-        }
-        return { query, params };
-    }
-    /**
-     * Build JOIN clause for include relationships
-     */
-    buildIncludeJoin(mainTable, include) {
-        const relationTable = include.relation;
-        const foreignKey = include.foreignKey || `${relationTable}_id`;
-        const primaryKey = include.primaryKey || 'id';
-        const joinType = include.type === 'one-to-many' || include.type === 'one-to-one' ? 'LEFT' : 'INNER';
-        let joinClause;
-        if (include.type === 'many-to-many' && include.through) {
-            // Many-to-many with junction table
-            const throughTable = include.through;
-            const throughForeignKey = include.throughForeignKey || `${mainTable}_id`;
-            const throughRelatedKey = include.throughRelatedKey || `${relationTable}_id`;
-            joinClause = `${joinType} JOIN "${throughTable}" ON "${mainTable}"."${primaryKey}" = "${throughTable}"."${throughForeignKey}" `;
-            joinClause += `${joinType} JOIN "${relationTable}" ON "${throughTable}"."${throughRelatedKey}" = "${relationTable}"."${primaryKey}"`;
-        }
-        else if (include.type === 'one-to-many') {
-            // One-to-many: foreign key is in the related table
-            joinClause = `${joinType} JOIN "${relationTable}" ON "${mainTable}"."${primaryKey}" = "${relationTable}"."${foreignKey}"`;
-        }
-        else {
-            // Many-to-one or one-to-one: foreign key is in the main table
-            joinClause = `${joinType} JOIN "${relationTable}" ON "${mainTable}"."${foreignKey}" = "${relationTable}"."${primaryKey}"`;
-        }
-        // Add where clause for the relation if specified
-        if (include.where) {
-            const { clause } = this.buildWhereClause(include.where, 1);
-            joinClause += ` AND ${clause}`;
-        }
-        return { joinClause };
-    }
-    /**
-     * Build INSERT query from options
-     */
-    buildInsertQuery(options) {
-        const dataArray = Array.isArray(options.data) ? options.data : [options.data];
-        const columns = Object.keys(dataArray[0]);
-        const params = [];
-        let paramIndex = 1;
-        let query = `INSERT INTO "${options.table}" (${columns.map((col) => `"${col}"`).join(', ')}) VALUES `;
-        const valuesClauses = [];
-        dataArray.forEach((data) => {
-            const valuePlaceholders = columns.map(() => `$${paramIndex++}`);
-            valuesClauses.push(`(${valuePlaceholders.join(', ')})`);
-            params.push(...columns.map((col) => data[col]));
-        });
-        query += valuesClauses.join(', ');
-        if (options.returning) {
-            const returningColumns = Array.isArray(options.returning)
-                ? options.returning.map((col) => `"${col}"`).join(', ')
-                : '*';
-            query += ` RETURNING ${returningColumns}`;
-        }
-        return { query, params };
-    }
-    /**
-     * Build UPDATE query from options
-     */
-    buildUpdateQuery(options) {
-        const params = [];
-        let paramIndex = 1;
-        const setClauses = Object.keys(options.data).map((key) => {
-            params.push(options.data[key]);
-            return `"${key}" = $${paramIndex++}`;
-        });
-        let query = `UPDATE "${options.table}" SET ${setClauses.join(', ')}`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-        }
-        if (options.returning) {
-            const returningColumns = Array.isArray(options.returning)
-                ? options.returning.map((col) => `"${col}"`).join(', ')
-                : '*';
-            query += ` RETURNING ${returningColumns}`;
-        }
-        return { query, params };
     }
-    /**
-     * Build DELETE query from options
-     */
-    buildDeleteQuery(options) {
-        const params = [];
-        let paramIndex = 1;
-        let query = `DELETE FROM "${options.table}"`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-        }
-        if (options.returning) {
-            const returningColumns = Array.isArray(options.returning)
-                ? options.returning.map((col) => `"${col}"`).join(', ')
-                : '*';
-            query += ` RETURNING ${returningColumns}`;
-        }
-        return { query, params };
+    // ==================== UTILITY METHODS ====================
+    escapeIdentifier(identifier) {
+        // PostgreSQL uses double quotes for identifiers
+        return `"${identifier.replace(/"/g, '""')}"`;
     }
-    /**
-     * Build UPSERT (INSERT ... ON CONFLICT) query from options
-     */
-    buildUpsertQuery(options) {
-        // Upsert only works with single records
-        const data = Array.isArray(options.data) ? options.data[0] : options.data;
-        const columns = Object.keys(data);
-        const params = [];
-        let paramIndex = 1;
-        let query = `INSERT INTO "${options.table}" (${columns.map((col) => `"${col}"`).join(', ')}) VALUES (`;
-        query += columns.map(() => `$${paramIndex++}`).join(', ');
-        params.push(...columns.map((col) => data[col]));
-        query += `) ON CONFLICT (${options.uniqueColumns.map((col) => `"${col}"`).join(', ')}) DO UPDATE SET `;
-        const updateClauses = columns
-            .filter((col) => !options.uniqueColumns.includes(col))
-            .map((col) => `"${col}" = EXCLUDED."${col}"`);
-        query += updateClauses.join(', ');
-        if (options.returning) {
-            const returningColumns = Array.isArray(options.returning)
-                ? options.returning.map((col) => `"${col}"`).join(', ')
-                : '*';
-            query += ` RETURNING ${returningColumns}`;
-        }
-        return { query, params };
+    escapeValue(value) {
+        if (value === null || value === undefined) {
+            return 'NULL';
+        }
+        if (typeof value === 'number') {
+            return String(value);
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        if (typeof value === 'object') {
+            return `'${JSON.stringify(value).replace(/'/g, "''")}'::jsonb`;
+        }
+        // String - escape single quotes
+        return `'${String(value).replace(/'/g, "''")}'`;
     }
     /**
-     * Build COUNT query from options
+     * Check if value is an update operator object
      */
-    buildCountQuery(options) {
-        const params = [];
-        let paramIndex = 1;
-        const column = options.column || '*';
-        let query = `SELECT COUNT(${column === '*' ? '*' : `"${column}"`}) as count FROM "${options.table}"`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-        }
-        return { query, params };
+    isUpdateOperator(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const operators = ['$INC', '$DEC', '$MUL', '$MIN', '$MAX', '$SET', '$UNSET', '$PUSH', '$PULL', '$ADDTOSET'];
+        return operators.some(op => op in value);
     }
-    /**
-     * Build aggregate query (SUM, AVG, MIN, MAX)
-     */
-    buildAggregateQuery(func, column, options) {
-        const params = [];
-        let paramIndex = 1;
-        let query = `SELECT ${func}("${column}") as result FROM "${options.table}"`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-        }
-        return { query, params };
+    getParameterPlaceholder(index) {
+        // PostgreSQL uses $1, $2, $3, etc.
+        return `$${index}`;
     }
-    /**
-     * Build GROUP BY query
-     */
-    buildGroupByQuery(options) {
-        const params = [];
-        let paramIndex = 1;
-        const groupColumns = options.groupBy.map((col) => `"${col}"`);
-        const selectColumns = [...groupColumns];
-        // Build aggregations
-        if (options.aggregate) {
-            Object.entries(options.aggregate).forEach(([alias, agg]) => {
-                const aggObj = agg;
-                if (aggObj.$COUNT !== undefined) {
-                    const column = aggObj.$COUNT === '*' ? '*' : `"${aggObj.$COUNT}"`;
-                    selectColumns.push(`COUNT(${column}) AS "${alias}"`);
-                }
-                else if (aggObj.$SUM !== undefined) {
-                    selectColumns.push(`SUM("${aggObj.$SUM}") AS "${alias}"`);
-                }
-                else if (aggObj.$AVG !== undefined) {
-                    selectColumns.push(`AVG("${aggObj.$AVG}") AS "${alias}"`);
-                }
-                else if (aggObj.$MIN !== undefined) {
-                    selectColumns.push(`MIN("${aggObj.$MIN}") AS "${alias}"`);
-                }
-                else if (aggObj.$MAX !== undefined) {
-                    selectColumns.push(`MAX("${aggObj.$MAX}") AS "${alias}"`);
-                }
-                else if (aggObj.$STRING_AGG !== undefined) {
-                    selectColumns.push(`STRING_AGG("${aggObj.$STRING_AGG}", ', ') AS "${alias}"`);
-                }
-                else if (aggObj.$ARRAY_AGG !== undefined) {
-                    selectColumns.push(`ARRAY_AGG("${aggObj.$ARRAY_AGG}") AS "${alias}"`);
+    getColumnTypeString(columnType, options) {
+        const typeMap = {
+            [enums_1.ColumnType.INTEGER]: 'INTEGER',
+            [enums_1.ColumnType.BIGINT]: 'BIGINT',
+            [enums_1.ColumnType.SMALLINT]: 'SMALLINT',
+            [enums_1.ColumnType.FLOAT]: 'REAL',
+            [enums_1.ColumnType.DOUBLE]: 'DOUBLE PRECISION',
+            [enums_1.ColumnType.DECIMAL]: (options === null || options === void 0 ? void 0 : options.precision)
+                ? `NUMERIC(${options.precision}${options.scale ? `, ${options.scale}` : ''})`
+                : 'NUMERIC',
+            [enums_1.ColumnType.STRING]: (options === null || options === void 0 ? void 0 : options.maxLength) ? `VARCHAR(${options.maxLength})` : 'VARCHAR(255)',
+            [enums_1.ColumnType.TEXT]: 'TEXT',
+            [enums_1.ColumnType.BOOLEAN]: 'BOOLEAN',
+            [enums_1.ColumnType.DATE]: 'DATE',
+            [enums_1.ColumnType.DATETIME]: 'TIMESTAMP',
+            [enums_1.ColumnType.TIMESTAMP]: 'TIMESTAMP WITH TIME ZONE',
+            [enums_1.ColumnType.TIME]: 'TIME',
+            [enums_1.ColumnType.JSON]: 'JSON',
+            [enums_1.ColumnType.JSONB]: 'JSONB',
+            [enums_1.ColumnType.UUID]: 'UUID',
+            [enums_1.ColumnType.BINARY]: 'BYTEA',
+            // ENUM type - returns VARCHAR, CHECK constraint is added in buildColumnDefinition
+            [enums_1.ColumnType.ENUM]: 'VARCHAR(255)',
+            [enums_1.ColumnType.ARRAY]: (options === null || options === void 0 ? void 0 : options.arrayType) ? `${options.arrayType}[]` : 'TEXT[]',
+        };
+        return typeMap[columnType] || columnType;
+    }
+    getSupportedFeatures() {
+        return [
+            base_adapter_1.DatabaseFeature.TRANSACTIONS,
+            base_adapter_1.DatabaseFeature.SAVEPOINTS,
+            base_adapter_1.DatabaseFeature.JSONB,
+            base_adapter_1.DatabaseFeature.JSON,
+            base_adapter_1.DatabaseFeature.ARRAYS,
+            base_adapter_1.DatabaseFeature.UUID,
+            base_adapter_1.DatabaseFeature.FULLTEXT_SEARCH,
+            base_adapter_1.DatabaseFeature.GIN_INDEX,
+            base_adapter_1.DatabaseFeature.GIST_INDEX,
+            base_adapter_1.DatabaseFeature.HASH_INDEX,
+            base_adapter_1.DatabaseFeature.PARTIAL_INDEX,
+            base_adapter_1.DatabaseFeature.COVERING_INDEX,
+            base_adapter_1.DatabaseFeature.CONCURRENT_INDEX,
+            base_adapter_1.DatabaseFeature.CTE,
+            base_adapter_1.DatabaseFeature.WINDOW_FUNCTIONS,
+            base_adapter_1.DatabaseFeature.RETURNING,
+            base_adapter_1.DatabaseFeature.UPSERT,
+            base_adapter_1.DatabaseFeature.FOREIGN_KEYS,
+            base_adapter_1.DatabaseFeature.CHECK_CONSTRAINTS,
+            base_adapter_1.DatabaseFeature.STORED_PROCEDURES,
+            base_adapter_1.DatabaseFeature.VIEWS,
+            base_adapter_1.DatabaseFeature.MATERIALIZED_VIEWS,
+            base_adapter_1.DatabaseFeature.TRIGGERS,
+            base_adapter_1.DatabaseFeature.SCHEMAS,
+            base_adapter_1.DatabaseFeature.TABLE_INHERITANCE,
+            base_adapter_1.DatabaseFeature.LIKE,
+            base_adapter_1.DatabaseFeature.ILIKE,
+            base_adapter_1.DatabaseFeature.REGEX,
+            base_adapter_1.DatabaseFeature.BETWEEN,
+            base_adapter_1.DatabaseFeature.ARRAY_CONTAINS,
+            base_adapter_1.DatabaseFeature.LIMIT_OFFSET,
+        ];
+    }
+    parseError(error) {
+        const code = error.code;
+        let type = enums_1.DatabaseErrorType.UNKNOWN_ERROR;
+        // Map PostgreSQL error codes
+        switch (code) {
+            case '23505':
+                type = enums_1.DatabaseErrorType.UNIQUE_VIOLATION;
+                break;
+            case '23503':
+                type = enums_1.DatabaseErrorType.FOREIGN_KEY_VIOLATION;
+                break;
+            case '23502':
+                type = enums_1.DatabaseErrorType.NOT_NULL_VIOLATION;
+                break;
+            case '23514':
+                type = enums_1.DatabaseErrorType.CHECK_VIOLATION;
+                break;
+            case '08000':
+            case '08003':
+            case '08006':
+                type = enums_1.DatabaseErrorType.CONNECTION_ERROR;
+                break;
+            case '42P01':
+            case '42703':
+                type = enums_1.DatabaseErrorType.SCHEMA_ERROR;
+                break;
+            case '28000':
+            case '28P01':
+                type = enums_1.DatabaseErrorType.AUTHENTICATION_ERROR;
+                break;
+            default:
+                if (code === null || code === void 0 ? void 0 : code.startsWith('42')) {
+                    type = enums_1.DatabaseErrorType.QUERY_ERROR;
                 }
-            });
         }
-        let query = `SELECT ${selectColumns.join(', ')} FROM "${options.table}"`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-            paramIndex += values.length;
-        }
-        query += ` GROUP BY ${groupColumns.join(', ')}`;
-        if (options.having) {
-            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
-            query += ` HAVING ${clause}`;
-            params.push(...values);
+        return {
+            type,
+            message: error.message || 'Unknown database error',
+            code,
+            details: {
+                constraint: error.constraint,
+                table: error.table,
+                column: error.column,
+                detail: error.detail,
+                hint: error.hint,
+            },
+        };
+    }
+    // ==================== PRIVATE HELPER METHODS ====================
+    ensureConnected() {
+        if (!this.connected || !this.pool) {
+            throw new database_error_1.DatabaseError('Not connected to PostgreSQL database', enums_1.DatabaseErrorType.CONNECTION_ERROR);
         }
-        return { query, params };
     }
-    /**
-     * Build multi-aggregate query
-     */
-    buildMultiAggregateQuery(options) {
+    buildWhereClause(where, startIndex) {
+        const clauses = [];
         const params = [];
-        let paramIndex = 1;
-        const aggregations = Object.entries(options.operations).map(([alias, agg]) => {
-            const aggObj = agg;
-            if (aggObj.$COUNT !== undefined) {
-                const column = aggObj.$COUNT === '*' ? '*' : `"${aggObj.$COUNT}"`;
-                return `COUNT(${column}) AS "${alias}"`;
-            }
-            if (aggObj.$SUM !== undefined) {
-                return `SUM("${aggObj.$SUM}") AS "${alias}"`;
-            }
-            if (aggObj.$AVG !== undefined) {
-                return `AVG("${aggObj.$AVG}") AS "${alias}"`;
-            }
-            if (aggObj.$MIN !== undefined) {
-                return `MIN("${aggObj.$MIN}") AS "${alias}"`;
-            }
-            if (aggObj.$MAX !== undefined) {
-                return `MAX("${aggObj.$MAX}") AS "${alias}"`;
-            }
-            if (aggObj.$STRING_AGG !== undefined) {
-                return `STRING_AGG("${aggObj.$STRING_AGG}", ', ') AS "${alias}"`;
-            }
-            if (aggObj.$ARRAY_AGG !== undefined) {
-                return `ARRAY_AGG("${aggObj.$ARRAY_AGG}") AS "${alias}"`;
-            }
-            throw new database_types_1.DatabaseError(database_types_1.DatabaseErrorType.VALIDATION_ERROR, `Invalid aggregation operation for alias "${alias}". Use format: { $COUNT: '*' }, { $SUM: 'column' }, etc.`);
-        });
-        let query = `SELECT ${aggregations.join(', ')} FROM "${options.table}"`;
-        if (options.where) {
-            const { clause, values } = this.buildWhereClause(options.where, paramIndex);
-            query += ` WHERE ${clause}`;
-            params.push(...values);
-            paramIndex += values.length;
-        }
-        if (options.groupBy && options.groupBy.length > 0) {
-            const groupCols = options.groupBy.map(col => `"${col}"`).join(', ');
-            query += ` GROUP BY ${groupCols}`;
-        }
-        if (options.having) {
-            const { clause, values } = this.buildWhereClause(options.having, paramIndex);
-            query += ` HAVING ${clause}`;
-            params.push(...values);
-        }
-        return { query, params };
-    }
-    /**
-     * Build WHERE clause from WhereClause object
-     * Supports both simplified syntax (GT, LT, AND, OR) and legacy syntax ($gt, $lt, $and, $or)
-     */
-    buildWhereClause(where, startIndex = 1) {
-        const values = [];
         let paramIndex = startIndex;
-        const buildCondition = (condition) => {
-            if (typeof condition !== 'object' || condition === null) {
-                values.push(condition);
-                return `$${paramIndex++}`;
+        for (const [key, value] of Object.entries(where)) {
+            if (key === '$AND') {
+                const andResult = this.buildWhereClause(value, paramIndex);
+                clauses.push(`(${andResult.whereClause})`);
+                params.push(...andResult.whereParams);
+                paramIndex += andResult.whereParams.length;
             }
-            // Handle logical operators (supports $AND, AND, and legacy $and)
-            if (condition.$AND || condition.AND || condition.$and) {
-                const andConditions = condition.$AND || condition.AND || condition.$and;
-                if (typeof andConditions === 'object' && !Array.isArray(andConditions)) {
-                    // New syntax: { $AND: { col1: val1, col2: val2 } }
-                    return buildCondition(andConditions);
-                }
-                else {
-                    // Legacy syntax: { $and: [cond1, cond2] }
-                    const subConditions = andConditions.map(buildCondition);
-                    return `(${subConditions.join(' AND ')})`;
+            else if (key === '$OR') {
+                const orClauses = [];
+                for (const [orKey, orValue] of Object.entries(value)) {
+                    const orResult = this.buildWhereClause({ [orKey]: orValue }, paramIndex);
+                    orClauses.push(orResult.whereClause);
+                    params.push(...orResult.whereParams);
+                    paramIndex += orResult.whereParams.length;
                 }
+                clauses.push(`(${orClauses.join(' OR ')})`);
             }
-            if (condition.$OR || condition.OR || condition.$or) {
-                const orConditions = condition.$OR || condition.OR || condition.$or;
-                if (typeof orConditions === 'object' && !Array.isArray(orConditions)) {
-                    // New syntax: { $OR: { col1: val1, col2: val2 } }
-                    const subClauses = [];
-                    for (const [key, value] of Object.entries(orConditions)) {
-                        if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
-                            subClauses.push(buildCondition({ [key]: value }));
-                        }
-                        else {
-                            subClauses.push(buildCondition({ [key]: value }));
-                        }
+            else if (value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)) {
+                // Handle operators
+                for (const [op, opValue] of Object.entries(value)) {
+                    switch (op) {
+                        case '$EQ':
+                            clauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$NE':
+                        case '$NOT':
+                            clauses.push(`${this.escapeIdentifier(key)} != $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$GT':
+                            clauses.push(`${this.escapeIdentifier(key)} > $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$GTE':
+                            clauses.push(`${this.escapeIdentifier(key)} >= $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$LT':
+                            clauses.push(`${this.escapeIdentifier(key)} < $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$LTE':
+                            clauses.push(`${this.escapeIdentifier(key)} <= $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$IN':
+                            clauses.push(`${this.escapeIdentifier(key)} = ANY($${paramIndex})`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$NOT_IN':
+                            clauses.push(`${this.escapeIdentifier(key)} != ALL($${paramIndex})`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$LIKE':
+                            clauses.push(`${this.escapeIdentifier(key)} LIKE $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$ILIKE':
+                            clauses.push(`${this.escapeIdentifier(key)} ILIKE $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$IS_NULL':
+                            clauses.push(`${this.escapeIdentifier(key)} IS ${opValue ? 'NULL' : 'NOT NULL'}`);
+                            break;
+                        case '$IS_NOT_NULL':
+                            clauses.push(`${this.escapeIdentifier(key)} IS ${opValue ? 'NOT NULL' : 'NULL'}`);
+                            break;
+                        case '$BETWEEN':
+                            const [min, max] = opValue;
+                            clauses.push(`${this.escapeIdentifier(key)} BETWEEN $${paramIndex} AND $${paramIndex + 1}`);
+                            params.push(min, max);
+                            paramIndex += 2;
+                            break;
+                        case '$CONTAINS':
+                            clauses.push(`${this.escapeIdentifier(key)} @> $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$CONTAINED_BY':
+                            clauses.push(`${this.escapeIdentifier(key)} <@ $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
+                        case '$OVERLAPS':
+                            clauses.push(`${this.escapeIdentifier(key)} && $${paramIndex}`);
+                            params.push(opValue);
+                            paramIndex++;
+                            break;
                     }
-                    return `(${subClauses.join(' OR ')})`;
-                }
-                else {
-                    // Legacy syntax: { $or: [cond1, cond2] }
-                    const subConditions = orConditions.map(buildCondition);
-                    return `(${subConditions.join(' OR ')})`;
                 }
             }
-            // Handle column conditions
-            const conditions = [];
-            for (const [key, value] of Object.entries(condition)) {
-                // Skip logical operators
-                if (key === '$AND' || key === 'AND' || key === '$and' || key === '$OR' || key === 'OR' || key === '$or') {
-                    continue;
-                }
-                if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-                    // Handle comparison operators
-                    for (const [op, opValue] of Object.entries(value)) {
-                        switch (op) {
-                            // Preferred $-prefixed syntax
-                            case '$GT':
-                            case 'GT':
-                            case '$gt':
-                                values.push(opValue);
-                                conditions.push(`"${key}" > $${paramIndex++}`);
-                                break;
-                            case '$GTE':
-                            case 'GTE':
-                            case '$gte':
-                                values.push(opValue);
-                                conditions.push(`"${key}" >= $${paramIndex++}`);
-                                break;
-                            case '$LT':
-                            case 'LT':
-                            case '$lt':
-                                values.push(opValue);
-                                conditions.push(`"${key}" < $${paramIndex++}`);
-                                break;
-                            case '$LTE':
-                            case 'LTE':
-                            case '$lte':
-                                values.push(opValue);
-                                conditions.push(`"${key}" <= $${paramIndex++}`);
-                                break;
-                            case '$NE':
-                            case '$NOT':
-                            case 'NE':
-                            case 'NOT':
-                            case '$ne':
-                                values.push(opValue);
-                                conditions.push(`"${key}" != $${paramIndex++}`);
-                                break;
-                            case '$IN':
-                            case 'IN':
-                            case '$in':
-                                values.push(opValue);
-                                conditions.push(`"${key}" = ANY($${paramIndex++})`);
-                                break;
-                            case '$NOT_IN':
-                            case 'NOT_IN':
-                            case '$nin':
-                                values.push(opValue);
-                                conditions.push(`"${key}" != ANY($${paramIndex++})`);
-                                break;
-                            case '$LIKE':
-                            case 'LIKE':
-                            case '$like':
-                                values.push(opValue);
-                                conditions.push(`"${key}" LIKE $${paramIndex++}`);
-                                break;
-                            case '$ILIKE':
-                            case 'ILIKE':
-                            case '$ilike':
-                                values.push(opValue);
-                                conditions.push(`"${key}" ILIKE $${paramIndex++}`);
-                                break;
-                            case '$IS_NULL':
-                            case 'IS_NULL':
-                            case '$null':
-                                conditions.push(`"${key}" IS NULL`);
-                                break;
-                            case '$IS_NOT_NULL':
-                            case 'IS_NOT_NULL':
-                            case '$notNull':
-                                conditions.push(`"${key}" IS NOT NULL`);
-                                break;
-                            case '$BETWEEN':
-                            case 'BETWEEN':
-                            case '$between':
-                                if (Array.isArray(opValue) && opValue.length === 2) {
-                                    values.push(opValue[0], opValue[1]);
-                                    conditions.push(`"${key}" BETWEEN $${paramIndex++} AND $${paramIndex++}`);
-                                }
-                                break;
-                        }
-                    }
-                }
-                else {
-                    // Simple equality
-                    values.push(value);
-                    conditions.push(`"${key}" = $${paramIndex++}`);
-                }
+            else {
+                // Simple equality
+                clauses.push(`${this.escapeIdentifier(key)} = $${paramIndex}`);
+                params.push(value);
+                paramIndex++;
             }
-            return conditions.join(' AND ');
+        }
+        return {
+            whereClause: clauses.join(' AND '),
+            whereParams: params,
         };
-        const clause = buildCondition(where);
-        return { clause, values };
     }
-    /**
-     * Build CREATE TABLE query
-     */
-    buildCreateTableQuery(schema, options) {
-        const columnDefs = schema.columns.map((col) => {
-            let def = `"${col.name}" ${this.mapColumnTypeToPostgreSQL(col.type)}`;
-            if (col.length) {
-                def += `(${col.length})`;
-            }
-            else if (col.precision && col.scale) {
-                def += `(${col.precision}, ${col.scale})`;
-            }
-            else if (col.precision) {
-                def += `(${col.precision})`;
-            }
-            if (col.primaryKey) {
-                def += ' PRIMARY KEY';
-            }
-            if (col.unique) {
-                def += ' UNIQUE';
-            }
-            if (!col.nullable && !col.primaryKey) {
-                def += ' NOT NULL';
-            }
-            if (col.defaultValue !== undefined) {
-                def += ` DEFAULT ${col.defaultValue}`;
-            }
-            if (col.autoIncrement) {
-                def = `"${col.name}" SERIAL PRIMARY KEY`;
-            }
+    buildCountQuery(query) {
+        // Build a COUNT query from the original query
+        const fromIndex = query.sql.toUpperCase().indexOf('FROM');
+        const orderByIndex = query.sql.toUpperCase().indexOf('ORDER BY');
+        const limitIndex = query.sql.toUpperCase().indexOf('LIMIT');
+        let endIndex = query.sql.length;
+        if (orderByIndex > 0)
+            endIndex = Math.min(endIndex, orderByIndex);
+        if (limitIndex > 0)
+            endIndex = Math.min(endIndex, limitIndex);
+        return `SELECT COUNT(*) as count ${query.sql.substring(fromIndex, endIndex)}`;
+    }
+    buildColumnDefinition(column) {
+        let def = `${this.escapeIdentifier(column.name)} ${this.getColumnTypeString(column.type, column)}`;
+        if (column.primaryKey) {
+            def += ' PRIMARY KEY';
+        }
+        if (column.autoIncrement) {
+            // PostgreSQL uses SERIAL/BIGSERIAL
+            def = `${this.escapeIdentifier(column.name)} ${column.type === enums_1.ColumnType.BIGINT ? 'BIGSERIAL' : 'SERIAL'} PRIMARY KEY`;
             return def;
-        });
-        let query = `CREATE TABLE ${(options === null || options === void 0 ? void 0 : options.ifNotExists) ? 'IF NOT EXISTS ' : ''}"${schema.name}" (${columnDefs.join(', ')})`;
-        return query;
-    }
-    /**
-     * Build ALTER TABLE queries
-     */
-    buildAlterTableQueries(tableName, alterations) {
-        return alterations.map((alt) => {
-            let query = `ALTER TABLE "${tableName}" `;
-            switch (alt.type) {
-                case schema_types_1.ColumnAlterationType.ADD:
-                    query += `ADD COLUMN "${alt.column.name}" ${this.mapColumnTypeToPostgreSQL(alt.column.type)}`;
-                    if (!alt.column.nullable) {
-                        query += ' NOT NULL';
-                    }
-                    break;
-                case schema_types_1.ColumnAlterationType.DROP:
-                    query += `DROP COLUMN "${alt.oldName}"`;
-                    break;
-                case schema_types_1.ColumnAlterationType.MODIFY:
-                    query += `ALTER COLUMN "${alt.column.name}" TYPE ${this.mapColumnTypeToPostgreSQL(alt.column.type)}`;
-                    break;
-                case schema_types_1.ColumnAlterationType.RENAME:
-                    query += `RENAME COLUMN "${alt.oldName}" TO "${alt.newName}"`;
-                    break;
-            }
-            return query;
-        });
-    }
-    /**
-     * Build CREATE INDEX query
-     */
-    buildCreateIndexQuery(options) {
-        const unique = options.index.unique ? 'UNIQUE ' : '';
-        const columns = options.index.columns.map((col) => `"${col.name}"`).join(', ');
-        return `CREATE ${unique}INDEX ${options.ifNotExists ? 'IF NOT EXISTS ' : ''}"${options.index.name}" ON "${options.table}" (${columns})`;
-    }
-    /**
-     * Map ColumnType to PostgreSQL type
-     */
-    mapColumnTypeToPostgreSQL(type) {
-        const typeMap = {
-            [schema_types_1.ColumnType.STRING]: 'VARCHAR',
-            [schema_types_1.ColumnType.TEXT]: 'TEXT',
-            [schema_types_1.ColumnType.VARCHAR]: 'VARCHAR',
-            [schema_types_1.ColumnType.CHAR]: 'CHAR',
-            [schema_types_1.ColumnType.INTEGER]: 'INTEGER',
-            [schema_types_1.ColumnType.BIGINT]: 'BIGINT',
-            [schema_types_1.ColumnType.SMALLINT]: 'SMALLINT',
-            [schema_types_1.ColumnType.DECIMAL]: 'DECIMAL',
-            [schema_types_1.ColumnType.NUMERIC]: 'NUMERIC',
-            [schema_types_1.ColumnType.FLOAT]: 'REAL',
-            [schema_types_1.ColumnType.DOUBLE]: 'DOUBLE PRECISION',
-            [schema_types_1.ColumnType.REAL]: 'REAL',
-            [schema_types_1.ColumnType.BOOLEAN]: 'BOOLEAN',
-            [schema_types_1.ColumnType.DATE]: 'DATE',
-            [schema_types_1.ColumnType.TIME]: 'TIME',
-            [schema_types_1.ColumnType.DATETIME]: 'TIMESTAMP',
-            [schema_types_1.ColumnType.TIMESTAMP]: 'TIMESTAMP',
-            [schema_types_1.ColumnType.JSON]: 'JSONB',
-            [schema_types_1.ColumnType.JSONB]: 'JSONB',
-            [schema_types_1.ColumnType.UUID]: 'UUID',
-            [schema_types_1.ColumnType.BLOB]: 'BYTEA',
-            [schema_types_1.ColumnType.BINARY]: 'BYTEA',
-            [schema_types_1.ColumnType.ARRAY]: 'ARRAY',
-            [schema_types_1.ColumnType.OBJECT]: 'JSONB',
-            [schema_types_1.ColumnType.ENUM]: 'VARCHAR',
-        };
-        return typeMap[type] || 'TEXT';
-    }
-    /**
-     * Map PostgreSQL type to ColumnType
-     */
-    mapPostgreSQLTypeToColumnType(pgType) {
-        const typeMap = {
-            'character varying': schema_types_1.ColumnType.VARCHAR,
-            varchar: schema_types_1.ColumnType.VARCHAR,
-            text: schema_types_1.ColumnType.TEXT,
-            character: schema_types_1.ColumnType.CHAR,
-            char: schema_types_1.ColumnType.CHAR,
-            integer: schema_types_1.ColumnType.INTEGER,
-            bigint: schema_types_1.ColumnType.BIGINT,
-            smallint: schema_types_1.ColumnType.SMALLINT,
-            decimal: schema_types_1.ColumnType.DECIMAL,
-            numeric: schema_types_1.ColumnType.NUMERIC,
-            real: schema_types_1.ColumnType.FLOAT,
-            'double precision': schema_types_1.ColumnType.DOUBLE,
-            boolean: schema_types_1.ColumnType.BOOLEAN,
-            date: schema_types_1.ColumnType.DATE,
-            time: schema_types_1.ColumnType.TIME,
-            timestamp: schema_types_1.ColumnType.TIMESTAMP,
-            'timestamp without time zone': schema_types_1.ColumnType.TIMESTAMP,
-            jsonb: schema_types_1.ColumnType.JSONB,
-            json: schema_types_1.ColumnType.JSON,
-            uuid: schema_types_1.ColumnType.UUID,
-            bytea: schema_types_1.ColumnType.BINARY,
-        };
-        return typeMap[pgType.toLowerCase()] || schema_types_1.ColumnType.TEXT;
-    }
-    /**
-     * Ensure migration table exists
-     */
-    async ensureMigrationTable(client) {
-        const query = `
-      CREATE TABLE IF NOT EXISTS _ductape_migrations (
-        tag VARCHAR(255) PRIMARY KEY,
-        name VARCHAR(255) NOT NULL,
-        executed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-      )
-    `;
-        await client.query(query);
-    }
-    /**
-     * Record migration execution
-     */
-    async recordMigration(client, migration, direction) {
-        await this.ensureMigrationTable(client);
-        const query = `
-      INSERT INTO _ductape_migrations (tag, name, executed_at)
-      VALUES ($1, $2, CURRENT_TIMESTAMP)
-      ON CONFLICT (tag) DO UPDATE SET executed_at = CURRENT_TIMESTAMP
-    `;
-        await client.query(query, [migration.tag, migration.name]);
-    }
-    /**
-     * Remove migration from history
-     */
-    async removeMigration(client, tag) {
-        await this.ensureMigrationTable(client);
-        const query = `DELETE FROM _ductape_migrations WHERE tag = $1`;
-        await client.query(query, [tag]);
-    }
-    // ==================== Utility Methods ====================
-    /**
-     * Escape identifier (table/column name)
-     */
-    escapeIdentifier(identifier) {
-        return `"${identifier.replace(/"/g, '""')}"`;
-    }
-    /**
-     * Escape value for SQL
-     */
-    escapeValue(value) {
-        if (value === null || value === undefined) {
-            return 'NULL';
         }
-        if (typeof value === 'string') {
-            return `'${value.replace(/'/g, "''")}'`;
+        if (column.nullable === false) {
+            def += ' NOT NULL';
         }
-        if (typeof value === 'boolean') {
-            return value ? 'TRUE' : 'FALSE';
-        }
-        if (value instanceof Date) {
-            return `'${value.toISOString()}'`;
+        if (column.unique) {
+            def += ' UNIQUE';
         }
-        if (Array.isArray(value)) {
-            return `ARRAY[${value.map((v) => this.escapeValue(v)).join(', ')}]`;
+        if (column.defaultValue !== undefined) {
+            def += ` DEFAULT ${this.escapeValue(column.defaultValue)}`;
         }
-        if (typeof value === 'object') {
-            return `'${JSON.stringify(value)}'::jsonb`;
-        }
-        return String(value);
-    }
-    /**
-     * Get database version
-     */
-    async getDatabaseVersion(connection) {
-        var _a;
-        try {
-            const pool = connection.getClient();
-            const result = await pool.query('SELECT version()');
-            return ((_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.version) || 'Unknown';
+        if (column.references) {
+            def += ` REFERENCES ${this.escapeIdentifier(column.references.table)}(${this.escapeIdentifier(column.references.column)})`;
+            if (column.references.onDelete) {
+                def += ` ON DELETE ${column.references.onDelete}`;
+            }
+            if (column.references.onUpdate) {
+                def += ` ON UPDATE ${column.references.onUpdate}`;
+            }
         }
-        catch (error) {
-            return 'Unknown';
+        // Handle ENUM type with CHECK constraint
+        if (column.type === enums_1.ColumnType.ENUM && column.enumValues && column.enumValues.length > 0) {
+            const escapedValues = column.enumValues.map((v) => `'${v.replace(/'/g, "''")}'`).join(', ');
+            def += ` CHECK (${this.escapeIdentifier(column.name)} IN (${escapedValues}))`;
+        }
+        // Handle custom check constraint (but don't duplicate if we just added one for ENUM)
+        if (column.check && column.type !== enums_1.ColumnType.ENUM) {
+            def += ` CHECK (${column.check})`;
+        }
+        else if (column.check && column.type === enums_1.ColumnType.ENUM) {
+            // If ENUM has custom check, combine them
+            def = def.replace(/\)$/, ` AND ${column.check})`);
+        }
+        return def;
+    }
+    buildConstraintDefinition(constraint) {
+        let def = `CONSTRAINT ${this.escapeIdentifier(constraint.name)}`;
+        switch (constraint.type) {
+            case 'PRIMARY_KEY':
+                def += ` PRIMARY KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                break;
+            case 'UNIQUE':
+                def += ` UNIQUE (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                break;
+            case 'FOREIGN_KEY':
+                def += ` FOREIGN KEY (${constraint.columns.map((c) => this.escapeIdentifier(c)).join(', ')})`;
+                def += ` REFERENCES ${this.escapeIdentifier(constraint.references.table)}(${this.escapeIdentifier(constraint.references.column)})`;
+                if (constraint.references.onDelete) {
+                    def += ` ON DELETE ${constraint.references.onDelete}`;
+                }
+                if (constraint.references.onUpdate) {
+                    def += ` ON UPDATE ${constraint.references.onUpdate}`;
+                }
+                break;
+            case 'CHECK':
+                def += ` CHECK (${constraint.expression})`;
+                break;
+        }
+        return def;
+    }
+    mapIsolationLevel(level) {
+        switch (level) {
+            case enums_1.IsolationLevel.READ_UNCOMMITTED:
+                return 'READ UNCOMMITTED';
+            case enums_1.IsolationLevel.READ_COMMITTED:
+                return 'READ COMMITTED';
+            case enums_1.IsolationLevel.REPEATABLE_READ:
+                return 'REPEATABLE READ';
+            case enums_1.IsolationLevel.SERIALIZABLE:
+                return 'SERIALIZABLE';
+            default:
+                return 'READ COMMITTED';
         }
     }
 }