orcaq 1.0.33 → 1.1.2

package/.output/server/chunks/_/tables.factory.mjs

@@ -1,10 +1,658 @@
 import { D as DatabaseClientType } from './db-connection.mjs';
 import { c as createError } from '../nitro/nitro.mjs';
+import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
 import { Readable } from 'node:stream';
 import { to } from 'pg-copy-streams';
 import QueryStream from 'pg-query-stream';
 import { c as createDatabaseHttpError } from './error.mjs';
-import { B as BaseDomainAdapter, c as createDomainAdapter } from './create-adapter.mjs';
+import { r as resolveMetadataTypeAlias } from './type-alias.constants.mjs';
+
+var __defProp$3 = Object.defineProperty;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, key + "" , value);
+function formatBytes$1(value) {
+  const bytes = Number(value || 0);
+  return `${bytes} B`;
+}
+function escapeMySqlIdentifier(identifier) {
+  return `\`${identifier.replace(/`/g, "``")}\``;
+}
+class MysqlTableAdapter extends BaseDomainAdapter {
+  constructor(adapter, dbType) {
+    super(adapter);
+    __publicField$3(this, "dbType");
+    this.dbType = dbType;
+  }
+  static async create(params, dbType = DatabaseClientType.MYSQL) {
+    const adapter = await MysqlTableAdapter.resolveAdapter(params, dbType);
+    return new MysqlTableAdapter(adapter, dbType);
+  }
+  async getOverviewTables(schema) {
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          table_name AS name,
+          table_schema AS schema,
+          'TABLE' AS kind,
+          '' AS owner,
+          table_rows AS estimated_row,
+          CONCAT(data_length + index_length, ' B') AS total_size,
+          CONCAT(data_length, ' B') AS data_size,
+          CONCAT(index_length, ' B') AS index_size,
+          NULLIF(table_comment, '') AS comment
+        FROM information_schema.tables
+        WHERE table_schema = ?
+          AND table_type = 'BASE TABLE'
+        ORDER BY table_name
+      `,
+      [schema]
+    );
+  }
+  async getTableStructure(schema, tableName) {
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          c.column_name,
+          c.column_type AS data_type,
+          c.is_nullable,
+          c.column_default AS default_value,
+          COALESCE(
+            GROUP_CONCAT(
+              CONCAT('-> ', k.referenced_table_name, '.', k.referenced_column_name)
+              SEPARATOR '
+'
+            ),
+            ''
+          ) AS foreign_keys,
+          NULLIF(c.column_comment, '') AS column_comment,
+          MAX(rc.update_rule) AS on_update,
+          MAX(rc.delete_rule) AS on_delete
+        FROM information_schema.columns c
+        LEFT JOIN information_schema.key_column_usage k
+          ON k.table_schema = c.table_schema
+          AND k.table_name = c.table_name
+          AND k.column_name = c.column_name
+          AND k.referenced_table_name IS NOT NULL
+        LEFT JOIN information_schema.referential_constraints rc
+          ON rc.constraint_schema = k.constraint_schema
+          AND rc.constraint_name = k.constraint_name
+        WHERE c.table_schema = ?
+          AND c.table_name = ?
+        GROUP BY
+          c.column_name,
+          c.column_type,
+          c.is_nullable,
+          c.column_default,
+          c.column_comment,
+          c.ordinal_position
+        ORDER BY c.ordinal_position
+      `,
+      [schema, tableName]
+    );
+  }
+  async getTableSize(schema, tableName) {
+    const [row] = await this.adapter.rawQuery(
+      `
+        SELECT
+          (data_length + index_length) AS total_bytes,
+          data_length AS data_bytes,
+          index_length AS index_bytes
+        FROM information_schema.tables
+        WHERE table_schema = ?
+          AND table_name = ?
+        LIMIT 1
+      `,
+      [schema, tableName]
+    );
+    if (!row) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return {
+      tableSize: formatBytes$1(row.total_bytes),
+      dataSize: formatBytes$1(row.data_bytes),
+      indexSize: formatBytes$1(row.index_bytes)
+    };
+  }
+  async getTableMeta(schema, tableName) {
+    const [row] = await this.adapter.rawQuery(
+      `
+        SELECT
+          table_type,
+          engine,
+          table_rows,
+          (data_length + index_length) AS total_bytes,
+          data_length AS data_bytes,
+          index_length AS index_bytes
+        FROM information_schema.tables
+        WHERE table_schema = ?
+          AND table_name = ?
+        LIMIT 1
+      `,
+      [schema, tableName]
+    );
+    if (!row) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return {
+      type: row.table_type || row.engine || "table",
+      owner: "",
+      rowEstimate: row.table_rows || 0,
+      totalSize: formatBytes$1(row.total_bytes),
+      tableSize: formatBytes$1(row.data_bytes),
+      indexSize: formatBytes$1(row.index_bytes)
+    };
+  }
+  async getTableDdl(schema, tableName) {
+    var _a;
+    const qualifiedTable = `${escapeMySqlIdentifier(schema)}.${escapeMySqlIdentifier(tableName)}`;
+    const result = await this.adapter.rawQuery(
+      `SHOW CREATE TABLE ${qualifiedTable}`
+    );
+    const createTableStatement = (_a = result[0]) == null ? void 0 : _a["Create Table"];
+    if (!createTableStatement) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return createTableStatement;
+  }
+  async getTableIndexes(schema, tableName) {
+    const rows = await this.adapter.rawQuery(
+      `
+        SELECT
+          index_name,
+          non_unique AS is_unique,
+          CASE WHEN index_name = 'PRIMARY' THEN 1 ELSE 0 END AS is_primary,
+          index_type AS method,
+          column_name
+        FROM information_schema.statistics
+        WHERE table_schema = ?
+          AND table_name = ?
+        ORDER BY index_name, seq_in_index
+      `,
+      [schema, tableName]
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    rows.forEach((row) => {
+      const existing = grouped.get(row.index_name);
+      const definitionPart = row.column_name;
+      if (existing) {
+        existing.definition = `${existing.definition}, ${definitionPart}`;
+        return;
+      }
+      grouped.set(row.index_name, {
+        indexName: row.index_name,
+        isUnique: row.is_unique === 0,
+        isPrimary: row.is_primary === 1,
+        method: row.method,
+        definition: definitionPart
+      });
+    });
+    return Array.from(grouped.values());
+  }
+  async getTableRlsStatus() {
+    return { enabled: false };
+  }
+  async getTableRlsPolicies() {
+    return [];
+  }
+  async getTableRules() {
+    return [];
+  }
+  async getTableTriggers(schema, tableName) {
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          trigger_name AS triggerName,
+          1 AS enabled,
+          action_timing AS timing,
+          JSON_ARRAY(event_manipulation) AS events,
+          action_orientation AS orientation,
+          action_statement AS definition
+        FROM information_schema.triggers
+        WHERE trigger_schema = ?
+          AND event_object_table = ?
+        ORDER BY trigger_name
+      `,
+      [schema, tableName]
+    );
+  }
+  async executeStatements(statements) {
+    const startTime = performance.now();
+    try {
+      const data = [];
+      for (const statement of statements) {
+        const result = await this.adapter.rawOut(statement);
+        data.push({
+          query: statement,
+          affectedRows: result.rowCount || 0,
+          results: result.rows
+        });
+      }
+      return {
+        success: true,
+        data,
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error == null ? void 0 : error.message) || "Failed to execute statements",
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    }
+  }
+  async executeBulkDelete(statements) {
+    return this.executeStatements(statements);
+  }
+  async executeBulkUpdate(statements) {
+    return this.executeStatements(statements);
+  }
+  async exportTableData(schema, tableName) {
+    const qualifiedTable = `${escapeMySqlIdentifier(schema)}.${escapeMySqlIdentifier(tableName)}`;
+    return this.adapter.rawQuery(`SELECT * FROM ${qualifiedTable}`);
+  }
+}
+
+var __defProp$2 = Object.defineProperty;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "" , value);
+function formatBytes(value) {
+  return `${Number(value || 0)} B`;
+}
+function escapeOracleIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function buildQualifiedTable$1(schema, tableName) {
+  return `${escapeOracleIdentifier(schema)}.${escapeOracleIdentifier(tableName)}`;
+}
+function formatOracleType(column) {
+  if (column.data_type === "NUMBER" && column.data_precision !== null) {
+    return column.data_scale !== null ? `NUMBER(${column.data_precision}, ${column.data_scale})` : `NUMBER(${column.data_precision})`;
+  }
+  if (["VARCHAR2", "NVARCHAR2", "CHAR", "NCHAR", "RAW"].includes(
+    column.data_type
+  ) && column.data_length !== null) {
+    return `${column.data_type}(${column.data_length})`;
+  }
+  return column.data_type;
+}
+class OracleTableAdapter extends BaseDomainAdapter {
+  constructor() {
+    super(...arguments);
+    __publicField$2(this, "dbType", DatabaseClientType.ORACLE);
+  }
+  static async create(params) {
+    const adapter = await OracleTableAdapter.resolveAdapter(
+      params,
+      DatabaseClientType.ORACLE
+    );
+    return new OracleTableAdapter(adapter);
+  }
+  async getOverviewTables(schema) {
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          t.table_name AS name,
+          t.owner AS schema,
+          'TABLE' AS kind,
+          t.owner AS owner,
+          t.num_rows AS estimated_row,
+          TO_CHAR(NVL(tb.table_bytes, 0) + NVL(ix.index_bytes, 0)) || ' B' AS total_size,
+          TO_CHAR(NVL(tb.table_bytes, 0)) || ' B' AS data_size,
+          TO_CHAR(NVL(ix.index_bytes, 0)) || ' B' AS index_size,
+          c.comments AS comment
+        FROM all_tables t
+        LEFT JOIN (
+          SELECT owner, segment_name, SUM(bytes) AS table_bytes
+          FROM all_segments
+          WHERE segment_type LIKE 'TABLE%'
+          GROUP BY owner, segment_name
+        ) tb
+          ON tb.owner = t.owner
+          AND tb.segment_name = t.table_name
+        LEFT JOIN (
+          SELECT ai.table_owner AS owner, ai.table_name, SUM(NVL(s.bytes, 0)) AS index_bytes
+          FROM all_indexes ai
+          LEFT JOIN all_segments s
+            ON s.owner = ai.owner
+            AND s.segment_name = ai.index_name
+          GROUP BY ai.table_owner, ai.table_name
+        ) ix
+          ON ix.owner = t.owner
+          AND ix.table_name = t.table_name
+        LEFT JOIN all_tab_comments c
+          ON c.owner = t.owner
+          AND c.table_name = t.table_name
+        WHERE t.owner = :1
+        ORDER BY t.table_name
+      `,
+      [schema]
+    );
+  }
+  async getForeignKeyConstraints(schema, tableName) {
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          ac.constraint_name,
+          acc.column_name,
+          r_acc.owner AS referenced_owner,
+          r_acc.table_name AS referenced_table_name,
+          r_acc.column_name AS referenced_column_name,
+          ac.delete_rule
+        FROM all_constraints ac
+        JOIN all_cons_columns acc
+          ON acc.owner = ac.owner
+          AND acc.constraint_name = ac.constraint_name
+        JOIN all_constraints r_ac
+          ON r_ac.owner = ac.r_owner
+          AND r_ac.constraint_name = ac.r_constraint_name
+        JOIN all_cons_columns r_acc
+          ON r_acc.owner = r_ac.owner
+          AND r_acc.constraint_name = r_ac.constraint_name
+          AND r_acc.position = acc.position
+        WHERE ac.constraint_type = 'R'
+          AND ac.owner = :1
+          AND ac.table_name = :2
+        ORDER BY acc.position
+      `,
+      [schema, tableName]
+    );
+  }
+  async getPrimaryKeyColumns(schema, tableName) {
+    return this.adapter.rawQuery(
+      `
+        SELECT acc.column_name
+        FROM all_constraints ac
+        JOIN all_cons_columns acc
+          ON acc.owner = ac.owner
+          AND acc.constraint_name = ac.constraint_name
+        WHERE ac.constraint_type = 'P'
+          AND ac.owner = :1
+          AND ac.table_name = :2
+        ORDER BY acc.position
+      `,
+      [schema, tableName]
+    );
+  }
+  async getTableStructure(schema, tableName) {
+    const [columns, foreignKeys] = await Promise.all([
+      this.adapter.rawQuery(
+        `
+          SELECT
+            c.column_name,
+            c.column_id,
+            c.data_type,
+            c.data_length,
+            c.data_precision,
+            c.data_scale,
+            c.nullable,
+            TRIM(c.data_default) AS default_value,
+            col.comments AS column_comment
+          FROM all_tab_columns c
+          LEFT JOIN all_col_comments col
+            ON col.owner = c.owner
+            AND col.table_name = c.table_name
+            AND col.column_name = c.column_name
+          WHERE c.owner = :1
+            AND c.table_name = :2
+          ORDER BY c.column_id
+        `,
+        [schema, tableName]
+      ),
+      this.getForeignKeyConstraints(schema, tableName)
+    ]);
+    const foreignKeyMap = /* @__PURE__ */ new Map();
+    foreignKeys.forEach((foreignKey) => {
+      const list = foreignKeyMap.get(foreignKey.column_name) || [];
+      list.push(foreignKey);
+      foreignKeyMap.set(foreignKey.column_name, list);
+    });
+    return columns.map((column) => {
+      var _a;
+      return {
+        column_name: column.column_name,
+        data_type: formatOracleType(column),
+        is_nullable: column.nullable === "Y" ? "YES" : "NO",
+        default_value: column.default_value,
+        foreign_keys: (foreignKeyMap.get(column.column_name) || []).map(
+          (foreignKey) => ` -> ${foreignKey.referenced_owner}.${foreignKey.referenced_table_name}(${foreignKey.referenced_column_name})`
+        ).join("\n"),
+        column_comment: column.column_comment || "",
+        on_delete: (_a = (foreignKeyMap.get(column.column_name) || [])[0]) == null ? void 0 : _a.delete_rule
+      };
+    });
+  }
+  async getTableSize(schema, tableName) {
+    const [row] = await this.adapter.rawQuery(
+      `
+        SELECT
+          NVL(tb.table_bytes, 0) AS table_bytes,
+          NVL(ix.index_bytes, 0) AS index_bytes
+        FROM dual
+        LEFT JOIN (
+          SELECT SUM(bytes) AS table_bytes
+          FROM all_segments
+          WHERE owner = :1
+            AND segment_name = :2
+            AND segment_type LIKE 'TABLE%'
+        ) tb ON 1 = 1
+        LEFT JOIN (
+          SELECT SUM(NVL(s.bytes, 0)) AS index_bytes
+          FROM all_indexes ai
+          LEFT JOIN all_segments s
+            ON s.owner = ai.owner
+            AND s.segment_name = ai.index_name
+          WHERE ai.table_owner = :1
+            AND ai.table_name = :2
+        ) ix ON 1 = 1
+      `,
+      [schema, tableName]
+    );
+    if (!row) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return {
+      tableSize: formatBytes((row.table_bytes || 0) + (row.index_bytes || 0)),
+      dataSize: formatBytes(row.table_bytes),
+      indexSize: formatBytes(row.index_bytes)
+    };
+  }
+  async getTableMeta(schema, tableName) {
+    const [row] = await this.adapter.rawQuery(
+      `
+        SELECT
+          t.owner,
+          t.num_rows,
+          NVL(tb.table_bytes, 0) AS table_bytes,
+          NVL(ix.index_bytes, 0) AS index_bytes
+        FROM all_tables t
+        LEFT JOIN (
+          SELECT owner, segment_name, SUM(bytes) AS table_bytes
+          FROM all_segments
+          WHERE segment_type LIKE 'TABLE%'
+          GROUP BY owner, segment_name
+        ) tb
+          ON tb.owner = t.owner
+          AND tb.segment_name = t.table_name
+        LEFT JOIN (
+          SELECT ai.table_owner AS owner, ai.table_name, SUM(NVL(s.bytes, 0)) AS index_bytes
+          FROM all_indexes ai
+          LEFT JOIN all_segments s
+            ON s.owner = ai.owner
+            AND s.segment_name = ai.index_name
+          GROUP BY ai.table_owner, ai.table_name
+        ) ix
+          ON ix.owner = t.owner
+          AND ix.table_name = t.table_name
+        WHERE t.owner = :1
+          AND t.table_name = :2
+      `,
+      [schema, tableName]
+    );
+    if (!row) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    return {
+      type: "TABLE",
+      owner: row.owner,
+      rowEstimate: row.num_rows || 0,
+      totalSize: formatBytes((row.table_bytes || 0) + (row.index_bytes || 0)),
+      tableSize: formatBytes(row.table_bytes),
+      indexSize: formatBytes(row.index_bytes)
+    };
+  }
+  async getTableDdl(schema, tableName) {
+    const [columns, primaryKeys, foreignKeys] = await Promise.all([
+      this.getTableStructure(schema, tableName),
+      this.getPrimaryKeyColumns(schema, tableName),
+      this.getForeignKeyConstraints(schema, tableName)
+    ]);
+    if (!columns.length) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    const lines = columns.map((column) => {
+      let line = `  ${escapeOracleIdentifier(column.column_name)} ${column.data_type}`;
+      if (column.default_value) {
+        line += ` DEFAULT ${column.default_value}`;
+      }
+      if (column.is_nullable === "NO") {
+        line += " NOT NULL";
+      }
+      return line;
+    });
+    if (primaryKeys.length) {
+      lines.push(
+        `  PRIMARY KEY (${primaryKeys.map((primaryKey) => escapeOracleIdentifier(primaryKey.column_name)).join(", ")})`
+      );
+    }
+    foreignKeys.forEach((foreignKey) => {
+      const deleteClause = foreignKey.delete_rule && foreignKey.delete_rule !== "NO ACTION" ? ` ON DELETE ${foreignKey.delete_rule}` : "";
+      lines.push(
+        `  CONSTRAINT ${escapeOracleIdentifier(
+          foreignKey.constraint_name
+        )} FOREIGN KEY (${escapeOracleIdentifier(
+          foreignKey.column_name
+        )}) REFERENCES ${buildQualifiedTable$1(
+          foreignKey.referenced_owner,
+          foreignKey.referenced_table_name
+        )} (${escapeOracleIdentifier(foreignKey.referenced_column_name)})${deleteClause}`
+      );
+    });
+    return `CREATE TABLE ${buildQualifiedTable$1(schema, tableName)} (
+${lines.join(",\n")}
+);`;
+  }
+  async getTableIndexes(schema, tableName) {
+    const rows = await this.adapter.rawQuery(
+      `
+        SELECT
+          ai.index_name,
+          CASE WHEN ai.uniqueness = 'UNIQUE' THEN 1 ELSE 0 END AS is_unique,
+          CASE WHEN pk.constraint_name IS NOT NULL THEN 1 ELSE 0 END AS is_primary,
+          ai.index_type AS method,
+          aic.column_name
+        FROM all_indexes ai
+        JOIN all_ind_columns aic
+          ON aic.index_owner = ai.owner
+          AND aic.index_name = ai.index_name
+        LEFT JOIN all_constraints pk
+          ON pk.owner = ai.table_owner
+          AND pk.index_name = ai.index_name
+          AND pk.constraint_type = 'P'
+        WHERE ai.table_owner = :1
+          AND ai.table_name = :2
+        ORDER BY ai.index_name, aic.column_position
+      `,
+      [schema, tableName]
+    );
+    const grouped = /* @__PURE__ */ new Map();
+    rows.forEach((row) => {
+      const existing = grouped.get(row.index_name);
+      if (existing) {
+        existing.definition = `${existing.definition}, ${row.column_name}`;
+        return;
+      }
+      grouped.set(row.index_name, {
+        indexName: row.index_name,
+        isUnique: row.is_unique === 1,
+        isPrimary: row.is_primary === 1,
+        method: row.method,
+        definition: row.column_name
+      });
+    });
+    return Array.from(grouped.values());
+  }
+  async getTableRlsStatus() {
+    return { enabled: false };
+  }
+  async getTableRlsPolicies() {
+    return [];
+  }
+  async getTableRules() {
+    return [];
+  }
+  async getTableTriggers(schema, tableName) {
+    const rows = await this.adapter.rawQuery(
+      `
+        SELECT
+          trigger_name,
+          status,
+          trigger_type,
+          triggering_event,
+          trigger_body,
+          description
+        FROM all_triggers
+        WHERE table_owner = :1
+          AND table_name = :2
+        ORDER BY trigger_name
+      `,
+      [schema, tableName]
+    );
+    return rows.map((row) => ({
+      triggerName: row.trigger_name,
+      enabled: row.status === "ENABLED",
+      timing: row.trigger_type.split(" ", 1)[0] || row.trigger_type,
+      events: row.triggering_event.split(/\s+OR\s+/),
+      orientation: row.trigger_type.includes("EACH ROW") ? "ROW" : "STATEMENT",
+      definition: row.trigger_body || row.description || ""
+    }));
+  }
+  async executeStatements(statements) {
+    const startTime = performance.now();
+    try {
+      const data = [];
+      for (const statement of statements) {
+        const result = await this.adapter.rawOut(statement);
+        data.push({
+          query: statement,
+          affectedRows: result.rowCount || 0,
+          results: result.rows
+        });
+      }
+      return {
+        success: true,
+        data,
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error == null ? void 0 : error.message) || "Failed to execute statements",
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    }
+  }
+  async executeBulkDelete(statements) {
+    return this.executeStatements(statements);
+  }
+  async executeBulkUpdate(statements) {
+    return this.executeStatements(statements);
+  }
+  async exportTableData(schema, tableName) {
+    return this.adapter.rawQuery(
+      `SELECT * FROM ${buildQualifiedTable$1(schema, tableName)}`
+    );
+  }
+}
 
 class PostgresTableAdvancedObjectsAdapter {
   constructor(adapter) {
@@ -446,29 +1094,7 @@ class PostgresTableStructureAdapter {
     const query = `
       SELECT
         a.attname AS column_name,
-        CASE
-          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character varying%' 
-              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character varying', 'varchar')
-          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'character%' 
-              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'character', 'char')
-          WHEN format_type(a.atttypid, a.atttypmod) = 'double precision' THEN 'float8'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'integer' THEN 'int4'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'smallint' THEN 'int2'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'bigint' THEN 'int8'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'real' THEN 'float4'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'serial' THEN 'serial4'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'smallserial' THEN 'serial2'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'bigserial' THEN 'serial8'
-          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'bit varying%' 
-              THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'bit varying', 'varbit')
-          WHEN format_type(a.atttypid, a.atttypmod) = 'boolean' THEN 'bool'
-          WHEN format_type(a.atttypid, a.atttypmod) LIKE 'numeric%' 
-          THEN REPLACE(format_type(a.atttypid, a.atttypmod), 'numeric', 'decimal')
-          WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp with time zone' THEN 'timestamptz'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'timestamp without time zone' THEN 'timestamp'
-          WHEN format_type(a.atttypid, a.atttypmod) = 'time with time zone' THEN 'timetz'
-          ELSE format_type(a.atttypid, a.atttypmod)
-        END as data_type,
+        format_type(a.atttypid, a.atttypmod) AS raw_type_name,
         NOT a.attnotnull AS is_nullable,
         PG_GET_EXPR(d.adbin, d.adrelid) AS default_value,
         COALESCE(fk_info.fk_text, '') AS foreign_keys,
@@ -525,7 +1151,18 @@ class PostgresTableStructureAdapter {
       ORDER BY
         a.attnum
     `;
-    return this.adapter.rawQuery(query, [tableName, schema]);
+    const rows = await this.adapter.rawQuery(query, [tableName, schema]);
+    return rows.map((row) => {
+      const shortType = resolveMetadataTypeAlias(
+        DatabaseClientType.POSTGRES,
+        row.raw_type_name
+      );
+      return {
+        ...row,
+        short_type_name: shortType,
+        data_type: shortType
+      };
+    });
   }
   async getTableSize(schema, tableName) {
     const query = `
@@ -710,18 +1347,18 @@ class PostgresTableStructureAdapter {
   }
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
 class PostgresTableAdapter extends BaseDomainAdapter {
   constructor(adapter) {
     super(adapter);
-    __publicField(this, "dbType", DatabaseClientType.POSTGRES);
-    __publicField(this, "metadataAdapter");
-    __publicField(this, "structureAdapter");
-    __publicField(this, "mutationAdapter");
-    __publicField(this, "exportAdapter");
-    __publicField(this, "advancedObjectsAdapter");
+    __publicField$1(this, "dbType", DatabaseClientType.POSTGRES);
+    __publicField$1(this, "metadataAdapter");
+    __publicField$1(this, "structureAdapter");
+    __publicField$1(this, "mutationAdapter");
+    __publicField$1(this, "exportAdapter");
+    __publicField$1(this, "advancedObjectsAdapter");
     this.metadataAdapter = new PostgresTableMetadataAdapter(this.adapter);
     this.structureAdapter = new PostgresTableStructureAdapter(this.adapter);
     this.mutationAdapter = new PostgresTableMutationAdapter(this.adapter);
@@ -778,10 +1415,253 @@ class PostgresTableAdapter extends BaseDomainAdapter {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
+function escapeSqliteIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function quoteSqliteString(value) {
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function resolveSqliteSchema(schema) {
+  if (!schema || schema === "public") {
+    return "main";
+  }
+  return schema;
+}
+function buildQualifiedTable(schema, tableName) {
+  const resolvedSchema = resolveSqliteSchema(schema);
+  return `${escapeSqliteIdentifier(resolvedSchema)}.${escapeSqliteIdentifier(tableName)}`;
+}
+class SqliteTableAdapter extends BaseDomainAdapter {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "dbType", DatabaseClientType.SQLITE3);
+  }
+  static async create(params) {
+    const adapter = await SqliteTableAdapter.resolveAdapter(
+      params,
+      DatabaseClientType.SQLITE3
+    );
+    return new SqliteTableAdapter(adapter);
+  }
+  async getTableInfo(schema, tableName) {
+    const resolvedSchema = resolveSqliteSchema(schema);
+    return this.adapter.rawQuery(
+      `PRAGMA ${escapeSqliteIdentifier(resolvedSchema)}.table_info(${quoteSqliteString(tableName)})`
+    );
+  }
+  async getForeignKeys(schema, tableName) {
+    const resolvedSchema = resolveSqliteSchema(schema);
+    return this.adapter.rawQuery(
+      `PRAGMA ${escapeSqliteIdentifier(resolvedSchema)}.foreign_key_list(${quoteSqliteString(tableName)})`
+    );
+  }
+  async getOverviewTables(schema) {
+    const resolvedSchema = resolveSqliteSchema(schema);
+    return this.adapter.rawQuery(
+      `
+        SELECT
+          name,
+          ${quoteSqliteString(resolvedSchema)} AS schema,
+          'TABLE' AS kind,
+          ${quoteSqliteString(resolvedSchema)} AS owner,
+          NULL AS estimated_row,
+          '0 B' AS total_size,
+          '0 B' AS data_size,
+          '0 B' AS index_size,
+          NULL AS comment
+        FROM ${escapeSqliteIdentifier(resolvedSchema)}.sqlite_master
+        WHERE type = 'table'
+          AND name NOT LIKE 'sqlite_%'
+        ORDER BY name
+      `
+    );
+  }
+  async getTableStructure(schema, tableName) {
+    const [columns, foreignKeys] = await Promise.all([
+      this.getTableInfo(schema, tableName),
+      this.getForeignKeys(schema, tableName)
+    ]);
+    const foreignKeyMap = /* @__PURE__ */ new Map();
+    foreignKeys.forEach((foreignKey) => {
+      const list = foreignKeyMap.get(foreignKey.from) || [];
+      list.push(foreignKey);
+      foreignKeyMap.set(foreignKey.from, list);
+    });
+    return columns.map((column) => {
+      var _a, _b;
+      return {
+        column_name: column.name,
+        data_type: column.type,
+        is_nullable: column.notnull === 0 ? "YES" : "NO",
+        default_value: column.dflt_value,
+        foreign_keys: (foreignKeyMap.get(column.name) || []).map((foreignKey) => ` -> ${foreignKey.table}(${foreignKey.to})`).join("\n"),
+        column_comment: "",
+        on_update: (_a = (foreignKeyMap.get(column.name) || [])[0]) == null ? void 0 : _a.on_update,
+        on_delete: (_b = (foreignKeyMap.get(column.name) || [])[0]) == null ? void 0 : _b.on_delete
+      };
+    });
+  }
+  async getTableSize(_schema, _tableName) {
+    return {
+      tableSize: "0 B",
+      dataSize: "0 B",
+      indexSize: "0 B"
+    };
+  }
+  async getTableMeta(schema, tableName) {
+    const [countRow] = await this.adapter.rawQuery(
+      `SELECT COUNT(*) AS row_count FROM ${buildQualifiedTable(schema, tableName)}`
+    );
+    return {
+      type: "TABLE",
+      owner: schema,
+      rowEstimate: (countRow == null ? void 0 : countRow.row_count) || 0,
+      totalSize: "0 B",
+      tableSize: "0 B",
+      indexSize: "0 B"
+    };
+  }
+  async getTableDdl(schema, tableName) {
+    const resolvedSchema = resolveSqliteSchema(schema);
+    const [row] = await this.adapter.rawQuery(
+      `
+        SELECT sql
+        FROM ${escapeSqliteIdentifier(resolvedSchema)}.sqlite_master
+        WHERE type = 'table'
+          AND name = ?
+      `,
+      [tableName]
+    );
+    if (!row) {
+      throw createError({ statusCode: 404, statusMessage: "Table not found" });
+    }
+    if (row.sql) {
+      return row.sql;
+    }
+    const columns = await this.getTableStructure(schema, tableName);
+    const ddlColumns = columns.map((column) => {
+      let line = `  ${escapeSqliteIdentifier(column.column_name)} ${column.data_type}`;
+      if (column.default_value) {
+        line += ` DEFAULT ${column.default_value}`;
+      }
+      if (column.is_nullable === "NO") {
+        line += " NOT NULL";
+      }
+      return line;
+    });
+    return `CREATE TABLE ${buildQualifiedTable(schema, tableName)} (
+${ddlColumns.join(",\n")}
+);`;
+  }
+  async getTableIndexes(schema, tableName) {
+    const indexes = await this.adapter.rawQuery(
+      `PRAGMA ${escapeSqliteIdentifier(schema)}.index_list(${quoteSqliteString(tableName)})`
+    );
+    const results = [];
+    for (const index of indexes) {
+      const columns = await this.adapter.rawQuery(
+        `PRAGMA ${escapeSqliteIdentifier(schema)}.index_info(${quoteSqliteString(index.name)})`
+      );
+      results.push({
+        indexName: index.name,
+        isUnique: index.unique === 1,
+        isPrimary: index.origin === "pk",
+        method: "BTREE",
+        definition: columns.map((column) => column.name).join(", ")
+      });
+    }
+    return results;
+  }
+  async getTableRlsStatus() {
+    return { enabled: false };
+  }
+  async getTableRlsPolicies() {
+    return [];
+  }
+  async getTableRules() {
+    return [];
+  }
+  async getTableTriggers(schema, tableName) {
+    const resolvedSchema = resolveSqliteSchema(schema);
+    const rows = await this.adapter.rawQuery(
+      `
+        SELECT name, sql
+        FROM ${escapeSqliteIdentifier(resolvedSchema)}.sqlite_master
+        WHERE type = 'trigger'
+          AND tbl_name = ?
+        ORDER BY name
+      `,
+      [tableName]
+    );
+    return rows.map((row) => {
+      var _a;
+      const definition = row.sql || "";
+      const timingMatch = definition.match(/\b(BEFORE|AFTER|INSTEAD OF)\b/i);
+      const events = definition.match(/\b(INSERT|UPDATE|DELETE)\b/gi) || [];
+      return {
+        triggerName: row.name,
+        enabled: true,
+        timing: ((_a = timingMatch == null ? void 0 : timingMatch[1]) == null ? void 0 : _a.toUpperCase()) || "AFTER",
+        events: events.map((event) => event.toUpperCase()),
+        orientation: "ROW",
+        definition
+      };
+    });
+  }
+  async executeStatements(statements) {
+    const startTime = performance.now();
+    try {
+      const data = [];
+      for (const statement of statements) {
+        const result = await this.adapter.rawOut(statement);
+        data.push({
+          query: statement,
+          affectedRows: result.rowCount || 0,
+          results: result.rows
+        });
+      }
+      return {
+        success: true,
+        data,
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: (error == null ? void 0 : error.message) || "Failed to execute statements",
+        queryTime: Number((performance.now() - startTime).toFixed(2))
+      };
+    }
+  }
+  async executeBulkDelete(statements) {
+    return this.executeStatements(statements);
+  }
+  async executeBulkUpdate(statements) {
+    return this.executeStatements(statements);
+  }
+  async exportTableData(schema, tableName) {
+    return this.adapter.rawQuery(
+      `SELECT * FROM ${buildQualifiedTable(schema, tableName)}`
+    );
+  }
+}
+
 async function createTableAdapter(dbType, params) {
-  return createDomainAdapter(dbType, params, "table", {
-    postgres: PostgresTableAdapter.create
-  });
+  return createDomainAdapter(
+    dbType,
+    params,
+    "table",
+    {
+      postgres: PostgresTableAdapter.create,
+      mysql: (params2) => MysqlTableAdapter.create(params2, DatabaseClientType.MYSQL),
+      mariadb: (params2) => MysqlTableAdapter.create(params2, DatabaseClientType.MARIADB),
+      oracledb: OracleTableAdapter.create,
+      sqlite3: SqliteTableAdapter.create
+    }
+  );
 }
 
 export { createTableAdapter as c };