sails-sqlite 0.1.0 → 0.2.0

package/lib/index.js

@@ -18,7 +18,11 @@ const DRY_MACHINES = {
   definePhysicalModel: require('./private/machines/define-physical-model'),
   dropPhysicalModel: require('./private/machines/drop-physical-model'),
   setPhysicalSequence: require('./private/machines/set-physical-sequence'),
-  join: require('./private/machines/join')
+  join: require('./private/machines/join'),
+  beginTransaction: require('./private/machines/begin-transaction'),
+  commitTransaction: require('./private/machines/commit-transaction'),
+  rollbackTransaction: require('./private/machines/rollback-transaction'),
+  leaseConnection: require('./private/machines/lease-connection')
 }
 
 const WET_MACHINES = Object.fromEntries(
@@ -255,11 +259,16 @@ module.exports = {
               )
             }
 
+            const modelDefinition = modelInfo.definition || modelInfo.attributes
+
             registeredDryModels[modelIdentity] = {
+              identity: modelIdentity,
               primaryKey: modelInfo.primaryKey,
-              attributes: modelInfo.definition || modelInfo.attributes,
+              definition: modelDefinition,
+              attributes: modelDefinition,
               tableName: modelInfo.tableName,
-              identity: modelInfo.identity
+              identity: modelInfo.identity,
+              datastore: datastoreName
             }
 
             // Uncomment for detailed debugging:
@@ -354,6 +363,14 @@ module.exports = {
               delete registeredDryModels[modelIdentity]
             }
           })
+
+          // Safety cleanup: If this is the last datastore being torn down,
+          // clear any remaining models to prevent registration conflicts
+          if (Object.keys(registeredDsEntries).length === 0) {
+            Object.keys(registeredDryModels).forEach((modelIdentity) => {
+              delete registeredDryModels[modelIdentity]
+            })
+          }
         } catch (err) {
           return done(err)
         }
@@ -533,30 +550,12 @@ module.exports = {
   //  ║║║╠═╣ ║ ║╚╗╔╝║╣    ││ │││││  └─┐│ │├─┘├─┘│ │├┬┘ │
   //  ╝╚╝╩ ╩ ╩ ╩ ╚╝ ╚═╝  └┘└─┘┴┘└┘  └─┘└─┘┴  ┴  └─┘┴└─ ┴
   // Build up native joins to run on the adapter.
-  join: function join(datastoreName, query, cb) {
-    var datastore = registeredDsEntries[datastoreName]
-    // Models are stored globally, not per datastore
-    var models = registeredDryModels
-
-    // Add redactPasswords function if not defined
-    function redactPasswords(err) {
-      // Simple implementation - in production you might want more sophisticated password redaction
-      return err
-    }
-
-    WET_MACHINES.join({
-      datastore: datastore,
-      models: models,
-      query: query
-    }).switch({
-      error: function error(err) {
-        return cb(redactPasswords(err))
-      },
-      success: function success(report) {
-        return cb(undefined, report)
-      }
-    })
-  },
+  join: buildStdAdapterMethod(
+    require('./private/machines/join'),
+    WET_MACHINES,
+    registeredDsEntries,
+    registeredDryModels
+  ),
   //////////////////////////////////////////////////////////////////////////////////////////////////
   //  ██████╗  ██████╗ ██╗                                                                        //
   //  ██╔══██╗██╔═══██╗██║                                                                        //
@@ -924,5 +923,182 @@ module.exports = {
    *
    * > https://github.com/node-machine/driver-interface/blob/master/layers/migratable/set-physical-sequence.js
    */
-  setPhysicalSequence: DRY_MACHINES.setPhysicalSequence
+  setPhysicalSequence: DRY_MACHINES.setPhysicalSequence,
+
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //  ████████╗██████╗  █████╗ ███╗   ███╗███████╗ █████╗  ██████╗████████╗██╗ ██████╗ ███╗   ██╗ //
+  //  ╚══██╔══╝██╔══██╗██╔══██╗████╗ ████║██╔════╝██╔══██╗██╔════╝╚══██╔══╝██║██╔═══██╗████╗  ██║ //
+  //     ██║   ██████╔╝███████║██╔████╔██║███████╗███████║██║        ██║   ██║██║   ██║██╔██╗ ██║ //
+  //     ██║   ██╔══██╗██╔══██║██║╚██╔╝██║╚════██║██╔══██║██║        ██║   ██║██║   ██║██║╚██╗██║ //
+  //     ██║   ██║  ██║██║  ██║██║ ╚═╝ ██║███████║██║  ██║╚██████╗   ██║   ██║╚██████╔╝██║ ╚████║ //
+  //     ╚═╝   ╚═╝  ╚═╝╚═╝  ╚═╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝ ╚═════╝   ╚═╝   ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ //
+  //                                                                                              //
+  // Transaction methods:                                                                         //
+  // Methods related to database transactions (begin, commit, rollback).                         //
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+
+  /**
+   *  ╔╗ ╔═╗╔═╗╦╔╗╔  ┌┬┐┬─┐┌─┐┌┐┌┌─┐┌─┐┌─┐┌┬┐┬┌─┐┌┐┌
+   *  ╠╩╗║╣ ║ ╦║║║║   │ ├┬┘├─┤│││└─┐├─┤│   │ ││ ││││
+   *  ╚═╝╚═╝╚═╝╩╝╚╝   ┴ ┴└─┴ ┴┘└┘└─┘┴ ┴└─┘ ┴ ┴└─┘┘└┘
+   * Begin a new database transaction.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {String}       datastoreName   The name of the datastore to perform the query on.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Dictionary}   options         Transaction options (connection, meta).
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Function}     done            Callback
+   *               @param {Error?}
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   */
+  beginTransaction: function (datastoreName, options, done) {
+    const dsEntry = registeredDsEntries[datastoreName]
+    const connection = options.connection
+    const meta = options.meta || {}
+
+    if (!dsEntry) {
+      return done(
+        new Error(
+          `Consistency violation: Cannot do that with datastore (${datastoreName}) because no matching datastore entry is registered in this adapter! This is usually due to a race condition (e.g. a lifecycle callback still running after the ORM has been torn down), or it could be due to a bug in this adapter. (If you get stumped, reach out at http://sailsjs.com/support.)`
+        )
+      )
+    }
+
+    WET_MACHINES.beginTransaction({
+      connection: connection,
+      meta: meta
+    }).switch({
+      error: function (err) {
+        return done(err)
+      },
+      success: function () {
+        return done()
+      }
+    })
+  },
+
+  /**
+   *  ╔═╗╔═╗╔╦╗╔╦╗╦╔╦╗  ┌┬┐┬─┐┌─┐┌┐┌┌─┐┌─┐┌─┐┌┬┐┬┌─┐┌┐┌
+   *  ║  ║ ║║║║║║║║ ║    │ ├┬┘├─┤│││└─┐├─┤│   │ ││ ││││
+   *  ╚═╝╚═╝╩ ╩╩ ╩╩ ╩    ┴ ┴└─┴ ┴┘└┘└─┘┴ ┴└─┘ ┴ ┴└─┘┘└┘
+   * Commit the database transaction on the provided connection.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {String}       datastoreName   The name of the datastore to perform the query on.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Dictionary}   options         Transaction options (connection, meta).
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Function}     done            Callback
+   *               @param {Error?}
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   */
+  commitTransaction: function (datastoreName, options, done) {
+    const dsEntry = registeredDsEntries[datastoreName]
+    const connection = options.connection
+    const meta = options.meta || {}
+
+    if (!dsEntry) {
+      return done(
+        new Error(
+          `Consistency violation: Cannot do that with datastore (${datastoreName}) because no matching datastore entry is registered in this adapter! This is usually due to a race condition (e.g. a lifecycle callback still running after the ORM has been torn down), or it could be due to a bug in this adapter. (If you get stumped, reach out at http://sailsjs.com/support.)`
+        )
+      )
+    }
+
+    WET_MACHINES.commitTransaction({
+      connection: connection,
+      meta: meta
+    }).switch({
+      error: function (err) {
+        return done(err)
+      },
+      success: function () {
+        return done()
+      }
+    })
+  },
+
+  /**
+   *  ╦═╗╔═╗╦  ╦  ╔╗ ╔═╗╔═╗╦╔═
+   *  ╠╦╝║ ║║  ║  ╠╩╗╠═╣║  ╠╩╗
+   *  ╩╚═╚═╝╩═╝╩═╝╚═╝╩ ╩╚═╝╩ ╩
+   *  ┌┬┐┬─┐┌─┐┌┐┌┌─┐┌─┐┌─┐┌┬┐┬┌─┐┌┐┌
+   *   │ ├┬┘├─┤│││└─┐├─┤│   │ ││ ││││
+   *   ┴ ┴└─┴ ┴┘└┘└─┘┴ ┴└─┘ ┴ ┴└─┘┘└┘
+   * Rollback the database transaction on the provided connection.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {String}       datastoreName   The name of the datastore to perform the query on.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Dictionary}   options         Transaction options (connection, meta).
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Function}     done            Callback
+   *               @param {Error?}
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   */
+  rollbackTransaction: function (datastoreName, options, done) {
+    const dsEntry = registeredDsEntries[datastoreName]
+    const connection = options.connection
+    const meta = options.meta || {}
+
+    if (!dsEntry) {
+      return done(
+        new Error(
+          `Consistency violation: Cannot do that with datastore (${datastoreName}) because no matching datastore entry is registered in this adapter! This is usually due to a race condition (e.g. a lifecycle callback still running after the ORM has been torn down), or it could be due to a bug in this adapter. (If you get stumped, reach out at http://sailsjs.com/support.)`
+        )
+      )
+    }
+
+    WET_MACHINES.rollbackTransaction({
+      connection: connection,
+      meta: meta
+    }).switch({
+      error: function (err) {
+        return done(err)
+      },
+      success: function () {
+        return done()
+      }
+    })
+  },
+
+  /**
+   *  ╦  ╔═╗╔═╗╔═╗╔═╗  ┌─┐┌─┐┌┐┌┌┐┌┌─┐┌─┐┌┬┐┬┌─┐┌┐┌
+   *  ║  ║╣ ╠═╣╚═╗║╣   │  │ │││││││├┤ │   │ ││ ││││
+   *  ╩═╝╚═╝╩ ╩╚═╝╚═╝  └─┘└─┘┘└┘┘└┘└─┘└─┘ ┴ ┴└─┘┘└┘
+   * Lease a connection from the datastore for use in a transaction.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {String}       datastoreName   The name of the datastore to lease from.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Dictionary}   meta            Meta options.
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   * @param  {Function}     done            Callback
+   *               @param {Error?}
+   *               @param {Dictionary?} connection
+   * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+   */
+  leaseConnection: function (datastoreName, meta, done) {
+    const dsEntry = registeredDsEntries[datastoreName]
+
+    if (!dsEntry) {
+      return done(
+        new Error(
+          `Consistency violation: Cannot do that with datastore (${datastoreName}) because no matching datastore entry is registered in this adapter! This is usually due to a race condition (e.g. a lifecycle callback still running after the ORM has been torn down), or it could be due to a bug in this adapter. (If you get stumped, reach out at http://sailsjs.com/support.)`
+        )
+      )
+    }
+
+    WET_MACHINES.leaseConnection({
+      manager: dsEntry.manager,
+      meta: meta || {}
+    }).switch({
+      error: function (err) {
+        return done(err)
+      },
+      failed: function (err) {
+        return done(err)
+      },
+      success: function (connection) {
+        return done(null, connection)
+      }
+    })
+  }
 }

package/lib/private/build-std-adapter-method.js

@@ -48,10 +48,14 @@ module.exports = function buildStdAdapterMethod(
 
     // Only add notUnique handler if the machine defines this exit
     if (machineDef.exits.notUnique) {
-      switchHandlers.notUnique = function (err) {
-        return done(
-          Object.assign(new Error('Not unique'), { code: 'E_UNIQUE' })
-        )
+      switchHandlers.notUnique = function (errInfo) {
+        // Create error in same format as sails-postgresql
+        const e = new Error(errInfo.message || 'Not unique')
+        e.code = 'E_UNIQUE'
+        if (errInfo.footprint) {
+          e.footprint = errInfo.footprint
+        }
+        return done(e)
       }
     }
 

package/lib/private/machines/avg-records.js

@@ -58,7 +58,7 @@ module.exports = {
     const db = inputs.connection
 
     try {
-      let avgQuery = `SELECT COALESCE(AVG(${numericFieldName}), 0) as average FROM ${tableName}`
+      let avgQuery = `SELECT COALESCE(AVG(\`${numericFieldName}\`), 0) as average FROM \`${tableName}\``
       if (whereClause) {
         avgQuery += ` WHERE ${whereClause}`
       }

package/lib/private/machines/begin-transaction.js

@@ -0,0 +1,51 @@
+/**
+ * Module dependencies
+ */
+
+/**
+ * Begin Transaction
+ *
+ * Begin a new database transaction on the provided connection.
+ */
+
+module.exports = {
+  friendlyName: 'Begin transaction',
+
+  description: 'Begin a new database transaction on the provided connection.',
+
+  moreInfoUrl:
+    'https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#transactionfunction---function',
+
+  inputs: {
+    connection: {
+      description:
+        'An active database connection that was acquired from a manager.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      description: 'Additional options for this query.',
+      example: '==='
+    }
+  },
+
+  fn: function beginTransaction(inputs, exits) {
+    const db = inputs.connection
+    const meta = inputs.meta || {}
+
+    try {
+      if (db.inTransaction) {
+        return exits.error(
+          new Error('Transaction is already active on this connection.')
+        )
+      }
+
+      db.prepare('BEGIN TRANSACTION').run()
+
+      return exits.success()
+    } catch (err) {
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/commit-transaction.js

@@ -0,0 +1,50 @@
+/**
+ * Module dependencies
+ */
+
+/**
+ * Commit Transaction
+ *
+ * Commit the current database transaction on the provided connection.
+ */
+
+module.exports = {
+  friendlyName: 'Commit transaction',
+
+  description:
+    'Commit the current database transaction on the provided connection.',
+
+  moreInfoUrl:
+    'https://github.com/WiseLibs/better-sqlite3/blob/master/docs/api.md#transactionfunction---function',
+
+  inputs: {
+    connection: {
+      description:
+        'An active database connection that was acquired from a manager.',
+      example: '===',
+      required: true
+    },
+
+    meta: {
+      description: 'Additional options for this query.',
+      example: '==='
+    }
+  },
+
+  fn: function commitTransaction(inputs, exits) {
+    const db = inputs.connection
+    const meta = inputs.meta || {}
+
+    try {
+      if (!db.inTransaction) {
+        return exits.error(new Error('No active transaction to commit.'))
+      }
+
+      db.prepare('COMMIT TRANSACTION').run()
+
+      return exits.success()
+    } catch (err) {
+      return exits.error(err)
+    }
+  }
+}

package/lib/private/machines/count-records.js

@@ -62,7 +62,7 @@ module.exports = {
     const db = inputs.connection
 
     try {
-      let countQuery = `SELECT COUNT(*) as count FROM ${tableName}`
+      let countQuery = `SELECT COUNT(*) as count FROM \`${tableName}\``
       if (whereClause) {
         countQuery += ` WHERE ${whereClause}`
       }

package/lib/private/machines/create-each-record.js

@@ -94,7 +94,7 @@ module.exports = {
         )
       }
 
-      const columns = columnNames.join(', ')
+      const columns = columnNames.map((col) => `\`${col}\``).join(', ')
       const valueClause = `(${columnNames.map(() => '?').join(', ')})`
       const allValueClauses = Array(s3q.newRecords.length)
         .fill(valueClause)

package/lib/private/machines/create-record.js

@@ -74,7 +74,7 @@ module.exports = {
       }
 
       // Prepare the INSERT statement with proper SQL escaping
-      const columns = columnNames.join(', ')
+      const columns = columnNames.map((col) => `\`${col}\``).join(', ')
       const placeholders = columnNames.map(() => '?').join(', ')
       const sql = `INSERT INTO \`${tableName}\` (${columns}) VALUES (${placeholders})`
 
@@ -94,7 +94,7 @@ module.exports = {
       }
 
       // Otherwise, fetch the newly created record
-      const selectSql = `SELECT * FROM ${tableName} WHERE rowid = ?`
+      const selectSql = `SELECT * FROM \`${tableName}\` WHERE rowid = ?`
       const selectStmt = db.prepare(selectSql)
       const phRecord = selectStmt.get(info.lastInsertRowid)
 

package/lib/private/machines/define-physical-model.js

@@ -61,15 +61,20 @@ module.exports = {
       }
     }
 
+    // Check if we're already in a transaction
+    const wasInTransaction = db.inTransaction
+
     try {
-      // Start a transaction
-      db.prepare('BEGIN').run()
+      // Start a transaction only if we're not already in one
+      if (!wasInTransaction) {
+        db.prepare('BEGIN').run()
+      }
 
       // Build and execute the CREATE TABLE statement
-      let createTableSQL = `CREATE TABLE IF NOT EXISTS ${inputs.tableName} (`
+      let createTableSQL = `CREATE TABLE IF NOT EXISTS \`${inputs.tableName}\` (`
       let columnDefs = inputs.columns.map((column) => {
         const columnType = column.columnType ?? column.type
-        let def = `${column.columnName} ${column.autoIncrement ? 'INTEGER' : getSqliteType(columnType)}`
+        let def = `\`${column.columnName}\` ${column.autoIncrement ? 'INTEGER' : getSqliteType(columnType)}`
         if (column.autoIncrement) {
           def += ' PRIMARY KEY AUTOINCREMENT NOT NULL'
         }
@@ -82,18 +87,22 @@ module.exports = {
       // Create indexes
       inputs.columns.forEach((column) => {
         if (column.unique && !column.autoIncrement) {
-          const indexSQL = `CREATE UNIQUE INDEX IF NOT EXISTS idx_${inputs.tableName}_${column.columnName} ON ${inputs.tableName} (${column.columnName})`
+          const indexSQL = `CREATE UNIQUE INDEX IF NOT EXISTS \`idx_${inputs.tableName}_${column.columnName}\` ON \`${inputs.tableName}\` (\`${column.columnName}\`)`
           db.prepare(indexSQL).run()
         }
       })
 
-      // Commit the transaction
-      db.prepare('COMMIT').run()
+      // Commit the transaction only if we started it
+      if (!wasInTransaction) {
+        db.prepare('COMMIT').run()
+      }
 
       return exits.success()
     } catch (error) {
-      // If there's an error, roll back the transaction
-      db.prepare('ROLLBACK').run()
+      // If there's an error, roll back the transaction (only if we started it)
+      if (!wasInTransaction) {
+        db.prepare('ROLLBACK').run()
+      }
       return exits.error(
         new Error(`Error defining table ${inputs.tableName}: ${error.message}`)
       )

package/lib/private/machines/destroy-records.js

@@ -62,25 +62,36 @@ module.exports = {
 
     const db = inputs.connection
 
+    // Check if we're already in a transaction
+    const wasInTransaction = db.inTransaction
+
     try {
-      // Start a transaction
-      db.exec('BEGIN TRANSACTION')
+      // Start a transaction only if we're not already in one
+      if (!wasInTransaction) {
+        db.exec('BEGIN TRANSACTION')
+      }
 
       let phRecords
       if (isFetchEnabled) {
         // Fetch matching records before deletion
-        const selectSql = `SELECT * FROM ${tableName} WHERE ${sqliteWhere}`
+        const selectSql = sqliteWhere
+          ? `SELECT * FROM \`${tableName}\` WHERE ${sqliteWhere}`
+          : `SELECT * FROM \`${tableName}\``
         const selectStmt = db.prepare(selectSql)
         phRecords = selectStmt.all()
       }
 
       // Perform the deletion
-      const deleteSql = `DELETE FROM ${tableName} WHERE ${sqliteWhere}`
+      const deleteSql = sqliteWhere
+        ? `DELETE FROM \`${tableName}\` WHERE ${sqliteWhere}`
+        : `DELETE FROM \`${tableName}\``
       const deleteStmt = db.prepare(deleteSql)
       const deleteInfo = deleteStmt.run()
 
-      // Commit the transaction
-      db.exec('COMMIT')
+      // Commit the transaction only if we started it
+      if (!wasInTransaction) {
+        db.exec('COMMIT')
+      }
 
       if (!isFetchEnabled) {
         return exits.success()
@@ -93,8 +104,10 @@ module.exports = {
 
       return exits.success(phRecords)
     } catch (err) {
-      // Rollback the transaction in case of error
-      db.exec('ROLLBACK')
+      // Rollback the transaction in case of error (only if we started it)
+      if (!wasInTransaction) {
+        db.exec('ROLLBACK')
+      }
       return exits.error(err)
     }
   }

package/lib/private/machines/drop-physical-model.js

@@ -24,8 +24,8 @@ module.exports = {
     const db = inputs.connection
 
     try {
-      // SQL to drop the table
-      const dropTableSQL = `DROP TABLE IF EXISTS ${inputs.tableName}`
+      // SQL to drop the table (properly escape the table name)
+      const dropTableSQL = `DROP TABLE IF EXISTS \`${inputs.tableName}\``
 
       // Execute the drop table operation
       db.prepare(dropTableSQL).run()

package/lib/private/machines/find-records.js

@@ -57,12 +57,12 @@ module.exports = {
 
       // Handle SELECT clause
       if (s3q.criteria.select) {
-        sqlQuery += s3q.criteria.select.join(', ')
+        sqlQuery += s3q.criteria.select.map((col) => `\`${col}\``).join(', ')
       } else {
         sqlQuery += '*'
       }
 
-      sqlQuery += ` FROM ${tableName}`
+      sqlQuery += ` FROM \`${tableName}\``
 
       // Handle WHERE clause
       const whereClause = buildSqliteWhereClause(
@@ -79,7 +79,7 @@ module.exports = {
         const sortClauses = s3q.criteria.sort.map((sortObj) => {
           const key = Object.keys(sortObj)[0]
           const direction = sortObj[key] === 'ASC' ? 'ASC' : 'DESC'
-          return `${key} ${direction}`
+          return `\`${key}\` ${direction}`
         })
         sqlQuery += ` ORDER BY ${sortClauses.join(', ')}`
       }