drizzle-cube 0.1.8 → 0.1.10

package/dist/server/index.js

@@ -1,58 +1,311 @@
-var z = Object.defineProperty;
-var U = (s, e, t) => e in s ? z(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
-var C = (s, e, t) => U(s, typeof e != "symbol" ? e + "" : e, t);
-import { sql as f, and as p, eq as v, count as y, max as B, min as O, avg as R, sum as I, countDistinct as Y, or as J, gt as A, lt as F, gte as w, lte as N, isNull as W, isNotNull as K, notInArray as H, ne as V, inArray as Z } from "drizzle-orm";
-import { parse as G, stringify as P } from "yaml";
-function we(s, e) {
+var W = Object.defineProperty;
+var B = (o, e, t) => e in o ? W(o, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : o[e] = t;
+var C = (o, e, t) => B(o, typeof e != "symbol" ? e + "" : e, t);
+import { sql as m, and as h, or as j, gt as N, lt as $, gte as w, lte as D, isNull as _, isNotNull as z, eq as v, count as y, max as Y, min as R, avg as K, sum as J, countDistinct as H, notInArray as V, ne as G, inArray as P } from "drizzle-orm";
+import { parse as Z, stringify as X } from "yaml";
+class O {
+  /**
+   * Helper method to build pattern for string matching
+   * Can be overridden by specific adapters if needed
+   */
+  buildPattern(e, t) {
+    switch (e) {
+      case "contains":
+      case "notContains":
+        return `%${t}%`;
+      case "startsWith":
+        return `${t}%`;
+      case "endsWith":
+        return `%${t}`;
+      default:
+        return t;
+    }
+  }
+}
+class q extends O {
+  getEngineType() {
+    return "postgres";
+  }
+  /**
+   * Build PostgreSQL time dimension using DATE_TRUNC function
+   * Extracted from executor.ts:649-670 and multi-cube-builder.ts:306-320
+   */
+  buildTimeDimension(e, t) {
+    switch (e) {
+      case "year":
+        return m`DATE_TRUNC('year', ${t}::timestamp)`;
+      case "quarter":
+        return m`DATE_TRUNC('quarter', ${t}::timestamp)`;
+      case "month":
+        return m`DATE_TRUNC('month', ${t}::timestamp)`;
+      case "week":
+        return m`DATE_TRUNC('week', ${t}::timestamp)`;
+      case "day":
+        return m`DATE_TRUNC('day', ${t}::timestamp)::timestamp`;
+      case "hour":
+        return m`DATE_TRUNC('hour', ${t}::timestamp)`;
+      case "minute":
+        return m`DATE_TRUNC('minute', ${t}::timestamp)`;
+      case "second":
+        return m`DATE_TRUNC('second', ${t}::timestamp)`;
+      default:
+        return t;
+    }
+  }
+  /**
+   * Build PostgreSQL string matching conditions using ILIKE (case-insensitive)
+   * Extracted from executor.ts:807-813 and multi-cube-builder.ts:468-474
+   */
+  buildStringCondition(e, t, s) {
+    const n = this.buildPattern(t, s);
+    switch (t) {
+      case "contains":
+        return m`${e} ILIKE ${n}`;
+      case "notContains":
+        return m`${e} NOT ILIKE ${n}`;
+      case "startsWith":
+        return m`${e} ILIKE ${n}`;
+      case "endsWith":
+        return m`${e} ILIKE ${n}`;
+      default:
+        throw new Error(`Unsupported string operator: ${t}`);
+    }
+  }
+  /**
+   * Build PostgreSQL type casting using :: syntax
+   * Extracted from various locations where ::timestamp was used
+   */
+  castToType(e, t) {
+    switch (t) {
+      case "timestamp":
+        return m`${e}::timestamp`;
+      case "decimal":
+        return m`${e}::decimal`;
+      case "integer":
+        return m`${e}::integer`;
+      default:
+        throw new Error(`Unsupported cast type: ${t}`);
+    }
+  }
+  /**
+   * Build PostgreSQL COUNT aggregation
+   * Extracted from multi-cube-builder.ts:278
+   */
+  buildCount(e) {
+    return m`COUNT(${e})`;
+  }
+  /**
+   * Build PostgreSQL COUNT DISTINCT aggregation
+   * Extracted from multi-cube-builder.ts:280
+   */
+  buildCountDistinct(e) {
+    return m`COUNT(DISTINCT ${e})`;
+  }
+  /**
+   * Build PostgreSQL SUM aggregation
+   * Extracted from multi-cube-builder.ts:282
+   */
+  buildSum(e) {
+    return m`SUM(${e})`;
+  }
+  /**
+   * Build PostgreSQL AVG aggregation with COALESCE for NULL handling
+   * PostgreSQL AVG returns NULL for empty sets, so we use COALESCE for consistent behavior
+   * Extracted from multi-cube-builder.ts:284
+   */
+  buildAvg(e) {
+    return m`COALESCE(AVG(${e}), 0)`;
+  }
+  /**
+   * Build PostgreSQL MIN aggregation
+   * Extracted from multi-cube-builder.ts:286
+   */
+  buildMin(e) {
+    return m`MIN(${e})`;
+  }
+  /**
+   * Build PostgreSQL MAX aggregation
+   * Extracted from multi-cube-builder.ts:288
+   */
+  buildMax(e) {
+    return m`MAX(${e})`;
+  }
+}
+class ee extends O {
+  getEngineType() {
+    return "mysql";
+  }
+  /**
+   * Build MySQL time dimension using DATE_FORMAT function
+   * MySQL equivalent to PostgreSQL's DATE_TRUNC
+   */
+  buildTimeDimension(e, t) {
+    const s = {
+      year: "%Y-01-01 00:00:00",
+      quarter: "%Y-%q-01 00:00:00",
+      // %q gives quarter (1,2,3,4), but we need to map this properly
+      month: "%Y-%m-01 00:00:00",
+      week: "%Y-%u-01 00:00:00",
+      // %u gives week of year
+      day: "%Y-%m-%d 00:00:00",
+      hour: "%Y-%m-%d %H:00:00",
+      minute: "%Y-%m-%d %H:%i:00",
+      second: "%Y-%m-%d %H:%i:%s"
+    };
+    switch (e) {
+      case "quarter":
+        return m`DATE_ADD(MAKEDATE(YEAR(${t}), 1), INTERVAL (QUARTER(${t}) - 1) * 3 MONTH)`;
+      case "week":
+        return m`DATE_SUB(${t}, INTERVAL WEEKDAY(${t}) DAY)`;
+      default:
+        const n = s[e];
+        return n ? m`STR_TO_DATE(DATE_FORMAT(${t}, ${n}), '%Y-%m-%d %H:%i:%s')` : t;
+    }
+  }
+  /**
+   * 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(e, t, s) {
+    const n = this.buildPattern(t, s.toLowerCase());
+    switch (t) {
+      case "contains":
+        return m`LOWER(${e}) LIKE ${n}`;
+      case "notContains":
+        return m`LOWER(${e}) NOT LIKE ${n}`;
+      case "startsWith":
+        return m`LOWER(${e}) LIKE ${n}`;
+      case "endsWith":
+        return m`LOWER(${e}) LIKE ${n}`;
+      default:
+        throw new Error(`Unsupported string operator: ${t}`);
+    }
+  }
+  /**
+   * Build MySQL type casting using CAST() function
+   * MySQL equivalent to PostgreSQL's :: casting syntax
+   */
+  castToType(e, t) {
+    switch (t) {
+      case "timestamp":
+        return m`CAST(${e} AS DATETIME)`;
+      case "decimal":
+        return m`CAST(${e} AS DECIMAL(10,2))`;
+      case "integer":
+        return m`CAST(${e} AS SIGNED INTEGER)`;
+      default:
+        throw new Error(`Unsupported cast type: ${t}`);
+    }
+  }
+  /**
+   * Build MySQL COUNT aggregation
+   * Standard SQL COUNT function
+   */
+  buildCount(e) {
+    return m`COUNT(${e})`;
+  }
+  /**
+   * Build MySQL COUNT DISTINCT aggregation
+   * Standard SQL COUNT DISTINCT function
+   */
+  buildCountDistinct(e) {
+    return m`COUNT(DISTINCT ${e})`;
+  }
+  /**
+   * Build MySQL SUM aggregation
+   * Standard SQL SUM function
+   */
+  buildSum(e) {
+    return m`SUM(${e})`;
+  }
+  /**
+   * Build MySQL AVG aggregation with IFNULL for NULL handling
+   * MySQL AVG returns NULL for empty sets, using IFNULL for consistency
+   */
+  buildAvg(e) {
+    return m`IFNULL(AVG(${e}), 0)`;
+  }
+  /**
+   * Build MySQL MIN aggregation
+   * Standard SQL MIN function
+   */
+  buildMin(e) {
+    return m`MIN(${e})`;
+  }
+  /**
+   * Build MySQL MAX aggregation
+   * Standard SQL MAX function
+   */
+  buildMax(e) {
+    return m`MAX(${e})`;
+  }
+}
+function te(o) {
+  switch (o) {
+    case "postgres":
+      return new q();
+    case "mysql":
+      return new ee();
+    case "sqlite":
+      throw new Error("SQLite adapter not yet implemented");
+    default:
+      throw new Error(`Unsupported database engine: ${o}`);
+  }
+}
+function $e(o, e) {
   return {
     ...e,
     name: e.name
   };
 }
-class x {
-  constructor(e, t) {
+class S {
+  constructor(e, t, s) {
+    C(this, "databaseAdapter");
     this.db = e, this.schema = t;
+    const n = s || this.getEngineType();
+    this.databaseAdapter = te(n);
   }
 }
-class X extends x {
+class ne extends S {
   async execute(e, t) {
     if (e && typeof e == "object") {
       if (typeof e.execute == "function") {
         const n = await e.execute();
-        return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
+        return Array.isArray(n) ? n.map((r) => this.convertNumericFields(r, t)) : n;
       }
       if (this.db && typeof this.db.execute == "function")
         try {
           const n = await this.db.execute(e);
-          return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
+          return Array.isArray(n) ? n.map((r) => this.convertNumericFields(r, t)) : n;
         } catch (n) {
           if (typeof e.getSQL == "function") {
-            const o = e.getSQL(), a = await this.db.execute(o);
-            return Array.isArray(a) ? a.map((r) => this.convertNumericFields(r, t)) : a;
+            const r = e.getSQL(), a = await this.db.execute(r);
+            return Array.isArray(a) ? a.map((i) => this.convertNumericFields(i, t)) : a;
           }
           throw n;
         }
     }
     if (!this.db.execute)
       throw new Error("PostgreSQL database instance must have an execute method");
-    const i = await this.db.execute(e);
-    return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+    const s = await this.db.execute(e);
+    return Array.isArray(s) ? s.map((n) => this.convertNumericFields(n, t)) : s;
   }
   /**
    * Convert numeric string fields to numbers (only for measure fields)
    */
   convertNumericFields(e, t) {
     if (!e || typeof e != "object") return e;
-    const i = {};
-    for (const [n, o] of Object.entries(e))
-      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
-    return i;
+    const s = {};
+    for (const [n, r] of Object.entries(e))
+      t && t.includes(n) ? s[n] = this.coerceToNumber(r) : s[n] = r;
+    return s;
   }
   /**
    * Coerce a value to a number if it represents a numeric type
    */
   coerceToNumber(e) {
-    var t, i;
+    var t, s;
     if (e == null || typeof e == "number") return e;
     if (typeof e == "bigint") return Number(e);
     if (e && typeof e == "object") {
@@ -61,7 +314,7 @@ class X extends x {
         if (/^-?\d+(\.\d+)?$/.test(n))
           return n.includes(".") ? parseFloat(n) : parseInt(n, 10);
       }
-      if (((t = e.constructor) == null ? void 0 : t.name) === "Numeric" || ((i = e.constructor) == null ? void 0 : i.name) === "Decimal" || "digits" in e || "sign" in e) {
+      if (((t = e.constructor) == null ? void 0 : t.name) === "Numeric" || ((s = e.constructor) == null ? void 0 : s.name) === "Decimal" || "digits" in e || "sign" in e) {
         const n = e.toString();
         return parseFloat(n);
       }
@@ -79,23 +332,23 @@ class X extends x {
     return "postgres";
   }
 }
-class q extends x {
+class se extends S {
   async execute(e, t) {
     if (e && typeof e == "object" && typeof e.execute == "function") {
-      const i = await e.execute();
-      return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+      const s = await e.execute();
+      return Array.isArray(s) ? s.map((n) => this.convertNumericFields(n, t)) : s;
     }
     try {
       if (this.db.all) {
-        const i = this.db.all(e);
-        return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+        const s = this.db.all(e);
+        return Array.isArray(s) ? s.map((n) => this.convertNumericFields(n, t)) : s;
       } else {
         if (this.db.run)
           return this.db.run(e);
         throw new Error("SQLite database instance must have an all() or run() method");
       }
-    } catch (i) {
-      throw new Error(`SQLite execution failed: ${i instanceof Error ? i.message : "Unknown error"}`);
+    } catch (s) {
+      throw new Error(`SQLite execution failed: ${s instanceof Error ? s.message : "Unknown error"}`);
     }
   }
   /**
@@ -103,10 +356,10 @@ class q extends x {
    */
   convertNumericFields(e, t) {
     if (!e || typeof e != "object") return e;
-    const i = {};
-    for (const [n, o] of Object.entries(e))
-      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
-    return i;
+    const s = {};
+    for (const [n, r] of Object.entries(e))
+      t && t.includes(n) ? s[n] = this.coerceToNumber(r) : s[n] = r;
+    return s;
   }
   /**
    * Coerce a value to a number if it represents a numeric type
@@ -125,26 +378,26 @@ class q extends x {
     return "sqlite";
   }
 }
-class ee extends x {
+class ie extends S {
   async execute(e, t) {
     if (e && typeof e == "object" && typeof e.execute == "function") {
       const n = await e.execute();
-      return Array.isArray(n) ? n.map((o) => this.convertNumericFields(o, t)) : n;
+      return Array.isArray(n) ? n.map((r) => this.convertNumericFields(r, t)) : n;
     }
     if (!this.db.execute)
       throw new Error("MySQL database instance must have an execute method");
-    const i = await this.db.execute(e);
-    return Array.isArray(i) ? i.map((n) => this.convertNumericFields(n, t)) : i;
+    const s = await this.db.execute(e);
+    return Array.isArray(s) ? s.map((n) => this.convertNumericFields(n, t)) : s;
   }
   /**
-   * Convert numeric string fields to numbers (only for measure fields)
+   * Convert numeric string fields to numbers (measure fields + numeric dimensions)
    */
   convertNumericFields(e, t) {
     if (!e || typeof e != "object") return e;
-    const i = {};
-    for (const [n, o] of Object.entries(e))
-      t && t.includes(n) ? i[n] = this.coerceToNumber(o) : i[n] = o;
-    return i;
+    const s = {};
+    for (const [n, r] of Object.entries(e))
+      t && t.includes(n) ? s[n] = this.coerceToNumber(r) : s[n] = r;
+    return s;
   }
   /**
    * Coerce a value to a number if it represents a numeric type
@@ -163,66 +416,75 @@ class ee extends x {
     return "mysql";
   }
 }
-function S(s, e) {
-  return new X(s, e);
+function F(o, e) {
+  return new ne(o, e, "postgres");
 }
-function M(s, e) {
-  return new q(s, e);
+function M(o, e) {
+  return new se(o, e, "sqlite");
 }
-function te(s, e) {
-  return new ee(s, e);
+function re(o, e) {
+  return new ie(o, e, "mysql");
 }
-function _(s, e, t) {
+function L(o, e, t) {
   if (t)
     switch (t) {
       case "postgres":
-        return S(s, e);
+        return F(o, e);
       case "mysql":
-        return te(s, e);
+        return re(o, e);
       case "sqlite":
-        return M(s, e);
+        return M(o, e);
     }
-  if (s.all && s.run)
-    return M(s, e);
-  if (s.execute)
-    return S(s, e);
+  if (o.all && o.run)
+    return M(o, e);
+  if (o.execute)
+    return F(o, e);
   throw new Error("Unable to determine database engine type. Please specify engineType parameter.");
 }
-function Ne(s, e) {
+function Ee(o, e) {
   return {
-    name: s,
+    name: o,
     ...e
   };
 }
-function b(s, e) {
-  return typeof s == "function" ? s(e) : s;
+function b(o, e) {
+  return typeof o == "function" ? o(e) : o;
 }
-function ne(s, e, t) {
+function oe(o, e, t) {
   return {
-    ...s,
+    ...o,
     cubes: e,
     currentCube: t
   };
 }
-class ie {
+class ae {
+  constructor(e) {
+    this.databaseAdapter = e;
+  }
+  /**
+   * Set the database adapter (for use when not provided in constructor)
+   */
+  setDatabaseAdapter(e) {
+    this.databaseAdapter = e;
+  }
   /**
    * Analyze a semantic query to determine which cubes are involved
    */
   analyzeCubeUsage(e) {
     const t = /* @__PURE__ */ new Set();
     if (e.measures)
-      for (const i of e.measures) {
-        const [n] = i.split(".");
+      for (const s of e.measures) {
+        const [n] = s.split(".");
         t.add(n);
       }
     if (e.dimensions)
-      for (const i of e.dimensions) {
-        const [n] = i.split(".");
+      for (const s of e.dimensions) {
+        const [n] = s.split(".");
         t.add(n);
       }
     if (e.timeDimensions)
-      for (const i of e.timeDimensions) {
-        const [n] = i.dimension.split(".");
+      for (const s of e.timeDimensions) {
+        const [n] = s.dimension.split(".");
         t.add(n);
       }
     return t;
@@ -230,20 +492,20 @@ class ie {
   /**
    * Build a multi-cube query plan
    */
-  buildMultiCubeQueryPlan(e, t, i) {
-    const n = this.analyzeCubeUsage(t), o = Array.from(n);
-    if (o.length === 1)
+  buildMultiCubeQueryPlan(e, t, s) {
+    const n = this.analyzeCubeUsage(t), r = Array.from(n);
+    if (r.length === 1)
       throw new Error("Single cube query should use QueryExecutor directly");
-    const a = this.choosePrimaryCube(o, t), r = e.get(a);
-    if (!r)
+    const a = this.choosePrimaryCube(r, t), i = e.get(a);
+    if (!i)
       throw new Error(`Primary cube '${a}' not found`);
-    const c = this.buildJoinPlan(e, r, o, i.securityContext), l = this.buildMultiCubeSelections(e, t, i.securityContext), u = this.buildMultiCubeWhereConditions(e, t, i), m = this.buildMultiCubeGroupByFields(e, t, i.securityContext);
+    const c = this.buildJoinPlan(e, i, r, s), u = this.buildMultiCubeSelections(e, t, s.securityContext), l = this.buildMultiCubeWhereConditions(e, t, s), d = this.buildMultiCubeGroupByFields(e, t, s.securityContext);
     return {
-      primaryCube: r,
+      primaryCube: i,
       joinCubes: c,
-      selections: l,
-      whereConditions: u,
-      groupByFields: m
+      selections: u,
+      whereConditions: l,
+      groupByFields: d
     };
   }
   /**
@@ -251,85 +513,79 @@ class ie {
    */
   choosePrimaryCube(e, t) {
     if (t.measures && t.measures.length > 0) {
-      const [i] = t.measures[0].split(".");
-      return i;
+      const [s] = t.measures[0].split(".");
+      return s;
     }
     if (t.dimensions && t.dimensions.length > 0) {
-      const [i] = t.dimensions[0].split(".");
-      return i;
+      const [s] = t.dimensions[0].split(".");
+      return s;
     }
     return e[0];
   }
   /**
    * Build join plan for multi-cube query
    */
-  buildJoinPlan(e, t, i, n) {
-    var r;
-    const o = [], a = i.filter((c) => c !== t.name);
+  buildJoinPlan(e, t, s, n) {
+    var i;
+    const r = [], a = s.filter((c) => c !== t.name);
     for (const c of a) {
-      const l = e.get(c);
-      if (!l)
-        throw new Error(`Cube '${c}' not found`);
-      const u = (r = t.joins) == null ? void 0 : r[c];
+      const u = e.get(c);
       if (!u)
+        throw new Error(`Cube '${c}' not found`);
+      const l = (i = t.joins) == null ? void 0 : i[c];
+      if (!l)
         throw new Error(`No join definition found from '${t.name}' to '${c}'`);
-      const m = ne(
-        {
-          db: {},
-          // Will be filled in during execution
-          schema: {},
-          // Will be filled in during execution
-          securityContext: n
-        },
+      const d = oe(
+        n,
         e,
-        l
-      ), d = u.condition(m);
-      o.push({
-        cube: l,
+        u
+      ), f = l.condition(d);
+      r.push({
+        cube: u,
         alias: `${c.toLowerCase()}_cube`,
-        joinType: u.type || "left",
-        joinCondition: d
+        joinType: l.type || "left",
+        joinCondition: f
       });
     }
-    return o;
+    return r;
   }
   /**
    * Build selections across multiple cubes
    */
-  buildMultiCubeSelections(e, t, i) {
-    const n = {}, o = {
+  buildMultiCubeSelections(e, t, s) {
+    const n = {}, r = {
       db: {},
       // Filled during execution
       schema: {},
       // Filled during execution
-      securityContext: i
+      securityContext: s
     };
     if (t.dimensions)
       for (const a of t.dimensions) {
-        const [r, c] = a.split("."), l = e.get(r);
-        if (l && l.dimensions[c]) {
-          const u = l.dimensions[c], m = b(u.sql, o);
-          n[a] = f`${m}`.as(a);
+        const [i, c] = a.split("."), u = e.get(i);
+        if (u && u.dimensions[c]) {
+          const l = u.dimensions[c], d = b(l.sql, r);
+          n[a] = m`${d}`.as(a);
         }
       }
     if (t.measures)
       for (const a of t.measures) {
-        const [r, c] = a.split("."), l = e.get(r);
-        if (l && l.measures[c]) {
-          const u = l.measures[c], m = this.buildMeasureExpression(u, o);
-          n[a] = f`${m}`.as(a);
+        const [i, c] = a.split("."), u = e.get(i);
+        if (u && u.measures[c]) {
+          const l = u.measures[c], d = this.buildMeasureExpression(l, r);
+          n[a] = m`${d}`.as(a);
         }
       }
     if (t.timeDimensions)
       for (const a of t.timeDimensions) {
-        const [r, c] = a.dimension.split("."), l = e.get(r);
-        if (l && l.dimensions[c]) {
-          const u = l.dimensions[c], m = this.buildTimeDimensionExpression(
-            u.sql,
+        const [i, c] = a.dimension.split("."), u = e.get(i);
+        if (u && u.dimensions[c]) {
+          const l = u.dimensions[c], d = this.buildTimeDimensionExpression(
+            l.sql,
             a.granularity,
-            o
+            r
           );
-          n[a.dimension] = f`${m}`.as(a.dimension);
+          n[a.dimension] = m`${d}`.as(a.dimension);
         }
       }
     return n;
@@ -338,149 +594,272 @@ class ie {
    * Build measure expression with aggregation (similar to single-cube approach)
    */
   buildMeasureExpression(e, t) {
-    let i = b(e.sql, t);
+    let s = b(e.sql, t);
     if (e.filters && e.filters.length > 0) {
-      const n = e.filters.map((o) => o(t));
-      i = f`CASE WHEN ${p(...n)} THEN ${i} END`;
+      const n = e.filters.map((r) => r(t));
+      s = m`CASE WHEN ${h(...n)} THEN ${s} END`;
     }
+    if (!this.databaseAdapter)
+      throw new Error("DatabaseAdapter is required for measure aggregation");
     switch (e.type) {
       case "count":
-        return f`COUNT(${i})`;
+        return this.databaseAdapter.buildCount(s);
       case "countDistinct":
-        return f`COUNT(DISTINCT ${i})`;
+        return this.databaseAdapter.buildCountDistinct(s);
       case "sum":
-        return f`SUM(${i})`;
+        return this.databaseAdapter.buildSum(s);
       case "avg":
-        return f`AVG(${i})`;
+        return this.databaseAdapter.buildAvg(s);
       case "min":
-        return f`MIN(${i})`;
+        return this.databaseAdapter.buildMin(s);
       case "max":
-        return f`MAX(${i})`;
+        return this.databaseAdapter.buildMax(s);
       case "number":
-        return i;
+        return s;
       default:
-        return f`COUNT(${i})`;
+        return this.databaseAdapter.buildCount(s);
     }
   }
   /**
    * Build time dimension expression (similar to single-cube approach)
    */
-  buildTimeDimensionExpression(e, t, i) {
-    const n = b(e, i);
+  buildTimeDimensionExpression(e, t, s) {
+    const n = b(e, s);
     if (!t)
       return n;
-    switch (t) {
-      case "year":
-        return f`DATE_TRUNC('year', ${n}::timestamp)`;
-      case "quarter":
-        return f`DATE_TRUNC('quarter', ${n}::timestamp)`;
-      case "month":
-        return f`DATE_TRUNC('month', ${n}::timestamp)`;
-      case "week":
-        return f`DATE_TRUNC('week', ${n}::timestamp)`;
-      case "day":
-        return f`DATE_TRUNC('day', ${n}::timestamp)`;
-      case "hour":
-        return f`DATE_TRUNC('hour', ${n}::timestamp)`;
-      case "minute":
-        return f`DATE_TRUNC('minute', ${n}::timestamp)`;
-      case "second":
-        return f`DATE_TRUNC('second', ${n}::timestamp)`;
-      default:
-        return n;
-    }
+    if (!this.databaseAdapter)
+      throw new Error("DatabaseAdapter is required for time dimension building");
+    return this.databaseAdapter.buildTimeDimension(t, n);
   }
   /**
    * Build WHERE conditions for multi-cube query
    */
-  buildMultiCubeWhereConditions(e, t, i) {
+  buildMultiCubeWhereConditions(e, t, s) {
     const n = [];
-    if (t.filters) {
-      for (const o of t.filters)
-        if ("member" in o) {
-          const [a] = o.member.split("."), r = e.get(a);
-          if (r) {
-            const c = this.buildFilterCondition(o, r, i);
-            c && n.push(c);
+    if (t.filters)
+      for (const r of t.filters) {
+        const a = this.processMultiCubeFilter(r, e, s);
+        a && n.push(a);
+      }
+    if (t.timeDimensions) {
+      for (const r of t.timeDimensions)
+        if (r.dateRange) {
+          const [a, i] = r.dimension.split("."), c = e.get(a);
+          if (c && c.dimensions[i]) {
+            const u = c.dimensions[i], l = b(u.sql, s), d = this.buildDateRangeCondition(l, r.dateRange);
+            d && n.push(d);
           }
         }
     }
     return n;
   }
   /**
-   * Filter condition builder (would reuse logic from DrizzleExecutor)
+   * Process a single filter for multi-cube queries (handles logical and simple filters)
    */
-  buildFilterCondition(e, t, i) {
-    if (e.operator === "equals" && e.values && e.values.length > 0) {
-      const [n, o] = e.member.split(".");
-      if (n === t.name) {
-        const a = t.dimensions[o] || t.measures[o];
-        if (a) {
-          const r = typeof a.sql == "function" ? a.sql(i) : a.sql;
-          return v(r, e.values[0]);
+  processMultiCubeFilter(e, t, s) {
+    if ("and" in e || "or" in e) {
+      if (e.and) {
+        const n = e.and.map((r) => this.processMultiCubeFilter(r, t, s)).filter((r) => r !== null);
+        return n.length > 0 ? h(...n) : null;
+      }
+      if (e.or) {
+        const n = e.or.map((r) => this.processMultiCubeFilter(r, t, s)).filter((r) => r !== null);
+        return n.length > 0 ? j(...n) : null;
+      }
+    }
+    if ("member" in e) {
+      const [n] = e.member.split("."), r = t.get(n);
+      if (r)
+        return this.buildFilterCondition(e, r, s);
+    }
+    return null;
+  }
+  /**
+   * Filter condition builder with comprehensive operator support
+   */
+  buildFilterCondition(e, t, s) {
+    if (!e.member || !e.operator)
+      return null;
+    const [n, r] = e.member.split(".");
+    if (n !== t.name)
+      return null;
+    const a = t.dimensions[r] || t.measures[r];
+    if (!a)
+      return null;
+    const i = b(a.sql, s), u = (e.values || []).filter((d) => d != null);
+    if (u.length === 0 && !["set", "notSet"].includes(e.operator))
+      return null;
+    const l = u[0];
+    switch (e.operator) {
+      case "equals":
+        if (u.length === 0)
+          return m`1 = 0`;
+        if (u.length === 1) {
+          const d = a.type === "time" && this.normalizeDate(l) || l;
+          return v(i, d);
+        } else if (a.type === "time") {
+          const d = u.map((f) => this.normalizeDate(f) || f);
+          return m`${i} IN (${m.join(d.map((f) => m`${f}`), m`, `)})`;
+        } else
+          return m`${i} IN (${m.join(u.map((d) => m`${d}`), m`, `)})`;
+      case "notEquals":
+        return u.length === 1 ? m`${i} <> ${l}` : u.length > 1 ? m`${i} NOT IN (${m.join(u.map((d) => m`${d}`), m`, `)})` : null;
+      case "contains":
+        if (!this.databaseAdapter)
+          throw new Error("DatabaseAdapter is required for string conditions");
+        return this.databaseAdapter.buildStringCondition(i, "contains", l);
+      case "notContains":
+        if (!this.databaseAdapter)
+          throw new Error("DatabaseAdapter is required for string conditions");
+        return this.databaseAdapter.buildStringCondition(i, "notContains", l);
+      case "startsWith":
+        if (!this.databaseAdapter)
+          throw new Error("DatabaseAdapter is required for string conditions");
+        return this.databaseAdapter.buildStringCondition(i, "startsWith", l);
+      case "endsWith":
+        if (!this.databaseAdapter)
+          throw new Error("DatabaseAdapter is required for string conditions");
+        return this.databaseAdapter.buildStringCondition(i, "endsWith", l);
+      case "gt":
+        return N(i, l);
+      case "gte":
+        return w(i, l);
+      case "lt":
+        return $(i, l);
+      case "lte":
+        return D(i, l);
+      case "set":
+        return z(i);
+      case "notSet":
+        return _(i);
+      case "inDateRange":
+        if (u.length >= 2) {
+          const d = this.normalizeDate(u[0]), f = this.normalizeDate(u[1]);
+          if (d && f)
+            return h(
+              w(i, d),
+              D(i, f)
+            );
         }
+        return null;
+      case "beforeDate": {
+        const d = this.normalizeDate(l);
+        return d ? $(i, d) : null;
       }
+      case "afterDate": {
+        const d = this.normalizeDate(l);
+        return d ? N(i, d) : null;
+      }
+      default:
+        return null;
+    }
+  }
+  /**
+   * Build date range condition for time dimensions
+   */
+  buildDateRangeCondition(e, t) {
+    if (!t) return null;
+    if (Array.isArray(t) && t.length >= 2) {
+      const s = this.normalizeDate(t[0]), n = this.normalizeDate(t[1]);
+      return !s || !n ? null : h(
+        w(e, s),
+        D(e, n)
+      );
+    }
+    if (typeof t == "string") {
+      const s = this.normalizeDate(t);
+      if (!s) return null;
+      const n = new Date(s);
+      n.setUTCHours(0, 0, 0, 0);
+      const r = new Date(s);
+      return r.setUTCHours(23, 59, 59, 999), h(
+        w(e, n),
+        D(e, r)
+      );
+    }
+    return null;
+  }
+  /**
+   * Normalize date values to handle both string and Date objects
+   * For PostgreSQL timestamp fields, Drizzle expects Date objects
+   */
+  normalizeDate(e) {
+    if (!e) return null;
+    if (e instanceof Date)
+      return isNaN(e.getTime()) ? null : e;
+    if (typeof e == "string") {
+      const t = new Date(e);
+      return isNaN(t.getTime()) ? null : t;
+    }
+    try {
+      const t = new Date(e);
+      if (!isNaN(t.getTime()))
+        return t;
+    } catch {
     }
     return null;
   }
   /**
    * Build GROUP BY fields for multi-cube query
    */
-  buildMultiCubeGroupByFields(e, t, i) {
+  buildMultiCubeGroupByFields(e, t, s) {
     const n = [];
     if (!(t.measures && t.measures.length > 0))
       return [];
     const a = {
       db: {},
       schema: {},
-      securityContext: i
+      securityContext: s
     };
     if (t.dimensions)
-      for (const r of t.dimensions) {
-        const [c, l] = r.split("."), u = e.get(c);
-        if (u && u.dimensions[l]) {
-          const m = u.dimensions[l], d = b(m.sql, a);
-          n.push(d);
+      for (const i of t.dimensions) {
+        const [c, u] = i.split("."), l = e.get(c);
+        if (l && l.dimensions[u]) {
+          const d = l.dimensions[u], f = b(d.sql, a);
+          n.push(f);
         }
       }
     if (t.timeDimensions)
-      for (const r of t.timeDimensions) {
-        const [c, l] = r.dimension.split("."), u = e.get(c);
-        if (u && u.dimensions[l]) {
-          const m = u.dimensions[l], d = this.buildTimeDimensionExpression(
-            m.sql,
-            r.granularity,
+      for (const i of t.timeDimensions) {
+        const [c, u] = i.dimension.split("."), l = e.get(c);
+        if (l && l.dimensions[u]) {
+          const d = l.dimensions[u], f = this.buildTimeDimensionExpression(
+            d.sql,
+            i.granularity,
             a
           );
-          n.push(d);
+          n.push(f);
         }
       }
     return n;
   }
 }
-class $ {
+class T {
   constructor(e) {
     C(this, "multiCubeBuilder");
-    this.dbExecutor = e, this.multiCubeBuilder = new ie();
+    C(this, "databaseAdapter");
+    if (this.dbExecutor = e, this.databaseAdapter = e.databaseAdapter, !this.databaseAdapter)
+      throw new Error("DatabaseExecutor must have a databaseAdapter property");
+    this.multiCubeBuilder = new ae(this.databaseAdapter);
   }
   /**
    * Unified query execution method that handles both single and multi-cube queries
    */
-  async execute(e, t, i) {
+  async execute(e, t, s) {
     try {
-      const n = j(e, t);
+      const n = Q(e, t);
       if (!n.isValid)
         throw new Error(`Query validation failed: ${n.errors.join(", ")}`);
-      const o = this.multiCubeBuilder.analyzeCubeUsage(t);
-      if (o.size === 0)
+      const r = this.multiCubeBuilder.analyzeCubeUsage(t);
+      if (r.size === 0)
         throw new Error("No cubes found for query");
-      if (o.size === 1) {
-        const a = Array.from(o)[0], r = e.get(a);
-        if (!r)
+      if (r.size === 1) {
+        const a = Array.from(r)[0], i = e.get(a);
+        if (!i)
           throw new Error(`Cube '${a}' not found`);
-        return this.executeSingleCube(r, t, i);
+        return this.executeSingleCube(i, t, s);
       } else
-        return this.executeMultiCube(e, t, i);
+        return this.executeMultiCube(e, t, s);
     } catch (n) {
       throw new Error(`Query execution failed: ${n instanceof Error ? n.message : "Unknown error"}`);
     }
@@ -488,76 +867,67 @@ class $ {
   /**
    * Legacy interface for single cube queries
    */
-  async executeQuery(e, t, i) {
+  async executeQuery(e, t, s) {
     const n = /* @__PURE__ */ new Map();
-    return n.set(e.name, e), this.execute(n, t, i);
+    return n.set(e.name, e), this.execute(n, t, s);
   }
   /**
    * Execute a single cube query
    */
-  async executeSingleCube(e, t, i) {
-    return this.executeCube(e, t, i);
+  async executeSingleCube(e, t, s) {
+    return this.executeCube(e, t, s);
   }
   /**
    * Execute a Cube query (dynamic query building)
    */
-  async executeCube(e, t, i) {
+  async executeCube(e, t, s) {
     try {
       const n = {
         db: this.dbExecutor.db,
         schema: this.dbExecutor.schema,
-        securityContext: i
-      }, o = e.sql(n), a = this.buildSelections(e, t, n);
-      let r = n.db.select(a).from(o.from);
-      if (o.joins)
-        for (const h of o.joins)
-          switch (h.type || "left") {
+        securityContext: s
+      }, r = e.sql(n), a = this.buildSelections(e, t, n);
+      let i = n.db.select(a).from(r.from);
+      if (r.joins)
+        for (const p of r.joins)
+          switch (p.type || "left") {
             case "left":
-              r = r.leftJoin(h.table, h.on);
+              i = i.leftJoin(p.table, p.on);
               break;
             case "inner":
-              r = r.innerJoin(h.table, h.on);
+              i = i.innerJoin(p.table, p.on);
               break;
             case "right":
-              r = r.rightJoin(h.table, h.on);
+              i = i.rightJoin(p.table, p.on);
               break;
             case "full":
-              r = r.fullJoin(h.table, h.on);
+              i = i.fullJoin(p.table, p.on);
               break;
           }
-      o.where && (r = r.where(o.where));
+      r.where && (i = i.where(r.where));
       const c = this.buildWhereConditions(e, t, n);
       if (c.length > 0) {
-        const h = c.length === 1 ? c[0] : p(...c);
-        r = r.where(h);
+        const p = c.length === 1 ? c[0] : h(...c);
+        i = i.where(p);
       }
-      const l = this.buildGroupByFields(e, t, n);
-      l.length > 0 && (r = r.groupBy(...l));
-      const u = this.buildOrderBy(t);
-      if (u.length > 0 && (r = r.orderBy(...u)), t.limit !== void 0) {
-        if (t.limit < 0)
-          throw new Error("Limit must be non-negative");
-        r = r.limit(t.limit);
-      }
-      if (t.offset !== void 0) {
-        if (t.offset < 0)
-          throw new Error("Offset must be non-negative");
-        r = r.offset(t.offset);
-      }
-      const m = t.measures || [], d = await this.dbExecutor.execute(r, m), Q = Array.isArray(d) ? d.map((h) => {
-        const E = { ...h };
+      const u = this.buildGroupByFields(e, t, n);
+      u.length > 0 && (i = i.groupBy(...u));
+      const l = this.buildOrderBy(t);
+      l.length > 0 && (i = i.orderBy(...l)), i = this.applyLimitAndOffset(i, t);
+      const d = this.collectNumericFields(e, t), f = await this.dbExecutor.execute(i, d), I = Array.isArray(f) ? f.map((p) => {
+        const A = { ...p };
         if (t.timeDimensions) {
-          for (const D of t.timeDimensions)
-            if (D.dimension in E) {
-              let g = E[D.dimension];
-              typeof g == "string" && g.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/) && (g = g.replace(" ", "T"), !g.endsWith("Z") && !g.includes("+") && (g = g + "Z")), E[D.dimension] = g;
+          for (const E of t.timeDimensions)
+            if (E.dimension in A) {
+              let g = A[E.dimension];
+              typeof g == "string" && g.match(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/) && (g = g.replace(" ", "T"), !g.endsWith("Z") && !g.includes("+") && (g = g + "Z")), A[E.dimension] = g;
             }
         }
-        return E;
-      }) : [d], k = this.generateAnnotations(e, t);
+        return A;
+      }) : [f], U = this.generateAnnotations(e, t);
       return {
-        data: Q,
-        annotation: k
+        data: I,
+        annotation: U
       };
     } catch (n) {
       throw new Error(`Cube query execution failed: ${n instanceof Error ? n.message : "Unknown error"}`);
@@ -566,184 +936,224 @@ class $ {
   /**
    * Execute multi-cube query using JOIN resolution
    */
-  async executeMultiCube(e, t, i) {
-    const n = this.buildMultiCubeQuery(e, t, i), o = t.measures || [], a = await this.dbExecutor.execute(n, o), r = {
+  async executeMultiCube(e, t, s) {
+    const n = this.buildMultiCubeQuery(e, t, s), r = this.collectNumericFieldsMultiCube(e, t), a = await this.dbExecutor.execute(n, r), i = {
       db: this.dbExecutor.db,
       schema: this.dbExecutor.schema,
-      securityContext: i
-    }, c = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, r), l = this.generateMultiCubeAnnotations(c, t);
+      securityContext: s
+    }, c = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, i), u = this.generateMultiCubeAnnotations(c, t);
     return {
       data: Array.isArray(a) ? a : [a],
-      annotation: l
+      annotation: u
     };
   }
   /**
    * Generate raw SQL for debugging (without execution)
    */
-  async generateSQL(e, t, i) {
-    return this.generateCubeSQL(e, t, i);
+  async generateSQL(e, t, s) {
+    return this.generateCubeSQL(e, t, s);
   }
   /**
    * Generate raw SQL for multi-cube queries without execution
    */
-  async generateMultiCubeSQL(e, t, i) {
-    const o = this.buildMultiCubeQuery(e, t, i).toSQL();
+  async generateMultiCubeSQL(e, t, s) {
+    const r = this.buildMultiCubeQuery(e, t, s).toSQL();
     return {
-      sql: o.sql,
-      params: o.params
+      sql: r.sql,
+      params: r.params
     };
   }
   /**
    * Build multi-cube query (extracted from executeMultiCube for reuse)
    */
-  buildMultiCubeQuery(e, t, i) {
+  buildMultiCubeQuery(e, t, s) {
     const n = {
       db: this.dbExecutor.db,
       schema: this.dbExecutor.schema,
-      securityContext: i
-    }, o = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, n), a = o.primaryCube.sql(n);
-    let r = n.db.select(o.selections).from(a.from);
+      securityContext: s
+    }, r = this.multiCubeBuilder.buildMultiCubeQueryPlan(e, t, n), a = r.primaryCube.sql(n);
+    let i = n.db.select(r.selections).from(a.from);
     if (a.joins)
-      for (const u of a.joins)
-        switch (u.type || "left") {
+      for (const l of a.joins)
+        switch (l.type || "left") {
           case "left":
-            r = r.leftJoin(u.table, u.on);
+            i = i.leftJoin(l.table, l.on);
             break;
           case "inner":
-            r = r.innerJoin(u.table, u.on);
+            i = i.innerJoin(l.table, l.on);
             break;
           case "right":
-            r = r.rightJoin(u.table, u.on);
+            i = i.rightJoin(l.table, l.on);
             break;
           case "full":
-            r = r.fullJoin(u.table, u.on);
+            i = i.fullJoin(l.table, l.on);
             break;
           default:
-            r = r.leftJoin(u.table, u.on);
+            i = i.leftJoin(l.table, l.on);
         }
-    if (o.joinCubes && o.joinCubes.length > 0)
-      for (const u of o.joinCubes) {
-        const m = u.cube.sql(n);
+    if (r.joinCubes && r.joinCubes.length > 0)
+      for (const l of r.joinCubes) {
+        const d = l.cube.sql(n);
         try {
-          switch (u.joinType || "left") {
+          switch (l.joinType || "left") {
             case "left":
-              r = r.leftJoin(m.from, u.joinCondition);
+              i = i.leftJoin(d.from, l.joinCondition);
               break;
             case "inner":
-              r = r.innerJoin(m.from, u.joinCondition);
+              i = i.innerJoin(d.from, l.joinCondition);
               break;
             case "right":
-              r = r.rightJoin(m.from, u.joinCondition);
+              i = i.rightJoin(d.from, l.joinCondition);
               break;
             case "full":
-              r = r.fullJoin(m.from, u.joinCondition);
+              i = i.fullJoin(d.from, l.joinCondition);
               break;
           }
-        } catch (d) {
-          console.warn(`Multi-cube join failed for ${u.cube.name}: ${d instanceof Error ? d.message : "Unknown error"}`);
+        } catch (f) {
+          console.warn(`Multi-cube join failed for ${l.cube.name}: ${f instanceof Error ? f.message : "Unknown error"}`);
         }
       }
     const c = [];
-    if (a.where && c.push(a.where), o.whereConditions.length > 0 && c.push(...o.whereConditions), c.length > 0) {
-      const u = c.length === 1 ? c[0] : p(...c);
-      r = r.where(u);
+    if (a.where && c.push(a.where), r.whereConditions.length > 0 && c.push(...r.whereConditions), c.length > 0) {
+      const l = c.length === 1 ? c[0] : h(...c);
+      i = i.where(l);
     }
-    o.groupByFields.length > 0 && (r = r.groupBy(...o.groupByFields));
-    const l = this.buildOrderBy(t);
-    if (l.length > 0 && (r = r.orderBy(...l)), t.limit !== void 0) {
-      if (t.limit < 0)
+    r.groupByFields.length > 0 && (i = i.groupBy(...r.groupByFields));
+    const u = this.buildOrderBy(t);
+    return u.length > 0 && (i = i.orderBy(...u)), i = this.applyLimitAndOffset(i, t), i;
+  }
+  /**
+   * Collect numeric field names (measures + numeric dimensions) for type conversion
+   */
+  collectNumericFields(e, t) {
+    const s = [];
+    if (t.measures && s.push(...t.measures), t.dimensions)
+      for (const n of t.dimensions) {
+        const r = n.includes(".") ? n.split(".")[1] : n, a = e.dimensions[r];
+        a && a.type === "number" && s.push(n);
+      }
+    return s;
+  }
+  /**
+   * Collect numeric field names for multi-cube queries
+   */
+  collectNumericFieldsMultiCube(e, t) {
+    const s = [];
+    if (t.measures && s.push(...t.measures), t.dimensions)
+      for (const n of t.dimensions) {
+        const r = n.includes(".") ? n.split(".")[1] : n;
+        for (const a of e.values()) {
+          const i = a.dimensions[r];
+          if (i && i.type === "number") {
+            s.push(n);
+            break;
+          }
+        }
+      }
+    return s;
+  }
+  /**
+   * Apply LIMIT and OFFSET to a query with validation
+   * If offset is provided without limit, add a reasonable default limit
+   */
+  applyLimitAndOffset(e, t) {
+    let s = t.limit;
+    t.offset !== void 0 && t.offset > 0 && s === void 0 && (s = 50);
+    let n = e;
+    if (s !== void 0) {
+      if (s < 0)
         throw new Error("Limit must be non-negative");
-      r = r.limit(t.limit);
+      n = n.limit(s);
     }
     if (t.offset !== void 0) {
       if (t.offset < 0)
         throw new Error("Offset must be non-negative");
-      r = r.offset(t.offset);
+      n = n.offset(t.offset);
     }
-    return r;
+    return n;
   }
   /**
    * Generate SQL for Cube
    */
-  async generateCubeSQL(e, t, i) {
+  async generateCubeSQL(e, t, s) {
     const n = {
       db: this.dbExecutor.db,
       schema: this.dbExecutor.schema,
-      securityContext: i
-    }, o = e.sql(n), a = this.buildSelections(e, t, n);
-    let r = n.db.select(a).from(o.from);
-    if (o.joins)
-      for (const d of o.joins)
-        switch (d.type || "left") {
+      securityContext: s
+    }, r = e.sql(n), a = this.buildSelections(e, t, n);
+    let i = n.db.select(a).from(r.from);
+    if (r.joins)
+      for (const f of r.joins)
+        switch (f.type || "left") {
           case "left":
-            r = r.leftJoin(d.table, d.on);
+            i = i.leftJoin(f.table, f.on);
             break;
           case "inner":
-            r = r.innerJoin(d.table, d.on);
+            i = i.innerJoin(f.table, f.on);
             break;
           case "right":
-            r = r.rightJoin(d.table, d.on);
+            i = i.rightJoin(f.table, f.on);
             break;
           case "full":
-            r = r.fullJoin(d.table, d.on);
+            i = i.fullJoin(f.table, f.on);
             break;
         }
-    o.where && (r = r.where(o.where));
+    r.where && (i = i.where(r.where));
     const c = this.buildWhereConditions(e, t, n);
     if (c.length > 0) {
-      const d = c.length === 1 ? c[0] : p(...c);
-      r = r.where(d);
+      const f = c.length === 1 ? c[0] : h(...c);
+      i = i.where(f);
     }
-    const l = this.buildGroupByFields(e, t, n);
-    l.length > 0 && (r = r.groupBy(...l));
-    const u = this.buildOrderBy(t);
-    if (u.length > 0 && (r = r.orderBy(...u)), t.limit !== void 0) {
+    const u = this.buildGroupByFields(e, t, n);
+    u.length > 0 && (i = i.groupBy(...u));
+    const l = this.buildOrderBy(t);
+    if (l.length > 0 && (i = i.orderBy(...l)), t.limit !== void 0) {
       if (t.limit < 0)
         throw new Error("Limit must be non-negative");
-      r = r.limit(t.limit);
+      i = i.limit(t.limit);
     }
     if (t.offset !== void 0) {
       if (t.offset < 0)
         throw new Error("Offset must be non-negative");
-      r = r.offset(t.offset);
+      i = i.offset(t.offset);
     }
-    const m = r.toSQL();
+    const d = i.toSQL();
     return {
-      sql: m.sql,
-      params: m.params
+      sql: d.sql,
+      params: d.params
     };
   }
   /**
    * Build dynamic selections for Cube measures and dimensions
    */
-  buildSelections(e, t, i) {
+  buildSelections(e, t, s) {
     const n = {};
     if (t.dimensions)
-      for (const o of t.dimensions) {
-        const [a, r] = o.split(".");
-        if (a === e.name && e.dimensions[r]) {
-          const c = e.dimensions[r], l = b(c.sql, i);
-          n[o] = f`${l}`.as(o);
+      for (const r of t.dimensions) {
+        const [a, i] = r.split(".");
+        if (a === e.name && e.dimensions[i]) {
+          const c = e.dimensions[i], u = b(c.sql, s);
+          n[r] = m`${u}`.as(r);
         }
       }
     if (t.measures)
-      for (const o of t.measures) {
-        const [a, r] = o.split(".");
-        if (a === e.name && e.measures[r]) {
-          const c = e.measures[r], l = this.buildMeasureExpression(c, i);
-          n[o] = f`${l}`.as(o);
+      for (const r of t.measures) {
+        const [a, i] = r.split(".");
+        if (a === e.name && e.measures[i]) {
+          const c = e.measures[i], u = this.buildMeasureExpression(c, s);
+          n[r] = m`${u}`.as(r);
         }
       }
     if (t.timeDimensions)
-      for (const o of t.timeDimensions) {
-        const [a, r] = o.dimension.split(".");
-        if (a === e.name && e.dimensions[r]) {
-          const c = e.dimensions[r], l = this.buildTimeDimensionExpression(
+      for (const r of t.timeDimensions) {
+        const [a, i] = r.dimension.split(".");
+        if (a === e.name && e.dimensions[i]) {
+          const c = e.dimensions[i], u = this.buildTimeDimensionExpression(
             c.sql,
-            o.granularity,
-            i
+            r.granularity,
+            s
           );
-          n[o.dimension] = f`${l}`.as(o.dimension);
+          n[r.dimension] = m`${u}`.as(r.dimension);
         }
       }
     return Object.keys(n).length === 0 && (n.count = y()), n;
@@ -752,74 +1162,53 @@ class $ {
    * Build measure expression with aggregation and filters for Cube
    */
   buildMeasureExpression(e, t) {
-    let i = b(e.sql, t);
+    let s = b(e.sql, t);
     if (e.filters && e.filters.length > 0) {
-      const n = e.filters.map((o) => o(t));
-      i = f`CASE WHEN ${p(...n)} THEN ${i} END`;
+      const n = e.filters.map((r) => r(t));
+      s = m`CASE WHEN ${h(...n)} THEN ${s} END`;
     }
     switch (e.type) {
       case "count":
-        return y(i);
+        return y(s);
       case "countDistinct":
-        return Y(i);
+        return H(s);
       case "sum":
-        return I(i);
+        return J(s);
       case "avg":
-        return R(i);
+        return K(s);
       case "min":
-        return O(i);
+        return R(s);
       case "max":
-        return B(i);
+        return Y(s);
       case "number":
-        return i;
+        return s;
       default:
-        return y(i);
+        return y(s);
     }
   }
   /**
-   * Build time dimension expression with granularity
+   * Build time dimension expression with granularity using database adapter
    */
-  buildTimeDimensionExpression(e, t, i) {
-    const n = b(e, i);
-    if (!t)
-      return f`${n}`;
-    switch (t) {
-      case "year":
-        return f`DATE_TRUNC('year', ${n}::timestamp)`;
-      case "quarter":
-        return f`DATE_TRUNC('quarter', ${n}::timestamp)`;
-      case "month":
-        return f`DATE_TRUNC('month', ${n}::timestamp)`;
-      case "week":
-        return f`DATE_TRUNC('week', ${n}::timestamp)`;
-      case "day":
-        return f`DATE_TRUNC('day', ${n}::timestamp)::timestamp`;
-      case "hour":
-        return f`DATE_TRUNC('hour', ${n}::timestamp)`;
-      case "minute":
-        return f`DATE_TRUNC('minute', ${n}::timestamp)`;
-      case "second":
-        return f`DATE_TRUNC('second', ${n}::timestamp)`;
-      default:
-        return n;
-    }
+  buildTimeDimensionExpression(e, t, s) {
+    const n = b(e, s);
+    return t ? this.databaseAdapter.buildTimeDimension(t, n) : m`${n}`;
   }
   /**
    * Build WHERE conditions from semantic query filters (Cube)
    */
-  buildWhereConditions(e, t, i) {
+  buildWhereConditions(e, t, s) {
     const n = [];
     if (t.filters && t.filters.length > 0)
-      for (const o of t.filters) {
-        const a = this.processFilter(o, e, i);
+      for (const r of t.filters) {
+        const a = this.processFilter(r, e, s);
         a && n.push(a);
       }
     if (t.timeDimensions)
-      for (const o of t.timeDimensions) {
-        const [a, r] = o.dimension.split(".");
-        if (a === e.name && e.dimensions[r] && o.dateRange) {
-          const c = e.dimensions[r], l = b(c.sql, i), u = this.buildDateRangeCondition(l, o.dateRange);
-          u && n.push(u);
+      for (const r of t.timeDimensions) {
+        const [a, i] = r.dimension.split(".");
+        if (a === e.name && e.dimensions[i] && r.dateRange) {
+          const c = e.dimensions[i], u = b(c.sql, s), l = this.buildDateRangeCondition(u, r.dateRange);
+          l && n.push(l);
         }
       }
     return n;
@@ -827,77 +1216,77 @@ class $ {
   /**
    * Process a single filter for Cube (basic or logical)
    */
-  processFilter(e, t, i) {
+  processFilter(e, t, s) {
     if ("and" in e || "or" in e) {
-      const l = e;
-      if (l.and) {
-        const u = l.and.map((m) => this.processFilter(m, t, i)).filter((m) => m !== null);
-        return u.length > 0 ? p(...u) : null;
+      const u = e;
+      if (u.and) {
+        const l = u.and.map((d) => this.processFilter(d, t, s)).filter((d) => d !== null);
+        return l.length > 0 ? h(...l) : null;
       }
-      if (l.or) {
-        const u = l.or.map((m) => this.processFilter(m, t, i)).filter((m) => m !== null);
-        return u.length > 0 ? J(...u) : null;
+      if (u.or) {
+        const l = u.or.map((d) => this.processFilter(d, t, s)).filter((d) => d !== null);
+        return l.length > 0 ? j(...l) : null;
       }
     }
-    const n = e, [o, a] = n.member.split(".");
-    if (o !== t.name) return null;
-    const r = t.dimensions[a] || t.measures[a];
-    if (!r) return null;
-    const c = b(r.sql, i);
+    const n = e, [r, a] = n.member.split(".");
+    if (r !== t.name) return null;
+    const i = t.dimensions[a] || t.measures[a];
+    if (!i) return null;
+    const c = b(i.sql, s);
     return this.buildFilterCondition(c, n.operator, n.values);
   }
   /**
    * Build filter condition using Drizzle operators
    */
-  buildFilterCondition(e, t, i) {
-    if (!i || i.length === 0)
-      return t === "equals" ? f`FALSE` : null;
-    const n = i.filter((a) => !(a == null || a === "" || typeof a == "string" && a.includes("\0")));
+  buildFilterCondition(e, t, s) {
+    if (!s || s.length === 0)
+      return t === "equals" ? m`FALSE` : null;
+    const n = s.filter((a) => !(a == null || a === "" || typeof a == "string" && a.includes("\0")));
     if (n.length === 0 && !["set", "notSet"].includes(t))
-      return t === "equals" ? f`FALSE` : null;
-    const o = n[0];
+      return t === "equals" ? m`FALSE` : null;
+    const r = n[0];
     switch (t) {
       case "equals":
-        return n.length > 1 ? Z(e, n) : n.length === 1 ? v(e, o) : f`FALSE`;
+        return n.length > 1 ? P(e, n) : n.length === 1 ? v(e, r) : m`FALSE`;
       case "notEquals":
-        return n.length > 1 ? H(e, n) : n.length === 1 ? V(e, o) : null;
+        return n.length > 1 ? V(e, n) : n.length === 1 ? G(e, r) : null;
       case "contains":
-        return f`${e} ILIKE ${"%" + o + "%"}`;
+        return this.databaseAdapter.buildStringCondition(e, "contains", r);
       case "notContains":
-        return f`${e} NOT ILIKE ${"%" + o + "%"}`;
+        return this.databaseAdapter.buildStringCondition(e, "notContains", r);
       case "startsWith":
-        return f`${e} ILIKE ${o + "%"}`;
+        return this.databaseAdapter.buildStringCondition(e, "startsWith", r);
       case "endsWith":
-        return f`${e} ILIKE ${"%" + o}`;
+        return this.databaseAdapter.buildStringCondition(e, "endsWith", r);
       case "gt":
-        return A(e, o);
+        return N(e, r);
       case "gte":
-        return w(e, o);
+        return w(e, r);
       case "lt":
-        return F(e, o);
+        return $(e, r);
       case "lte":
-        return N(e, o);
+        return D(e, r);
       case "set":
-        return K(e);
+        return z(e);
       case "notSet":
-        return W(e);
+        return _(e);
       case "inDateRange":
         if (n.length >= 2) {
-          const a = this.normalizeDate(n[0]), r = this.normalizeDate(n[1]);
-          if (a && r)
-            return p(
+          const a = this.normalizeDate(n[0]), i = this.normalizeDate(n[1]);
+          if (a && i)
+            return h(
               w(e, a),
-              N(e, r)
+              D(e, i)
             );
         }
         return null;
       case "beforeDate": {
-        const a = this.normalizeDate(o);
-        return a ? F(e, a) : null;
+        const a = this.normalizeDate(r);
+        return a ? $(e, a) : null;
       }
       case "afterDate": {
-        const a = this.normalizeDate(o);
-        return a ? A(e, a) : null;
+        const a = this.normalizeDate(r);
+        return a ? N(e, a) : null;
       }
       default:
         return null;
@@ -909,27 +1298,27 @@ class $ {
   buildDateRangeCondition(e, t) {
     if (!t) return null;
     if (Array.isArray(t) && t.length >= 2) {
-      const i = this.normalizeDate(t[0]), n = this.normalizeDate(t[1]);
-      return !i || !n ? null : p(
-        w(e, i),
-        N(e, n)
+      const s = this.normalizeDate(t[0]), n = this.normalizeDate(t[1]);
+      return !s || !n ? null : h(
+        w(e, s),
+        D(e, n)
       );
     }
     if (typeof t == "string") {
-      const i = this.parseRelativeDateRange(t);
-      if (i)
-        return p(
-          w(e, i.start),
-          N(e, i.end)
+      const s = this.parseRelativeDateRange(t);
+      if (s)
+        return h(
+          w(e, s.start),
+          D(e, s.end)
         );
       const n = this.normalizeDate(t);
       if (!n) return null;
-      const o = new Date(n);
-      o.setUTCHours(0, 0, 0, 0);
+      const r = new Date(n);
+      r.setUTCHours(0, 0, 0, 0);
       const a = new Date(n);
-      return a.setUTCHours(23, 59, 59, 999), p(
-        w(e, o),
-        N(e, a)
+      return a.setUTCHours(23, 59, 59, 999), h(
+        w(e, r),
+        D(e, a)
       );
     }
     return null;
@@ -938,30 +1327,30 @@ class $ {
    * Parse relative date range expressions like "last 7 days", "this month"
    */
   parseRelativeDateRange(e) {
-    const t = /* @__PURE__ */ new Date(), i = e.toLowerCase().trim(), n = i.match(/^last\s+(\d+)\s+days?$/);
+    const t = /* @__PURE__ */ new Date(), s = e.toLowerCase().trim(), n = s.match(/^last\s+(\d+)\s+days?$/);
     if (n) {
-      const r = parseInt(n[1], 10), c = new Date(t);
-      c.setDate(t.getDate() - r), c.setHours(0, 0, 0, 0);
-      const l = new Date(t);
-      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+      const i = parseInt(n[1], 10), c = new Date(t);
+      c.setDate(t.getDate() - i), c.setHours(0, 0, 0, 0);
+      const u = new Date(t);
+      return u.setHours(23, 59, 59, 999), { start: c, end: u };
     }
-    if (i === "this month") {
-      const r = new Date(t.getFullYear(), t.getMonth(), 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), t.getMonth() + 1, 0, 23, 59, 59, 999);
-      return { start: r, end: c };
+    if (s === "this month") {
+      const i = new Date(t.getFullYear(), t.getMonth(), 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), t.getMonth() + 1, 0, 23, 59, 59, 999);
+      return { start: i, end: c };
     }
-    const o = i.match(/^last\s+(\d+)\s+months?$/);
-    if (o) {
-      const r = parseInt(o[1], 10), c = new Date(t.getFullYear(), t.getMonth() - r, 1, 0, 0, 0, 0), l = new Date(t);
-      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+    const r = s.match(/^last\s+(\d+)\s+months?$/);
+    if (r) {
+      const i = parseInt(r[1], 10), c = new Date(t.getFullYear(), t.getMonth() - i, 1, 0, 0, 0, 0), u = new Date(t);
+      return u.setHours(23, 59, 59, 999), { start: c, end: u };
     }
-    if (i === "this year") {
-      const r = new Date(t.getFullYear(), 0, 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), 11, 31, 23, 59, 59, 999);
-      return { start: r, end: c };
+    if (s === "this year") {
+      const i = new Date(t.getFullYear(), 0, 1, 0, 0, 0, 0), c = new Date(t.getFullYear(), 11, 31, 23, 59, 59, 999);
+      return { start: i, end: c };
     }
-    const a = i.match(/^last\s+(\d+)\s+years?$/);
+    const a = s.match(/^last\s+(\d+)\s+years?$/);
     if (a) {
-      const r = parseInt(a[1], 10), c = new Date(t.getFullYear() - r, 0, 1, 0, 0, 0, 0), l = new Date(t);
-      return l.setHours(23, 59, 59, 999), { start: c, end: l };
+      const i = parseInt(a[1], 10), c = new Date(t.getFullYear() - i, 0, 1, 0, 0, 0, 0), u = new Date(t);
+      return u.setHours(23, 59, 59, 999), { start: c, end: u };
     }
     return null;
   }
@@ -974,8 +1363,8 @@ class $ {
     if (e instanceof Date)
       return isNaN(e.getTime()) ? null : e;
     if (typeof e == "string") {
-      const i = new Date(e);
-      return isNaN(i.getTime()) ? null : i;
+      const s = new Date(e);
+      return isNaN(s.getTime()) ? null : s;
     }
     const t = new Date(e);
     return isNaN(t.getTime()) ? null : t;
@@ -983,26 +1372,26 @@ class $ {
   /**
    * Build GROUP BY fields from dimensions and time dimensions (Cube)
    */
-  buildGroupByFields(e, t, i) {
+  buildGroupByFields(e, t, s) {
     const n = [];
     if (t.dimensions)
-      for (const o of t.dimensions) {
-        const [a, r] = o.split(".");
-        if (a === e.name && e.dimensions[r]) {
-          const c = e.dimensions[r], l = b(c.sql, i);
-          n.push(l);
+      for (const r of t.dimensions) {
+        const [a, i] = r.split(".");
+        if (a === e.name && e.dimensions[i]) {
+          const c = e.dimensions[i], u = b(c.sql, s);
+          n.push(u);
         }
       }
     if (t.timeDimensions)
-      for (const o of t.timeDimensions) {
-        const [a, r] = o.dimension.split(".");
-        if (a === e.name && e.dimensions[r]) {
-          const c = e.dimensions[r], l = this.buildTimeDimensionExpression(
+      for (const r of t.timeDimensions) {
+        const [a, i] = r.dimension.split(".");
+        if (a === e.name && e.dimensions[i]) {
+          const c = e.dimensions[i], u = this.buildTimeDimensionExpression(
             c.sql,
-            o.granularity,
-            i
+            r.granularity,
+            s
           );
-          n.push(l);
+          n.push(u);
         }
       }
     return n;
@@ -1011,128 +1400,128 @@ class $ {
    * Build ORDER BY clause with automatic time dimension sorting
    */
   buildOrderBy(e, t) {
-    var o;
-    const i = [], n = t || [
+    var r;
+    const s = [], n = t || [
       ...e.measures || [],
       ...e.dimensions || [],
-      ...((o = e.timeDimensions) == null ? void 0 : o.map((a) => a.dimension)) || []
+      ...((r = e.timeDimensions) == null ? void 0 : r.map((a) => a.dimension)) || []
     ];
     if (e.order && Object.keys(e.order).length > 0)
-      for (const [a, r] of Object.entries(e.order)) {
+      for (const [a, i] of Object.entries(e.order)) {
         if (!n.includes(a))
           throw new Error(`Cannot order by '${a}': field is not selected in the query`);
-        const c = r === "desc" ? f`DESC` : f`ASC`;
-        i.push(f`${f.identifier(a)} ${c}`);
+        const c = i === "desc" ? m`DESC` : m`ASC`;
+        s.push(m`${m.identifier(a)} ${c}`);
       }
     if (e.timeDimensions && e.timeDimensions.length > 0) {
-      const a = new Set(Object.keys(e.order || {})), r = [...e.timeDimensions].sort(
-        (c, l) => c.dimension.localeCompare(l.dimension)
+      const a = new Set(Object.keys(e.order || {})), i = [...e.timeDimensions].sort(
+        (c, u) => c.dimension.localeCompare(u.dimension)
       );
-      for (const c of r)
-        a.has(c.dimension) || i.push(f`${f.identifier(c.dimension)} ASC`);
+      for (const c of i)
+        a.has(c.dimension) || s.push(m`${m.identifier(c.dimension)} ASC`);
     }
-    return i;
+    return s;
   }
   /**
    * Generate annotations for UI metadata
    */
   generateAnnotations(e, t) {
-    const i = {}, n = {}, o = {};
+    const s = {}, n = {}, r = {};
     if (t.measures)
       for (const a of t.measures) {
-        const [r, c] = a.split(".");
-        if (r === e.name && e.measures[c]) {
-          const l = e.measures[c];
-          i[a] = {
-            title: l.title || c,
-            shortTitle: l.title || c,
-            type: l.type
+        const [i, c] = a.split(".");
+        if (i === e.name && e.measures[c]) {
+          const u = e.measures[c];
+          s[a] = {
+            title: u.title || c,
+            shortTitle: u.title || c,
+            type: u.type
           };
         }
       }
     if (t.dimensions)
       for (const a of t.dimensions) {
-        const [r, c] = a.split(".");
-        if (r === e.name && e.dimensions[c]) {
-          const l = e.dimensions[c];
+        const [i, c] = a.split(".");
+        if (i === e.name && e.dimensions[c]) {
+          const u = e.dimensions[c];
           n[a] = {
-            title: l.title || c,
-            shortTitle: l.title || c,
-            type: l.type
+            title: u.title || c,
+            shortTitle: u.title || c,
+            type: u.type
           };
         }
       }
     if (t.timeDimensions)
       for (const a of t.timeDimensions) {
-        const [r, c] = a.dimension.split(".");
-        if (r === e.name && e.dimensions[c]) {
-          const l = e.dimensions[c];
-          o[a.dimension] = {
-            title: l.title || c,
-            shortTitle: l.title || c,
-            type: l.type,
+        const [i, c] = a.dimension.split(".");
+        if (i === e.name && e.dimensions[c]) {
+          const u = e.dimensions[c];
+          r[a.dimension] = {
+            title: u.title || c,
+            shortTitle: u.title || c,
+            type: u.type,
             granularity: a.granularity
           };
         }
       }
     return {
-      measures: i,
+      measures: s,
       dimensions: n,
       segments: {},
-      timeDimensions: o
+      timeDimensions: r
     };
   }
   /**
    * Generate annotations for multi-cube queries
    */
   generateMultiCubeAnnotations(e, t) {
-    const i = {}, n = {}, o = {}, a = [e.primaryCube];
-    if (e.joinCubes && a.push(...e.joinCubes.map((r) => r.cube)), t.measures)
-      for (const r of t.measures) {
-        const [c, l] = r.split("."), u = a.find((m) => m.name === c);
-        if (u && u.measures[l]) {
-          const m = u.measures[l];
-          i[r] = {
-            title: m.title || l,
-            shortTitle: m.title || l,
-            type: m.type
+    const s = {}, n = {}, r = {}, a = [e.primaryCube];
+    if (e.joinCubes && a.push(...e.joinCubes.map((i) => i.cube)), t.measures)
+      for (const i of t.measures) {
+        const [c, u] = i.split("."), l = a.find((d) => d.name === c);
+        if (l && l.measures[u]) {
+          const d = l.measures[u];
+          s[i] = {
+            title: d.title || u,
+            shortTitle: d.title || u,
+            type: d.type
           };
         }
       }
     if (t.dimensions)
-      for (const r of t.dimensions) {
-        const [c, l] = r.split("."), u = a.find((m) => m.name === c);
-        if (u && u.dimensions[l]) {
-          const m = u.dimensions[l];
-          n[r] = {
-            title: m.title || l,
-            shortTitle: m.title || l,
-            type: m.type
+      for (const i of t.dimensions) {
+        const [c, u] = i.split("."), l = a.find((d) => d.name === c);
+        if (l && l.dimensions[u]) {
+          const d = l.dimensions[u];
+          n[i] = {
+            title: d.title || u,
+            shortTitle: d.title || u,
+            type: d.type
           };
         }
       }
     if (t.timeDimensions)
-      for (const r of t.timeDimensions) {
-        const [c, l] = r.dimension.split("."), u = a.find((m) => m.name === c);
-        if (u && u.dimensions && u.dimensions[l]) {
-          const m = u.dimensions[l];
-          o[r.dimension] = {
-            title: m.title || l,
-            shortTitle: m.title || l,
-            type: m.type,
-            granularity: r.granularity
+      for (const i of t.timeDimensions) {
+        const [c, u] = i.dimension.split("."), l = a.find((d) => d.name === c);
+        if (l && l.dimensions && l.dimensions[u]) {
+          const d = l.dimensions[u];
+          r[i.dimension] = {
+            title: d.title || u,
+            shortTitle: d.title || u,
+            type: d.type,
+            granularity: i.granularity
           };
         }
       }
     return {
-      measures: i,
+      measures: s,
       dimensions: n,
       segments: {},
-      timeDimensions: o
+      timeDimensions: r
     };
   }
 }
-class T {
+class x {
   // 5 minutes in milliseconds
   constructor(e) {
     C(this, "cubes", /* @__PURE__ */ new Map());
@@ -1140,7 +1529,7 @@ class T {
     C(this, "metadataCache");
     C(this, "metadataCacheTimestamp");
     C(this, "METADATA_CACHE_TTL", 5 * 60 * 1e3);
-    e != null && e.databaseExecutor ? this.dbExecutor = e.databaseExecutor : e != null && e.drizzle && (this.dbExecutor = _(
+    e != null && e.databaseExecutor ? this.dbExecutor = e.databaseExecutor : e != null && e.drizzle && (this.dbExecutor = L(
       e.drizzle,
       e.schema,
       e.engineType
@@ -1155,8 +1544,8 @@ class T {
   /**
    * Set Drizzle instance and schema directly
    */
-  setDrizzle(e, t, i) {
-    this.dbExecutor = _(e, t, i);
+  setDrizzle(e, t, s) {
+    this.dbExecutor = L(e, t, s);
   }
   /**
    * Check if database executor is configured
@@ -1194,7 +1583,7 @@ class T {
   async execute(e, t) {
     if (!this.dbExecutor)
       throw new Error("Database executor not configured");
-    return new $(this.dbExecutor).execute(this.cubes, e, t);
+    return new T(this.dbExecutor).execute(this.cubes, e, t);
   }
   /**
    * Execute a multi-cube query
@@ -1205,10 +1594,10 @@ class T {
   /**
    * Execute a single cube query
    */
-  async executeQuery(e, t, i) {
+  async executeQuery(e, t, s) {
     if (!this.cubes.get(e))
       throw new Error(`Cube '${e}' not found`);
-    return this.execute(t, i);
+    return this.execute(t, s);
   }
   /**
    * Get metadata for all cubes (for API responses)
@@ -1218,7 +1607,7 @@ class T {
     const e = Date.now();
     if (this.metadataCache && this.metadataCacheTimestamp && e - this.metadataCacheTimestamp < this.METADATA_CACHE_TTL)
       return this.metadataCache;
-    const t = Array.from(this.cubes.values()).map((i) => this.generateCubeMetadata(i));
+    const t = Array.from(this.cubes.values()).map((s) => this.generateCubeMetadata(s));
     return this.metadataCache = t, this.metadataCacheTimestamp = e, t;
   }
   /**
@@ -1226,25 +1615,25 @@ class T {
    * Optimized version that minimizes object iterations
    */
   generateCubeMetadata(e) {
-    const t = Object.keys(e.measures), i = Object.keys(e.dimensions), n = new Array(t.length), o = new Array(i.length);
+    const t = Object.keys(e.measures), s = Object.keys(e.dimensions), n = new Array(t.length), r = new Array(s.length);
     for (let a = 0; a < t.length; a++) {
-      const r = t[a], c = e.measures[r];
+      const i = t[a], c = e.measures[i];
       n[a] = {
-        name: `${e.name}.${r}`,
-        title: c.title || r,
-        shortTitle: c.title || r,
+        name: `${e.name}.${i}`,
+        title: c.title || i,
+        shortTitle: c.title || i,
         type: c.type,
         format: void 0,
         // Measure doesn't have format field
         description: c.description
       };
     }
-    for (let a = 0; a < i.length; a++) {
-      const r = i[a], c = e.dimensions[r];
-      o[a] = {
-        name: `${e.name}.${r}`,
-        title: c.title || r,
-        shortTitle: c.title || r,
+    for (let a = 0; a < s.length; a++) {
+      const i = s[a], c = e.dimensions[i];
+      r[a] = {
+        name: `${e.name}.${i}`,
+        title: c.title || i,
+        shortTitle: c.title || i,
         type: c.type,
         format: void 0,
         // Dimension doesn't have format field
@@ -1256,7 +1645,7 @@ class T {
       title: e.title || e.name,
       description: e.description,
       measures: n,
-      dimensions: o,
+      dimensions: r,
       segments: []
       // Add segments support later if needed
     };
@@ -1264,13 +1653,13 @@ class T {
   /**
    * Get SQL for a query without executing it (debugging)
    */
-  async generateSQL(e, t, i) {
+  async generateSQL(e, t, s) {
     const n = this.getCube(e);
     if (!n)
       throw new Error(`Cube '${e}' not found`);
     if (!this.dbExecutor)
       throw new Error("Database executor not configured");
-    return new $(this.dbExecutor).generateSQL(n, t, i);
+    return new T(this.dbExecutor).generateSQL(n, t, s);
   }
   /**
    * Get SQL for a multi-cube query without executing it (debugging)
@@ -1278,7 +1667,7 @@ class T {
   async generateMultiCubeSQL(e, t) {
     if (!this.dbExecutor)
       throw new Error("Database executor not configured");
-    return new $(this.dbExecutor).generateMultiCubeSQL(this.cubes, e, t);
+    return new T(this.dbExecutor).generateMultiCubeSQL(this.cubes, e, t);
   }
   /**
    * Check if a cube exists
@@ -1317,93 +1706,93 @@ class T {
    * Ensures all referenced cubes and fields exist
    */
   validateQuery(e) {
-    return j(this.cubes, e);
+    return Q(this.cubes, e);
   }
 }
-function j(s, e) {
-  const t = [], i = /* @__PURE__ */ new Set();
+function Q(o, e) {
+  const t = [], s = /* @__PURE__ */ new Set();
   if (e.measures)
     for (const n of e.measures) {
-      const [o, a] = n.split(".");
-      if (!o || !a) {
+      const [r, a] = n.split(".");
+      if (!r || !a) {
         t.push(`Invalid measure format: ${n}. Expected format: 'CubeName.fieldName'`);
         continue;
       }
-      i.add(o);
-      const r = s.get(o);
-      if (!r) {
-        t.push(`Cube '${o}' not found (referenced in measure '${n}')`);
+      s.add(r);
+      const i = o.get(r);
+      if (!i) {
+        t.push(`Cube '${r}' not found (referenced in measure '${n}')`);
         continue;
       }
-      r.measures[a] || t.push(`Measure '${a}' not found on cube '${o}'`);
+      i.measures[a] || t.push(`Measure '${a}' not found on cube '${r}'`);
     }
   if (e.dimensions)
     for (const n of e.dimensions) {
-      const [o, a] = n.split(".");
-      if (!o || !a) {
+      const [r, a] = n.split(".");
+      if (!r || !a) {
         t.push(`Invalid dimension format: ${n}. Expected format: 'CubeName.fieldName'`);
         continue;
       }
-      i.add(o);
-      const r = s.get(o);
-      if (!r) {
-        t.push(`Cube '${o}' not found (referenced in dimension '${n}')`);
+      s.add(r);
+      const i = o.get(r);
+      if (!i) {
+        t.push(`Cube '${r}' not found (referenced in dimension '${n}')`);
         continue;
       }
-      r.dimensions[a] || t.push(`Dimension '${a}' not found on cube '${o}'`);
+      i.dimensions[a] || t.push(`Dimension '${a}' not found on cube '${r}'`);
     }
   if (e.timeDimensions)
     for (const n of e.timeDimensions) {
-      const [o, a] = n.dimension.split(".");
-      if (!o || !a) {
+      const [r, a] = n.dimension.split(".");
+      if (!r || !a) {
         t.push(`Invalid timeDimension format: ${n.dimension}. Expected format: 'CubeName.fieldName'`);
         continue;
       }
-      i.add(o);
-      const r = s.get(o);
-      if (!r) {
-        t.push(`Cube '${o}' not found (referenced in timeDimension '${n.dimension}')`);
+      s.add(r);
+      const i = o.get(r);
+      if (!i) {
+        t.push(`Cube '${r}' not found (referenced in timeDimension '${n.dimension}')`);
         continue;
       }
-      r.dimensions[a] || t.push(`TimeDimension '${a}' not found on cube '${o}' (must be a dimension with time type)`);
+      i.dimensions[a] || t.push(`TimeDimension '${a}' not found on cube '${r}' (must be a dimension with time type)`);
     }
   if (e.filters)
     for (const n of e.filters)
-      L(n, s, t, i);
-  return i.size === 0 && t.push("Query must reference at least one cube through measures, dimensions, or filters"), {
+      k(n, o, t, s);
+  return s.size === 0 && t.push("Query must reference at least one cube through measures, dimensions, or filters"), {
     isValid: t.length === 0,
     errors: t
   };
 }
-function L(s, e, t, i) {
-  if ("and" in s || "or" in s) {
-    const r = s.and || s.or || [];
-    for (const c of r)
-      L(c, e, t, i);
+function k(o, e, t, s) {
+  if ("and" in o || "or" in o) {
+    const i = o.and || o.or || [];
+    for (const c of i)
+      k(c, e, t, s);
     return;
   }
-  if (!("member" in s)) {
+  if (!("member" in o)) {
     t.push("Filter must have a member field");
     return;
   }
-  const [n, o] = s.member.split(".");
-  if (!n || !o) {
-    t.push(`Invalid filter member format: ${s.member}. Expected format: 'CubeName.fieldName'`);
+  const [n, r] = o.member.split(".");
+  if (!n || !r) {
+    t.push(`Invalid filter member format: ${o.member}. Expected format: 'CubeName.fieldName'`);
     return;
   }
-  i.add(n);
+  s.add(n);
   const a = e.get(n);
   if (!a) {
-    t.push(`Cube '${n}' not found (referenced in filter '${s.member}')`);
+    t.push(`Cube '${n}' not found (referenced in filter '${o.member}')`);
     return;
   }
-  !a.dimensions[o] && !a.measures[o] && t.push(`Filter field '${o}' not found on cube '${n}' (must be a dimension or measure)`);
+  !a.dimensions[r] && !a.measures[r] && t.push(`Filter field '${r}' not found on cube '${n}' (must be a dimension or measure)`);
 }
-function Ee(s) {
-  return new T(s);
+function ye(o) {
+  return new x(o);
 }
-const se = new T();
-function re(s) {
+const ce = new x();
+function ue(o) {
   const e = {
     valid: !0,
     errors: [],
@@ -1411,7 +1800,7 @@ function re(s) {
     cubes: []
   };
   try {
-    const t = G(s);
+    const t = Z(o);
     if (!t)
       return e.valid = !1, e.errors.push("Invalid YAML: empty or malformed content"), e;
     if (t.cubes && Array.isArray(t.cubes))
@@ -1420,8 +1809,8 @@ function re(s) {
       e.cubes = [t];
     else
       return e.valid = !1, e.errors.push('YAML must contain either a "cubes" array or cube properties at root level'), e;
-    for (const i of e.cubes) {
-      const n = oe(i);
+    for (const s of e.cubes) {
+      const n = le(s);
       e.errors.push(...n);
     }
     e.valid = e.errors.length === 0;
@@ -1430,87 +1819,87 @@ function re(s) {
   }
   return e;
 }
-function oe(s) {
+function le(o) {
   const e = [];
-  return s.name || e.push("Cube name is required"), !s.sql && !s.sql_table && !s.sqlTable && e.push('Cube must have either "sql", "sql_table", or "sqlTable" property'), s.dimensions && s.dimensions.forEach((t, i) => {
-    t.name || e.push(`Dimension at index ${i} is missing name`), t.type || e.push(`Dimension "${t.name}" is missing type`), t.sql || e.push(`Dimension "${t.name}" is missing sql`);
-  }), s.measures && s.measures.forEach((t, i) => {
-    t.name || e.push(`Measure at index ${i} is missing name`), t.type || e.push(`Measure "${t.name}" is missing type`), t.sql || e.push(`Measure "${t.name}" is missing sql`);
-  }), s.joins && s.joins.forEach((t, i) => {
-    t.name || e.push(`Join at index ${i} is missing name`), t.relationship || e.push(`Join "${t.name}" is missing relationship`), t.sql || e.push(`Join "${t.name}" is missing sql`);
+  return o.name || e.push("Cube name is required"), !o.sql && !o.sql_table && !o.sqlTable && e.push('Cube must have either "sql", "sql_table", or "sqlTable" property'), o.dimensions && o.dimensions.forEach((t, s) => {
+    t.name || e.push(`Dimension at index ${s} is missing name`), t.type || e.push(`Dimension "${t.name}" is missing type`), t.sql || e.push(`Dimension "${t.name}" is missing sql`);
+  }), o.measures && o.measures.forEach((t, s) => {
+    t.name || e.push(`Measure at index ${s} is missing name`), t.type || e.push(`Measure "${t.name}" is missing type`), t.sql || e.push(`Measure "${t.name}" is missing sql`);
+  }), o.joins && o.joins.forEach((t, s) => {
+    t.name || e.push(`Join at index ${s} is missing name`), t.relationship || e.push(`Join "${t.name}" is missing relationship`), t.sql || e.push(`Join "${t.name}" is missing sql`);
   }), e;
 }
-function ae(s) {
+function de(o) {
   const e = {};
-  s.dimensions && s.dimensions.forEach((r) => {
-    e[r.name] = ce(r);
+  o.dimensions && o.dimensions.forEach((i) => {
+    e[i.name] = me(i);
   });
   const t = {};
-  s.measures && s.measures.forEach((r) => {
-    t[r.name] = le(r);
+  o.measures && o.measures.forEach((i) => {
+    t[i.name] = fe(i);
   });
-  const i = {};
-  s.joins && s.joins.forEach((r) => {
-    i[r.name] = fe(r);
+  const s = {};
+  o.joins && o.joins.forEach((i) => {
+    s[i.name] = be(i);
   });
   const n = {};
-  (s.pre_aggregations || s.preAggregations) && (s.pre_aggregations || s.preAggregations || []).forEach((c) => {
-    n[c.name] = de(c);
+  (o.pre_aggregations || o.preAggregations) && (o.pre_aggregations || o.preAggregations || []).forEach((c) => {
+    n[c.name] = ge(c);
   });
-  let o = s.sql;
-  !o && (s.sql_table || s.sqlTable) && (o = `SELECT * FROM ${s.sql_table || s.sqlTable}`);
-  const a = s.refresh_key || s.refreshKey;
+  let r = o.sql;
+  !r && (o.sql_table || o.sqlTable) && (r = `SELECT * FROM ${o.sql_table || o.sqlTable}`);
+  const a = o.refresh_key || o.refreshKey;
   return {
-    name: s.name,
-    title: s.title,
-    description: s.description,
-    sql: o || "",
-    sqlAlias: s.sql_alias || s.sqlAlias,
-    dataSource: s.data_source || s.dataSource,
+    name: o.name,
+    title: o.title,
+    description: o.description,
+    sql: r || "",
+    sqlAlias: o.sql_alias || o.sqlAlias,
+    dataSource: o.data_source || o.dataSource,
     refreshKey: a ? {
       every: a.every,
       sql: a.sql
     } : void 0,
     dimensions: e,
     measures: t,
-    joins: Object.keys(i).length > 0 ? i : void 0,
+    joins: Object.keys(s).length > 0 ? s : void 0,
     preAggregations: Object.keys(n).length > 0 ? n : void 0,
-    meta: s.meta
+    meta: o.meta
   };
 }
-function ce(s) {
+function me(o) {
   return {
-    name: s.name,
-    title: s.title,
-    description: s.description,
-    type: s.type,
-    sql: s.sql,
-    primaryKey: s.primary_key || s.primaryKey,
-    shown: s.shown,
-    format: s.format,
-    meta: s.meta
+    name: o.name,
+    title: o.title,
+    description: o.description,
+    type: o.type,
+    sql: o.sql,
+    primaryKey: o.primary_key || o.primaryKey,
+    shown: o.shown,
+    format: o.format,
+    meta: o.meta
   };
 }
-function le(s) {
-  var i;
-  const e = (i = s.filters) == null ? void 0 : i.map((n) => ({
+function fe(o) {
+  var s;
+  const e = (s = o.filters) == null ? void 0 : s.map((n) => ({
     sql: n.sql
-  })), t = s.rolling_window || s.rollingWindow;
+  })), t = o.rolling_window || o.rollingWindow;
   return {
-    name: s.name,
-    title: s.title,
-    description: s.description,
-    type: s.type,
-    sql: s.sql,
-    format: s.format,
-    shown: s.shown,
+    name: o.name,
+    title: o.title,
+    description: o.description,
+    type: o.type,
+    sql: o.sql,
+    format: o.format,
+    shown: o.shown,
     filters: e,
     rollingWindow: t,
-    meta: s.meta
+    meta: o.meta
   };
 }
-function ue(s) {
-  switch (s) {
+function he(o) {
+  switch (o) {
     case "one_to_one":
       return "hasOne";
     case "one_to_many":
@@ -1521,8 +1910,8 @@ function ue(s) {
       return "belongsTo";
   }
 }
-function me(s) {
-  switch (s) {
+function pe(o) {
+  switch (o) {
     case "hasOne":
       return "one_to_one";
     case "hasMany":
@@ -1533,62 +1922,62 @@ function me(s) {
       return "many_to_one";
   }
 }
-function fe(s) {
+function be(o) {
   return {
-    name: s.name,
-    type: s.type,
-    relationship: ue(s.relationship),
-    sql: s.sql
+    name: o.name,
+    type: o.type,
+    relationship: he(o.relationship),
+    sql: o.sql
   };
 }
-function de(s) {
-  const e = s.time_dimension || s.timeDimension, t = s.refresh_key || s.refreshKey;
+function ge(o) {
+  const e = o.time_dimension || o.timeDimension, t = o.refresh_key || o.refreshKey;
   return {
-    name: s.name,
-    measures: s.measures,
-    dimensions: s.dimensions,
+    name: o.name,
+    measures: o.measures,
+    dimensions: o.dimensions,
     timeDimension: e,
     refreshKey: t,
-    indexes: s.indexes
+    indexes: o.indexes
   };
 }
-async function he() {
+async function Ce() {
   try {
-    const { promises: s } = await import("fs"), e = await s.readFile("non-existent-file.txt", "utf-8").catch((t) => t.message);
+    const { promises: o } = await import("fs"), e = await o.readFile("non-existent-file.txt", "utf-8").catch((t) => t.message);
     return !(typeof e == "string" && e.includes("not implemented"));
   } catch {
     return !1;
   }
 }
-function pe(s) {
-  const e = re(s);
+function we(o) {
+  const e = ue(o);
   if (!e.valid)
     throw new Error(`Invalid YAML cube definition:
 ${e.errors.join(`
 `)}`);
-  return e.cubes.map((t) => ae(t));
+  return e.cubes.map((t) => de(t));
 }
-async function De(s) {
-  if (!await he())
+async function Te(o) {
+  if (!await Ce())
     return console.log("ℹ️ YAML file loading not supported in this environment (Cloudflare Workers/Edge Runtime). Use inline YAML strings or build-time transformations instead."), [];
   try {
-    const { promises: t } = await import("fs"), i = await t.readFile(s, "utf-8");
-    return pe(i);
+    const { promises: t } = await import("fs"), s = await t.readFile(o, "utf-8");
+    return we(s);
   } catch (t) {
-    return console.log(`ℹ️ Could not load YAML file ${s}:`, t instanceof Error ? t.message : t), [];
+    return console.log(`ℹ️ Could not load YAML file ${o}:`, t instanceof Error ? t.message : t), [];
   }
 }
-function ye(s) {
-  let e = s;
+function Se(o) {
+  let e = o;
   return e = e.replace(/\{CUBE\}/g, "${CUBE}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*\.[A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\{([A-Za-z_][A-Za-z0-9_]*)\}/g, "${$1}"), e = e.replace(/\$\$\{/g, "${"), e;
 }
-function $e(s) {
+function xe(o) {
   const e = {
-    name: s.name,
-    title: s.title,
-    description: s.description,
-    sql: typeof s.sql == "string" ? s.sql : void 0,
-    dimensions: Object.values(s.dimensions).map((t) => ({
+    name: o.name,
+    title: o.title,
+    description: o.description,
+    sql: typeof o.sql == "string" ? o.sql : void 0,
+    dimensions: Object.values(o.dimensions).map((t) => ({
       name: t.name,
       title: t.title,
       description: t.description,
@@ -1599,8 +1988,8 @@ function $e(s) {
       format: t.format,
       meta: t.meta
     })),
-    measures: Object.values(s.measures).map((t) => {
-      var i;
+    measures: Object.values(o.measures).map((t) => {
+      var s;
       return {
         name: t.name,
         title: t.title,
@@ -1609,108 +1998,108 @@ function $e(s) {
         sql: typeof t.sql == "string" ? t.sql : "",
         format: t.format,
         shown: t.shown,
-        filters: (i = t.filters) == null ? void 0 : i.map((n) => ({
+        filters: (s = t.filters) == null ? void 0 : s.map((n) => ({
           sql: typeof n.sql == "string" ? n.sql : ""
         })),
         rolling_window: t.rollingWindow,
         meta: t.meta
       };
     }),
-    joins: s.joins ? Object.values(s.joins).map((t) => ({
+    joins: o.joins ? Object.values(o.joins).map((t) => ({
       name: t.name || "",
       type: t.type,
-      relationship: me(t.relationship),
+      relationship: pe(t.relationship),
       sql: typeof t.sql == "string" ? t.sql : ""
     })) : void 0,
-    meta: s.meta
+    meta: o.meta
   };
-  return P(e, {
+  return X(e, {
     indent: 2,
     lineWidth: 120,
     minContentWidth: 40
   });
 }
-const xe = se;
-function Te(s) {
-  return new T({
-    drizzle: s.drizzle,
-    schema: s.schema
+const Fe = ce;
+function Me(o) {
+  return new x({
+    drizzle: o.drizzle,
+    schema: o.schema
   });
 }
-const Ae = {
+const Le = {
   /**
    * Create a simple query builder
    */
   query: () => {
-    const s = (e, t = [], i = [], n = [], o, a) => ({
+    const o = (e, t = [], s = [], n = [], r, a) => ({
       measures: e,
       dimensions: t,
-      filters: i,
+      filters: s,
       timeDimensions: n,
-      limit: o,
+      limit: r,
       order: a
     });
     return {
       measures: (e) => ({
         dimensions: (t = []) => ({
-          filters: (i = []) => ({
+          filters: (s = []) => ({
             timeDimensions: (n = []) => ({
-              limit: (o) => ({
-                order: (a) => s(e, t, i, n, o, a)
+              limit: (r) => ({
+                order: (a) => o(e, t, s, n, r, a)
               }),
-              order: (o) => s(e, t, i, n, void 0, o)
+              order: (r) => o(e, t, s, n, void 0, r)
             }),
             limit: (n) => ({
-              order: (o) => s(e, t, i, [], n, o)
+              order: (r) => o(e, t, s, [], n, r)
             }),
-            order: (n) => s(e, t, i, [], void 0, n)
+            order: (n) => o(e, t, s, [], void 0, n)
           }),
-          timeDimensions: (i = []) => ({
+          timeDimensions: (s = []) => ({
             filters: (n = []) => ({
-              limit: (o) => ({
-                order: (a) => s(e, t, n, i, o, a)
+              limit: (r) => ({
+                order: (a) => o(e, t, n, s, r, a)
               }),
-              order: (o) => s(e, t, n, i, void 0, o)
+              order: (r) => o(e, t, n, s, void 0, r)
             }),
             limit: (n) => ({
-              order: (o) => s(e, t, [], i, n, o)
+              order: (r) => o(e, t, [], s, n, r)
             }),
-            order: (n) => s(e, t, [], i, void 0, n)
+            order: (n) => o(e, t, [], s, void 0, n)
           }),
-          limit: (i) => ({
-            order: (n) => s(e, t, [], [], i, n)
+          limit: (s) => ({
+            order: (n) => o(e, t, [], [], s, n)
           }),
-          order: (i) => s(e, t, [], [], void 0, i)
+          order: (s) => o(e, t, [], [], void 0, s)
         }),
         filters: (t = []) => ({
-          dimensions: (i = []) => ({
+          dimensions: (s = []) => ({
             timeDimensions: (n = []) => ({
-              limit: (o) => ({
-                order: (a) => s(e, i, t, n, o, a)
+              limit: (r) => ({
+                order: (a) => o(e, s, t, n, r, a)
               }),
-              order: (o) => s(e, i, t, n, void 0, o)
+              order: (r) => o(e, s, t, n, void 0, r)
             }),
             limit: (n) => ({
-              order: (o) => s(e, i, t, [], n, o)
+              order: (r) => o(e, s, t, [], n, r)
             }),
-            order: (n) => s(e, i, t, [], void 0, n)
+            order: (n) => o(e, s, t, [], void 0, n)
           }),
-          timeDimensions: (i = []) => ({
+          timeDimensions: (s = []) => ({
             dimensions: (n = []) => ({
-              limit: (o) => ({
-                order: (a) => s(e, n, t, i, o, a)
+              limit: (r) => ({
+                order: (a) => o(e, n, t, s, r, a)
               }),
-              order: (o) => s(e, n, t, i, void 0, o)
+              order: (r) => o(e, n, t, s, void 0, r)
             }),
             limit: (n) => ({
-              order: (o) => s(e, [], t, i, n, o)
+              order: (r) => o(e, [], t, s, n, r)
             }),
-            order: (n) => s(e, [], t, i, void 0, n)
+            order: (n) => o(e, [], t, s, void 0, n)
           }),
-          limit: (i) => ({
-            order: (n) => s(e, [], t, [], i, n)
+          limit: (s) => ({
+            order: (n) => o(e, [], t, [], s, n)
           }),
-          order: (i) => s(e, [], t, [], void 0, i)
+          order: (s) => o(e, [], t, [], void 0, s)
         })
       })
     };
@@ -1719,55 +2108,55 @@ const Ae = {
    * Create filters
    */
   filters: {
-    equals: (s, e) => ({ member: s, operator: "equals", values: [e] }),
-    notEquals: (s, e) => ({ member: s, operator: "notEquals", values: [e] }),
-    contains: (s, e) => ({ member: s, operator: "contains", values: [e] }),
-    greaterThan: (s, e) => ({ member: s, operator: "gt", values: [e] }),
-    lessThan: (s, e) => ({ member: s, operator: "lt", values: [e] }),
-    inDateRange: (s, e, t) => ({
-      member: s,
+    equals: (o, e) => ({ member: o, operator: "equals", values: [e] }),
+    notEquals: (o, e) => ({ member: o, operator: "notEquals", values: [e] }),
+    contains: (o, e) => ({ member: o, operator: "contains", values: [e] }),
+    greaterThan: (o, e) => ({ member: o, operator: "gt", values: [e] }),
+    lessThan: (o, e) => ({ member: o, operator: "lt", values: [e] }),
+    inDateRange: (o, e, t) => ({
+      member: o,
       operator: "inDateRange",
       values: [e, t]
     }),
-    set: (s) => ({ member: s, operator: "set", values: [] }),
-    notSet: (s) => ({ member: s, operator: "notSet", values: [] })
+    set: (o) => ({ member: o, operator: "set", values: [] }),
+    notSet: (o) => ({ member: o, operator: "notSet", values: [] })
   },
   /**
    * Create time dimensions
    */
   timeDimensions: {
-    create: (s, e, t) => ({
-      dimension: s,
+    create: (o, e, t) => ({
+      dimension: o,
       granularity: e,
       dateRange: t
     })
   }
 };
 export {
-  x as BaseDatabaseExecutor,
-  ie as MultiCubeBuilder,
-  ee as MySQLExecutor,
-  X as PostgresExecutor,
-  $ as QueryExecutor,
-  q as SQLiteExecutor,
-  T as SemanticLayerCompiler,
-  Ae as SemanticLayerUtils,
-  ye as convertCubeReferences,
-  _ as createDatabaseExecutor,
-  Te as createDrizzleSemanticLayer,
-  ne as createMultiCubeContext,
-  te as createMySQLExecutor,
-  S as createPostgresExecutor,
+  S as BaseDatabaseExecutor,
+  ae as MultiCubeBuilder,
+  ie as MySQLExecutor,
+  ne as PostgresExecutor,
+  T as QueryExecutor,
+  se as SQLiteExecutor,
+  x as SemanticLayerCompiler,
+  Le as SemanticLayerUtils,
+  Se as convertCubeReferences,
+  L as createDatabaseExecutor,
+  Me as createDrizzleSemanticLayer,
+  oe as createMultiCubeContext,
+  re as createMySQLExecutor,
+  F as createPostgresExecutor,
   M as createSQLiteExecutor,
-  Ee as createSemanticLayer,
-  xe as defaultSemanticLayer,
-  Ne as defineCube,
-  we as defineLegacyCube,
-  pe as loadYamlCubes,
-  De as loadYamlCubesFromFile,
-  re as parseYamlCubes,
+  ye as createSemanticLayer,
+  Fe as defaultSemanticLayer,
+  Ee as defineCube,
+  $e as defineLegacyCube,
+  we as loadYamlCubes,
+  Te as loadYamlCubesFromFile,
+  ue as parseYamlCubes,
   b as resolveSqlExpression,
-  $e as semanticCubeToYaml,
-  se as semanticLayer,
-  ae as yamlCubeToSemanticCube
+  xe as semanticCubeToYaml,
+  ce as semanticLayer,
+  de as yamlCubeToSemanticCube
 };