@minnowdb/core 0.7.0 → 0.7.1

package/dist/engine/sql-semantics.js

@@ -1,700 +1,633 @@
 import { dateMilliseconds } from "../date-value.js";
 import { assertWellFormedString } from "../block-format/unicode.js";
-import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS, } from "./cache-limits.js";
-import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue, } from "./sql-domains.js";
-/**
- * SQL value semantics shared by the row and vector executors.
- *
- * Keep comparison, equality-key, scalar, and pattern behavior here so an execution-path
- * optimization cannot silently change query results.
- */
+import { MAX_SQL_NESTING_DEPTH, MAX_SQL_PATTERN_CHARACTERS, MAX_SQL_PATTERN_MATCH_STEPS } from "./cache-limits.js";
+import { collatedDomainCompare, enumDomainCompare, exactNumericCompare, externalSqlDomainValue, externalSqlTextValue, intervalDomainCompare, isDateDomainValue, isSqlDomainValue } from "./sql-domains.js";
 const SQL_TIMESTAMP_TEXT = /^(\d{4}-\d{2}-\d{2})(?:[ T](\d{2}:\d{2}(?::\d{2}(?:\.\d{1,3})?)?))?(Z|[+-]\d{2}:?\d{2})?$/;
-/**
- * The standard's datetime text — `2026-01-02`, `2026-01-02 03:04:05`, `2026-01-02T03:04:05.250Z`,
- * an optional zone offset — read as an instant. A zoneless spelling is UTC, the reading every
- * datetime in a Minnow database has; `undefined` for text in any other shape.
- */
-export function parseSqlTimestampText(text) {
-    const match = SQL_TIMESTAMP_TEXT.exec(text.trim());
-    if (match === null)
-        return undefined;
-    const [, day, time = "00:00:00", zone = "Z"] = match;
-    const seconds = time.length === 5 ? `${time}:00` : time;
-    const date = new Date(`${String(day)}T${seconds}${zone === "Z" ? "Z" : zone}`);
-    return Number.isFinite(dateMilliseconds(date)) ? date : undefined;
+function parseSqlTimestampText(text) {
+  const match = SQL_TIMESTAMP_TEXT.exec(text.trim());
+  if (match === null)
+    return void 0;
+  const [, day, time = "00:00:00", zone = "Z"] = match;
+  const seconds = time.length === 5 ? `${time}:00` : time;
+  const date = /* @__PURE__ */ new Date(`${String(day)}T${seconds}${zone === "Z" ? "Z" : zone}`);
+  return Number.isFinite(dateMilliseconds(date)) ? date : void 0;
 }
-/**
- * PostgreSQL reads an untyped string constant beside a typed value in that value's type:
- * `joined >= '2026-01-01'`, `id = '5'`, `active = 't'`. Catalog-backed plans coerce such literals
- * before execution; this runtime reading covers the schema-less row executor and anything the
- * plan rewrite could not see. Text that does not parse in the other side's type keeps the
- * comparable-types error below, so a genuine mismatch still fails.
- */
-export function coercedComparable(text, other) {
-    if (other instanceof Date || isDateDomainValue(other))
-        return parseSqlTimestampText(text) ?? text;
-    if (typeof other === "number") {
-        const trimmed = text.trim();
-        if (trimmed === "")
-            return text;
-        const parsed = Number(trimmed);
-        return Number.isFinite(parsed) ? parsed : text;
-    }
-    if (typeof other === "boolean") {
-        const lowered = text.trim().toLowerCase();
-        if (lowered === "t" || lowered === "true" || lowered === "1")
-            return true;
-        if (lowered === "f" || lowered === "false" || lowered === "0")
-            return false;
-    }
-    return text;
+function coercedComparable(text, other) {
+  if (other instanceof Date || isDateDomainValue(other))
+    return parseSqlTimestampText(text) ?? text;
+  if (typeof other === "number") {
+    const trimmed = text.trim();
+    if (trimmed === "")
+      return text;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) ? parsed : text;
+  }
+  if (typeof other === "boolean") {
+    const lowered = text.trim().toLowerCase();
+    if (lowered === "t" || lowered === "true" || lowered === "1")
+      return true;
+    if (lowered === "f" || lowered === "false" || lowered === "0")
+      return false;
+  }
+  return text;
 }
-/**
- * Applies the untyped-literal reading to a comparison's two operands: a plain string beside a
- * typed value (datetime, DATE, number, boolean) is read in that value's type when it parses.
- * Both executors call this before their own comparisons, so the reading is one decision.
- */
-export function coerceComparisonOperands(left, right) {
-    const plainText = (value) => typeof value === "string" && !isSqlDomainValue(value);
-    const typed = (value) => typeof value !== "string" || isDateDomainValue(value);
-    if (plainText(left) && typed(right))
-        return [coercedComparable(left, right), right];
-    if (plainText(right) && typed(left))
-        return [left, coercedComparable(right, left)];
-    return [left, right];
+function coerceComparisonOperands(left, right) {
+  const plainText = (value) => typeof value === "string" && !isSqlDomainValue(value);
+  const typed = (value) => typeof value !== "string" || isDateDomainValue(value);
+  if (plainText(left) && typed(right))
+    return [coercedComparable(left, right), right];
+  if (plainText(right) && typed(left))
+    return [left, coercedComparable(right, left)];
+  return [left, right];
 }
-/**
- * Deterministic SQL ordering. Strings use Unicode codepoint order rather than host locale data,
- * and signed zero compares equal because SQL numeric equality does not distinguish it.
- */
-export function compareSqlValues(left, right) {
-    // Plain numbers and untagged strings are the bulk of every comparison; settle them before the
-    // domain checks. NaN falls through so its placement stays with the general ordering below, and
-    // a string starting with NUL may carry a domain tag, so only tag-free strings take the short path.
-    if (typeof left === "number" && typeof right === "number") {
-        if (left < right)
-            return -1;
-        if (left > right)
-            return 1;
-        if (left === right)
-            return 0;
-    }
-    else if (typeof left === "string" &&
-        typeof right === "string" &&
-        left.charCodeAt(0) !== 0 &&
-        right.charCodeAt(0) !== 0) {
-        return compareSqlStrings(left, right);
-    }
-    const [coercedLeft, coercedRight] = coerceComparisonOperands(left, right);
-    // Object.is, not !==: NaN would otherwise look changed on every pass and recurse forever.
-    if (!Object.is(coercedLeft, left) || !Object.is(coercedRight, right)) {
-        return compareSqlValues(coercedLeft, coercedRight);
-    }
-    const plainLeft = externalSqlTextValue(left);
-    const plainRight = externalSqlTextValue(right);
-    if ((typeof left === "string" && plainLeft !== left) ||
-        (typeof right === "string" && plainRight !== right)) {
-        if (typeof plainLeft !== "string" || typeof plainRight !== "string") {
-            throw new TypeError("Values must have comparable SQL types");
-        }
-        return compareSqlStrings(plainLeft, plainRight);
-    }
-    const collated = collatedDomainCompare(left, right);
-    if (collated !== undefined)
-        return collated;
-    const interval = intervalDomainCompare(left, right);
-    if (interval !== undefined)
-        return interval;
-    const enumOrder = enumDomainCompare(left, right);
-    if (enumOrder !== undefined)
-        return enumOrder;
-    const exact = exactNumericCompare(left, right);
-    if (exact !== undefined)
-        return exact;
-    const temporal = (value) => {
-        if (value instanceof Date)
-            return dateMilliseconds(value);
-        if (!isDateDomainValue(value))
-            return undefined;
-        const external = externalSqlDomainValue(value);
-        return typeof external === "string" ? Date.parse(`${external}T00:00:00.000Z`) : undefined;
-    };
-    const temporalLeft = temporal(left);
-    const temporalRight = temporal(right);
-    if (temporalLeft !== undefined || temporalRight !== undefined) {
-        const comparableLeft = temporalLeft ?? (typeof left === "number" ? left : undefined);
-        const comparableRight = temporalRight ?? (typeof right === "number" ? right : undefined);
-        if (comparableLeft === undefined || comparableRight === undefined) {
-            throw new TypeError("Values must have comparable SQL types");
-        }
-        return comparableLeft - comparableRight;
+function compareSqlValues(left, right) {
+  if (typeof left === "number" && typeof right === "number") {
+    if (left < right)
+      return -1;
+    if (left > right)
+      return 1;
+    if (left === right)
+      return 0;
+  } else if (typeof left === "string" && typeof right === "string" && left.charCodeAt(0) !== 0 && right.charCodeAt(0) !== 0) {
+    return compareSqlStrings(left, right);
+  }
+  const [coercedLeft, coercedRight] = coerceComparisonOperands(left, right);
+  if (!Object.is(coercedLeft, left) || !Object.is(coercedRight, right)) {
+    return compareSqlValues(coercedLeft, coercedRight);
+  }
+  const plainLeft = externalSqlTextValue(left);
+  const plainRight = externalSqlTextValue(right);
+  if (typeof left === "string" && plainLeft !== left || typeof right === "string" && plainRight !== right) {
+    if (typeof plainLeft !== "string" || typeof plainRight !== "string") {
+      throw new TypeError("Values must have comparable SQL types");
     }
-    const a = left;
-    const b = right;
-    if (a === b)
-        return 0;
-    if (a === null || a === undefined)
-        return -1;
-    if (b === null || b === undefined)
-        return 1;
-    if (typeof a === "number" && typeof b === "number") {
-        if (Number.isNaN(a))
-            return Number.isNaN(b) ? 0 : 1;
-        if (Number.isNaN(b))
-            return -1;
-        return a - b;
+    return compareSqlStrings(plainLeft, plainRight);
+  }
+  const collated = collatedDomainCompare(left, right);
+  if (collated !== void 0)
+    return collated;
+  const interval = intervalDomainCompare(left, right);
+  if (interval !== void 0)
+    return interval;
+  const enumOrder = enumDomainCompare(left, right);
+  if (enumOrder !== void 0)
+    return enumOrder;
+  const exact = exactNumericCompare(left, right);
+  if (exact !== void 0)
+    return exact;
+  const temporal = (value) => {
+    if (value instanceof Date)
+      return dateMilliseconds(value);
+    if (!isDateDomainValue(value))
+      return void 0;
+    const external = externalSqlDomainValue(value);
+    return typeof external === "string" ? Date.parse(`${external}T00:00:00.000Z`) : void 0;
+  };
+  const temporalLeft = temporal(left);
+  const temporalRight = temporal(right);
+  if (temporalLeft !== void 0 || temporalRight !== void 0) {
+    const comparableLeft = temporalLeft ?? (typeof left === "number" ? left : void 0);
+    const comparableRight = temporalRight ?? (typeof right === "number" ? right : void 0);
+    if (comparableLeft === void 0 || comparableRight === void 0) {
+      throw new TypeError("Values must have comparable SQL types");
     }
-    if (typeof a === "string" && typeof b === "string")
-        return compareSqlStrings(a, b);
-    if (typeof a === "boolean" && typeof b === "boolean")
-        return Number(a) - Number(b);
-    throw new TypeError("Values must have comparable SQL types");
+    return comparableLeft - comparableRight;
+  }
+  const a = left;
+  const b = right;
+  if (a === b)
+    return 0;
+  if (a === null || a === void 0)
+    return -1;
+  if (b === null || b === void 0)
+    return 1;
+  if (typeof a === "number" && typeof b === "number") {
+    if (Number.isNaN(a))
+      return Number.isNaN(b) ? 0 : 1;
+    if (Number.isNaN(b))
+      return -1;
+    return a - b;
+  }
+  if (typeof a === "string" && typeof b === "string")
+    return compareSqlStrings(a, b);
+  if (typeof a === "boolean" && typeof b === "boolean")
+    return Number(a) - Number(b);
+  throw new TypeError("Values must have comparable SQL types");
 }
-/** Hot-path string comparison shared by executors without locale-dependent host state. */
-export function compareSqlStrings(left, right) {
-    if (left === right)
-        return 0;
-    return left < right ? -1 : 1;
+function compareSqlStrings(left, right) {
+  if (left === right)
+    return 0;
+  return left < right ? -1 : 1;
 }
-/** A JSON-safe equality token used by set operations and recursive-CTE deduplication. */
-export function encodeSqlEqualityValue(value) {
-    if (value === null || value === undefined)
-        return [0];
-    if (typeof value === "boolean")
-        return [1, value];
-    if (typeof value === "number")
-        return [2, String(value === 0 ? 0 : value)];
-    if (typeof value === "string")
-        return [3, externalSqlTextValue(value)];
-    if (value instanceof Date)
-        return [4, dateMilliseconds(value)];
-    throw new TypeError("Query produced an unsupported value");
+function encodeSqlEqualityValue(value) {
+  if (value === null || value === void 0)
+    return [0];
+  if (typeof value === "boolean")
+    return [1, value];
+  if (typeof value === "number")
+    return [2, String(value === 0 ? 0 : value)];
+  if (typeof value === "string")
+    return [3, externalSqlTextValue(value)];
+  if (value instanceof Date)
+    return [4, dateMilliseconds(value)];
+  throw new TypeError("Query produced an unsupported value");
 }
-/**
- * SQLite-compatible ROUND behavior for Minnow's finite number type: precision truncates to an
- * integer and clamps to 0..30, with ties rounded away from zero.
- */
-export function roundSqlNumber(value, precision = 0) {
-    const digits = Math.min(30, Math.max(0, Math.trunc(precision)));
-    // Whole-number rounding is arithmetic: toFixed(0) picks the integer nearest the exact binary
-    // value, ties toward larger magnitude. Below 2^52 the fractional part of a double is exact,
-    // so floor and compare reproduce it without formatting a string per row.
-    if (digits === 0 && Number.isFinite(value)) {
-        const magnitude = Math.abs(value);
-        if (magnitude >= 4_503_599_627_370_496)
-            return value === 0 ? 0 : value;
-        const whole = Math.floor(magnitude);
-        const rounded = magnitude - whole >= 0.5 ? whole + 1 : whole;
-        return rounded === 0 ? 0 : value < 0 ? -rounded : rounded;
-    }
-    // SQLite formats with the requested decimal precision and parses the result back. toFixed
-    // follows the same decimal path, avoiding multiplication overflow and binary scaling drift.
-    const rounded = Number(value.toFixed(digits));
-    return rounded === 0 ? 0 : rounded;
+function roundSqlNumber(value, precision = 0) {
+  const digits = Math.min(30, Math.max(0, Math.trunc(precision)));
+  if (digits === 0 && Number.isFinite(value)) {
+    const magnitude = Math.abs(value);
+    if (magnitude >= 4503599627370496)
+      return value === 0 ? 0 : value;
+    const whole = Math.floor(magnitude);
+    const rounded2 = magnitude - whole >= 0.5 ? whole + 1 : whole;
+    return rounded2 === 0 ? 0 : value < 0 ? -rounded2 : rounded2;
+  }
+  const rounded = Number(value.toFixed(digits));
+  return rounded === 0 ? 0 : rounded;
 }
 const MAX_PATTERN_CACHE_ENTRIES = 128;
 const MAX_PATTERN_CACHE_RETAINED_SIZE = 64 * 1024;
-const likeCache = new Map();
-const similarCache = new Map();
+const likeCache = /* @__PURE__ */ new Map();
+const similarCache = /* @__PURE__ */ new Map();
 let likeCacheRetainedSize = 0;
 let similarCacheRetainedSize = 0;
 function cachedPattern(cache, key) {
-    const entry = cache.get(key);
-    if (entry === undefined)
-        return undefined;
-    cache.delete(key);
-    cache.set(key, entry);
-    return entry[0];
+  const entry = cache.get(key);
+  if (entry === void 0)
+    return void 0;
+  cache.delete(key);
+  cache.set(key, entry);
+  return entry[0];
 }
 function retainPattern(cache, key, matcher, retainedSize, setRetainedSize) {
-    const entrySize = key.length + matcher.retainedSize;
-    if (entrySize > MAX_PATTERN_CACHE_RETAINED_SIZE)
-        return;
-    while (cache.size >= MAX_PATTERN_CACHE_ENTRIES ||
-        retainedSize + entrySize > MAX_PATTERN_CACHE_RETAINED_SIZE) {
-        const oldest = cache.keys().next().value;
-        if (oldest === undefined)
-            break;
-        const removed = cache.get(oldest);
-        cache.delete(oldest);
-        retainedSize -= removed?.[1] ?? 0;
-    }
-    cache.set(key, [matcher, entrySize]);
-    setRetainedSize(retainedSize + entrySize);
+  const entrySize = key.length + matcher.retainedSize;
+  if (entrySize > MAX_PATTERN_CACHE_RETAINED_SIZE)
+    return;
+  while (cache.size >= MAX_PATTERN_CACHE_ENTRIES || retainedSize + entrySize > MAX_PATTERN_CACHE_RETAINED_SIZE) {
+    const oldest = cache.keys().next().value;
+    if (oldest === void 0)
+      break;
+    const removed = cache.get(oldest);
+    cache.delete(oldest);
+    retainedSize -= removed?.[1] ?? 0;
+  }
+  cache.set(key, [matcher, entrySize]);
+  setRetainedSize(retainedSize + entrySize);
 }
 function throwPatternWorkLimit() {
-    throw new RangeError(`SQL pattern match exceeds ${String(MAX_SQL_PATTERN_MATCH_STEPS)} deterministic steps`);
+  throw new RangeError(`SQL pattern match exceeds ${String(MAX_SQL_PATTERN_MATCH_STEPS)} deterministic steps`);
 }
 function exactSingleCharacter(value, label) {
-    assertBoundedPattern(value, label, 2);
-    const characters = value[Symbol.iterator]();
-    const first = characters.next();
-    if (first.done === true || characters.next().done !== true) {
-        throw new TypeError(`${label.replace(" escape", " ESCAPE")} takes one character`);
-    }
-    return first.value;
+  assertBoundedPattern(value, label, 2);
+  const characters = value[Symbol.iterator]();
+  const first = characters.next();
+  if (first.done === true || characters.next().done !== true) {
+    throw new TypeError(`${label.replace(" escape", " ESCAPE")} takes one character`);
+  }
+  return first.value;
 }
 function tokenizeLike(pattern, escape) {
-    const tokens = [];
-    let escaped = false;
-    for (const character of pattern) {
-        if (escaped) {
-            tokens.push(character);
-            escaped = false;
-        }
-        else if (escape !== undefined && character === escape) {
-            escaped = true;
-        }
-        else if (character === "%") {
-            if (tokens.at(-1) !== 0)
-                tokens.push(0);
-        }
-        else if (character === "_")
-            tokens.push(1);
-        else
-            tokens.push(character);
-    }
-    if (escaped)
-        throw new TypeError("LIKE pattern ends with a dangling escape character");
-    return tokens;
+  const tokens = [];
+  let escaped = false;
+  for (const character of pattern) {
+    if (escaped) {
+      tokens.push(character);
+      escaped = false;
+    } else if (escape !== void 0 && character === escape) {
+      escaped = true;
+    } else if (character === "%") {
+      if (tokens.at(-1) !== 0)
+        tokens.push(0);
+    } else if (character === "_")
+      tokens.push(1);
+    else
+      tokens.push(character);
+  }
+  if (escaped)
+    throw new TypeError("LIKE pattern ends with a dangling escape character");
+  return tokens;
 }
-/** Unicode simple-case approximation used consistently by row and vector LIKE execution. */
 function simpleCaseFold(character) {
-    const upper = character.toUpperCase();
-    const codePoints = upper[Symbol.iterator]();
-    return codePoints.next().done !== true && codePoints.next().done === true ? upper : character;
+  const upper = character.toUpperCase();
+  const codePoints = upper[Symbol.iterator]();
+  return codePoints.next().done !== true && codePoints.next().done === true ? upper : character;
 }
 function likeCharactersEqual(left, right, caseInsensitive) {
-    return left === right || (caseInsensitive && simpleCaseFold(left) === simpleCaseFold(right));
+  return left === right || caseInsensitive && simpleCaseFold(left) === simpleCaseFold(right);
 }
 function literalLikeMatcher(tokens, caseInsensitive) {
-    if (tokens.includes(1))
-        return undefined;
-    const leading = tokens[0] === 0;
-    const trailing = tokens.at(-1) === 0;
-    const begin = leading ? 1 : 0;
-    const end = trailing ? tokens.length - 1 : tokens.length;
-    if (tokens.slice(begin, end).some((token) => typeof token !== "string"))
-        return undefined;
-    const body = tokens
-        .slice(begin, end)
-        .map((token) => (typeof token === "string" ? token : ""))
-        .join("");
-    if (!caseInsensitive) {
-        const test = (value) => {
-            if (typeof value !== "string")
-                throw new TypeError("LIKE input must be a string");
-            if (leading && trailing)
-                return value.includes(body);
-            if (leading)
-                return value.endsWith(body);
-            if (trailing)
-                return value.startsWith(body);
-            return value === body;
-        };
-        return { test, retainedSize: tokens.length * 16 + body.length * 2 };
-    }
-    const needle = Array.from(body, simpleCaseFold);
-    const prefix = new Uint32Array(needle.length);
-    for (let index = 1, matched = 0; index < needle.length; index += 1) {
-        while (matched > 0 && needle[index] !== needle[matched])
-            matched = prefix[matched - 1] ?? 0;
-        if (needle[index] === needle[matched])
-            matched += 1;
-        prefix[index] = matched;
-    }
-    const test = (value) => {
-        if (typeof value !== "string")
-            throw new TypeError("LIKE input must be a string");
-        if (needle.length === 0)
-            return leading || trailing || value.length === 0;
-        let matched = 0;
-        let position = 0;
-        let matchedAtEnd = false;
-        for (const rawCharacter of value) {
-            matchedAtEnd = false;
-            const character = simpleCaseFold(rawCharacter);
-            while (matched > 0 && character !== needle[matched])
-                matched = prefix[matched - 1] ?? 0;
-            if (character === needle[matched])
-                matched += 1;
-            position += 1;
-            if (matched === needle.length) {
-                const startsAt = position - needle.length;
-                if (leading && trailing)
-                    return true;
-                if (!leading && startsAt === 0) {
-                    if (trailing)
-                        return true;
-                    matchedAtEnd = true;
-                }
-                else if (leading && !trailing)
-                    matchedAtEnd = true;
-                matched = prefix[matched - 1] ?? 0;
-            }
-        }
-        return matchedAtEnd;
-    };
-    return {
-        test,
-        retainedSize: tokens.length * 16 + body.length * 2 + prefix.byteLength,
+  if (tokens.includes(1))
+    return void 0;
+  const leading = tokens[0] === 0;
+  const trailing = tokens.at(-1) === 0;
+  const begin = leading ? 1 : 0;
+  const end = trailing ? tokens.length - 1 : tokens.length;
+  if (tokens.slice(begin, end).some((token) => typeof token !== "string"))
+    return void 0;
+  const body = tokens.slice(begin, end).map((token) => typeof token === "string" ? token : "").join("");
+  if (!caseInsensitive) {
+    const test2 = (value) => {
+      if (typeof value !== "string")
+        throw new TypeError("LIKE input must be a string");
+      if (leading && trailing)
+        return value.includes(body);
+      if (leading)
+        return value.endsWith(body);
+      if (trailing)
+        return value.startsWith(body);
+      return value === body;
     };
+    return { test: test2, retainedSize: tokens.length * 16 + body.length * 2 };
+  }
+  const needle = Array.from(body, simpleCaseFold);
+  const prefix = new Uint32Array(needle.length);
+  for (let index = 1, matched = 0; index < needle.length; index += 1) {
+    while (matched > 0 && needle[index] !== needle[matched])
+      matched = prefix[matched - 1] ?? 0;
+    if (needle[index] === needle[matched])
+      matched += 1;
+    prefix[index] = matched;
+  }
+  const test = (value) => {
+    if (typeof value !== "string")
+      throw new TypeError("LIKE input must be a string");
+    if (needle.length === 0)
+      return leading || trailing || value.length === 0;
+    let matched = 0;
+    let position = 0;
+    let matchedAtEnd = false;
+    for (const rawCharacter of value) {
+      matchedAtEnd = false;
+      const character = simpleCaseFold(rawCharacter);
+      while (matched > 0 && character !== needle[matched])
+        matched = prefix[matched - 1] ?? 0;
+      if (character === needle[matched])
+        matched += 1;
+      position += 1;
+      if (matched === needle.length) {
+        const startsAt = position - needle.length;
+        if (leading && trailing)
+          return true;
+        if (!leading && startsAt === 0) {
+          if (trailing)
+            return true;
+          matchedAtEnd = true;
+        } else if (leading && !trailing)
+          matchedAtEnd = true;
+        matched = prefix[matched - 1] ?? 0;
+      }
+    }
+    return matchedAtEnd;
+  };
+  return {
+    test,
+    retainedSize: tokens.length * 16 + body.length * 2 + prefix.byteLength
+  };
 }
 function generalLikeMatcher(tokens, caseInsensitive) {
-    const test = (value) => {
-        if (typeof value !== "string")
-            throw new TypeError("LIKE input must be a string");
-        let remaining = MAX_SQL_PATTERN_MATCH_STEPS;
-        let tokenIndex = 0;
-        let valueIndex = 0;
-        let manyIndex = -1;
-        let retryValueIndex = 0;
-        while (valueIndex < value.length) {
-            if (--remaining < 0)
-                throwPatternWorkLimit();
-            const token = tokens[tokenIndex];
-            if (token === 0) {
-                manyIndex = tokenIndex;
-                tokenIndex += 1;
-                retryValueIndex = valueIndex;
-                continue;
-            }
-            const codePoint = value.codePointAt(valueIndex);
-            if (codePoint === undefined)
-                break;
-            const character = String.fromCodePoint(codePoint);
-            if (token === 1 ||
-                (typeof token === "string" && likeCharactersEqual(token, character, caseInsensitive))) {
-                tokenIndex += 1;
-                valueIndex += character.length;
-                continue;
-            }
-            if (manyIndex < 0)
-                return false;
-            const retryCodePoint = value.codePointAt(retryValueIndex);
-            if (retryCodePoint === undefined)
-                return false;
-            retryValueIndex += String.fromCodePoint(retryCodePoint).length;
-            valueIndex = retryValueIndex;
-            tokenIndex = manyIndex + 1;
-        }
-        while (tokens[tokenIndex] === 0) {
-            if (--remaining < 0)
-                throwPatternWorkLimit();
-            tokenIndex += 1;
-        }
-        return tokenIndex === tokens.length;
-    };
-    return { test, retainedSize: tokens.length * 16 };
+  const test = (value) => {
+    if (typeof value !== "string")
+      throw new TypeError("LIKE input must be a string");
+    let remaining = MAX_SQL_PATTERN_MATCH_STEPS;
+    let tokenIndex = 0;
+    let valueIndex = 0;
+    let manyIndex = -1;
+    let retryValueIndex = 0;
+    while (valueIndex < value.length) {
+      if (--remaining < 0)
+        throwPatternWorkLimit();
+      const token = tokens[tokenIndex];
+      if (token === 0) {
+        manyIndex = tokenIndex;
+        tokenIndex += 1;
+        retryValueIndex = valueIndex;
+        continue;
+      }
+      const codePoint = value.codePointAt(valueIndex);
+      if (codePoint === void 0)
+        break;
+      const character = String.fromCodePoint(codePoint);
+      if (token === 1 || typeof token === "string" && likeCharactersEqual(token, character, caseInsensitive)) {
+        tokenIndex += 1;
+        valueIndex += character.length;
+        continue;
+      }
+      if (manyIndex < 0)
+        return false;
+      const retryCodePoint = value.codePointAt(retryValueIndex);
+      if (retryCodePoint === void 0)
+        return false;
+      retryValueIndex += String.fromCodePoint(retryCodePoint).length;
+      valueIndex = retryValueIndex;
+      tokenIndex = manyIndex + 1;
+    }
+    while (tokens[tokenIndex] === 0) {
+      if (--remaining < 0)
+        throwPatternWorkLimit();
+      tokenIndex += 1;
+    }
+    return tokenIndex === tokens.length;
+  };
+  return { test, retainedSize: tokens.length * 16 };
 }
-/** Compiles SQL LIKE without exposing input to the host regular-expression engine. */
-export function compileLikePattern(pattern, caseInsensitive = false, escape) {
-    assertBoundedPattern(pattern, "LIKE pattern");
-    const exactEscape = escape === undefined ? undefined : exactSingleCharacter(escape, "LIKE escape");
-    const key = JSON.stringify([caseInsensitive, exactEscape ?? null, pattern]);
-    const cached = cachedPattern(likeCache, key);
-    if (cached !== undefined)
-        return cached;
-    const tokens = tokenizeLike(pattern, exactEscape);
-    const matcher = literalLikeMatcher(tokens, caseInsensitive) ?? generalLikeMatcher(tokens, caseInsensitive);
-    retainPattern(likeCache, key, matcher, likeCacheRetainedSize, (size) => {
-        likeCacheRetainedSize = size;
-    });
-    return matcher;
+function compileLikePattern(pattern, caseInsensitive = false, escape) {
+  assertBoundedPattern(pattern, "LIKE pattern");
+  const exactEscape = escape === void 0 ? void 0 : exactSingleCharacter(escape, "LIKE escape");
+  const key = JSON.stringify([caseInsensitive, exactEscape ?? null, pattern]);
+  const cached = cachedPattern(likeCache, key);
+  if (cached !== void 0)
+    return cached;
+  const tokens = tokenizeLike(pattern, exactEscape);
+  const matcher = literalLikeMatcher(tokens, caseInsensitive) ?? generalLikeMatcher(tokens, caseInsensitive);
+  retainPattern(likeCache, key, matcher, likeCacheRetainedSize, (size) => {
+    likeCacheRetainedSize = size;
+  });
+  return matcher;
 }
 const ANY_CHARACTER = () => true;
-/** Parses SIMILAR TO directly into an NFA, avoiding an allocation-heavy intermediate AST. */
 class SimilarCompiler {
-    escape;
-    #characters;
-    states = [];
-    #index = 0;
-    constructor(pattern, escape) {
-        this.escape = escape;
-        this.#characters = Array.from(pattern);
+  escape;
+  #characters;
+  states = [];
+  #index = 0;
+  constructor(pattern, escape) {
+    this.escape = escape;
+    this.#characters = Array.from(pattern);
+  }
+  compile() {
+    const fragment = this.#alternative(0);
+    if (this.#index !== this.#characters.length) {
+      throw new TypeError("SIMILAR TO pattern has an unmatched closing parenthesis");
     }
-    compile() {
-        const fragment = this.#alternative(0);
-        if (this.#index !== this.#characters.length) {
-            throw new TypeError("SIMILAR TO pattern has an unmatched closing parenthesis");
-        }
-        return fragment;
+    return fragment;
+  }
+  #state() {
+    this.states.push([[]]);
+    return this.states.length - 1;
+  }
+  #empty() {
+    const start = this.#state();
+    const end = this.#state();
+    this.states[start]?.[0].push(end);
+    return [start, end];
+  }
+  #consume(matches) {
+    const start = this.#state();
+    const end = this.#state();
+    const state = this.states[start];
+    if (state !== void 0)
+      state[1] = [end, matches];
+    return [start, end];
+  }
+  #repeat(fragment, plus) {
+    const start = this.#state();
+    const end = this.#state();
+    this.states[start]?.[0].push(fragment[0]);
+    if (!plus)
+      this.states[start]?.[0].push(end);
+    this.states[fragment[1]]?.[0].push(fragment[0], end);
+    return [start, end];
+  }
+  #alternative(depth) {
+    const first = this.#sequence(depth);
+    if (this.#characters[this.#index] !== "|" || this.#characters[this.#index] === this.escape) {
+      return first;
     }
-    #state() {
-        this.states.push([[]]);
-        return this.states.length - 1;
+    const start = this.#state();
+    const end = this.#state();
+    this.states[start]?.[0].push(first[0]);
+    this.states[first[1]]?.[0].push(end);
+    while (this.#characters[this.#index] === "|" && this.#characters[this.#index] !== this.escape) {
+      this.#index += 1;
+      const next = this.#sequence(depth);
+      this.states[start]?.[0].push(next[0]);
+      this.states[next[1]]?.[0].push(end);
     }
-    #empty() {
-        const start = this.#state();
-        const end = this.#state();
-        this.states[start]?.[0].push(end);
-        return [start, end];
+    return [start, end];
+  }
+  #sequence(depth) {
+    let result;
+    for (; ; ) {
+      const character = this.#characters[this.#index];
+      if (character === void 0 || (character === "|" || character === ")") && character !== this.escape) {
+        return result ?? this.#empty();
+      }
+      let fragment = this.#atom(depth);
+      const quantifier = this.#characters[this.#index];
+      if ((quantifier === "*" || quantifier === "+") && quantifier !== this.escape) {
+        this.#index += 1;
+        fragment = this.#repeat(fragment, quantifier === "+");
+        const repeated = this.#characters[this.#index];
+        if ((repeated === "*" || repeated === "+") && repeated !== this.escape) {
+          throw new TypeError("SIMILAR TO pattern repeats a quantifier");
+        }
+      }
+      if (result === void 0)
+        result = fragment;
+      else {
+        this.states[result[1]]?.[0].push(fragment[0]);
+        result = [result[0], fragment[1]];
+      }
     }
-    #consume(matches) {
-        const start = this.#state();
-        const end = this.#state();
-        const state = this.states[start];
-        if (state !== undefined)
-            state[1] = [end, matches];
-        return [start, end];
+  }
+  #atom(depth) {
+    const character = this.#characters[this.#index];
+    if (character === void 0)
+      return this.#empty();
+    this.#index += 1;
+    if (character === this.escape) {
+      const literal = this.#characters[this.#index];
+      if (literal === void 0) {
+        throw new TypeError("SIMILAR TO pattern ends with its escape character");
+      }
+      this.#index += 1;
+      return this.#consume((candidate) => candidate === literal);
     }
-    #repeat(fragment, plus) {
-        const start = this.#state();
-        const end = this.#state();
-        this.states[start]?.[0].push(fragment[0]);
-        if (!plus)
-            this.states[start]?.[0].push(end);
-        this.states[fragment[1]]?.[0].push(fragment[0], end);
-        return [start, end];
+    if (character === "*" || character === "+") {
+      throw new TypeError("SIMILAR TO quantifier has no preceding expression");
     }
-    #alternative(depth) {
-        const first = this.#sequence(depth);
-        if (this.#characters[this.#index] !== "|" || this.#characters[this.#index] === this.escape) {
-            return first;
-        }
-        const start = this.#state();
-        const end = this.#state();
-        this.states[start]?.[0].push(first[0]);
-        this.states[first[1]]?.[0].push(end);
-        while (this.#characters[this.#index] === "|" && this.#characters[this.#index] !== this.escape) {
-            this.#index += 1;
-            const next = this.#sequence(depth);
-            this.states[start]?.[0].push(next[0]);
-            this.states[next[1]]?.[0].push(end);
-        }
-        return [start, end];
+    if (character === "(") {
+      if (depth >= MAX_SQL_NESTING_DEPTH) {
+        throw new RangeError(`SIMILAR TO nesting exceeds ${String(MAX_SQL_NESTING_DEPTH)} levels`);
+      }
+      const child = this.#alternative(depth + 1);
+      if (this.#characters[this.#index] !== ")") {
+        throw new TypeError("SIMILAR TO pattern has an unmatched opening parenthesis");
+      }
+      this.#index += 1;
+      return child;
     }
-    #sequence(depth) {
-        let result;
-        for (;;) {
-            const character = this.#characters[this.#index];
-            if (character === undefined ||
-                ((character === "|" || character === ")") && character !== this.escape)) {
-                return result ?? this.#empty();
-            }
-            let fragment = this.#atom(depth);
-            const quantifier = this.#characters[this.#index];
-            if ((quantifier === "*" || quantifier === "+") && quantifier !== this.escape) {
-                this.#index += 1;
-                fragment = this.#repeat(fragment, quantifier === "+");
-                const repeated = this.#characters[this.#index];
-                if ((repeated === "*" || repeated === "+") && repeated !== this.escape) {
-                    throw new TypeError("SIMILAR TO pattern repeats a quantifier");
-                }
-            }
-            if (result === undefined)
-                result = fragment;
-            else {
-                this.states[result[1]]?.[0].push(fragment[0]);
-                result = [result[0], fragment[1]];
-            }
+    if (character === "[")
+      return this.#consume(this.#characterClass());
+    if (character === "%")
+      return this.#repeat(this.#consume(ANY_CHARACTER), false);
+    if (character === "_")
+      return this.#consume(ANY_CHARACTER);
+    return this.#consume((candidate) => candidate === character);
+  }
+  #characterClass() {
+    let source = "[";
+    let closed = false;
+    let hasMember = false;
+    while (this.#index < this.#characters.length) {
+      const character = this.#characters[this.#index] ?? "";
+      this.#index += 1;
+      if (character === this.escape) {
+        const literal = this.#characters[this.#index];
+        if (literal === void 0) {
+          throw new TypeError("SIMILAR TO pattern ends with its escape character");
         }
-    }
-    #atom(depth) {
-        const character = this.#characters[this.#index];
-        if (character === undefined)
-            return this.#empty();
         this.#index += 1;
-        if (character === this.escape) {
-            const literal = this.#characters[this.#index];
-            if (literal === undefined) {
-                throw new TypeError("SIMILAR TO pattern ends with its escape character");
-            }
-            this.#index += 1;
-            return this.#consume((candidate) => candidate === literal);
-        }
-        if (character === "*" || character === "+") {
-            throw new TypeError("SIMILAR TO quantifier has no preceding expression");
-        }
-        if (character === "(") {
-            if (depth >= MAX_SQL_NESTING_DEPTH) {
-                throw new RangeError(`SIMILAR TO nesting exceeds ${String(MAX_SQL_NESTING_DEPTH)} levels`);
-            }
-            const child = this.#alternative(depth + 1);
-            if (this.#characters[this.#index] !== ")") {
-                throw new TypeError("SIMILAR TO pattern has an unmatched opening parenthesis");
-            }
-            this.#index += 1;
-            return child;
-        }
-        if (character === "[")
-            return this.#consume(this.#characterClass());
-        if (character === "%")
-            return this.#repeat(this.#consume(ANY_CHARACTER), false);
-        if (character === "_")
-            return this.#consume(ANY_CHARACTER);
-        return this.#consume((candidate) => candidate === character);
+        source += ["\\", "]", "^", "-"].includes(literal) ? `\\${literal}` : literal;
+        hasMember = true;
+        continue;
+      }
+      if (character === "]") {
+        closed = true;
+        break;
+      }
+      source += character;
+      if (character !== "^" || source.length > 2)
+        hasMember = true;
     }
-    #characterClass() {
-        let source = "[";
-        let closed = false;
-        let hasMember = false;
-        while (this.#index < this.#characters.length) {
-            const character = this.#characters[this.#index] ?? "";
-            this.#index += 1;
-            if (character === this.escape) {
-                const literal = this.#characters[this.#index];
-                if (literal === undefined) {
-                    throw new TypeError("SIMILAR TO pattern ends with its escape character");
-                }
-                this.#index += 1;
-                source += ["\\", "]", "^", "-"].includes(literal) ? `\\${literal}` : literal;
-                hasMember = true;
-                continue;
-            }
-            if (character === "]") {
-                closed = true;
-                break;
-            }
-            source += character;
-            if (character !== "^" || source.length > 2)
-                hasMember = true;
-        }
-        if (!closed)
-            throw new TypeError("SIMILAR TO pattern has an unterminated character class");
-        if (!hasMember)
-            throw new TypeError("SIMILAR TO pattern has an empty character class");
-        source += "]";
-        let expression;
-        try {
-            // The host expression is deliberately limited to one character class and one codepoint.
-            // It cannot contain repetition, grouping, or alternation, so backtracking work is constant.
-            expression = new RegExp(`^(?:${source})$`, "u");
-        }
-        catch {
-            throw new TypeError("SIMILAR TO pattern has an invalid character class");
-        }
-        return (candidate) => expression.test(candidate);
+    if (!closed)
+      throw new TypeError("SIMILAR TO pattern has an unterminated character class");
+    if (!hasMember)
+      throw new TypeError("SIMILAR TO pattern has an empty character class");
+    source += "]";
+    let expression;
+    try {
+      expression = new RegExp(`^(?:${source})$`, "u");
+    } catch {
+      throw new TypeError("SIMILAR TO pattern has an invalid character class");
     }
+    return (candidate) => expression.test(candidate);
+  }
 }
 function nfaMatcher(pattern, escape) {
-    const compiler = new SimilarCompiler(pattern, escape);
-    const fragment = compiler.compile();
-    const { states } = compiler;
-    const test = (value) => {
-        if (typeof value !== "string")
-            throw new TypeError("SIMILAR TO input must be a string");
-        let remaining = MAX_SQL_PATTERN_MATCH_STEPS;
-        const marks = new Uint32Array(states.length);
-        const stack = [];
-        let active = [];
-        let next = [];
-        let generation = 1;
-        const addClosure = (seed, output) => {
-            stack.push(seed);
-            while (stack.length > 0) {
-                if (--remaining < 0)
-                    throwPatternWorkLimit();
-                const stateIndex = stack.pop();
-                if (stateIndex === undefined || marks[stateIndex] === generation)
-                    continue;
-                marks[stateIndex] = generation;
-                output.push(stateIndex);
-                for (const target of states[stateIndex]?.[0] ?? [])
-                    stack.push(target);
-            }
-        };
-        addClosure(fragment[0], active);
-        for (const character of value) {
-            generation += 1;
-            next.length = 0;
-            for (const stateIndex of active) {
-                if (--remaining < 0)
-                    throwPatternWorkLimit();
-                const transition = states[stateIndex]?.[1];
-                if (transition?.[1](character) === true)
-                    addClosure(transition[0], next);
-            }
-            if (next.length === 0)
-                return false;
-            [active, next] = [next, active];
-        }
-        return active.includes(fragment[1]);
+  const compiler = new SimilarCompiler(pattern, escape);
+  const fragment = compiler.compile();
+  const { states } = compiler;
+  const test = (value) => {
+    if (typeof value !== "string")
+      throw new TypeError("SIMILAR TO input must be a string");
+    let remaining = MAX_SQL_PATTERN_MATCH_STEPS;
+    const marks = new Uint32Array(states.length);
+    const stack = [];
+    let active = [];
+    let next = [];
+    let generation = 1;
+    const addClosure = (seed, output) => {
+      stack.push(seed);
+      while (stack.length > 0) {
+        if (--remaining < 0)
+          throwPatternWorkLimit();
+        const stateIndex = stack.pop();
+        if (stateIndex === void 0 || marks[stateIndex] === generation)
+          continue;
+        marks[stateIndex] = generation;
+        output.push(stateIndex);
+        for (const target of states[stateIndex]?.[0] ?? [])
+          stack.push(target);
+      }
     };
-    // State objects, epsilon arrays, transition objects, and matcher closures all cost materially
-    // more than their integer payload. A conservative model keeps large compiled patterns out of
-    // the cache instead of pretending their Uint32-sized indexes are the whole retained graph.
-    return { test, retainedSize: states.length * 32 };
-}
-const regexCache = new Map();
-/**
- * PostgreSQL's ~ / ~* / !~ / !~* operators and REGEXP_REPLACE, compiled as JavaScript regular
- * expressions. Advanced regular expressions and JavaScript agree on the everyday syntax; the
- * `n` flag makes `.` and anchors newline-sensitive, `i` is case-insensitive, and `g` replaces
- * every match. Patterns are bounded like every other SQL pattern.
- */
-export function compileRegexPattern(pattern, flags = "") {
-    assertBoundedPattern(pattern, "regular expression");
-    const normalized = [...new Set(flags)].sort().join("");
-    const key = `${normalized}\u0000${pattern}`;
-    const cached = regexCache.get(key);
-    if (cached !== undefined) {
-        cached.lastIndex = 0;
-        return cached;
+    addClosure(fragment[0], active);
+    for (const character of value) {
+      generation += 1;
+      next.length = 0;
+      for (const stateIndex of active) {
+        if (--remaining < 0)
+          throwPatternWorkLimit();
+        const transition = states[stateIndex]?.[1];
+        if (transition?.[1](character) === true)
+          addClosure(transition[0], next);
+      }
+      if (next.length === 0)
+        return false;
+      [active, next] = [next, active];
     }
-    let jsFlags = "u";
-    if (normalized.includes("i"))
-        jsFlags += "i";
-    if (normalized.includes("g"))
-        jsFlags += "g";
-    if (normalized.includes("n"))
-        jsFlags += "m";
-    else
-        jsFlags += "s";
-    let expression;
+    return active.includes(fragment[1]);
+  };
+  return { test, retainedSize: states.length * 32 };
+}
+const regexCache = /* @__PURE__ */ new Map();
+function compileRegexPattern(pattern, flags = "") {
+  assertBoundedPattern(pattern, "regular expression");
+  const normalized = [...new Set(flags)].sort().join("");
+  const key = `${normalized}\0${pattern}`;
+  const cached = regexCache.get(key);
+  if (cached !== void 0) {
+    cached.lastIndex = 0;
+    return cached;
+  }
+  let jsFlags = "u";
+  if (normalized.includes("i"))
+    jsFlags += "i";
+  if (normalized.includes("g"))
+    jsFlags += "g";
+  if (normalized.includes("n"))
+    jsFlags += "m";
+  else
+    jsFlags += "s";
+  let expression;
+  try {
+    expression = new RegExp(pattern, jsFlags);
+  } catch {
     try {
-        expression = new RegExp(pattern, jsFlags);
+      expression = new RegExp(pattern, jsFlags.replace("u", ""));
+    } catch (error) {
+      throw new TypeError(`Invalid regular expression: ${error instanceof Error ? error.message : pattern}`, { cause: error });
     }
-    catch {
-        try {
-            expression = new RegExp(pattern, jsFlags.replace("u", ""));
-        }
-        catch (error) {
-            throw new TypeError(`Invalid regular expression: ${error instanceof Error ? error.message : pattern}`, { cause: error });
-        }
-    }
-    if (regexCache.size >= 256)
-        regexCache.clear();
-    regexCache.set(key, expression);
-    return expression;
+  }
+  if (regexCache.size >= 256)
+    regexCache.clear();
+  regexCache.set(key, expression);
+  return expression;
 }
-/** PostgreSQL SIMILAR TO compiled to a Thompson NFA with bounded deterministic work. */
-export function compileSimilarPattern(pattern, escape = "\\") {
-    assertBoundedPattern(pattern, "SIMILAR TO pattern");
-    const exactEscape = exactSingleCharacter(escape, "SIMILAR TO escape");
-    const key = JSON.stringify([exactEscape, pattern]);
-    const cached = cachedPattern(similarCache, key);
-    if (cached !== undefined)
-        return cached;
-    const matcher = nfaMatcher(pattern, exactEscape);
-    retainPattern(similarCache, key, matcher, similarCacheRetainedSize, (size) => {
-        similarCacheRetainedSize = size;
-    });
-    return matcher;
+function compileSimilarPattern(pattern, escape = "\\") {
+  assertBoundedPattern(pattern, "SIMILAR TO pattern");
+  const exactEscape = exactSingleCharacter(escape, "SIMILAR TO escape");
+  const key = JSON.stringify([exactEscape, pattern]);
+  const cached = cachedPattern(similarCache, key);
+  if (cached !== void 0)
+    return cached;
+  const matcher = nfaMatcher(pattern, exactEscape);
+  retainPattern(similarCache, key, matcher, similarCacheRetainedSize, (size) => {
+    similarCacheRetainedSize = size;
+  });
+  return matcher;
 }
 function assertBoundedPattern(value, label, limit = MAX_SQL_PATTERN_CHARACTERS) {
-    if (value.length > limit) {
-        throw new RangeError(`${label} exceeds ${String(limit)} characters`);
-    }
-    assertWellFormedString(value, label);
+  if (value.length > limit) {
+    throw new RangeError(`${label} exceeds ${String(limit)} characters`);
+  }
+  assertWellFormedString(value, label);
 }
-/** Defines an own enumerable result-column property, including the special name `__proto__`. */
-export function defineSqlResultProperty(target, name, value) {
-    Object.defineProperty(target, name, {
-        value,
-        enumerable: true,
-        configurable: true,
-        writable: true,
-    });
+function defineSqlResultProperty(target, name, value) {
+  Object.defineProperty(target, name, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  });
 }
-/**
- * A scalar function's string operand, or a type error naming the function. Shared because both
- * the scalar evaluator and the SQL/JSON functions insist on real strings rather than coercing:
- * a silent coercion here would make `LENGTH(42)` answer instead of failing.
- */
-export function stringArgument(name, value) {
-    const external = externalSqlDomainValue(value);
-    if (typeof external !== "string")
-        throw new TypeError(`${name} requires a string argument`);
-    return external;
+function stringArgument(name, value) {
+  const external = externalSqlDomainValue(value);
+  if (typeof external !== "string")
+    throw new TypeError(`${name} requires a string argument`);
+  return external;
 }
+export {
+  coerceComparisonOperands,
+  coercedComparable,
+  compareSqlStrings,
+  compareSqlValues,
+  compileLikePattern,
+  compileRegexPattern,
+  compileSimilarPattern,
+  defineSqlResultProperty,
+  encodeSqlEqualityValue,
+  parseSqlTimestampText,
+  roundSqlNumber,
+  stringArgument
+};