objection 3.9.1 → 4.0.0-rc.2

package/lib/relations/manyToMany/update/ManyToManyUpdateOperationBase.js

@@ -1,19 +1,13 @@
-'use strict';
-
-const { UpdateOperation } = require('../../../queryBuilder/operations/UpdateOperation');
-const { addWhereGroup } = require('../../../queryBuilder/whereGroups');
-const { chunk } = require('../../../utils/objectUtils');
-const { isMySql, isMsSql } = require('../../../utils/knexUtils');
-
-// Stay below the limits of bound values per statement of SQLite before 3.32
-// (999) and SQL Server (2100), leaving room for the patched values:
-const maxBatchValues = 500;
+import { UpdateOperation } from '../../../queryBuilder/operations/UpdateOperation.js';
+import { addWhereGroup } from '../../../queryBuilder/whereGroups.js';
+import { isMySql, isMsSql, whereInKeys } from '../../../utils/knexUtils.js';
+import { getWindowOrder, rowNumberColumn } from '../../../queryBuilder/operations/windowOrder.js';
 
 const LimitSelector = /^(orderBy\w*|limit|offset)$/;
 // Without underscores, so that column name mappers don't change it.
 const relatedPropColumn = 'objectiontmprelated';
 
-class ManyToManyUpdateOperationBase extends UpdateOperation {
+export class ManyToManyUpdateOperationBase extends UpdateOperation {
   constructor(name, opt) {
     super(name, opt);
 
@@ -39,9 +33,15 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     // table. On MySQL, concurrent updates with that subquery deadlock (#135).
     this.skipRelationFilter = builder.internalOptions().skipRelationFilter;
 
-    // Copy all extra properties to the `joinTablePatch` object.
+    // Copy the extra properties to the `joinTablePatch` object, or the ones
+    // that `upsertGraph()` writes:
+    const { joinTableExtras } = builder.internalOptions();
+
     for (const extra of this.relation.joinTableExtras) {
-      if (extra.aliasProp in obj) {
+      if (
+        extra.aliasProp in obj &&
+        (!joinTableExtras || joinTableExtras.includes(extra.aliasProp))
+      ) {
         this.hasExtraProps = true;
         this.joinTablePatch[extra.joinTableProp] = obj[extra.aliasProp];
       }
@@ -76,7 +76,6 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
       // `onAfterBuild()`.
       this.relatedIdsQuery = this.createRelatedIdsQuery(builder, hasLimit);
       if (hasLimit) {
-        this.relatedIdsQuery.copyFrom(builder, LimitSelector);
         builder.clear(LimitSelector);
       }
     }
@@ -84,33 +83,47 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     return super.onBuild(builder);
   }
 
-  // Selects the ids of the related rows to update. Fetch raw rows, so that no
-  // hooks run for them.
+  // Select the ids of the related rows to update from the filter subquery
+  // itself. Filtering the related table by them again lets Postgres pick plans
+  // that run the subquery once per related row, which takes minutes for a few
+  // thousand (#161). Fetch raw rows, so that no hooks run for them.
   createRelatedIdsQuery(builder, hasLimit) {
     const { relatedModelClass, relatedProp } = this.relation;
+    const idProperty = relatedModelClass.getIdRelationProperty();
+    const filterQuery = this.modifyFilterSubquery.clone();
+    const idRefs = idProperty.refs(filterQuery);
 
     if (hasLimit) {
-      // The limit picks related rows, not join rows, so filter the related
-      // table by the ids of the matching join rows. The join rows refer to the
-      // related rows by their `relatedProp`, which isn't necessarily their id
-      // (#360). We select it after the ids, aliased as it can be the same
-      // columns:
-      const relatedIdsQuery = relatedModelClass.query().childQueryOf(builder);
-      const idRefs = relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
-      const relatedPropRefs = relatedProp
-        .refs(relatedIdsQuery)
-        .map((ref, index) => ref.as(`${relatedPropColumn}${index}`));
-      return this.applyModifyFilterForRelatedTable(relatedIdsQuery).select([
-        ...idRefs,
-        ...relatedPropRefs,
-      ]);
+      // The join rows refer to the related rows by their `relatedProp`, which
+      // isn't necessarily their id (#360). We select it after the ids, aliased
+      // as it can be the same columns:
+      const relatedPropColumns = relatedProp.cols.map((_, index) => `${relatedPropColumn}${index}`);
+      const columns = [...idProperty.cols, ...relatedPropColumns];
+
+      // The filter subquery returns a row per join row, and `distinct` can't
+      // order by columns that it doesn't select. So we number the rows in the
+      // order of the query, and the limit picks the related rows by their
+      // first row:
+      const order = getWindowOrder(builder, builder.knex(), builder.tableRef());
+      const numberedQuery = filterQuery
+        .select([
+          ...idRefs,
+          ...relatedProp.refs(filterQuery).map((ref, index) => ref.as(relatedPropColumns[index])),
+        ])
+        .onBuildKnex((knexBuilder) =>
+          knexBuilder.rowNumber(rowNumberColumn, (window) => window.orderBy(order)),
+        );
+
+      return relatedModelClass
+        .query()
+        .childQueryOf(builder)
+        .from(numberedQuery.as(rowNumberColumn))
+        .select(columns)
+        .groupBy(columns)
+        .orderByRaw('min(??)', [rowNumberColumn])
+        .copyFrom(builder, /^(limit|offset)$/);
     } else {
-      // Select the ids from the filter subquery itself. Filtering the related
-      // table by them again lets Postgres pick plans that run the subquery
-      // once per related row, which takes minutes for a few thousand (#161).
-      const relatedIdsQuery = this.modifyFilterSubquery.clone();
-      const idRefs = relatedModelClass.getIdRelationProperty().refs(relatedIdsQuery);
-      return relatedIdsQuery.distinct(idRefs);
+      return filterQuery.distinct(idRefs);
     }
   }
 
@@ -119,7 +132,7 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
   // `none()`, leaves the join rows untouched too.
   async onAfterBuild(builder) {
     // An offset that `onBuild()` moved to the ids query is honoured, and
-    // doesn't warn.
+    // doesn't throw.
     super.onAfterBuild(builder);
     if (this.hasExtraProps && !this.isResolvedWithoutUpdate(builder)) {
       let relatedValues = null;
@@ -130,22 +143,15 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
         const values = rows.map((row) => Object.values(row));
         const { size } = this.relation.relatedModelClass.getIdRelationProperty();
         this.relatedIds = values.map((row) => row.slice(0, size));
+        // With a limit, the filters match the join rows of more related rows
+        // than the limit picks, so only update the join rows of the picked
+        // ones, by the `relatedProp` values that follow their ids.
         if (this.relatedIdsQuery.has(/^(limit|offset)$/)) {
           relatedValues = values.map((row) => row.slice(size));
         }
       }
 
-      let numJoinRowsUpdated;
-      if (relatedValues) {
-        // The filters match the join rows of more related rows than the limit
-        // picks, so only update the join rows of the picked ones, by the
-        // `relatedProp` values that follow their ids.
-        for (const values of chunkKeys(relatedValues, this.relation.relatedProp.size)) {
-          await this.updateJoinRows(builder, values);
-        }
-      } else {
-        numJoinRowsUpdated = await this.updateJoinRows(builder);
-      }
+      const numJoinRowsUpdated = await this.updateJoinRows(builder, relatedValues);
 
       if (this.hasNothingToUpdate) {
         // Only the join rows change, so count the related rows that they
@@ -157,6 +163,14 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     }
   }
 
+  // Changes of only the extras still write the join rows, see `onAfterBuild()`.
+  // @override
+  isResolvedWithoutWrite(builder) {
+    return (
+      super.isResolvedWithoutWrite(builder) && !(this.hasExtraProps && this.hasNothingToUpdate)
+    );
+  }
+
   updateJoinRows(builder, relatedValues = null) {
     const joinTableUpdateQuery = this.relation
       .getJoinModelClass(builder.knex())
@@ -171,7 +185,8 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     );
     if (relatedValues) {
       addWhereGroup(joinTableUpdateQuery, () =>
-        joinTableUpdateQuery.whereInComposite(
+        whereInKeys(
+          joinTableUpdateQuery,
           this.relation.joinTableRelatedProp.refs(joinTableUpdateQuery),
           relatedValues,
         ),
@@ -184,21 +199,6 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     return joinTableUpdateQuery;
   }
 
-  // Update the related rows in batches of their ids, as databases limit the
-  // number of values in one statement.
-  queryBatches(builder) {
-    if (this.relatedIds) {
-      const batches = chunkKeys(
-        this.relatedIds,
-        this.relation.relatedModelClass.getIdRelationProperty().size,
-      );
-      // Without ids, still execute the query once for the dialect's result:
-      return batches.length > 0 ? batches : [[]];
-    } else {
-      return null;
-    }
-  }
-
   // Filters the join rows by the ids of the owner and the updated model.
   applyIdFilterForJoinTable(builder) {
     return builder
@@ -234,11 +234,3 @@ class ManyToManyUpdateOperationBase extends UpdateOperation {
     return clone;
   }
 }
-
-function chunkKeys(keys, size) {
-  return chunk(keys, Math.floor(maxBatchValues / size));
-}
-
-module.exports = {
-  ManyToManyUpdateOperationBase,
-};

package/lib/relations/manyToMany/update/ManyToManyUpdateSqliteOperation.js

@@ -1,12 +1,6 @@
-'use strict';
+import { ManyToManyUpdateOperationBase } from './ManyToManyUpdateOperationBase.js';
+import { ManyToManySqliteModifyMixin } from '../ManyToManySqliteModifyMixin.js';
 
-const { ManyToManyUpdateOperationBase } = require('./ManyToManyUpdateOperationBase');
-const { ManyToManySqliteModifyMixin } = require('../ManyToManySqliteModifyMixin');
-
-class ManyToManyUpdateSqliteOperation extends ManyToManySqliteModifyMixin(
+export class ManyToManyUpdateSqliteOperation extends ManyToManySqliteModifyMixin(
   ManyToManyUpdateOperationBase,
 ) {}
-
-module.exports = {
-  ManyToManyUpdateSqliteOperation,
-};

package/lib/transaction.js

@@ -1,9 +1,7 @@
-'use strict';
+import * as promiseUtils from './utils/promiseUtils/index.js';
+import { isFunction } from './utils/objectUtils.js';
 
-const promiseUtils = require('./utils/promiseUtils');
-const { isFunction } = require('./utils/objectUtils');
-
-function transaction() {
+export function transaction() {
   // There must be at least one model class and the callback.
   if (arguments.length < 2) {
     return Promise.reject(
@@ -90,7 +88,3 @@ transaction.start = function (modelClassOrKnex) {
 function isModelClass(maybeModel) {
   return isFunction(maybeModel) && maybeModel.isObjectionModelClass;
 }
-
-module.exports = {
-  transaction,
-};

package/lib/utils/assert.js

@@ -1,12 +1,10 @@
-'use strict';
-
-function assertHasIdColumn(modelClass) {
+export function assertHasIdColumn(modelClass) {
   if (modelClass.getIdColumnArray().length === 0) {
     throw new Error(`model ${modelClass.name} has no idColumn`);
   }
 }
 
-function assertHasId(model) {
+export function assertHasId(model) {
   assertHasIdColumn(model.constructor);
 
   if (!model.$hasId()) {
@@ -19,16 +17,10 @@ function assertHasId(model) {
   }
 }
 
-function assertIdNotUndefined(id, message) {
+export function assertIdNotUndefined(id, message) {
   if (Array.isArray(id)) {
     id.forEach((id) => assertIdNotUndefined(id, message));
   } else if (id === undefined) {
     throw Error(message);
   }
 }
-
-module.exports = {
-  assertHasId,
-  assertHasIdColumn,
-  assertIdNotUndefined,
-};

package/lib/utils/buildUtils.js

@@ -1,8 +1,6 @@
-'use strict';
+import { isObject, isFunction } from './objectUtils.js';
 
-const { isObject, isFunction } = require('./objectUtils');
-
-function buildArg(arg, builder) {
+export function buildArg(arg, builder) {
   if (!isObject(arg)) {
     return arg;
   }
@@ -15,7 +13,3 @@ function buildArg(arg, builder) {
     return arg;
   }
 }
-
-module.exports = {
-  buildArg,
-};

package/lib/utils/classUtils.js

@@ -1,13 +1,7 @@
-'use strict';
-
-function inherit(Constructor, BaseConstructor) {
+export function inherit(Constructor, BaseConstructor) {
   Constructor.prototype = Object.create(BaseConstructor.prototype);
   Constructor.prototype.constructor = BaseConstructor;
   Object.setPrototypeOf(Constructor, BaseConstructor);
 
   return Constructor;
 }
-
-module.exports = {
-  inherit,
-};

package/lib/utils/createModifier.js

@@ -1,8 +1,6 @@
-'use strict';
+import { asArray, isString, isFunction, isPlainObject } from './objectUtils.js';
 
-const { asArray, isString, isFunction, isPlainObject } = require('./objectUtils');
-
-function createModifier({ modelClass, modifier, modifiers }) {
+export function createModifier({ modelClass, modifier, modifiers }) {
   const modelModifiers = modelClass ? modelClass.getModifiers() : {};
 
   const modifierFunctions = asArray(modifier).map((modifier) => {
@@ -36,7 +34,3 @@ function createModifier({ modelClass, modifier, modifiers }) {
     }
   };
 }
-
-module.exports = {
-  createModifier,
-};

package/lib/utils/identifierMapping.js

@@ -1,6 +1,5 @@
-'use strict';
-
-const { isObject } = require('./objectUtils');
+import { isObject } from './objectUtils.js';
+import { isFieldExpressionKey } from './parseFieldExpression.js';
 
 // Super fast memoize for single argument functions.
 function memoize(func) {
@@ -21,7 +20,7 @@ function memoize(func) {
 // camelCase to snake_case converter that also works with non-ascii characters
 // This is needed especially so that aliases containing the `:` character,
 // objection uses internally, work.
-function snakeCase(
+export function snakeCase(
   str,
   {
     upperCase = false,
@@ -90,7 +89,7 @@ function snakeCase(
 
 // snake_case to camelCase converter that simply reverses
 // the actions done by `snakeCase` function.
-function camelCase(str, { upperCase = false } = {}) {
+export function camelCase(str, { upperCase = false } = {}) {
   if (str.length === 0) {
     return str;
   }
@@ -149,9 +148,10 @@ function mapLastPart(mapper, separator) {
 }
 
 // Returns a function that takes an object as an input and maps the object's keys
-// using `mapper`. If the input is not an object, the input is returned unchanged.
+// using `mapper`, passing on `arg`. If the input is not an object, the input is
+// returned unchanged.
 function keyMapper(mapper) {
-  return (obj) => {
+  return (obj, arg) => {
     if (!isObject(obj) || Array.isArray(obj)) {
       return obj;
     }
@@ -161,7 +161,7 @@ function keyMapper(mapper) {
 
     for (let i = 0, l = keys.length; i < l; ++i) {
       const key = keys[i];
-      out[mapper(key)] = obj[key];
+      out[mapper(key, arg)] = obj[key];
     }
 
     return out;
@@ -171,8 +171,7 @@ function keyMapper(mapper) {
 // Returns a function that only calls `mapper` for the part of the input string
 // before the first `separator`, and leaves the rest untouched. For field
 // expressions like `jsonColumn:some.jsonPath` this maps the column but keeps
-// the json path as is. The mapper doesn't know the schema, so the first `:`
-// marks the boundary also in a declared column name like `ns:name`.
+// the json path as is.
 function mapFirstPart(mapper, separator) {
   return (str) => {
     const idx = str.indexOf(separator);
@@ -180,16 +179,22 @@ function mapFirstPart(mapper, separator) {
   };
 }
 
-function snakeCaseMappers(opt = {}) {
-  const format = (str) => snakeCase(str, opt);
+export function snakeCaseMappers(opt = {}) {
+  const { preserveJsonKeys = true } = opt;
+  const formatColumn = memoize((str) => snakeCase(str, opt));
+  const formatFieldExpression = memoize(mapFirstPart(formatColumn, ':'));
 
   return {
     parse: keyMapper(memoize((str) => camelCase(str, opt))),
-    format: keyMapper(memoize(opt.preserveJsonKeys ? mapFirstPart(format, ':') : format)),
+    // Models pass `isFieldExpression()`, which knows the columns with a `:` that
+    // their schema declares, like `ns:fooBar`. These are converted as a whole.
+    format: keyMapper((key, isFieldExpression = isFieldExpressionKey) =>
+      preserveJsonKeys && isFieldExpression(key) ? formatFieldExpression(key) : formatColumn(key),
+    ),
   };
 }
 
-function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
+export function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
   const formatId = memoize(mapLastPart(format, idSeparator));
   const parseId = memoize(mapLastPart(parse, idSeparator));
   const parseKeys = keyMapper(parseId);
@@ -215,14 +220,14 @@ function knexIdentifierMappers({ parse, format, idSeparator = ':' } = {}) {
   };
 }
 
-function knexSnakeCaseMappers(opt = {}) {
+export function knexSnakeCaseMappers(opt = {}) {
   return knexIdentifierMappers({
     parse: (str) => camelCase(str, opt),
     format: (str) => snakeCase(str, opt),
   });
 }
 
-function knexIdentifierMapping(colToProp) {
+export function knexIdentifierMapping(colToProp) {
   const propToCol = Object.keys(colToProp).reduce((propToCol, column) => {
     propToCol[colToProp[column]] = column;
     return propToCol;
@@ -234,14 +239,5 @@ function knexIdentifierMapping(colToProp) {
   });
 }
 
-module.exports = {
-  snakeCase,
-  camelCase,
-  snakeCaseMappers,
-  knexSnakeCaseMappers,
-  knexIdentifierMappers,
-  knexIdentifierMapping,
-
-  camelCaseKeys: keyMapper(memoize(camelCase)),
-  snakeCaseKeys: keyMapper(memoize(snakeCase)),
-};
+export const camelCaseKeys = keyMapper(memoize(camelCase));
+export const snakeCaseKeys = keyMapper(memoize(snakeCase));

package/lib/utils/internalPropUtils.js

@@ -1,11 +1,5 @@
-'use strict';
-
 const INTERNAL_PROP_PREFIX = '$';
 
-function isInternalProp(propName) {
+export function isInternalProp(propName) {
   return propName[0] === INTERNAL_PROP_PREFIX;
 }
-
-module.exports = {
-  isInternalProp,
-};

package/lib/utils/knexUtils.js

@@ -1,8 +1,6 @@
-'use strict';
+import { isObject, isFunction, isString, isNumber, asSingle } from '../utils/objectUtils.js';
 
-const { isObject, isFunction } = require('../utils/objectUtils');
-
-function getDialect(knex) {
+export function getDialect(knex) {
   const type = typeof knex;
 
   return (
@@ -14,48 +12,109 @@ function getDialect(knex) {
   );
 }
 
-function isPostgres(knex) {
+export function isPostgres(knex) {
   return getDialect(knex) === 'postgresql';
 }
 
-function isOracle(knex) {
+export function isOracle(knex) {
   const dialect = getDialect(knex);
   return dialect === 'oracle' || dialect === 'oracledb';
 }
 
-function isMySql(knex) {
+export function isMySql(knex) {
   const dialect = getDialect(knex);
   return dialect === 'mysql' || dialect === 'mysql2';
 }
 
-function isSqlite(knex) {
+export function isSqlite(knex) {
   return getDialect(knex) === 'sqlite3';
 }
 
-function isMsSql(knex) {
+export function isMsSql(knex) {
   return getDialect(knex) === 'mssql';
 }
 
-// Only Postgres and SQL Server return the identifiers of all the rows inserted
-// by one query.
-function hasBatchInsert(knex) {
-  return isPostgres(knex) || isMsSql(knex);
+// Postgres, SQL Server and SQLite (through `returning`, since SQLite 3.35)
+// return the identifiers of all the rows inserted by one query.
+export function hasBatchInsert(knex) {
+  return isPostgres(knex) || isMsSql(knex) || isSqlite(knex);
 }
 
-// MySQL supports window functions since 8.0, MariaDB since 10.2. Without a
-// version, knex assumes the latest one, and so do we.
-function hasWindowFunctions(knex) {
-  const { version, isMariaDB } = knex.client;
+// knex inserts the rows of a SQLite batch with `select ... union all`, which
+// fills the columns that a row leaves out with NULL, not with their defaults.
+export function hasBatchInsertDefaults(knex) {
+  return !isSqlite(knex);
+}
 
-  if (isMySql(knex) && version) {
-    const [major, minor] = version.split('.').map(Number);
-    return isMariaDB ? major > 10 || (major === 10 && minor >= 2) : major >= 8;
+// The number of rows that fit into one query if each binds `parameters` values.
+// SQL Server binds 2100 values, Postgres 65535 and SQLite 999 (32766 since 3.32,
+// but builds may be older), and we leave a margin for the values that aren't
+// rows. The MySQL drivers inline the values in the query.
+export function getMaxRows(knex, parameters) {
+  const maxParameters = isMsSql(knex)
+    ? 2000
+    : isPostgres(knex)
+      ? 65000
+      : isSqlite(knex)
+        ? 900
+        : Infinity;
+  return Math.max(1, Math.floor(maxParameters / parameters));
+}
+
+// Filter the columns of `refs` by a list of keys, which are arrays of values for
+// composite keys, with as few bound values as possible, see `getMaxRows()`:
+// Postgres binds single keys as one array, SQLite and SQL Server (2016 or newer
+// for `openjson`) all keys as one JSON array, and the MySQL drivers inline the
+// values. Composite keys on Postgres and keys that JSON can't represent, like
+// binary ids, bind one value per column.
+export function whereInKeys(builder, refs, keys) {
+  const knex = builder.knex();
+  const isComposite = refs.length > 1;
+  const values = isComposite ? keys : keys.map(asSingle);
+  const json = values.flat().every((value) => isString(value) || isNumber(value))
+    ? JSON.stringify(values)
+    : null;
+
+  if (isPostgres(knex) && !isComposite) {
+    return builder.whereRaw('? = any(?)', [refs[0], values]);
+  } else if (json && isSqlite(knex) && isComposite) {
+    const columns = refs.map(() => '?').join(', ');
+    const selects = refs.map((_, index) => `json_extract(value, '$[${index}]')`).join(', ');
+    return builder.whereRaw(`(${columns}) in (select ${selects} from json_each(?))`, [
+      ...refs,
+      json,
+    ]);
+  } else if (json && isSqlite(knex)) {
+    return builder.whereRaw('? in (select value from json_each(?))', [refs[0], json]);
+  } else if (json && isMsSql(knex) && isComposite) {
+    // SQL Server doesn't support row values in `in`:
+    const conditions = refs.map((_, index) => `? = json_value(value, '$[${index}]')`).join(' and ');
+    return builder.whereRaw(`exists (select 1 from openjson(?) where ${conditions})`, [
+      json,
+      ...refs,
+    ]);
+  } else if (json && isMsSql(knex)) {
+    return builder.whereRaw('? in (select value from openjson(?))', [refs[0], json]);
   } else {
-    return true;
+    return builder.whereInComposite(refs, keys);
   }
 }
 
-function isKnexQueryBuilder(value) {
+// The number of rows that one insert query can take: `getMaxRows()`, and the
+// limits on rows: SQLite compiles the rows to `select ... union all`, and limits
+// a compound select to 500 terms, and SQL Server limits `values` to 1000 rows.
+export function getMaxInsertRows(knex, parameters) {
+  const maxRows = isSqlite(knex) ? 500 : isMsSql(knex) ? 1000 : Infinity;
+  return Math.min(maxRows, getMaxRows(knex, parameters));
+}
+
+// The `pg` drivers return `json` and `jsonb` columns parsed, and `text` columns
+// as text.
+export function isJsonParsedByDriver(knex) {
+  return ['pg', 'pgnative', 'cockroachdb'].includes(knex.client.driverName);
+}
+
+export function isKnexQueryBuilder(value) {
   return (
     hasConstructor(value) &&
     isFunction(value.select) &&
@@ -65,33 +124,18 @@ function isKnexQueryBuilder(value) {
   );
 }
 
-function isKnexJoinBuilder(value) {
+export function isKnexJoinBuilder(value) {
   return hasConstructor(value) && value.grouping === 'join' && 'joinType' in value;
 }
 
-function isKnexRaw(value) {
+export function isKnexRaw(value) {
   return hasConstructor(value) && value.isRawInstance && 'client' in value;
 }
 
-function isKnexTransaction(knex) {
+export function isKnexTransaction(knex) {
   return !!getDialect(knex) && isFunction(knex.commit) && isFunction(knex.rollback);
 }
 
 function hasConstructor(value) {
   return isObject(value) && isFunction(value.constructor);
 }
-
-module.exports = {
-  getDialect,
-  isPostgres,
-  isMySql,
-  isSqlite,
-  isMsSql,
-  isOracle,
-  hasBatchInsert,
-  hasWindowFunctions,
-  isKnexQueryBuilder,
-  isKnexJoinBuilder,
-  isKnexRaw,
-  isKnexTransaction,
-};