windmill-components 1.613.4 → 1.623.1

package/package/components/apps/components/display/dbtable/queries/dbQueriesUtils.d.ts

@@ -1,9 +0,0 @@
-import type { DbType } from '../../../../../dbTypes';
-import type { TableEditorForeignKey, TableEditorValuesColumn } from '../tableEditor';
-export declare function formatDefaultValue(str: string, datatype: string, resourceType: DbType): string;
-export declare function renderColumn(c: TableEditorValuesColumn, dbType: DbType, primaryKeyModifier?: boolean): string;
-export declare function renderForeignKey(fk: TableEditorForeignKey, options: {
-    useSchema: boolean;
-    dbType: DbType;
-    tableName: string;
-}): string;

package/package/components/apps/components/display/dbtable/queries/dbQueriesUtils.js

@@ -1,45 +0,0 @@
-export function formatDefaultValue(str, datatype, resourceType) {
-    if (!str)
-        return '';
-    if (str.startsWith('{') && str.endsWith('}')) {
-        return str.slice(1, str.length - 1);
-    }
-    if (resourceType === 'postgresql') {
-        return `CAST('${str}' AS ${datatype})`;
-    }
-    return `'${str}'`;
-}
-export function renderColumn(c, dbType, primaryKeyModifier = false) {
-    const datatype = c.datatype_length ? `${c.datatype}(${c.datatype_length})` : c.datatype;
-    const defValue = c.defaultValue && formatDefaultValue(c.defaultValue, datatype, dbType);
-    let str = `${c.name} ${datatype}`;
-    if (!c.nullable)
-        str += ' NOT NULL';
-    if (defValue)
-        str += ` DEFAULT ${defValue}`;
-    if (primaryKeyModifier)
-        str += ' PRIMARY KEY';
-    return str;
-}
-export function renderForeignKey(fk, options) {
-    const sourceColumns = fk.columns.map((c) => c.sourceColumn).filter(Boolean);
-    const targetColumns = fk.columns.map((c) => c.targetColumn).filter(Boolean);
-    const targetTable = options.useSchema || !fk.targetTable?.includes('.')
-        ? fk.targetTable
-        : fk.targetTable?.split('.').pop();
-    let sql = 'CONSTRAINT ';
-    sql += `fk_${[
-        options.tableName,
-        ...sourceColumns.map((c) => c?.substring(0, 10)),
-        targetTable,
-        ...targetColumns.map((c) => c?.substring(0, 10))
-    ]
-        .join('_')
-        .replaceAll('.', '_')} `.substring(0, 60);
-    sql += ` FOREIGN KEY (${sourceColumns.join(', ')}) REFERENCES ${targetTable} (${targetColumns.join(', ')})`;
-    if (fk.onDelete !== 'NO ACTION')
-        sql += ` ON DELETE ${fk.onDelete}`;
-    if (fk.onUpdate !== 'NO ACTION')
-        sql += ` ON UPDATE ${fk.onUpdate}`;
-    return sql;
-}

package/package/components/apps/components/display/dbtable/queries/relationalKeys.d.ts

@@ -1,47 +0,0 @@
-import type { DbInput, DbType } from '../../../../../dbTypes';
-import type { ScriptLang } from '../../../../../../gen';
-import type { TableEditorForeignKey } from '../tableEditor';
-import type { TableMetadata } from '../utils';
-/**
- * Raw foreign key result from database queries
- */
-export type RawForeignKey = {
-    fk_constraint_name: string;
-    source_column: string;
-    target_table: string;
-    target_column: string;
-    on_delete: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-    on_update: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-};
-/**
- * Raw primary key constraint result from database queries
- */
-export type RawPrimaryKeyConstraint = {
-    constraint_name: string;
-};
-/**
- * Generates SQL query to fetch foreign key information for a specific table
- * @param dbType - The database type
- * @param table - The table name (can include schema, e.g., "schema.table")
- * @param defaultSchema - The default schema to use when table doesn't include one
- * @returns SQL query string
- */
-export declare function makeForeignKeysQuery(dbType: DbType, table: string, defaultSchema?: string): string;
-/**
- * Generates SQL query to fetch primary key constraint name for a specific table
- * @param dbType - The database type
- * @param table - The table name (can include schema, e.g., "schema.table")
- * @param defaultSchema - The default schema to use when table doesn't include one
- * @returns SQL query string
- */
-export declare function makePrimaryKeyConstraintQuery(dbType: DbType, table: string, defaultSchema?: string): string;
-/**
- * Transforms raw foreign key results from database into TableEditorForeignKey format
- * Groups by constraint name and aggregates columns
- */
-export declare function transformForeignKeys(rawResults: RawForeignKey[]): TableEditorForeignKey[];
-export declare function fetchTableRelationalKeys(input: DbInput, dbType: DbType, table: string, schema: string | undefined, workspace: string, dbArg: Record<string, any>, language: ScriptLang, getColDefs: () => Promise<TableMetadata>): Promise<{
-    foreignKeys: TableEditorForeignKey[];
-    pk_constraint_name?: string;
-    colDefs: TableMetadata;
-}>;

package/package/components/apps/components/display/dbtable/queries/relationalKeys.js

@@ -1,402 +0,0 @@
-import { wrapDucklakeQuery } from '../../../../../ducklake';
-import { runScriptAndPollResult } from '../../../../../jobs/utils';
-/**
- * Generates SQL query to fetch foreign key information for a specific table
- * @param dbType - The database type
- * @param table - The table name (can include schema, e.g., "schema.table")
- * @param defaultSchema - The default schema to use when table doesn't include one
- * @returns SQL query string
- */
-export function makeForeignKeysQuery(dbType, table, defaultSchema) {
-    const tableParts = table.split('.');
-    const tableName = tableParts[tableParts.length - 1];
-    const schemaName = tableParts.length > 1 ? tableParts[0] : defaultSchema;
-    switch (dbType) {
-        case 'postgresql':
-            return makePostgresForeignKeysQuery(tableName, schemaName || 'public');
-        case 'mysql':
-            return makeMysqlForeignKeysQuery(tableName, schemaName || '');
-        case 'ms_sql_server':
-            return makeMsSqlForeignKeysQuery(tableName, schemaName || 'dbo');
-        case 'snowflake':
-            return makeSnowflakeForeignKeysQuery(tableName, schemaName || 'PUBLIC');
-        case 'bigquery':
-            return makeBigQueryForeignKeysQuery(tableName, schemaName);
-        case 'duckdb':
-            return makeDuckDbForeignKeysQuery(tableName, schemaName || 'main');
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-/**
- * Generates SQL query to fetch primary key constraint name for a specific table
- * @param dbType - The database type
- * @param table - The table name (can include schema, e.g., "schema.table")
- * @param defaultSchema - The default schema to use when table doesn't include one
- * @returns SQL query string
- */
-export function makePrimaryKeyConstraintQuery(dbType, table, defaultSchema) {
-    const tableParts = table.split('.');
-    const tableName = tableParts[tableParts.length - 1];
-    const schemaName = tableParts.length > 1 ? tableParts[0] : defaultSchema;
-    switch (dbType) {
-        case 'postgresql':
-            return makePostgresPrimaryKeyQuery(tableName, schemaName || 'public');
-        case 'mysql':
-            return makeMysqlPrimaryKeyQuery(tableName, schemaName || '');
-        case 'ms_sql_server':
-            return makeMsSqlPrimaryKeyQuery(tableName, schemaName || 'dbo');
-        case 'snowflake':
-            return makeSnowflakePrimaryKeyQuery(tableName, schemaName || 'PUBLIC');
-        case 'bigquery':
-            return makeBigQueryPrimaryKeyQuery(tableName, schemaName);
-        case 'duckdb':
-            return makeDuckDbPrimaryKeyQuery(tableName, schemaName || 'main');
-        default:
-            throw new Error(`Unsupported database type: ${dbType}`);
-    }
-}
-/**
- * Transforms raw foreign key results from database into TableEditorForeignKey format
- * Groups by constraint name and aggregates columns
- */
-export function transformForeignKeys(rawResults) {
-    // Group by constraint name
-    const grouped = new Map();
-    for (const fk of rawResults) {
-        const existing = grouped.get(fk.fk_constraint_name) || [];
-        existing.push(fk);
-        grouped.set(fk.fk_constraint_name, existing);
-    }
-    // Transform to TableEditorForeignKey format
-    return Array.from(grouped.values()).map((fks) => {
-        const firstFk = fks[0];
-        return {
-            fk_constraint_name: firstFk.fk_constraint_name,
-            targetTable: firstFk.target_table,
-            columns: fks.map((fk) => ({
-                sourceColumn: fk.source_column,
-                targetColumn: fk.target_column
-            })),
-            onDelete: firstFk.on_delete,
-            onUpdate: firstFk.on_update
-        };
-    });
-}
-// PostgreSQL queries
-function makePostgresForeignKeysQuery(tableName, schemaName) {
-    return `
-SELECT
-    tc.constraint_name as fk_constraint_name,
-    kcu.column_name as source_column,
-    ccu.table_schema || '.' || ccu.table_name as target_table,
-    ccu.column_name as target_column,
-    COALESCE(rc.delete_rule, 'NO ACTION') as on_delete,
-    COALESCE(rc.update_rule, 'NO ACTION') as on_update
-FROM
-    information_schema.table_constraints AS tc
-    JOIN information_schema.key_column_usage AS kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.table_schema = kcu.table_schema
-    JOIN information_schema.constraint_column_usage AS ccu
-        ON ccu.constraint_name = tc.constraint_name
-        AND ccu.table_schema = tc.table_schema
-    LEFT JOIN information_schema.referential_constraints AS rc
-        ON rc.constraint_name = tc.constraint_name
-        AND rc.constraint_schema = tc.table_schema
-WHERE
-    tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_name = '${tableName}'
-    AND tc.table_schema = '${schemaName}'
-ORDER BY
-    tc.constraint_name, kcu.ordinal_position;
-`.trim();
-}
-function makePostgresPrimaryKeyQuery(tableName, schemaName) {
-    return `
-SELECT
-    tc.constraint_name
-FROM
-    information_schema.table_constraints AS tc
-WHERE
-    tc.constraint_type = 'PRIMARY KEY'
-    AND tc.table_name = '${tableName}'
-    AND tc.table_schema = '${schemaName}'
-LIMIT 1;
-`.trim();
-}
-// MySQL queries
-function makeMysqlForeignKeysQuery(tableName, schemaName) {
-    const whereClause = schemaName
-        ? `AND kcu.TABLE_SCHEMA = '${schemaName}'`
-        : `AND kcu.TABLE_SCHEMA = DATABASE()`;
-    return `
-SELECT
-    kcu.CONSTRAINT_NAME as fk_constraint_name,
-    kcu.COLUMN_NAME as source_column,
-    CONCAT(kcu.REFERENCED_TABLE_SCHEMA, '.', kcu.REFERENCED_TABLE_NAME) as target_table,
-    kcu.REFERENCED_COLUMN_NAME as target_column,
-    COALESCE(rc.DELETE_RULE, 'NO ACTION') as on_delete,
-    COALESCE(rc.UPDATE_RULE, 'NO ACTION') as on_update
-FROM
-    INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
-    JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-        ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
-        AND kcu.TABLE_SCHEMA = rc.CONSTRAINT_SCHEMA
-WHERE
-    kcu.TABLE_NAME = '${tableName}'
-    ${whereClause}
-    AND kcu.REFERENCED_TABLE_NAME IS NOT NULL
-ORDER BY
-    kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION;
-`.trim();
-}
-function makeMysqlPrimaryKeyQuery(tableName, schemaName) {
-    const whereClause = schemaName
-        ? `AND tc.TABLE_SCHEMA = '${schemaName}'`
-        : `AND tc.TABLE_SCHEMA = DATABASE()`;
-    return `
-SELECT
-    tc.CONSTRAINT_NAME as constraint_name
-FROM
-    INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-WHERE
-    tc.CONSTRAINT_TYPE = 'PRIMARY KEY'
-    AND tc.TABLE_NAME = '${tableName}'
-    ${whereClause}
-LIMIT 1;
-`.trim();
-}
-// MS SQL Server queries
-function makeMsSqlForeignKeysQuery(tableName, schemaName) {
-    return `
-SELECT
-    fk.name as fk_constraint_name,
-    COL_NAME(fkc.parent_object_id, fkc.parent_column_id) as source_column,
-    OBJECT_SCHEMA_NAME(fkc.referenced_object_id) + '.' + OBJECT_NAME(fkc.referenced_object_id) as target_table,
-    COL_NAME(fkc.referenced_object_id, fkc.referenced_column_id) as target_column,
-    CASE fk.delete_referential_action
-        WHEN 0 THEN 'NO ACTION'
-        WHEN 1 THEN 'CASCADE'
-        WHEN 2 THEN 'SET NULL'
-        WHEN 3 THEN 'SET DEFAULT'
-    END as on_delete,
-    CASE fk.update_referential_action
-        WHEN 0 THEN 'NO ACTION'
-        WHEN 1 THEN 'CASCADE'
-        WHEN 2 THEN 'SET NULL'
-        WHEN 3 THEN 'SET DEFAULT'
-    END as on_update
-FROM
-    sys.foreign_keys fk
-    INNER JOIN sys.foreign_key_columns fkc
-        ON fk.object_id = fkc.constraint_object_id
-    INNER JOIN sys.tables t
-        ON fk.parent_object_id = t.object_id
-    INNER JOIN sys.schemas s
-        ON t.schema_id = s.schema_id
-WHERE
-    t.name = '${tableName}'
-    AND s.name = '${schemaName}'
-ORDER BY
-    fk.name, fkc.constraint_column_id;
-`.trim();
-}
-function makeMsSqlPrimaryKeyQuery(tableName, schemaName) {
-    return `
-SELECT
-    kc.name as constraint_name
-FROM
-    sys.key_constraints kc
-    INNER JOIN sys.tables t
-        ON kc.parent_object_id = t.object_id
-    INNER JOIN sys.schemas s
-        ON t.schema_id = s.schema_id
-WHERE
-    kc.type = 'PK'
-    AND t.name = '${tableName}'
-    AND s.name = '${schemaName}';
-`.trim();
-}
-// Snowflake queries
-function makeSnowflakeForeignKeysQuery(tableName, schemaName) {
-    return `
-SELECT
-    tc.constraint_name as fk_constraint_name,
-    kcu.column_name as source_column,
-    rc.unique_constraint_schema || '.' || ccu.table_name as target_table,
-    ccu.column_name as target_column,
-    COALESCE(rc.delete_rule, 'NO ACTION') as on_delete,
-    COALESCE(rc.update_rule, 'NO ACTION') as on_update
-FROM
-    information_schema.table_constraints tc
-    JOIN information_schema.referential_constraints rc
-        ON tc.constraint_name = rc.constraint_name
-        AND tc.constraint_schema = rc.constraint_schema
-    JOIN information_schema.key_column_usage kcu
-        ON tc.constraint_name = kcu.constraint_name
-        AND tc.constraint_schema = kcu.constraint_schema
-    JOIN information_schema.constraint_column_usage ccu
-        ON rc.unique_constraint_name = ccu.constraint_name
-        AND rc.unique_constraint_schema = ccu.constraint_schema
-WHERE
-    tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_name = '${tableName}'
-    AND tc.table_schema = '${schemaName}'
-ORDER BY
-    tc.constraint_name, kcu.ordinal_position;
-`.trim();
-}
-function makeSnowflakePrimaryKeyQuery(tableName, schemaName) {
-    return `
-SELECT
-    constraint_name
-FROM
-    information_schema.table_constraints
-WHERE
-    constraint_type = 'PRIMARY KEY'
-    AND table_name = '${tableName}'
-    AND table_schema = '${schemaName}'
-LIMIT 1;
-`.trim();
-}
-// BigQuery queries
-function makeBigQueryForeignKeysQuery(tableName, schemaName) {
-    if (!schemaName) {
-        throw new Error('BigQuery requires a dataset (schema) name');
-    }
-    return `
-SELECT
-    tc.constraint_name as fk_constraint_name,
-    kcu.column_name as source_column,
-    ccu.table_name as target_table,
-    ccu.column_name as target_column,
-    'NO ACTION' as on_delete,
-    'NO ACTION' as on_update
-FROM
-    \`${schemaName}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS\` tc
-    JOIN \`${schemaName}.INFORMATION_SCHEMA.KEY_COLUMN_USAGE\` kcu
-        ON tc.constraint_name = kcu.constraint_name
-    JOIN \`${schemaName}.INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE\` ccu
-        ON tc.constraint_name = ccu.constraint_name
-WHERE
-    tc.constraint_type = 'FOREIGN KEY'
-    AND tc.table_name = '${tableName}'
-ORDER BY
-    tc.constraint_name, kcu.ordinal_position;
-`.trim();
-}
-function makeBigQueryPrimaryKeyQuery(tableName, schemaName) {
-    if (!schemaName) {
-        throw new Error('BigQuery requires a dataset (schema) name');
-    }
-    return `
-SELECT
-    constraint_name
-FROM
-    \`${schemaName}.INFORMATION_SCHEMA.TABLE_CONSTRAINTS\`
-WHERE
-    constraint_type = 'PRIMARY KEY'
-    AND table_name = '${tableName}'
-LIMIT 1;
-`.trim();
-}
-// DuckDB queries
-function makeDuckDbForeignKeysQuery(tableName, schemaName) {
-    // DuckDB supports foreign keys starting from v0.9.0
-    return `
-SELECT
-    fk_constraint.constraint_name as fk_constraint_name,
-    kcu.column_name as source_column,
-    ccu.table_schema || '.' || ccu.table_name as target_table,
-    ccu.column_name as target_column,
-    'NO ACTION' as on_delete,
-    'NO ACTION' as on_update
-FROM
-    information_schema.table_constraints fk_constraint
-    JOIN information_schema.key_column_usage kcu
-        ON fk_constraint.constraint_name = kcu.constraint_name
-        AND fk_constraint.constraint_schema = kcu.constraint_schema
-    JOIN information_schema.constraint_column_usage ccu
-        ON fk_constraint.constraint_name = ccu.constraint_name
-        AND fk_constraint.constraint_schema = ccu.constraint_schema
-WHERE
-    fk_constraint.constraint_type = 'FOREIGN KEY'
-    AND fk_constraint.table_name = '${tableName}'
-    AND fk_constraint.table_schema = '${schemaName}'
-ORDER BY
-    fk_constraint.constraint_name, kcu.ordinal_position;
-`.trim();
-}
-function makeDuckDbPrimaryKeyQuery(tableName, schemaName) {
-    return `
-SELECT
-    constraint_name
-FROM
-    information_schema.table_constraints
-WHERE
-    constraint_type = 'PRIMARY KEY'
-    AND table_name = '${tableName}'
-    AND table_schema = '${schemaName}'
-LIMIT 1;
-`.trim();
-}
-export async function fetchTableRelationalKeys(input, dbType, table, schema, workspace, dbArg, language, getColDefs) {
-    let fkPromise = async () => {
-        try {
-            if (dbType !== 'bigquery') {
-                let fkQuery = makeForeignKeysQuery(dbType, table, schema);
-                if (input.type === 'ducklake')
-                    fkQuery = wrapDucklakeQuery(fkQuery, input.ducklake);
-                const fkResult = await runScriptAndPollResult({
-                    workspace,
-                    requestBody: { args: dbArg, content: fkQuery, language }
-                });
-                let rawForeignKeys = fkResult;
-                if (rawForeignKeys && Array.isArray(rawForeignKeys)) {
-                    // Lowercase keys for consistency
-                    rawForeignKeys = rawForeignKeys.map((fk) => {
-                        const lowerFk = {};
-                        Object.keys(fk).forEach((key) => {
-                            lowerFk[key.toLowerCase()] = fk[key];
-                        });
-                        return lowerFk;
-                    });
-                    return transformForeignKeys(rawForeignKeys);
-                }
-            }
-        }
-        catch (e) {
-            console.warn('Failed to fetch foreign keys:', e);
-        }
-        return [];
-    };
-    let pkPromise = async () => {
-        try {
-            if (dbType !== 'bigquery' && dbType !== 'mysql') {
-                let pkQuery = makePrimaryKeyConstraintQuery(dbType, table, schema);
-                if (input.type === 'ducklake')
-                    pkQuery = wrapDucklakeQuery(pkQuery, input.ducklake);
-                const pkResult = await runScriptAndPollResult({
-                    workspace,
-                    requestBody: { args: dbArg, content: pkQuery, language }
-                });
-                let rawPkResult = pkResult;
-                if (rawPkResult && Array.isArray(rawPkResult) && rawPkResult.length > 0) {
-                    const pkRecord = rawPkResult[0];
-                    const pk_constraint_name = pkRecord?.constraint_name || pkRecord?.CONSTRAINT_NAME || '';
-                    return pk_constraint_name;
-                }
-            }
-        }
-        catch (e) {
-            console.warn('Failed to fetch primary key constraint:', e);
-        }
-    };
-    const [foreignKeys, pk_constraint_name, colDefs] = await Promise.all([
-        fkPromise(),
-        pkPromise(),
-        getColDefs()
-    ]);
-    return { foreignKeys, pk_constraint_name, colDefs };
-}

package/package/components/apps/components/display/dbtable/tableEditor.d.ts

@@ -1,35 +0,0 @@
-import type { ColumnMetadata, TableMetadata } from './utils';
-export type TableEditorValues = {
-    name: string;
-    columns: TableEditorValuesColumn[];
-    foreignKeys: TableEditorForeignKey[];
-    pk_constraint_name?: string;
-};
-export type TableEditorValuesColumn = {
-    name: string;
-    datatype: string;
-    primaryKey?: boolean;
-    defaultValue?: string;
-    nullable?: boolean;
-    datatype_length?: number;
-    initialName?: string;
-    default_constraint_name?: string;
-};
-export type TableEditorForeignKey = {
-    targetTable?: string;
-    columns: {
-        sourceColumn?: string;
-        targetColumn?: string;
-    }[];
-    onDelete: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-    onUpdate: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-    fk_constraint_name?: string;
-};
-export declare function datatypeDefaultLength(datatype: string): number;
-export declare function buildTableEditorValues({ metadata, tableName, pk_constraint_name, foreignKeys }: {
-    metadata: TableMetadata;
-    tableName: string;
-    pk_constraint_name?: string;
-    foreignKeys: TableEditorForeignKey[];
-}): TableEditorValues;
-export declare function columnDefToTableEditorValuesColumn(colDef: ColumnMetadata): TableEditorValuesColumn;

package/package/components/apps/components/display/dbtable/tableEditor.js

@@ -1,49 +0,0 @@
-import { countChars } from '../../../../../utils';
-export function datatypeDefaultLength(datatype) {
-    datatype = datatype.toLowerCase();
-    if (datatype == 'bit')
-        return 1;
-    if (['varchar', 'char', 'nvarchar', 'nchar', 'varbinary', 'binary'].includes(datatype)) {
-        return 255;
-    }
-    else {
-        return 10;
-    }
-}
-export function buildTableEditorValues({ metadata, tableName, pk_constraint_name, foreignKeys }) {
-    return {
-        name: tableName,
-        columns: metadata.map(columnDefToTableEditorValuesColumn),
-        pk_constraint_name,
-        foreignKeys
-    };
-}
-export function columnDefToTableEditorValuesColumn(colDef) {
-    let datatype;
-    let datatype_length;
-    const match = colDef.datatype?.match(/^([\w\s]+?)(?:\((\d+)\))?(\[\])?$/);
-    if (match) {
-        datatype = match[1].replace(/\s+/g, ' ').trim().toUpperCase() + (match[3] || ''); // Normalize spaces and add '[]' if it's an array type
-        datatype_length = match[2] ? parseInt(match[2], 10) : datatypeDefaultLength(datatype);
-    }
-    else {
-        datatype = colDef.datatype?.replace(/\s+/g, ' ').toUpperCase() || 'UNKNOWN';
-    }
-    const defaultValue = colDef.defaultvalue
-        ? colDef.defaultvalue.startsWith("'") &&
-            colDef.defaultvalue.endsWith("'") &&
-            countChars(colDef.defaultvalue, "'") === 2
-            ? colDef.defaultvalue.substring(1, colDef.defaultvalue.length - 1)
-            : `{${colDef.defaultvalue}}`
-        : undefined;
-    return {
-        name: colDef.field,
-        primaryKey: colDef.isprimarykey,
-        defaultValue,
-        nullable: colDef.isnullable !== 'NO',
-        datatype,
-        datatype_length,
-        initialName: colDef.field,
-        default_constraint_name: colDef.default_constraint_name
-    };
-}