@minnowdb/core 0.6.8 → 0.7.0

package/dist/engine/sql-domains.d.ts

@@ -72,5 +72,11 @@ export declare function externalSqlDomainValue(value: unknown): unknown;
  * those shapes keeps `||` from inventing a text concatenation PostgreSQL does not have —
  * and from ever concatenating internal domain encodings.
  */
-export declare function concatenatedSqlValue(left: string, right: string): string;
+export declare function concatenatedSqlValue(leftValue: unknown, rightValue: unknown): string;
+/**
+ * Orders two INTERVAL values the way PostgreSQL's interval comparison does: a month counts as
+ * 30 days and a day as 24 hours, so INTERVAL '3 months' equals INTERVAL '90 days' and
+ * INTERVAL '2 days' sorts below INTERVAL '10 days'. Undefined unless both are intervals.
+ */
+export declare function intervalDomainCompare(left: unknown, right: unknown): number | undefined;
 export declare function isSqlDomainValue(value: unknown): value is string;

package/dist/engine/sql-domains.js

@@ -765,7 +765,15 @@ function concatenationDomainKind(value) {
  * those shapes keeps `||` from inventing a text concatenation PostgreSQL does not have —
  * and from ever concatenating internal domain encodings.
  */
-export function concatenatedSqlValue(left, right) {
+export function concatenatedSqlValue(leftValue, rightValue) {
+    // PostgreSQL has text || anynonarray and anynonarray || text: one side is text and the other
+    // renders as text. Two non-text operands (1 || 2, TRUE || FALSE) have no || operator.
+    const leftText = typeof leftValue === "string";
+    const rightText = typeof rightValue === "string";
+    if (!leftText && !rightText)
+        throw new TypeError("|| requires a string operand");
+    const left = leftText ? leftValue : concatenationOperandText(leftValue);
+    const right = rightText ? rightValue : concatenationOperandText(rightValue);
     const leftKind = concatenationDomainKind(left);
     const rightKind = concatenationDomainKind(right);
     for (const kind of [leftKind, rightKind]) {
@@ -781,6 +789,35 @@ export function concatenatedSqlValue(left, right) {
     }
     return protectedSqlTextValue(String(externalSqlDomainValue(left)) + String(externalSqlDomainValue(right)));
 }
+/** The text a non-string || operand contributes: PostgreSQL's output rendering of the value. */
+function concatenationOperandText(value) {
+    if (typeof value === "number")
+        return String(value);
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    if (value instanceof Date)
+        return dateIsoString(value);
+    throw new TypeError("|| requires a string operand");
+}
+/**
+ * Orders two INTERVAL values the way PostgreSQL's interval comparison does: a month counts as
+ * 30 days and a day as 24 hours, so INTERVAL '3 months' equals INTERVAL '90 days' and
+ * INTERVAL '2 days' sorts below INTERVAL '10 days'. Undefined unless both are intervals.
+ */
+export function intervalDomainCompare(left, right) {
+    if (typeof left !== "string" ||
+        typeof right !== "string" ||
+        !left.startsWith(INTERVAL_VALUE) ||
+        !right.startsWith(INTERVAL_VALUE)) {
+        return undefined;
+    }
+    const total = (value) => {
+        const [months, days, microseconds] = JSON.parse(value.slice(INTERVAL_VALUE.length));
+        return (months * 30 + days) * 86_400_000_000 + microseconds;
+    };
+    const difference = total(left) - total(right);
+    return difference === 0 ? 0 : difference < 0 ? -1 : 1;
+}
 export function isSqlDomainValue(value) {
     return typeof value === "string" && value.startsWith(PREFIX);
 }

package/dist/engine/sql-functions.d.ts

@@ -0,0 +1,11 @@
+export type SimpleScalarResult = "string" | "number" | "boolean" | "datetime" | "date" | "interval" | "argument";
+export interface SimpleScalarFunction {
+    readonly minArgs: number;
+    readonly maxArgs: number;
+    /** The output type; "argument" carries the first argument's type through. */
+    readonly returns: SimpleScalarResult;
+    /** False for functions that read NULL arguments as data (CONCAT) instead of returning NULL. */
+    readonly nullOnNull?: false;
+    readonly evaluate: (values: readonly unknown[]) => unknown;
+}
+export declare const simpleScalarFunctions: ReadonlyMap<string, SimpleScalarFunction>;