fix: resolve various db2 issues

dev/db2/11.5/.env_list

@@ -1,7 +1,6 @@
 LICENSE=accept
 DB2INSTANCE=db2inst1
 DB2INST1_PASSWORD=password
-DBNAME=testdb
 BLU=false
 ENABLE_ORACLE_COMPATIBILITY=false
 UPDATEAVAIL=NO
@@ -12,4 +11,4 @@ PERSISTENT_HOME=false
 HADR_ENABLED=false
 ETCD_ENDPOINT=
 ETCD_USERNAME=
-ETCD_PASSWORD=
+ETCD_PASSWORD=

dev/db2/11.5/start.sh

@@ -1,5 +1,9 @@
 cd dev/db2/11.5
+
 export DIALECT=db2
+SEQ_DB="${SEQ_DB:-testdb}"
+# db2 db names must be uppercase
+SEQ_DB=$(echo "$SEQ_DB" | awk '{print toupper($0)}')
 
 mkdir -p Docker
 if [ ! "$(sudo docker ps -q -f name=db2server)" ]; then
@@ -9,7 +13,7 @@ if [ ! "$(sudo docker ps -q -f name=db2server)" ]; then
     sudo docker rm -f db2server
 		sudo rm -rf /Docker
 	fi
-	sudo docker run -h db2server --name db2server --restart=always --detach --privileged=true -p 50000:50000 --env-file .env_list -v /Docker:/database ibmcom/db2-amd64:11.5.6.0a
+	sudo docker run -h db2server --name db2server --restart=always --detach --privileged=true -p 50000:50000 --env "DBNAME=$SEQ_DB" --env-file .env_list -v /Docker:/database ibmcom/db2-amd64:11.5.7.0
 	count=1
 	while true
 	do
@@ -18,7 +22,7 @@ if [ ! "$(sudo docker ps -q -f name=db2server)" ]; then
 		sudo docker exec db2server bash -c "su db2inst1 & disown"
 		break
 	  fi
-	  if ($count -gt 30); then
+	  if [ $count -gt 30 ]; then
 		echo "Error: Db2 docker setup has not completed in 10 minutes."
 		break
 	  fi

src/dialects/abstract/query-generator.js

@@ -613,32 +613,39 @@ export class AbstractQueryGenerator {
       options.where = this.whereQuery(options.where);
     }
 
-    if (typeof tableName === 'string') {
-      tableName = this.quoteIdentifiers(tableName);
-    } else {
-      tableName = this.quoteTable(tableName);
-    }
+    const escapedTableName = typeof tableName === 'string' ? this.quoteIdentifiers(tableName) : this.quoteTable(tableName);
 
     const concurrently = this._dialect.supports.index.concurrently && options.concurrently ? 'CONCURRENTLY' : undefined;
     let ind;
     if (this._dialect.supports.indexViaAlter) {
       ind = [
         'ALTER TABLE',
-        tableName,
+        escapedTableName,
         concurrently,
         'ADD',
       ];
     } else {
       ind = ['CREATE'];
     }
 
+    // DB2 incorrectly scopes the index if we don't specify the schema name,
+    // which will cause it to error if another schema contains a table that uses an index with an identical name
+    const escapedIndexName = tableName.schema && this.dialect === 'db2'
+      // 'quoteTable' isn't the best name: it quotes any identifier.
+      // in this case, the goal is to produce '"schema_name"."index_name"' to scope the index in this schema
+      ? this.quoteTable({
+        schema: tableName.schema,
+        tableName: options.name,
+      })
+      : this.quoteIdentifiers(options.name);
+
     ind = ind.concat(
       options.unique ? 'UNIQUE' : '',
       options.type, 'INDEX',
       !this._dialect.supports.indexViaAlter ? concurrently : undefined,
-      this.quoteIdentifiers(options.name),
+      escapedIndexName,
       this._dialect.supports.index.using === 1 && options.using ? `USING ${options.using}` : '',
-      !this._dialect.supports.indexViaAlter ? `ON ${tableName}` : undefined,
+      !this._dialect.supports.indexViaAlter ? `ON ${escapedTableName}` : undefined,
       this._dialect.supports.index.using === 2 && options.using ? `USING ${options.using}` : '',
       `(${fieldsSql.join(', ')})`,
       this._dialect.supports.index.parser && options.parser ? `WITH PARSER ${options.parser}` : undefined,

src/dialects/db2/query-generator.js

@@ -33,17 +33,23 @@ export class Db2QueryGenerator extends AbstractQueryGenerator {
     ].join(' ');
   }
 
+  _errorTableCount = 0;
+
   dropSchema(schema) {
     // DROP SCHEMA Can't drop schema if it is not empty.
     // DROP SCHEMA Can't drop objects belonging to the schema
     // So, call the admin procedure to drop schema.
-    const query = `CALL SYSPROC.ADMIN_DROP_SCHEMA(${wrapSingleQuote(schema.trim())}, NULL, $sequelize_1, $sequelize_2)`;
+    const query = `CALL SYSPROC.ADMIN_DROP_SCHEMA(${wrapSingleQuote(schema.trim())}, NULL, $sequelize_errorSchema, $sequelize_errorTable)`;
+
+    if (this._errorTableCount >= Number.MAX_SAFE_INTEGER) {
+      this._errorTableCount = 0;
+    }
 
     return {
       query,
       bind: {
-        sequelize_1: { ParamType: 'INOUT', Data: 'ERRORSCHEMA' },
-        sequelize_2: { ParamType: 'INOUT', Data: 'ERRORTABLE' },
+        sequelize_errorSchema: { ParamType: 'INOUT', Data: 'ERRORSCHEMA' },
+        sequelize_errorTable: { ParamType: 'INOUT', Data: `ERRORTABLE${this._errorTableCount++}` },
       },
     };
   }
@@ -58,7 +64,7 @@ export class Db2QueryGenerator extends AbstractQueryGenerator {
   }
 
   createTableQuery(tableName, attributes, options) {
-    const query = 'CREATE TABLE <%= table %> (<%= attributes %>)';
+    const query = 'CREATE TABLE IF NOT EXISTS <%= table %> (<%= attributes %>)';
     const primaryKeys = [];
     const foreignKeys = {};
     const attrStr = [];
@@ -185,15 +191,6 @@ export class Db2QueryGenerator extends AbstractQueryGenerator {
     return 'SELECT TABNAME AS "tableName", TRIM(TABSCHEMA) AS "tableSchema" FROM SYSCAT.TABLES WHERE TABSCHEMA = USER AND TYPE = \'T\' ORDER BY TABSCHEMA, TABNAME';
   }
 
-  dropTableQuery(tableName) {
-    const query = 'DROP TABLE <%= table %>';
-    const values = {
-      table: this.quoteTable(tableName),
-    };
-
-    return `${_.template(query, this._templateSettings)(values).trim()};`;
-  }
-
   addColumnQuery(table, key, dataType) {
     dataType.field = key;
 

src/dialects/db2/query-interface.js

@@ -1,5 +1,6 @@
 'use strict';
 
+import { AggregateError, DatabaseError } from '../../errors';
 import { assertNoReservedBind } from '../../utils/sql';
 
 const _ = require('lodash');
@@ -84,6 +85,61 @@ export class Db2QueryInterface extends QueryInterface {
     return [result, undefined];
   }
 
+  async dropSchema(schema, options) {
+    const outParams = new Map();
+
+    // DROP SCHEMA works in a weird way in DB2:
+    // Its query uses ADMIN_DROP_SCHEMA, which stores the error message in a table
+    // specified by two IN-OUT parameters.
+    // If the returned values for these parameters is not null, then an error occurred.
+    const response = await super.dropSchema(schema, {
+      ...options,
+      // TODO: db2 supports out parameters. We don't have a proper API for it yet
+      //   for now, this temporary API will have to do.
+      _unsafe_db2Outparams: outParams,
+    });
+
+    const errorTable = outParams.get('sequelize_errorTable');
+    if (errorTable != null) {
+      const errorSchema = outParams.get('sequelize_errorSchema');
+
+      const errorData = await this.sequelize.queryRaw(`SELECT * FROM "${errorSchema}"."${errorTable}"`, {
+        type: QueryTypes.SELECT,
+      });
+
+      // replicate the data ibm_db adds on an error object
+      const error = new Error(errorData[0].DIAGTEXT);
+      error.sqlcode = errorData[0].SQLCODE;
+      error.sql = errorData[0].STATEMENT;
+      error.state = errorData[0].SQLSTATE;
+
+      const wrappedError = new DatabaseError(error);
+
+      try {
+        await this.dropTable({
+          tableName: errorTable,
+          schema: errorSchema,
+        });
+      } catch (dropError) {
+        throw new AggregateError([
+          wrappedError,
+          new Error(`An error occurred while cleaning up table ${errorSchema}.${errorTable}`, { cause: dropError }),
+        ]);
+      }
+
+      // -204 is "name is undefined" (schema does not exist)
+      // 'queryInterface.dropSchema' is supposed to be DROP SCHEMA IF EXISTS
+      // so we can ignore this error
+      if (error.sqlcode === -204 && error.state === '42704') {
+        return response;
+      }
+
+      throw wrappedError;
+    }
+
+    return response;
+  }
+
   async createTable(tableName, attributes, options, model) {
     let sql = '';
 
@@ -122,4 +178,35 @@ export class Db2QueryInterface extends QueryInterface {
     return await this.sequelize.queryRaw(sql, options);
   }
 
+  async addConstraint(tableName, options) {
+    try {
+      return await super.addConstraint(tableName, options);
+    } catch (error) {
+      if (!error.cause) {
+        throw error;
+      }
+
+      // Operation not allowed for reason code "7" on table "DB2INST1.users".  SQLSTATE=57007
+      if (error.cause.sqlcode !== -668 || error.cause.state !== '57007') {
+        throw error;
+      }
+
+      // https://www.ibm.com/support/pages/how-verify-and-resolve-sql0668n-reason-code-7-when-accessing-table
+      await this.executeTableReorg(tableName);
+      await super.addConstraint(tableName, options);
+    }
+  }
+
+  /**
+   * DB2 can put tables in the "reorg pending" state after a structure change (e.g. ALTER)
+   * Other changes cannot be done to these tables until the reorg has been completed.
+   *
+   * This method forces a reorg to happen now.
+   *
+   * @param {TableName} tableName - The name of the table to reorg
+   */
+  async executeTableReorg(tableName) {
+    // https://www.ibm.com/support/pages/sql0668n-operating-not-allowed-reason-code-7-seen-when-querying-or-viewing-table-db2-warehouse-cloud-and-db2-cloud
+    return await this.sequelize.query(`CALL SYSPROC.ADMIN_CMD('REORG TABLE ${this.queryGenerator.quoteTable(tableName)}')`);
+  }
 }

src/dialects/db2/query.js

@@ -95,6 +95,8 @@ export class Db2Query extends AbstractQuery {
 
         const SQL = this.sql.toUpperCase();
         let newSql = this.sql;
+
+        // TODO: move this to Db2QueryGenerator
         if ((this.isSelectQuery() || _.startsWith(SQL, 'SELECT '))
             && !SQL.includes(' FROM ', 8)) {
           if (this.sql.charAt(this.sql.length - 1) === ';') {
@@ -112,6 +114,17 @@ export class Db2Query extends AbstractQuery {
           stmt.execute(params, (err, result, outparams) => {
             debug(`executed(${this.connection.uuid || 'default'}):${newSql} ${parameters ? util.inspect(parameters, { compact: true, breakLength: Infinity }) : ''}`);
 
+            // map the INOUT parameters to the name provided by the dev
+            // this is an internal API, not yet ready for dev consumption, hence the _unsafe_ prefix.
+            if (outparams && this.options.bindParameterOrder && this.options._unsafe_db2Outparams) {
+              for (let i = 0; i < this.options.bindParameterOrder.length; i++) {
+                const paramName = this.options.bindParameterOrder[i];
+                const paramValue = outparams[i];
+
+                this.options._unsafe_db2Outparams.set(paramName, paramValue);
+              }
+            }
+
             if (benchmark) {
               this.sequelize.log(`Executed (${this.connection.uuid || 'default'}): ${newSql} ${parameters ? util.inspect(parameters, { compact: true, breakLength: Infinity }) : ''}`, Date.now() - queryBegin, this.options);
             }
@@ -190,51 +203,10 @@ export class Db2Query extends AbstractQuery {
   }
 
   filterSQLError(err, sql, connection) {
-    if (err.message.search('SQL0204N') !== -1 && _.startsWith(sql, 'DROP ')) {
-      err = null; // Ignore table not found error for drop table.
-    } else if (err.message.search('SQL0443N') !== -1) {
-      if (this.isDropSchemaQuery()) {
-        // Delete ERRORSCHEMA.ERRORTABLE if it exist.
-        connection.querySync('DROP TABLE ERRORSCHEMA.ERRORTABLE;');
-        // Retry deleting the schema
-        connection.querySync(this.sql);
-      }
-
-      err = null; // Ignore drop schema error.
-    } else if (err.message.search('SQL0601N') !== -1) {
-      const match = err.message.match(/SQL0601N {2}The name of the object to be created is identical to the existing name "(.*)" of type "(.*)"./);
-      if (match && match.length > 1 && match[2] === 'TABLE') {
-        let table;
-        const mtarray = match[1].split('.');
-        if (mtarray[1]) {
-          table = `"${mtarray[0]}"."${mtarray[1]}"`;
-        } else {
-          table = `"${mtarray[0]}"`;
-        }
-
-        if (connection.dropTable !== false) {
-          connection.querySync(`DROP TABLE ${table}`);
-          err = connection.querySync(sql);
-        } else {
-          err = null;
-        }
-      } else {
-        err = null; // Ignore create schema error.
-      }
-    } else if (err.message.search('SQL0911N') !== -1) {
-      if (err.message.search('Reason code "2"') !== -1) {
-        err = null; // Ignore deadlock error due to program logic.
-      }
-    } else if (err.message.search('SQL0605W') !== -1) {
-      err = null; // Ignore warning.
-    } else if (err.message.search('SQL0668N') !== -1
-      && _.startsWith(sql, 'ALTER TABLE ')) {
-      connection.querySync(`CALL SYSPROC.ADMIN_CMD('REORG TABLE ${sql.slice(12).split(' ')[0]}')`);
-      err = connection.querySync(sql);
-    }
-
-    if (err && err.length === 0) {
-      err = null;
+    // This error is safe to ignore:
+    // [IBM][CLI Driver][DB2/LINUXX8664] SQL0605W  The index was not created because an index "x" with a matching definition already exists.  SQLSTATE=01550
+    if (err.message.search('SQL0605W') !== -1) {
+      return null;
     }
 
     return err;

src/sequelize.js

@@ -526,9 +526,10 @@ Only bind parameters can be provided, in the dialect-specific syntax.
 Use Sequelize#query if you wish to use replacements.`);
     }
 
-    options = { ...this.options.query, ...options };
+    options = { ...this.options.query, ...options, bindParameterOrder: null };
 
     let bindParameters;
+    let bindParameterOrder;
     if (options.bind != null) {
       const isBindArray = Array.isArray(options.bind);
       if (!isPlainObject(options.bind) && !isBindArray) {
@@ -549,6 +550,8 @@ Use Sequelize#query if you wish to use replacements.`);
 
       sql = mappedResult.sql;
 
+      // used by dialects that support "INOUT" parameters to map the OUT parameters back the the name the dev used.
+      options.bindParameterOrder = mappedResult.bindOrder;
       if (mappedResult.bindOrder == null) {
         bindParameters = options.bind;
       } else {

test/integration/model.test.js

@@ -2145,7 +2145,7 @@ describe(Support.getTestDialectTeaser('Model'), () => {
       const expectedLengths = {
         mssql: 2,
         postgres: 2,
-        db2: 10,
+        db2: 2,
         mariadb: 3,
         mysql: 1,
         sqlite: 1,