drizzle-cube 0.5.7 → 0.5.8

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

@@ -0,0 +1,287 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+/**
+ * Database capabilities for feature detection
+ * 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;
+}
+/**
+ * Window function types supported by the adapter
+ */
+export type WindowFunctionType = 'lag' | 'lead' | 'rank' | 'denseRank' | 'rowNumber' | 'ntile' | 'firstValue' | 'lastValue' | 'movingAvg' | 'movingSum';
+/**
+ * Window function configuration
+ */
+export interface WindowFunctionConfig {
+    /** Number of rows to offset for lag/lead */
+    offset?: number;
+    /** Default value when offset is out of bounds */
+    defaultValue?: any;
+    /** Number of buckets for ntile */
+    nTile?: number;
+    /** Frame specification for moving aggregates */
+    frame?: {
+        type: 'rows' | 'range';
+        start: number | 'unbounded';
+        end: number | 'current' | 'unbounded';
+    };
+}
+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
+     * @param duration - ISO 8601 duration (e.g., "P7D" for 7 days, "PT1H" for 1 hour)
+     * @returns SQL expression representing the interval
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build time difference expression in seconds between two timestamps
+     * Used for calculating time-to-convert metrics in funnel analysis
+     * @param end - End timestamp expression
+     * @param start - Start timestamp expression
+     * @returns SQL expression for (end - start) in seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build expression to add an ISO 8601 duration to a timestamp
+     * Used for time window constraint checks in funnel analysis
+     * @param timestamp - Base timestamp expression
+     * @param duration - ISO 8601 duration to add
+     * @returns SQL expression for timestamp + interval
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build conditional aggregation with database-specific syntax
+     * Used for single-pass funnel metrics aggregation
+     * PostgreSQL uses FILTER clause, MySQL/SQLite use CASE WHEN
+     * @param aggFn - Aggregation function: 'count' | 'avg' | 'min' | 'max' | 'sum'
+     * @param expr - Expression to aggregate (null for COUNT(*))
+     * @param condition - Condition for filtering
+     * @returns SQL for conditional aggregation
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build date difference expression in specified periods
+     * Used for retention analysis to calculate period numbers
+     * @param startDate - Start date expression
+     * @param endDate - End date expression
+     * @param unit - Unit for difference ('day' | 'week' | 'month')
+     * @returns SQL expression for date difference in periods
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build a subquery that generates a series of period numbers (0 to maxPeriod)
+     * Used for retention analysis to cross-join with user data
+     * @param maxPeriod - Maximum period number to generate
+     * @returns SQL expression for period series subquery with alias 'p' containing 'period_number' column
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build time dimension expression with granularity truncation
+     * @param granularity - Time granularity (day, month, year, etc.)
+     * @param fieldExpr - The date/timestamp field expression
+     * @returns SQL expression for truncated time dimension
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build string matching condition
+     * @param fieldExpr - The field to search in
+     * @param operator - The string matching operator
+     * @param value - The value to match
+     * @returns SQL expression for string matching
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): SQL;
+    /**
+     * Cast expression to specific database type
+     * @param fieldExpr - The field expression to cast
+     * @param targetType - Target database type
+     * @returns SQL expression with type casting
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * Build AVG aggregation expression with database-specific null handling
+     * @param fieldExpr - The field expression to average
+     * @returns SQL expression for AVG aggregation (COALESCE vs IFNULL for null handling)
+     */
+    buildAvg(fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build CASE WHEN conditional expression
+     * @param conditions - Array of condition/result pairs
+     * @param elseValue - Optional ELSE clause value
+     * @returns SQL expression for CASE WHEN statement
+     */
+    buildCaseWhen(conditions: Array<{
+        when: SQL;
+        then: any;
+    }>, elseValue?: any): SQL;
+    /**
+     * Build boolean literal expression
+     * @param value - Boolean value to represent
+     * @returns SQL expression for boolean literal (TRUE/FALSE/1/0 depending on database)
+     */
+    buildBooleanLiteral(value: boolean): SQL;
+    /**
+     * Convert filter values to database-compatible types
+     * @param value - The filter value to convert
+     * @returns Converted value for database queries
+     */
+    convertFilterValue(value: any): any;
+    /**
+     * Prepare date value for database-specific storage format
+     * @param date - Date value to prepare
+     * @returns Database-compatible date representation
+     */
+    prepareDateValue(date: Date): any;
+    /**
+     * Check if this database stores timestamps as integers
+     * @returns True if timestamps are stored as integers (milliseconds), false for native timestamps
+     */
+    isTimestampInteger(): boolean;
+    /**
+     * Convert time dimension result values back to Date objects for consistency
+     * @param value - The time dimension value from query results
+     * @returns Date object or original value if not a time dimension
+     */
+    convertTimeDimensionResult(value: any): any;
+    /**
+     * Preprocess calculated measure template for database-specific transformations
+     * This allows each adapter to modify the template before substitution occurs
+     * @param calculatedSql - The template string with {member} references
+     * @returns Preprocessed template string
+     */
+    preprocessCalculatedTemplate(calculatedSql: string): string;
+    /**
+     * Get database capabilities for feature detection
+     * Used for graceful degradation when functions aren't supported
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build STDDEV aggregation expression
+     * @param fieldExpr - The field expression to calculate stddev for
+     * @param useSample - Use sample stddev (STDDEV_SAMP) vs population (STDDEV_POP). Default: false
+     * @returns SQL expression or null if unsupported
+     */
+    buildStddev(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build VARIANCE aggregation expression
+     * @param fieldExpr - The field expression to calculate variance for
+     * @param useSample - Use sample variance (VAR_SAMP) vs population (VAR_POP). Default: false
+     * @returns SQL expression or null if unsupported
+     */
+    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL | null;
+    /**
+     * Build PERCENTILE aggregation expression
+     * @param fieldExpr - The field expression to calculate percentile for
+     * @param percentile - Percentile value (0-100)
+     * @returns SQL expression or null if unsupported
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL | null;
+    /**
+     * Build a window function expression
+     * @param type - Window function type (lag, lead, rank, etc.)
+     * @param fieldExpr - The field expression (null for rank functions that don't need a field)
+     * @param partitionBy - PARTITION BY columns
+     * @param orderBy - ORDER BY columns with direction
+     * @param config - Additional configuration (offset, default, frame, etc.)
+     * @returns SQL expression or null if unsupported
+     */
+    buildWindowFunction(type: WindowFunctionType, fieldExpr: AnyColumn | SQL | null, partitionBy?: (AnyColumn | SQL)[], orderBy?: Array<{
+        field: AnyColumn | SQL;
+        direction: 'asc' | 'desc';
+    }>, config?: WindowFunctionConfig): SQL | null;
+}
+/**
+ * Abstract base class for database adapters
+ * Provides common functionality that can be shared across database implementations
+ */
+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;
+    /**
+     * Helper method to build pattern for string matching
+     * Can be overridden by specific adapters if needed
+     */
+    protected buildPattern(operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith', value: string): string;
+    /**
+     * Parse ISO 8601 duration into components
+     * Supports P[n]Y[n]M[n]DT[n]H[n]M[n]S format
+     * @param duration - ISO 8601 duration string (e.g., "P7D", "PT1H30M", "P1DT2H")
+     * @returns Parsed duration components
+     */
+    protected parseISODuration(duration: string): {
+        years: number;
+        months: number;
+        days: number;
+        hours: number;
+        minutes: number;
+        seconds: number;
+    };
+    /**
+     * Convert ISO 8601 duration to total seconds
+     * Note: Months and years are approximated (30 days/month, 365 days/year)
+     * @param duration - ISO 8601 duration string
+     * @returns Total seconds
+     */
+    protected durationToSeconds(duration: string): number;
+}

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

@@ -0,0 +1,114 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } 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)
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build Databend time difference in seconds
+     * Uses TIMESTAMPDIFF(SECOND, start, end)
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build Databend timestamp + interval expression
+     * 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
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build Databend period series using generate_series via numbers table
+     * Databend has a numbers() table function that can be used similarly
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build Databend time dimension using DATE_TRUNC function
+     * Databend supports DATE_TRUNC with quoted granularity like PostgreSQL
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build Databend string matching conditions using LOWER+LIKE fallback
+     * Databend does not support ILIKE
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): 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)
+     * and COVAR_SAMP(x,x) = VAR_SAMP(x) mathematically
+     */
+    buildVariance(fieldExpr: AnyColumn | SQL, useSample?: boolean): SQL;
+    /**
+     * Build Databend PERCENTILE aggregation
+     * 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

@@ -0,0 +1,122 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } from './base-adapter';
+export declare class DuckDBAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'duckdb';
+    /**
+     * DuckDB does not support non-constant LIMIT in correlated subqueries,
+     * 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'
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build DuckDB time difference in seconds using EPOCH() function
+     * DuckDB uses EPOCH(timestamp) instead of EXTRACT(EPOCH FROM timestamp)
+     * Returns (end - start) as seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build DuckDB timestamp + interval expression
+     */
+    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
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build DuckDB date difference in periods using DATE_DIFF
+     * DuckDB has native DATE_DIFF function with unit support
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build DuckDB period series using UNNEST(generate_series(...))
+     * DuckDB's generate_series returns an array, so we need to UNNEST it to get a table
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build DuckDB time dimension using DATE_TRUNC function
+     * DuckDB uses DATE_TRUNC like PostgreSQL
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build DuckDB string matching conditions using ILIKE (case-insensitive)
+     * DuckDB supports ILIKE like PostgreSQL
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): 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
+     * doesn't work well in scalar subqueries against CTEs in funnel queries
+     * Note: supportsLateralJoins is false because DuckDB doesn't support non-constant
+     * 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

@@ -0,0 +1,122 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities, WindowFunctionType, WindowFunctionConfig } 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
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build MySQL time difference in seconds using TIMESTAMPDIFF
+     * Returns (end - start) as seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build MySQL timestamp + interval expression
+     * Uses DATE_ADD function
+     */
+    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
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build MySQL period series using recursive CTE
+     * MySQL 8.0+ supports recursive CTEs for generating sequences
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build MySQL time dimension using DATE_FORMAT function
+     * MySQL equivalent to PostgreSQL's DATE_TRUNC
+     */
+    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
+     */
+    buildStringCondition(fieldExpr: AnyColumn | SQL, operator: 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'like' | 'notLike' | 'ilike' | 'regex' | 'notRegex', value: string): 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
+     */
+    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;
+    /**
+     * 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;
+}