@budibase/backend-core 3.2.26 → 3.2.27

package/dist/src/sql/sql.js

@@ -1,1536 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = 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];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.COUNT_FIELD_NAME = void 0;
-const knex_1 = require("knex");
-const dbCore = __importStar(require("../db"));
-const utils_1 = require("./utils");
-const sqlTable_1 = __importDefault(require("./sqlTable"));
-const types_1 = require("@budibase/types");
-const environment_1 = __importDefault(require("../environment"));
-const shared_core_1 = require("@budibase/shared-core");
-const lodash_1 = require("lodash");
-exports.COUNT_FIELD_NAME = "__bb_total";
-function getBaseLimit() {
-    const envLimit = environment_1.default.SQL_MAX_ROWS
-        ? parseInt(environment_1.default.SQL_MAX_ROWS)
-        : null;
-    return envLimit || 5000;
-}
-function getRelationshipLimit() {
-    const envLimit = environment_1.default.SQL_MAX_RELATED_ROWS
-        ? parseInt(environment_1.default.SQL_MAX_RELATED_ROWS)
-        : null;
-    return envLimit || 500;
-}
-function prioritisedArraySort(toSort, priorities) {
-    return toSort.sort((a, b) => {
-        const aPriority = priorities.find(field => field && a.endsWith(field));
-        const bPriority = priorities.find(field => field && b.endsWith(field));
-        if (aPriority && !bPriority) {
-            return -1;
-        }
-        if (!aPriority && bPriority) {
-            return 1;
-        }
-        return a.localeCompare(b);
-    });
-}
-function convertBooleans(query) {
-    if (Array.isArray(query)) {
-        return query.map((q) => convertBooleans(q));
-    }
-    else {
-        if (query.bindings) {
-            query.bindings = query.bindings.map(binding => {
-                if (typeof binding === "boolean") {
-                    return binding ? 1 : 0;
-                }
-                return binding;
-            });
-        }
-    }
-    return query;
-}
-function isSqs(table) {
-    return (table.sourceType === types_1.TableSourceType.INTERNAL ||
-        table.sourceId === types_1.INTERNAL_TABLE_SOURCE_ID);
-}
-function escapeQuotes(value, quoteChar = '"') {
-    return value.replace(new RegExp(quoteChar, "g"), `${quoteChar}${quoteChar}`);
-}
-function wrap(value, quoteChar = '"') {
-    return `${quoteChar}${escapeQuotes(value, quoteChar)}${quoteChar}`;
-}
-function stringifyArray(value, quoteStyle = '"') {
-    for (let i in value) {
-        if (typeof value[i] === "string") {
-            value[i] = wrap(value[i], quoteStyle);
-        }
-    }
-    return `[${value.join(",")}]`;
-}
-const allowEmptyRelationships = {
-    [types_1.BasicOperator.EQUAL]: false,
-    [types_1.BasicOperator.NOT_EQUAL]: true,
-    [types_1.BasicOperator.EMPTY]: false,
-    [types_1.BasicOperator.NOT_EMPTY]: true,
-    [types_1.BasicOperator.FUZZY]: false,
-    [types_1.BasicOperator.STRING]: false,
-    [types_1.RangeOperator.RANGE]: false,
-    [types_1.ArrayOperator.CONTAINS]: false,
-    [types_1.ArrayOperator.NOT_CONTAINS]: true,
-    [types_1.ArrayOperator.CONTAINS_ANY]: false,
-    [types_1.ArrayOperator.ONE_OF]: false,
-    [types_1.LogicalOperator.AND]: false,
-    [types_1.LogicalOperator.OR]: false,
-};
-class InternalBuilder {
-    constructor(client, knex, query) {
-        var _a;
-        // states the various situations in which we need a full mapped select statement
-        this.SPECIAL_SELECT_CASES = {
-            POSTGRES_MONEY: (field) => {
-                var _a;
-                return (this.client === types_1.SqlClient.POSTGRES &&
-                    ((_a = field === null || field === void 0 ? void 0 : field.externalType) === null || _a === void 0 ? void 0 : _a.includes("money")));
-            },
-            MSSQL_DATES: (field) => {
-                return (this.client === types_1.SqlClient.MS_SQL &&
-                    (field === null || field === void 0 ? void 0 : field.type) === types_1.FieldType.DATETIME &&
-                    field.timeOnly);
-            },
-        };
-        this.client = client;
-        this.query = query;
-        this.knex = knex;
-        this.splitter = new shared_core_1.dataFilters.ColumnSplitter([this.table], {
-            aliases: this.query.tableAliases,
-            columnPrefix: (_a = this.query.meta) === null || _a === void 0 ? void 0 : _a.columnPrefix,
-        });
-    }
-    get table() {
-        return this.query.table;
-    }
-    get knexClient() {
-        return this.knex.client;
-    }
-    getFieldSchema(key) {
-        const { column } = this.splitter.run(key);
-        return this.table.schema[column];
-    }
-    quoteChars() {
-        const wrapped = this.knexClient.wrapIdentifier("foo", {});
-        return [wrapped[0], wrapped[wrapped.length - 1]];
-    }
-    // Takes a string like foo and returns a quoted string like [foo] for SQL
-    // Server and "foo" for Postgres.
-    quote(str) {
-        return this.knexClient.wrapIdentifier(str, {});
-    }
-    isQuoted(key) {
-        const [start, end] = this.quoteChars();
-        return key.startsWith(start) && key.endsWith(end);
-    }
-    // Takes a string like a.b.c or an array like ["a", "b", "c"] and returns a
-    // quoted identifier like [a].[b].[c] for SQL Server and `a`.`b`.`c` for
-    // MySQL.
-    quotedIdentifier(key) {
-        if (!Array.isArray(key)) {
-            key = this.splitIdentifier(key);
-        }
-        return key.map(part => this.quote(part)).join(".");
-    }
-    quotedValue(value) {
-        const formatter = this.knexClient.formatter(this.knexClient.queryBuilder());
-        return formatter.wrap(value, false);
-    }
-    castIntToString(identifier) {
-        switch (this.client) {
-            case types_1.SqlClient.ORACLE: {
-                return this.knex.raw("to_char(??)", [identifier]);
-            }
-            case types_1.SqlClient.POSTGRES: {
-                return this.knex.raw("??::TEXT", [identifier]);
-            }
-            case types_1.SqlClient.MY_SQL:
-            case types_1.SqlClient.MARIADB: {
-                return this.knex.raw("CAST(?? AS CHAR)", [identifier]);
-            }
-            case types_1.SqlClient.SQL_LITE: {
-                // Technically sqlite can actually represent numbers larger than a 64bit
-                // int as a string, but it does it using scientific notation (e.g.
-                // "1e+20") which is not what we want. Given that the external SQL
-                // databases are limited to supporting only 64bit ints, we settle for
-                // that here.
-                return this.knex.raw("printf('%d', ??)", [identifier]);
-            }
-            case types_1.SqlClient.MS_SQL: {
-                return this.knex.raw("CONVERT(NVARCHAR, ??)", [identifier]);
-            }
-        }
-    }
-    // Unfortuantely we cannot rely on knex's identifier escaping because it trims
-    // the identifier string before escaping it, which breaks cases for us where
-    // columns that start or end with a space aren't referenced correctly anymore.
-    //
-    // So whenever you're using an identifier binding in knex, e.g. knex.raw("??
-    // as ?", ["foo", "bar"]), you need to make sure you call this:
-    //
-    //   knex.raw("?? as ?", [this.quotedIdentifier("foo"), "bar"])
-    //
-    // Issue we filed against knex about this:
-    //   https://github.com/knex/knex/issues/6143
-    rawQuotedIdentifier(key) {
-        return this.knex.raw(this.quotedIdentifier(key));
-    }
-    // Turns an identifier like a.b.c or `a`.`b`.`c` into ["a", "b", "c"]
-    splitIdentifier(key) {
-        const [start, end] = this.quoteChars();
-        if (this.isQuoted(key)) {
-            return key.slice(1, -1).split(`${end}.${start}`);
-        }
-        return key.split(".");
-    }
-    qualifyIdentifier(key) {
-        const tableName = this.getTableName();
-        const parts = this.splitIdentifier(key);
-        if (parts[0] !== tableName) {
-            parts.unshift(tableName);
-        }
-        if (this.isQuoted(key)) {
-            return this.quotedIdentifier(parts);
-        }
-        return parts.join(".");
-    }
-    isFullSelectStatementRequired() {
-        for (let column of Object.values(this.table.schema)) {
-            if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(column)) {
-                return true;
-            }
-            else if (this.SPECIAL_SELECT_CASES.MSSQL_DATES(column)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    generateSelectStatement() {
-        const { table, resource } = this.query;
-        if (!resource || !resource.fields || resource.fields.length === 0) {
-            return "*";
-        }
-        const alias = this.getTableName(table);
-        const schema = this.table.schema;
-        if (!this.isFullSelectStatementRequired()) {
-            return [this.knex.raw("??", [`${alias}.*`])];
-        }
-        // get just the fields for this table
-        return resource.fields
-            .map(field => {
-            const parts = field.split(/\./g);
-            let table = undefined;
-            let column = parts[0];
-            // Just a column name, e.g.: "column"
-            if (parts.length > 1) {
-                table = parts[0];
-                column = parts.slice(1).join(".");
-            }
-            return { table, column, field };
-        })
-            .filter(({ table }) => !table || table === alias)
-            .map(({ table, column, field }) => {
-            const columnSchema = schema[column];
-            if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(columnSchema)) {
-                return this.knex.raw(`??::money::numeric as ??`, [
-                    this.rawQuotedIdentifier([table, column].join(".")),
-                    this.knex.raw(this.quote(field)),
-                ]);
-            }
-            if (this.SPECIAL_SELECT_CASES.MSSQL_DATES(columnSchema)) {
-                // Time gets returned as timestamp from mssql, not matching the expected
-                // HH:mm format
-                // TODO: figure out how to express this safely without string
-                // interpolation.
-                return this.knex.raw(`CONVERT(varchar, ??, 108) as ??`, [
-                    this.rawQuotedIdentifier(field),
-                    this.knex.raw(this.quote(field)),
-                ]);
-            }
-            if (table) {
-                return this.rawQuotedIdentifier(`${table}.${column}`);
-            }
-            else {
-                return this.rawQuotedIdentifier(field);
-            }
-        });
-    }
-    // OracleDB can't use character-large-objects (CLOBs) in WHERE clauses,
-    // so when we use them we need to wrap them in to_char(). This function
-    // converts a field name to the appropriate identifier.
-    convertClobs(field, opts) {
-        if (this.client !== types_1.SqlClient.ORACLE) {
-            throw new Error("you've called convertClobs on a DB that's not Oracle, this is a mistake");
-        }
-        const parts = this.splitIdentifier(field);
-        const col = parts.pop();
-        const schema = this.table.schema[col];
-        let identifier = this.rawQuotedIdentifier(field);
-        if (schema.type === types_1.FieldType.STRING ||
-            schema.type === types_1.FieldType.LONGFORM ||
-            schema.type === types_1.FieldType.BB_REFERENCE_SINGLE ||
-            schema.type === types_1.FieldType.BB_REFERENCE ||
-            schema.type === types_1.FieldType.OPTIONS ||
-            schema.type === types_1.FieldType.BARCODEQR) {
-            if (opts === null || opts === void 0 ? void 0 : opts.forSelect) {
-                identifier = this.knex.raw("to_char(??) as ??", [
-                    identifier,
-                    this.rawQuotedIdentifier(col),
-                ]);
-            }
-            else {
-                identifier = this.knex.raw("to_char(??)", [identifier]);
-            }
-        }
-        return identifier;
-    }
-    parse(input, schema) {
-        if (Array.isArray(input)) {
-            return JSON.stringify(input);
-        }
-        if (input == undefined) {
-            return null;
-        }
-        if (this.client === types_1.SqlClient.ORACLE &&
-            schema.type === types_1.FieldType.DATETIME &&
-            schema.timeOnly) {
-            if (input instanceof Date) {
-                const hours = input.getHours().toString().padStart(2, "0");
-                const minutes = input.getMinutes().toString().padStart(2, "0");
-                const seconds = input.getSeconds().toString().padStart(2, "0");
-                return `${hours}:${minutes}:${seconds}`;
-            }
-            if (typeof input === "string") {
-                return new Date(`1970-01-01T${input}Z`);
-            }
-        }
-        if (typeof input === "string") {
-            if ((0, utils_1.isInvalidISODateString)(input)) {
-                return null;
-            }
-            if ((0, utils_1.isValidISODateString)(input)) {
-                return new Date(input.trim());
-            }
-        }
-        return input;
-    }
-    parseBody(body) {
-        for (let [key, value] of Object.entries(body)) {
-            const { column } = this.splitter.run(key);
-            const schema = this.table.schema[column];
-            if (!schema) {
-                continue;
-            }
-            body[key] = this.parse(value, schema);
-        }
-        return body;
-    }
-    parseFilters(filters) {
-        filters = (0, lodash_1.cloneDeep)(filters);
-        for (const op of Object.values(types_1.BasicOperator)) {
-            const filter = filters[op];
-            if (!filter) {
-                continue;
-            }
-            for (const key of Object.keys(filter)) {
-                if (Array.isArray(filter[key])) {
-                    filter[key] = JSON.stringify(filter[key]);
-                    continue;
-                }
-                const { column } = this.splitter.run(key);
-                const schema = this.table.schema[column];
-                if (!schema) {
-                    continue;
-                }
-                filter[key] = this.parse(filter[key], schema);
-            }
-        }
-        for (const op of Object.values(types_1.ArrayOperator)) {
-            const filter = filters[op];
-            if (!filter) {
-                continue;
-            }
-            for (const key of Object.keys(filter)) {
-                const { column } = this.splitter.run(key);
-                const schema = this.table.schema[column];
-                if (!schema) {
-                    continue;
-                }
-                filter[key] = filter[key].map(v => this.parse(v, schema));
-            }
-        }
-        for (const op of Object.values(types_1.RangeOperator)) {
-            const filter = filters[op];
-            if (!filter) {
-                continue;
-            }
-            for (const key of Object.keys(filter)) {
-                const { column } = this.splitter.run(key);
-                const schema = this.table.schema[column];
-                if (!schema) {
-                    continue;
-                }
-                const value = filter[key];
-                if ("low" in value) {
-                    value.low = this.parse(value.low, schema);
-                }
-                if ("high" in value) {
-                    value.high = this.parse(value.high, schema);
-                }
-            }
-        }
-        return filters;
-    }
-    addJoinFieldCheck(query, relationship) {
-        var _a;
-        const document = ((_a = relationship.from) === null || _a === void 0 ? void 0 : _a.split(".")[0]) || "";
-        return query.andWhere(`${document}.fieldName`, "=", relationship.column);
-    }
-    addRelationshipForFilter(query, allowEmptyRelationships, filterKey, whereCb) {
-        const { relationships, schema, tableAliases: aliases, table } = this.query;
-        const fromAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[table.name]) || table.name;
-        const matches = (value) => filterKey.match(new RegExp(`^${value}\\.`));
-        if (!relationships) {
-            return query;
-        }
-        for (const relationship of relationships) {
-            const relatedTableName = relationship.tableName;
-            const toAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[relatedTableName]) || relatedTableName;
-            const matchesTableName = matches(relatedTableName) || matches(toAlias);
-            const matchesRelationName = matches(relationship.column);
-            // this is the relationship which is being filtered
-            if ((matchesTableName || matchesRelationName) &&
-                relationship.to &&
-                relationship.tableName) {
-                const joinTable = this.knex
-                    .select(this.knex.raw(1))
-                    .from({ [toAlias]: relatedTableName });
-                let subQuery = joinTable.clone();
-                const manyToMany = (0, utils_1.validateManyToMany)(relationship);
-                let updatedKey;
-                if (!matchesTableName) {
-                    updatedKey = filterKey.replace(new RegExp(`^${relationship.column}.`), `${(aliases === null || aliases === void 0 ? void 0 : aliases[relationship.tableName]) || relationship.tableName}.`);
-                }
-                else {
-                    updatedKey = filterKey;
-                }
-                if (manyToMany) {
-                    const throughAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[manyToMany.through]) || relationship.through;
-                    let throughTable = this.tableNameWithSchema(manyToMany.through, {
-                        alias: throughAlias,
-                        schema,
-                    });
-                    subQuery = subQuery
-                        // add a join through the junction table
-                        .innerJoin(throughTable, function () {
-                        this.on(`${toAlias}.${manyToMany.toPrimary}`, "=", `${throughAlias}.${manyToMany.to}`);
-                    })
-                        // check the document in the junction table points to the main table
-                        .where(`${throughAlias}.${manyToMany.from}`, "=", this.rawQuotedIdentifier(`${fromAlias}.${manyToMany.fromPrimary}`));
-                    // in SQS the same junction table is used for different many-to-many relationships between the
-                    // two same tables, this is needed to avoid rows ending up in all columns
-                    if (this.client === types_1.SqlClient.SQL_LITE) {
-                        subQuery = this.addJoinFieldCheck(subQuery, manyToMany);
-                    }
-                    query = query.where(q => {
-                        q.whereExists(whereCb(updatedKey, subQuery));
-                        if (allowEmptyRelationships) {
-                            q.orWhereNotExists(joinTable.clone().innerJoin(throughTable, function () {
-                                this.on(`${fromAlias}.${manyToMany.fromPrimary}`, "=", `${throughAlias}.${manyToMany.from}`);
-                            }));
-                        }
-                    });
-                }
-                else {
-                    const toKey = `${toAlias}.${relationship.to}`;
-                    const foreignKey = `${fromAlias}.${relationship.from}`;
-                    // "join" to the main table, making sure the ID matches that of the main
-                    subQuery = subQuery.where(toKey, "=", this.rawQuotedIdentifier(foreignKey));
-                    query = query.where(q => {
-                        q.whereExists(whereCb(updatedKey, subQuery.clone()));
-                        if (allowEmptyRelationships) {
-                            q.orWhereNotExists(subQuery);
-                        }
-                    });
-                }
-            }
-        }
-        return query;
-    }
-    // right now we only do filters on the specific table being queried
-    addFilters(query, filters, opts) {
-        if (!filters) {
-            return query;
-        }
-        const builder = this;
-        filters = this.parseFilters(Object.assign({}, filters));
-        const aliases = this.query.tableAliases;
-        // if all or specified in filters, then everything is an or
-        const shouldOr = filters.allOr;
-        const isSqlite = this.client === types_1.SqlClient.SQL_LITE;
-        const tableName = isSqlite ? this.table._id : this.table.name;
-        function getTableAlias(name) {
-            const alias = aliases === null || aliases === void 0 ? void 0 : aliases[name];
-            return alias || name;
-        }
-        function iterate(structure, operation, fn, complexKeyFn) {
-            const handleRelationship = (q, key, value) => {
-                const [filterTableName, ...otherProperties] = key.split(".");
-                const property = otherProperties.join(".");
-                const alias = getTableAlias(filterTableName);
-                return q.andWhere(subquery => fn(subquery, alias ? `${alias}.${property}` : property, value));
-            };
-            for (const key in structure) {
-                const value = structure[key];
-                const updatedKey = dbCore.removeKeyNumbering(key);
-                const isRelationshipField = updatedKey.includes(".");
-                const shouldProcessRelationship = (opts === null || opts === void 0 ? void 0 : opts.relationship) && isRelationshipField;
-                let castedTypeValue;
-                if (key === types_1.InternalSearchFilterOperator.COMPLEX_ID_OPERATOR &&
-                    (castedTypeValue = structure[key]) &&
-                    complexKeyFn) {
-                    const alias = getTableAlias(tableName);
-                    query = complexKeyFn(query, castedTypeValue.id.map((x) => alias ? `${alias}.${x}` : x), castedTypeValue.values);
-                }
-                else if (!isRelationshipField) {
-                    const alias = getTableAlias(tableName);
-                    query = fn(query, alias ? `${alias}.${updatedKey}` : updatedKey, value);
-                }
-                else if (shouldProcessRelationship) {
-                    if (shouldOr) {
-                        query = query.or;
-                    }
-                    query = builder.addRelationshipForFilter(query, allowEmptyRelationships[operation], updatedKey, (updatedKey, q) => {
-                        return handleRelationship(q, updatedKey, value);
-                    });
-                }
-            }
-        }
-        const like = (q, key, value) => {
-            if ((filters === null || filters === void 0 ? void 0 : filters.fuzzyOr) || shouldOr) {
-                q = q.or;
-            }
-            if (this.client === types_1.SqlClient.ORACLE ||
-                this.client === types_1.SqlClient.SQL_LITE) {
-                return q.whereRaw(`LOWER(??) LIKE ?`, [
-                    this.rawQuotedIdentifier(key),
-                    `%${value.toLowerCase()}%`,
-                ]);
-            }
-            return q.whereILike(
-            // @ts-expect-error knex types are wrong, raw is fine here
-            this.rawQuotedIdentifier(key), this.knex.raw("?", [`%${value}%`]));
-        };
-        const contains = (mode, any = false) => {
-            function addModifiers(q) {
-                if (shouldOr || mode === (filters === null || filters === void 0 ? void 0 : filters.containsAny)) {
-                    q = q.or;
-                }
-                if (mode === (filters === null || filters === void 0 ? void 0 : filters.notContains)) {
-                    q = q.not;
-                }
-                return q;
-            }
-            if (this.client === types_1.SqlClient.POSTGRES) {
-                iterate(mode, types_1.ArrayOperator.CONTAINS, (q, key, value) => {
-                    q = addModifiers(q);
-                    if (any) {
-                        return q.whereRaw(`COALESCE(??::jsonb \\?| array??, FALSE)`, [
-                            this.rawQuotedIdentifier(key),
-                            this.knex.raw(stringifyArray(value, "'")),
-                        ]);
-                    }
-                    else {
-                        return q.whereRaw(`COALESCE(??::jsonb @> '??', FALSE)`, [
-                            this.rawQuotedIdentifier(key),
-                            this.knex.raw(stringifyArray(value)),
-                        ]);
-                    }
-                });
-            }
-            else if (this.client === types_1.SqlClient.MY_SQL ||
-                this.client === types_1.SqlClient.MARIADB) {
-                iterate(mode, types_1.ArrayOperator.CONTAINS, (q, key, value) => {
-                    return addModifiers(q).whereRaw(`COALESCE(?(??, ?), FALSE)`, [
-                        this.knex.raw(any ? "JSON_OVERLAPS" : "JSON_CONTAINS"),
-                        this.rawQuotedIdentifier(key),
-                        this.knex.raw(wrap(stringifyArray(value))),
-                    ]);
-                });
-            }
-            else {
-                iterate(mode, types_1.ArrayOperator.CONTAINS, (q, key, value) => {
-                    if (value.length === 0) {
-                        return q;
-                    }
-                    q = q.where(subQuery => {
-                        if (mode === (filters === null || filters === void 0 ? void 0 : filters.notContains)) {
-                            subQuery = subQuery.not;
-                        }
-                        subQuery = subQuery.where(subSubQuery => {
-                            for (const elem of value) {
-                                if (mode === (filters === null || filters === void 0 ? void 0 : filters.containsAny)) {
-                                    subSubQuery = subSubQuery.or;
-                                }
-                                else {
-                                    subSubQuery = subSubQuery.and;
-                                }
-                                const lower = typeof elem === "string" ? `"${elem.toLowerCase()}"` : elem;
-                                subSubQuery = subSubQuery.whereLike(
-                                // @ts-expect-error knex types are wrong, raw is fine here
-                                this.knex.raw(`COALESCE(LOWER(??), '')`, [
-                                    this.rawQuotedIdentifier(key),
-                                ]), `%${lower}%`);
-                            }
-                        });
-                        if (mode === (filters === null || filters === void 0 ? void 0 : filters.notContains)) {
-                            subQuery = subQuery.or.whereNull(
-                            // @ts-expect-error knex types are wrong, raw is fine here
-                            this.rawQuotedIdentifier(key));
-                        }
-                        return subQuery;
-                    });
-                    return q;
-                });
-            }
-        };
-        if (filters.$and) {
-            const { $and } = filters;
-            for (const condition of $and.conditions) {
-                query = query.where(b => {
-                    this.addFilters(b, condition, opts);
-                });
-            }
-        }
-        if (filters.$or) {
-            const { $or } = filters;
-            query = query.where(b => {
-                for (const condition of $or.conditions) {
-                    b.orWhere(c => this.addFilters(c, Object.assign(Object.assign({}, condition), { allOr: true }), opts));
-                }
-            });
-        }
-        if (filters.oneOf) {
-            iterate(filters.oneOf, types_1.ArrayOperator.ONE_OF, (q, key, array) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (this.client === types_1.SqlClient.ORACLE) {
-                    // @ts-ignore
-                    key = this.convertClobs(key);
-                }
-                return q.whereIn(key, Array.isArray(array) ? array : [array]);
-            }, (q, key, array) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (this.client === types_1.SqlClient.ORACLE) {
-                    // @ts-ignore
-                    key = key.map(k => this.convertClobs(k));
-                }
-                return q.whereIn(key, Array.isArray(array) ? array : [array]);
-            });
-        }
-        if (filters.string) {
-            iterate(filters.string, types_1.BasicOperator.STRING, (q, key, value) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (this.client === types_1.SqlClient.ORACLE ||
-                    this.client === types_1.SqlClient.SQL_LITE) {
-                    return q.whereRaw(`LOWER(??) LIKE ?`, [
-                        this.rawQuotedIdentifier(key),
-                        `${value.toLowerCase()}%`,
-                    ]);
-                }
-                else {
-                    return q.whereILike(key, `${value}%`);
-                }
-            });
-        }
-        if (filters.fuzzy) {
-            iterate(filters.fuzzy, types_1.BasicOperator.FUZZY, like);
-        }
-        if (filters.range) {
-            iterate(filters.range, types_1.RangeOperator.RANGE, (q, key, value) => {
-                const isEmptyObject = (val) => {
-                    return (val &&
-                        Object.keys(val).length === 0 &&
-                        Object.getPrototypeOf(val) === Object.prototype);
-                };
-                if (isEmptyObject(value.low)) {
-                    value.low = "";
-                }
-                if (isEmptyObject(value.high)) {
-                    value.high = "";
-                }
-                const lowValid = (0, utils_1.isValidFilter)(value.low), highValid = (0, utils_1.isValidFilter)(value.high);
-                const schema = this.getFieldSchema(key);
-                let rawKey = key;
-                let high = value.high;
-                let low = value.low;
-                if (this.client === types_1.SqlClient.ORACLE) {
-                    rawKey = this.convertClobs(key);
-                }
-                else if (this.client === types_1.SqlClient.SQL_LITE &&
-                    (schema === null || schema === void 0 ? void 0 : schema.type) === types_1.FieldType.BIGINT) {
-                    rawKey = this.knex.raw("CAST(?? AS INTEGER)", [
-                        this.rawQuotedIdentifier(key),
-                    ]);
-                    high = this.knex.raw("CAST(? AS INTEGER)", [value.high]);
-                    low = this.knex.raw("CAST(? AS INTEGER)", [value.low]);
-                }
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (lowValid && highValid) {
-                    // @ts-expect-error knex types are wrong, raw is fine here
-                    return q.whereBetween(rawKey, [low, high]);
-                }
-                else if (lowValid) {
-                    // @ts-expect-error knex types are wrong, raw is fine here
-                    return q.where(rawKey, ">=", low);
-                }
-                else if (highValid) {
-                    // @ts-expect-error knex types are wrong, raw is fine here
-                    return q.where(rawKey, "<=", high);
-                }
-                return q;
-            });
-        }
-        if (filters.equal) {
-            iterate(filters.equal, types_1.BasicOperator.EQUAL, (q, key, value) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (this.client === types_1.SqlClient.MS_SQL) {
-                    return q.whereRaw(`CASE WHEN ?? = ? THEN 1 ELSE 0 END = 1`, [
-                        this.rawQuotedIdentifier(key),
-                        value,
-                    ]);
-                }
-                else if (this.client === types_1.SqlClient.ORACLE) {
-                    const identifier = this.convertClobs(key);
-                    return q.where(subq => 
-                    // @ts-expect-error knex types are wrong, raw is fine here
-                    subq.whereNotNull(identifier).andWhere(identifier, value));
-                }
-                else {
-                    return q.whereRaw(`COALESCE(?? = ?, FALSE)`, [
-                        this.rawQuotedIdentifier(key),
-                        value,
-                    ]);
-                }
-            });
-        }
-        if (filters.notEqual) {
-            iterate(filters.notEqual, types_1.BasicOperator.NOT_EQUAL, (q, key, value) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                if (this.client === types_1.SqlClient.MS_SQL) {
-                    return q.whereRaw(`CASE WHEN ?? = ? THEN 1 ELSE 0 END = 0`, [
-                        this.rawQuotedIdentifier(key),
-                        value,
-                    ]);
-                }
-                else if (this.client === types_1.SqlClient.ORACLE) {
-                    const identifier = this.convertClobs(key);
-                    return (q
-                        .where(subq => subq.not
-                        // @ts-expect-error knex types are wrong, raw is fine here
-                        .whereNull(identifier)
-                        .and.where(identifier, "!=", value))
-                        // @ts-expect-error knex types are wrong, raw is fine here
-                        .or.whereNull(identifier));
-                }
-                else {
-                    return q.whereRaw(`COALESCE(?? != ?, TRUE)`, [
-                        this.rawQuotedIdentifier(key),
-                        value,
-                    ]);
-                }
-            });
-        }
-        if (filters.empty) {
-            iterate(filters.empty, types_1.BasicOperator.EMPTY, (q, key) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                return q.whereNull(key);
-            });
-        }
-        if (filters.notEmpty) {
-            iterate(filters.notEmpty, types_1.BasicOperator.NOT_EMPTY, (q, key) => {
-                if (shouldOr) {
-                    q = q.or;
-                }
-                return q.whereNotNull(key);
-            });
-        }
-        if (filters.contains) {
-            contains(filters.contains);
-        }
-        if (filters.notContains) {
-            contains(filters.notContains);
-        }
-        if (filters.containsAny) {
-            contains(filters.containsAny, true);
-        }
-        const tableRef = (aliases === null || aliases === void 0 ? void 0 : aliases[this.table._id]) || this.table._id;
-        // when searching internal tables make sure long looking for rows
-        if (filters.documentType && !(0, utils_1.isExternalTable)(this.table) && tableRef) {
-            // has to be its own option, must always be AND onto the search
-            query.andWhereLike(`${tableRef}._id`, `${(0, types_1.prefixed)(filters.documentType)}%`);
-        }
-        return query;
-    }
-    isSqs() {
-        return isSqs(this.table);
-    }
-    getTableName(table) {
-        if (!table) {
-            table = this.table;
-        }
-        let name = table.name;
-        if (isSqs(table) && table._id) {
-            // SQS uses the table ID rather than the table name
-            name = table._id;
-        }
-        const aliases = this.query.tableAliases || {};
-        return aliases[name] ? aliases[name] : name;
-    }
-    addDistinctCount(query) {
-        if (!this.table.primary) {
-            throw new Error("SQL counting requires primary key to be supplied");
-        }
-        return query.countDistinct(`${this.getTableName()}.${this.table.primary[0]} as ${exports.COUNT_FIELD_NAME}`);
-    }
-    addAggregations(query, aggregations) {
-        var _a;
-        const fields = ((_a = this.query.resource) === null || _a === void 0 ? void 0 : _a.fields) || [];
-        const tableName = this.getTableName();
-        if (fields.length > 0) {
-            const qualifiedFields = fields.map(field => this.qualifyIdentifier(field));
-            if (this.client === types_1.SqlClient.ORACLE) {
-                const groupByFields = qualifiedFields.map(field => this.convertClobs(field));
-                const selectFields = qualifiedFields.map(field => this.convertClobs(field, { forSelect: true }));
-                query = query.groupBy(groupByFields).select(selectFields);
-            }
-            else {
-                query = query.groupBy(qualifiedFields).select(qualifiedFields);
-            }
-        }
-        for (const aggregation of aggregations) {
-            const op = aggregation.calculationType;
-            if (op === types_1.CalculationType.COUNT) {
-                if ("distinct" in aggregation && aggregation.distinct) {
-                    if (this.client === types_1.SqlClient.ORACLE) {
-                        const field = this.convertClobs(`${tableName}.${aggregation.field}`);
-                        query = query.select(this.knex.raw(`COUNT(DISTINCT ??) as ??`, [
-                            field,
-                            aggregation.name,
-                        ]));
-                    }
-                    else {
-                        query = query.countDistinct(`${tableName}.${aggregation.field} as ${aggregation.name}`);
-                    }
-                }
-                else {
-                    if (this.client === types_1.SqlClient.ORACLE) {
-                        const field = this.convertClobs(`${tableName}.${aggregation.field}`);
-                        query = query.select(this.knex.raw(`COUNT(??) as ??`, [field, aggregation.name]));
-                    }
-                    else {
-                        query = query.count(`${aggregation.field} as ${aggregation.name}`);
-                    }
-                }
-            }
-            else {
-                const fieldSchema = this.getFieldSchema(aggregation.field);
-                if (!fieldSchema) {
-                    // This should not happen in practice.
-                    throw new Error(`field schema missing for aggregation target: ${aggregation.field}`);
-                }
-                let aggregate = this.knex.raw("??(??)", [
-                    this.knex.raw(op),
-                    this.rawQuotedIdentifier(`${tableName}.${aggregation.field}`),
-                ]);
-                if (fieldSchema.type === types_1.FieldType.BIGINT) {
-                    aggregate = this.castIntToString(aggregate);
-                }
-                query = query.select(this.knex.raw("?? as ??", [aggregate, aggregation.name]));
-            }
-        }
-        return query;
-    }
-    isAggregateField(field) {
-        var _a, _b;
-        const found = (_b = (_a = this.query.resource) === null || _a === void 0 ? void 0 : _a.aggregations) === null || _b === void 0 ? void 0 : _b.find(aggregation => aggregation.name === field);
-        return !!found;
-    }
-    addSorting(query) {
-        var _a, _b;
-        let { sort, resource } = this.query;
-        const primaryKey = this.table.primary;
-        const aliased = this.getTableName();
-        if (!Array.isArray(primaryKey)) {
-            throw new Error("Sorting requires primary key to be specified for table");
-        }
-        if (sort && Object.keys(sort || {}).length > 0) {
-            for (let [key, value] of Object.entries(sort)) {
-                const direction = value.direction === types_1.SortOrder.ASCENDING ? "asc" : "desc";
-                // TODO: figure out a way to remove this conditional, not relying on
-                // the defaults of each datastore.
-                let nulls = undefined;
-                if (this.client === types_1.SqlClient.POSTGRES ||
-                    this.client === types_1.SqlClient.ORACLE) {
-                    nulls = value.direction === types_1.SortOrder.ASCENDING ? "first" : "last";
-                }
-                if (this.isAggregateField(key)) {
-                    query = query.orderBy(key, direction, nulls);
-                }
-                else {
-                    let composite = `${aliased}.${key}`;
-                    if (this.client === types_1.SqlClient.ORACLE) {
-                        query = query.orderByRaw(`?? ?? nulls ??`, [
-                            this.convertClobs(composite),
-                            this.knex.raw(direction),
-                            this.knex.raw(nulls),
-                        ]);
-                    }
-                    else {
-                        query = query.orderBy(composite, direction, nulls);
-                    }
-                }
-            }
-        }
-        // add sorting by the primary key if the result isn't already sorted by it,
-        // to make sure result is deterministic
-        const hasAggregations = ((_b = (_a = resource === null || resource === void 0 ? void 0 : resource.aggregations) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0;
-        if (!hasAggregations && (!sort || sort[primaryKey[0]] === undefined)) {
-            query = query.orderBy(`${aliased}.${primaryKey[0]}`);
-        }
-        return query;
-    }
-    tableNameWithSchema(tableName, opts) {
-        let withSchema = (opts === null || opts === void 0 ? void 0 : opts.schema) ? `${opts.schema}.${tableName}` : tableName;
-        if (opts === null || opts === void 0 ? void 0 : opts.alias) {
-            withSchema += ` as ${opts.alias}`;
-        }
-        return withSchema;
-    }
-    buildJsonField(table, field) {
-        var _a;
-        const parts = field.split(".");
-        let baseName = parts[parts.length - 1];
-        let unaliased;
-        let tableField;
-        if (parts.length > 1) {
-            const alias = parts.shift();
-            unaliased = parts.join(".");
-            tableField = `${alias}.${unaliased}`;
-        }
-        else {
-            unaliased = parts.join(".");
-            tableField = unaliased;
-        }
-        if ((_a = this.query.meta) === null || _a === void 0 ? void 0 : _a.columnPrefix) {
-            baseName = baseName.replace(this.query.meta.columnPrefix, "");
-        }
-        let identifier = this.rawQuotedIdentifier(tableField);
-        // Internal tables have special _id, _rev, createdAt, and updatedAt fields
-        // that do not appear in the schema, meaning schema could actually be
-        // undefined.
-        const schema = table.schema[baseName];
-        if (schema && schema.type === types_1.FieldType.BIGINT) {
-            identifier = this.castIntToString(identifier);
-        }
-        return [unaliased, identifier];
-    }
-    maxFunctionParameters() {
-        // functions like say json_build_object() in SQL have a limit as to how many can be performed
-        // before a limit is met, this limit exists in Postgres/SQLite. This can be very important, such as
-        // for JSON column building as part of relationships. We also have a default limit to avoid very complex
-        // functions being built - it is likely this is not necessary or the best way to do it.
-        switch (this.client) {
-            case types_1.SqlClient.SQL_LITE:
-                return 127;
-            case types_1.SqlClient.POSTGRES:
-                return 100;
-            // other DBs don't have a limit, but set some sort of limit
-            default:
-                return 200;
-        }
-    }
-    addJsonRelationships(query, fromTable, relationships) {
-        const sqlClient = this.client;
-        const knex = this.knex;
-        const { resource, tableAliases: aliases, schema, tables } = this.query;
-        const fields = (resource === null || resource === void 0 ? void 0 : resource.fields) || [];
-        for (let relationship of relationships) {
-            const { tableName: toTable, through: throughTable, to: toKey, from: fromKey, fromPrimary, toPrimary, } = relationship;
-            // skip invalid relationships
-            if (!toTable || !fromTable) {
-                continue;
-            }
-            const relatedTable = tables[toTable];
-            if (!relatedTable) {
-                throw new Error(`related table "${toTable}" not found in datasource`);
-            }
-            const toAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[toTable]) || toTable, fromAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[fromTable]) || fromTable, throughAlias = (throughTable && (aliases === null || aliases === void 0 ? void 0 : aliases[throughTable])) || throughTable;
-            let toTableWithSchema = this.tableNameWithSchema(toTable, {
-                alias: toAlias,
-                schema,
-            });
-            const requiredFields = [
-                ...((relatedTable === null || relatedTable === void 0 ? void 0 : relatedTable.primary) || []),
-                relatedTable === null || relatedTable === void 0 ? void 0 : relatedTable.primaryDisplay,
-            ].filter(field => field);
-            // sort the required fields to first in the list, so they don't get sliced out
-            let relationshipFields = prioritisedArraySort(fields.filter(field => field.split(".")[0] === toAlias), requiredFields);
-            relationshipFields = relationshipFields.slice(0, Math.floor(this.maxFunctionParameters() / 2));
-            const fieldList = relationshipFields.map(field => this.buildJsonField(relatedTable, field));
-            const fieldListFormatted = fieldList
-                .map(f => {
-                const separator = this.client === types_1.SqlClient.ORACLE ? " VALUE " : ",";
-                return this.knex.raw(`?${separator}??`, [f[0], f[1]]).toString();
-            })
-                .join(",");
-            // SQL Server uses TOP - which performs a little differently to the normal LIMIT syntax
-            // it reduces the result set rather than limiting how much data it filters over
-            const primaryKey = `${toAlias}.${toPrimary || toKey}`;
-            let subQuery = knex
-                .from(toTableWithSchema)
-                // add sorting to get consistent order
-                .orderBy(primaryKey);
-            const isManyToMany = throughTable && toPrimary && fromPrimary;
-            let correlatedTo = isManyToMany
-                ? `${throughAlias}.${fromKey}`
-                : `${toAlias}.${toKey}`, correlatedFrom = isManyToMany
-                ? `${fromAlias}.${fromPrimary}`
-                : `${fromAlias}.${fromKey}`;
-            // many-to-many relationship needs junction table join
-            if (isManyToMany) {
-                let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
-                    alias: throughAlias,
-                    schema,
-                });
-                subQuery = subQuery.join(throughTableWithSchema, function () {
-                    this.on(`${toAlias}.${toPrimary}`, "=", `${throughAlias}.${toKey}`);
-                });
-            }
-            // add the correlation to the overall query
-            subQuery = subQuery.where(correlatedTo, "=", this.rawQuotedIdentifier(correlatedFrom));
-            const standardWrap = (select) => {
-                subQuery = subQuery.select(`${toAlias}.*`).limit(getRelationshipLimit());
-                // @ts-ignore - the from alias syntax isn't in Knex typing
-                return knex.select(select).from({
-                    [toAlias]: subQuery,
-                });
-            };
-            let wrapperQuery;
-            switch (sqlClient) {
-                case types_1.SqlClient.SQL_LITE:
-                    // need to check the junction table document is to the right column, this is just for SQS
-                    subQuery = this.addJoinFieldCheck(subQuery, relationship);
-                    wrapperQuery = standardWrap(this.knex.raw(`json_group_array(json_object(${fieldListFormatted}))`));
-                    break;
-                case types_1.SqlClient.POSTGRES:
-                    wrapperQuery = standardWrap(this.knex.raw(`json_agg(json_build_object(${fieldListFormatted}))`));
-                    break;
-                case types_1.SqlClient.MARIADB:
-                    // can't use the standard wrap due to correlated sub-query limitations in MariaDB
-                    wrapperQuery = subQuery.select(knex.raw(`json_arrayagg(json_object(${fieldListFormatted}) LIMIT ${getRelationshipLimit()})`));
-                    break;
-                case types_1.SqlClient.MY_SQL:
-                case types_1.SqlClient.ORACLE:
-                    wrapperQuery = standardWrap(this.knex.raw(`json_arrayagg(json_object(${fieldListFormatted}))`));
-                    break;
-                case types_1.SqlClient.MS_SQL: {
-                    const comparatorQuery = knex
-                        .select(`*`)
-                        // @ts-ignore - from alias syntax not TS supported
-                        .from({
-                        [fromAlias]: subQuery
-                            .select(fieldList.map(f => {
-                            // @ts-expect-error raw is fine here, knex types are wrong
-                            return knex.ref(f[1]).as(f[0]);
-                        }))
-                            .limit(getRelationshipLimit()),
-                    });
-                    wrapperQuery = knex.raw(`(SELECT ?? = (${comparatorQuery} FOR JSON PATH))`, [this.rawQuotedIdentifier(toAlias)]);
-                    break;
-                }
-                default:
-                    throw new Error(`JSON relationships not implement for ${sqlClient}`);
-            }
-            query = query.select({ [relationship.column]: wrapperQuery });
-        }
-        return query;
-    }
-    addJoin(query, tables, columns) {
-        const { tableAliases: aliases, schema } = this.query;
-        const toTable = tables.to, fromTable = tables.from, throughTable = tables.through;
-        const toAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[toTable]) || toTable, throughAlias = (throughTable && (aliases === null || aliases === void 0 ? void 0 : aliases[throughTable])) || throughTable, fromAlias = (aliases === null || aliases === void 0 ? void 0 : aliases[fromTable]) || fromTable;
-        let toTableWithSchema = this.tableNameWithSchema(toTable, {
-            alias: toAlias,
-            schema,
-        });
-        let throughTableWithSchema = throughTable
-            ? this.tableNameWithSchema(throughTable, {
-                alias: throughAlias,
-                schema,
-            })
-            : undefined;
-        if (!throughTable) {
-            query = query.leftJoin(toTableWithSchema, function () {
-                for (let relationship of columns) {
-                    const from = relationship.from, to = relationship.to;
-                    this.orOn(`${fromAlias}.${from}`, "=", `${toAlias}.${to}`);
-                }
-            });
-        }
-        else {
-            query = query
-                // @ts-ignore
-                .leftJoin(throughTableWithSchema, function () {
-                for (let relationship of columns) {
-                    const fromPrimary = relationship.fromPrimary;
-                    const from = relationship.from;
-                    this.orOn(`${fromAlias}.${fromPrimary}`, "=", `${throughAlias}.${from}`);
-                }
-            })
-                .leftJoin(toTableWithSchema, function () {
-                for (let relationship of columns) {
-                    const toPrimary = relationship.toPrimary;
-                    const to = relationship.to;
-                    this.orOn(`${toAlias}.${toPrimary}`, `${throughAlias}.${to}`);
-                }
-            });
-        }
-        return query;
-    }
-    qualifiedKnex(opts) {
-        var _a;
-        let alias = (_a = this.query.tableAliases) === null || _a === void 0 ? void 0 : _a[this.query.table.name];
-        if ((opts === null || opts === void 0 ? void 0 : opts.alias) === false) {
-            alias = undefined;
-        }
-        else if (typeof (opts === null || opts === void 0 ? void 0 : opts.alias) === "string") {
-            alias = opts.alias;
-        }
-        return this.knex(this.tableNameWithSchema(this.query.table.name, {
-            alias,
-            schema: this.query.schema,
-        }));
-    }
-    create(opts) {
-        var _a;
-        const { body } = this.query;
-        if (!body) {
-            throw new Error("Cannot create without row body");
-        }
-        let query = this.qualifiedKnex({ alias: false });
-        const parsedBody = this.parseBody(body);
-        if (this.client === types_1.SqlClient.ORACLE) {
-            // Oracle doesn't seem to automatically insert nulls
-            // if we don't specify them, so we need to do that here
-            for (const [column, schema] of Object.entries(this.query.table.schema)) {
-                if (((_a = schema.constraints) === null || _a === void 0 ? void 0 : _a.presence) === true ||
-                    schema.type === types_1.FieldType.FORMULA ||
-                    schema.type === types_1.FieldType.AUTO ||
-                    schema.type === types_1.FieldType.LINK ||
-                    schema.type === types_1.FieldType.AI) {
-                    continue;
-                }
-                const value = parsedBody[column];
-                if (value == null) {
-                    parsedBody[column] = null;
-                }
-            }
-        }
-        else {
-            // make sure no null values in body for creation
-            for (let [key, value] of Object.entries(parsedBody)) {
-                if (value == null) {
-                    delete parsedBody[key];
-                }
-            }
-        }
-        // mysql can't use returning
-        if (opts.disableReturning) {
-            return query.insert(parsedBody);
-        }
-        else {
-            return query.insert(parsedBody).returning("*");
-        }
-    }
-    bulkCreate() {
-        const { body } = this.query;
-        let query = this.qualifiedKnex({ alias: false });
-        if (!Array.isArray(body)) {
-            return query;
-        }
-        const parsedBody = body.map(row => this.parseBody(row));
-        return query.insert(parsedBody);
-    }
-    bulkUpsert() {
-        const { body } = this.query;
-        let query = this.qualifiedKnex({ alias: false });
-        if (!Array.isArray(body)) {
-            return query;
-        }
-        const parsedBody = body.map(row => this.parseBody(row));
-        if (this.client === types_1.SqlClient.POSTGRES ||
-            this.client === types_1.SqlClient.SQL_LITE ||
-            this.client === types_1.SqlClient.MY_SQL ||
-            this.client === types_1.SqlClient.MARIADB) {
-            const primary = this.table.primary;
-            if (!primary) {
-                throw new Error("Primary key is required for upsert");
-            }
-            return query.insert(parsedBody).onConflict(primary).merge();
-        }
-        else if (this.client === types_1.SqlClient.MS_SQL ||
-            this.client === types_1.SqlClient.ORACLE) {
-            // No upsert or onConflict support in MSSQL/Oracle yet, see:
-            //   https://github.com/knex/knex/pull/6050
-            return query.insert(parsedBody);
-        }
-        return query.upsert(parsedBody);
-    }
-    read(opts = {}) {
-        var _a, _b;
-        let { operation, filters, paginate, relationships, table } = this.query;
-        const { limits } = opts;
-        // start building the query
-        let query = this.qualifiedKnex();
-        // handle pagination
-        let foundOffset = null;
-        let foundLimit = (limits === null || limits === void 0 ? void 0 : limits.query) || (limits === null || limits === void 0 ? void 0 : limits.base);
-        if (paginate && paginate.page && paginate.limit) {
-            // @ts-ignore
-            const page = paginate.page <= 1 ? 0 : paginate.page - 1;
-            const offset = page * paginate.limit;
-            foundLimit = paginate.limit;
-            foundOffset = offset;
-        }
-        else if (paginate && paginate.offset && paginate.limit) {
-            foundLimit = paginate.limit;
-            foundOffset = paginate.offset;
-        }
-        else if (paginate && paginate.limit) {
-            foundLimit = paginate.limit;
-        }
-        // counting should not sort, limit or offset
-        if (operation !== types_1.Operation.COUNT) {
-            // add the found limit if supplied
-            if (foundLimit != null) {
-                query = query.limit(foundLimit);
-            }
-            // add overall pagination
-            if (foundOffset != null) {
-                query = query.offset(foundOffset);
-            }
-        }
-        const aggregations = ((_a = this.query.resource) === null || _a === void 0 ? void 0 : _a.aggregations) || [];
-        if (operation === types_1.Operation.COUNT) {
-            query = this.addDistinctCount(query);
-        }
-        else if (aggregations.length > 0) {
-            query = this.addAggregations(query, aggregations);
-        }
-        else {
-            query = query.select(this.generateSelectStatement());
-        }
-        // have to add after as well (this breaks MS-SQL)
-        if (operation !== types_1.Operation.COUNT) {
-            query = this.addSorting(query);
-        }
-        query = this.addFilters(query, filters, { relationship: true });
-        // handle relationships with a CTE for all others
-        if ((relationships === null || relationships === void 0 ? void 0 : relationships.length) && aggregations.length === 0) {
-            const mainTable = ((_b = this.query.tableAliases) === null || _b === void 0 ? void 0 : _b[table.name]) || table.name;
-            const cte = this.addSorting(this.knex
-                .with("paginated", query)
-                .select(this.generateSelectStatement())
-                .from({
-                [mainTable]: "paginated",
-            }));
-            // add JSON aggregations attached to the CTE
-            return this.addJsonRelationships(cte, table.name, relationships);
-        }
-        return query;
-    }
-    update(opts) {
-        const { body, filters } = this.query;
-        if (!body) {
-            throw new Error("Cannot update without row body");
-        }
-        let query = this.qualifiedKnex();
-        const parsedBody = this.parseBody(body);
-        query = this.addFilters(query, filters);
-        // mysql can't use returning
-        if (opts.disableReturning) {
-            return query.update(parsedBody);
-        }
-        else {
-            return query.update(parsedBody).returning("*");
-        }
-    }
-    delete(opts) {
-        const { filters } = this.query;
-        let query = this.qualifiedKnex();
-        query = this.addFilters(query, filters);
-        // mysql can't use returning
-        if (opts.disableReturning) {
-            return query.delete();
-        }
-        else {
-            return query.delete().returning(this.generateSelectStatement());
-        }
-    }
-}
-class SqlQueryBuilder extends sqlTable_1.default {
-    // pass through client to get flavour of SQL
-    constructor(client, limit = getBaseLimit()) {
-        super(client);
-        this.limit = limit;
-    }
-    convertToNative(query, opts = {}) {
-        const sqlClient = this.getSqlClient();
-        if (opts === null || opts === void 0 ? void 0 : opts.disableBindings) {
-            return { sql: query.toString() };
-        }
-        else {
-            let native = (0, utils_1.getNativeSql)(query);
-            if (sqlClient === types_1.SqlClient.SQL_LITE) {
-                native = convertBooleans(native);
-            }
-            return native;
-        }
-    }
-    /**
-     * @param json The JSON query DSL which is to be converted to SQL.
-     * @param opts extra options which are to be passed into the query builder, e.g. disableReturning
-     * which for the sake of mySQL stops adding the returning statement to inserts, updates and deletes.
-     * @return the query ready to be passed to the driver.
-     */
-    _query(json, opts = {}) {
-        const sqlClient = this.getSqlClient();
-        const config = {
-            client: this.getBaseSqlClient(),
-        };
-        if (sqlClient === types_1.SqlClient.SQL_LITE || sqlClient === types_1.SqlClient.ORACLE) {
-            config.useNullAsDefault = true;
-        }
-        const client = (0, knex_1.knex)(config);
-        let query;
-        const builder = new InternalBuilder(sqlClient, client, json);
-        switch (this._operation(json)) {
-            case types_1.Operation.CREATE:
-                query = builder.create(opts);
-                break;
-            case types_1.Operation.READ:
-                query = builder.read({
-                    limits: {
-                        query: this.limit,
-                        base: getBaseLimit(),
-                    },
-                });
-                break;
-            case types_1.Operation.COUNT:
-                // read without any limits to count
-                query = builder.read();
-                break;
-            case types_1.Operation.UPDATE:
-                query = builder.update(opts);
-                break;
-            case types_1.Operation.DELETE:
-                query = builder.delete(opts);
-                break;
-            case types_1.Operation.BULK_CREATE:
-                query = builder.bulkCreate();
-                break;
-            case types_1.Operation.BULK_UPSERT:
-                query = builder.bulkUpsert();
-                break;
-            case types_1.Operation.CREATE_TABLE:
-            case types_1.Operation.UPDATE_TABLE:
-            case types_1.Operation.DELETE_TABLE:
-                return this._tableQuery(json);
-            default:
-                throw `Operation type is not supported by SQL query builder`;
-        }
-        return this.convertToNative(query, opts);
-    }
-    getReturningRow(queryFn, json) {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            if (!json.extra || !json.extra.idFilter) {
-                return {};
-            }
-            const input = this._query({
-                operation: types_1.Operation.READ,
-                datasource: json.datasource,
-                schema: json.schema,
-                table: json.table,
-                tables: json.tables,
-                resource: { fields: [] },
-                filters: (_a = json.extra) === null || _a === void 0 ? void 0 : _a.idFilter,
-                paginate: { limit: 1 },
-            });
-            return queryFn(input, types_1.Operation.READ);
-        });
-    }
-    // when creating if an ID has been inserted need to make sure
-    // the id filter is enriched with it before trying to retrieve the row
-    checkLookupKeys(id, json) {
-        if (!id || !json.table.primary) {
-            return json;
-        }
-        const primaryKey = json.table.primary[0];
-        json.extra = {
-            idFilter: {
-                equal: {
-                    [primaryKey]: id,
-                },
-            },
-        };
-        return json;
-    }
-    // this function recreates the returning functionality of postgres
-    queryWithReturning(json_1, queryFn_1) {
-        return __awaiter(this, arguments, void 0, function* (json, queryFn, processFn = (result) => result) {
-            const sqlClient = this.getSqlClient();
-            const operation = this._operation(json);
-            const input = this._query(json, { disableReturning: true });
-            if (Array.isArray(input)) {
-                const responses = [];
-                for (let query of input) {
-                    responses.push(yield queryFn(query, operation));
-                }
-                return responses;
-            }
-            let row;
-            // need to manage returning, a feature mySQL can't do
-            if (operation === types_1.Operation.DELETE) {
-                row = processFn(yield this.getReturningRow(queryFn, json));
-            }
-            const response = yield queryFn(input, operation);
-            const results = processFn(response);
-            // same as delete, manage returning
-            if (operation === types_1.Operation.CREATE || operation === types_1.Operation.UPDATE) {
-                let id;
-                if (sqlClient === types_1.SqlClient.MS_SQL) {
-                    id = results === null || results === void 0 ? void 0 : results[0].id;
-                }
-                else if (sqlClient === types_1.SqlClient.MY_SQL ||
-                    sqlClient === types_1.SqlClient.MARIADB) {
-                    id = results === null || results === void 0 ? void 0 : results.insertId;
-                }
-                row = processFn(yield this.getReturningRow(queryFn, this.checkLookupKeys(id, json)));
-            }
-            if (operation === types_1.Operation.COUNT) {
-                return results;
-            }
-            if (operation !== types_1.Operation.READ) {
-                return row;
-            }
-            return results.length ? results : [{ [operation.toLowerCase()]: true }];
-        });
-    }
-    getTableName(table, aliases) {
-        let name = table.name;
-        if (table.sourceType === types_1.TableSourceType.INTERNAL ||
-            table.sourceId === types_1.INTERNAL_TABLE_SOURCE_ID) {
-            if (!table._id) {
-                return;
-            }
-            // SQS uses the table ID rather than the table name
-            name = table._id;
-        }
-        return (aliases === null || aliases === void 0 ? void 0 : aliases[name]) || name;
-    }
-    convertJsonStringColumns(table, results, aliases) {
-        const tableName = this.getTableName(table, aliases);
-        for (const [name, field] of Object.entries(table.schema)) {
-            if (!this._isJsonColumn(field)) {
-                continue;
-            }
-            const fullName = `${tableName}.${name}`;
-            for (let row of results) {
-                if (typeof row[fullName] === "string") {
-                    row[fullName] = JSON.parse(row[fullName]);
-                }
-                if (typeof row[name] === "string") {
-                    row[name] = JSON.parse(row[name]);
-                }
-            }
-        }
-        return results;
-    }
-    _isJsonColumn(field) {
-        return (types_1.JsonTypes.includes(field.type) &&
-            !shared_core_1.helpers.schema.isDeprecatedSingleUserColumn(field));
-    }
-    log(query, values) {
-        (0, utils_1.sqlLog)(this.getSqlClient(), query, values);
-    }
-}
-exports.default = SqlQueryBuilder;
-//# sourceMappingURL=sql.js.map