windmill-components 1.596.1 → 1.613.0

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

@@ -1,25 +1,3 @@
 import type { DbType } from '../../../../../dbTypes';
-export type CreateTableValues = {
-    name: string;
-    columns: CreateTableValuesColumn[];
-    foreignKeys: {
-        targetTable?: string;
-        columns: {
-            sourceColumn?: string;
-            targetColumn?: string;
-        }[];
-        onDelete: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-        onUpdate: 'CASCADE' | 'SET NULL' | 'NO ACTION';
-    }[];
-};
-type CreateTableValuesColumn = {
-    name: string;
-    datatype: string;
-    primaryKey?: boolean;
-    defaultValue?: string;
-    nullable?: boolean;
-    datatype_length?: number;
-};
-export declare function makeCreateTableQuery(values: CreateTableValues, dbType: DbType, schema?: string): string;
-export declare function datatypeDefaultLength(datatype: string): number;
-export {};
+import type { TableEditorValues } from '../tableEditor';
+export declare function makeCreateTableQuery(values: TableEditorValues, dbType: DbType, schema?: string): string;

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

@@ -1,4 +1,5 @@
 import { dbSupportsSchemas } from '../utils';
+import { formatDefaultValue } from './dbQueriesUtils';
 export function makeCreateTableQuery(values, dbType, schema) {
     const pkCount = values.columns.reduce((p, c) => p + (c.primaryKey ? 1 : 0), 0);
     function transformColumn(c) {
@@ -9,8 +10,12 @@ export function makeCreateTableQuery(values, dbType, schema) {
             str += ' NOT NULL';
         if (defValue)
             str += ` DEFAULT ${defValue}`;
-        if (pkCount === 1 && c.primaryKey)
-            str += ' PRIMARY KEY';
+        if (pkCount === 1 && c.primaryKey) {
+            if (dbType === 'bigquery')
+                str += ' PRIMARY KEY NOT ENFORCED';
+            else
+                str += ' PRIMARY KEY';
+        }
         return str;
     }
     function transformFk(fk) {
@@ -31,31 +36,12 @@ export function makeCreateTableQuery(values, dbType, schema) {
     lines.push(...values.foreignKeys.map(transformFk));
     if (pkCount > 1) {
         const pks = values.columns.filter((c) => c.primaryKey);
-        lines.push(`  PRIMARY KEY (${pks.map((c) => c.name).join(', ')})`);
+        let pk = `  PRIMARY KEY (${pks.map((c) => c.name).join(', ')})`;
+        if (dbType === 'bigquery')
+            pk += ' NOT ENFORCED';
+        lines.push(pk);
     }
     return `CREATE TABLE ${useSchema && schema ? schema.trim() + '.' : ''}${values.name.trim()} (
 ${lines.join(',\n')}
 );`;
 }
-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 datatypeDefaultLength(datatype) {
-    datatype = datatype.toLowerCase();
-    if (datatype == 'bit')
-        return 1;
-    if (['varchar', 'char', 'nvarchar', 'nchar', 'varbinary', 'binary'].includes(datatype)) {
-        return 255;
-    }
-    else {
-        return 10;
-    }
-}

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

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,402 @@
+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/queries/select.d.ts

@@ -4,6 +4,8 @@ import { type ColumnDef } from '../utils';
 export declare function makeSelectQuery(table: string, columnDefs: ColumnDef[], whereClause: string | undefined, dbType: DbType, options?: {
     limit?: number;
     offset?: number;
+}, breakingFeatures?: {
+    fixPgIntTypes?: boolean;
 }): string;
 export declare function getSelectInput(dbInput: DbInput, table: string | undefined, columnDefs: ColumnDef[], whereClause: string | undefined, options?: {
     limit?: number;

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

@@ -53,7 +53,7 @@ function makeSnowflakeSelectQuery(table, columnDefs, whereClause, options) {
     query = buildParameters(headers, 'snowflake') + '\n' + query;
     return query;
 }
-export function makeSelectQuery(table, columnDefs, whereClause, dbType, options) {
+export function makeSelectQuery(table, columnDefs, whereClause, dbType, options, breakingFeatures) {
     if (!table)
         throw new Error('Table name is required');
     let quicksearchCondition = '';
@@ -84,11 +84,28 @@ CASE WHEN :order_by = '${column.field}' AND :is_desc IS true THEN \`${column.fie
             break;
         }
         case 'postgresql': {
+            function buildOrderBy({ field, is_desc = false, text_cast = false, check_is_number }) {
+                const numberCheckExpr = check_is_number === true
+                    ? ` pg_typeof("${field}")::text IN ('integer', 'bigint', 'smallint', 'numeric', 'real', 'double precision') AND`
+                    : check_is_number === false
+                        ? ` pg_typeof("${field}")::text NOT IN ('integer', 'bigint', 'smallint', 'numeric', 'real', 'double precision') AND`
+                        : '';
+                return `(CASE WHEN${numberCheckExpr} $4 = '${field}' AND $5 IS ${is_desc} THEN "${field}"${text_cast ? '::text' : ''} END)${is_desc ? ' DESC' : ''}`;
+            }
             const orderBy = `
       ${columnDefs
-                .map((column) => `
-      (CASE WHEN $4 = '${column.field}' AND $5 IS false THEN "${column.field}"::text END),
-      (CASE WHEN $4 = '${column.field}' AND $5 IS true THEN "${column.field}"::text END) DESC`)
+                .map((column) => {
+                if (breakingFeatures?.fixPgIntTypes) {
+                    return `
+      ${buildOrderBy({ field: column.field, is_desc: false, text_cast: true, check_is_number: false })},
+      ${buildOrderBy({ field: column.field, is_desc: false, text_cast: false, check_is_number: true })},
+      ${buildOrderBy({ field: column.field, is_desc: true, text_cast: true, check_is_number: false })},
+      ${buildOrderBy({ field: column.field, is_desc: true, text_cast: false, check_is_number: true })}`;
+                }
+                return `
+      ${buildOrderBy({ field: column.field, is_desc: false, text_cast: true })},
+      ${buildOrderBy({ field: column.field, is_desc: true, text_cast: true })}`;
+            })
                 .join(',\n')}`;
             quicksearchCondition = `($3 = '' OR CONCAT(${filteredColumns.join(', ')}) ILIKE '%' || $3 || '%')`;
             query += `SELECT ${filteredColumns
@@ -99,25 +116,39 @@ CASE WHEN :order_by = '${column.field}' AND :is_desc IS true THEN \`${column.fie
             query += ` LIMIT $1::INT OFFSET $2::INT`;
             break;
         }
-        case 'ms_sql_server':
+        case 'ms_sql_server': {
             // MSSQL uses CONCAT for string concatenation and supports OFFSET FETCH for pagination
             // Note: MSSQL does not have a built-in ILIKE function, so we use LIKE with a case-insensitive collation if needed
             //
             // Note 2: CONCAT in mssql requires 2 to 254 arguments. But we can't change this query without breaking
             // existing policies
+            // Filter out data types that cannot be sorted or concatenated in MS SQL Server
+            const unsortableTypes = ['text', 'ntext', 'image'];
             const orderBy = columnDefs
+                .filter((column) => !unsortableTypes.includes(column.datatype.toLowerCase()))
                 .map((column) => {
                 return `
 (CASE WHEN @p4 = '${column.field}' AND @p5 = 0 THEN ${column.field} END) ASC,
 (CASE WHEN @p4 = '${column.field}' AND @p5 = 1 THEN ${column.field} END) DESC`;
             })
                 .join(',\n');
-            quicksearchCondition = ` (@p3 = '' OR CONCAT(${selectClause}) LIKE '%' + @p3 + '%')`;
+            // Create search clause that excludes unsortable types to avoid CONCAT issues
+            const searchClause = filteredColumns
+                .filter((col) => {
+                const fieldName = col.slice(1, -1); // Remove brackets
+                const def = columnDefs.find((c) => c.field === fieldName);
+                return !unsortableTypes.includes(def?.datatype.toLowerCase() ?? '');
+            })
+                .join(', ');
+            quicksearchCondition = searchClause
+                ? ` (@p3 = '' OR CONCAT(${searchClause}) LIKE '%' + @p3 + '%')`
+                : ` (@p3 = '')`;
             query += `SELECT ${selectClause} FROM ${table}`;
             query += ` WHERE ${whereClause ? `${whereClause} AND` : ''} ${quicksearchCondition}`;
             query += ` ORDER BY ${orderBy}`;
             query += ` OFFSET @p2 ROWS FETCH NEXT @p1 ROWS ONLY`;
             break;
+        }
         case 'snowflake': {
             return makeSnowflakeSelectQuery(table, columnDefs, whereClause, options);
         }