windmill-components 1.555.1 → 1.558.2

package/package/components/apps/components/display/dbtable/AppDbExplorer.svelte

@@ -18,7 +18,7 @@ import { CancelablePromise } from '../../../../../gen';
 import RefreshButton from '../../helpers/RefreshButton.svelte';
 import RunnableWrapper from '../../helpers/RunnableWrapper.svelte';
 import InsertRowDrawerButton from '../InsertRowDrawerButton.svelte';
-import { assert } from '../../../../../utils';
+import { getDucklakeSchema } from '../../../../dbOps';
 let { id, configuration, customCss = undefined, render, initializing = $bindable(undefined), actions = [] } = $props();
 $effect.pre(() => {
     if (initializing === undefined) {
@@ -53,7 +53,7 @@ function computeInput(columnDefs, whereClause, resource) {
     timeoutInput = setTimeout(() => {
         timeoutInput = undefined;
         console.log('compute input');
-        input = getSelectInput(resource, resolvedConfig.type.configuration[resolvedConfig.type.selected].table, columnDefs, whereClause, resolvedConfig.type.selected);
+        input = getSelectInput(dbInput, resolvedConfig.type.configuration[resolvedConfig.type.selected].table, columnDefs, whereClause);
     }, 1000);
 }
 const { app, worldStore, mode, selectedComponent } = getContext('AppViewerContext');
@@ -68,9 +68,23 @@ let renderCount = $state(0);
 let insertDrawer = undefined;
 let componentContainerHeight = $state(undefined);
 let buttonContainerHeight = $state(undefined);
+let dbPath = $derived(resolvedConfig.type.selected !== 'ducklake'
+    ? resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.resource
+    : resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.ducklake);
+let dbInput = $derived(resolvedConfig.type.selected === 'ducklake'
+    ? {
+        type: 'ducklake',
+        ducklake: dbPath.split('ducklake://')[1]
+    }
+    : {
+        type: 'database',
+        resourcePath: dbPath.split('$res:')[1],
+        resourceType: resolvedConfig.type.selected
+    });
+let dbtype = $derived(resolvedConfig.type.selected === 'ducklake' ? 'duckdb' : resolvedConfig.type.selected);
 function onUpdate(e) {
     const { columnDef, value, data, oldValue } = e.detail;
-    updateCell?.triggerUpdate(resolvedConfig.type.configuration[resolvedConfig.type.selected].resource, resolvedConfig.type.configuration[resolvedConfig.type.selected].table ?? 'unknown', columnDef, resolvedConfig.columnDefs, value, data, oldValue, resolvedConfig.type.selected);
+    updateCell?.triggerUpdate(dbInput, resolvedConfig.type.configuration[resolvedConfig.type.selected].table ?? 'unknown', columnDef, resolvedConfig.columnDefs, value, data, oldValue);
 }
 let outputs = initOutput($worldStore, id, {
     selectedRowIndex: 0,
@@ -98,33 +112,34 @@ function updateOneOfConfiguration(oneOfConfiguration, resolvedConfig, patch) {
     });
 }
 async function listTables() {
-    let resource = resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.resource;
-    if (!resource)
+    if (!dbPath)
         return;
-    if (lastResource === resource)
+    if (lastResource === dbPath)
         return;
-    lastResource = resource;
+    lastResource = dbPath;
     const gridItem = findGridItem($app, id);
-    if (!gridItem) {
+    if (!gridItem)
         return;
-    }
-    updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, {
-        table: {
-            selectOptions: [],
-            loading: true
-        }
-    });
-    if (!resolvedConfig.type?.configuration?.[resolvedConfig.type.selected]?.resource) {
+    updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, { table: { selectOptions: [], loading: true } });
+    if (!dbPath) {
         $app = $app;
         return;
     }
     try {
         const dbSchemas = {};
-        await getDbSchemas(resolvedConfig?.type?.selected, resolvedConfig.type.configuration[resolvedConfig?.type?.selected].resource.split(':')[1], $workspaceStore, dbSchemas, () => { });
+        if (resolvedConfig?.type?.selected === 'ducklake') {
+            dbSchemas[dbPath] = await getDucklakeSchema({
+                workspace: $workspaceStore,
+                ducklake: dbPath.split('ducklake://')[1]
+            });
+        }
+        else {
+            await getDbSchemas(resolvedConfig?.type?.selected, dbPath.split('$res:')[1], $workspaceStore, dbSchemas, () => { });
+        }
         updateOneOfConfiguration(gridItem.data.configuration.type, resolvedConfig.type, {
             table: {
                 selectOptions: dbSchemas
-                    ? await getTablesByResource(dbSchemas, resolvedConfig?.type?.selected, resource.split(':')[1], $workspaceStore)
+                    ? await getTablesByResource(dbSchemas, dbtype, dbPath, $workspaceStore)
                     : [],
                 loading: false
             }
@@ -225,13 +240,16 @@ async function listColumnsIfAvailable() {
     gridItem.data.configuration.columnDefs.loading = true;
     gridItem.data = gridItem.data;
     $app = $app;
-    let resource = resolvedConfig.type.configuration[selected].resource;
-    assert('resource starts with $res:', resource?.startsWith('$res:'), resource);
-    let tableMetadata = await loadTableMetaData({
-        type: 'database',
-        resourcePath: resource.substring(5),
-        resourceType: selected
-    }, $workspaceStore, resolvedConfig.type.configuration[selected].table);
+    let tableMetadata = await loadTableMetaData(resolvedConfig.type.selected === 'ducklake'
+        ? {
+            type: 'ducklake',
+            ducklake: dbPath.split('ducklake://')[1]
+        }
+        : {
+            type: 'database',
+            resourcePath: dbPath.split('$res:')[1],
+            resourceType: dbtype
+        }, $workspaceStore, resolvedConfig.type.configuration[selected].table);
     if (!tableMetadata)
         return;
     let old = columnDefs?.value ?? [];
@@ -339,7 +357,7 @@ function connectToComponents() {
 async function insert(args) {
     try {
         const selected = resolvedConfig.type.selected;
-        await insertRowRunnable?.insertRow(resolvedConfig.type.configuration[selected].resource, $workspaceStore, resolvedConfig.type.configuration[selected].table, resolvedConfig.columnDefs, args, selected);
+        await insertRowRunnable?.insertRow(dbInput, $workspaceStore, resolvedConfig.type.configuration[selected].table, resolvedConfig.columnDefs, args);
         insertDrawer?.closeDrawer();
         renderCount++;
     }
@@ -355,8 +373,7 @@ let dbExplorerCount = $state(undefined);
 function onDelete(e) {
     const data = { ...e.detail };
     delete data['__index'];
-    const selected = resolvedConfig.type.selected;
-    deleteRow?.triggerDelete(resolvedConfig.type.configuration[selected].resource, resolvedConfig.type.configuration[selected].table ?? 'unknown', resolvedConfig.columnDefs, data, selected);
+    deleteRow?.triggerDelete(dbInput, resolvedConfig.type.configuration[resolvedConfig.type.selected].table ?? 'unknown', resolvedConfig.columnDefs, data);
 }
 let refreshCount = $state(0);
 let loading = $state(false);
@@ -370,14 +387,14 @@ $effect(() => {
     resolvedConfig.type.selected &&
         render &&
         untrack(() => {
-            computeInput(resolvedConfig.columnDefs, resolvedConfig.whereClause, resolvedConfig.type.configuration[resolvedConfig.type.selected].resource);
+            computeInput(resolvedConfig.columnDefs, resolvedConfig.whereClause, dbPath);
         });
 });
 $effect(() => {
     editorContext != undefined &&
         $mode == 'dnd' &&
         resolvedConfig.type &&
-        resolvedConfig.type.configuration?.[resolvedConfig.type.selected]?.resource &&
+        dbPath &&
         untrack(() => listTables());
 });
 $effect(() => {
@@ -440,8 +457,7 @@ let hideInsert = $derived(resolvedConfig.hideInsert);
 		{id}
 		{quicksearch}
 		{table}
-		resource={resolvedConfig?.type?.configuration?.[resolvedConfig?.type?.selected]?.resource}
-		resourceType={resolvedConfig?.type?.selected}
+		{dbInput}
 		columnDefs={resolvedConfig?.columnDefs}
 		whereClause={resolvedConfig?.whereClause}
 	/>
@@ -484,14 +500,14 @@ let hideInsert = $derived(resolvedConfig.hideInsert);
 					{#if hideInsert !== true}
 						<InsertRowDrawerButton
 							columnDefs={resolvedConfig.columnDefs}
-							dbType={resolvedConfig.type.selected}
+							dbType={dbtype}
 							onInsert={(args) => insert(args)}
 						/>
 					{/if}
 				</div>
 			</div>
 		{/if}
-		{#if resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.resource && resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.table}
+		{#if dbPath && resolvedConfig.type.configuration?.[resolvedConfig?.type?.selected]?.table}
 			<!-- {JSON.stringify(lastInput)} -->
 			<!-- <span class="text-xs">{JSON.stringify(configuration.columnDefs)}</span> -->
 			{#key renderCount && render}

package/package/components/apps/components/display/dbtable/DbExplorerCount.svelte

@@ -3,7 +3,7 @@ import RunnableWrapper from '../../helpers/RunnableWrapper.svelte';
 import { initOutput } from '../../../editor/appUtils';
 import {} from './utils';
 import { getCountInput } from './queries/count';
-let { id, table, resource, renderCount, quicksearch, resourceType, columnDefs, whereClause } = $props();
+let { id, table, renderCount, quicksearch, dbInput, columnDefs, whereClause } = $props();
 const { worldStore } = getContext('AppViewerContext');
 let outputs = initOutput($worldStore, `${id}_count`, {
     result: undefined,
@@ -32,15 +32,17 @@ export async function computeCount(forceCompute) {
             return;
         }
     }
-    if (table != undefined && resource !== undefined) {
+    if (table != undefined &&
+        ((dbInput.type == 'ducklake' && dbInput.ducklake !== undefined) ||
+            (dbInput.type == 'database' && dbInput.resourcePath !== undefined))) {
         renderCountLast = renderCount;
         lastTableCount = table;
         quicksearchLast = quicksearch;
-        await getCount(resource, table, quicksearch);
+        await getCount(dbInput, table, quicksearch);
     }
 }
-async function getCount(resource, table, quicksearch) {
-    input = getCountInput(resource, table, resourceType, localColumnDefs, whereClause);
+async function getCount(dbInput, table, quicksearch) {
+    input = getCountInput(dbInput, table, localColumnDefs, whereClause);
     await tick();
     if (runnableComponent) {
         await runnableComponent?.runComponent(undefined, undefined, undefined, {

package/package/components/apps/components/display/dbtable/DbExplorerCount.svelte.d.ts

@@ -1,13 +1,13 @@
 import { type ColumnDef } from './utils';
+import type { DbInput } from '../../../../dbOps';
 interface Props {
     id: string;
     table: string | undefined;
-    resource: string | undefined;
     renderCount: number;
     quicksearch: string;
-    resourceType: string;
     columnDefs: ColumnDef[];
     whereClause: string | undefined;
+    dbInput: DbInput;
 }
 declare const DbExplorerCount: import("svelte").Component<Props, {
     computeCount: (forceCompute?: boolean | undefined) => Promise<void>;

package/package/components/apps/components/display/dbtable/DeleteRow.svelte

@@ -15,10 +15,10 @@ let runnableComponent = $state();
 let loading = $state(false);
 let input = $state(undefined);
 const dispatch = createEventDispatcher();
-export async function triggerDelete(resource, table, allColumns, data, dbType) {
+export async function triggerDelete(dbInput, table, allColumns, data) {
     let primaryColumns = getPrimaryKeys(allColumns);
     let columns = allColumns?.filter((x) => primaryColumns.includes(x.field));
-    input = getDeleteInput(resource, table, columns, dbType);
+    input = getDeleteInput(dbInput, table, columns);
     await tick();
     if (runnableComponent) {
         let ndata = {};

package/package/components/apps/components/display/dbtable/DeleteRow.svelte.d.ts

@@ -1,4 +1,5 @@
-import { type ColumnDef, type DbType } from './utils';
+import { type ColumnDef } from './utils';
+import type { DbInput } from '../../../../dbOps';
 interface Props {
     id: string;
 }
@@ -20,7 +21,7 @@ declare const DeleteRow: $$__sveltets_2_IsomorphicComponent<Props, {
 } & {
     [evt: string]: CustomEvent<any>;
 }, {}, {
-    triggerDelete: (resource: string, table: string, allColumns: ColumnDef[], data: Record<string, any>, dbType: DbType) => Promise<void>;
+    triggerDelete: (dbInput: DbInput, table: string, allColumns: ColumnDef[], data: Record<string, any>) => Promise<void>;
 }, "">;
 type DeleteRow = InstanceType<typeof DeleteRow>;
 export default DeleteRow;

package/package/components/apps/components/display/dbtable/InsertRow.svelte

@@ -6,7 +6,7 @@ import { argSigToJsonSchemaType } from 'windmill-utils-internal';
 import SchemaForm from '../../../../SchemaForm.svelte';
 import { untrack } from 'svelte';
 import Toggle from '../../../../Toggle.svelte';
-let schema = $state(undefined);
+import { usePromise } from '../../../../../svelte5Utils.svelte';
 function parseSQLArgs(field, dbType) {
     let rawType = '';
     switch (dbType) {
@@ -46,11 +46,11 @@ function rawTypeToSchemaType(typ) {
         return typ;
     }
 }
-async function builtSchema(fields, dbType) {
+async function buildSchema() {
     const properties = {};
     const required = [];
     await init(wasmUrl);
-    fields.forEach((field) => {
+    fields?.forEach((field) => {
         const schemaProperty = {
             type: 'string'
         };
@@ -70,6 +70,12 @@ async function builtSchema(fields, dbType) {
                 schemaProperty.default = field.defaultValue;
             }
         }
+        if (field.type === 'timestamp without time zone' || field.type === 'timestamp') {
+            schemaProperty.format = 'naive-date-time';
+        }
+        if (field.type === 'timestamp with time zone' || field.type === 'timestamptz') {
+            schemaProperty.format = 'date-time';
+        }
         properties[field.name] = schemaProperty;
         const isRequired = (field.isPrimaryKey || field.defaultValue === undefined || field.defaultValue === null) &&
             field.nullable !== 'YES' &&
@@ -78,7 +84,7 @@ async function builtSchema(fields, dbType) {
             required.push(field.name);
         }
     });
-    schema = {
+    return {
         $schema: 'http://json-schema.org/draft-07/schema#',
         type: 'object',
         properties,
@@ -107,10 +113,10 @@ let fields = $derived(columnDefs
         nullable: column.isnullable
     };
 }));
+let schemaPromise = usePromise(buildSchema);
+let schema = $derived(schemaPromise.value);
 $effect(() => {
-    ;
-    [fields, dbType];
-    untrack(() => builtSchema(fields ?? [], dbType));
+    fields && dbType && untrack(() => schemaPromise.refresh());
 });
 $effect(() => {
     if (schema) {

package/package/components/apps/components/display/dbtable/InsertRowRunnable.svelte

@@ -15,11 +15,14 @@ let runnableComponent = $state();
 let loading = $state(false);
 let input = $state(undefined);
 const dispatch = createEventDispatcher();
-export async function insertRow(resource, workspace, table, columns, values, resourceType) {
-    if (!resource || !table || !workspace) {
+export async function insertRow(dbInput, workspace, table, columns, values) {
+    if ((dbInput.type == 'ducklake' && !dbInput.ducklake) ||
+        (dbInput.type == 'database' && !dbInput.resourcePath) ||
+        !table ||
+        !workspace) {
         return false;
     }
-    input = getInsertInput(table, columns, resource, resourceType);
+    input = getInsertInput(dbInput, table, columns);
     await tick();
     if (runnableComponent) {
         await runnableComponent?.runComponent(undefined, undefined, undefined, values, {

package/package/components/apps/components/display/dbtable/InsertRowRunnable.svelte.d.ts

@@ -1,4 +1,5 @@
 import { type ColumnDef } from './utils';
+import type { DbInput } from '../../../../dbOps';
 interface Props {
     id: string;
 }
@@ -20,7 +21,7 @@ declare const InsertRowRunnable: $$__sveltets_2_IsomorphicComponent<Props, {
 } & {
     [evt: string]: CustomEvent<any>;
 }, {}, {
-    insertRow: (resource: string, workspace: string | undefined, table: string | undefined, columns: ColumnDef[], values: Record<string, any>, resourceType: string) => Promise<boolean>;
+    insertRow: (dbInput: DbInput, workspace: string | undefined, table: string | undefined, columns: ColumnDef[], values: Record<string, any>) => Promise<boolean>;
 }, "">;
 type InsertRowRunnable = InstanceType<typeof InsertRowRunnable>;
 export default InsertRowRunnable;

package/package/components/apps/components/display/dbtable/UpdateCell.svelte

@@ -14,11 +14,11 @@ let outputs = initOutput($worldStore, `${id}_update`, {
 let runnableComponent = $state(undefined);
 let loading = $state(false);
 let input = $state(undefined);
-export async function triggerUpdate(resource, table, column, allColumns, valueToUpdate, data, oldValue = undefined, dbType) {
+export async function triggerUpdate(dbInput, table, column, allColumns, valueToUpdate, data, oldValue = undefined) {
     // const datatype = tableMetaData?.find((column) => column.isprimarykey)?.datatype
     let primaryColumns = getPrimaryKeys(allColumns);
     let columns = allColumns?.filter((x) => primaryColumns.includes(x.field));
-    input = getUpdateInput(resource, table, column, columns, dbType);
+    input = getUpdateInput(dbInput, table, column, columns);
     await tick();
     if (runnableComponent) {
         let ndata = {};

package/package/components/apps/components/display/dbtable/UpdateCell.svelte.d.ts

@@ -1,9 +1,10 @@
-import { type ColumnDef, type DbType } from './utils';
+import { type ColumnDef } from './utils';
+import type { DbInput } from '../../../../dbOps';
 interface Props {
     id: string;
 }
 declare const UpdateCell: import("svelte").Component<Props, {
-    triggerUpdate: (resource: string, table: string, column: ColumnDef, allColumns: ColumnDef[], valueToUpdate: string, data: Record<string, any>, oldValue: string | undefined, dbType: DbType) => Promise<void>;
+    triggerUpdate: (dbInput: DbInput, table: string, column: ColumnDef, allColumns: ColumnDef[], valueToUpdate: string, data: Record<string, any>, oldValue?: string | undefined) => Promise<void>;
 }, "">;
 type UpdateCell = ReturnType<typeof UpdateCell>;
 export default UpdateCell;

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

@@ -1,5 +1,6 @@
 import type { AppInput } from '../../../../inputType';
+import { type DbInput } from '../../../../../dbOps';
 import { type DbType } from '../utils';
 import { type ColumnDef } from '../utils';
 export declare function makeCountQuery(dbType: DbType, table: string, whereClause: string | undefined, columnDefs: ColumnDef[]): string;
-export declare function getCountInput(resource: string, table: string, resourceType: DbType, columnDefs: ColumnDef[], whereClause: string | undefined): AppInput | undefined;
+export declare function getCountInput(dbInput: DbInput, table: string, columnDefs: ColumnDef[], whereClause: string | undefined): AppInput | undefined;

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

@@ -1,3 +1,4 @@
+import { wrapDucklakeQuery } from '../../../../../dbOps';
 import { buildParameters } from '../utils';
 import { getLanguageByResourceType, buildVisibleFieldList } from '../utils';
 export function makeCountQuery(dbType, table, whereClause = undefined, columnDefs) {
@@ -106,27 +107,34 @@ export function makeCountQuery(dbType, table, whereClause = undefined, columnDef
     }
     return query;
 }
-export function getCountInput(resource, table, resourceType, columnDefs, whereClause) {
-    if (!resource || !table || !columnDefs) {
-        // Return undefined if resource or table is not defined
+export function getCountInput(dbInput, table, columnDefs, whereClause) {
+    if ((dbInput.type == 'ducklake' && !dbInput.ducklake) ||
+        (dbInput.type == 'database' && !dbInput.resourcePath) ||
+        !table ||
+        !columnDefs?.length) {
         return undefined;
     }
-    const query = makeCountQuery(resourceType, table, whereClause, columnDefs);
+    const dbType = dbInput.type === 'ducklake' ? 'duckdb' : dbInput.resourceType;
+    let query = makeCountQuery(dbType, table, whereClause, columnDefs);
+    if (dbInput.type === 'ducklake')
+        query = wrapDucklakeQuery(query, dbInput.ducklake);
     const updateRunnable = {
         name: 'AppDbExplorer',
         type: 'runnableByName',
         inlineScript: {
             content: query,
-            language: getLanguageByResourceType(resourceType),
+            language: getLanguageByResourceType(dbType),
             schema: {
                 $schema: 'https://json-schema.org/draft/2020-12/schema',
-                properties: {
-                    database: {
-                        description: 'Database name',
-                        type: 'object',
-                        format: `resource-${resourceType}`
+                properties: dbInput.type === 'database'
+                    ? {
+                        database: {
+                            description: 'Database name',
+                            type: 'object',
+                            format: `resource-${dbType}`
+                        }
                     }
-                },
+                    : {},
                 required: ['database'],
                 type: 'object'
             }
@@ -134,14 +142,16 @@ export function getCountInput(resource, table, resourceType, columnDefs, whereCl
     };
     const updateQuery = {
         runnable: updateRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: `resource-${resourceType}`
+        fields: dbInput.type === 'database'
+            ? {
+                database: {
+                    type: 'static',
+                    value: `$res:${dbInput.resourcePath}`,
+                    fieldType: 'object',
+                    format: `resource-${dbType}`
+                }
             }
-        },
+            : {},
         type: 'runnable',
         fieldType: 'object'
     };

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

@@ -17,7 +17,7 @@ type CreateTableValuesColumn = {
     datatype: string;
     primaryKey?: boolean;
     defaultValue?: string;
-    not_null?: boolean;
+    nullable?: boolean;
     datatype_length?: number;
 };
 export declare function makeCreateTableQuery(values: CreateTableValues, dbType: DbType, schema?: string): string;

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

@@ -5,7 +5,7 @@ export function makeCreateTableQuery(values, dbType, schema) {
         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.not_null)
+        if (!c.nullable)
             str += ' NOT NULL';
         if (defValue)
             str += ` DEFAULT ${defValue}`;

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

@@ -1,4 +1,5 @@
 import type { AppInput } from '../../../../inputType';
+import { type DbInput } from '../../../../../dbOps';
 import { type ColumnDef, type DbType } from '../utils';
 export declare function makeDeleteQuery(table: string, columns: ColumnDef[], dbType: DbType): string;
-export declare function getDeleteInput(resource: string, table: string, columns: ColumnDef[], dbType: DbType): AppInput | undefined;
+export declare function getDeleteInput(dbInput: DbInput, table: string, columns: ColumnDef[]): AppInput | undefined;

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

@@ -1,3 +1,4 @@
+import { wrapDucklakeQuery } from '../../../../../dbOps';
 import { getLanguageByResourceType, buildParameters } from '../utils';
 export function makeDeleteQuery(table, columns, dbType) {
     let query = buildParameters(dbType === 'snowflake' ? columns.flatMap((c) => [c, c]) : columns, dbType);
@@ -48,15 +49,21 @@ export function makeDeleteQuery(table, columns, dbType) {
             throw new Error('Unsupported database type');
     }
 }
-export function getDeleteInput(resource, table, columns, dbType) {
-    if (!resource || !table) {
+export function getDeleteInput(dbInput, table, columns) {
+    if ((dbInput.type == 'ducklake' && !dbInput.ducklake) ||
+        (dbInput.type == 'database' && !dbInput.resourcePath) ||
+        !table) {
         return undefined;
     }
+    const dbType = dbInput.type === 'ducklake' ? 'duckdb' : dbInput.resourceType;
+    let query = makeDeleteQuery(table, columns, dbType);
+    if (dbInput.type === 'ducklake')
+        query = wrapDucklakeQuery(query, dbInput.ducklake);
     const deleteRunnable = {
         name: 'AppDbExplorer',
         type: 'runnableByName',
         inlineScript: {
-            content: makeDeleteQuery(table, columns, dbType),
+            content: query,
             language: getLanguageByResourceType(dbType),
             schema: {
                 $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -68,14 +75,16 @@ export function getDeleteInput(resource, table, columns, dbType) {
     };
     const deleteQuery = {
         runnable: deleteRunnable,
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: `resource-${dbType}`
+        fields: dbInput.type == 'database'
+            ? {
+                database: {
+                    type: 'static',
+                    value: `$res:${dbInput.resourcePath}`,
+                    fieldType: 'object',
+                    format: `resource-${dbType}`
+                }
             }
-        },
+            : {},
         type: 'runnable',
         fieldType: 'object'
     };

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

@@ -1,5 +1,6 @@
 import type { AppInput } from '../../../../inputType';
+import { type DbInput } from '../../../../../dbOps';
 import { type DbType } from '../utils';
 import { type ColumnDef } from '../utils';
 export declare function makeInsertQuery(table: string, columns: ColumnDef[], dbType: DbType): string;
-export declare function getInsertInput(table: string, columns: ColumnDef[], resource: string, dbType: DbType): AppInput;
+export declare function getInsertInput(dbInput: DbInput, table: string, columns: ColumnDef[]): AppInput;

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

@@ -1,3 +1,4 @@
+import { wrapDucklakeQuery } from '../../../../../dbOps';
 import { buildParameters, ColumnIdentity } from '../utils';
 import { getLanguageByResourceType } from '../utils';
 function formatInsertValues(columns, dbType, startIndex = 1) {
@@ -80,16 +81,19 @@ export function makeInsertQuery(table, columns, dbType) {
     const defaultValues = formatDefaultValues(columnsDefault);
     const commaOrEmpty = shouldInsertComma ? ', ' : '';
     query += `INSERT INTO ${table} (${columnNames}) VALUES (${insertValues}${commaOrEmpty}${defaultValues})`;
-    console.log(query);
     return query;
 }
-export function getInsertInput(table, columns, resource, dbType) {
+export function getInsertInput(dbInput, table, columns) {
+    const dbType = dbInput.type === 'ducklake' ? 'duckdb' : dbInput.resourceType;
+    let query = makeInsertQuery(table, columns, dbType);
+    if (dbInput.type === 'ducklake')
+        query = wrapDucklakeQuery(query, dbInput.ducklake);
     return {
         runnable: {
             name: 'AppDbExplorer',
             type: 'runnableByName',
             inlineScript: {
-                content: makeInsertQuery(table, columns, dbType),
+                content: query,
                 language: getLanguageByResourceType(dbType),
                 schema: {
                     $schema: 'https://json-schema.org/draft/2020-12/schema',
@@ -99,14 +103,16 @@ export function getInsertInput(table, columns, resource, dbType) {
                 }
             }
         },
-        fields: {
-            database: {
-                type: 'static',
-                value: resource,
-                fieldType: 'object',
-                format: `resource-${dbType}`
+        fields: dbInput.type === 'database'
+            ? {
+                database: {
+                    type: 'static',
+                    value: `$res:${dbInput.resourcePath}`,
+                    fieldType: 'object',
+                    format: `resource-${dbType}`
+                }
             }
-        },
+            : {},
         type: 'runnable',
         fieldType: 'object'
     };

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

@@ -1,11 +1,12 @@
 import type { AppInput } from '../../../../inputType';
+import { type DbInput } from '../../../../../dbOps';
 import { type DbType } from '../utils';
 import { type ColumnDef } from '../utils';
 export declare function makeSelectQuery(table: string, columnDefs: ColumnDef[], whereClause: string | undefined, dbType: DbType, options?: {
     limit?: number;
     offset?: number;
 }): string;
-export declare function getSelectInput(resource: string, table: string | undefined, columnDefs: ColumnDef[], whereClause: string | undefined, dbType: DbType, options?: {
+export declare function getSelectInput(dbInput: DbInput, table: string | undefined, columnDefs: ColumnDef[], whereClause: string | undefined, options?: {
     limit?: number;
     offset?: number;
 }): AppInput | undefined;