From cc142b18bb88638a537c62e9fa96d64bdb9ba5a2 Mon Sep 17 00:00:00 2001 From: Geoffrey Park Date: Fri, 20 Dec 2024 17:57:35 +0900 Subject: [PATCH] Add tests for Altibase --- src/odbc_connection.cpp | 7 +- test/DBMS/_test.test.js | 3 +- test/DBMS/altibase/BIGINT.test.js | 120 +++++++ test/DBMS/altibase/BINARY.test.js | 62 ++++ test/DBMS/altibase/CHARACTER.test.js | 62 ++++ test/DBMS/altibase/CLOB.test.js | 45 +++ test/DBMS/altibase/DECIMAL.test.js | 125 +++++++ test/DBMS/altibase/INTEGER.test.js | 115 ++++++ test/DBMS/altibase/NUMERIC.test.js | 125 +++++++ test/DBMS/altibase/SMALLINT.test.js | 115 ++++++ test/DBMS/altibase/VARBINARY.test.js | 62 ++++ test/DBMS/altibase/VARCHAR.test.js | 45 +++ test/DBMS/altibase/XML.test.js | 70 ++++ test/DBMS/altibase/_test.test.js | 13 + test/DBMS/altibase/config.js | 436 +++++++++++++++++++++++ test/_test.test.js | 1 + test/connection/beginTransaction.test.js | 5 + test/connection/callProcedure.test.js | 37 +- test/connection/foreignkeys.test.js | 28 +- test/connection/primaryKeys.test.js | 16 +- test/queries/_test.test.js | 21 +- 21 files changed, 1484 insertions(+), 29 deletions(-) create mode 100644 test/DBMS/altibase/BIGINT.test.js create mode 100644 test/DBMS/altibase/BINARY.test.js create mode 100644 test/DBMS/altibase/CHARACTER.test.js create mode 100644 test/DBMS/altibase/CLOB.test.js create mode 100644 test/DBMS/altibase/DECIMAL.test.js create mode 100644 test/DBMS/altibase/INTEGER.test.js create mode 100644 test/DBMS/altibase/NUMERIC.test.js create mode 100644 test/DBMS/altibase/SMALLINT.test.js create mode 100644 test/DBMS/altibase/VARBINARY.test.js create mode 100644 test/DBMS/altibase/VARCHAR.test.js create mode 100644 test/DBMS/altibase/XML.test.js create mode 100644 test/DBMS/altibase/_test.test.js create mode 100644 test/DBMS/altibase/config.js diff --git a/src/odbc_connection.cpp b/src/odbc_connection.cpp index 32eccd1a..a72a8c55 100644 --- a/src/odbc_connection.cpp +++ b/src/odbc_connection.cpp @@ -1405,6 +1405,8 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker { data->parameters[i]->ParameterType = data->storedRows[i][SQLPROCEDURECOLUMNS_DATA_TYPE_INDEX].smallint_data; // DataType -> ParameterType data->parameters[i]->ColumnSize = data->storedRows[i][SQLPROCEDURECOLUMNS_COLUMN_SIZE_INDEX].integer_data; // ParameterSize -> ColumnSize data->parameters[i]->Nullable = data->storedRows[i][SQLPROCEDURECOLUMNS_NULLABLE_INDEX].smallint_data; + // Decimal digits are missing for IN and INOUT parameters. + data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; // For each parameter, need to manipulate the data buffer and C type // depending on what the InputOutputType is: @@ -1736,7 +1738,6 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker { data->parameters[i]->ValueType = SQL_C_CHAR; data->parameters[i]->ParameterValuePtr = new SQLCHAR[bufferSize]; data->parameters[i]->BufferLength = bufferSize; - data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; break; case SQL_DOUBLE: @@ -1744,28 +1745,24 @@ class CallProcedureAsyncWorker : public ODBCAsyncWorker { data->parameters[i]->ValueType = SQL_C_DOUBLE; data->parameters[i]->ParameterValuePtr = new SQLDOUBLE(); data->parameters[i]->BufferLength = sizeof(SQLDOUBLE); - data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; break; case SQL_TINYINT: data->parameters[i]->ValueType = SQL_C_UTINYINT; data->parameters[i]->ParameterValuePtr = new SQLCHAR(); data->parameters[i]->BufferLength = sizeof(SQLCHAR); - data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; break; case SQL_SMALLINT: data->parameters[i]->ValueType = SQL_C_SSHORT; data->parameters[i]->ParameterValuePtr = new SQLSMALLINT(); data->parameters[i]->BufferLength = sizeof(SQLSMALLINT); - data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; break; case SQL_INTEGER: data->parameters[i]->ValueType = SQL_C_SLONG; data->parameters[i]->ParameterValuePtr = new SQLINTEGER(); data->parameters[i]->BufferLength = sizeof(SQLINTEGER); - data->parameters[i]->DecimalDigits = data->storedRows[i][SQLPROCEDURECOLUMNS_DECIMAL_DIGITS_INDEX].smallint_data; break; case SQL_BIGINT: diff --git a/test/DBMS/_test.test.js b/test/DBMS/_test.test.js index edd8b96e..f4bcf31c 100644 --- a/test/DBMS/_test.test.js +++ b/test/DBMS/_test.test.js @@ -1,3 +1,4 @@ module.exports = { - ibmi: require('./ibmi/_test.test') + ibmi: require('./ibmi/_test.test'), + altibase: require('./altibase/_test.test') } diff --git a/test/DBMS/altibase/BIGINT.test.js b/test/DBMS/altibase/BIGINT.test.js new file mode 100644 index 00000000..7257d19b --- /dev/null +++ b/test/DBMS/altibase/BIGINT.test.js @@ -0,0 +1,120 @@ +module.exports = { + dataType: 'BIGINT', + configurations: [ + { + size: null, + options: null, + tests: [ + // These tests only run if the N-API version supports BigInt + ...(parseInt(process.versions.napi) >= 5 ? [ + { + name: 'BigInt -> BIGINT (min value)', + values: { + in: { + value: -9223372036854775807n, + expected: -9223372036854775807n, + }, + inout: { + value: -9223372036854775808n, + expected: -9223372036854775807n, + }, + out: { + value: null, + // expected: -9223372036854775808n, + expected: null, // In Altibase, 0x8000000000000000 is null + }, + } + }, + { + name: 'BigInt -> BIGINT (max value)', + values: { + in: { + value: 9223372036854775806n, + expected: 9223372036854775806n, + }, + inout: { + value: 9223372036854775807n, + expected: 9223372036854775806n, + }, + out: { + value: null, + expected: 9223372036854775807n, + }, + }, + }, + ] : []), + { + name: 'Number -> BIGINT [MIN_SAFE_INTEGER]', + values: { + in: { + value: Number.MIN_SAFE_INTEGER + 1, + expected: Number.MIN_SAFE_INTEGER + 1, + }, + inout: { + value: Number.MIN_SAFE_INTEGER, + expected: Number.MIN_SAFE_INTEGER + 1, + }, + out: { + value: null, + expected: BigInt(Number.MIN_SAFE_INTEGER), + }, + }, + }, + { + name: 'Number -> BIGINT [MAX_SAFE_INTEGER]', + values: { + in: { + value: Number.MAX_SAFE_INTEGER - 1, + expected: Number.MAX_SAFE_INTEGER - 1, + }, + inout: { + value: Number.MAX_SAFE_INTEGER, + expected: Number.MAX_SAFE_INTEGER - 1, + }, + out: { + value: null, + expected: BigInt(Number.MAX_SAFE_INTEGER), + }, + }, + }, + { + name: 'String -> BIGINT (min value)', + values: { + in: { + value: "-9223372036854775807", + expected: "-9223372036854775807", + }, + inout: { + // value: "-9223372036854775808", + value: "-9223372036854775807", // In Altibase minimum bigint value is -9223372036854775807 + expected: "-9223372036854775807", + }, + + out: { + value: null, + // binding '-9223372036854775808' makes Numeric value out of range error + expected: -9223372036854775807n, + }, + }, + }, + { + name: 'String -> BIGINT (max value)', + values: { + in: { + value: "9223372036854775806", + expected: "9223372036854775806", + }, + inout: { + value: "9223372036854775807", + expected: "9223372036854775806", + }, + out: { + value: null, + expected: 9223372036854775807n, + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/BINARY.test.js b/test/DBMS/altibase/BINARY.test.js new file mode 100644 index 00000000..65fc7a51 --- /dev/null +++ b/test/DBMS/altibase/BINARY.test.js @@ -0,0 +1,62 @@ +module.exports = { + dataType: 'BINARY', + configurations: [ + { + size: '(16)', + options: null, + tests: [ + { + name: 'Buffer -> BINARY', + values: { + in: { + value: Buffer.from('7468697320697320612074c3a97374', 'hex'), + expected: Buffer.from('7468697320697320612074c3a97374', 'hex'), + }, + inout: { + value: Buffer.from('00112233445566778899aabbccddeeff', 'hex'), + expected: Buffer.from('7468697320697320612074c3a97374', 'hex'), + }, + out: { + value: null, + expected: Buffer.from('00112233445566778899aabbccddeeff', 'hex'), + }, + }, + }, + { + name: 'Buffer -> BINARY [empty buffer]', + values: { + in: { + value: Buffer.alloc(0), + expected: Buffer.alloc(0), + }, + inout: { + value: Buffer.alloc(0), + expected: null, // In Altibase, length 0 is treated as null. + }, + out: { + value: null, + expected: null, + }, + }, + }, + { + name: 'Buffer -> BINARY [null bytes]', + values: { + in: { + value: Buffer.alloc(16), + expected: Buffer.alloc(16), + }, + inout: { + value: Buffer.alloc(16), + expected: Buffer.alloc(16), + }, + out: { + value: null, + expected: Buffer.alloc(16), + }, + }, + }, + ], + } + ], +}; diff --git a/test/DBMS/altibase/CHARACTER.test.js b/test/DBMS/altibase/CHARACTER.test.js new file mode 100644 index 00000000..4feaadef --- /dev/null +++ b/test/DBMS/altibase/CHARACTER.test.js @@ -0,0 +1,62 @@ +module.exports = { + dataType: 'CHAR', + configurations: [ + { + size: '(16)', + options: null, + tests: [ + { + name: 'string -> CHARACTER [empty]', + values: { + in: { + value: '', + expected: '', + }, + inout: { + value: ' ', + expected: null, + }, + out: { + value: null, + expected: ' ', + }, + }, + }, + { + name: 'string -> CHAR (partially full values)', + values: { + in: { + value: 'ABCD1234', + expected: 'ABCD1234', + }, + inout: { + value: 'Z Y X W 9', + expected: 'ABCD1234 ', + }, + out: { + value: null, + expected: 'Z Y X W 9 ', + }, + }, + }, + { + name: 'string -> CHARACTER (full)', + values: { + in: { + value: 'ABCD1234EFGH5678', + expected: 'ABCD1234EFGH5678', + }, + inout: { + value: 'Z Y X W 9 8 7 6 ', + expected: 'ABCD1234EFGH5678', + }, + out: { + value: null, + expected: 'Z Y X W 9 8 7 6 ', + }, + }, + }, + ], + } + ], +}; diff --git a/test/DBMS/altibase/CLOB.test.js b/test/DBMS/altibase/CLOB.test.js new file mode 100644 index 00000000..a7377eef --- /dev/null +++ b/test/DBMS/altibase/CLOB.test.js @@ -0,0 +1,45 @@ +module.exports = { + dataType: 'CLOB', + configurations: [ + { + size: '(16)', + options: null, + tests: [ + { + name: 'string -> CLOB [full]', + values: { + in: { + value: 'ABCD1234EFGH5678', + expected: 'ABCD1234EFGH5678', + }, + inout: { + value: ' A B C D E F G H', + expected: 'ABCD1234EFGH5678', + }, + out: { + value: null, + expected: ' A B C D E F G H', + }, + }, + }, + { + name: 'Buffer -> CLOB (partially full values)', + values: { + in: { + value: Buffer.from('7468697320697320612074c3a9737400', 'hex'), + expected: Buffer.from('7468697320697320612074c3a9737400', 'hex'), + }, + inout: { + value: Buffer.from('c8c5d3d3d65a', 'hex'), + expected: Buffer.from('7468697320697320612074c3a9737400', 'hex'), + }, + out: { + value: null, + expected: 'HELLO!', + }, + }, + } + ], + }, + ], +}; diff --git a/test/DBMS/altibase/DECIMAL.test.js b/test/DBMS/altibase/DECIMAL.test.js new file mode 100644 index 00000000..1eb24ffe --- /dev/null +++ b/test/DBMS/altibase/DECIMAL.test.js @@ -0,0 +1,125 @@ +module.exports = { + dataType: 'DECIMAL', + configurations: [ + { + size: '(38, 0)', + options: null, + tests: [ + { + name: 'string -> DECIMAL (min value)', + values: { + in: { + value: '-99999999999999999999999999999999999999', + expected: '-99999999999999999999999999999999999999', + }, + inout: { + value: '-98989898989898989898989898989898989898', + expected: '-99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '-98989898989898989898989898989898989898', + }, + }, + }, + { + name: 'string -> DECIMAL (max value)', + values: { + in: { + value: '99999999999999999999999999999999999999', + expected: '99999999999999999999999999999999999999', + }, + inout: { + value: '98989898989898989898989898989898989898', + expected: '99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '98989898989898989898989898989898989898', + }, + }, + }, + ], + }, + { + size: '(38, 38)', + options: null, + tests: [ + { + name: 'string -> DECIMAL (min value)', + values: { + in: { + value: '-.99999999999999999999999999999999999999', + expected: '-.99999999999999999999999999999999999999', + }, + inout: { + value: '-.98989898989898989898989898989898989898', + expected: '-0.9999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '-0.9898989898989898989898989898989898989', + }, + }, + }, + { + name: 'string -> DECIMAL (max value)', + values: { + in: { + value: '.99999999999999999999999999999999999999', + expected: '.99999999999999999999999999999999999999', + }, + inout: { + value: '.98989898989898989898989898989898989898', + expected: '0.99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '0.98989898989898989898989898989898989898', + }, + }, + }, + ], + }, + { + size: '(38, 20)', + options: null, + tests: [ + { + name: 'string -> DECIMAL (min value)', + values: { + in: { + value: '-999999999999999999.99999999999999999999', + expected: '-999999999999999999.99999999999999999999', + }, + inout: { + value: '-989898989898989898.89898989898989898989', + expected: '-999999999999999999.99999999999999999999', + }, + out: { + value: undefined, + expected: '-989898989898989898.89898989898989898989', + }, + }, + }, + { + name: 'string -> DECIMAL (max value)', + values: { + in: { + value: '999999999999999999.99999999999999999999', + expected: '999999999999999999.99999999999999999999', + }, + inout: { + value: '989898989898989898.89898989898989898989', + expected: '999999999999999999.99999999999999999999', + }, + out: { + value: undefined, + expected: '989898989898989898.89898989898989898989', + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/INTEGER.test.js b/test/DBMS/altibase/INTEGER.test.js new file mode 100644 index 00000000..03be6d18 --- /dev/null +++ b/test/DBMS/altibase/INTEGER.test.js @@ -0,0 +1,115 @@ +module.exports = { + dataType: 'INTEGER', + configurations: [ + { + size: null, + options: null, + tests: [ + { + name: 'Number -> INTEGER (min value)', + values: { + in: { + value: -2147483648, + expected: -2147483648, + }, + inout: { + value: -2147483647, + expected: null, // -2147483648(0x80000000) is null in Altibase + }, + out: { + value: null, + expected: -2147483647, + }, + }, + }, + { + name: 'Number -> INTEGER (max value)', + values: { + in: { + value: 2147483647, + expected: 2147483647, + }, + inout: { + value: 2147483646, + expected: 2147483647, + }, + out: { + value: null, + expected: 2147483646, + }, + }, + }, + // These tests only run if the N-API version supports BigInt + ...(parseInt(process.versions.napi) >= 5 ? [ + { + name: 'BigInt -> INTEGER (min value)', + values: { + in: { + value: -2147483648n, + expected: -2147483648n, + }, + inout: { + value: -2147483647n, + expected: null, + }, + out: { + value: null, + expected: -2147483647, + }, + }, + }, + { + name: 'BigInt -> INTEGER (max value)', + values: { + in: { + value: 2147483647n, + expected: 2147483647n, + }, + inout: { + value: 2147483646n, + expected: 2147483647n, + }, + out: { + value: null, + expected: 2147483646, + }, + }, + }] : []), + { + name: 'String -> INTEGER (min value)', + values: { + in: { + value: "-2147483647", + expected: "-2147483647", + }, + inout: { + value: "-2147483646", + expected: "-2147483647", + }, + out: { + value: null, + expected: -2147483646, + }, + }, + }, + { + name: 'String -> INTEGER (max value)', + values: { + in: { + value: "2147483647", + expected: "2147483647", + }, + inout: { + value: "2147483646", + expected: "2147483647", + }, + out: { + value: null, + expected: 2147483646, + }, + }, + }, + ], + } + ] +}; diff --git a/test/DBMS/altibase/NUMERIC.test.js b/test/DBMS/altibase/NUMERIC.test.js new file mode 100644 index 00000000..5ed79a09 --- /dev/null +++ b/test/DBMS/altibase/NUMERIC.test.js @@ -0,0 +1,125 @@ +module.exports = { + dataType: 'NUMERIC', + configurations: [ + { + size: '(38, 0)', + options: null, + tests: [ + { + name: 'string -> NUMERIC (min value)', + values: { + in: { + value: '-99999999999999999999999999999999999999', + expected: '-99999999999999999999999999999999999999', + }, + inout: { + value: '-98989898989898989898989898989898989898', + expected: '-99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '-98989898989898989898989898989898989898', + }, + }, + }, + { + name: 'string -> NUMERIC (max value)', + values: { + in: { + value: '99999999999999999999999999999999999999', + expected: '99999999999999999999999999999999999999', + }, + inout: { + value: '98989898989898989898989898989898989898', + expected: '99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '98989898989898989898989898989898989898', + }, + }, + }, + ], + }, + { + size: '(38, 38)', + options: null, + tests: [ + { + name: 'string -> NUMERIC (min value)', + values: { + in: { + value: '-.99999999999999999999999999999999999999', + expected: '-.99999999999999999999999999999999999999', + }, + inout: { + value: '-.98989898989898989898989898989898989898', + expected: '-0.9999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '-0.9898989898989898989898989898989898989', + }, + }, + }, + { + name: 'string -> NUMERIC (max value)', + values: { + in: { + value: '.99999999999999999999999999999999999999', + expected: '.99999999999999999999999999999999999999', + }, + inout: { + value: '.98989898989898989898989898989898989898', + expected: '0.99999999999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '0.98989898989898989898989898989898989898', + }, + }, + }, + ], + }, + { + size: '(38, 30)', + options: null, + tests: [ + { + name: 'string -> NUMERIC (min value)', + values: { + in: { + value: '-99999999.999999999999999999999999999999', + expected: '-99999999.999999999999999999999999999999', + }, + inout: { + value: '-98989898.898989898989898989898989898989', + expected: '-99999999.999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '-98989898.898989898989898989898989898989', + }, + }, + }, + { + name: 'string -> NUMERIC (max value)', + values: { + in: { + value: '99999999.999999999999999999999999999999', + expected: '99999999.999999999999999999999999999999', + }, + inout: { + value: '98989898.898989898989898989898989898989', + expected: '99999999.999999999999999999999999999999', + }, + out: { + value: undefined, + expected: '98989898.898989898989898989898989898989', + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/SMALLINT.test.js b/test/DBMS/altibase/SMALLINT.test.js new file mode 100644 index 00000000..b5881f74 --- /dev/null +++ b/test/DBMS/altibase/SMALLINT.test.js @@ -0,0 +1,115 @@ +module.exports = { + dataType: 'SMALLINT', + configurations: [ + { + size: null, + options: null, + tests: [ + { + name: 'Number -> SMALLINT (min value)', + values: { + in: { + value: -32768, + expected: -32768, + }, + inout: { + value: -32767, + expected: null, + }, + out: { + value: null, + expected: -32767, + }, + }, + }, + { + name: 'Number -> SMALLINT (max value)', + values: { + in: { + value: 32767, + expected: 32767, + }, + inout: { + value: 32766, + expected: 32767, + }, + out: { + value: null, + expected: 32766, + }, + }, + }, + // These tests only run if the N-API version supports BigInt + ...(parseInt(process.versions.napi) >= 5 ? [ + { + name: 'BigInt -> SMALLINT (min value)', + values: { + in: { + value: -32768n, + expected: -32768n, + }, + inout: { + value: -32767n, + expected: null, + }, + out: { + value: null, + expected: -32767, + }, + }, + }, + { + name: 'BigInt -> SMALLINT (max value)', + values: { + in: { + value: 32767n, + expected: 32767n, + }, + inout: { + value: 32766n, + expected: 32767n, + }, + out: { + value: null, + expected: 32766, + }, + }, + }] : []), + { + name: 'String -> SMALLINT (min value)', + values: { + in: { + value: "-32767", + expected: "-32767", + }, + inout: { + value: "-32767", + expected: "-32767", + }, + out: { + value: null, + expected: -32767, + }, + }, + }, + { + name: 'String -> SMALLINT (max value)', + values: { + in: { + value: "32767", + expected: "32767", + }, + inout: { + value: "32766", + expected: "32767", + }, + out: { + value: null, + expected: 32766, + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/VARBINARY.test.js b/test/DBMS/altibase/VARBINARY.test.js new file mode 100644 index 00000000..2769d6fd --- /dev/null +++ b/test/DBMS/altibase/VARBINARY.test.js @@ -0,0 +1,62 @@ +module.exports = { + dataType: 'VARBYTE', + configurations: [ + { + size: '(16)', + options: null, + tests: [ + { + name: 'Buffer -> BINARY', + values: { + in: { + value: Buffer.from('7468697320697320612074c3a97374', 'hex'), + expected: Buffer.from('7468697320697320612074c3a97374', 'hex'), + }, + inout: { + value: Buffer.from('00112233445566778899aabbccddeeff', 'hex'), + expected: Buffer.from('7468697320697320612074c3a97374', 'hex'), + }, + out: { + value: null, + expected: '00112233445566778899AABBCCDDEEFF', + }, + }, + }, + { + name: 'Buffer -> BINARY [empty buffer]', + values: { + in: { + value: Buffer.alloc(0), + expected: Buffer.alloc(0), + }, + inout: { + value: Buffer.alloc(0), + expected: null, + }, + out: { + value: null, + expected: null, + }, + }, + }, + { + name: 'Buffer -> BINARY [null bytes]', + values: { + in: { + value: Buffer.alloc(16), + expected: Buffer.alloc(16), + }, + inout: { + value: Buffer.alloc(16), + expected: Buffer.alloc(16), + }, + out: { + value: null, + expected: '00000000000000000000000000000000', + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/VARCHAR.test.js b/test/DBMS/altibase/VARCHAR.test.js new file mode 100644 index 00000000..c6fb4e77 --- /dev/null +++ b/test/DBMS/altibase/VARCHAR.test.js @@ -0,0 +1,45 @@ +module.exports = { + dataType: 'VARCHAR', + configurations: [ + { + size: '(16)', + options: null, + tests: [ + { + name: 'string -> VARCHAR [empty]', + values: { + in: { + value: '', + expected: '', + }, + inout: { + value: ' ', + expected: null, + }, + out: { + value: null, + expected: ' ', + }, + }, + }, + { + name: 'string -> VARCHAR (full)', + values: { + in: { + value: 'ABCD1234EFGH5678', + expected: 'ABCD1234EFGH5678', + }, + inout: { + value: 'Z Y X W 9 8 7 6 ', + expected: 'ABCD1234EFGH5678', + }, + out: { + value: null, + expected: 'Z Y X W 9 8 7 6 ', + }, + }, + }, + ], + } + ], +}; diff --git a/test/DBMS/altibase/XML.test.js b/test/DBMS/altibase/XML.test.js new file mode 100644 index 00000000..4e9816dd --- /dev/null +++ b/test/DBMS/altibase/XML.test.js @@ -0,0 +1,70 @@ +module.exports = { + dataType: 'XML', + configurations: [ + { + size: null, + options: null, + tests: [ + { + name: 'string -> XML [empty]', + values: { + in: { + value: '', + expected: '', + }, + inout: { + value: ' ', + expected: '', + }, + out: { + value: null, + expected: ' ', + }, + }, + }, + { + name: 'string -> XML (full)', + values: { + in: { + value: ` + Tove + Jani + Reminder + Don't forget me this weekend! + `, + expected: ` + Tove + Jani + Reminder + Don't forget me this weekend! + `, + }, + inout: { + value: ` + Tove + Jani + Reminder + Don't forget me this weekend! + `, + expected: ` + Tove + Jani + Reminder + Don't forget me this weekend! + `, + }, + out: { + value: null, + expected: ` + Tove + Jani + Reminder + Don't forget me this weekend! + `, + }, + }, + }, + ], + }, + ], +}; diff --git a/test/DBMS/altibase/_test.test.js b/test/DBMS/altibase/_test.test.js new file mode 100644 index 00000000..8edc54e4 --- /dev/null +++ b/test/DBMS/altibase/_test.test.js @@ -0,0 +1,13 @@ +module.exports = [ + require('./BIGINT.test.js'), + require('./BINARY.test.js'), + require('./CHARACTER.test.js'), + // require('./CLOB.js'), + require('./DECIMAL.test.js'), + require('./INTEGER.test.js'), + require('./NUMERIC.test.js'), + require('./SMALLINT.test.js'), + require('./VARBINARY.test.js'), + require('./VARCHAR.test.js'), + // require('./XML.js'), +]; diff --git a/test/DBMS/altibase/config.js b/test/DBMS/altibase/config.js new file mode 100644 index 00000000..f884a6f2 --- /dev/null +++ b/test/DBMS/altibase/config.js @@ -0,0 +1,436 @@ +const odbc = require('../../../lib/odbc'); + +module.exports = { + generateCreateOrReplaceQueries: function(tableName, fields) { + const sqlQueries = []; + sqlQueries.push(`DROP TABLE IF EXISTS ${tableName}`); + sqlQueries.push(`CREATE TABLE ${tableName} ${fields}`); + sqlQueries.push(`CREATE OR REPLACE PROCEDURE TESTPROC(a1 OUT INTEGER) AS BEGIN SELECT 1 INTO a1 FROM dual; END;`); // DB_STOREDPROCEDURE + sqlQueries.push(`CREATE OR REPLACE PROCEDURE TESTPROC2(a1 OUT INTEGER, a2 OUT INTEGER) AS BEGIN SELECT 1 INTO a1 FROM dual; SELECT 2 INTO a2 FROM dual; END;`); // DB_STOREDPROCEDURE2 + return sqlQueries; + }, + sqlColumnsColumns: [ + { + "name":"TABLE_CAT", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_SCHEM", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"COLUMN_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"DATA_TYPE", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TYPE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":40, + "decimalDigits":0, + "nullable":true + }, + { + "name":"COLUMN_SIZE", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"BUFFER_LENGTH", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"DECIMAL_DIGITS", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"NUM_PREC_RADIX", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"NULLABLE", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"REMARKS", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":1, + "decimalDigits":0, + "nullable":true + }, + { + "name":"COLUMN_DEF", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":4000, + "decimalDigits":0, + "nullable":true + }, + { + "name":"SQL_DATA_TYPE", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"SQL_DATETIME_SUB", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"CHAR_OCTET_LENGTH", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"ORDINAL_POSITION", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"IS_NULLABLE", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":3, + "decimalDigits":0, + "nullable":true + }, + { + "name":"STORE_TYPE", + "dataType":1, + "dataTypeName":"SQL_CHAR", + "columnSize":1, + "decimalDigits":0, + "nullable":true + }, + { + "name":"ENCRYPT", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"GEOMETRY", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + } + ], + sqlPrimaryKeysColumns : [ + { + "name":"TABLE_CAT", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_SCHEM", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"COLUMN_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"KEY_SEQ", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PK_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"INDEX_ID", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + } + ], + sqlForeignKeysColumns: [ + { + "name":"PKTABLE_CAT", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PKTABLE_SCHEM", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PKTABLE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"PKCOLUMN_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"FKTABLE_CAT", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"FKTABLE_SCHEM", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"FKTABLE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"FKCOLUMN_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":false + }, + { + "name":"KEY_SEQ", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"UPDATE_RULE", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"DELETE_RULE", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + }, + { + "name":"FK_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PK_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"DEFERRABILITY", + "dataType":5, + "dataTypeName":"SQL_SMALLINT", + "columnSize":5, + "decimalDigits":0, + "nullable":true + } + ], + sqlTablesColumns: [ + { + "name":"TABLE_CAT", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_SCHEM", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLE_TYPE", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":17, + "decimalDigits":0, + "nullable":true + }, + { + "name":"REMARKS", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":128, + "decimalDigits":0, + "nullable":true + }, + { + "name":"MAXROW", + "dataType":-5, + "dataTypeName":"SQL_BIGINT", + "columnSize":19, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLESPACE_NAME", + "dataType":12, + "dataTypeName":"SQL_VARCHAR", + "columnSize":40, + "decimalDigits":0, + "nullable":true + }, + { + "name":"TABLESPACE_TYPE", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PCTFREE", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + }, + { + "name":"PCTUSED", + "dataType":4, + "dataTypeName":"SQL_INTEGER", + "columnSize":10, + "decimalDigits":0, + "nullable":true + } + ] +}; diff --git a/test/_test.test.js b/test/_test.test.js index c5fe6721..ee32ed1c 100644 --- a/test/_test.test.js +++ b/test/_test.test.js @@ -11,6 +11,7 @@ const DBMS_LIST = [ 'mysql', 'postgresql', 'postgres', 'sybase', + 'altibase' ]; global.dbms = undefined; diff --git a/test/connection/beginTransaction.test.js b/test/connection/beginTransaction.test.js index 6cdcd856..35b90ca9 100644 --- a/test/connection/beginTransaction.test.js +++ b/test/connection/beginTransaction.test.js @@ -233,6 +233,11 @@ describe('.beginTransaction([callback])...', () => { connection1 = await odbc.connect(`${process.env.CONNECTION_STRING}`); connection2 = await odbc.connect(`${process.env.CONNECTION_STRING};DMConnAttr=[1227]=32`); } + else if (global.dbms === 'altibase') + { + connection1 = await odbc.connect(`${process.env.CONNECTION_STRING}`); + connection2 = await odbc.connect(`${process.env.CONNECTION_STRING}`); + } await connection1.beginTransaction(); let result1 = await connection1.query(`INSERT INTO ${process.env.DB_SCHEMA}.${process.env.DB_TABLE} VALUES(1, 'committed', 10)`) assert.notDeepEqual(result1, null); diff --git a/test/connection/callProcedure.test.js b/test/connection/callProcedure.test.js index 20c25fce..ef40b14f 100644 --- a/test/connection/callProcedure.test.js +++ b/test/connection/callProcedure.test.js @@ -32,22 +32,37 @@ if (dbms) { try { connection = await odbc.connect(process.env.CONNECTION_STRING); // await connection.beginTransaction(); - const procedureQuery = `CREATE OR REPLACE PROCEDURE ${process.env.DB_SCHEMA}.${procedureName} ( - IN IN_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, - INOUT INOUT_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, - OUT OUT_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''} + let procedureQuery; + if (global.dbms === 'altibase') { + procedureQuery = `CREATE OR REPLACE PROCEDURE ${process.env.DB_SCHEMA}.${procedureName} ( + IN_${dataType} IN ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, + INOUT_${dataType} IN OUT ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, + OUT_${dataType} OUT ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''} ) - LANGUAGE SQL - MODIFIES SQL DATA - PROGRAM TYPE SUB - CONCURRENT ACCESS RESOLUTION DEFAULT - DYNAMIC RESULT SETS 0 - OLD SAVEPOINT LEVEL - COMMIT ON RETURN NO + AS BEGIN SET OUT_${dataType} = INOUT_${dataType}; SET INOUT_${dataType} = IN_${dataType}; END`; + } + else { + procedureQuery = `CREATE OR REPLACE PROCEDURE ${process.env.DB_SCHEMA}.${procedureName} ( + IN IN_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, + INOUT INOUT_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''}, + OUT OUT_${dataType} ${dataType} ${size ? `${size} ` : ' '}${options ? `${options}` : ''} + ) + LANGUAGE SQL + MODIFIES SQL DATA + PROGRAM TYPE SUB + CONCURRENT ACCESS RESOLUTION DEFAULT + DYNAMIC RESULT SETS 0 + OLD SAVEPOINT LEVEL + COMMIT ON RETURN NO + BEGIN + SET OUT_${dataType} = INOUT_${dataType}; + SET INOUT_${dataType} = IN_${dataType}; + END`; + } await connection.query(procedureQuery); // await connection.commit(); } catch (error) { diff --git a/test/connection/foreignkeys.test.js b/test/connection/foreignkeys.test.js index 1a380d48..6f8ef419 100644 --- a/test/connection/foreignkeys.test.js +++ b/test/connection/foreignkeys.test.js @@ -7,8 +7,20 @@ describe('.foreignKeys(catalog, schema, table, fkCatalog, fkSchema, fkTable, cal let connection; try { connection = await odbc.connect(`${process.env.CONNECTION_STRING}`); - const query1 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.PKTABLE (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; - const query2 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.FKTABLE (PKID INTEGER, NAME VARCHAR(24), FOREIGN KEY(PKID) REFERENCES PKTABLE(ID))`; + let query1; + let query2; + if (global.dbms === 'altibase') { // Altibase does not support the CREATE OR REPLACE TABLE statement. + query1 = `DROP TABLE IF EXISTS ${process.env.DB_SCHEMA}.FKTABLE`; + query2 = `DROP TABLE IF EXISTS ${process.env.DB_SCHEMA}.PKTABLE`; + await connection.query(query1); + await connection.query(query2); + query1 = `CREATE TABLE ${process.env.DB_SCHEMA}.PKTABLE (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; + query2 = `CREATE TABLE ${process.env.DB_SCHEMA}.FKTABLE (PKID INTEGER, NAME VARCHAR(24), FOREIGN KEY(PKID) REFERENCES PKTABLE(ID))`; + } + else { + query1 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.PKTABLE (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; + query2 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.FKTABLE (PKID INTEGER, NAME VARCHAR(24), FOREIGN KEY(PKID) REFERENCES PKTABLE(ID))`; + } await connection.query(query1); await connection.query(query2); } catch (error) { @@ -24,8 +36,16 @@ describe('.foreignKeys(catalog, schema, table, fkCatalog, fkSchema, fkTable, cal let connection; try { connection = await odbc.connect(`${process.env.CONNECTION_STRING}`); - const query1 = `DROP TABLE ${process.env.DB_SCHEMA}.PKTABLE`; - const query2 = `DROP TABLE ${process.env.DB_SCHEMA}.FKTABLE`; + let query1; + let query2; + if (global.dbms === 'altibase') { // The foreign key table must be dropped first in Altibase. + query1 = `DROP TABLE ${process.env.DB_SCHEMA}.FKTABLE`; + query2 = `DROP TABLE ${process.env.DB_SCHEMA}.PKTABLE`; + } + else { + query1 = `DROP TABLE ${process.env.DB_SCHEMA}.PKTABLE`; + query2 = `DROP TABLE ${process.env.DB_SCHEMA}.FKTABLE`; + } await connection.query(query1); await connection.query(query2); } catch (error) { diff --git a/test/connection/primaryKeys.test.js b/test/connection/primaryKeys.test.js index 11b86774..434ac499 100644 --- a/test/connection/primaryKeys.test.js +++ b/test/connection/primaryKeys.test.js @@ -7,8 +7,20 @@ describe('.primaryKeys(catalog, schema, table, callback)...', () => { let connection; try { connection = await odbc.connect(`${process.env.CONNECTION_STRING}`); - const query1 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.PKTEST (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; - const query2 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.MULTIPKTEST (ID INTEGER, NUM INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID, NUM))`; + let query1; + let query2; + if (global.dbms === 'altibase') { // Altibase does not support the CREATE OR REPLACE TABLE statement. + query1 = `DROP TABLE IF EXISTS ${process.env.DB_SCHEMA}.PKTEST`; + query2 = `DROP TABLE IF EXISTS ${process.env.DB_SCHEMA}.MULTIPKTEST`; + await connection.query(query1); + await connection.query(query2); + query1 = `CREATE TABLE ${process.env.DB_SCHEMA}.PKTEST (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; + query2 = `CREATE TABLE ${process.env.DB_SCHEMA}.MULTIPKTEST (ID INTEGER, NUM INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID, NUM))`; + } + else { + query1 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.PKTEST (ID INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID))`; + query2 = `CREATE OR REPLACE TABLE ${process.env.DB_SCHEMA}.MULTIPKTEST (ID INTEGER, NUM INTEGER, NAME VARCHAR(24), AGE INTEGER, PRIMARY KEY(ID, NUM))`; + } await connection.query(query1); await connection.query(query2); } catch (error) { diff --git a/test/queries/_test.test.js b/test/queries/_test.test.js index 5ca309d8..cd56d5c7 100644 --- a/test/queries/_test.test.js +++ b/test/queries/_test.test.js @@ -15,22 +15,27 @@ describe('Queries...', () => { }); it('...should pass w1nk/node-odbc issue #54', async () => { - const result = await connection.query(`select cast(-1 as INTEGER) as TEST1, cast(-2147483648 as INTEGER) as TEST2, cast(2147483647 as INTEGER) as TEST3 ${global.dbms === 'ibmi' ? 'from sysibm.sysdummy1' : ''}`); + // The minimum integer value for Altibase is -2147483647 + const result = await connection.query(`select cast(-1 as INTEGER) as TEST1, cast(${global.dbms === 'altibase' ? -2147483647 : -2147483648} as INTEGER) as TEST2, cast(2147483647 as INTEGER) as TEST3 ${global.dbms === 'ibmi' ? 'from sysibm.sysdummy1' : ''}`); assert.notDeepEqual(result, null); assert.deepEqual(result.length, 1); assert.deepEqual(result[0].TEST1, -1); - assert.deepEqual(result[0].TEST2, -2147483648); + assert.deepEqual(result[0].TEST2, `${global.dbms === 'altibase' ? -2147483647 : -2147483648}`); assert.deepEqual(result[0].TEST3, 2147483647); }); it('...should pass w1nk/node-odbc issue #85', async () => { - const result = await connection.query(`select cast(-1 as INTEGER) as TEST1, cast(-2147483648 as INTEGER) as TEST2, cast(2147483647 as INTEGER) as TEST3 ${global.dbms === 'ibmi' ? 'from sysibm.sysdummy1' : ''}`); + const result = await connection.query(`select cast(-1 as INTEGER) as TEST1, cast(${global.dbms === 'altibase' ? -2147483647 : -2147483648} as INTEGER) as TEST2, cast(2147483647 as INTEGER) as TEST3 ${global.dbms === 'ibmi' ? 'from sysibm.sysdummy1' : ''}`); assert.notDeepEqual(result, null); assert.deepEqual(result.length, 1); assert.deepEqual(result[0].TEST1, -1); - assert.deepEqual(result[0].TEST2, -2147483648); + assert.deepEqual(result[0].TEST2, `${global.dbms === 'altibase' ? -2147483647 : -2147483648}`); assert.deepEqual(result[0].TEST3, 2147483647); }); - it('...should retrieve data from an SQL_(W)LONG data types', async () => { + it('...should retrieve data from an SQL_(W)LONG data types', async function() { + if (global.dbms === 'altibase') + { + this.skip(); // Casting to CLOB is not supported in Altibase + } const alphabet = 'abcdefghijklmnopqrstuvwxyz' const result = await connection.query(`select cast ('${alphabet}' as CLOB) as SQL_LONGVARCHAR_FIELD, cast ('${alphabet}' as DBCLOB CCSID 1200) as SQL_WLONGVARCHAR_FIELD, cast (cast('${alphabet}' as CLOB CCSID 1208) as BLOB) as SQL_LONGVARBINARY_FIELD from sysibm.sysdummy1`); assert.notDeepEqual(result, null); @@ -69,7 +74,11 @@ describe('Queries...', () => { nullable: false }); }); - it('...should retrieve data from an SQL_(W)LONG data types with a small initial buffer', async () => { + it('...should retrieve data from an SQL_(W)LONG data types with a small initial buffer', async function() { + if (global.dbms === 'altibase') + { + this.skip(); // Casting to CLOB is not supported in Altibase + } const alphabet = 'abcdefghijklmnopqrstuvwxyz' const result = await connection.query(`select cast ('${alphabet}' as CLOB) as SQL_LONGVARCHAR_FIELD, cast ('${alphabet}' as DBCLOB CCSID 1200) as SQL_WLONGVARCHAR_FIELD, cast (cast('${alphabet}' as CLOB CCSID 1208) as BLOB) as SQL_LONGVARBINARY_FIELD from sysibm.sysdummy1`, { initialBufferSize: 4 }); assert.notDeepEqual(result, null);