drizzle-cube 0.5.8 → 0.6.0

package/dist/server/{openai-BZdAA7Ji.js → openai-cDlFSTk6.js}

@@ -1,5 +1,62 @@
 //#region src/server/agent/providers/openai.ts
-var e = class {
+function* e(e, t) {
+	let n = e.index ?? 0;
+	if (e.id && (t.set(n, {
+		id: e.id,
+		name: e.function?.name || "",
+		arguments: ""
+	}), yield {
+		type: "tool_use_start",
+		id: e.id,
+		name: e.function?.name || ""
+	}), e.function?.name && t.has(n)) {
+		let r = t.get(n);
+		r.name ||= e.function.name;
+	}
+	if (e.function?.arguments) {
+		let r = t.get(n);
+		r && (r.arguments += e.function.arguments, yield {
+			type: "tool_input_delta",
+			json: e.function.arguments
+		});
+	}
+}
+function* t(e, t) {
+	for (let [e, n] of t) {
+		let r = {};
+		try {
+			n.arguments && (r = JSON.parse(n.arguments));
+		} catch {}
+		yield {
+			type: "tool_use_end",
+			id: n.id,
+			input: r
+		}, t.delete(e);
+	}
+	yield {
+		type: "message_meta",
+		stopReason: e
+	};
+}
+function* n(n, r) {
+	n.usage && (yield {
+		type: "message_meta",
+		inputTokens: n.usage.prompt_tokens,
+		outputTokens: n.usage.completion_tokens,
+		stopReason: ""
+	});
+	let i = n.choices?.[0];
+	if (!i) return;
+	let a = i.delta;
+	if (a) {
+		if (a.content && (yield {
+			type: "text_delta",
+			text: a.content
+		}), a.tool_calls) for (let t of a.tool_calls) yield* e(t, r);
+		i.finish_reason && (yield* t(i.finish_reason, r));
+	}
+}
+var r = class {
 	client;
 	apiKey;
 	baseURL;
@@ -36,62 +93,7 @@ var e = class {
 	}
 	async *parseStreamEvents(e) {
 		let t = /* @__PURE__ */ new Map();
-		for await (let n of e) {
-			let e = n;
-			e.usage && (yield {
-				type: "message_meta",
-				inputTokens: e.usage.prompt_tokens,
-				outputTokens: e.usage.completion_tokens,
-				stopReason: ""
-			});
-			let r = e.choices?.[0];
-			if (!r) continue;
-			let i = r.delta;
-			if (i) {
-				if (i.content && (yield {
-					type: "text_delta",
-					text: i.content
-				}), i.tool_calls) for (let e of i.tool_calls) {
-					let n = e.index ?? 0;
-					if (e.id && (t.set(n, {
-						id: e.id,
-						name: e.function?.name || "",
-						arguments: ""
-					}), yield {
-						type: "tool_use_start",
-						id: e.id,
-						name: e.function?.name || ""
-					}), e.function?.name && t.has(n)) {
-						let r = t.get(n);
-						r.name ||= e.function.name;
-					}
-					if (e.function?.arguments) {
-						let r = t.get(n);
-						r && (r.arguments += e.function.arguments, yield {
-							type: "tool_input_delta",
-							json: e.function.arguments
-						});
-					}
-				}
-				if (r.finish_reason) {
-					for (let [e, n] of t) {
-						let r = {};
-						try {
-							n.arguments && (r = JSON.parse(n.arguments));
-						} catch {}
-						yield {
-							type: "tool_use_end",
-							id: n.id,
-							input: r
-						}, t.delete(e);
-					}
-					yield {
-						type: "message_meta",
-						stopReason: r.finish_reason
-					};
-				}
-			}
-		}
+		for await (let r of e) yield* n(r, t);
 	}
 	formatTools(e) {
 		return e.map((e) => ({
@@ -150,4 +152,4 @@ var e = class {
 	}
 };
 //#endregion
-export { e as OpenAIProvider };
+export { r as OpenAIProvider };

package/dist/server/openai-vXvLni8v.cjs

@@ -0,0 +1 @@
+function*e(e,t){let n=e.index??0;if(e.id&&(t.set(n,{id:e.id,name:e.function?.name||``,arguments:``}),yield{type:`tool_use_start`,id:e.id,name:e.function?.name||``}),e.function?.name&&t.has(n)){let r=t.get(n);r.name||=e.function.name}if(e.function?.arguments){let r=t.get(n);r&&(r.arguments+=e.function.arguments,yield{type:`tool_input_delta`,json:e.function.arguments})}}function*t(e,t){for(let[e,n]of t){let r={};try{n.arguments&&(r=JSON.parse(n.arguments))}catch{}yield{type:`tool_use_end`,id:n.id,input:r},t.delete(e)}yield{type:`message_meta`,stopReason:e}}function*n(n,r){n.usage&&(yield{type:`message_meta`,inputTokens:n.usage.prompt_tokens,outputTokens:n.usage.completion_tokens,stopReason:``});let i=n.choices?.[0];if(!i)return;let a=i.delta;if(a){if(a.content&&(yield{type:`text_delta`,text:a.content}),a.tool_calls)for(let t of a.tool_calls)yield*e(t,r);i.finish_reason&&(yield*t(i.finish_reason,r))}}var r=class{client;apiKey;baseURL;initialized=!1;constructor(e,t){this.apiKey=e,this.baseURL=t?.baseURL}async ensureClient(){if(this.initialized)return;let e;try{let t=await Promise.resolve().then(()=>require("./openai-D0musiYP.cjs"));e=t.default||t.OpenAI||t}catch{throw Error(`openai is required for the OpenAI provider. Install it with: npm install openai`)}let t={apiKey:this.apiKey};this.baseURL&&(t.baseURL=this.baseURL),this.client=new e(t),this.initialized=!0}async createStream(e){await this.ensureClient();let{messages:t}=this.formatMessages(e.messages,e.system);return this.client.chat.completions.create({model:e.model,max_completion_tokens:e.maxTokens,tools:this.formatTools(e.tools),messages:t,stream:!0,stream_options:{include_usage:!0}})}async*parseStreamEvents(e){let t=new Map;for await(let r of e)yield*n(r,t)}formatTools(e){return e.map(e=>({type:`function`,function:{name:e.name,description:e.description,parameters:e.parameters}}))}formatMessages(e,t){let n=[{role:`system`,content:t}];for(let t of e)if(t.role===`user`)n.push({role:`user`,content:typeof t.content==`string`?t.content:JSON.stringify(t.content)});else if(t.role===`assistant`)if(typeof t.content==`string`)n.push({role:`assistant`,content:t.content});else{let e=t.content,r=e.filter(e=>e.type===`text`).map(e=>e.text).join(``),i=e.filter(e=>e.type===`tool_use`).map(e=>({id:e.id,type:`function`,function:{name:e.name,arguments:JSON.stringify(e.input||{})}})),a={role:`assistant`};r&&(a.content=r),i.length>0&&(a.tool_calls=i),n.push(a)}else t.role===`tool`?n.push(t):t.role===`tool_result`&&n.push({role:`user`,content:typeof t.content==`string`?t.content:JSON.stringify(t.content)});return{messages:n}}formatToolResults(e){return e.map(e=>({role:`tool`,tool_call_id:e.toolUseId,content:e.content}))}shouldContinue(e){return e===`tool_calls`}formatError(e){if(!e||!(e instanceof Error))return`Something went wrong. Please try again.`;let t=e.message||``,n=e;return n.status===429?`Too many requests. Please wait a moment and try again.`:n.status===401?`Authentication failed. Please check your API key configuration.`:n.status===503||n.status===502?`The AI service is temporarily unavailable. Please try again in a moment.`:n.status===400?`There was a problem with the request. Please try again.`:t.startsWith(`{`)||t.startsWith(`Error: {`)?`The AI service encountered an error. Please try again.`:t}};exports.OpenAIProvider=r;

package/dist/server/server/adapters/base-adapter.d.ts

@@ -5,22 +5,12 @@ import { TimeGranularity } from '../types';
  * Used for graceful degradation when functions aren't supported
  */
 export interface DatabaseCapabilities {
-    /** Whether the database supports STDDEV_POP/STDDEV_SAMP */
-    supportsStddev: boolean;
-    /** Whether the database supports VAR_POP/VAR_SAMP */
-    supportsVariance: boolean;
     /** Whether the database supports PERCENTILE_CONT or similar */
     supportsPercentile: boolean;
-    /** Whether the database supports window functions (LAG, LEAD, RANK, etc.) */
-    supportsWindowFunctions: boolean;
-    /** Whether the database supports frame clauses (ROWS BETWEEN, RANGE BETWEEN) */
-    supportsFrameClause: boolean;
     /** Whether the database supports LATERAL joins (PostgreSQL 9.3+, MySQL 8.0.14+) */
     supportsLateralJoins: boolean;
     /** Whether percentile functions work in subqueries against CTEs (false for DuckDB) */
     supportsPercentileSubqueries: boolean;
-    /** Whether derived tables (subqueries) work in FROM clauses inside CTEs (false for Databend) */
-    supportsDerivedTablesInCTE: boolean;
     /** Whether correlated LATERAL subqueries can reference CTEs (false for Snowflake) */
     supportsLateralSubqueriesInCTE: boolean;
 }
@@ -50,12 +40,6 @@ export interface DatabaseAdapter {
      * Get the database engine type this adapter supports
      */
     getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
-    /**
-     * Check if the database supports LATERAL joins
-     * Required for optimized flow queries with index-backed seeks
-     * @returns true for PostgreSQL 9.3+, MySQL 8.0.14+, SingleStore; false for SQLite
-     */
-    supportsLateralJoins(): boolean;
     /**
      * Build SQL INTERVAL from ISO 8601 duration string
      * Used for time window constraints in funnel analysis
@@ -225,39 +209,100 @@ export interface DatabaseAdapter {
  */
 export declare abstract class BaseDatabaseAdapter implements DatabaseAdapter {
     abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
-    abstract supportsLateralJoins(): boolean;
     abstract buildIntervalFromISO(duration: string): SQL;
     abstract buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
     abstract buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    abstract buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     abstract buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
     abstract buildPeriodSeriesSubquery(maxPeriod: number): SQL;
     abstract buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
-    abstract buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
     abstract castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    abstract buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    abstract buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    abstract buildBooleanLiteral(value: boolean): SQL;
-    abstract convertFilterValue(value: any): any;
-    abstract prepareDateValue(date: Date): any;
-    abstract isTimestampInteger(): boolean;
-    abstract convertTimeDimensionResult(value: any): any;
     abstract getCapabilities(): DatabaseCapabilities;
-    abstract buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
-    abstract buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
     abstract buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL | null;
-    abstract buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL | null;
     /**
      * Default implementation returns template unchanged
      * Override in specific adapters for database-specific preprocessing
      */
     preprocessCalculatedTemplate(calculatedSql: string): string;
+    /**
+     * Wrap an aggregate so NULL (empty set) becomes 0.
+     * Default uses COALESCE; engines without COALESCE (MySQL/SQLite) override with IFNULL.
+     */
+    protected nullToZero(expr: SQL): SQL;
+    /**
+     * Case-insensitive LIKE matching for contains/startsWith/endsWith/ilike.
+     * Default uses native ILIKE (PostgreSQL/DuckDB/Snowflake); engines without ILIKE
+     * (MySQL/SQLite/Databend) override with LOWER()+LIKE.
+     * @param pattern - the LIKE pattern in its original case (already wrapped with % as needed)
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * Regular-expression matching. Default uses PostgreSQL's ~* / !~* operators;
+     * each other engine overrides with its own regex syntax (REGEXP, GLOB, regexp_matches, REGEXP_LIKE).
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build a string matching condition. The case-insensitive and regex families are
+     * delegated to the caseInsensitiveLike()/regexCondition() hooks; plain LIKE/NOT LIKE
+     * are identical across all engines.
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    /**
+     * Build conditional aggregation. Default uses portable CASE WHEN
+     * (MySQL/SQLite/Databend/Snowflake); PostgreSQL/DuckDB override with the FILTER clause.
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build AVG with null-to-zero handling (COALESCE/IFNULL via nullToZero()).
+     */
+    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build CASE WHEN conditional expression.
+     * SQLite overrides this to handle embedded SQL objects in THEN/ELSE.
+     */
+    buildCaseWhen(conditions: Array<{
+        when: SQL;
+        then: any;
+    }>, elseValue?: any): SQL;
+    /**
+     * Build boolean literal. Default uses TRUE/FALSE keywords; SQLite overrides with 1/0.
+     */
+    buildBooleanLiteral(value: boolean): SQL;
+    /**
+     * Convert filter values to database-compatible types.
+     * Default is a pass-through; SQLite overrides to handle booleans/dates as integers.
+     */
+    convertFilterValue(value: any): any;
+    /**
+     * Prepare a Date for storage. Default passes the Date through (native timestamps);
+     * SQLite overrides to convert to integer milliseconds.
+     */
+    prepareDateValue(date: Date): any;
+    /**
+     * Whether timestamps are stored as integers. Default false; SQLite overrides to true.
+     */
+    isTimestampInteger(): boolean;
+    /**
+     * Convert a time-dimension result value. Default is a pass-through.
+     */
+    convertTimeDimensionResult(value: any): any;
+    /**
+     * Build STDDEV aggregation. Default uses STDDEV_POP/STDDEV_SAMP with null-to-zero.
+     * Engines without native STDDEV (SQLite) override to return null.
+     */
+    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build VARIANCE aggregation. Default uses VAR_POP/VAR_SAMP with null-to-zero.
+     * SQLite overrides to null; Databend overrides to a COVAR-based workaround.
+     */
+    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build a window function expression. Identical across all supported engines
+     * (standard SQL:2003 window syntax), so it lives here as a shared default.
+     */
+    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
+        field: AnyColumn | SQL;
+        direction: 'asc' | 'desc';
+    }>, config?: WindowFunctionConfig): SQL | null;
     /**
      * Helper method to build pattern for string matching
      * Can be overridden by specific adapters if needed

package/dist/server/server/adapters/databend-adapter.d.ts

@@ -1,12 +1,8 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
 import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
 export declare class DatabendAdapter extends BaseDatabaseAdapter {
     getEngineType(): 'databend';
-    /**
-     * Databend does not support LATERAL joins
-     */
-    supportsLateralJoins(): boolean;
     /**
      * Build Databend INTERVAL from ISO 8601 duration
      * Databend supports INTERVAL n UNIT syntax (e.g., INTERVAL 7 DAY)
@@ -22,11 +18,6 @@ export declare class DatabendAdapter extends BaseDatabaseAdapter {
      * Uses timestamp + INTERVAL n UNIT syntax (Databend doesn't support DATE_ADD function)
      */
     buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build Databend conditional aggregation using CASE WHEN
-     * FILTER clause support is uncertain in Databend, so use CASE WHEN for safety
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     /**
      * Build Databend date difference in periods using DATE_DIFF
      */
@@ -38,60 +29,26 @@ export declare class DatabendAdapter extends BaseDatabaseAdapter {
     buildPeriodSeriesSubquery(maxPeriod: number): SQL;
     /**
      * Build Databend time dimension using DATE_TRUNC function
-     * Databend supports DATE_TRUNC with quoted granularity like PostgreSQL
+     * Databend supports DATE_TRUNC with unquoted granularity keywords
      */
     buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build Databend string matching conditions using LOWER+LIKE fallback
-     * Databend does not support ILIKE
+     * Databend has no ILIKE — use LOWER()+LIKE with SQL-side LOWER() on the pattern.
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * Databend regex matching uses the REGEXP operator
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
     /**
      * Build Databend type casting
      * Databend supports both :: syntax and CAST() function
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build Databend AVG aggregation with COALESCE for NULL handling
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build Databend CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build Databend boolean literal
-     * Databend uses TRUE/FALSE keywords
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - Databend uses native types
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for Databend
-     * Databend accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * Databend stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * Databend time dimensions already return proper values
-     */
-    convertTimeDimensionResult(value: any): any;
     /**
      * Databend capabilities - start conservative
      */
     getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build Databend STDDEV aggregation
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
     /**
      * Build Databend VARIANCE aggregation
      * Databend doesn't have VAR_POP/VAR_SAMP, but COVAR_POP(x,x) = VAR_POP(x)
@@ -103,12 +60,4 @@ export declare class DatabendAdapter extends BaseDatabaseAdapter {
      * Databend may support QUANTILE or PERCENTILE_CONT - start with unsupported
      */
     buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL;
-    /**
-     * Build Databend window function expression
-     * Databend has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
 }

package/dist/server/server/adapters/duckdb-adapter.d.ts

@@ -1,6 +1,6 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
 import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
 export declare class DuckDBAdapter extends BaseDatabaseAdapter {
     getEngineType(): 'duckdb';
     /**
@@ -8,7 +8,6 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      * which is required for the LATERAL join strategy in flow queries.
      * Use window function strategy instead.
      */
-    supportsLateralJoins(): boolean;
     /**
      * Build DuckDB INTERVAL from ISO 8601 duration
      * DuckDB supports PostgreSQL-style INTERVAL literal syntax: INTERVAL '7 days'
@@ -25,9 +24,8 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      */
     buildDateAddInterval(timestamp: SQL, duration: string): SQL;
     /**
-     * Build DuckDB conditional aggregation using CASE WHEN
-     * DuckDB supports FILTER clause, but CASE WHEN provides broader compatibility
-     * Using FILTER clause as DuckDB does support it
+     * Build DuckDB conditional aggregation using the FILTER clause
+     * DuckDB supports the standard SQL FILTER clause like PostgreSQL
      */
     buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     /**
@@ -46,48 +44,14 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      */
     buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build DuckDB string matching conditions using ILIKE (case-insensitive)
-     * DuckDB supports ILIKE like PostgreSQL
+     * DuckDB uses function-style regex matching: regexp_matches(field, pattern)
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
     /**
      * Build DuckDB type casting
      * DuckDB supports both :: syntax and CAST() function
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
-    /**
-     * Build DuckDB AVG aggregation with COALESCE for NULL handling
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build DuckDB CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build DuckDB boolean literal
-     * DuckDB uses TRUE/FALSE keywords
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - DuckDB uses native types
-     */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for DuckDB
-     * DuckDB accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * DuckDB stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * DuckDB time dimensions already return proper values
-     */
-    convertTimeDimensionResult(value: any): any;
     /**
      * DuckDB has full support for statistical and window functions
      * Note: supportsPercentileSubqueries is false because DuckDB's QUANTILE_CONT
@@ -96,27 +60,9 @@ export declare class DuckDBAdapter extends BaseDatabaseAdapter {
      * LIMIT in correlated subqueries, which is required for flow query LATERAL joins
      */
     getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build DuckDB STDDEV aggregation
-     * Uses STDDEV_POP for population, STDDEV_SAMP for sample
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build DuckDB VARIANCE aggregation
-     * Uses VAR_POP for population, VAR_SAMP for sample
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
     /**
      * Build DuckDB PERCENTILE aggregation
      * DuckDB uses QUANTILE_CONT instead of PERCENTILE_CONT
      */
     buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
-    /**
-     * Build DuckDB window function expression
-     * DuckDB has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
 }

package/dist/server/server/adapters/mysql-adapter.d.ts

@@ -1,16 +1,12 @@
 import { SQL, AnyColumn } from 'drizzle-orm';
 import { TimeGranularity } from '../types';
-import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
 export declare class MySQLAdapter extends BaseDatabaseAdapter {
     getEngineType(): 'mysql' | 'singlestore';
-    /**
-     * MySQL supports LATERAL joins since version 8.0.14
-     */
-    supportsLateralJoins(): boolean;
     /**
      * Build MySQL INTERVAL from ISO 8601 duration
-     * MySQL uses DATE_ADD with INTERVAL syntax but intervals must be added separately
-     * For simplicity, we convert to seconds for consistent handling
+     * MySQL has no standalone interval literal usable in arithmetic, so we convert
+     * to total seconds for consistent handling.
      */
     buildIntervalFromISO(duration: string): SQL;
     /**
@@ -20,15 +16,9 @@ export declare class MySQLAdapter extends BaseDatabaseAdapter {
     buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
     /**
      * Build MySQL timestamp + interval expression
-     * Uses DATE_ADD function
+     * Uses a chain of DATE_ADD calls, one per duration component
      */
     buildDateAddInterval(timestamp: SQL, duration: string): SQL;
-    /**
-     * Build MySQL conditional aggregation using CASE WHEN
-     * MySQL doesn't support FILTER clause, so we use CASE WHEN pattern
-     * Example: AVG(CASE WHEN step_1_time IS NOT NULL THEN time_diff END)
-     */
-    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
     /**
      * Build MySQL date difference in periods using TIMESTAMPDIFF
      * For retention analysis period calculations
@@ -45,78 +35,31 @@ export declare class MySQLAdapter extends BaseDatabaseAdapter {
      */
     buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
     /**
-     * Build MySQL string matching conditions using LIKE
-     * MySQL LIKE is case-insensitive by default (depending on collation)
-     * For guaranteed case-insensitive matching, we use LOWER() functions
+     * MySQL has no ILIKE — use LOWER()+LIKE with the pattern lowercased in JS.
+     */
+    protected caseInsensitiveLike(fieldExpr: AnyColumn | SQL, pattern: string, negated: boolean): SQL;
+    /**
+     * MySQL regex matching uses the REGEXP operator
      */
-    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
     /**
      * Build MySQL type casting using CAST() function
      * MySQL equivalent to PostgreSQL's :: casting syntax
      */
     castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
     /**
-     * Build MySQL AVG aggregation with IFNULL for NULL handling
-     * MySQL AVG returns NULL for empty sets, using IFNULL for consistency
-     */
-    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
-    /**
-     * Build MySQL CASE WHEN conditional expression
-     */
-    buildCaseWhen(conditions: Array<{
-        when: SQL;
-        then: any;
-    }>, elseValue?: any): SQL;
-    /**
-     * Build MySQL boolean literal
-     * MySQL uses TRUE/FALSE keywords (equivalent to 1/0)
-     */
-    buildBooleanLiteral(value: boolean): SQL;
-    /**
-     * Convert filter values - MySQL uses native types
-     * No conversion needed for MySQL
+     * MySQL AVG/STDDEV/VARIANCE use IFNULL (no COALESCE-for-zero idiom mismatch,
+     * but IFNULL is the MySQL-idiomatic null guard).
      */
-    convertFilterValue(value: any): any;
-    /**
-     * Prepare date value for MySQL
-     * MySQL accepts Date objects directly
-     */
-    prepareDateValue(date: Date): any;
-    /**
-     * MySQL stores timestamps as native timestamp types
-     */
-    isTimestampInteger(): boolean;
-    /**
-     * MySQL time dimensions already return proper values
-     * No conversion needed
-     */
-    convertTimeDimensionResult(value: any): any;
+    protected nullToZero(expr: SQL): SQL;
     /**
      * MySQL 8.0+ has support for statistical and window functions
      * but not PERCENTILE_CONT
      */
     getCapabilities(): DatabaseCapabilities;
-    /**
-     * Build MySQL STDDEV aggregation
-     * Uses STDDEV_POP for population, STDDEV_SAMP for sample
-     */
-    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
-    /**
-     * Build MySQL VARIANCE aggregation
-     * Uses VAR_POP for population, VAR_SAMP for sample
-     */
-    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
     /**
      * MySQL does not support PERCENTILE_CONT
      * Returns null for graceful degradation
      */
     buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL | null;
-    /**
-     * Build MySQL window function expression
-     * MySQL 8.0+ has full window function support
-     */
-    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
-        field: AnyColumn | SQL;
-        direction: 'asc' | 'desc';
-    }>, config?: WindowFunctionConfig): SQL;
 }