@snowtop/ent 0.1.0-alpha1 → 0.1.0-alpha100

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,10 +23,12 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sensitiveValue = exports.In = exports.Or = exports.And = exports.LessEq = exports.GreaterEq = exports.Less = exports.Greater = exports.NotEq = exports.Eq = void 0;
+exports.Modulo = exports.Divide = exports.Multiply = exports.Subtract = exports.Add = 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 (typeof val === "object" && val.logValue !== undefined);
+    return (val !== null &&
+        typeof val === "object" &&
+        val.logValue !== undefined);
 }
 function rawValue(val) {
     if (isSensitive(val)) {
@@ -31,17 +37,114 @@ function rawValue(val) {
     return val;
 }
 class simpleClause {
-    constructor(col, value, op) {
+    constructor(col, value, op, handleNull) {
         this.col = col;
         this.value = value;
         this.op = op;
+        this.handleNull = handleNull;
     }
     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} ?`;
     }
+    nullClause() {
+        if (!this.handleNull || this.value !== null) {
+            return;
+        }
+        return this.handleNull;
+    }
+    columns() {
+        return [this.col];
+    }
+    values() {
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.values();
+        }
+        if (isSensitive(this.value)) {
+            return [this.value.value()];
+        }
+        return [this.value];
+    }
+    logValues() {
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.logValues();
+        }
+        if (isSensitive(this.value)) {
+            return [this.value.logValue()];
+        }
+        return [this.value];
+    }
+    instanceKey() {
+        const nullClause = this.nullClause();
+        if (nullClause) {
+            return nullClause.instanceKey();
+        }
+        return `${this.col}${this.op}${rawValue(this.value)}`;
+    }
+}
+class isNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NULL`;
+    }
+    columns() {
+        return [];
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NULL`;
+    }
+}
+class isNotNullClause {
+    constructor(col) {
+        this.col = col;
+    }
+    clause(idx) {
+        return `${this.col} IS NOT NULL`;
+    }
+    columns() {
+        return [];
+    }
+    values() {
+        return [];
+    }
+    logValues() {
+        return [];
+    }
+    instanceKey() {
+        return `${this.col} IS NOT NULL`;
+    }
+}
+class arraySimpleClause {
+    constructor(col, value, op) {
+        this.col = col;
+        this.value = value;
+        this.op = op;
+    }
+    clause(idx) {
+        if (db_1.default.getDialect() === db_1.Dialect.Postgres) {
+            return `$${idx} ${this.op} ANY(${this.col})`;
+        }
+        return `${this.col} ${this.op} ?`;
+    }
+    columns() {
+        return [this.col];
+    }
     values() {
         if (isSensitive(this.value)) {
             return [this.value.value()];
@@ -58,18 +161,105 @@ class simpleClause {
         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) {
+    static getPostgresInClauseValuesThreshold() {
+        return 70;
+    }
+    constructor(col, value, type = "uuid") {
         this.col = col;
         this.value = value;
+        this.type = type;
     }
     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++;
             }
         }
@@ -77,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;
     }
@@ -112,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) {
@@ -141,16 +342,159 @@ 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);
     }
 }
+class tsQueryClause {
+    constructor(col, val, tsVectorCol) {
+        this.col = col;
+        this.val = val;
+        this.tsVectorCol = tsVectorCol;
+    }
+    isTsQuery(val) {
+        return typeof val !== "string";
+    }
+    getInfo() {
+        if (this.isTsQuery(this.val)) {
+            return { value: this.val.value, language: this.val.language };
+        }
+        return {
+            language: "english",
+            value: this.val,
+        };
+    }
+    clause(idx) {
+        const { language } = this.getInfo();
+        if (db_1.Dialect.Postgres === db_1.default.getDialect()) {
+            if (this.tsVectorCol) {
+                return `to_tsvector(${this.col}) @@ ${this.getFunction()}('${language}', $${idx})`;
+            }
+            return `${this.col} @@ ${this.getFunction()}('${language}', $${idx})`;
+        }
+        // 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];
+    }
+    logValues() {
+        const { value } = this.getInfo();
+        return [value];
+    }
+    getFunction() {
+        return "to_tsquery";
+    }
+    instanceKey() {
+        const { language, value } = this.getInfo();
+        if (this.tsVectorCol) {
+            return `to_tsvector(${this.col})@@${this.getFunction()}:${language}:${value}`;
+        }
+        return `${this.col}@@${this.getFunction()}:${language}:${value}`;
+    }
+}
+class plainToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "plainto_tsquery";
+    }
+}
+class phraseToTsQueryClause extends tsQueryClause {
+    getFunction() {
+        return "phraseto_tsquery";
+    }
+}
+class websearchTosQueryClause extends tsQueryClause {
+    getFunction() {
+        return "websearch_to_tsquery";
+    }
+}
+// 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 Eq(col, value) {
-    return new simpleClause(col, value, "=");
+    return new simpleClause(col, value, "=", new isNullClause(col));
 }
 exports.Eq = Eq;
 function NotEq(col, value) {
-    return new simpleClause(col, value, "!=");
+    return new simpleClause(col, value, "!=", new isNotNullClause(col));
 }
 exports.NotEq = NotEq;
 function Greater(col, value) {
@@ -173,15 +517,93 @@ function And(...args) {
     return new compositeClause(args, " AND ");
 }
 exports.And = And;
+function AndOptional(...args) {
+    // @ts-ignore
+    let filtered = args.filter((v) => v !== undefined);
+    if (filtered.length === 1) {
+        return filtered[0];
+    }
+    return And(...filtered);
+}
+exports.AndOptional = AndOptional;
 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
+// https://www.postgresql.org/docs/current/textsearch-controls.html#TEXTSEARCH-PARSING-QUERIES
+// to_tsquery
+// plainto_tsquery
+// phraseto_tsquery;
+// websearch_to_tsquery
+function TsQuery(col, val) {
+    return new tsQueryClause(col, val);
+}
+exports.TsQuery = TsQuery;
+function PlainToTsQuery(col, val) {
+    return new plainToTsQueryClause(col, val);
+}
+exports.PlainToTsQuery = PlainToTsQuery;
+function PhraseToTsQuery(col, val) {
+    return new phraseToTsQueryClause(col, val);
+}
+exports.PhraseToTsQuery = PhraseToTsQuery;
+function WebsearchToTsQuery(col, val) {
+    return new websearchTosQueryClause(col, val);
+}
+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);
+}
+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);
+}
+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);
+}
+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);
+}
+exports.TsVectorWebsearchToTsQuery = TsVectorWebsearchToTsQuery;
+// TODO would be nice to support this with building blocks but not supporting for now
+// AND: foo & bar,
+// OR: foo | bar
+// followed by: foo <-> bar
+// NOT: !foo
+// starts_with: theo:*
 // wrap a query in the db with this to ensure that it doesn't show up in the logs
 // e.g. if querying for password, SSN, etc
 // we'll pass the right fields to query and log something along the lines of `****`
@@ -196,3 +618,114 @@ 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;
+// These 5 are used on the RHS of an expression
+function Add(col, value) {
+    return new simpleClause(col, value, "+", new isNullClause(col));
+}
+exports.Add = Add;
+function Subtract(col, value) {
+    return new simpleClause(col, value, "-", new isNullClause(col));
+}
+exports.Subtract = Subtract;
+function Multiply(col, value) {
+    return new simpleClause(col, value, "*", new isNullClause(col));
+}
+exports.Multiply = Multiply;
+function Divide(col, value) {
+    return new simpleClause(col, value, "/", new isNullClause(col));
+}
+exports.Divide = Divide;
+function Modulo(col, value) {
+    return new simpleClause(col, value, "%", new isNullClause(col));
+}
+exports.Modulo = Modulo;