@budibase/backend-core 2.29.28 → 2.29.29

package/dist/src/sql/sql.js

@@ -38,7 +38,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const knex_1 = require("knex");
 const dbCore = __importStar(require("../db"));
 const utils_1 = require("./utils");
-const sqlStatements_1 = require("./sqlStatements");
 const sqlTable_1 = __importDefault(require("./sqlTable"));
 const types_1 = require("@budibase/types");
 const environment_1 = __importDefault(require("../environment"));
@@ -49,126 +48,6 @@ function getBaseLimit() {
         : null;
     return envLimit || 5000;
 }
-// Takes a string like foo and returns a quoted string like [foo] for SQL Server
-// and "foo" for Postgres.
-function quote(client, str) {
-    switch (client) {
-        case types_1.SqlClient.SQL_LITE:
-        case types_1.SqlClient.ORACLE:
-        case types_1.SqlClient.POSTGRES:
-            return `"${str}"`;
-        case types_1.SqlClient.MS_SQL:
-            return `[${str}]`;
-        case types_1.SqlClient.MY_SQL:
-            return `\`${str}\``;
-    }
-}
-// Takes a string like a.b.c and returns a quoted identifier like [a].[b].[c]
-// for SQL Server and `a`.`b`.`c` for MySQL.
-function quotedIdentifier(client, key) {
-    return key
-        .split(".")
-        .map(part => quote(client, part))
-        .join(".");
-}
-function parse(input) {
-    if (Array.isArray(input)) {
-        return JSON.stringify(input);
-    }
-    if (input == undefined) {
-        return null;
-    }
-    if (typeof input !== "string") {
-        return input;
-    }
-    if ((0, utils_1.isInvalidISODateString)(input)) {
-        return null;
-    }
-    if ((0, utils_1.isValidISODateString)(input)) {
-        return new Date(input.trim());
-    }
-    return input;
-}
-function parseBody(body) {
-    for (let [key, value] of Object.entries(body)) {
-        body[key] = parse(value);
-    }
-    return body;
-}
-function parseFilters(filters) {
-    if (!filters) {
-        return {};
-    }
-    for (let [key, value] of Object.entries(filters)) {
-        let parsed;
-        if (typeof value === "object") {
-            parsed = parseFilters(value);
-        }
-        else {
-            parsed = parse(value);
-        }
-        // @ts-ignore
-        filters[key] = parsed;
-    }
-    return filters;
-}
-function generateSelectStatement(json, knex) {
-    const { resource, meta } = json;
-    const client = knex.client.config.client;
-    if (!resource || !resource.fields || resource.fields.length === 0) {
-        return "*";
-    }
-    const schema = meta.table.schema;
-    return resource.fields.map(field => {
-        var _a;
-        const parts = field.split(/\./g);
-        let table = undefined;
-        let column = undefined;
-        // Just a column name, e.g.: "column"
-        if (parts.length === 1) {
-            column = parts[0];
-        }
-        // A table name and a column name, e.g.: "table.column"
-        if (parts.length === 2) {
-            table = parts[0];
-            column = parts[1];
-        }
-        // A link doc, e.g.: "table.doc1.fieldName"
-        if (parts.length > 2) {
-            table = parts[0];
-            column = parts.slice(1).join(".");
-        }
-        if (!column) {
-            throw new Error(`Invalid field name: ${field}`);
-        }
-        const columnSchema = schema[column];
-        if (client === types_1.SqlClient.POSTGRES &&
-            ((_a = columnSchema === null || columnSchema === void 0 ? void 0 : columnSchema.externalType) === null || _a === void 0 ? void 0 : _a.includes("money"))) {
-            return knex.raw(`${quotedIdentifier(client, [table, column].join("."))}::money::numeric as ${quote(client, field)}`);
-        }
-        if (client === types_1.SqlClient.MS_SQL &&
-            (columnSchema === null || columnSchema === void 0 ? void 0 : columnSchema.type) === types_1.FieldType.DATETIME &&
-            columnSchema.timeOnly) {
-            // Time gets returned as timestamp from mssql, not matching the expected
-            // HH:mm format
-            return knex.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
-        }
-        // There's at least two edge cases being handled in the expression below.
-        //  1. The column name could start/end with a space, and in that case we
-        //     want to preseve that space.
-        //  2. Almost all column names are specified in the form table.column, except
-        //     in the case of relationships, where it's table.doc1.column. In that
-        //     case, we want to split it into `table`.`doc1.column` for reasons that
-        //     aren't actually clear to me, but `table`.`doc1` breaks things with the
-        //     sample data tests.
-        if (table) {
-            return knex.raw(`${quote(client, table)}.${quote(client, column)} as ${quote(client, field)}`);
-        }
-        else {
-            return knex.raw(`${quote(client, field)} as ${quote(client, field)}`);
-        }
-    });
-}
 function getTableName(table) {
     // SQS uses the table ID rather than the table name
     if ((table === null || table === void 0 ? void 0 : table.sourceType) === types_1.TableSourceType.INTERNAL ||
@@ -196,26 +75,226 @@ function convertBooleans(query) {
     return query;
 }
 class InternalBuilder {
-    constructor(client) {
+    constructor(client, knex, query) {
         this.client = client;
+        this.query = query;
+        this.knex = knex;
+        this.splitter = new shared_core_1.dataFilters.ColumnSplitter([this.table], {
+            aliases: this.query.tableAliases,
+            columnPrefix: this.query.meta.columnPrefix,
+        });
+    }
+    get table() {
+        return this.query.meta.table;
+    }
+    getFieldSchema(key) {
+        const { column } = this.splitter.run(key);
+        return this.table.schema[column];
+    }
+    // Takes a string like foo and returns a quoted string like [foo] for SQL Server
+    // and "foo" for Postgres.
+    quote(str) {
+        switch (this.client) {
+            case types_1.SqlClient.SQL_LITE:
+            case types_1.SqlClient.ORACLE:
+            case types_1.SqlClient.POSTGRES:
+                return `"${str}"`;
+            case types_1.SqlClient.MS_SQL:
+                return `[${str}]`;
+            case types_1.SqlClient.MY_SQL:
+                return `\`${str}\``;
+        }
+    }
+    // Takes a string like a.b.c and returns a quoted identifier like [a].[b].[c]
+    // for SQL Server and `a`.`b`.`c` for MySQL.
+    quotedIdentifier(key) {
+        return key
+            .split(".")
+            .map(part => this.quote(part))
+            .join(".");
+    }
+    generateSelectStatement() {
+        const { resource, meta } = this.query;
+        if (!resource || !resource.fields || resource.fields.length === 0) {
+            return "*";
+        }
+        const schema = meta.table.schema;
+        return resource.fields.map(field => {
+            var _a;
+            const parts = field.split(/\./g);
+            let table = undefined;
+            let column = undefined;
+            // Just a column name, e.g.: "column"
+            if (parts.length === 1) {
+                column = parts[0];
+            }
+            // A table name and a column name, e.g.: "table.column"
+            if (parts.length === 2) {
+                table = parts[0];
+                column = parts[1];
+            }
+            // A link doc, e.g.: "table.doc1.fieldName"
+            if (parts.length > 2) {
+                table = parts[0];
+                column = parts.slice(1).join(".");
+            }
+            if (!column) {
+                throw new Error(`Invalid field name: ${field}`);
+            }
+            const columnSchema = schema[column];
+            if (this.client === types_1.SqlClient.POSTGRES &&
+                ((_a = columnSchema === null || columnSchema === void 0 ? void 0 : columnSchema.externalType) === null || _a === void 0 ? void 0 : _a.includes("money"))) {
+                return this.knex.raw(`${this.quotedIdentifier([table, column].join("."))}::money::numeric as ${this.quote(field)}`);
+            }
+            if (this.client === types_1.SqlClient.MS_SQL &&
+                (columnSchema === null || columnSchema === void 0 ? void 0 : columnSchema.type) === types_1.FieldType.DATETIME &&
+                columnSchema.timeOnly) {
+                // Time gets returned as timestamp from mssql, not matching the expected
+                // HH:mm format
+                return this.knex.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
+            }
+            // There's at least two edge cases being handled in the expression below.
+            //  1. The column name could start/end with a space, and in that case we
+            //     want to preseve that space.
+            //  2. Almost all column names are specified in the form table.column, except
+            //     in the case of relationships, where it's table.doc1.column. In that
+            //     case, we want to split it into `table`.`doc1.column` for reasons that
+            //     aren't actually clear to me, but `table`.`doc1` breaks things with the
+            //     sample data tests.
+            if (table) {
+                return this.knex.raw(`${this.quote(table)}.${this.quote(column)} as ${this.quote(field)}`);
+            }
+            else {
+                return this.knex.raw(`${this.quote(field)} as ${this.quote(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) {
+        const parts = field.split(".");
+        const col = parts.pop();
+        const schema = this.table.schema[col];
+        let identifier = this.quotedIdentifier(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) {
+            identifier = `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) {
+        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;
     }
     // right now we only do filters on the specific table being queried
-    addFilters(query, filters, table, opts) {
-        var _a;
+    addFilters(query, filters, opts) {
         if (!filters) {
             return query;
         }
-        filters = parseFilters(filters);
+        filters = this.parseFilters(filters);
+        const aliases = this.query.tableAliases;
         // if all or specified in filters, then everything is an or
         const allOr = filters.allOr;
-        const sqlStatements = new sqlStatements_1.SqlStatements(this.client, table, {
-            allOr,
-            columnPrefix: opts.columnPrefix,
-        });
-        const tableName = this.client === types_1.SqlClient.SQL_LITE ? table._id : table.name;
+        const tableName = this.client === types_1.SqlClient.SQL_LITE ? this.table._id : this.table.name;
         function getTableAlias(name) {
-            var _a;
-            const alias = (_a = opts.aliases) === null || _a === void 0 ? void 0 : _a[name];
+            const alias = aliases === null || aliases === void 0 ? void 0 : aliases[name];
             return alias || name;
         }
         function iterate(structure, fn, complexKeyFn) {
@@ -230,11 +309,11 @@ class InternalBuilder {
                     const alias = getTableAlias(tableName);
                     complexKeyFn(castedTypeValue.id.map((x) => alias ? `${alias}.${x}` : x), castedTypeValue.values);
                 }
-                else if (!opts.relationship && !isRelationshipField) {
+                else if (!(opts === null || opts === void 0 ? void 0 : opts.relationship) && !isRelationshipField) {
                     const alias = getTableAlias(tableName);
                     fn(alias ? `${alias}.${updatedKey}` : updatedKey, value);
                 }
-                else if (opts.relationship && isRelationshipField) {
+                else if ((opts === null || opts === void 0 ? void 0 : opts.relationship) && isRelationshipField) {
                     const [filterTableName, property] = updatedKey.split(".");
                     const alias = getTableAlias(filterTableName);
                     fn(alias ? `${alias}.${property}` : property, value);
@@ -251,7 +330,9 @@ class InternalBuilder {
             else {
                 const rawFnc = `${fnc}Raw`;
                 // @ts-ignore
-                query = query[rawFnc](`LOWER(${quotedIdentifier(this.client, key)}) LIKE ?`, [`%${value.toLowerCase()}%`]);
+                query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+                    `%${value.toLowerCase()}%`,
+                ]);
             }
         };
         const contains = (mode, any = false) => {
@@ -285,6 +366,7 @@ class InternalBuilder {
                 const andOr = mode === (filters === null || filters === void 0 ? void 0 : filters.containsAny) ? " OR " : " AND ";
                 iterate(mode, (key, value) => {
                     let statement = "";
+                    const identifier = this.quotedIdentifier(key);
                     for (let i in value) {
                         if (typeof value[i] === "string") {
                             value[i] = `%"${value[i].toLowerCase()}"%`;
@@ -292,24 +374,43 @@ class InternalBuilder {
                         else {
                             value[i] = `%${value[i]}%`;
                         }
-                        statement +=
-                            (statement ? andOr : "") +
-                                `COALESCE(LOWER(${quotedIdentifier(this.client, key)}), '') LIKE ?`;
+                        statement += `${statement ? andOr : ""}COALESCE(LOWER(${identifier}), '') LIKE ?`;
                     }
                     if (statement === "") {
                         return;
                     }
-                    // @ts-ignore
-                    query = query[rawFnc](`${not}(${statement})`, value);
+                    if (not) {
+                        query = query[rawFnc](`(NOT (${statement}) OR ${identifier} IS NULL)`, value);
+                    }
+                    else {
+                        query = query[rawFnc](statement, value);
+                    }
                 });
             }
         };
         if (filters.oneOf) {
             const fnc = allOr ? "orWhereIn" : "whereIn";
             iterate(filters.oneOf, (key, array) => {
-                query = query[fnc](key, Array.isArray(array) ? array : [array]);
+                if (this.client === types_1.SqlClient.ORACLE) {
+                    key = this.convertClobs(key);
+                    array = Array.isArray(array) ? array : [array];
+                    const binding = new Array(array.length).fill("?").join(",");
+                    query = query.whereRaw(`${key} IN (${binding})`, array);
+                }
+                else {
+                    query = query[fnc](key, Array.isArray(array) ? array : [array]);
+                }
             }, (key, array) => {
-                query = query[fnc](key, Array.isArray(array) ? array : [array]);
+                if (this.client === types_1.SqlClient.ORACLE) {
+                    const keyStr = `(${key.map(k => this.convertClobs(k)).join(",")})`;
+                    const binding = `(${array
+                        .map((a) => `(${new Array(a.length).fill("?").join(",")})`)
+                        .join(",")})`;
+                    query = query.whereRaw(`${keyStr} IN ${binding}`, array.flat());
+                }
+                else {
+                    query = query[fnc](key, Array.isArray(array) ? array : [array]);
+                }
             });
         }
         if (filters.string) {
@@ -322,7 +423,9 @@ class InternalBuilder {
                 else {
                     const rawFnc = `${fnc}Raw`;
                     // @ts-ignore
-                    query = query[rawFnc](`LOWER(${quotedIdentifier(this.client, key)}) LIKE ?`, [`${value.toLowerCase()}%`]);
+                    query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+                        `${value.toLowerCase()}%`,
+                    ]);
                 }
             });
         }
@@ -343,14 +446,40 @@ class InternalBuilder {
                     value.high = "";
                 }
                 const lowValid = (0, utils_1.isValidFilter)(value.low), highValid = (0, utils_1.isValidFilter)(value.high);
+                const schema = this.getFieldSchema(key);
+                if (this.client === types_1.SqlClient.ORACLE) {
+                    // @ts-ignore
+                    key = this.knex.raw(this.convertClobs(key));
+                }
                 if (lowValid && highValid) {
-                    query = sqlStatements.between(query, key, value.low, value.high);
+                    if ((schema === null || schema === void 0 ? void 0 : schema.type) === types_1.FieldType.BIGINT &&
+                        this.client === types_1.SqlClient.SQL_LITE) {
+                        query = query.whereRaw(`CAST(${key} AS INTEGER) BETWEEN CAST(? AS INTEGER) AND CAST(? AS INTEGER)`, [value.low, value.high]);
+                    }
+                    else {
+                        const fnc = allOr ? "orWhereBetween" : "whereBetween";
+                        query = query[fnc](key, [value.low, value.high]);
+                    }
                 }
                 else if (lowValid) {
-                    query = sqlStatements.lte(query, key, value.low);
+                    if ((schema === null || schema === void 0 ? void 0 : schema.type) === types_1.FieldType.BIGINT &&
+                        this.client === types_1.SqlClient.SQL_LITE) {
+                        query = query.whereRaw(`CAST(${key} AS INTEGER) >= CAST(? AS INTEGER)`, [value.low]);
+                    }
+                    else {
+                        const fnc = allOr ? "orWhere" : "where";
+                        query = query[fnc](key, ">=", value.low);
+                    }
                 }
                 else if (highValid) {
-                    query = sqlStatements.gte(query, key, value.high);
+                    if ((schema === null || schema === void 0 ? void 0 : schema.type) === types_1.FieldType.BIGINT &&
+                        this.client === types_1.SqlClient.SQL_LITE) {
+                        query = query.whereRaw(`CAST(${key} AS INTEGER) <= CAST(? AS INTEGER)`, [value.high]);
+                    }
+                    else {
+                        const fnc = allOr ? "orWhere" : "where";
+                        query = query[fnc](key, "<=", value.high);
+                    }
                 }
             });
         }
@@ -358,13 +487,14 @@ class InternalBuilder {
             iterate(filters.equal, (key, value) => {
                 const fnc = allOr ? "orWhereRaw" : "whereRaw";
                 if (this.client === types_1.SqlClient.MS_SQL) {
-                    query = query[fnc](`CASE WHEN ${quotedIdentifier(this.client, key)} = ? THEN 1 ELSE 0 END = 1`, [value]);
+                    query = query[fnc](`CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 1`, [value]);
                 }
                 else if (this.client === types_1.SqlClient.ORACLE) {
-                    query = query[fnc](`COALESCE(${quotedIdentifier(this.client, key)}, -1) = ?`, [value]);
+                    const identifier = this.convertClobs(key);
+                    query = query[fnc](`(${identifier} IS NOT NULL AND ${identifier} = ?)`, [value]);
                 }
                 else {
-                    query = query[fnc](`COALESCE(${quotedIdentifier(this.client, key)} = ?, FALSE)`, [value]);
+                    query = query[fnc](`COALESCE(${this.quotedIdentifier(key)} = ?, FALSE)`, [value]);
                 }
             });
         }
@@ -372,13 +502,14 @@ class InternalBuilder {
             iterate(filters.notEqual, (key, value) => {
                 const fnc = allOr ? "orWhereRaw" : "whereRaw";
                 if (this.client === types_1.SqlClient.MS_SQL) {
-                    query = query[fnc](`CASE WHEN ${quotedIdentifier(this.client, key)} = ? THEN 1 ELSE 0 END = 0`, [value]);
+                    query = query[fnc](`CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 0`, [value]);
                 }
                 else if (this.client === types_1.SqlClient.ORACLE) {
-                    query = query[fnc](`COALESCE(${quotedIdentifier(this.client, key)}, -1) != ?`, [value]);
+                    const identifier = this.convertClobs(key);
+                    query = query[fnc](`(${identifier} IS NOT NULL AND ${identifier} != ?) OR ${identifier} IS NULL`, [value]);
                 }
                 else {
-                    query = query[fnc](`COALESCE(${quotedIdentifier(this.client, key)} != ?, TRUE)`, [value]);
+                    query = query[fnc](`COALESCE(${this.quotedIdentifier(key)} != ?, TRUE)`, [value]);
                 }
             });
         }
@@ -403,43 +534,50 @@ class InternalBuilder {
         if (filters.containsAny) {
             contains(filters.containsAny, true);
         }
-        const tableRef = ((_a = opts === null || opts === void 0 ? void 0 : opts.aliases) === null || _a === void 0 ? void 0 : _a[table._id]) || table._id;
+        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)(table) && tableRef) {
+        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;
     }
-    addDistinctCount(query, json) {
-        const table = json.meta.table;
-        const primary = table.primary;
-        const aliases = json.tableAliases;
-        const aliased = table.name && (aliases === null || aliases === void 0 ? void 0 : aliases[table.name]) ? aliases[table.name] : table.name;
+    addDistinctCount(query) {
+        const primary = this.table.primary;
+        const aliases = this.query.tableAliases;
+        const aliased = this.table.name && (aliases === null || aliases === void 0 ? void 0 : aliases[this.table.name])
+            ? aliases[this.table.name]
+            : this.table.name;
         if (!primary) {
             throw new Error("SQL counting requires primary key to be supplied");
         }
         return query.countDistinct(`${aliased}.${primary[0]} as total`);
     }
-    addSorting(query, json) {
-        let { sort } = json;
-        const table = json.meta.table;
-        const primaryKey = table.primary;
-        const tableName = getTableName(table);
-        const aliases = json.tableAliases;
-        const aliased = tableName && (aliases === null || aliases === void 0 ? void 0 : aliases[tableName]) ? aliases[tableName] : table === null || table === void 0 ? void 0 : table.name;
+    addSorting(query) {
+        var _a;
+        let { sort } = this.query;
+        const primaryKey = this.table.primary;
+        const tableName = getTableName(this.table);
+        const aliases = this.query.tableAliases;
+        const aliased = tableName && (aliases === null || aliases === void 0 ? void 0 : aliases[tableName]) ? aliases[tableName] : (_a = this.table) === null || _a === void 0 ? void 0 : _a.name;
         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";
-                let nulls;
-                if (this.client === types_1.SqlClient.POSTGRES) {
-                    // All other clients already sort this as expected by default, and adding this to the rest of the clients is causing issues
+                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";
                 }
-                query = query.orderBy(`${aliased}.${key}`, direction, nulls);
+                let composite = `${aliased}.${key}`;
+                if (this.client === types_1.SqlClient.ORACLE) {
+                    query = query.orderByRaw(`${this.convertClobs(composite)} ${direction} nulls ${nulls}`);
+                }
+                else {
+                    query = query.orderBy(composite, direction, nulls);
+                }
             }
         }
         // add sorting by the primary key if the result isn't already sorted by it,
@@ -522,22 +660,47 @@ class InternalBuilder {
         }
         return query;
     }
-    knexWithAlias(knex, endpoint, aliases) {
-        const tableName = endpoint.entityId;
-        const tableAlias = aliases === null || aliases === void 0 ? void 0 : aliases[tableName];
-        return knex(this.tableNameWithSchema(tableName, {
-            alias: tableAlias,
-            schema: endpoint.schema,
+    qualifiedKnex(opts) {
+        var _a;
+        let alias = (_a = this.query.tableAliases) === null || _a === void 0 ? void 0 : _a[this.query.endpoint.entityId];
+        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.endpoint.entityId, {
+            alias,
+            schema: this.query.endpoint.schema,
         }));
     }
-    create(knex, json, opts) {
-        const { endpoint, body } = json;
-        let query = this.knexWithAlias(knex, endpoint);
-        const parsedBody = parseBody(body);
-        // make sure no null values in body for creation
-        for (let [key, value] of Object.entries(parsedBody)) {
-            if (value == null) {
-                delete parsedBody[key];
+    create(opts) {
+        var _a;
+        const { body } = this.query;
+        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.meta.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) {
+                    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
@@ -548,46 +711,47 @@ class InternalBuilder {
             return query.insert(parsedBody).returning("*");
         }
     }
-    bulkCreate(knex, json) {
-        const { endpoint, body } = json;
-        let query = this.knexWithAlias(knex, endpoint);
+    bulkCreate() {
+        const { body } = this.query;
+        let query = this.qualifiedKnex({ alias: false });
         if (!Array.isArray(body)) {
             return query;
         }
-        const parsedBody = body.map(row => parseBody(row));
+        const parsedBody = body.map(row => this.parseBody(row));
         return query.insert(parsedBody);
     }
-    bulkUpsert(knex, json) {
-        const { endpoint, body } = json;
-        let query = this.knexWithAlias(knex, endpoint);
+    bulkUpsert() {
+        const { body } = this.query;
+        let query = this.qualifiedKnex({ alias: false });
         if (!Array.isArray(body)) {
             return query;
         }
-        const parsedBody = body.map(row => parseBody(row));
+        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) {
-            const primary = json.meta.table.primary;
+            const primary = this.table.primary;
             if (!primary) {
                 throw new Error("Primary key is required for upsert");
             }
             const ret = query.insert(parsedBody).onConflict(primary).merge();
             return ret;
         }
-        else if (this.client === types_1.SqlClient.MS_SQL) {
-            // No upsert or onConflict support in MSSQL yet, see:
+        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(knex, json, opts = {}) {
-        let { endpoint, filters, paginate, relationships, tableAliases } = json;
+    read(opts = {}) {
+        let { endpoint, filters, paginate, relationships, tableAliases } = this.query;
         const { limits } = opts;
         const counting = endpoint.operation === types_1.Operation.COUNT;
         const tableName = endpoint.entityId;
         // start building the query
-        let query = this.knexWithAlias(knex, endpoint, tableAliases);
+        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);
@@ -617,15 +781,12 @@ class InternalBuilder {
             }
             // add sorting to pre-query
             // no point in sorting when counting
-            query = this.addSorting(query, json);
+            query = this.addSorting(query);
         }
         // add filters to the query (where)
-        query = this.addFilters(query, filters, json.meta.table, {
-            columnPrefix: json.meta.columnPrefix,
-            aliases: tableAliases,
-        });
+        query = this.addFilters(query, filters);
         const alias = (tableAliases === null || tableAliases === void 0 ? void 0 : tableAliases[tableName]) || tableName;
-        let preQuery = knex({
+        let preQuery = this.knex({
             // the typescript definition for the knex constructor doesn't support this
             // syntax, but it is the only way to alias a pre-query result as part of
             // a query - there is an alias dictionary type, but it assumes it can only
@@ -634,11 +795,11 @@ class InternalBuilder {
         });
         // if counting, use distinct count, else select
         preQuery = !counting
-            ? preQuery.select(generateSelectStatement(json, knex))
-            : this.addDistinctCount(preQuery, json);
+            ? preQuery.select(this.generateSelectStatement())
+            : this.addDistinctCount(preQuery);
         // have to add after as well (this breaks MS-SQL)
         if (this.client !== types_1.SqlClient.MS_SQL && !counting) {
-            preQuery = this.addSorting(preQuery, json);
+            preQuery = this.addSorting(preQuery);
         }
         // handle joins
         query = this.addRelationships(preQuery, tableName, relationships, endpoint.schema, tableAliases);
@@ -647,20 +808,13 @@ class InternalBuilder {
         if (limits === null || limits === void 0 ? void 0 : limits.base) {
             query = query.limit(limits.base);
         }
-        return this.addFilters(query, filters, json.meta.table, {
-            columnPrefix: json.meta.columnPrefix,
-            relationship: true,
-            aliases: tableAliases,
-        });
+        return this.addFilters(query, filters, { relationship: true });
     }
-    update(knex, json, opts) {
-        const { endpoint, body, filters, tableAliases } = json;
-        let query = this.knexWithAlias(knex, endpoint, tableAliases);
-        const parsedBody = parseBody(body);
-        query = this.addFilters(query, filters, json.meta.table, {
-            columnPrefix: json.meta.columnPrefix,
-            aliases: tableAliases,
-        });
+    update(opts) {
+        const { body, filters } = this.query;
+        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);
@@ -669,19 +823,16 @@ class InternalBuilder {
             return query.update(parsedBody).returning("*");
         }
     }
-    delete(knex, json, opts) {
-        const { endpoint, filters, tableAliases } = json;
-        let query = this.knexWithAlias(knex, endpoint, tableAliases);
-        query = this.addFilters(query, filters, json.meta.table, {
-            columnPrefix: json.meta.columnPrefix,
-            aliases: tableAliases,
-        });
+    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(generateSelectStatement(json, knex));
+            return query.delete().returning(this.generateSelectStatement());
         }
     }
 }
@@ -715,18 +866,18 @@ class SqlQueryBuilder extends sqlTable_1.default {
         const config = {
             client: sqlClient,
         };
-        if (sqlClient === types_1.SqlClient.SQL_LITE) {
+        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);
+        const builder = new InternalBuilder(sqlClient, client, json);
         switch (this._operation(json)) {
             case types_1.Operation.CREATE:
-                query = builder.create(client, json, opts);
+                query = builder.create(opts);
                 break;
             case types_1.Operation.READ:
-                query = builder.read(client, json, {
+                query = builder.read({
                     limits: {
                         query: this.limit,
                         base: getBaseLimit(),
@@ -735,19 +886,19 @@ class SqlQueryBuilder extends sqlTable_1.default {
                 break;
             case types_1.Operation.COUNT:
                 // read without any limits to count
-                query = builder.read(client, json);
+                query = builder.read();
                 break;
             case types_1.Operation.UPDATE:
-                query = builder.update(client, json, opts);
+                query = builder.update(opts);
                 break;
             case types_1.Operation.DELETE:
-                query = builder.delete(client, json, opts);
+                query = builder.delete(opts);
                 break;
             case types_1.Operation.BULK_CREATE:
-                query = builder.bulkCreate(client, json);
+                query = builder.bulkCreate();
                 break;
             case types_1.Operation.BULK_UPSERT:
-                query = builder.bulkUpsert(client, json);
+                query = builder.bulkUpsert();
                 break;
             case types_1.Operation.CREATE_TABLE:
             case types_1.Operation.UPDATE_TABLE: