@lightdash/warehouses 0.3453.0 → 0.3454.0

package/dist/warehouseClients/DuckdbWarehouseClient.js

@@ -7,6 +7,7 @@ exports.DuckdbWarehouseClient = exports.DuckdbSqlBuilder = exports.getDuckdbTime
 const node_api_1 = require("@duckdb/node-api");
 const common_1 = require("@lightdash/common");
 const crypto_1 = require("crypto");
+const fs_1 = __importDefault(require("fs"));
 const promises_1 = __importDefault(require("fs/promises"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
@@ -137,6 +138,28 @@ class AsyncSemaphore {
         }
     }
 }
+class ConcurrencyBudget {
+    constructor(limit) {
+        this.limit = limit;
+        this.active = 0;
+    }
+    tryAcquire() {
+        if (this.active >= this.limit) {
+            return false;
+        }
+        this.active += 1;
+        return true;
+    }
+    release() {
+        this.active -= 1;
+    }
+    isIdle() {
+        return this.active === 0;
+    }
+    reset() {
+        this.active = 0;
+    }
+}
 // DuckDB StatementType values — see duckdb/common/enums/statement_type.hpp
 const ALLOWED_STATEMENT_TYPES_USER_SQL = new Set([1 /* SELECT */]);
 const BLOCKED_STATEMENT_TYPES_INTERNAL_SQL = new Set([
@@ -148,7 +171,7 @@ const BLOCKED_STATEMENT_TYPES_INTERNAL_SQL = new Set([
     26, // DETACH
 ]);
 const BLOCKED_FUNCTION_PATTERN = /\b(current_setting|duckdb_settings|duckdb_secrets|query|query_table)\s*\(/i;
-const BLOCKED_USER_SQL_FILE_FUNCTION_PATTERN = /\b(read_(?:blob|csv(?:_auto)?|json(?:_auto|_objects(?:_auto)?)?|ndjson(?:_auto|_objects(?:_auto)?)?|parquet|text|xlsx))\s*\(/i;
+const BLOCKED_USER_SQL_FILE_FUNCTION_PATTERN = /\b(read\s*_\s*(?:blob|csv(?:\s*_\s*auto)?|json(?:\s*_\s*(?:auto|objects(?:\s*_\s*auto)?))?|ndjson(?:\s*_\s*(?:auto|objects(?:\s*_\s*auto)?))?|parquet|text|xlsx)|parquet\s*_\s*scan|glob|sqlite\s*_\s*scan|postgres\s*_\s*scan|mysql\s*_\s*scan)\s*\(/i;
 const BLOCKED_USER_SQL_FILE_TABLE_PATTERN = /\b(?:from|join)\s+'[^']*'/i;
 const buildMotherduckConnectionString = ({ database, token, }) => {
     const params = new URLSearchParams({
@@ -157,6 +180,43 @@ const buildMotherduckConnectionString = ({ database, token, }) => {
     });
     return `md:${encodeURIComponent(database)}?${params.toString()}`;
 };
+const EMBEDDED_DATASET_PATTERN = /^[a-z0-9_-]+$/;
+const DEFAULT_EMBEDDED_DATA_DIRECTORY = path_1.default.resolve(__dirname, '../../../backend/assets/playground');
+const EMBEDDED_RESOURCE_LIMITS = {
+    memoryLimit: '256MB',
+    threads: 1,
+};
+const EMBEDDED_QUERY_TIMEOUT_MS = 10000;
+const EMBEDDED_MAX_CONCURRENT_QUERIES = 2;
+const EMBEDDED_MAX_CONCURRENT_QUERIES_PER_ORGANIZATION = 1;
+const resolveEmbeddedDatabasePath = (dataset) => {
+    if (!EMBEDDED_DATASET_PATTERN.test(dataset)) {
+        throw new common_1.ParameterError('Embedded DuckDB dataset must contain only lowercase letters, numbers, hyphens, and underscores');
+    }
+    const baseDirectory = process.env.PLAYGROUND_DATA_DIR ?? DEFAULT_EMBEDDED_DATA_DIRECTORY;
+    let realBaseDirectory;
+    try {
+        realBaseDirectory = fs_1.default.realpathSync(baseDirectory);
+    }
+    catch {
+        throw new common_1.ParameterError(`Embedded DuckDB dataset "${dataset}" was not found in ${baseDirectory}`);
+    }
+    const databasePath = path_1.default.join(baseDirectory, `${dataset}.duckdb`);
+    let realDatabasePath;
+    try {
+        realDatabasePath = fs_1.default.realpathSync(databasePath);
+    }
+    catch {
+        throw new common_1.ParameterError(`Embedded DuckDB dataset "${dataset}" was not found in ${baseDirectory}`);
+    }
+    const relativePath = path_1.default.relative(realBaseDirectory, realDatabasePath);
+    if (relativePath === '' ||
+        relativePath.startsWith(`..${path_1.default.sep}`) ||
+        path_1.default.isAbsolute(relativePath)) {
+        throw new common_1.ParameterError(`Embedded DuckDB dataset "${dataset}" resolves outside ${baseDirectory}`);
+    }
+    return realDatabasePath;
+};
 class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
     constructor(credentials, options) {
         const isS3Only = credentials &&
@@ -167,6 +227,11 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             'type' in credentials &&
             credentials.type === common_1.WarehouseTypes.DUCKDB &&
             credentials.connectionType === common_1.DuckdbConnectionType.DUCKLAKE;
+        const isEmbedded = !isS3Only &&
+            credentials &&
+            'type' in credentials &&
+            credentials.type === common_1.WarehouseTypes.DUCKDB &&
+            credentials.connectionType === common_1.DuckdbConnectionType.EMBEDDED;
         let effectiveCredentials;
         if (isS3Only) {
             effectiveCredentials = DUCKDB_INTERNAL_CREDENTIALS;
@@ -188,6 +253,9 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
                 dataTimezone: ducklake.dataTimezone,
             };
         }
+        else if (isEmbedded) {
+            effectiveCredentials = DUCKDB_INTERNAL_CREDENTIALS;
+        }
         else {
             effectiveCredentials =
                 credentials ??
@@ -201,9 +269,16 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             this.ducklakeConfig =
                 credentials;
         }
+        if (isEmbedded) {
+            this.embeddedConfig =
+                credentials;
+        }
         // Project DuckDB credentials map to MotherDuck only. The in-memory
         // internal credentials remain available for pre-aggregate helper flows.
-        if (this.ducklakeConfig ||
+        if (this.embeddedConfig) {
+            this.databasePath = resolveEmbeddedDatabasePath(this.embeddedConfig.dataset);
+        }
+        else if (this.ducklakeConfig ||
             effectiveCredentials.database === ':memory:') {
             this.databasePath = ':memory:';
         }
@@ -217,7 +292,12 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
                 token,
             });
         }
-        this.resourceLimits = options?.resourceLimits;
+        this.resourceLimits = this.embeddedConfig
+            ? {
+                ...EMBEDDED_RESOURCE_LIMITS,
+                ...options?.resourceLimits,
+            }
+            : options?.resourceLimits;
         this.sharedResourceLimits = options?.sharedResourceLimits;
         // DuckLake attaches a postgres catalog secret on every fresh DuckDB
         // instance, and the postgres extension only pools 8 connections per
@@ -231,6 +311,8 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             options?.instanceCacheKey ?? ducklakeAutoCacheKey;
         this.logger = options?.logger;
         this.onQueryProfile = options?.onQueryProfile;
+        this.embeddedQueryTimeoutMs =
+            options?.embeddedQueryTimeoutMs ?? EMBEDDED_QUERY_TIMEOUT_MS;
     }
     static hashDucklakeConfig(ducklake) {
         return (0, crypto_1.createHash)('sha256')
@@ -256,19 +338,48 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         }
         return this.instanceCacheKey;
     }
+    static tryAcquireEmbeddedConcurrency(organizationUuid) {
+        if (!DuckdbWarehouseClient.embeddedConcurrencyBudget.tryAcquire()) {
+            return undefined;
+        }
+        if (!organizationUuid) {
+            return () => DuckdbWarehouseClient.embeddedConcurrencyBudget.release();
+        }
+        const organizationBudget = DuckdbWarehouseClient.embeddedOrganizationConcurrencyBudgets.get(organizationUuid) ??
+            new ConcurrencyBudget(EMBEDDED_MAX_CONCURRENT_QUERIES_PER_ORGANIZATION);
+        DuckdbWarehouseClient.embeddedOrganizationConcurrencyBudgets.set(organizationUuid, organizationBudget);
+        if (!organizationBudget.tryAcquire()) {
+            DuckdbWarehouseClient.embeddedConcurrencyBudget.release();
+            return undefined;
+        }
+        return () => {
+            organizationBudget.release();
+            DuckdbWarehouseClient.embeddedConcurrencyBudget.release();
+            if (organizationBudget.isIdle()) {
+                DuckdbWarehouseClient.embeddedOrganizationConcurrencyBudgets.delete(organizationUuid);
+            }
+        };
+    }
     getSQLWithMetadata(sql, tags) {
         if (!tags) {
             return sql;
         }
         return `${sql}\n-- ${JSON.stringify(tags)}`;
     }
-    static async hardenInstance(db, options) {
+    static async hardenInstance(db) {
         await db.run('SET allow_community_extensions = false;');
-        const autoload = options?.allowKnownExtensionAutoload ?? false;
-        await db.run(`SET autoinstall_known_extensions = ${autoload};`);
-        await db.run(`SET autoload_known_extensions = ${autoload};`);
+        await db.run('SET autoinstall_known_extensions = false;');
+        await db.run('SET autoload_known_extensions = false;');
         await db.run('SET allow_unredacted_secrets = false;');
     }
+    static async applyResourceLimits(db, resourceLimits) {
+        if (resourceLimits?.memoryLimit) {
+            await db.run(`SET memory_limit = '${resourceLimits.memoryLimit}';`);
+        }
+        if (resourceLimits?.threads) {
+            await db.run(`SET threads = ${resourceLimits.threads};`);
+        }
+    }
     static usesS3CredentialChain(s3Config) {
         return !(s3Config.accessKey && s3Config.secretKey);
     }
@@ -299,15 +410,11 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             // exhausts on projects with >8 models.
             await db.run('SET pg_connection_limit = 64;');
         }
-        await DuckdbWarehouseClient.hardenInstance(db, {
-            allowKnownExtensionAutoload: !!client.ducklakeConfig,
-        });
-        if (client.sharedResourceLimits?.memoryLimit) {
-            await db.run(`SET memory_limit = '${client.sharedResourceLimits.memoryLimit}';`);
-        }
-        if (client.sharedResourceLimits?.threads) {
-            await db.run(`SET threads = ${client.sharedResourceLimits.threads};`);
+        if (client.ducklakeConfig) {
+            await db.run('SET autoinstall_known_extensions = true;');
+            await db.run('SET autoload_known_extensions = true;');
         }
+        await DuckdbWarehouseClient.applyResourceLimits(db, client.sharedResourceLimits);
         if (client.s3Config) {
             await db.run(DuckdbWarehouseClient.buildS3SecretSql(client.s3Config));
         }
@@ -319,6 +426,7 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
                 await db.run(stmt);
             }
         }
+        await DuckdbWarehouseClient.hardenInstance(db);
         const bootstrapMs = performance.now() - bootstrapStart;
         client.logger?.info(`DuckDB query bootstrap complete: cacheKey=${client.instanceCacheKey ?? 'none'} bootstrap=${(0, common_1.formatMilliseconds)(bootstrapMs)}ms httpfs=${(0, common_1.formatMilliseconds)(httpfsMs)}ms memory_limit=${client.sharedResourceLimits?.memoryLimit ?? 'default'} threads=${client.sharedResourceLimits?.threads ?? 'default'} s3=${client.s3Config ? 'configured' : 'none'} ducklake=${client.ducklakeConfig ? 'configured' : 'none'} shared=${client.instanceCacheKey ? 'true' : 'false'}`, {
             shared: !!client.instanceCacheKey,
@@ -385,6 +493,7 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
                 throw error;
             }
             DuckdbWarehouseClient.sharedInstances.set(instanceCacheKey, instance);
+            DuckdbWarehouseClient.sharedInstanceResourceLimits.set(instanceCacheKey, client.sharedResourceLimits);
             client.logger?.info(`DuckDB shared instance initialized: cacheKey=${instanceCacheKey} semaphore_wait=${(0, common_1.formatMilliseconds)(semaphoreWaitMs)}ms instance_create=${(0, common_1.formatMilliseconds)(instanceCreateMs)}ms bootstrap=${(0, common_1.formatMilliseconds)(bootstrapMs)}ms`, {
                 instanceCacheKey,
                 semaphoreWaitMs,
@@ -403,28 +512,38 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             semaphore.release();
         }
     }
-    static clearSharedInstance(instanceCacheKey, logger) {
-        const sharedInstance = DuckdbWarehouseClient.sharedInstances.get(instanceCacheKey);
-        if (sharedInstance) {
-            try {
-                sharedInstance.closeSync?.();
-            }
-            catch {
-                // best-effort cleanup
+    static async clearSharedInstance(instanceCacheKey, logger) {
+        const semaphore = DuckdbWarehouseClient.getSharedInstanceSemaphore(instanceCacheKey);
+        await semaphore.acquire();
+        try {
+            const sharedInstance = DuckdbWarehouseClient.sharedInstances.get(instanceCacheKey);
+            if (sharedInstance) {
+                try {
+                    sharedInstance.closeSync?.();
+                }
+                catch {
+                    // best-effort cleanup
+                }
+                DuckdbWarehouseClient.sharedInstances.delete(instanceCacheKey);
+                DuckdbWarehouseClient.sharedInstanceResourceLimits.delete(instanceCacheKey);
+                logger?.info(`DuckDB shared instance cleared: ${instanceCacheKey}`);
             }
-            DuckdbWarehouseClient.sharedInstances.delete(instanceCacheKey);
-            DuckdbWarehouseClient.sharedInstanceSemaphores.delete(instanceCacheKey);
-            logger?.info(`DuckDB shared instance cleared: ${instanceCacheKey}`);
+        }
+        finally {
+            semaphore.release();
         }
     }
     /** Reset shared state without closing — for use in tests with mocked instances. */
     static resetSharedDuckdbStateForTesting() {
         DuckdbWarehouseClient.sharedInstances.clear();
+        DuckdbWarehouseClient.sharedInstanceResourceLimits.clear();
         DuckdbWarehouseClient.sharedInstanceSemaphores.clear();
+        DuckdbWarehouseClient.embeddedConcurrencyBudget.reset();
+        DuckdbWarehouseClient.embeddedOrganizationConcurrencyBudgets.clear();
     }
     async close() {
         if (this.instanceCacheKey) {
-            DuckdbWarehouseClient.clearSharedInstance(this.instanceCacheKey, this.logger);
+            await DuckdbWarehouseClient.clearSharedInstance(this.instanceCacheKey, this.logger);
         }
     }
     static escapeDuckdbString(v) {
@@ -659,7 +778,7 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         this.logger?.info('DuckDB connect retries exhausted, recreating shared instance', {
             instanceCacheKey,
         });
-        DuckdbWarehouseClient.clearSharedInstance(instanceCacheKey, this.logger);
+        await DuckdbWarehouseClient.clearSharedInstance(instanceCacheKey, this.logger);
         sharedInstanceAcquisition =
             await DuckdbWarehouseClient.getOrCreateSharedInstance(this);
         semaphoreWaitMs += sharedInstanceAcquisition.semaphoreWaitMs;
@@ -685,19 +804,15 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             await db.run('LOAD httpfs;');
             await DuckdbWarehouseClient.loadAwsExtensionForCredentialChain(db, this.s3Config);
         }
-        await DuckdbWarehouseClient.hardenInstance(db, {
-            allowKnownExtensionAutoload: !!this.ducklakeConfig,
-        });
         await db.run(`SET temp_directory = '${tempDir}';`);
         if (this.ducklakeConfig) {
             await db.run('SET pg_connection_limit = 64;');
         }
-        if (this.resourceLimits?.memoryLimit) {
-            await db.run(`SET memory_limit = '${this.resourceLimits.memoryLimit}';`);
-        }
-        if (this.resourceLimits?.threads) {
-            await db.run(`SET threads = ${this.resourceLimits.threads};`);
+        if (this.ducklakeConfig) {
+            await db.run('SET autoinstall_known_extensions = true;');
+            await db.run('SET autoload_known_extensions = true;');
         }
+        await DuckdbWarehouseClient.applyResourceLimits(db, this.resourceLimits);
         if (this.s3Config) {
             await db.run(DuckdbWarehouseClient.buildS3SecretSql(this.s3Config));
         }
@@ -709,6 +824,7 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
                 await db.run(stmt);
             }
         }
+        await DuckdbWarehouseClient.hardenInstance(db);
         this.logger?.info(`DuckDB isolated bootstrap: memory_limit=${this.resourceLimits?.memoryLimit ?? 'default'} threads=${this.resourceLimits?.threads ?? 'default'} s3=${this.s3Config ? 'configured' : 'none'} ducklake=${this.ducklakeConfig ? 'configured' : 'none'}`);
     }
     /** Ephemeral DuckDB instance with resource limits (e.g. parquet conversion). */
@@ -779,6 +895,8 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         const sessionStart = performance.now();
         const sharedConnection = await this.connectWithRetry();
         try {
+            await DuckdbWarehouseClient.applyResourceLimits(sharedConnection.connection, DuckdbWarehouseClient.sharedInstanceResourceLimits.get(this.getRequiredInstanceCacheKey()));
+            await DuckdbWarehouseClient.hardenInstance(sharedConnection.connection);
             const queryStart = performance.now();
             const result = await callback(sharedConnection.connection);
             const queryMs = performance.now() - queryStart;
@@ -810,9 +928,9 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
      * - Shared instance (has instanceCacheKey): warm cached instance for queries
      * - Default: ephemeral query session
      */
-    async withSession(callback) {
+    async withSession(callback, organizationUuid) {
         if (this.databasePath !== ':memory:') {
-            return this.withDirectSession(callback);
+            return this.withDirectSession(callback, organizationUuid);
         }
         if (this.hasResourceLimits()) {
             return this.withIsolatedSession(callback);
@@ -823,17 +941,38 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         return this.withEphemeralQuerySession(callback);
     }
     /** Direct connection to the configured MotherDuck database. */
-    async withDirectSession(callback) {
+    async withDirectSession(callback, organizationUuid) {
         const sessionStart = performance.now();
+        const releaseEmbeddedConcurrency = this.embeddedConfig
+            ? DuckdbWarehouseClient.tryAcquireEmbeddedConcurrency(organizationUuid)
+            : undefined;
+        if (this.embeddedConfig && !releaseEmbeddedConcurrency) {
+            throw new common_1.WarehouseQueryError('Playground query capacity is full. Try again shortly.');
+        }
         const instanceCreateStart = performance.now();
-        const instance = await node_api_1.DuckDBInstance.create(this.databasePath);
-        const instanceCreateMs = performance.now() - instanceCreateStart;
-        const connectStart = performance.now();
-        const connection = await instance.connect();
-        const connectMs = performance.now() - connectStart;
+        let instance;
+        let connection;
         try {
+            instance = this.embeddedConfig
+                ? await node_api_1.DuckDBInstance.create(this.databasePath, {
+                    access_mode: 'READ_ONLY',
+                    memory_limit: this.resourceLimits?.memoryLimit ??
+                        EMBEDDED_RESOURCE_LIMITS.memoryLimit,
+                    threads: String(this.resourceLimits?.threads ??
+                        EMBEDDED_RESOURCE_LIMITS.threads),
+                })
+                : await node_api_1.DuckDBInstance.create(this.databasePath);
+            const instanceCreateMs = performance.now() - instanceCreateStart;
+            const connectStart = performance.now();
+            connection = await instance.connect();
+            const connectMs = performance.now() - connectStart;
+            if (this.embeddedConfig) {
+                await DuckdbWarehouseClient.hardenInstance(connection);
+            }
             const queryStart = performance.now();
-            const result = await callback(connection);
+            const result = this.embeddedConfig
+                ? await this.withEmbeddedQueryDeadline(connection, callback)
+                : await callback(connection);
             const queryMs = performance.now() - queryStart;
             const totalMs = performance.now() - sessionStart;
             const sanitizedPath = this.databasePath.replace(/motherduck_token=[^&]*/, 'motherduck_token=***');
@@ -846,10 +985,38 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             return result;
         }
         finally {
-            connection.closeSync?.();
-            connection.disconnectSync?.();
-            instance.closeSync?.();
+            connection?.closeSync?.();
+            connection?.disconnectSync?.();
+            instance?.closeSync?.();
+            releaseEmbeddedConcurrency?.();
+        }
+    }
+    async withEmbeddedQueryDeadline(connection, callback) {
+        let deadlineExceeded = false;
+        const timeout = setTimeout(() => {
+            deadlineExceeded = true;
+            connection.interrupt();
+        }, this.embeddedQueryTimeoutMs);
+        timeout.unref();
+        try {
+            const result = await callback(connection);
+            if (deadlineExceeded) {
+                throw this.getEmbeddedQueryTimeoutError();
+            }
+            return result;
+        }
+        catch (error) {
+            if (deadlineExceeded) {
+                throw this.getEmbeddedQueryTimeoutError();
+            }
+            throw error;
         }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    getEmbeddedQueryTimeoutError() {
+        return new common_1.WarehouseQueryError(`Playground query exceeded the ${this.embeddedQueryTimeoutMs / 1000} second execution limit and was stopped. Try a simpler query.`, { timeoutMs: this.embeddedQueryTimeoutMs });
     }
     getBindValues(options) {
         const hasValues = !!options?.values && options.values.length > 0;
@@ -947,9 +1114,70 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         return fields;
     }
     static stripSqlComments(sql) {
-        return sql
-            .replace(/--[^\n]*/g, '') // line comments
-            .replace(/\/\*[\s\S]*?\*\//g, ''); // block comments
+        let result = '';
+        let index = 0;
+        let quote = null;
+        while (index < sql.length) {
+            const current = sql[index];
+            const next = sql[index + 1];
+            if (quote) {
+                result += current;
+                if (quote === '$$') {
+                    if (current === '$' && next === '$') {
+                        result += next;
+                        index += 2;
+                        quote = null;
+                    }
+                    else {
+                        index += 1;
+                    }
+                }
+                else if (current === quote) {
+                    if (next === quote) {
+                        result += next;
+                        index += 2;
+                    }
+                    else {
+                        quote = null;
+                        index += 1;
+                    }
+                }
+                else {
+                    index += 1;
+                }
+            }
+            else if (current === "'" || current === '"') {
+                quote = current;
+                result += current;
+                index += 1;
+            }
+            else if (current === '$' && next === '$') {
+                quote = '$$';
+                result += '$$';
+                index += 2;
+            }
+            else if (current === '-' && next === '-') {
+                result += ' ';
+                index += 2;
+                while (index < sql.length && sql[index] !== '\n') {
+                    index += 1;
+                }
+            }
+            else if (current === '/' && next === '*') {
+                result += ' ';
+                index += 2;
+                while (index < sql.length &&
+                    !(sql[index] === '*' && sql[index + 1] === '/')) {
+                    index += 1;
+                }
+                index = Math.min(index + 2, sql.length);
+            }
+            else {
+                result += current;
+                index += 1;
+            }
+        }
+        return result;
     }
     static validateSqlFunctions(sql) {
         const stripped = DuckdbWarehouseClient.stripSqlComments(sql);
@@ -962,7 +1190,8 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
         const stripped = DuckdbWarehouseClient.stripSqlComments(sql);
         const functionMatch = stripped.match(BLOCKED_USER_SQL_FILE_FUNCTION_PATTERN);
         if (functionMatch) {
-            throw new Error(`SQL validation error: function '${functionMatch[1]}' is not allowed`);
+            const functionName = functionMatch[1].replace(/\s+/g, '');
+            throw new Error(`SQL validation error: function '${functionName}' is not allowed`);
         }
         if (BLOCKED_USER_SQL_FILE_TABLE_PATTERN.test(stripped)) {
             throw new Error('SQL validation error: file table paths are not allowed');
@@ -1014,13 +1243,16 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             if (options?.timezone) {
                 await db.run(`SET TimeZone = '${this.escapeString(options.timezone)}';`);
             }
-            const profilePath = this.logger
+            const profilePath = this.logger && !this.embeddedConfig
                 ? path_1.default.join(os_1.default.tmpdir(), `duckdb-profile-${Date.now()}-${Math.random().toString(36).slice(2)}.json`)
                 : undefined;
             if (profilePath) {
                 await db.run("PRAGMA enable_profiling='json';");
                 await db.run(`PRAGMA profiling_output='${profilePath}';`);
             }
+            if (this.embeddedConfig) {
+                await db.run("SET disabled_filesystems = 'LocalFileSystem';");
+            }
             await this.validateUserSql(db, sql);
             reportPhase?.('session', performance.now() - sessionStart);
             const queryStart = performance.now();
@@ -1045,7 +1277,7 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
             if (profilePath) {
                 await this.logQueryProfile(profilePath, this.logger, options?.tags);
             }
-        });
+        }, options?.tags?.organization_uuid);
     }
     async executeAsyncQuery(...args) {
         const [queryArgs, resultsStreamCallback] = args;
@@ -1160,7 +1392,10 @@ class DuckdbWarehouseClient extends WarehouseBaseClient_1.default {
 }
 exports.DuckdbWarehouseClient = DuckdbWarehouseClient;
 DuckdbWarehouseClient.sharedInstances = new Map();
+DuckdbWarehouseClient.sharedInstanceResourceLimits = new Map();
 DuckdbWarehouseClient.sharedInstanceSemaphores = new Map();
+DuckdbWarehouseClient.embeddedConcurrencyBudget = new ConcurrencyBudget(EMBEDDED_MAX_CONCURRENT_QUERIES);
+DuckdbWarehouseClient.embeddedOrganizationConcurrencyBudgets = new Map();
 DuckdbWarehouseClient.sqlBuilder = new DuckdbSqlBuilder();
 DuckdbWarehouseClient.DUCKLAKE_CATALOG_SECRET = '__lightdash_ducklake_catalog';
 DuckdbWarehouseClient.DUCKLAKE_DATA_SECRET = '__lightdash_ducklake_data';