@objectstack/service-analytics 17.3.0 → 17.4.0

package/dist/index.js

@@ -51,14 +51,36 @@ var CubeRegistry = class {
     this.cubes.clear();
   }
   /**
-   * Auto-generate a cube definition from an object schema.
+   * Auto-generate a cube definition from an object's FIELD SCHEMA, and register
+   * it under `objectName`.
    *
-   * Heuristic rules:
-   * - `number` fields → `sum`, `avg`, `min`, `max` measures
-   * - `boolean` fields → `count` measure (count where true)
-   * - All non-computed fields → dimensions
-   * - `date`/`datetime` fields → time dimensions with standard granularities
-   * - A default `count` measure is always added
+   * ⚠️ Nothing in this repository calls this — the only in-tree caller is a unit
+   * test, and every cube the platform registers itself comes from one of the
+   * three sources named on the class above (#15019). That is not the same thing
+   * as unreachable: `CubeRegistry` is exported from the package entry and
+   * `AnalyticsService.cubeRegistry` is public, so a consumer of
+   * `@objectstack/service-analytics` can call it, and what it mints does reach
+   * the wire — `getMeta()` serves the labels below as `CubeMeta` titles. Whether
+   * this published method is removed or wired up as a real cube source is #15019.
+   *
+   * Heuristic rules, measured by driving the built package (the list this
+   * replaces claimed three behaviours the code does not have — `min`/`max`
+   * measures, a `count` measure for booleans, and a computed-field exclusion):
+   * - `number` / `currency` / `percent` fields → one `sum` and one `avg` measure
+   *   each, labelled with the field's label plus ` (Sum)` / ` (Avg)`. No `min`
+   *   or `max` measure is minted.
+   * - EVERY field becomes a dimension; there is no computed-field exclusion (the
+   *   `fields` parameter carries no flag one could exclude on).
+   * - `boolean` fields become a `boolean` DIMENSION and nothing else — no count
+   *   measure is minted for them.
+   * - `date` / `datetime` fields → `time` dimensions granulated
+   *   day/week/month/quarter/year.
+   * - A default `count` measure labelled `Count` is always added.
+   *
+   * Those three defaults (`Count`, and the two composites) are English literals
+   * with no i18n hook; #14492's ruling listed the `Count` one as a site to carry
+   * the `builtinAggregate` discriminator, and it was left alone because no
+   * in-repo path reaches it.
    *
    * @param objectName - The snake_case object name (used as table/cube name)
    * @param fields - Array of field descriptors `{ name, type, label? }`
@@ -126,6 +148,38 @@ var CubeRegistry = class {
   }
 };
 
+// src/measure-result-type.ts
+import {
+  REFERENCE_VALUE_TYPES,
+  SINGLE_OPTION_TYPES,
+  STRING_VALUE_TYPES
+} from "@objectstack/spec/data";
+var MEASURE_RESULT_TYPE_TEMPORAL = "time";
+var MEASURE_RESULT_TYPE_STRING = "string";
+var TEMPORAL_SOURCE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "date",
+  "datetime",
+  "time"
+]);
+var STRING_SOURCE_FIELD_TYPES = /* @__PURE__ */ new Set([
+  // Plain strings: text/textarea/email/url/phone/password/secret, the rich
+  // bodies (markdown/html/richtext/code), and color/signature/qrcode.
+  ...STRING_VALUE_TYPES,
+  // One declared option code — select/radio.
+  ...SINGLE_OPTION_TYPES,
+  // The referenced row's id — lookup/master_detail/tree/user.
+  ...REFERENCE_VALUE_TYPES,
+  // The rendered record number, zero-padded under the default `{0000}`.
+  "autonumber"
+]);
+function measureResultType(aggregate2, sourceFieldType) {
+  if (aggregate2 !== "min" && aggregate2 !== "max") return void 0;
+  if (sourceFieldType === void 0) return void 0;
+  if (TEMPORAL_SOURCE_FIELD_TYPES.has(sourceFieldType)) return MEASURE_RESULT_TYPE_TEMPORAL;
+  if (STRING_SOURCE_FIELD_TYPES.has(sourceFieldType)) return MEASURE_RESULT_TYPE_STRING;
+  return void 0;
+}
+
 // src/strategies/filter-normalizer.ts
 import { isFilterAST, parseFilterAST, VALID_AST_OPERATORS } from "@objectstack/spec/data";
 import { StandardErrorCode } from "@objectstack/spec/api";
@@ -669,6 +723,86 @@ function asciiLowerSqlExpr(expr) {
   return `translate(${expr}, '${ASCII_UPPER_LETTERS}', '${ASCII_LOWER_LETTERS}')`;
 }
 
+// src/text-match-sql.ts
+var KNOWN_DIALECTS = /* @__PURE__ */ new Set(["sqlite", "postgres", "mysql"]);
+function normalizeSqlDialect(name) {
+  return typeof name === "string" && KNOWN_DIALECTS.has(name) ? name : "unknown";
+}
+function sqlDialectFor(ctx, objectName) {
+  const hook = ctx.sqlDialect;
+  if (typeof hook !== "function") return "unknown";
+  return normalizeSqlDialect(hook.call(ctx, objectName));
+}
+function escapeGlobPattern(value) {
+  return String(value).replace(/[*?[]/g, "[$&]");
+}
+function wrapShape(escaped, shape, wildcard) {
+  if (shape === "starts") return `${escaped}${wildcard}`;
+  if (shape === "ends") return `${wildcard}${escaped}`;
+  return `${wildcard}${escaped}${wildcard}`;
+}
+function globPattern(shape, value) {
+  return wrapShape(escapeGlobPattern(value), shape, "*");
+}
+function mysqlAsciiLowerBinarySql(expr) {
+  return asciiLowerReplaceSql(`CAST(${expr} AS BINARY)`);
+}
+function asciiLowerReplaceSql(expr) {
+  let out = expr;
+  for (let i = 0; i < ASCII_UPPER_LETTERS.length; i++) {
+    out = `REPLACE(${out}, '${ASCII_UPPER_LETTERS[i]}', '${ASCII_LOWER_LETTERS[i]}')`;
+  }
+  return out;
+}
+function textMatchPredicateSql(req) {
+  const { dialect, column, shape, value, bind: bind2 } = req;
+  const negate = req.negate === true;
+  const fold = req.fold === true;
+  if (dialect === "sqlite") {
+    const lower = (expr) => fold ? `lower(${expr})` : expr;
+    return `${lower(column)} ${negate ? "NOT GLOB" : "GLOB"} ${lower(bind2(globPattern(shape, value)))}`;
+  }
+  const keyword = negate ? "NOT LIKE" : "LIKE";
+  if (dialect === "mysql") {
+    const binary = (expr) => fold ? mysqlAsciiLowerBinarySql(expr) : `CAST(${expr} AS BINARY)`;
+    return `${binary(column)} ${keyword} ${binary(bind2(likePattern(shape, value)))} ESCAPE ${bind2(LIKE_ESCAPE_CHAR)}`;
+  }
+  const asciiLower = dialect === "postgres" ? asciiLowerSqlExpr : asciiLowerReplaceSql;
+  const folded = (expr) => fold ? asciiLower(expr) : expr;
+  return `${folded(column)} ${keyword} ${folded(bind2(likePattern(shape, value)))} ESCAPE ${bind2(LIKE_ESCAPE_CHAR)}`;
+}
+
+// src/non-text-column.ts
+import { NON_TEXT_STORED_VALUE_TYPES } from "@objectstack/spec/data";
+function textOperatorPolarity(op) {
+  switch (op) {
+    case "$contains":
+    case "$startsWith":
+    case "$endsWith":
+    case "$icontains":
+    case "$like":
+    case "$ilike":
+    case "contains":
+    case "startsWith":
+    case "endsWith":
+    case "icontains":
+      return "positive";
+    case "$notContains":
+    case "notContains":
+      return "negative";
+    default:
+      return null;
+  }
+}
+function isNonTextDeclaredType(type) {
+  return typeof type === "string" && NON_TEXT_STORED_VALUE_TYPES.has(type);
+}
+function nonTextColumnResolver(ctx, objectName) {
+  const declared = ctx.declaredFieldType;
+  if (typeof declared !== "function") return void 0;
+  return (field) => isNonTextDeclaredType(declared.call(ctx, objectName, field));
+}
+
 // src/read-scope-sql.ts
 var IDENT = /^[a-z_][a-z0-9_]*$/i;
 var READ_SCOPE_COMPILE_FAILED = "READ_SCOPE_COMPILE_FAILED";
@@ -679,6 +813,7 @@ function readScopeCompileError(message) {
   return err;
 }
 var FALSE_CLAUSE = "1 = 0";
+var TRUE_CLAUSE = "1 = 1";
 function isFilterNode(v) {
   return v !== null && typeof v === "object" && !Array.isArray(v);
 }
@@ -688,10 +823,10 @@ function quoteIdent(name, kind) {
   }
   return `"${name}"`;
 }
-function compileScopedFilterToSql(filter, alias) {
+function compileScopedFilterToSql(filter, alias, options = {}) {
   const quotedAlias = quoteIdent(alias, "alias");
   const params = [];
-  const sql = compileNode(filter, quotedAlias, params);
+  const sql = compileNode(filter, quotedAlias, params, options);
   return { sql, params };
 }
 function emptyMembershipFinding(spec, negated, path) {
@@ -741,12 +876,12 @@ function assertReadScopeCannotVacate(scope, objectName) {
     `[read-scope-sql] read scope for "${objectName}" has an empty $in under negation at ${found.path} \u2014 an empty membership matches nothing, so its negation matches every row and the read scope admits the whole table (fail-closed).`
   );
 }
-function compileSub(node, qAlias) {
+function compileSub(node, qAlias, opts) {
   const params = [];
-  const sql = compileNode(node, qAlias, params);
+  const sql = compileNode(node, qAlias, params, opts);
   return { sql, params };
 }
-function compileNode(node, qAlias, params) {
+function compileNode(node, qAlias, params, opts) {
   if (!isFilterNode(node)) {
     throw readScopeCompileError("[read-scope-sql] read scope must be a filter object (fail-closed).");
   }
@@ -760,7 +895,7 @@ function compileNode(node, qAlias, params) {
         if (key === "$or") clauses.push(FALSE_CLAUSE);
         continue;
       }
-      const compiled = value.map((child) => compileSub(child, qAlias));
+      const compiled = value.map((child) => compileSub(child, qAlias, opts));
       if (key === "$or" && compiled.some((c) => c.sql.length === 0)) continue;
       const kept = compiled.filter((c) => c.sql.length > 0);
       if (kept.length === 0) continue;
@@ -769,7 +904,7 @@ function compileNode(node, qAlias, params) {
       clauses.push(`(${kept.map((c) => c.sql).join(joiner)})`);
     } else if (key === "$not") {
       const operand = isFilterNode(value) ? nullSafeNegationOperand2(value) : value;
-      const inner = compileSub(operand, qAlias);
+      const inner = compileSub(operand, qAlias, opts);
       if (inner.sql.length === 0) {
         clauses.push(FALSE_CLAUSE);
       } else {
@@ -779,12 +914,12 @@ function compileNode(node, qAlias, params) {
     } else if (key.startsWith("$")) {
       throw readScopeCompileError(`[read-scope-sql] unsupported top-level operator "${key}" (fail-closed).`);
     } else {
-      clauses.push(compileField(key, value, qAlias, params));
+      clauses.push(compileField(key, value, qAlias, params, opts));
     }
   }
   return clauses.join(" AND ");
 }
-function compileField(field, value, qAlias, params) {
+function compileField(field, value, qAlias, params, opts) {
   const col = `${qAlias}.${quoteIdent(field, "field")}`;
   assertDefinedComparands2(field, value);
   assertBooleanFlagComparands(field, value);
@@ -804,7 +939,7 @@ function compileField(field, value, qAlias, params) {
   }
   const parts = [];
   for (const op of keys) {
-    parts.push(compileOperator(col, op, ops[op], field, params));
+    parts.push(compileOperator(col, op, ops[op], field, params, opts));
   }
   return parts.length === 1 ? parts[0] : `(${parts.join(" AND ")})`;
 }
@@ -812,8 +947,20 @@ function bind(params, v) {
   params.push(v);
   return "?";
 }
-function bindLike(params, pattern) {
-  return `${bind(params, pattern)} ESCAPE ${bind(params, LIKE_ESCAPE_CHAR)}`;
+function textMatch(col, shape, val, negate, params, opts, fold = false) {
+  return textMatchPredicateSql({
+    dialect: normalizeSqlDialect(opts.dialect),
+    column: col,
+    shape,
+    value: val,
+    negate,
+    fold,
+    bind: (v) => bind(params, v)
+  });
+}
+function textOverNonTextColumn(op, field, opts) {
+  if (!opts.nonTextColumn || !opts.nonTextColumn(field)) return null;
+  return textOperatorPolarity(op) === "negative" ? TRUE_CLAUSE : FALSE_CLAUSE;
 }
 function nullSafeNegative(col, test) {
   return `(${col} IS NULL OR ${test})`;
@@ -878,7 +1025,7 @@ function assertNoFieldReferenceComparand2(field, spec) {
     });
   }
 }
-function compileOperator(col, op, val, field, params) {
+function compileOperator(col, op, val, field, params, opts) {
   switch (op) {
     case "$eq":
       return val === null ? `${col} IS NULL` : `${col} = ${bind(params, val)}`;
@@ -912,12 +1059,19 @@ function compileOperator(col, op, val, field, params) {
       return `${col} BETWEEN ${bind(params, val[0])} AND ${bind(params, val[1])}`;
     }
     // [#5567] The comparand is a LITERAL, so it is escaped and the escape
-    // character is bound with it. See {@link bindLike}.
+    // character is bound with it. See {@link textMatch}.
     // [#5234] …and it must be a value `String()` can render, which is asserted
-    // BEFORE `likePattern` sees it — see {@link assertRenderableText}.
+    // BEFORE a pattern is built from it — see {@link assertRenderableText}.
+    // [#14079] Every text arm asks {@link textOverNonTextColumn} AFTER its
+    // comparand gate and BEFORE it binds: a comparand the contract refuses is
+    // still refused, and a column whose stored value is never text gets the
+    // contract's constant instead of a match over a number.
+    // [#15684] …and the four case-EXACT arms take their construct from the
+    // DIALECT ({@link textMatch}): a plain `LIKE` folds ASCII case on SQLite,
+    // so this scope ADMITTED rows the policy excludes — over-reach (#3948).
     case "$contains":
       assertRenderableText(op, field, val);
-      return `${col} LIKE ${bindLike(params, likePattern("contains", val))}`;
+      return textOverNonTextColumn(op, field, opts) ?? textMatch(col, "contains", val, false, params, opts);
     /**
      * [#6520] `$icontains` on the READ-SCOPE lowering — the one compiler in this
      * package where a wrong answer is an ADR-0021 scope over-reach rather than a
@@ -933,23 +1087,39 @@ function compileOperator(col, op, val, field, params) {
      * the rows already lower-case — and on a read scope that is a row set the
      * policy author never wrote, in the narrowing direction here but in the
      * WIDENING direction under a `$not`.
+     *
+     * [#15780] …and WHICH fold is the DIALECT's answer, exactly as the keyword
+     * is for the case-exact arms. This line used to spell its own binds and
+     * emit `translate()` unconditionally, on the reasoning that a
+     * case-INSENSITIVE operator never wants the per-dialect case-EXACT
+     * construct. The first half of that was right and the second half hid the
+     * defect: `translate()` is Postgres/Oracle, so on a SQLite datasource this
+     * read scope compiled to a statement the engine could not PARSE — an RLS
+     * policy that cannot be evaluated at all. It goes through
+     * {@link textMatch} now with `fold` set, which keeps `translate()` on
+     * Postgres, emits `lower(col) GLOB lower(?)` on SQLite, the nested-
+     * `REPLACE` binary fold on MySQL and — [#16028] — the same `REPLACE` chain
+     * without the cast on the `unknown` residue, because a datasource whose
+     * dialect nothing answered can BE SQLite and `translate()` failed to parse
+     * there just as loudly through this compiler as through the other two. The
+     * `ESCAPE`
+     * binding is still never folded — the construct table owns that, and the
+     * SQLite arm has no `ESCAPE` clause to bind at all.
      */
-    case "$icontains": {
+    case "$icontains":
       assertRenderableText(op, field, val);
-      const patternRef = asciiLowerSqlExpr(bind(params, likePattern("contains", val)));
-      return `${asciiLowerSqlExpr(col)} LIKE ${patternRef} ESCAPE ${bind(params, LIKE_ESCAPE_CHAR)}`;
-    }
+      return textOverNonTextColumn(op, field, opts) ?? textMatch(col, "contains", val, false, params, opts, true);
     // [#5298] NULL-safe: `NOT LIKE` is UNKNOWN for a NULL column, and "does not
     // contain" is true of a value that is not there.
     case "$notContains":
       assertRenderableText(op, field, val);
-      return nullSafeNegative(col, `${col} NOT LIKE ${bindLike(params, likePattern("contains", val))}`);
+      return textOverNonTextColumn(op, field, opts) ?? nullSafeNegative(col, textMatch(col, "contains", val, true, params, opts));
     case "$startsWith":
       assertRenderableText(op, field, val);
-      return `${col} LIKE ${bindLike(params, likePattern("starts", val))}`;
+      return textOverNonTextColumn(op, field, opts) ?? textMatch(col, "starts", val, false, params, opts);
     case "$endsWith":
       assertRenderableText(op, field, val);
-      return `${col} LIKE ${bindLike(params, likePattern("ends", val))}`;
+      return textOverNonTextColumn(op, field, opts) ?? textMatch(col, "ends", val, false, params, opts);
     // [#6387] `val` is a boolean here — {@link assertBooleanFlagComparands}
     // refused anything else at {@link compileField}, before this emitter runs.
     // So `=== true` is an exhaustive TWO-WAY choice over the declared domain,
@@ -1380,7 +1550,10 @@ var NativeSQLStrategy = class {
     if (typeof ctx.getReadScope !== "function") return;
     const filter = ctx.getReadScope(objectName);
     if (filter === void 0 || filter === null) return;
-    const { sql, params: scopeParams } = compileScopedFilterToSql(filter, alias);
+    const { sql, params: scopeParams } = compileScopedFilterToSql(filter, alias, {
+      nonTextColumn: nonTextColumnResolver(ctx, objectName),
+      dialect: sqlDialectFor(ctx, objectName)
+    });
     assertReadScopeCannotVacate(filter, objectName);
     if (!sql) return;
     let i = 0;
@@ -1658,12 +1831,16 @@ var NativeSQLStrategy = class {
       gte: ">=",
       lt: "<",
       lte: "<=",
+      // [#15684 / #15780] For every text operator these entries are the
+      // OPERATOR GATE, not the emitted keyword: `text-match-sql.ts` picks
+      // `LIKE` or `GLOB` per dialect below. ⛔ Reading these five as the
+      // emitted SQL is exactly the mistake #15780 was — `$icontains` was the
+      // last row still emitting the keyword written here, together with a
+      // `translate()` fold SQLite cannot parse.
       contains: "LIKE",
       notContains: "NOT LIKE",
       startsWith: "LIKE",
       endsWith: "LIKE",
-      // [#6520] `$icontains` — `LIKE` like its neighbours; what separates it is
-      // the ASCII fold applied below, not the keyword.
       icontains: "LIKE"
     };
     const likeShape = {
@@ -1689,13 +1866,22 @@ var NativeSQLStrategy = class {
     if (!sqlOp || !values || values.length === 0) return null;
     const shape = likeShape[operator];
     if (shape) {
-      params.push(likePattern(shape, values[0]));
-      const patternRef = `$${params.length}`;
-      params.push(LIKE_ESCAPE_CHAR);
-      if (operator === "icontains") {
-        return `${asciiLowerSqlExpr(rawCol)} ${sqlOp} ${asciiLowerSqlExpr(patternRef)} ESCAPE $${params.length}`;
+      const polarity = textOperatorPolarity(operator);
+      if (polarity && nonTextColumnResolver(ctx, target.object)?.(target.field)) {
+        return polarity === "negative" ? SQL_CONST_TRUE : SQL_CONST_FALSE;
       }
-      return `${rawCol} ${sqlOp} ${patternRef} ESCAPE $${params.length}`;
+      return textMatchPredicateSql({
+        dialect: sqlDialectFor(ctx, target.object),
+        column: rawCol,
+        shape,
+        value: values[0],
+        negate: operator === "notContains",
+        fold: operator === "icontains",
+        bind: (v) => {
+          params.push(v);
+          return `$${params.length}`;
+        }
+      });
     }
     if (operator === "lte") {
       const nextDay = nextUtcCalendarDay(values[0]);
@@ -1796,15 +1982,25 @@ var SCALAR_SQL_OPS = {
   lte: "<="
 };
 var LIKE_SQL_OPS = {
-  contains: { sql: "LIKE", shape: "contains" },
-  notContains: { sql: "NOT LIKE", shape: "contains" },
-  startsWith: { sql: "LIKE", shape: "starts" },
-  endsWith: { sql: "LIKE", shape: "ends" },
-  // [#6520] `$icontains`: the same escaped pattern and bound `ESCAPE` as its
-  // four case-EXACT neighbours, with `fold` adding the ASCII-only case fold to
-  // both sides of the comparison. The flag is on this row alone — the family
-  // above it is case-sensitive by ruling (#4706 Q2 = A).
-  icontains: { sql: "LIKE", shape: "contains", fold: true }
+  // [#15684 / #15780] This table carries NO keyword, deliberately. Every row's
+  // construct comes from the DIALECT (`text-match-sql.ts`): `GLOB` on SQLite,
+  // `LIKE` over `CAST(… AS BINARY)` on MySQL, plain `LIKE` on Postgres, since a
+  // plain `LIKE` is case-exact on Postgres alone. #15684 kept a `sql` field
+  // here for the FOLDING row, which was the last row still emitting a keyword
+  // written locally — together with the `translate()` fold that could not parse
+  // on SQLite. #15780 moved that row onto the table too, so the field had no
+  // reader left, and a dead field named `sql` sitting beside a compiler is an
+  // invitation to read it as the emitted keyword.
+  //
+  // What survives here is only what the construct table cannot derive from the
+  // operator name: which POLARITY the row is (`negate`) and whether it FOLDS
+  // (`fold`), each spelled once. `fold` is on `icontains` ALONE — the four
+  // above it are case-SENSITIVE by ruling (#4706 Q2 = A).
+  contains: { shape: "contains" },
+  notContains: { shape: "contains", negate: true },
+  startsWith: { shape: "starts" },
+  endsWith: { shape: "ends" },
+  icontains: { shape: "contains", fold: true }
 };
 var ObjectQLStrategy = class {
   constructor() {
@@ -1974,7 +2170,7 @@ var ObjectQLStrategy = class {
       for (const m of query.measures) {
         const { field, method } = this.resolveMeasureAggregation(cube, m);
         const measureFilter = datasetScope?.measureFilters?.[m];
-        const predicate = measureFilter ? this.renderFilterNodeSql(normalizeAnalyticsFilterTree({ where: measureFilter }), cube, params) : null;
+        const predicate = measureFilter ? this.renderFilterNodeSql(normalizeAnalyticsFilterTree({ where: measureFilter }), cube, params, ctx) : null;
         const aggSql = predicate ? this.conditionalAggregateSql(method, field, predicate) : method === "count" ? "COUNT(*)" : method === "count_distinct" ? `COUNT(DISTINCT ${field})` : `${method.toUpperCase()}(${field})`;
         selectParts.push(`${aggSql} AS "${m}"`);
       }
@@ -1983,14 +2179,16 @@ var ObjectQLStrategy = class {
     const filterClause = this.renderFilterNodeSql(
       normalizeAnalyticsFilterTree(query),
       cube,
-      params
+      params,
+      ctx
     );
     if (filterClause) whereParts.push(filterClause);
     if (datasetScope?.filter) {
       const scopeSql = this.renderFilterNodeSql(
         normalizeAnalyticsFilterTree({ where: datasetScope.filter }),
         cube,
-        params
+        params,
+        ctx
       );
       if (scopeSql) whereParts.push(scopeSql);
     }
@@ -2003,7 +2201,10 @@ var ObjectQLStrategy = class {
     }
     const scope = ctx.getReadScope?.(tableName);
     if (scope != null) {
-      const { sql: scopeSql, params: scopeParams } = compileScopedFilterToSql(scope, tableName);
+      const { sql: scopeSql, params: scopeParams } = compileScopedFilterToSql(scope, tableName, {
+        nonTextColumn: nonTextColumnResolver(ctx, tableName),
+        dialect: sqlDialectFor(ctx, tableName)
+      });
       assertReadScopeCannotVacate(scope, tableName);
       if (scopeSql) {
         let i = 0;
@@ -2437,7 +2638,7 @@ var ObjectQLStrategy = class {
    * not render that operator": #5333 was exactly that conflation, and an
    * unrenderable operator now THROWS (see the exit below).
    */
-  buildFilterClauseSql(col, operator, values, params) {
+  buildFilterClauseSql(col, operator, values, params, target, ctx) {
     if (operator === "set") return `${col} IS NOT NULL`;
     if (operator === "notSet") return `${col} IS NULL`;
     if (!values || values.length === 0) return null;
@@ -2450,12 +2651,22 @@ var ObjectQLStrategy = class {
     }
     const like = LIKE_SQL_OPS[operator];
     if (like) {
-      params.push(likePattern(like.shape, values[0]));
-      const patternRef = `$${params.length}`;
-      params.push(LIKE_ESCAPE_CHAR);
-      const lhs = like.fold ? asciiLowerSqlExpr(col) : col;
-      const rhs = like.fold ? asciiLowerSqlExpr(patternRef) : patternRef;
-      return `${lhs} ${like.sql} ${rhs} ESCAPE $${params.length}`;
+      const polarity = textOperatorPolarity(operator);
+      if (polarity && target && ctx && nonTextColumnResolver(ctx, target.object)?.(target.field)) {
+        return polarity === "negative" ? SQL_CONST_TRUE : SQL_CONST_FALSE;
+      }
+      return textMatchPredicateSql({
+        dialect: target && ctx ? sqlDialectFor(ctx, target.object) : "unknown",
+        column: col,
+        shape: like.shape,
+        value: values[0],
+        negate: like.negate === true,
+        fold: like.fold === true,
+        bind: (v) => {
+          params.push(v);
+          return `$${params.length}`;
+        }
+      });
     }
     const op = SCALAR_SQL_OPS[operator];
     if (!op) {
@@ -2494,6 +2705,29 @@ var ObjectQLStrategy = class {
     }
     return void 0;
   }
+  /**
+   * [#14079] The (object, field) a filter member binds against — the echo's
+   * copy of `NativeSQLStrategy.resolveStorageTarget`, kept beside the
+   * `LIKE_SQL_OPS` table for the same reason that table is a copy: this file
+   * renders a description of the statement THAT compiler produces, and the
+   * declared-type test both apply is keyed by object and field. A dotted
+   * `sql` is a relationship path (ADR-0071): every segment but the last is a
+   * hop whose join alias is the dot-to-`__` spelling the dataset compiler keys
+   * `cube.joins` by, the last is the column.
+   */
+  resolveStorageTarget(cube, member, baseObject) {
+    const dim = this.lookupMember(cube, member, "dimension");
+    const measure = dim ? void 0 : this.lookupMember(cube, member, "measure");
+    const rawSql = dim?.sql ?? measure?.sql ?? (member.includes(".") ? member.split(".").slice(1).join(".") : member);
+    if (rawSql.includes(".")) {
+      const segments = rawSql.split(".");
+      const field = segments[segments.length - 1];
+      const relPath = segments.slice(0, -1).join(".");
+      const object = cube.joins?.[relPath.replace(/\./g, "__")]?.name ?? relPath;
+      return { object, field };
+    }
+    return { object: baseObject, field: rawSql.replace(/^\$/, "") };
+  }
   resolveFieldName(cube, member, kind) {
     if (kind === "dimension" || kind === "any") {
       const dim = this.lookupMember(cube, member, "dimension");
@@ -2633,7 +2867,7 @@ var ObjectQLStrategy = class {
    * exactly — including the invariant that a `null` return leaves `params`
    * untouched, so no comparand is left with no placeholder to consume it.
    */
-  renderFilterNodeSql(node, cube, params) {
+  renderFilterNodeSql(node, cube, params, ctx) {
     if (!node) return null;
     if (node.kind === "const") {
       return node.value ? SQL_CONST_TRUE : SQL_CONST_FALSE;
@@ -2643,17 +2877,23 @@ var ObjectQLStrategy = class {
         this.resolveFieldName(cube, node.member, "any"),
         node.operator,
         node.values,
-        params
+        params,
+        // [#14079] The (object, field) this member binds against, resolved the
+        // way `NativeSQLStrategy.resolveStorageTarget` resolves it, so the echo
+        // asks the declared-type hook the same question the executed statement
+        // asked and prints the same constant for a non-text column.
+        this.resolveStorageTarget(cube, node.member, this.extractObjectName(cube)),
+        ctx
       );
     }
     if (node.kind === "not") {
-      const inner = this.renderFilterNodeSql(node.child, cube, params);
+      const inner = this.renderFilterNodeSql(node.child, cube, params, ctx);
       return inner ? `NOT (${inner})` : SQL_CONST_FALSE;
     }
     const paramBase = params.length;
     const parts = [];
     for (const child of node.children) {
-      const clause = this.renderFilterNodeSql(child, cube, params);
+      const clause = this.renderFilterNodeSql(child, cube, params, ctx);
       if (clause === null) {
         if (node.kind !== "or") continue;
         params.length = paramBase;
@@ -3867,25 +4107,55 @@ function bucketDate(value, granularity, timezone) {
       return `${y}-${m}-${day}`;
   }
 }
-function aggregate(rows, metricType, field) {
-  if (metricType === "count" || field === "*") {
-    if (metricType === "countDistinct") {
-      return new Set(rows.map((r) => r[field]).filter((v) => v != null)).size;
+function numericOperand(v) {
+  if (typeof v === "number") return Number.isFinite(v) ? v : null;
+  if (typeof v === "string" && v.trim() !== "") {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : null;
+  }
+  return null;
+}
+function compareOperands(a, b) {
+  const an = numericOperand(a);
+  const bn = numericOperand(b);
+  if (an !== null && bn !== null) return an - bn;
+  return compare(a, b);
+}
+function extremumOf(rows, field, kind) {
+  let winner;
+  let seen = false;
+  for (const r of rows) {
+    const v = r[field];
+    if (v == null) continue;
+    if (!seen) {
+      winner = v;
+      seen = true;
+      continue;
     }
-    return rows.length;
+    const c = compareOperands(v, winner);
+    if (kind === "min" ? c < 0 : c > 0) winner = v;
   }
+  return seen ? winner : null;
+}
+function aggregate(rows, metricType, field) {
+  if (metricType === "count" || field === "*") return rows.length;
   const nums = rows.map((r) => Number(r[field])).filter((n) => Number.isFinite(n));
   switch (metricType) {
-    case "countDistinct":
+    // The spec's spelling (`AggregationFunction`), which is what the compiler
+    // copies through. It used to be spelled `countDistinct` here — a word no
+    // producer mints — so the arm was UNREACHABLE and the measure fell to the
+    // numeric `default` below, answering a sum of coerced values (or a row
+    // count) under the author's `count_distinct` name.
+    case "count_distinct":
       return new Set(rows.map((r) => r[field]).filter((v) => v != null)).size;
     case "sum":
       return nums.reduce((a, b) => a + b, 0);
     case "avg":
       return nums.length ? nums.reduce((a, b) => a + b, 0) / nums.length : 0;
     case "min":
-      return nums.length ? Math.min(...nums) : 0;
+      return extremumOf(rows, field, "min");
     case "max":
-      return nums.length ? Math.max(...nums) : 0;
+      return extremumOf(rows, field, "max");
     default:
       return nums.length ? nums.reduce((a, b) => a + b, 0) : rows.length;
   }
@@ -3946,7 +4216,19 @@ function evaluateAnalyticsQueryOverRows(query, cube, rows) {
   return {
     rows: limited,
     fields: [
-      ...dimensions.map((d) => ({ name: d, type: "string" })),
+      // A dimension column is described by the CUBE dimension's own type — the
+      // same expression `NativeSQLStrategy.buildFieldMeta` and its ObjectQL
+      // sibling use (`d?.type || 'string'`), so a `date` dataset dimension is
+      // `'time'` here exactly as it is on the live path. Minting `'string'` for
+      // every dimension made the same column two different things depending
+      // only on whether a pending seed draft existed (#16203 (b)).
+      ...dimensions.map((d) => ({ name: d, type: String(cube.dimensions?.[d]?.type || "string") })),
+      // ⛔ A MEASURE column keeps the `'number'` every producer in the platform
+      // mints for it, live faces included. Correcting it is one rule owned by
+      // `measureResultType` (#15768/#16101) and applied at the ADR-0021
+      // descriptor pass; a second copy of it here would be two implementations
+      // free to drift, over a question this producer cannot answer anyway (it
+      // has the cube, not the source object's declared field types).
       ...query.measures.map((m) => ({ name: m, type: "number" }))
     ]
   };
@@ -4079,7 +4361,17 @@ var AnalyticsService = class {
       },
       coerceTemporalFilterValue: config.coerceTemporalFilterValue,
       coerceTemporalFilterColumn: config.coerceTemporalFilterColumn,
-      isExternalObject: config.isExternalObject
+      isExternalObject: config.isExternalObject,
+      // [#14079] The declared field type, read off the same `sourceFieldMeta`
+      // hook the display chains use — so the three SQL compilers can give a
+      // text operator over a numeric or boolean column the contract's answer
+      // at compile time. A host that wired no hook answers `undefined`, and
+      // the compilers keep the behaviour they had.
+      declaredFieldType: (object, field) => config.sourceFieldMeta?.(object, field)?.type,
+      // [#15684] The dialect that will run the compiled statement, so the
+      // case-EXACT text family picks a construct that IS case-exact there.
+      // Same tiering as the hook above: `undefined` keeps today's `LIKE`.
+      sqlDialect: (object) => config.sqlDialect?.(object)
     };
     const builtIn = [
       new NativeSQLStrategy(),
@@ -4295,10 +4587,10 @@ var AnalyticsService = class {
           query: async (q) => evaluateAnalyticsQueryOverRows(q, compiled.cube, seedRows)
         };
         const previewResult = await new DatasetExecutor(previewService).execute(compiled, selection, context);
+        this.enrichResultColumns(previewResult, dataset, selection, context);
         return previewResult;
       }
     }
-    const requestLocale = context?.locale;
     const provider = this.readScopeProvider;
     const resolveScope = provider ? (targetObject) => provider(targetObject, context) : void 0;
     const labelDeps = this.labelResolver ? withLabelFetchCache(this.labelResolver) : void 0;
@@ -4334,7 +4626,7 @@ var AnalyticsService = class {
       }
       throw err;
     }
-    const selectedDims = (selection.dimensions ?? []).map((name) => dataset.dimensions?.find((d) => d.name === name)).filter((d) => !!d);
+    const selectedDims = this.selectedDimensions(dataset, selection);
     const drillDims = selectedDims.filter((d) => !!d.field && d.type !== "date");
     if (drillDims.length && result.rows.length) {
       result.object = dataset.object;
@@ -4403,6 +4695,48 @@ var AnalyticsService = class {
         }
       }
     }
+    this.enrichResultColumns(result, dataset, selection, context);
+    return result;
+  }
+  /**
+   * The dataset dimensions this selection GROUPED THE GRID BY, resolved against
+   * the dataset definition. Shared by drill metadata, row-value label
+   * resolution and — through {@link enrichResultColumns} — the dimension column
+   * headers, so all three answer "which dimensions" the same way.
+   */
+  selectedDimensions(dataset, selection) {
+    return (selection.dimensions ?? []).map((name) => dataset.dimensions?.find((d) => d.name === name)).filter((d) => !!d);
+  }
+  /**
+   * ADR-0021 — describe the result's COLUMNS from the dataset's own authored
+   * definition: a measure's `label` / `format` / `currency` / `percentScale` /
+   * `builtinAggregate` and the `type` its aggregate really returns, then a
+   * dimension column's header `label`.
+   *
+   * **Every key here is read off the DATASET** (the authored measure or
+   * dimension) **and `sourceFieldMeta`** (the source object's declared field
+   * metadata). Not one is read off `result.rows`. That is what makes this one
+   * seam serve both paths that produce a dataset response — the live engine
+   * query and the ADR-0037 P3 draft-data preview — and it is why #16097 was a
+   * defect rather than a deliberate omission: the preview branch returns ~250
+   * lines before this ran, so a response over drafted seed rows carried none of
+   * these keys and a renderer fell back to humanizing the raw measure name and
+   * guessing a percent scale from magnitude — the exact failures #5537,
+   * objectui#3136 and #14492 each closed on the live path.
+   *
+   * Extracted rather than copied onto the second path, for the reason the
+   * `type` correction below already gives for living here at all: this is ONE
+   * rule holding both halves of the question, and a per-path copy would be two
+   * implementations of it, free to drift.
+   *
+   * ⛔ Not here, and deliberately: dimension VALUE label resolution
+   * ({@link resolveDimensionLabels}), which rewrites the grouped value in each
+   * ROW. That reads the rows, it is the one enrichment a seed-draft row set can
+   * make unnecessary, and the preview path skips it on purpose — see the note
+   * at that early return.
+   */
+  enrichResultColumns(result, dataset, selection, context) {
+    const requestLocale = context?.locale;
     if (result.fields?.length && dataset.measures?.length) {
       const measureByName = new Map(dataset.measures.map((m) => [m.name, m]));
       for (const f of result.fields) {
@@ -4427,9 +4761,11 @@ var AnalyticsService = class {
         if (f.percentScale == null) {
           f.percentScale = m.derived?.op === "ratio" ? "fraction" : percentScaleOf(meta);
         }
+        const resultType = measureResultType(m.aggregate, meta?.type);
+        if (resultType) f.type = resultType;
       }
     }
-    const describableDims = [...selectedDims];
+    const describableDims = [...this.selectedDimensions(dataset, selection)];
     for (const t of selection.timeDimensions ?? []) {
       if (describableDims.some((d2) => d2.name === t.dimension)) continue;
       const d = dataset.dimensions?.find((x) => x.name === t.dimension);
@@ -4446,7 +4782,6 @@ var AnalyticsService = class {
         if (label !== void 0) f.label = label;
       }
     }
-    return result;
   }
   /**
    * Get cube metadata for discovery.
@@ -5280,6 +5615,16 @@ var AnalyticsServicePlugin = class {
       }
       return columnSql;
     };
+    const sqlDialect = (objectName) => {
+      try {
+        const svc = ctx.getService("data");
+        const driver = svc?.getDriverForObject?.(objectName);
+        const named = driver?.dialectName;
+        return typeof named === "string" ? named : void 0;
+      } catch {
+        return void 0;
+      }
+    };
     const config = {
       cubes: this.options.cubes,
       logger: ctx.logger,
@@ -5321,6 +5666,8 @@ var AnalyticsServicePlugin = class {
       // prevent: it drifts by one step, silently, and the drift only surfaces as
       // an error message pointing at the wrong database.
       getObjectDatasource: (objectName) => dataEngine()?.resolveEffectiveDatasource?.(objectName),
+      // [#15684] The executing driver's own dialect — see `sqlDialect` above.
+      sqlDialect,
       // ADR-0062 D6 — a federated object carries an `external` block (ADR-0015).
       // Reported so NativeSQLStrategy declines it (its hand-compiled FROM would
       // hit the wrong physical table) and the driver-correct ObjectQL path runs.