drizzle-cube 0.5.7 → 0.6.0

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

@@ -0,0 +1,332 @@
+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 PERCENTILE_CONT or similar */
+    supportsPercentile: 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 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';
+    /**
+     * 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 buildIntervalFromISO(duration: string): SQL;
+    abstract buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    abstract buildDateAddInterval(timestamp: SQL, duration: string): 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 castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    abstract getCapabilities(): DatabaseCapabilities;
+    abstract buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): 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
+     */
+    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,63 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
+export declare class DatabendAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'databend';
+    /**
+     * 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 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 unquoted granularity keywords
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * 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
+     */
+    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;
+    /**
+     * Databend capabilities - start conservative
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * 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;
+}

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

@@ -0,0 +1,68 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities } 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.
+     */
+    /**
+     * 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 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;
+    /**
+     * 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;
+    /**
+     * DuckDB uses function-style regex matching: regexp_matches(field, pattern)
+     */
+    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;
+    /**
+     * 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 PERCENTILE aggregation
+     * DuckDB uses QUANTILE_CONT instead of PERCENTILE_CONT
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
+}

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

@@ -0,0 +1,65 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
+export declare class MySQLAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'mysql' | 'singlestore';
+    /**
+     * Build MySQL INTERVAL from ISO 8601 duration
+     * MySQL has no standalone interval literal usable in arithmetic, so we convert
+     * to total 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 a chain of DATE_ADD calls, one per duration component
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): 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;
+    /**
+     * 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
+     */
+    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;
+    /**
+     * MySQL AVG/STDDEV/VARIANCE use IFNULL (no COALESCE-for-zero idiom mismatch,
+     * but IFNULL is the MySQL-idiomatic null guard).
+     */
+    protected nullToZero(expr: SQL): SQL;
+    /**
+     * MySQL 8.0+ has support for statistical and window functions
+     * but not PERCENTILE_CONT
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * MySQL does not support PERCENTILE_CONT
+     * Returns null for graceful degradation
+     */
+    buildPercentile(_fieldExpr: AnyColumn | SQL, _percentile: number): SQL | null;
+}

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

@@ -0,0 +1,55 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
+export declare class PostgresAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'postgres';
+    /**
+     * Build PostgreSQL INTERVAL from ISO 8601 duration
+     * PostgreSQL supports INTERVAL literal syntax: INTERVAL '7 days'
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build PostgreSQL time difference in seconds using EXTRACT(EPOCH FROM ...)
+     * Returns (end - start) as seconds
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build PostgreSQL timestamp + interval expression
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build PostgreSQL conditional aggregation using FILTER clause
+     * PostgreSQL supports the standard SQL FILTER clause for efficient conditional aggregation
+     * Example: AVG(time_diff) FILTER (WHERE step_1_time IS NOT NULL)
+     */
+    buildConditionalAggregation(aggFn: 'count' | 'avg' | 'min' | 'max' | 'sum', expr: SQL | null, condition: SQL): SQL;
+    /**
+     * Build PostgreSQL date difference in periods using AGE and EXTRACT
+     * For retention analysis period calculations
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build PostgreSQL period series using generate_series
+     * PostgreSQL's generate_series returns a set directly usable as a table
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build PostgreSQL time dimension using DATE_TRUNC function
+     * Extracted from executor.ts:649-670 and multi-cube-builder.ts:306-320
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Build PostgreSQL type casting using :: syntax
+     * Extracted from various locations where ::timestamp was used
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * PostgreSQL has full support for statistical and window functions
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build PostgreSQL PERCENTILE_CONT aggregation
+     * Uses ordered-set aggregate function
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
+}

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

@@ -0,0 +1,4 @@
+import { MySQLAdapter } from './mysql-adapter';
+export declare class SingleStoreAdapter extends MySQLAdapter {
+    getEngineType(): 'singlestore';
+}

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

@@ -0,0 +1,53 @@
+import { SQL, AnyColumn } from 'drizzle-orm';
+import { TimeGranularity } from '../types';
+import { BaseDatabaseAdapter, DatabaseCapabilities } from './base-adapter';
+export declare class SnowflakeAdapter extends BaseDatabaseAdapter {
+    getEngineType(): 'snowflake';
+    /**
+     * Build Snowflake INTERVAL from ISO 8601 duration
+     * Snowflake doesn't have a standalone INTERVAL type like PostgreSQL.
+     * We convert to total seconds for use in DATEADD; callers should prefer buildDateAddInterval.
+     */
+    buildIntervalFromISO(duration: string): SQL;
+    /**
+     * Build Snowflake time difference in seconds
+     * Uses DATEDIFF('SECOND', start, end)
+     */
+    buildTimeDifferenceSeconds(end: SQL, start: SQL): SQL;
+    /**
+     * Build Snowflake timestamp + interval expression
+     * Uses chained DATEADD(unit, amount, timestamp) calls
+     */
+    buildDateAddInterval(timestamp: SQL, duration: string): SQL;
+    /**
+     * Build Snowflake date difference in periods using DATEDIFF
+     */
+    buildDateDiffPeriods(startDate: SQL, endDate: SQL, unit: 'day' | 'week' | 'month'): SQL;
+    /**
+     * Build Snowflake period series using TABLE(GENERATOR(ROWCOUNT => n)) + ROW_NUMBER()
+     */
+    buildPeriodSeriesSubquery(maxPeriod: number): SQL;
+    /**
+     * Build Snowflake time dimension using DATE_TRUNC function
+     * Snowflake supports DATE_TRUNC with quoted granularity like PostgreSQL
+     */
+    buildTimeDimension(granularity: TimeGranularity, fieldExpr: AnyColumn | SQL): SQL;
+    /**
+     * Snowflake uses function-style regex matching: REGEXP_LIKE(field, pattern)
+     */
+    protected regexCondition(fieldExpr: AnyColumn | SQL, value: string, negated: boolean): SQL;
+    /**
+     * Build Snowflake type casting using :: syntax
+     * Snowflake supports both :: syntax and CAST() function
+     */
+    castToType(fieldExpr: AnyColumn | SQL, targetType: 'timestamp' | 'decimal' | 'integer'): SQL;
+    /**
+     * Snowflake capabilities - full SQL support
+     */
+    getCapabilities(): DatabaseCapabilities;
+    /**
+     * Build Snowflake PERCENTILE_CONT aggregation
+     * Uses ordered-set aggregate function
+     */
+    buildPercentile(fieldExpr: AnyColumn | SQL, percentile: number): SQL;
+}