@dbml/connector 5.6.0-alpha.1 → 6.0.0

package/dist/connectors/mysql/index.js

@@ -0,0 +1,454 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchemaJson = fetchSchemaJson;
+const promise_1 = require("mysql2/promise");
+const lodash_1 = require("lodash");
+const NUMBER_REGEX = '^-?[0-9]+(.[0-9]+)?$';
+async function connectMySQL(connection) {
+    const client = await (0, promise_1.createConnection)(connection);
+    try {
+        await client.connect();
+        await client.query('SELECT 1');
+        return client;
+    }
+    catch (error) {
+        await client.end();
+        if (error instanceof Error) {
+            throw new Error(`MySQL connection error: ${error.message}`);
+        }
+        throw error;
+    }
+}
+function getEnumName(tableName, columnName) {
+    return `${tableName}_${columnName}_enum`;
+}
+function getGenerationExpression(extraType, generationExpression) {
+    if (extraType === 'VIRTUAL GENERATED') {
+        return `GENERATED ALWAYS AS (${generationExpression}) VIRTUAL`;
+    }
+    if (extraType === 'STORED GENERATED') {
+        return `GENERATED ALWAYS AS (${generationExpression}) STORED`;
+    }
+    // for timestamp data type
+    if (extraType.includes('on update CURRENT_TIMESTAMP')) {
+        return 'on update CURRENT_TIMESTAMP';
+    }
+    // others
+    return '';
+}
+function getDbDefault(columnDefault, defaultValueType) {
+    if (columnDefault === null) {
+        return null;
+    }
+    return { value: columnDefault, type: defaultValueType };
+}
+function getFieldType(tableName, columnName, columnType, columnDataType, columnExtra, generationExpression) {
+    if (columnDataType === 'enum') {
+        // enum must have static value -> no need to check the generation expression
+        return getEnumName(tableName, columnName);
+    }
+    const fieldGenerationExpression = getGenerationExpression(columnExtra, generationExpression);
+    if (fieldGenerationExpression) {
+        return `${columnType} ${fieldGenerationExpression}`;
+    }
+    return columnType;
+}
+function generateField(row) {
+    const { tableName, columnName, columnDefault, defaultValueType, columnIsNullable, columnType, columnDataType, columnComment, columnExtra, generationExpression, } = row;
+    const fieldType = getFieldType(tableName, columnName, columnType, columnDataType, columnExtra, generationExpression);
+    const fieldDefaultValue = getDbDefault(columnDefault, defaultValueType);
+    const isNullable = columnIsNullable === 'YES';
+    return {
+        name: columnName,
+        type: { type_name: fieldType, schemaName: null },
+        dbdefault: fieldDefaultValue,
+        not_null: !isNullable,
+        increment: columnExtra === 'auto_increment',
+        note: { value: columnComment || '' },
+    };
+}
+// Do not get the index sub part since in DBML, it is impossible to create index on part of column.
+function getIndexColumn(columnName, idxExpression, idxSubPart) {
+    if (idxExpression) {
+        return { value: idxExpression, type: 'expression' };
+    }
+    if (idxSubPart) {
+        return { value: `${columnName}(${idxSubPart})`, type: 'expression' };
+    }
+    if (columnName) {
+        return { value: columnName, type: 'column' };
+    }
+    return null;
+}
+async function generateTablesAndFields(client, schemaName) {
+    const query = `
+    select
+      t.table_name as tableName,
+      t.table_comment as tableComment,
+      c.column_name as columnName,
+      c.column_default as columnDefault,
+      case
+        when c.column_default is null then 'boolean'
+        when c.data_type = 'enum' then 'string'
+        when c.column_default regexp ? then 'number'
+        when c.extra like '%DEFAULT_GENERATED%' then 'expression'
+        else 'string'
+      end as defaultValueType,
+      c.is_nullable as columnIsNullable,
+      c.data_type as columnDataType,
+      c.column_type as columnType,
+      c.extra as columnExtra,
+      c.column_comment as columnComment,
+      c.generation_expression as generationExpression
+    from information_schema.tables t
+    join information_schema.columns c
+    on t.table_schema = c.table_schema and t.table_name = c.table_name
+    where
+      t.table_schema = ? and t.table_type = 'BASE TABLE'
+    order by
+      t.table_name, c.ordinal_position;
+  `;
+    const queryResponse = await client.query(query, [NUMBER_REGEX, schemaName]);
+    const rows = queryResponse[0];
+    const tableMap = {};
+    const fieldMap = {};
+    rows.forEach((row) => {
+        const { tableName, tableComment } = row;
+        const key = tableName;
+        if (!tableMap[key]) {
+            tableMap[key] = {
+                name: tableName,
+                note: { value: tableComment || '' },
+            };
+        }
+        if (!fieldMap[key]) {
+            fieldMap[key] = [];
+        }
+        const field = generateField(row);
+        fieldMap[key].push(field);
+    });
+    return {
+        tableList: Object.values(tableMap),
+        fieldMap,
+    };
+}
+async function generateEnums(client, schemaName) {
+    const query = `
+    select
+      t.table_name as tableName,
+      c.column_name as columnName,
+      TRIM(LEADING 'enum' FROM c.column_type) AS rawValues
+    from information_schema.tables t
+    join information_schema.columns c
+    on t.table_schema = c.table_schema and t.table_name = c.table_name
+    where
+      t.table_schema = ? and t.table_type = 'BASE TABLE' and c.data_type = 'enum'
+    order by
+      t.table_name, c.ordinal_position;
+  `;
+    const queryResponse = await client.query(query, [schemaName]);
+    const rows = queryResponse[0];
+    const enumList = rows.map((row) => {
+        const { tableName, columnName, rawValues } = row;
+        // i.e. ('value1','value2')
+        const valueList = rawValues
+            .slice(1, -1)
+            .split(',')
+            .map((value) => ({ name: value.slice(1, -1) }));
+        const enumName = getEnumName(tableName, columnName);
+        return {
+            name: enumName,
+            values: valueList,
+        };
+    });
+    return enumList;
+}
+/**
+ * Mysql automatically creates index for primary keys, foreign keys, unique constraint. -> Ignore
+ */
+async function generateIndexes(client, schemaName) {
+    const query = `
+    with
+      pk_fk_uniques as (
+        select constraint_name, table_name
+        from information_schema.table_constraints
+        where table_schema = ?
+      )
+    select
+      st.table_name as tableName,
+      case
+        when st.non_unique = 0 then true
+        else false
+        end as isIdxUnique,
+      st.index_name as idxName,
+      st.column_name as columnName,
+      st.sub_part as idxSubPart,
+      st.index_type as idxType,
+      replace(st.expression, '\`', '') as idxExpression
+    from information_schema.statistics st
+    where
+      st.table_schema = ?
+      and st.index_name not in (
+        select constraint_name
+        from pk_fk_uniques pfu
+        where pfu.table_name = st.table_name
+      )
+      and st.index_type in ('BTREE', 'HASH')
+    group by
+      st.table_name, st.non_unique, st.index_name, st.column_name, st.sub_part, st.index_type, st.expression
+    order by st.index_name;
+  `;
+    const queryResponse = await client.query(query, [schemaName, schemaName]);
+    const rows = queryResponse[0];
+    const tableIndexMap = rows.reduce((acc, row) => {
+        const { tableName, idxName, idxType, isIdxUnique, columnName, idxExpression, idxSubPart, } = row;
+        const key = tableName;
+        if (!acc[key]) {
+            acc[key] = {};
+        }
+        if (!acc[key][idxName]) {
+            // init first index
+            acc[key][idxName] = {
+                name: idxName,
+                type: idxType,
+                columns: [],
+                unique: !!isIdxUnique,
+            };
+        }
+        const currentIndex = acc[key][idxName];
+        const column = getIndexColumn(columnName, idxExpression, idxSubPart);
+        if (column) {
+            currentIndex.columns.push(column);
+        }
+        return acc;
+    }, {});
+    const indexMap = {};
+    Object.keys(tableIndexMap).forEach((tableName) => {
+        indexMap[tableName] = (0, lodash_1.flatten)(Object.values(tableIndexMap[tableName]));
+    });
+    return indexMap;
+}
+async function generatePrimaryAndUniqueConstraint(client, schemaName) {
+    const query = `
+    select
+      tc.table_name as tableName,
+      tc.constraint_name as constraintName,
+      group_concat(kcu.column_name order by kcu.ordinal_position separator ',') as columnNames,
+      count(kcu.column_name) as columnCount,
+      tc.constraint_type as constraintType
+    from information_schema.table_constraints tc
+    join information_schema.key_column_usage kcu
+    on
+      tc.constraint_schema = kcu.constraint_schema
+      and tc.constraint_name = kcu.constraint_name
+      and tc.table_name = kcu.table_name
+    where
+      (tc.constraint_type = 'PRIMARY KEY' or tc.constraint_type = 'UNIQUE')
+      and tc.table_schema = ?
+    group by tc.table_name, tc.constraint_name, tc.constraint_type
+    order by tc.table_name, tc.constraint_name;
+  `;
+    const queryResponse = await client.query(query, [schemaName]);
+    const rows = queryResponse[0];
+    const inlineConstraintList = rows.filter((constraint) => constraint.columnCount === 1);
+    const outOfLineConstraintList = rows.filter((constraint) => constraint.columnCount > 1);
+    const compositeTableConstraintMap = outOfLineConstraintList.reduce((acc, row) => {
+        const { tableName, constraintName, columnNames, constraintType, } = row;
+        const key = tableName;
+        if (!acc[key]) {
+            acc[key] = {};
+        }
+        if (!acc[key][constraintName]) {
+            acc[key][constraintName] = {
+                name: constraintName,
+            };
+        }
+        if (constraintType === 'PRIMARY KEY') {
+            acc[key][constraintName].pk = true;
+        }
+        if (constraintType === 'UNIQUE') {
+            acc[key][constraintName].unique = true;
+        }
+        const columnList = columnNames
+            .split(',')
+            .map((col) => ({ type: 'column', value: col }));
+        acc[key][constraintName].columns = columnList;
+        return acc;
+    }, {});
+    const compositeConstraintMap = {};
+    Object.keys(compositeTableConstraintMap).forEach((tableName) => {
+        compositeConstraintMap[tableName] = (0, lodash_1.flatten)(Object.values(compositeTableConstraintMap[tableName]));
+    });
+    const constraintMap = inlineConstraintList.reduce((acc, row) => {
+        const { tableName, columnNames, constraintType } = row;
+        const key = tableName;
+        if (!acc[key]) {
+            acc[key] = {};
+        }
+        const columnList = columnNames.split(',');
+        columnList.forEach((columnName) => {
+            if (!acc[key][columnName]) {
+                acc[key][columnName] = { checks: [] };
+            }
+            if (constraintType === 'PRIMARY KEY') {
+                acc[key][columnName].pk = true;
+            }
+            if (constraintType === 'UNIQUE' && !acc[key][columnName].pk) {
+                acc[key][columnName].unique = true;
+            }
+        });
+        return acc;
+    }, {});
+    return { compositeConstraintMap, primaryAndUniqueConstraintMap: constraintMap };
+}
+function extractColumnsFromCheckConstraint(checkClause) {
+    return [...checkClause.matchAll(/`(?:``|[^`])*`/g)].map((col) => col.toString().slice(1, -1));
+}
+async function generateCheckConstraints(client, schemaName) {
+    const query = `
+    select
+      cc.constraint_name as constraintName,
+      tc.table_name as tableName,
+      cc.check_clause as checkClause
+    from information_schema.check_constraints cc
+    join information_schema.table_constraints tc
+      on cc.constraint_name = tc.constraint_name
+    where cc.constraint_schema = ?
+  `;
+    const queryResponse = await client.query(query, [schemaName]);
+    const rows = queryResponse[0];
+    const checks = {};
+    const tableConstraints = {};
+    rows.forEach((row) => {
+        const { constraintName, tableName, checkClause, } = row;
+        const key = tableName;
+        const cols = extractColumnsFromCheckConstraint(checkClause);
+        if (cols.length === 1) {
+            const col = cols[0];
+            if (!tableConstraints[key])
+                tableConstraints[key] = {};
+            if (!tableConstraints[key][col])
+                tableConstraints[key][col] = { checks: [] };
+            tableConstraints[key][col].checks.push({
+                name: constraintName,
+                // The check definition has the form: `(expr)`
+                // The expression starts at 1 and ends at -1
+                expression: checkClause.slice(1, -1),
+            });
+            return;
+        }
+        if (!checks[key])
+            checks[key] = [];
+        checks[key].push({
+            name: constraintName,
+            // The check definition has the form: `(expr)`
+            // The expression starts at 1 and ends at -1
+            expression: checkClause.slice(1, -1),
+        });
+    });
+    return { checks, tableConstraints };
+}
+async function generateForeignKeys(client, schemaName) {
+    const query = `
+    select
+      rc.constraint_name as constraintName,
+      rc.table_name as foreignTableName,
+      group_concat(kcu.column_name order by kcu.ordinal_position separator ',') as foreignColumnNames,
+      kcu.referenced_table_name as refTableName,
+      group_concat(kcu.referenced_column_name order by kcu.ordinal_position separator ',') as refColumnNames,
+      rc.update_rule as onUpdate,
+      rc.delete_rule as onDelete
+    from information_schema.referential_constraints rc
+    join information_schema.key_column_usage kcu
+    on
+      rc.constraint_name = kcu.constraint_name
+      and rc.table_name = kcu.table_name
+      and rc.constraint_schema = kcu.table_schema
+    where rc.constraint_schema = ?
+    group by
+      rc.constraint_name,
+      rc.table_name,
+      kcu.referenced_table_name,
+      rc.update_rule,
+      rc.delete_rule
+    order by
+      rc.table_name;
+  `;
+    const queryResponse = await client.query(query, [schemaName]);
+    const rows = queryResponse[0];
+    const foreignKeyList = rows.map((row) => {
+        const { constraintName, onDelete, onUpdate, foreignTableName, foreignColumnNames, refTableName, refColumnNames, } = row;
+        const endpoint1 = {
+            tableName: foreignTableName,
+            fieldNames: foreignColumnNames.split(','),
+            relation: '*',
+        };
+        const endpoint2 = {
+            tableName: refTableName,
+            fieldNames: refColumnNames.split(','),
+            relation: '1',
+        };
+        return {
+            name: constraintName,
+            endpoints: [endpoint1, endpoint2],
+            onDelete: onDelete === 'NO ACTION' ? null : onDelete,
+            onUpdate: onUpdate === 'NO ACTION' ? null : onUpdate,
+        };
+    });
+    return foreignKeyList;
+}
+function combineIndexAndCompositeConstraint(userDefinedIndexMap, compositeConstraintMap) {
+    const indexMap = Object.assign(userDefinedIndexMap, {});
+    Object.keys(compositeConstraintMap).forEach((tableName) => {
+        const compositeConstraint = compositeConstraintMap[tableName];
+        if (!indexMap[tableName]) {
+            indexMap[tableName] = compositeConstraint;
+            return;
+        }
+        indexMap[tableName].push(...compositeConstraint);
+    });
+    return indexMap;
+}
+async function fetchSchemaJson(connection) {
+    const client = await connectMySQL(connection);
+    // In MySQL, a schema is equal database
+    const { database: schemaName } = client.config;
+    if (!schemaName) {
+        throw new Error('Cannot get schema name from the connection');
+    }
+    try {
+        const result = await Promise.all([
+            generateTablesAndFields(client, schemaName),
+            generateEnums(client, schemaName),
+            generateIndexes(client, schemaName),
+            generatePrimaryAndUniqueConstraint(client, schemaName),
+            generateForeignKeys(client, schemaName),
+            generateCheckConstraints(client, schemaName),
+        ]);
+        const [{ tableList, fieldMap }, enumList, rawIndexMap, { primaryAndUniqueConstraintMap, compositeConstraintMap }, foreignKeyList, { checks: tableCheckConstraintMap, tableConstraints: columnCheckConstraintMap },] = result;
+        // combine normal index and composite key
+        const indexMap = combineIndexAndCompositeConstraint(rawIndexMap, compositeConstraintMap);
+        const tableConstraints = { ...primaryAndUniqueConstraintMap };
+        Object.keys(columnCheckConstraintMap).forEach((tableName) => {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            Object.keys(columnCheckConstraintMap[tableName]).forEach((colName) => {
+                if (!tableConstraints[tableName][colName])
+                    tableConstraints[tableName][colName] = { checks: [] };
+                tableConstraints[tableName][colName].checks.push(...columnCheckConstraintMap[tableName][colName].checks);
+            });
+        });
+        return {
+            tables: tableList,
+            fields: fieldMap,
+            refs: foreignKeyList,
+            enums: enumList,
+            indexes: indexMap,
+            tableConstraints,
+            checks: tableCheckConstraintMap,
+        };
+    }
+    finally {
+        await client.end();
+    }
+}

package/dist/connectors/oracle/constraints.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConstraints = generateConstraints;
+const utils_1 = require("./utils");
+async function generateConstraints(client) {
+    const query = `
+    WITH all_constraints AS (
+      SELECT
+        c.CONSTRAINT_NAME,
+        c.TABLE_NAME,
+        c.CONSTRAINT_TYPE,
+        c.SEARCH_CONDITION_VC AS CHECK_EXPRESSION
+      FROM USER_CONSTRAINTS c
+      WHERE c.CONSTRAINT_TYPE IN ('P', 'U', 'C') -- P stands for primary key, U stands for unique and C stands for check
+        AND (c.CONSTRAINT_TYPE != 'C' OR UPPER(c.SEARCH_CONDITION_VC) NOT LIKE '%IS NOT NULL')
+    ),
+    constraint_columns AS (
+      SELECT
+        cc.CONSTRAINT_NAME,
+        LISTAGG(cc.COLUMN_NAME, '${utils_1.LIST_SEPARATOR}') WITHIN GROUP (ORDER BY cc.POSITION) AS COLUMNS,
+        COUNT(cc.COLUMN_NAME) AS COLUMN_COUNT
+      FROM USER_CONS_COLUMNS cc
+      GROUP BY cc.CONSTRAINT_NAME
+    )
+    SELECT
+      ac.CONSTRAINT_NAME AS "constraint_name",
+      ac.TABLE_NAME AS "table_name",
+      cc.COLUMNS AS "columns",
+      cc.COLUMN_COUNT AS "column_count",
+      ac.CHECK_EXPRESSION AS "check_expression",
+      ac.CONSTRAINT_TYPE AS "constraint_type"
+    FROM all_constraints ac
+    LEFT JOIN constraint_columns cc
+      ON ac.CONSTRAINT_NAME = cc.CONSTRAINT_NAME
+    LEFT JOIN USER_OBJECTS obj
+      ON obj.OBJECT_NAME = ac.TABLE_NAME
+      AND obj.OBJECT_TYPE = 'TABLE'
+    ORDER BY
+      obj.CREATED,
+      obj.OBJECT_ID,
+      ac.CONSTRAINT_NAME
+  `;
+    const indexes = {};
+    const tableConstraints = {};
+    const checks = {};
+    const res = await client.execute(query, [], utils_1.EXECUTE_OPTIONS);
+    res.rows?.forEach((row) => {
+        const { constraint_name, table_name, columns: columnsStr, column_count, check_expression, constraint_type } = row;
+        const tableName = table_name;
+        const constraintName = constraint_name || '';
+        const columns = (columnsStr || '').split(utils_1.LIST_SEPARATOR);
+        const columnCount = column_count || 1;
+        const constraintType = constraint_type;
+        const checkExpression = (check_expression || null);
+        // Table-level check constraints
+        if (constraintType === 'C' && checkExpression && columnCount > 1) {
+            if (!checks[tableName])
+                checks[tableName] = [];
+            const check = {
+                name: constraintName,
+                expression: checkExpression,
+            };
+            checks[tableName].push(check);
+            return;
+        }
+        // Column-level check constraints
+        if (constraintType === 'C' && checkExpression && columnCount === 1 && columns.length === 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            const column = columns[0];
+            if (!tableConstraints[tableName][column])
+                tableConstraints[tableName][column] = { checks: [] };
+            tableConstraints[tableName][column].checks.push({
+                name: constraintName,
+                expression: checkExpression,
+            });
+        }
+        // Column-level unique or primary indexes
+        if (['P', 'U'].includes(constraintType) && columnCount === 1 && columns.length === 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            const column = columns[0];
+            if (!tableConstraints[tableName][column])
+                tableConstraints[tableName][column] = { checks: [] };
+            tableConstraints[tableName][column].pk ||= constraintType === 'P';
+            tableConstraints[tableName][column].unique ||= constraintType === 'U';
+        }
+        // Table-level unique or primary indexes
+        if (['P', 'U'].includes(constraintType) && columnCount > 1) {
+            if (!tableConstraints[tableName])
+                tableConstraints[tableName] = {};
+            if (!indexes[tableName])
+                indexes[tableName] = [];
+            const index = {
+                name: constraintName,
+                type: '',
+                unique: true,
+                pk: constraintType === 'P',
+                columns: columns.map((c) => ({
+                    type: 'column',
+                    value: c,
+                })),
+            };
+            indexes[tableName].push(index);
+        }
+    });
+    return {
+        indexes,
+        tableConstraints,
+        checks,
+    };
+}

package/dist/connectors/oracle/index.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSchemaJson = fetchSchemaJson;
+const oracledb_1 = require("oracledb");
+const tables_1 = require("./tables");
+const refs_1 = require("./refs");
+const constraints_1 = require("./constraints");
+const indexes_1 = require("./indexes");
+const utils_1 = require("./utils");
+const getValidatedClient = async (username, password, dbidentifier) => {
+    const client = await (0, oracledb_1.getConnection)({
+        username,
+        password,
+        connectionString: dbidentifier,
+    });
+    try {
+        await client.execute('SELECT 1 FROM DUAL');
+        return client;
+    }
+    catch (error) {
+        await client.close();
+        if (error instanceof Error) {
+            throw new Error(`OracleSQL connection error: ${error.message}`);
+        }
+        throw error;
+    }
+};
+// Expect an Easy Connect string format: username/password@[//]host[:port][/database]
+// `username` and `password` are mandatory
+// `port` and `database` (and the parts enclosed in `[]`) are optional
+// Explanation of the format: https://www.orafaq.com/wiki/EZCONNECT
+async function fetchSchemaJson(connection) {
+    const { username, password, dbidentifier } = (0, utils_1.processEasyConnectString)(connection);
+    const client = await getValidatedClient(username, password, dbidentifier);
+    const tablesAndFieldsRes = (0, tables_1.generateTablesAndFields)(client);
+    const constraintsRes = (0, constraints_1.generateConstraints)(client);
+    const refsRes = (0, refs_1.generateRawRefs)(client);
+    const indexesRes = (0, indexes_1.generateIndexes)(client);
+    const res = await Promise.all([
+        tablesAndFieldsRes,
+        constraintsRes,
+        refsRes,
+        indexesRes,
+    ]);
+    const { tables, fields } = res[0];
+    const { indexes: uniqueIndexes, tableConstraints, checks } = res[1];
+    const refs = res[2];
+    const indexes = res[3];
+    Object.keys(uniqueIndexes).forEach((key) => {
+        if (!indexes[key])
+            indexes[key] = uniqueIndexes[key];
+        else
+            indexes[key].push(...uniqueIndexes[key]);
+    });
+    await client.close();
+    return {
+        tables,
+        fields,
+        refs,
+        // As of oracle 19c, there's no native ENUM data type
+        // ENUM is introduced in oracle 23ai
+        enums: [],
+        indexes,
+        tableConstraints,
+        checks,
+    };
+}
+;

package/dist/connectors/oracle/indexes.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateIndexes = generateIndexes;
+const utils_1 = require("./utils");
+async function generateIndexes(client) {
+    const query = `
+    SELECT
+      i.INDEX_NAME AS "index_name",
+      i.TABLE_NAME AS "table_name",
+      CASE
+        WHEN i.INDEX_TYPE LIKE '%NORMAL' THEN 'btree'
+        ELSE LOWER(REGEXP_REPLACE(i.INDEX_TYPE, '^FUNCTION-BASED ', ''))
+      END AS "index_type",
+      CASE WHEN i.UNIQUENESS = 'UNIQUE' THEN 1 ELSE 0 END AS "is_unique",
+      ic.COLUMN_NAME AS "column_name",
+      ic.COLUMN_POSITION AS "column_position",
+      ie.COLUMN_EXPRESSION AS "column_expression"
+    FROM USER_INDEXES i
+    LEFT JOIN USER_IND_COLUMNS ic
+      ON i.INDEX_NAME = ic.INDEX_NAME
+    LEFT JOIN USER_IND_EXPRESSIONS ie
+      ON i.INDEX_NAME = ie.INDEX_NAME
+      AND ic.COLUMN_POSITION = ie.COLUMN_POSITION
+    LEFT JOIN USER_OBJECTS obj
+      ON obj.OBJECT_NAME = i.TABLE_NAME
+      AND obj.OBJECT_TYPE = 'TABLE'
+    WHERE NOT EXISTS (
+      SELECT 1
+      FROM USER_CONSTRAINTS c
+      WHERE c.INDEX_NAME = i.INDEX_NAME
+    )
+    ORDER BY obj.CREATED, obj.OBJECT_ID, i.INDEX_NAME, ic.COLUMN_POSITION
+  `;
+    const res = await client.execute(query, [], utils_1.EXECUTE_OPTIONS);
+    const indexes = {};
+    const indexMap = {};
+    res.rows?.forEach((row) => {
+        const { index_name, table_name, index_type, is_unique, column_name, column_expression } = row;
+        const name = index_name;
+        const table = table_name;
+        const type = index_type;
+        const unique = !!is_unique;
+        if (column_expression) {
+            if (!indexMap[name]) {
+                indexMap[name] = { table, type, unique, columns: [] };
+            }
+            indexMap[name].columns.push({ type: 'expression', value: column_expression });
+            return;
+        }
+        if (column_name) {
+            if (!indexMap[name]) {
+                indexMap[name] = { table, type, unique, columns: [] };
+            }
+            indexMap[name].columns.push({ type: 'column', value: column_name });
+            return;
+        }
+    });
+    Object.entries(indexMap).forEach(([name, { table, type, unique, columns }]) => {
+        const index = { name, type, unique, columns };
+        if (!indexes[table])
+            indexes[table] = [];
+        indexes[table].push(index);
+    });
+    return indexes;
+}