drizzle-cube 0.4.30 → 0.4.32

package/dist/server/index.d.ts

@@ -241,9 +241,9 @@ export declare abstract class BaseDatabaseExecutor implements DatabaseExecutor {
     db: DrizzleDatabase;
     schema?: any | undefined;
     databaseAdapter: DatabaseAdapter;
-    constructor(db: DrizzleDatabase, schema?: any | undefined, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb');
+    constructor(db: DrizzleDatabase, schema?: any | undefined, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake');
     abstract execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
-    abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb';
+    abstract getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
     abstract explainQuery(sqlString: string, params: unknown[], options?: ExplainOptions): Promise<ExplainResult>;
     abstract getTableIndexes(tableNames: string[]): Promise<IndexInfo[]>;
 }
@@ -615,7 +615,12 @@ export declare interface CompiledCube extends Cube {
  * @param engineType - Optional explicit engine type override
  * @returns Appropriate database executor
  */
-export declare function createDatabaseExecutor(db: DrizzleDatabase, schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb'): DatabaseExecutor;
+export declare function createDatabaseExecutor(db: DrizzleDatabase, schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake'): DatabaseExecutor;
+
+/**
+ * Factory function for creating Databend executors
+ */
+export declare function createDatabendExecutor(db: DrizzleDatabase, schema?: any): DatabendExecutor;
 
 /**
  * Create a new semantic layer instance with Drizzle integration
@@ -646,6 +651,11 @@ export declare function createMySQLExecutor(db: DrizzleDatabase, schema?: any):
  */
 export declare function createPostgresExecutor(db: DrizzleDatabase, schema?: any): PostgresExecutor;
 
+/**
+ * Factory function for creating Snowflake executors
+ */
+export declare function createSnowflakeExecutor(db: DrizzleDatabase, schema?: any): SnowflakeExecutor;
+
 /**
  * Factory function for creating SQLite executors
  */
@@ -968,7 +978,7 @@ declare interface DatabaseAdapter {
     /**
      * Get the database engine type this adapter supports
      */
-    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb';
+    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
     /**
      * Check if the database supports LATERAL joins
      * Required for optimized flow queries with index-backed seeks
@@ -1158,6 +1168,10 @@ declare interface DatabaseCapabilities {
     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;
 }
 
 /**
@@ -1174,13 +1188,40 @@ export declare interface DatabaseExecutor {
     /** Execute a Drizzle SQL query or query object */
     execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
     /** Get the database engine type */
-    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb';
+    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
     /** Execute EXPLAIN on a SQL query to get the execution plan */
     explainQuery(sqlString: string, params: unknown[], options?: ExplainOptions): Promise<ExplainResult>;
     /** Get existing indexes for the specified tables */
     getTableIndexes(tableNames: string[]): Promise<IndexInfo[]>;
 }
 
+export declare class DatabendExecutor extends BaseDatabaseExecutor {
+    execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
+    /**
+     * Extract SQL string and params from a query object for error logging
+     */
+    private extractSqlFromQuery;
+    /**
+     * Convert numeric string fields to numbers (only for measure fields)
+     */
+    private convertNumericFields;
+    /**
+     * Coerce a value to a number if it represents a numeric type
+     */
+    private coerceToNumber;
+    getEngineType(): 'databend';
+    /**
+     * Execute EXPLAIN on a SQL query to get the execution plan
+     * Databend supports EXPLAIN and EXPLAIN ANALYZE
+     */
+    explainQuery(sqlString: string, params: unknown[], options?: ExplainOptions): Promise<ExplainResult>;
+    /**
+     * Get existing indexes for the specified tables
+     * Databend uses system tables for index information
+     */
+    getTableIndexes(tableNames: string[]): Promise<IndexInfo[]>;
+}
+
 /**
  * Helper function to create cubes
  */
@@ -1620,7 +1661,7 @@ export declare interface ExplainResult {
  */
 export declare interface ExplainSummary {
     /** Database engine type */
-    database: 'postgres' | 'mysql' | 'sqlite' | 'duckdb';
+    database: 'postgres' | 'mysql' | 'sqlite' | 'duckdb' | 'databend' | 'snowflake';
     /** Planning time in milliseconds (if available) */
     planningTime?: number;
     /** Execution time in milliseconds (if ANALYZE was used) */
@@ -4380,7 +4421,7 @@ export declare class SemanticLayerCompiler {
         drizzle?: DatabaseExecutor['db'];
         schema?: any;
         databaseExecutor?: DatabaseExecutor;
-        engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb';
+        engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake';
         /** Cache configuration for query result caching */
         cache?: CacheConfig;
     });
@@ -4391,11 +4432,11 @@ export declare class SemanticLayerCompiler {
     /**
      * Get the database engine type for SQL formatting
      */
-    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | undefined;
+    getEngineType(): 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake' | undefined;
     /**
      * Set Drizzle instance and schema directly
      */
-    setDrizzle(db: DatabaseExecutor['db'], schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb'): void;
+    setDrizzle(db: DatabaseExecutor['db'], schema?: any, engineType?: 'postgres' | 'mysql' | 'sqlite' | 'singlestore' | 'duckdb' | 'databend' | 'snowflake'): void;
     /**
      * Check if database executor is configured
      */
@@ -4690,6 +4731,33 @@ export declare interface SimpleSource extends LogicalNodeBase {
     ctes: CTEPreAggregate[];
 }
 
+export declare class SnowflakeExecutor extends BaseDatabaseExecutor {
+    execute<T = any[]>(query: SQL | any, numericFields?: string[]): Promise<T>;
+    /**
+     * Extract SQL string and params from a query object for error logging
+     */
+    private extractSqlFromQuery;
+    /**
+     * Convert numeric string fields to numbers (only for measure fields)
+     */
+    private convertNumericFields;
+    /**
+     * Coerce a value to a number if it represents a numeric type
+     */
+    private coerceToNumber;
+    getEngineType(): 'snowflake';
+    /**
+     * Execute EXPLAIN on a SQL query to get the execution plan
+     * Snowflake supports EXPLAIN and EXPLAIN USING TEXT/JSON/TABULAR
+     */
+    explainQuery(sqlString: string, params: unknown[], options?: ExplainOptions): Promise<ExplainResult>;
+    /**
+     * Get existing indexes for the specified tables
+     * Snowflake doesn't use traditional indexes (it uses micro-partitioning)
+     */
+    getTableIndexes(_tableNames: string[]): Promise<IndexInfo[]>;
+}
+
 export { SQL }
 
 /**