@snowtop/ent 0.1.19-test2 → 0.1.20

package/core/clause.js

@@ -24,7 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.JSONKeyInList = exports.JSONBKeyInList = exports.JSONKeyExists = 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.DBTypeNotIn = exports.TextNotIn = exports.IntegerNotIn = exports.UuidNotIn = exports.DBTypeIn = exports.TextIn = exports.IntegerIn = exports.UuidIn = exports.In = exports.OrOptional = exports.Or = exports.AndOptional = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.ContainsIgnoreCase = exports.EndsWithIgnoreCase = exports.StartsWithIgnoreCase = exports.Contains = exports.EndsWith = exports.StartsWith = exports.Eq = exports.ArrayNotEq = exports.ArrayEq = exports.PostgresArrayNotOverlaps = exports.PostgresArrayOverlaps = exports.PostgresArrayNotContains = exports.PostgresArrayNotContainsValue = exports.PostgresArrayContains = exports.PostgresArrayContainsValue = exports.notInClause = exports.inClause = void 0;
-exports.Expression = exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsSubQuery = void 0;
+exports.Expression = exports.getCombinedClause = exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = exports.PaginationMultipleColsQuery = exports.PaginationMultipleColsSubQuery = void 0;
 const db_1 = __importStar(require("./db"));
 const query_impl_1 = require("./query_impl");
 function isSensitive(val) {
@@ -38,18 +38,21 @@ function rawValue(val) {
     }
     return val;
 }
-function renderCol(col, alias) {
+function renderCol(col, overrideAlias, alias) {
+    if (overrideAlias) {
+        return `${overrideAlias}.${col}`;
+    }
     if (alias) {
         return `${alias}.${col}`;
     }
     return col;
 }
 class simpleClause {
-    constructor(col, value, op, handleNull) {
+    constructor(col, value, op, opts) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.handleNull = handleNull;
+        this.opts = opts;
     }
     clause(idx, alias) {
         const nullClause = this.nullClause();
@@ -57,15 +60,15 @@ class simpleClause {
             return nullClause.clause(idx, alias);
         }
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            return `${renderCol(this.col, alias)} ${this.op} $${idx}`;
+            return `${renderCol(this.col, this.opts?.overrideAlias, alias)} ${this.op} $${idx}`;
         }
-        return `${renderCol(this.col, alias)} ${this.op} ?`;
+        return `${renderCol(this.col, this.opts?.overrideAlias, alias)} ${this.op} ?`;
     }
     nullClause() {
-        if (!this.handleNull || this.value !== null) {
+        if (!this.opts?.handleNull || this.value !== null) {
             return;
         }
-        return this.handleNull;
+        return this.opts.handleNull;
     }
     columns() {
         return [this.col];
@@ -95,6 +98,9 @@ class simpleClause {
         if (nullClause) {
             return nullClause.instanceKey();
         }
+        if (this.opts?.overrideAlias) {
+            return `${this.opts.overrideAlias}.${this.col}${this.op}${rawValue(this.value)}`;
+        }
         return `${this.col}${this.op}${rawValue(this.value)}`;
     }
 }
@@ -131,11 +137,12 @@ class existsQueryClause extends queryClause {
     }
 }
 class isNullClause {
-    constructor(col) {
+    constructor(col, overrideAlias) {
         this.col = col;
+        this.overrideAlias = overrideAlias;
     }
     clause(_idx, alias) {
-        return `${renderCol(this.col, alias)} IS NULL`;
+        return `${renderCol(this.col, this.overrideAlias, alias)} IS NULL`;
     }
     columns() {
         return [];
@@ -147,27 +154,15 @@ class isNullClause {
         return [];
     }
     instanceKey() {
-        return `${this.col} IS NULL`;
+        return `${this.col}${this.overrideAlias ?? ""} IS NULL`;
     }
 }
-class isNotNullClause {
-    constructor(col) {
-        this.col = col;
-    }
+class isNotNullClause extends isNullClause {
     clause(idx, alias) {
-        return `${renderCol(this.col, alias)} IS NOT NULL`;
-    }
-    columns() {
-        return [];
-    }
-    values() {
-        return [];
-    }
-    logValues() {
-        return [];
+        return `${renderCol(this.col, this.overrideAlias, alias)} IS NOT NULL`;
     }
     instanceKey() {
-        return `${this.col} IS NOT NULL`;
+        return `${this.col}${this.overrideAlias ?? ""} IS NOT NULL`;
     }
 }
 class simpleExpression {
@@ -191,14 +186,15 @@ class simpleExpression {
     }
 }
 class arraySimpleClause {
-    constructor(col, value, op) {
+    constructor(col, value, op, overrideAlias) {
         this.col = col;
         this.value = value;
         this.op = op;
+        this.overrideAlias = overrideAlias;
     }
     clause(idx, alias) {
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            return `$${idx} ${this.op} ANY(${renderCol(this.col, alias)})`;
+            return `$${idx} ${this.op} ANY(${renderCol(this.col, this.overrideAlias, alias)})`;
         }
         return `${renderCol(this.col, alias)} ${this.op} ?`;
     }
@@ -218,22 +214,22 @@ class arraySimpleClause {
         return [this.value];
     }
     instanceKey() {
-        return `${this.col}${this.op}${rawValue(this.value)}`;
+        return `${this.col}${this.overrideAlias ?? ""}${this.op}${rawValue(this.value)}`;
     }
 }
 class postgresArrayOperator {
-    constructor(col, value, op, not) {
+    constructor(col, value, op, opts) {
         this.col = col;
         this.value = value;
         this.op = op;
-        this.not = not;
+        this.opts = opts;
     }
     clause(idx, alias) {
         if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
-            if (this.not) {
-                return `NOT ${renderCol(this.col, alias)} ${this.op} $${idx}`;
+            if (this.opts?.not) {
+                return `NOT ${renderCol(this.col, this.opts.overrideAlias, alias)} ${this.op} $${idx}`;
             }
-            return `${renderCol(this.col, alias)} ${this.op} $${idx}`;
+            return `${renderCol(this.col, this.opts?.overrideAlias, alias)} ${this.op} $${idx}`;
         }
         throw new Error(`not supported`);
     }
@@ -253,15 +249,21 @@ class postgresArrayOperator {
         return [`{${this.value}}`];
     }
     instanceKey() {
-        if (this.not) {
-            return `NOT:${this.col}${this.op}${rawValue(this.value)}`;
+        if (this.opts?.not) {
+            if (this.opts.overrideAlias) {
+                return `NOT:${this.opts.overrideAlias}.${this.col}${this.op}${rawValue(this.value)}`;
+            }
+            return `NOT:${this.col}${this.opts?.overrideAlias ?? ""}${this.op}${rawValue(this.value)}`;
+        }
+        if (this.opts?.overrideAlias) {
+            return `${this.opts.overrideAlias}.${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);
+    constructor(col, value, op, opts) {
+        super(col, value, op, opts);
     }
     values() {
         return [
@@ -292,20 +294,25 @@ class inClause {
     static getPostgresInClauseValuesThreshold() {
         return 70;
     }
-    constructor(col, value, type = "uuid") {
+    constructor(col, value, type = "uuid", overrideAlias) {
         this.col = col;
         this.value = value;
         this.type = type;
+        this.overrideAlias = overrideAlias;
         this.op = "IN";
     }
     clause(idx, alias) {
         // do a simple = when only one item
         if (this.value.length === 1) {
             if (this.op === "IN") {
-                return new simpleClause(this.col, this.value[0], "=").clause(idx, alias);
+                return new simpleClause(this.col, this.value[0], "=", {
+                    overrideAlias: this.overrideAlias,
+                }).clause(idx, alias);
             }
             else {
-                return new simpleClause(this.col, this.value[0], "!=").clause(idx, alias);
+                return new simpleClause(this.col, this.value[0], "!=", {
+                    overrideAlias: this.overrideAlias,
+                }).clause(idx, alias);
             }
         }
         const postgres = db_1.default.getDialect() === db_1.Dialect.Postgres;
@@ -338,7 +345,7 @@ class inClause {
         if (postgresValuesList) {
             inValue = `VALUES${inValue}`;
         }
-        return `${renderCol(this.col, alias)} ${this.op} (${inValue})`;
+        return `${renderCol(this.col, this.overrideAlias, alias)} ${this.op} (${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
@@ -362,6 +369,9 @@ class inClause {
         return result;
     }
     instanceKey() {
+        if (this.overrideAlias) {
+            return `${this.op.toLowerCase()}:${this.overrideAlias}.${this.col}:${this.values().join(",")}`;
+        }
         return `${this.op.toLowerCase()}:${this.col}:${this.values().join(",")}`;
     }
 }
@@ -427,10 +437,10 @@ class compositeClause {
     }
 }
 class tsQueryClause {
-    constructor(col, val, tsVectorCol) {
+    constructor(col, val, opts) {
         this.col = col;
         this.val = val;
-        this.tsVectorCol = tsVectorCol;
+        this.opts = opts;
     }
     isTsQuery(val) {
         return typeof val !== "string";
@@ -447,13 +457,13 @@ class tsQueryClause {
     clause(idx, alias) {
         const { language } = this.getInfo();
         if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
-            if (this.tsVectorCol) {
-                return `to_tsvector(${renderCol(this.col, alias)}) @@ ${this.getFunction()}('${language}', $${idx})`;
+            if (this.opts?.tsVectorCol) {
+                return `to_tsvector(${renderCol(this.col, this.opts.overrideAlias, alias)}) @@ ${this.getFunction()}('${language}', $${idx})`;
             }
-            return `${renderCol(this.col, alias)} @@ ${this.getFunction()}('${language}', $${idx})`;
+            return `${renderCol(this.col, this.opts?.overrideAlias, alias)} @@ ${this.getFunction()}('${language}', $${idx})`;
         }
         // FYI this doesn't actually work for sqlite since different
-        return `${renderCol(this.col, alias)} @@ ${this.getFunction()}('${language}', ?)`;
+        return `${renderCol(this.col, this.opts?.overrideAlias, alias)} @@ ${this.getFunction()}('${language}', ?)`;
     }
     columns() {
         return [this.col];
@@ -471,9 +481,15 @@ class tsQueryClause {
     }
     instanceKey() {
         const { language, value } = this.getInfo();
-        if (this.tsVectorCol) {
+        if (this.opts?.tsVectorCol) {
+            if (this.opts.overrideAlias) {
+                return `to_tsvector(${this.opts.overrideAlias}.${this.col})@@${this.getFunction()}:${language}:${value}`;
+            }
             return `to_tsvector(${this.col})@@${this.getFunction()}:${language}:${value}`;
         }
+        if (this.opts?.overrideAlias) {
+            return `${this.opts.overrideAlias}.${this.col}@@${this.getFunction()}:${language}:${value}`;
+        }
         return `${this.col}@@${this.getFunction()}:${language}:${value}`;
     }
 }
@@ -499,8 +515,8 @@ class websearchTosQueryClause extends tsQueryClause {
  * 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, "@>");
+function PostgresArrayContainsValue(col, value, overrideAlias) {
+    return new postgresArrayOperator(col, value, "@>", { overrideAlias });
 }
 exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
 /**
@@ -508,8 +524,8 @@ exports.PostgresArrayContainsValue = PostgresArrayContainsValue;
  * 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, "@>");
+function PostgresArrayContains(col, value, overrideAlias) {
+    return new postgresArrayOperatorList(col, value, "@>", { overrideAlias });
 }
 exports.PostgresArrayContains = PostgresArrayContains;
 /**
@@ -517,8 +533,11 @@ exports.PostgresArrayContains = PostgresArrayContains;
  * 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);
+function PostgresArrayNotContainsValue(col, value, overrideAlias) {
+    return new postgresArrayOperator(col, value, "@>", {
+        not: true,
+        overrideAlias,
+    });
 }
 exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
 /**
@@ -526,8 +545,11 @@ exports.PostgresArrayNotContainsValue = PostgresArrayNotContainsValue;
  * 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);
+function PostgresArrayNotContains(col, value, overrideAlias) {
+    return new postgresArrayOperatorList(col, value, "@>", {
+        not: true,
+        overrideAlias,
+    });
 }
 exports.PostgresArrayNotContains = PostgresArrayNotContains;
 /**
@@ -535,8 +557,10 @@ exports.PostgresArrayNotContains = PostgresArrayNotContains;
  * 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, "&&");
+function PostgresArrayOverlaps(col, value, overrideAlias) {
+    return new postgresArrayOperatorList(col, value, "&&", {
+        overrideAlias,
+    });
 }
 exports.PostgresArrayOverlaps = PostgresArrayOverlaps;
 /**
@@ -544,8 +568,11 @@ exports.PostgresArrayOverlaps = PostgresArrayOverlaps;
  * 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);
+function PostgresArrayNotOverlaps(col, value, overrideAlias) {
+    return new postgresArrayOperatorList(col, value, "&&", {
+        not: true,
+        overrideAlias,
+    });
 }
 exports.PostgresArrayNotOverlaps = PostgresArrayNotOverlaps;
 /**
@@ -562,52 +589,70 @@ function ArrayNotEq(col, value) {
     return new arraySimpleClause(col, value, "!=");
 }
 exports.ArrayNotEq = ArrayNotEq;
-function Eq(col, value) {
-    return new simpleClause(col, value, "=", new isNullClause(col));
+function Eq(col, value, overrideAlias) {
+    return new simpleClause(col, value, "=", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Eq = Eq;
-function StartsWith(col, value) {
-    return new simpleClause(col, `${value}%`, "LIKE");
+function StartsWith(col, value, overrideAlias) {
+    return new simpleClause(col, `${value}%`, "LIKE", {
+        overrideAlias,
+    });
 }
 exports.StartsWith = StartsWith;
-function EndsWith(col, value) {
-    return new simpleClause(col, `%${value}`, "LIKE");
+function EndsWith(col, value, overrideAlias) {
+    return new simpleClause(col, `%${value}`, "LIKE", {
+        overrideAlias,
+    });
 }
 exports.EndsWith = EndsWith;
-function Contains(col, value) {
-    return new simpleClause(col, `%${value}%`, "LIKE");
+function Contains(col, value, overrideAlias) {
+    return new simpleClause(col, `%${value}%`, "LIKE", {
+        overrideAlias,
+    });
 }
 exports.Contains = Contains;
-function StartsWithIgnoreCase(col, value) {
-    return new simpleClause(col, `${value}%`, "ILIKE");
+function StartsWithIgnoreCase(col, value, overrideAlias) {
+    return new simpleClause(col, `${value}%`, "ILIKE", {
+        overrideAlias,
+    });
 }
 exports.StartsWithIgnoreCase = StartsWithIgnoreCase;
-function EndsWithIgnoreCase(col, value) {
-    return new simpleClause(col, `%${value}`, "ILIKE");
+function EndsWithIgnoreCase(col, value, overrideAlias) {
+    return new simpleClause(col, `%${value}`, "ILIKE", { overrideAlias });
 }
 exports.EndsWithIgnoreCase = EndsWithIgnoreCase;
-function ContainsIgnoreCase(col, value) {
-    return new simpleClause(col, `%${value}%`, "ILIKE");
+function ContainsIgnoreCase(col, value, overrideAlias) {
+    return new simpleClause(col, `%${value}%`, "ILIKE", {
+        overrideAlias,
+    });
 }
 exports.ContainsIgnoreCase = ContainsIgnoreCase;
-function NotEq(col, value) {
-    return new simpleClause(col, value, "!=", new isNotNullClause(col));
+function NotEq(col, value, overrideAlias) {
+    return new simpleClause(col, value, "!=", {
+        handleNull: new isNotNullClause(col),
+        overrideAlias,
+    });
 }
 exports.NotEq = NotEq;
-function Greater(col, value) {
-    return new simpleClause(col, value, ">");
+function Greater(col, value, overrideAlias) {
+    return new simpleClause(col, value, ">", {
+        overrideAlias,
+    });
 }
 exports.Greater = Greater;
-function Less(col, value) {
-    return new simpleClause(col, value, "<");
+function Less(col, value, overrideAlias) {
+    return new simpleClause(col, value, "<", { overrideAlias });
 }
 exports.Less = Less;
-function GreaterEq(col, value) {
-    return new simpleClause(col, value, ">=");
+function GreaterEq(col, value, overrideAlias) {
+    return new simpleClause(col, value, ">=", { overrideAlias });
 }
 exports.GreaterEq = GreaterEq;
-function LessEq(col, value) {
-    return new simpleClause(col, value, "<=");
+function LessEq(col, value, overrideAlias) {
+    return new simpleClause(col, value, "<=", { overrideAlias });
 }
 exports.LessEq = LessEq;
 function And(...args) {
@@ -647,44 +692,44 @@ function In(...args) {
     return new inClause(args[0], args.slice(1));
 }
 exports.In = In;
-function UuidIn(col, values) {
-    return new inClause(col, values, "uuid");
+function UuidIn(col, values, overrideAlias) {
+    return new inClause(col, values, "uuid", overrideAlias);
 }
 exports.UuidIn = UuidIn;
-function IntegerIn(col, values) {
-    return new inClause(col, values, "integer");
+function IntegerIn(col, values, overrideAlias) {
+    return new inClause(col, values, "integer", overrideAlias);
 }
 exports.IntegerIn = IntegerIn;
-function TextIn(col, values) {
-    return new inClause(col, values, "text");
+function TextIn(col, values, overrideAlias) {
+    return new inClause(col, values, "text", overrideAlias);
 }
 exports.TextIn = TextIn;
 /*
  * if not uuid or text, pass the db type that can be used to cast this query
  * if we end up with a large list of ids
  */
-function DBTypeIn(col, values, typ) {
-    return new inClause(col, values, typ);
+function DBTypeIn(col, values, typ, overrideAlias) {
+    return new inClause(col, values, typ, overrideAlias);
 }
 exports.DBTypeIn = DBTypeIn;
-function UuidNotIn(col, values) {
-    return new notInClause(col, values, "uuid");
+function UuidNotIn(col, values, overrideAlias) {
+    return new notInClause(col, values, "uuid", overrideAlias);
 }
 exports.UuidNotIn = UuidNotIn;
-function IntegerNotIn(col, values) {
-    return new notInClause(col, values, "integer");
+function IntegerNotIn(col, values, overrideAlias) {
+    return new notInClause(col, values, "integer", overrideAlias);
 }
 exports.IntegerNotIn = IntegerNotIn;
-function TextNotIn(col, values) {
-    return new notInClause(col, values, "text");
+function TextNotIn(col, values, overrideAlias) {
+    return new notInClause(col, values, "text", overrideAlias);
 }
 exports.TextNotIn = TextNotIn;
 /*
  * if not uuid or text, pass the db type that can be used to cast this query
  * if we end up with a large list of ids
  */
-function DBTypeNotIn(col, values, typ) {
-    return new notInClause(col, values, typ);
+function DBTypeNotIn(col, values, typ, overrideAlias) {
+    return new notInClause(col, values, typ, overrideAlias);
 }
 exports.DBTypeNotIn = DBTypeNotIn;
 // if string defaults to english
@@ -693,46 +738,55 @@ exports.DBTypeNotIn = DBTypeNotIn;
 // plainto_tsquery
 // phraseto_tsquery;
 // websearch_to_tsquery
-function TsQuery(col, val) {
-    return new tsQueryClause(col, val);
+function TsQuery(col, val, overrideAlias) {
+    return new tsQueryClause(col, val, { overrideAlias });
 }
 exports.TsQuery = TsQuery;
-function PlainToTsQuery(col, val) {
-    return new plainToTsQueryClause(col, val);
+function PlainToTsQuery(col, val, overrideAlias) {
+    return new plainToTsQueryClause(col, val, { overrideAlias });
 }
 exports.PlainToTsQuery = PlainToTsQuery;
-function PhraseToTsQuery(col, val) {
-    return new phraseToTsQueryClause(col, val);
+function PhraseToTsQuery(col, val, overrideAlias) {
+    return new phraseToTsQueryClause(col, val, { overrideAlias });
 }
 exports.PhraseToTsQuery = PhraseToTsQuery;
-function WebsearchToTsQuery(col, val) {
-    return new websearchTosQueryClause(col, val);
+function WebsearchToTsQuery(col, val, overrideAlias) {
+    return new websearchTosQueryClause(col, val, { overrideAlias });
 }
 exports.WebsearchToTsQuery = WebsearchToTsQuery;
 // TsVectorColTsQuery is used when the column is not a tsvector field e.g.
 // when there's an index just on the field and is not a combination of multiple fields
-function TsVectorColTsQuery(col, val) {
-    return new tsQueryClause(col, val, true);
+function TsVectorColTsQuery(col, val, overrideAlias) {
+    return new tsQueryClause(col, val, { tsVectorCol: true, overrideAlias });
 }
 exports.TsVectorColTsQuery = TsVectorColTsQuery;
 // TsVectorPlainToTsQuery is used when the column is not a tsvector field e.g.
 // when there's an index just on the field and is not a combination of multiple fields
 // TODO do these 4 need TsQuery because would be nice to have language?
 // it seems to default to the config of the column
-function TsVectorPlainToTsQuery(col, val) {
-    return new plainToTsQueryClause(col, val, true);
+function TsVectorPlainToTsQuery(col, val, overrideAlias) {
+    return new plainToTsQueryClause(col, val, {
+        tsVectorCol: true,
+        overrideAlias,
+    });
 }
 exports.TsVectorPlainToTsQuery = TsVectorPlainToTsQuery;
 // TsVectorPhraseToTsQuery is used when the column is not a tsvector field e.g.
 // when there's an index just on the field and is not a combination of multiple fields
-function TsVectorPhraseToTsQuery(col, val) {
-    return new phraseToTsQueryClause(col, val, true);
+function TsVectorPhraseToTsQuery(col, val, overrideAlias) {
+    return new phraseToTsQueryClause(col, val, {
+        tsVectorCol: true,
+        overrideAlias,
+    });
 }
 exports.TsVectorPhraseToTsQuery = TsVectorPhraseToTsQuery;
 // TsVectorWebsearchToTsQuery is used when the column is not a tsvector field e.g.
 // when there's an index just on the field and is not a combination of multiple fields
-function TsVectorWebsearchToTsQuery(col, val) {
-    return new websearchTosQueryClause(col, val, true);
+function TsVectorWebsearchToTsQuery(col, val, overrideAlias) {
+    return new websearchTosQueryClause(col, val, {
+        tsVectorCol: true,
+        overrideAlias,
+    });
 }
 exports.TsVectorWebsearchToTsQuery = TsVectorWebsearchToTsQuery;
 // TODO would be nice to support this with building blocks but not supporting for now
@@ -759,28 +813,29 @@ exports.sensitiveValue = sensitiveValue;
 // 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) {
+function JSONObjectFieldKeyASJSON(col, field, overrideAlias) {
     // type as keyof T to make it easier to use in other queries
-    return `${col}->'${field}'`;
+    return `${renderCol(col, overrideAlias)}->'${field}'`;
 }
 exports.JSONObjectFieldKeyASJSON = JSONObjectFieldKeyASJSON;
-function JSONObjectFieldKeyAsText(col, field) {
+function JSONObjectFieldKeyAsText(col, field, overrideAlias) {
     // type as keyof T to make it easier to use in other queries
-    return `${col}->>'${field}'`;
+    return `${renderCol(col, overrideAlias)}->>'${field}'`;
 }
 exports.JSONObjectFieldKeyAsText = JSONObjectFieldKeyAsText;
 class jSONPathValuePredicateClause {
-    constructor(col, path, value, pred) {
+    constructor(col, path, value, pred, overrideAlias) {
         this.col = col;
         this.path = path;
         this.value = value;
         this.pred = pred;
+        this.overrideAlias = overrideAlias;
     }
     clause(idx, alias) {
         if (db_1.default.getDialect() !== db_1.Dialect.Postgres) {
             throw new Error(`not supported`);
         }
-        return `${renderCol(this.col, alias)} @@ $${idx}`;
+        return `${renderCol(this.col, this.overrideAlias, alias)} @@ $${idx}`;
     }
     columns() {
         return [this.col];
@@ -801,22 +856,29 @@ class jSONPathValuePredicateClause {
         return [this.wrap(this.value)];
     }
     instanceKey() {
+        if (this.overrideAlias) {
+            return `${this.overrideAlias}.${this.col}${this.path}${rawValue(this.value)}${this.pred}`;
+        }
         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);
+function JSONPathValuePredicate(dbCol, path, val, pred, overrideAlias) {
+    return new jSONPathValuePredicateClause(dbCol, path, val, pred, overrideAlias);
 }
 exports.JSONPathValuePredicate = JSONPathValuePredicate;
-function JSONKeyExists(dbCol, val) {
-    return new simpleClause(dbCol, val, "?", new isNullClause(dbCol));
+function JSONKeyExists(dbCol, val, overrideAlias) {
+    return new simpleClause(dbCol, val, "?", {
+        // TODO ola: does isNullClause make sense here???
+        handleNull: new isNullClause(dbCol),
+        overrideAlias,
+    });
 }
 exports.JSONKeyExists = JSONKeyExists;
-function JSONBKeyInList(dbCol, jsonCol, val) {
+function JSONBKeyInList(dbCol, jsonCol, val, overrideAlias) {
     const opts = {
         fields: ["1"],
-        tableName: `jsonb_array_elements(${dbCol}) AS json_element`,
+        tableName: `jsonb_array_elements(${renderCol(dbCol, overrideAlias)}) AS json_element`,
         // @ts-ignore
         clause: And(JSONKeyExists("json_element", jsonCol), 
         // @ts-ignore
@@ -825,10 +887,10 @@ function JSONBKeyInList(dbCol, jsonCol, val) {
     return new existsQueryClause(opts);
 }
 exports.JSONBKeyInList = JSONBKeyInList;
-function JSONKeyInList(dbCol, jsonCol, val) {
+function JSONKeyInList(dbCol, jsonCol, val, overrideAlias) {
     const opts = {
         fields: ["1"],
-        tableName: `json_array_elements(${dbCol}) AS json_element`,
+        tableName: `json_array_elements(${renderCol(dbCol, overrideAlias)}) AS json_element`,
         // @ts-ignore
         clause: And(JSONKeyExists("json_element", jsonCol), 
         // @ts-ignore
@@ -840,22 +902,25 @@ exports.JSONKeyInList = JSONKeyInList;
 // 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) {
+    constructor(col, op, tableName, uniqueCol, val, overrideAlias) {
         this.col = col;
         this.op = op;
         this.tableName = tableName;
         this.uniqueCol = uniqueCol;
         this.val = val;
+        this.overrideAlias = overrideAlias;
     }
     buildSimpleQuery(clause, idx, alias) {
-        return `SELECT ${renderCol(this.col, alias)} FROM ${this.tableName} WHERE ${clause.clause(idx, alias)}`;
+        return `SELECT ${renderCol(this.col, this.overrideAlias, alias)} FROM ${this.tableName} WHERE ${clause.clause(idx, alias)}`;
     }
     clause(idx, alias) {
-        const eq1 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx, alias);
-        const eq2 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val), idx + 1, alias);
-        const op = new simpleClause(this.uniqueCol, this.val, this.op).clause(idx + 2, alias);
+        const eq1 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val, this.overrideAlias), idx, alias);
+        const eq2 = this.buildSimpleQuery(Eq(this.uniqueCol, this.val, this.overrideAlias), idx + 1, alias);
+        const op = new simpleClause(this.uniqueCol, this.val, this.op, {
+            overrideAlias: this.overrideAlias,
+        }).clause(idx + 2, alias);
         // nest in () to make sure it's scoped correctly
-        return `(${renderCol(this.col, alias)} ${this.op} (${eq1}) OR (${renderCol(this.col, alias)} = (${eq2}) AND ${op}))`;
+        return `(${renderCol(this.col, this.overrideAlias, alias)} ${this.op} (${eq1}) OR (${renderCol(this.col, this.overrideAlias, alias)} = (${eq2}) AND ${op}))`;
     }
     columns() {
         return [this.col];
@@ -868,32 +933,56 @@ class paginationMultipleColumnsSubQueryClause {
         return [log, log, log];
     }
     instanceKey() {
+        if (this.overrideAlias) {
+            return `${this.overrideAlias}.${this.col}-${this.op}-${this.tableName}-${this.overrideAlias}.${this.uniqueCol}-${this.val}`;
+        }
         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);
+function PaginationMultipleColsSubQuery(col, op, tableName, uniqueCol, val, overrideAlias) {
+    return new paginationMultipleColumnsSubQueryClause(col, op, tableName, uniqueCol, val, overrideAlias);
 }
 exports.PaginationMultipleColsSubQuery = PaginationMultipleColsSubQuery;
+function PaginationMultipleColsQuery(sortCol, cursorCol, less, // if true, <, if false, >
+sortValue, cursorValue, overrideAlias) {
+    const clauseFn = less ? Less : Greater;
+    return And(Or(clauseFn(sortCol, sortValue, overrideAlias), And(Eq(sortCol, sortValue, overrideAlias), clauseFn(cursorCol, cursorValue, overrideAlias))));
+}
+exports.PaginationMultipleColsQuery = PaginationMultipleColsQuery;
 // These 5 are used on the RHS of an expression
-function Add(col, value) {
-    return new simpleClause(col, value, "+", new isNullClause(col));
+function Add(col, value, overrideAlias) {
+    return new simpleClause(col, value, "+", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Add = Add;
-function Subtract(col, value) {
-    return new simpleClause(col, value, "-", new isNullClause(col));
+function Subtract(col, value, overrideAlias) {
+    return new simpleClause(col, value, "-", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Subtract = Subtract;
-function Multiply(col, value) {
-    return new simpleClause(col, value, "*", new isNullClause(col));
+function Multiply(col, value, overrideAlias) {
+    return new simpleClause(col, value, "*", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Multiply = Multiply;
-function Divide(col, value) {
-    return new simpleClause(col, value, "/", new isNullClause(col));
+function Divide(col, value, overrideAlias) {
+    return new simpleClause(col, value, "/", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Divide = Divide;
-function Modulo(col, value) {
-    return new simpleClause(col, value, "%", new isNullClause(col));
+function Modulo(col, value, overrideAlias) {
+    return new simpleClause(col, value, "%", {
+        handleNull: new isNullClause(col),
+        overrideAlias,
+    });
 }
 exports.Modulo = Modulo;
 function getCombinedClause(options, cls, checkIntersection = false) {