@snowtop/ent 0.1.0-alpha9 → 0.1.0-alpha91

package/core/clause.d.ts

@@ -1,8 +1,10 @@
 export interface Clause {
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     instanceKey(): string;
     logValues(): any[];
+    compositeOp?: string;
 }
 export interface SensitiveValue {
     value(): any;
@@ -12,10 +14,23 @@ declare class simpleClause implements Clause {
     protected col: string;
     private value;
     private op;
-    private handleSqliteNull?;
-    constructor(col: string, value: any, op: string, handleSqliteNull?: Clause | undefined);
+    private handleNull?;
+    constructor(col: string, value: any, op: string, handleNull?: Clause | undefined);
     clause(idx: number): string;
-    private sqliteNull;
+    private nullClause;
+    columns(): string[];
+    values(): any[];
+    logValues(): any[];
+    instanceKey(): string;
+}
+export declare class inClause implements Clause {
+    private col;
+    private value;
+    private type;
+    static getPostgresInClauseValuesThreshold(): number;
+    constructor(col: string, value: any[], type?: string);
+    clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
@@ -23,18 +38,58 @@ declare class simpleClause implements Clause {
 declare class compositeClause implements Clause {
     private clauses;
     private sep;
+    compositeOp: string;
     constructor(clauses: Clause[], sep: string);
     clause(idx: number): string;
+    columns(): string[];
     values(): any[];
     logValues(): any[];
     instanceKey(): string;
 }
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayContains(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContainsValue(col: string, value: any): Clause;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotContains(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayOverlaps(col: string, value: any[]): Clause;
+/**
+ * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+export declare function PostgresArrayNotOverlaps(col: string, value: any[]): Clause;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 export declare function ArrayEq(col: string, value: any): Clause;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 export declare function ArrayNotEq(col: string, value: any): Clause;
-export declare function ArrayGreater(col: string, value: any): Clause;
-export declare function ArrayLess(col: string, value: any): Clause;
-export declare function ArrayGreaterEq(col: string, value: any): Clause;
-export declare function ArrayLessEq(col: string, value: any): Clause;
 export declare function Eq(col: string, value: any): Clause;
 export declare function NotEq(col: string, value: any): Clause;
 export declare function Greater(col: string, value: any): simpleClause;
@@ -44,7 +99,9 @@ export declare function LessEq(col: string, value: any): simpleClause;
 export declare function And(...args: Clause[]): compositeClause;
 export declare function AndOptional(...args: (Clause | undefined)[]): Clause;
 export declare function Or(...args: Clause[]): compositeClause;
+export declare function OrOptional(...args: (Clause | undefined)[]): Clause;
 export declare function In(col: string, ...values: any): Clause;
+export declare function In(col: string, values: any[], type?: string): Clause;
 interface TsQuery {
     language: "english" | "french" | "german" | "simple";
     value: string;
@@ -58,4 +115,23 @@ export declare function TsVectorPlainToTsQuery(col: string, val: string | TsQuer
 export declare function TsVectorPhraseToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function TsVectorWebsearchToTsQuery(col: string, val: string | TsQuery): Clause;
 export declare function sensitiveValue(val: any): SensitiveValue;
+export declare function JSONObjectFieldKeyASJSON(col: string, field: string): string;
+export declare function JSONObjectFieldKeyAsText(col: string, field: string): string;
+declare type predicate = "==" | ">" | "<" | "!=" | ">=" | "<=";
+export declare function JSONPathValuePredicate(dbCol: string, path: string, val: any, pred: predicate): Clause;
+declare class paginationMultipleColumnsSubQueryClause implements Clause {
+    private col;
+    private op;
+    private tableName;
+    private uniqueCol;
+    private val;
+    constructor(col: string, op: string, tableName: string, uniqueCol: string, val: any);
+    private buildSimpleQuery;
+    clause(idx: number): string;
+    columns(): string[];
+    values(): any[];
+    logValues(): any[];
+    instanceKey(): string;
+}
+export declare function PaginationMultipleColsSubQuery(col: string, op: string, tableName: string, uniqueCol: string, val: any): paginationMultipleColumnsSubQueryClause;
 export {};

package/core/clause.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
 }) : (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     o[k2] = m[k];
@@ -19,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayLessEq = exports.ArrayGreaterEq = exports.ArrayLess = exports.ArrayGreater = exports.ArrayNotEq = exports.ArrayEq = void 0;
+exports.PaginationMultipleColsSubQuery = exports.JSONPathValuePredicate = exports.JSONObjectFieldKeyAsText = exports.JSONObjectFieldKeyASJSON = exports.sensitiveValue = exports.TsVectorWebsearchToTsQuery = exports.TsVectorPhraseToTsQuery = exports.TsVectorPlainToTsQuery = exports.TsVectorColTsQuery = exports.WebsearchToTsQuery = exports.PhraseToTsQuery = exports.PlainToTsQuery = exports.TsQuery = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.inClause = void 0;
 const db_1 = __importStar(require("./db"));
 function isSensitive(val) {
     return (val !== null &&
@@ -33,35 +37,35 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op, handleSqliteNull) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.handleSqliteNull = handleSqliteNull;
+        this.handleNull = handleNull;
     }
     clause(idx) {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.clause(idx);
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.clause(idx);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
             return `${this.col} ${this.op} $${idx}`;
         }
         return `${this.col} ${this.op} ?`;
     }
-    sqliteNull() {
-        if (!this.handleSqliteNull || this.value !== null) {
-            return;
-        }
-        if (db_1.default.getDialect() !== db_1.Dialect.SQLite) {
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
             return;
         }
-        return this.handleSqliteNull;
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
     }
     values() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.values();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.values();
         }
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -69,9 +73,9 @@ class simpleClause {
         return [this.value];
     }
     logValues() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.logValues();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.logValues();
         }
         if (isSensitive(this.value)) {
             return [this.value.logValue()];
@@ -79,9 +83,9 @@ class simpleClause {
         return [this.value];
     }
     instanceKey() {
-        const sqliteClause = this.sqliteNull();
-        if (sqliteClause) {
-            return sqliteClause.instanceKey();
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.instanceKey();
         }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
@@ -93,6 +97,9 @@ class isNullClause {
     clause(idx) {
         return `${this.col} IS NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -110,6 +117,9 @@ class isNotNullClause {
     clause(idx) {
         return `${this.col} IS NOT NULL`;
     }
+    columns() {
+        return [];
+    }
     values() {
         return [];
     }
@@ -132,6 +142,9 @@ class arraySimpleClause {
         }
         return `${this.col} ${this.op} ?`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -148,18 +161,105 @@ class arraySimpleClause {
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
+class postgresArrayOperator {
+    constructor(col, value, op, not) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+        this.not = not;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            if (this.not) {
+                return `NOT ${this.col} ${this.op} $${idx}`;
+            }
+            return `${this.col} ${this.op} $${idx}`;
+        }
+        throw new Error(`not supported`);
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.value()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [`{${this.value.logValue()}}`];
+        }
+        return [`{${this.value}}`];
+    }
+    instanceKey() {
+        if (this.not) {
+            return `NOT:${this.col}${this.op}${rawValue(this.value)}`;
+        }
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
+class postgresArrayOperatorList extends postgresArrayOperator {
+    constructor(col, value, op, not) {
+        super(col, value, op, not);
+    }
+    values() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.value();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+    logValues() {
+        return [
+            `{${this.value
+                .map((v) => {
+                if (isSensitive(v)) {
+                    return v.logValue();
+                }
+                return v;
+            })
+                .join(", ")}}`,
+        ];
+    }
+}
 class inClause {
-    constructor(col, value) {
+    constructor(col, value, type = "uuid") {
         this.col = col;
         this.value = value;
+        this.type = type;
+    }
+    static getPostgresInClauseValuesThreshold() {
+        return 70;
     }
     clause(idx) {
-        const dialect = db_1.default.getDialect();
+        // do a simple = when only one item
+        if (this.value.length === 1) {
+            return new simpleClause(this.col, this.value[0], "=").clause(idx);
+        }
+        const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
+        const postgresValuesList = postgres &&
+            this.value.length >= inClause.getPostgresInClauseValuesThreshold();
         let indices;
-        if (dialect === db_1.Dialect.Postgres) {
+        if (postgres) {
             indices = [];
             for (let i = 0; i < this.value.length; i++) {
-                indices.push(`$${idx}`);
+                if (postgresValuesList) {
+                    if (i === 0) {
+                        indices.push(`($${idx}::${this.type})`);
+                    }
+                    else {
+                        indices.push(`($${idx})`);
+                    }
+                }
+                else {
+                    indices.push(`$${idx}`);
+                }
                 idx++;
             }
         }
@@ -167,34 +267,31 @@ class inClause {
             indices = new Array(this.value.length);
             indices.fill("?", 0);
         }
-        const inValue = indices.join(", ");
+        let inValue = indices.join(", ");
+        // wrap in VALUES list for postgres...
+        if (postgresValuesList) {
+            inValue = `VALUES${inValue}`;
+        }
         return `${this.col} IN (${inValue})`;
         // TODO we need to return idx at end to query builder...
         // or anything that's doing a composite query so next clause knows where to start
         // or change to a sqlx.Rebind format
         // here's what sqlx does: https://play.golang.org/p/vPzvYqeAcP0
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.value());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(rawValue(value));
         }
         return result;
     }
     logValues() {
         const result = [];
-        for (const value of this.value) {
-            if (isSensitive(value)) {
-                result.push(value.logValue());
-            }
-            else {
-                result.push(value);
-            }
+        for (let value of this.value) {
+            result.push(isSensitive(value) ? value.logValue() : value);
         }
         return result;
     }
@@ -202,19 +299,33 @@ class inClause {
         return `in:${this.col}:${this.values().join(",")}`;
     }
 }
+exports.inClause = inClause;
 class compositeClause {
     constructor(clauses, sep) {
         this.clauses = clauses;
         this.sep = sep;
+        this.compositeOp = this.sep;
     }
     clause(idx) {
         let clauses = [];
         for (const clause of this.clauses) {
-            clauses.push(clause.clause(idx));
+            let cls = clause.clause(idx);
+            // if composite clause and a different op, add parens so that we enforce order of precedence
+            if (clause.compositeOp && clause.compositeOp !== this.sep) {
+                cls = `(${cls})`;
+            }
+            clauses.push(cls);
             idx = idx + clause.values().length;
         }
         return clauses.join(this.sep);
     }
+    columns() {
+        const ret = [];
+        for (const cls of this.clauses) {
+            ret.push(...cls.columns());
+        }
+        return ret;
+    }
     values() {
         let result = [];
         for (const clause of this.clauses) {
@@ -231,7 +342,14 @@ class compositeClause {
     }
     instanceKey() {
         let keys = [];
-        this.clauses.forEach((clause) => keys.push(clause.instanceKey()));
+        this.clauses.forEach((clause) => {
+            if (clause.compositeOp && clause.compositeOp != this.sep) {
+                keys.push(`(${clause.instanceKey()})`);
+            }
+            else {
+                keys.push(clause.instanceKey());
+            }
+        });
         return keys.join(this.sep);
     }
 }
@@ -264,6 +382,9 @@ class tsQueryClause {
         // FYI this doesn't actually work for sqlite since different
         return `${this.col} @@ ${this.getFunction()}('${language}', ?)`;
     }
+    columns() {
+        return [this.col];
+    }
     values() {
         const { value } = this.getInfo();
         return [value];
@@ -298,31 +419,76 @@ class websearchTosQueryClause extends tsQueryClause {
         return "websearch_to_tsquery";
     }
 }
-// TODO we need to check sqlite version...
+// postgres array operators
+// https://www.postgresql.org/docs/current/functions-array.html
+/**
+ * creates a clause to determine if the given value is contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>");
+}
+exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
+/**
+ * creates a clause to determine if every item in the list is stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>");
+}
+exports.PostgresArrayContains = PostgresArrayContains;
+/**
+ * creates a clause to determine if the given value is NOT contained in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContainsValue(col, value) {
+    return new postgresArrayOperator(col, value, "@>", true);
+}
+exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
+/**
+ * creates a clause to determine if every item in the list is NOT stored in the array stored in the column in the db
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotContains(col, value) {
+    return new postgresArrayOperatorList(col, value, "@>", true);
+}
+exports.PostgresArrayNotContains = PostgresArrayNotContains;
+/**
+ * creates a clause to determine if the arrays overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&");
+}
+exports.PostgresArrayOverlaps = PostgresArrayOverlaps;
+/**
+ * creates a clause to determine if the arrays do not overlap, that is, do they have any elements in common
+ * only works with postgres gin indexes
+ * https://www.postgresql.org/docs/current/indexes-types.html#INDEXES-TYPES-GIN
+ */
+function PostgresArrayNotOverlaps(col, value) {
+    return new postgresArrayOperatorList(col, value, "&&", true);
+}
+exports.PostgresArrayNotOverlaps = PostgresArrayNotOverlaps;
+/**
+ * @deprecated use PostgresArrayContainsValue
+ */
 function ArrayEq(col, value) {
     return new arraySimpleClause(col, value, "=");
 }
 exports.ArrayEq = ArrayEq;
+/**
+ * @deprecated use PostgresNotArrayContains
+ */
 function ArrayNotEq(col, value) {
     return new arraySimpleClause(col, value, "!=");
 }
 exports.ArrayNotEq = ArrayNotEq;
-function ArrayGreater(col, value) {
-    return new arraySimpleClause(col, value, ">");
-}
-exports.ArrayGreater = ArrayGreater;
-function ArrayLess(col, value) {
-    return new arraySimpleClause(col, value, "<");
-}
-exports.ArrayLess = ArrayLess;
-function ArrayGreaterEq(col, value) {
-    return new arraySimpleClause(col, value, ">=");
-}
-exports.ArrayGreaterEq = ArrayGreaterEq;
-function ArrayLessEq(col, value) {
-    return new arraySimpleClause(col, value, "<=");
-}
-exports.ArrayLessEq = ArrayLessEq;
 function Eq(col, value) {
     return new simpleClause(col, value, "=", new isNullClause(col));
 }
@@ -364,9 +530,24 @@ function Or(...args) {
     return new compositeClause(args, " OR ");
 }
 exports.Or = Or;
-// TODO this breaks if values.length ===1 and array. todo fix
-function In(col, ...values) {
-    return new inClause(col, values);
+function OrOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return Or(...filtered);
+}
+exports.OrOptional = OrOptional;
+function In(...args) {
+    if (args.length < 2) {
+        throw new Error(`invalid args passed to In`);
+    }
+    // 2nd overload
+    if (Array.isArray(args[1])) {
+        return new inClause(args[0], args[1], args[2]);
+    }
+    return new inClause(args[0], args.slice(1));
 }
 exports.In = In;
 // if string defaults to english
@@ -437,3 +618,93 @@ function sensitiveValue(val) {
     };
 }
 exports.sensitiveValue = sensitiveValue;
+// These don't return Clauses but return helpful things that can be passed to clauses
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+// see test in db_clause.test.ts
+// unclear best time to use this...
+function JSONObjectFieldKeyASJSON(col, field) {
+    return `${col}->'${field}'`;
+}
+exports.JSONObjectFieldKeyASJSON = JSONObjectFieldKeyASJSON;
+function JSONObjectFieldKeyAsText(col, field) {
+    return `${col}->>'${field}'`;
+}
+exports.JSONObjectFieldKeyAsText = JSONObjectFieldKeyAsText;
+class jSONPathValuePredicateClause {
+    constructor(col, path, value, pred) {
+        this.col = col;
+        this.path = path;
+        this.value = value;
+        this.pred = pred;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() !== db_1.Dialect.Postgres) {
+            throw new Error(`not supported`);
+        }
+        return `${this.col} @@ $${idx}`;
+    }
+    columns() {
+        return [this.col];
+    }
+    wrap(val) {
+        return `${this.path} ${this.pred} ${JSON.stringify(val)}`;
+    }
+    values() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.value())];
+        }
+        return [this.wrap(this.value)];
+    }
+    logValues() {
+        if (isSensitive(this.value)) {
+            return [this.wrap(this.value.logValue())];
+        }
+        return [this.wrap(this.value)];
+    }
+    instanceKey() {
+        return `${this.col}${this.path}${rawValue(this.value)}${this.pred}`;
+    }
+}
+// https://www.postgresql.org/docs/12/functions-json.html#FUNCTIONS-JSON-OP-TABLE
+function JSONPathValuePredicate(dbCol, path, val, pred) {
+    return new jSONPathValuePredicateClause(dbCol, path, val, pred);
+}
+exports.JSONPathValuePredicate = JSONPathValuePredicate;
+// TODO need a better name for this lol
+// this assumes we're doing the same direction twice which isn't necessarily accurate in the future...
+class paginationMultipleColumnsSubQueryClause {
+    constructor(col, op, tableName, uniqueCol, val) {
+        this.col = col;
+        this.op = op;
+        this.tableName = tableName;
+        this.uniqueCol = uniqueCol;
+        this.val = val;
+    }
+    buildSimpleQuery(clause, idx) {
+        return `SELECT ${this.col} FROM ${this.tableName} WHERE ${clause.clause(idx)}`;
+    }
+    clause(idx) {
+        const eq1 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx);
+        const eq2 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx + 1);
+        const op = new simpleClause(this.uniqueCol, this.val, this.op).clause(idx + 2);
+        // nest in () to make sure it's scoped correctly
+        return `(${this.col} ${this.op} (${eq1}) OR (${this.col} = (${eq2}) AND ${op}))`;
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        return [this.val, this.val, this.val];
+    }
+    logValues() {
+        const log = isSensitive(this.val) ? this.val.logValue() : this.val;
+        return [log, log, log];
+    }
+    instanceKey() {
+        return `${this.col}-${this.op}-${this.tableName}-${this.uniqueCol}-${this.val}`;
+    }
+}
+function PaginationMultipleColsSubQuery(col, op, tableName, uniqueCol, val) {
+    return new paginationMultipleColumnsSubQueryClause(col, op, tableName, uniqueCol, val);
+}
+exports.PaginationMultipleColsSubQuery = PaginationMultipleColsSubQuery;