@sqlrooms/duckdb 0.29.0-rc.1 → 0.29.0-rc.11

package/dist/DuckDbSlice.js

@@ -1,11 +1,55 @@
-import { createDbSchemaTrees, escapeVal, getColValAsNumber, isQualifiedTableName, joinStatements, makeQualifiedTableName, separateLastStatement, } from '@sqlrooms/duckdb-core';
+import { createDbSchemaTrees, escapeVal, getColValAsNumber, getRawSqlTableReference, getTableIdentity, isQualifiedTableName, joinStatements, makeQualifiedTableName, parseQualifiedSqlIdentifier, separateLastStatement, } from '@sqlrooms/duckdb-core';
 import { createSlice, registerCommandsForOwner, unregisterCommandsForOwner, useBaseRoomStore, } from '@sqlrooms/room-store';
 import * as arrow from 'apache-arrow';
 import deepEquals from 'fast-deep-equal';
 import { produce } from 'immer';
 import { z } from 'zod';
 import { createWasmDuckDbConnector } from './connectors/createDuckDbConnector';
+import { loadSchemaCatalog, loadTableSchemas, } from './loadTableSchemas';
 const DUCKDB_COMMAND_OWNER = '@sqlrooms/duckdb';
+const INTERNAL_SQLROOMS_PREFIX = '__sqlrooms';
+/** DuckDB's temporary database catalog; never show in the default data source tree. */
+const DUCKDB_TEMP_DATABASE = 'temp';
+/**
+ * Default predicate: which tables/schemas/databases appear in the data source panel.
+ * Hides `__sqlrooms_*` names and DuckDB's `temp` database.
+ */
+export const defaultLoadTableSchemasFilter = (table) => {
+    if (table.table.startsWith(INTERNAL_SQLROOMS_PREFIX) ||
+        table.database?.startsWith(INTERNAL_SQLROOMS_PREFIX) ||
+        table.schema?.startsWith(INTERNAL_SQLROOMS_PREFIX)) {
+        return false;
+    }
+    if (table.database === DUCKDB_TEMP_DATABASE) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Factory returning {@link defaultLoadTableSchemasFilter}.
+ * Hides `__sqlrooms_*` names and DuckDB's `temp` database.
+ * Apps can pass {@link CreateDuckDbSliceProps.loadTableSchemasFilter} to add more rules.
+ */
+export function createDefaultLoadTableSchemasFilter() {
+    return defaultLoadTableSchemasFilter;
+}
+/**
+ * Default catalog visibility predicate for the data source panel.
+ * Hides SQLRooms internal objects and DuckDB's temporary database catalog.
+ */
+export const defaultLoadSchemaCatalogFilter = (entry) => {
+    switch (entry.type) {
+        case 'database':
+            return (!entry.database.startsWith(INTERNAL_SQLROOMS_PREFIX) &&
+                entry.database !== DUCKDB_TEMP_DATABASE);
+        case 'schema':
+            return (!entry.database.startsWith(INTERNAL_SQLROOMS_PREFIX) &&
+                entry.database !== DUCKDB_TEMP_DATABASE &&
+                !entry.schema.startsWith(INTERNAL_SQLROOMS_PREFIX));
+        case 'table':
+            return defaultLoadTableSchemasFilter(entry.table);
+    }
+};
 const DropTableCommandInput = z.object({
     tableName: z.string().describe('Name of the table to drop.'),
 });
@@ -33,14 +77,74 @@ const CreateTableFromQueryCommandInput = z.object({
         .default(false)
         .describe('Allow multiple SQL statements where the final one is SELECT.'),
 });
-function isDuckDbPlaceholderViewColumn(columnName, columnType) {
-    return columnName === '__' && columnType.toUpperCase() === 'UNKNOWN';
-}
 /**
  * Create a DuckDB slice for managing the connector
  */
-export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } = {}) {
+export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), loadTableSchemasFilter = defaultLoadTableSchemasFilter, loadSchemaCatalogFilter, } = {}) {
+    let refreshPromise = null;
+    let pendingSchemaRefresh = false;
+    const effectiveSchemaCatalogFilter = loadSchemaCatalogFilter ??
+        (loadTableSchemasFilter === null
+            ? null
+            : ((entry) => {
+                if (entry.type === 'table') {
+                    return loadTableSchemasFilter
+                        ? loadTableSchemasFilter(entry.table)
+                        : true;
+                }
+                return defaultLoadSchemaCatalogFilter(entry);
+            }));
     return createSlice((set, get, store) => {
+        const parseTableReferenceParts = (tableName) => {
+            const parsed = parseQualifiedSqlIdentifier(tableName);
+            return parsed?.table
+                ? {
+                    database: parsed.database,
+                    schema: parsed.schema,
+                    table: parsed.table,
+                }
+                : { table: tableName };
+        };
+        /**
+         * Internal helper to load a table schema by exact name, bypassing the visibility filter.
+         * Used when performing exact lookups (e.g., checking if a specific table exists).
+         */
+        const loadTableSchemaByName = async (tableName) => {
+            const tableNameParts = typeof tableName === 'string'
+                ? parseTableReferenceParts(tableName)
+                : tableName;
+            const qualifiedName = get().db.qualifyTableName(tableNameParts);
+            const connector = await get().db.getConnector();
+            const [table] = await loadTableSchemas(connector, {
+                database: qualifiedName.database,
+                schema: qualifiedName.schema,
+                table: qualifiedName.table,
+                defaultDatabase: get().db.currentDatabase,
+            });
+            return table &&
+                table.table.table === qualifiedName.table &&
+                (!qualifiedName.schema ||
+                    table.table.schema === qualifiedName.schema) &&
+                (!qualifiedName.database ||
+                    table.table.database === qualifiedName.database)
+                ? table
+                : undefined;
+        };
+        const throwIfUnresolvedExplicitDatabaseReference = (tableName, table) => {
+            if (table) {
+                return;
+            }
+            const database = typeof tableName === 'string'
+                ? parseTableReferenceParts(tableName).database
+                : tableName.database;
+            if (!database) {
+                return;
+            }
+            const qualifiedName = isQualifiedTableName(tableName)
+                ? get().db.qualifyTableName(tableName)
+                : get().db.qualifyTableName(parseTableReferenceParts(tableName));
+            throw new Error(`Relation "${getRawSqlTableReference(qualifiedName)}" not found.`);
+        };
         return {
             db: {
                 connector, // Will be initialized during init
@@ -52,6 +156,16 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                 tableRowCounts: {},
                 schemaTrees: undefined,
                 queryCache: {},
+                qualifyTableName(tableName) {
+                    const { currentDatabase, currentSchema } = get().db;
+                    const parts = typeof tableName === 'string' ? { table: tableName } : tableName;
+                    return makeQualifiedTableName({
+                        database: parts.database ?? currentDatabase,
+                        schema: parts.schema ?? currentSchema,
+                        table: parts.table,
+                        defaultDatabase: parts.defaultDatabase ?? currentDatabase,
+                    });
+                },
                 setConnector: (connector) => {
                     set(produce((state) => {
                         state.config.dataSources = [];
@@ -60,7 +174,9 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                 },
                 initialize: async () => {
                     await get().db.connector.initialize();
-                    await get().db.refreshTableSchemas();
+                    // No await here, we want to continue initializing the room even
+                    // if the table schemas are not refreshed yet
+                    get().db.refreshTableSchemas();
                     registerCommandsForOwner(store, DUCKDB_COMMAND_OWNER, createDuckDbCommands());
                 },
                 getConnector: async () => {
@@ -69,6 +185,18 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                 },
                 destroy: async () => {
                     unregisterCommandsForOwner(store, DUCKDB_COMMAND_OWNER);
+                    // Wait for any in-flight refreshTableSchemas() to finish before
+                    // destroying the connector. initialize() fires it without await,
+                    // so it may still be querying the native DuckDB instance; tearing
+                    // that down mid-flight causes a use-after-free segfault.
+                    if (refreshPromise) {
+                        try {
+                            await refreshPromise;
+                        }
+                        catch {
+                            // ignore – we're shutting down
+                        }
+                    }
                     try {
                         if (get().db.connector) {
                             await get().db.connector.destroy();
@@ -92,14 +220,13 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                 async createTableFromQuery(tableName, query, options) {
                     const { replace = true, temp = false, view = false, allowMultipleStatements = false, abortSignal, } = options || {};
                     // For temp tables/views, DuckDB requires the "temp" database
-                    const baseQualifiedName = isQualifiedTableName(tableName)
-                        ? tableName
-                        : makeQualifiedTableName({ table: tableName });
+                    const baseQualifiedName = get().db.qualifyTableName(tableName);
                     const qualifiedName = temp
                         ? makeQualifiedTableName({
                             table: baseQualifiedName.table,
                             schema: baseQualifiedName.schema,
                             database: 'temp',
+                            defaultDatabase: get().db.currentDatabase,
                         })
                         : baseQualifiedName;
                     const connector = await get().db.getConnector();
@@ -121,7 +248,7 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                     ]
                         .filter(Boolean)
                         .join(' ');
-                    const createStatement = `${createKeyword} ${qualifiedName} AS (
+                    const createStatement = `${createKeyword} ${getRawSqlTableReference(qualifiedName)} AS (
               ${lastStatement}
             )`;
                     const fullQuery = joinStatements(precedingStatements, createStatement);
@@ -153,18 +280,19 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                  * @deprecated Use .loadTableRowCount() instead
                  */
                 async getTableRowCount(table, schema = 'main') {
-                    return get().db.loadTableRowCount({ table, schema });
+                    return get().db.loadTableRowCount(get().db.qualifyTableName({ table, schema }));
                 },
                 async loadTableRowCount(tableName) {
                     const { schema, database, table } = typeof tableName === 'string'
-                        ? { table: tableName }
-                        : tableName || {};
+                        ? get().db.qualifyTableName(parseTableReferenceParts(tableName))
+                        : get().db.qualifyTableName(tableName);
                     const connector = await get().db.getConnector();
-                    const result = await connector.query(`SELECT COUNT(*) FROM ${makeQualifiedTableName({
+                    const qualifiedName = get().db.qualifyTableName({
                         schema,
                         database,
                         table,
-                    })}`);
+                    });
+                    const result = await connector.query(`SELECT COUNT(*) FROM ${getRawSqlTableReference(qualifiedName)}`);
                     return getColValAsNumber(result);
                 },
                 /**
@@ -174,188 +302,182 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                     return await get().db.loadTableSchemas({ schema });
                 },
                 async loadTableSchemas(filter) {
-                    const { schema, database, table } = filter || {};
-                    const sql = `WITH tables_and_views AS (
-              FROM duckdb_tables() SELECT
-                database_name AS database,
-                schema_name AS schema,
-                table_name AS name,
-                sql,
-                comment,
-                estimated_size,
-                FALSE AS isView
-              UNION
-              FROM duckdb_views() SELECT
-                database_name AS database,
-                schema_name AS schema,
-                view_name AS name,
-                sql,
-                comment,
-                NULL estimated_size,
-                TRUE AS isView
-            )
-            SELECT
-                isView,
-                database, schema,
-                name, column_names, column_types,
-                sql, comment,
-                estimated_size
-            FROM (DESCRIBE)
-            LEFT OUTER JOIN tables_and_views USING (database, schema, name)
-            ${schema || database || table
-                        ? `WHERE ${[
-                            schema ? `schema = ${escapeVal(schema)}` : '',
-                            database ? `database = ${escapeVal(database)}` : '',
-                            table ? `name = ${escapeVal(table)}` : '',
-                        ]
-                            .filter(Boolean)
-                            .join(' AND ')}`
-                        : ''}`;
-                    const describeResults = await connector.query(sql);
-                    const newTables = [];
-                    for (let i = 0; i < describeResults.numRows; i++) {
-                        const isView = describeResults.getChild('isView')?.get(i);
-                        const database = describeResults.getChild('database')?.get(i);
-                        const schema = describeResults.getChild('schema')?.get(i);
-                        const table = describeResults.getChild('name')?.get(i);
-                        const sql = describeResults.getChild('sql')?.get(i);
-                        const comment = describeResults.getChild('comment')?.get(i);
-                        const estimatedSize = describeResults
-                            .getChild('estimated_size')
-                            ?.get(i);
-                        const columnNames = describeResults
-                            .getChild('column_names')
-                            ?.get(i);
-                        const columnTypes = describeResults
-                            .getChild('column_types')
-                            ?.get(i);
-                        const columns = [];
-                        for (let di = 0; di < (columnNames?.length ?? 0); di++) {
-                            const columnName = String(columnNames.get(di));
-                            const columnType = String(columnTypes?.get(di));
-                            if (isDuckDbPlaceholderViewColumn(columnName, columnType)) {
-                                continue;
-                            }
-                            columns.push({
-                                name: columnName,
-                                type: columnType,
-                            });
-                        }
-                        newTables.push({
-                            table: makeQualifiedTableName({ database, schema, table }),
-                            database,
-                            schema,
-                            tableName: table,
-                            columns,
-                            sql,
-                            comment,
-                            isView: Boolean(isView),
-                            rowCount: typeof estimatedSize === 'bigint'
-                                ? Number(estimatedSize)
-                                : estimatedSize === null
-                                    ? undefined
-                                    : estimatedSize,
-                        });
-                    }
-                    return newTables;
+                    const connector = await get().db.getConnector();
+                    return loadTableSchemas(connector, {
+                        ...filter,
+                        filterFunction: loadTableSchemasFilter,
+                        defaultDatabase: get().db.currentDatabase,
+                    });
                 },
                 async checkTableExists(tableName) {
-                    const qualifiedName = isQualifiedTableName(tableName)
-                        ? tableName
-                        : makeQualifiedTableName({ table: tableName });
-                    const table = (await get().db.loadTableSchemas(qualifiedName))[0];
-                    if (!table) {
-                        return false;
+                    const table = get().db.findTable(tableName) ??
+                        (await loadTableSchemaByName(tableName));
+                    return Boolean(table);
+                },
+                async dropRelation(tableName) {
+                    const connector = await get().db.getConnector();
+                    const table = get().db.findTable(tableName) ??
+                        (await loadTableSchemaByName(tableName));
+                    throwIfUnresolvedExplicitDatabaseReference(tableName, table);
+                    const qualifiedTable = table?.table ??
+                        (isQualifiedTableName(tableName)
+                            ? get().db.qualifyTableName(tableName)
+                            : get().db.qualifyTableName(parseTableReferenceParts(tableName)));
+                    const isView = table?.isView;
+                    const qualifiedTableReference = getRawSqlTableReference(qualifiedTable);
+                    if (isView) {
+                        await connector.query(`DROP VIEW IF EXISTS ${qualifiedTableReference};`);
+                    }
+                    else {
+                        await connector.query(`DROP TABLE IF EXISTS ${qualifiedTableReference};`);
                     }
-                    return true;
+                    get().db.refreshTableSchemas();
                 },
                 async dropTable(tableName) {
                     const connector = await get().db.getConnector();
-                    const qualifiedTable = isQualifiedTableName(tableName)
-                        ? tableName
-                        : makeQualifiedTableName({ table: tableName });
-                    await connector.query(`DROP TABLE IF EXISTS ${qualifiedTable};`);
-                    await get().db.refreshTableSchemas();
+                    const table = get().db.findTable(tableName) ??
+                        (await loadTableSchemaByName(tableName));
+                    throwIfUnresolvedExplicitDatabaseReference(tableName, table);
+                    const qualifiedTable = table?.table ??
+                        (isQualifiedTableName(tableName)
+                            ? get().db.qualifyTableName(tableName)
+                            : get().db.qualifyTableName(parseTableReferenceParts(tableName)));
+                    if (table?.isView) {
+                        throw new Error(`"${getRawSqlTableReference(qualifiedTable)}" is a view. Use dropRelation() to remove views.`);
+                    }
+                    await connector.query(`DROP TABLE IF EXISTS ${getRawSqlTableReference(qualifiedTable)};`);
+                    get().db.refreshTableSchemas();
                 },
                 async addTable(tableName, data) {
-                    const qualifiedName = isQualifiedTableName(tableName)
-                        ? tableName
-                        : makeQualifiedTableName({ table: tableName });
+                    const qualifiedName = get().db.qualifyTableName(tableName);
                     const { db } = get();
+                    const tableReference = getRawSqlTableReference(qualifiedName);
                     if (data instanceof arrow.Table) {
                         // TODO: make sure the table is replaced
-                        await db.connector.loadArrow(data, qualifiedName.toString());
+                        await db.connector.loadArrow(data, tableReference);
                     }
                     else {
-                        await db.connector.loadObjects(data, qualifiedName.toString(), {
+                        await db.connector.loadObjects(data, tableReference, {
                             replace: true,
                         });
                     }
-                    const newTable = (await db.loadTableSchemas(qualifiedName))[0];
+                    const newTable = await loadTableSchemaByName(qualifiedName);
                     if (!newTable) {
                         throw new Error('Failed to add table');
                     }
                     set((state) => produce(state, (draft) => {
                         draft.db.tables.push(newTable);
                     }));
-                    await get().db.refreshTableSchemas();
+                    get().db.refreshTableSchemas();
                     return newTable;
                 },
                 async setTableRowCount(tableName, rowCount) {
-                    const qualifiedName = isQualifiedTableName(tableName)
-                        ? tableName
-                        : makeQualifiedTableName({ table: tableName });
+                    const qualifiedName = get().db.qualifyTableName(tableName);
                     set((state) => produce(state, (draft) => {
-                        draft.db.tableRowCounts[qualifiedName.toString()] = rowCount;
+                        draft.db.tableRowCounts[getTableIdentity(qualifiedName)] =
+                            rowCount;
                     }));
                 },
                 getTable(tableName) {
-                    return get().db.findTableByName(tableName);
+                    return get().db.findTable(tableName);
                 },
-                findTableByName(tableName) {
-                    const { table, schema, database } = {
-                        schema: get().db.currentSchema,
-                        database: get().db.currentDatabase,
-                        ...(typeof tableName === 'string'
-                            ? { table: tableName }
-                            : tableName),
+                findTable(tableName) {
+                    const { currentSchema, currentDatabase, tables } = get().db;
+                    const findMatchingTable = ({ table, schema, database, }) => table
+                        ? tables.find((t) => t.table.table === table &&
+                            (!schema || t.table.schema === schema) &&
+                            (!database || t.table.database === database))
+                        : undefined;
+                    const findUniqueMatchingTable = ({ table, schema, }) => {
+                        if (!table)
+                            return undefined;
+                        const matches = tables.filter((t) => t.table.table === table &&
+                            (!schema || t.table.schema === schema));
+                        return matches.length === 1 ? matches[0] : undefined;
+                    };
+                    const resolvedTableName = typeof tableName === 'string'
+                        ? (parseQualifiedSqlIdentifier(tableName) ?? {})
+                        : tableName;
+                    const { table, schema, database, defaultDatabase } = {
+                        schema: currentSchema,
+                        database: currentDatabase,
+                        ...resolvedTableName,
                     };
-                    return get().db.tables.find((t) => t.table.table === table &&
-                        (!schema || t.table.schema === schema) &&
-                        (!database || t.table.database === database));
+                    const exactMatch = findMatchingTable({ table, schema, database });
+                    if (exactMatch)
+                        return exactMatch;
+                    const isStaleDefaultDatabaseReference = typeof tableName !== 'string' &&
+                        database &&
+                        defaultDatabase &&
+                        database === defaultDatabase &&
+                        database !== currentDatabase;
+                    if (isStaleDefaultDatabaseReference) {
+                        return findUniqueMatchingTable({ table, schema });
+                    }
+                    return undefined;
+                },
+                findTableByName(tableName) {
+                    return get().db.findTable(tableName);
                 },
                 async refreshTableSchemas() {
+                    if (refreshPromise) {
+                        pendingSchemaRefresh = true;
+                        return refreshPromise;
+                    }
                     set((state) => produce(state, (draft) => {
                         draft.db.isRefreshingTableSchemas = true;
                     }));
-                    try {
-                        const connector = await get().db.getConnector();
-                        const result = await connector.query(`SELECT current_schema() AS schema, current_database() AS database`);
-                        set((state) => produce(state, (draft) => {
-                            draft.db.currentSchema = result.getChild('schema')?.get(0);
-                            draft.db.currentDatabase = result
-                                .getChild('database')
-                                ?.get(0);
-                        }));
-                        const newTables = await get().db.loadTableSchemas();
-                        // Only update if there's an actual change in the schemas
-                        if (!deepEquals(newTables, get().db.tables)) {
+                    refreshPromise = (async () => {
+                        try {
+                            let schemasWithTables = [];
+                            do {
+                                pendingSchemaRefresh = false;
+                                const connector = await get().db.getConnector();
+                                const result = await connector.query(`SELECT current_schema() AS schema, current_database() AS database`);
+                                const currentSchemaValue = result.getChild('schema')?.get(0);
+                                const currentDatabaseValue = result
+                                    .getChild('database')
+                                    ?.get(0);
+                                const currentSchema = currentSchemaValue == null
+                                    ? undefined
+                                    : String(currentSchemaValue);
+                                const currentDatabase = currentDatabaseValue == null
+                                    ? undefined
+                                    : String(currentDatabaseValue);
+                                set((state) => produce(state, (draft) => {
+                                    draft.db.currentSchema = currentSchema;
+                                    draft.db.currentDatabase = currentDatabase;
+                                }));
+                                schemasWithTables = await loadSchemaCatalog(connector, {
+                                    filterFunction: effectiveSchemaCatalogFilter,
+                                    defaultDatabase: currentDatabase,
+                                });
+                            } while (pendingSchemaRefresh);
+                            const newTables = schemasWithTables.flatMap((s) => s.tables);
+                            const currentTables = get().db.tables;
+                            const currentSchemaTrees = get().db.schemaTrees;
+                            const newSchemaTrees = createDbSchemaTrees(schemasWithTables);
+                            if (!deepEquals(newTables, currentTables) ||
+                                !deepEquals(newSchemaTrees, currentSchemaTrees)) {
+                                set((state) => produce(state, (draft) => {
+                                    draft.db.tables = newTables;
+                                    draft.db.schemaTrees = newSchemaTrees;
+                                }));
+                            }
+                            return newTables;
+                        }
+                        catch (err) {
+                            get().room.captureException(err);
+                            return [];
+                        }
+                        finally {
+                            refreshPromise = null;
                             set((state) => produce(state, (draft) => {
-                                draft.db.tables = newTables;
-                                draft.db.schemaTrees = createDbSchemaTrees(newTables);
+                                draft.db.isRefreshingTableSchemas = false;
                             }));
                         }
-                        return newTables;
-                    }
-                    catch (err) {
-                        get().room.captureException(err);
-                        return [];
-                    }
-                    finally {
-                        set((state) => produce(state, (draft) => {
-                            draft.db.isRefreshingTableSchemas = false;
-                        }));
-                    }
+                    })();
+                    return refreshPromise;
                 },
                 async sqlSelectToJson(sql) {
                     const connector = await get().db.getConnector();
@@ -378,7 +500,12 @@ export function createDuckDbSlice({ connector = createWasmDuckDbConnector(), } =
                     set((state) => produce(state, (draft) => {
                         draft.db.queryCache[queryKey] = queryHandle;
                     }));
-                    queryHandle.result.finally(() => {
+                    queryHandle.result
+                        .catch(() => {
+                        // Prevent unhandled promise rejection warnings.
+                        // Callers handle errors via await/try-catch.
+                    })
+                        .finally(() => {
                         // remove from cache after completion
                         set((state) => produce(state, (draft) => {
                             delete draft.db.queryCache[queryKey];
@@ -415,10 +542,18 @@ function createDuckDbCommands() {
         },
         {
             id: 'db.drop-table',
-            name: 'Drop table',
-            description: 'Drop a table from DuckDB by name',
+            name: 'Drop relation',
+            description: 'Drop a table or view from DuckDB by name',
             group: 'Database',
-            keywords: ['duckdb', 'database', 'drop', 'table', 'delete'],
+            keywords: [
+                'duckdb',
+                'database',
+                'drop',
+                'table',
+                'view',
+                'relation',
+                'delete',
+            ],
             inputSchema: DropTableCommandInput,
             inputDescription: 'Provide a tableName to remove from DuckDB.',
             metadata: {
@@ -436,11 +571,11 @@ function createDuckDbCommands() {
             },
             execute: async ({ getState }, input) => {
                 const { tableName } = input;
-                await getState().db.dropTable(tableName);
+                await getState().db.dropRelation(tableName);
                 return {
                     success: true,
                     commandId: 'db.drop-table',
-                    message: `Dropped table "${tableName}".`,
+                    message: `Dropped relation "${tableName}".`,
                 };
             },
         },