/* Copyright (c) 2019, 2021 IBM Copyright (c) 2013, Dan VerWeire Copyright (c) 2010, Lee Smith Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies. THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include #include #include "odbc.h" #include "odbc_connection.h" #include "odbc_statement.h" #include "odbc_cursor.h" #ifdef dynodbc #include "dynodbc.h" #endif // // object keys for the result object // const char* NAME = "name\0"; // const char* DATA_TYPE = "dataType\0"; // const char* STATEMENT = "statement\0"; // const char* PARAMETERS = "parameters\0"; // const char* RETURN = "return\0"; // const char* COUNT = "count\0"; // const char* COLUMNS = "columns\0"; size_t strlen16(const char16_t* string) { const char16_t* str = string; while(*str) str++; return str - string; } // error strings const char* ODBC_ERRORS = "odbcErrors\0"; const char* STATE = "state\0"; const char* CODE = "code\0"; const char* MESSAGE = "message\0"; #ifdef UNICODE const SQLTCHAR NO_STATE_TEXT = L'\0'; const SQLTCHAR* NO_MSG_TEXT = (SQLTCHAR *)L"\0"; const size_t NO_MSG_TEXT_LENGTH = strlen16((char16_t *)NO_MSG_TEXT); #else const SQLTCHAR NO_STATE_TEXT = '\0'; const char* NO_MSG_TEXT = "\0"; const size_t NO_MSG_TEXT_LENGTH = strlen(NO_MSG_TEXT); #endif // byte count, needed for memcpy const size_t NO_MSG_TEXT_SIZE = NO_MSG_TEXT_LENGTH * sizeof(SQLTCHAR); uv_mutex_t ODBC::g_odbcMutex; SQLHENV ODBC::hEnv; Napi::Value ODBC::Init(Napi::Env env, Napi::Object exports) { hEnv = NULL; Napi::HandleScope scope(env); // Wrap ODBC constants in an object that we can then expand std::vector ODBC_CONSTANTS; ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("ODBCVER", Napi::Number::New(env, ODBCVER), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_COMMIT", Napi::Number::New(env, SQL_COMMIT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_ROLLBACK", Napi::Number::New(env, SQL_ROLLBACK), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_USER_NAME", Napi::Number::New(env, SQL_USER_NAME), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_PARAM_INPUT", Napi::Number::New(env, SQL_PARAM_INPUT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_PARAM_INPUT_OUTPUT", Napi::Number::New(env, SQL_PARAM_INPUT_OUTPUT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_PARAM_OUTPUT", Napi::Number::New(env, SQL_PARAM_OUTPUT), napi_enumerable)); // Export the integer values for each data type so developers can utilize // them programmatically if needed ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_CHAR", Napi::Number::New(env, SQL_CHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_VARCHAR", Napi::Number::New(env, SQL_VARCHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_LONGVARCHAR", Napi::Number::New(env, SQL_LONGVARCHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_WCHAR", Napi::Number::New(env, SQL_WCHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_WVARCHAR", Napi::Number::New(env, SQL_WVARCHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_WLONGVARCHAR", Napi::Number::New(env, SQL_WLONGVARCHAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_DECIMAL", Napi::Number::New(env, SQL_DECIMAL), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_NUMERIC", Napi::Number::New(env, SQL_NUMERIC), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_SMALLINT", Napi::Number::New(env, SQL_SMALLINT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTEGER", Napi::Number::New(env, SQL_INTEGER), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_REAL", Napi::Number::New(env, SQL_REAL), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_FLOAT", Napi::Number::New(env, SQL_FLOAT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_DOUBLE", Napi::Number::New(env, SQL_DOUBLE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_BIT", Napi::Number::New(env, SQL_BIT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TINYINT", Napi::Number::New(env, SQL_TINYINT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_BIGINT", Napi::Number::New(env, SQL_BIGINT), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_BINARY", Napi::Number::New(env, SQL_BINARY), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_VARBINARY", Napi::Number::New(env, SQL_VARBINARY), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_LONGVARBINARY", Napi::Number::New(env, SQL_LONGVARBINARY), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TYPE_DATE", Napi::Number::New(env, SQL_TYPE_DATE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TYPE_TIME", Napi::Number::New(env, SQL_TYPE_TIME), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TYPE_TIMESTAMP", Napi::Number::New(env, SQL_TYPE_TIMESTAMP), napi_enumerable)); // These are listed in the Microsoft ODBC documentation, but don't appear to // be in unixODBC // ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TYPE_UTCDATETIME", Napi::Number::New(env, SQL_TYPE_UTCDATETIME), napi_enumerable)); // ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TYPE_UTCTIME", Napi::Number::New(env, SQL_TYPE_UTCTIME), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_MONTH", Napi::Number::New(env, SQL_INTERVAL_MONTH), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_YEAR", Napi::Number::New(env, SQL_INTERVAL_YEAR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_YEAR_TO_MONTH", Napi::Number::New(env, SQL_INTERVAL_YEAR_TO_MONTH), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_DAY", Napi::Number::New(env, SQL_INTERVAL_DAY), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_HOUR", Napi::Number::New(env, SQL_INTERVAL_HOUR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_MINUTE", Napi::Number::New(env, SQL_INTERVAL_MINUTE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_SECOND", Napi::Number::New(env, SQL_INTERVAL_SECOND), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_DAY_TO_HOUR", Napi::Number::New(env, SQL_INTERVAL_DAY_TO_HOUR), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_DAY_TO_MINUTE", Napi::Number::New(env, SQL_INTERVAL_DAY_TO_MINUTE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_DAY_TO_SECOND", Napi::Number::New(env, SQL_INTERVAL_DAY_TO_SECOND), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_HOUR_TO_MINUTE", Napi::Number::New(env, SQL_INTERVAL_HOUR_TO_MINUTE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_HOUR_TO_SECOND", Napi::Number::New(env, SQL_INTERVAL_HOUR_TO_SECOND), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_INTERVAL_MINUTE_TO_SECOND", Napi::Number::New(env, SQL_INTERVAL_MINUTE_TO_SECOND), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_GUID", Napi::Number::New(env, SQL_GUID), napi_enumerable)); // End data types ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_NO_NULLS", Napi::Number::New(env, SQL_NO_NULLS), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_NULLABLE", Napi::Number::New(env, SQL_NULLABLE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_NULLABLE_UNKNOWN", Napi::Number::New(env, SQL_NULLABLE_UNKNOWN), napi_enumerable)); // setIsolationLevel options ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TXN_READ_UNCOMMITTED", Napi::Number::New(env, SQL_TXN_READ_UNCOMMITTED), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TRANSACTION_READ_UNCOMMITTED", Napi::Number::New(env, SQL_TRANSACTION_READ_UNCOMMITTED), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TXN_READ_COMMITTED", Napi::Number::New(env, SQL_TXN_READ_COMMITTED), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TRANSACTION_READ_COMMITTED", Napi::Number::New(env, SQL_TRANSACTION_READ_COMMITTED), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TXN_REPEATABLE_READ", Napi::Number::New(env, SQL_TXN_REPEATABLE_READ), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TRANSACTION_REPEATABLE_READ", Napi::Number::New(env, SQL_TRANSACTION_REPEATABLE_READ), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TXN_SERIALIZABLE", Napi::Number::New(env, SQL_TXN_SERIALIZABLE), napi_enumerable)); ODBC_CONSTANTS.push_back(Napi::PropertyDescriptor::Value("SQL_TRANSACTION_SERIALIZABLE", Napi::Number::New(env, SQL_TRANSACTION_SERIALIZABLE), napi_enumerable)); Napi::Object odbcConstants = Napi::Object::New(env); odbcConstants.DefineProperties(ODBC_CONSTANTS); exports.Set("odbcConstants", odbcConstants); exports.Set("connect", Napi::Function::New(env, ODBC::Connect)); SQLRETURN return_code; // Initialize the cross platform mutex provided by libuv uv_mutex_init(&ODBC::g_odbcMutex); uv_mutex_lock(&ODBC::g_odbcMutex); // Initialize the Environment handle return_code = SQLAllocHandle ( SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv ); uv_mutex_unlock(&ODBC::g_odbcMutex); if (!SQL_SUCCEEDED(return_code)) { // TODO: Redo // Napi::Error(env, Napi::String::New(env, (const char*)ODBC::GetSQLErrors(SQL_HANDLE_ENV, hEnv)[0].message)).ThrowAsJavaScriptException(); return env.Null(); } // Use ODBC 3.x behavior return_code = SQLSetEnvAttr ( hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER ); return exports; } ODBC::~ODBC() { uv_mutex_lock(&ODBC::g_odbcMutex); if (hEnv) { SQLFreeHandle(SQL_HANDLE_ENV, hEnv); hEnv = NULL; } uv_mutex_unlock(&ODBC::g_odbcMutex); } //////////////////////////////////////////////////////////////////////////////// /////////////////////////////// ODBCAsyncWorker //////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // // This class extends Napi::AsyncWorker to standardize error handling for all // AsyncWorkers used by the package // //////////////////////////////////////////////////////////////////////////////// ODBCAsyncWorker::ODBCAsyncWorker(Napi::Function& callback) : Napi::AsyncWorker(callback) {}; // TODO: Documentation for this function void ODBCAsyncWorker::OnError(const Napi::Error &e) { Napi::Env env = Env(); Napi::HandleScope scope(env); // add the additional information to the Error object Napi::Error error = Napi::Error::New(env, e.Message()); Napi::Array odbcErrors = Napi::Array::New(env); for (SQLINTEGER i = 0; i < errorCount; i++) { ODBCError odbcError = errors[i]; Napi::Object errorObject = Napi::Object::New(env); errorObject.Set ( Napi::String::New(env, STATE), #ifdef UNICODE Napi::String::New(env, (odbcError.state != NULL) ? (const char16_t*)odbcError.state : (const char16_t*)L"") #else Napi::String::New(env, (odbcError.state != NULL) ? (const char*)odbcError.state : "") #endif ); errorObject.Set ( Napi::String::New(env, CODE), Napi::Number::New(env, odbcError.code) ); errorObject.Set ( Napi::String::New(env, MESSAGE), #ifdef UNICODE Napi::String::New(env, (odbcError.message != NULL) ? (const char16_t *)odbcError.message : (const char16_t *)NO_MSG_TEXT) #else Napi::String::New(env, (odbcError.message != NULL) ? (const char *)odbcError.message : (const char *)NO_MSG_TEXT) #endif ); // Error message has been copied off of the C ODBC error stucture, and can // now be deleted if (odbcError.message != NULL) { delete[] odbcError.message; odbcError.message = NULL; } odbcErrors.Set(i, errorObject); } error.Set( Napi::String::New(env, ODBC_ERRORS), odbcErrors ); std::vector callbackArguments; callbackArguments.push_back(error.Value()); Callback().Call(callbackArguments); } // After a SQL Function doesn't pass SQL_SUCCEEDED, the handle type and handle // are sent to this function, which gets the information and stores it in an // array of ODBCErrors ODBCError* ODBCAsyncWorker::GetODBCErrors ( SQLSMALLINT handleType, SQLHANDLE handle ) { SQLRETURN return_code; SQLSMALLINT error_message_length = ERROR_MESSAGE_BUFFER_CHARS; SQLINTEGER statusRecCount; return_code = SQLGetDiagField ( handleType, // HandleType handle, // Handle 0, // RecNumber SQL_DIAG_NUMBER, // DiagIdentifier &statusRecCount, // DiagInfoPtr SQL_IS_INTEGER, // BufferLength NULL // StringLengthPtr ); if (!SQL_SUCCEEDED(return_code)) { ODBCError *odbcErrors = new ODBCError[1]; ODBCError error; error.state[0] = NO_STATE_TEXT; error.code = 0; error.message = new SQLTCHAR[NO_MSG_TEXT_LENGTH + 1]; memcpy(error.message, NO_MSG_TEXT, NO_MSG_TEXT_SIZE + sizeof(SQLTCHAR)); odbcErrors[0] = error; return odbcErrors; } ODBCError *odbcErrors = new ODBCError[statusRecCount]; this->errorCount = statusRecCount; for (SQLSMALLINT i = 0; i < statusRecCount; i++) { ODBCError error; SQLSMALLINT new_error_message_length; return_code = SQL_SUCCESS; while(SQL_SUCCEEDED(return_code)) { error.message = new SQLTCHAR[error_message_length]; return_code = SQLGetDiagRec ( handleType, // HandleType handle, // Handle i + 1, // RecNumber error.state, // SQLState &error.code, // NativeErrorPtr error.message, // MessageText error_message_length, // BufferLength &new_error_message_length // TextLengthPtr ); if (error_message_length > new_error_message_length) { break; } delete[] error.message; error_message_length = new_error_message_length + 1; } if (!SQL_SUCCEEDED(return_code)) { error.state[0] = NO_STATE_TEXT; error.code = 0; memcpy(error.message, NO_MSG_TEXT, NO_MSG_TEXT_SIZE + 1); } odbcErrors[i] = error; } return odbcErrors; } // TODO: Documentation for this function bool ODBCAsyncWorker::CheckAndHandleErrors(SQLRETURN return_code, SQLSMALLINT handleType, SQLHANDLE handle, const char *message) { if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(handleType, handle); SetError(message); return true; } return false; } // End ODBCAsyncWorker ///////////////////////////////////////////////////////// /* * Connect */ class ConnectAsyncWorker : public ODBCAsyncWorker { private: SQLTCHAR *connectionStringPtr; ConnectionOptions *options; GetInfoResults get_info_results; SQLHENV hEnv; SQLHDBC hDBC; void Execute() { SQLRETURN return_code; uv_mutex_lock(&ODBC::g_odbcMutex); return_code = SQLAllocHandle( SQL_HANDLE_DBC, hEnv, &hDBC ); if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(SQL_HANDLE_ENV, hEnv); SetError("[odbc] Error allocating the connection handle"); return; } if (options->connectionTimeout > 0) { return_code = SQLSetConnectAttr( hDBC, // ConnectionHandle SQL_ATTR_CONNECTION_TIMEOUT, // Attribute (SQLPOINTER) (intptr_t) options->connectionTimeout, // ValuePtr SQL_IS_UINTEGER // StringLength ); if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); SetError("[odbc] Error setting the connection timeout"); return; } } if (options->loginTimeout > 0) { return_code = SQLSetConnectAttr ( hDBC, // ConnectionHandle SQL_ATTR_LOGIN_TIMEOUT, // Attribute (SQLPOINTER) (intptr_t) options->loginTimeout, // ValuePtr SQL_IS_UINTEGER // StringLength ); if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); SetError("[odbc] Error setting the login timeout"); return; } // "If the specified timeout exceeds the maximum login timeout in the // data source, the driver substitutes that value and returns SQLSTATE // 01S02 (Option value changed)." if (return_code == SQL_SUCCESS_WITH_INFO) { return_code = SQLGetConnectAttr ( hDBC, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER) &options->loginTimeout, IGNORED_PARAMETER, NULL ); if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); SetError("[odbc] Error setting retrieving the changed login timeout"); return; } } } //Attempt to connect return_code = SQLDriverConnect ( hDBC, // ConnectionHandle NULL, // WindowHandle connectionStringPtr, // InConnectionString SQL_NTS, // StringLength1 NULL, // OutConnectionString 0, // BufferLength - in characters NULL, // StringLength2Ptr SQL_DRIVER_NOPROMPT // DriverCompletion ); uv_mutex_unlock(&ODBC::g_odbcMutex); if (!SQL_SUCCEEDED(return_code)) { this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); SetError("[odbc] Error connecting to the database"); return; } // get information about the connection // maximum column length return_code = SQLGetInfo ( hDBC, // ConnectionHandle SQL_MAX_COLUMN_NAME_LEN, // InfoType &get_info_results.max_column_name_length, // InfoValuePtr sizeof(SQLSMALLINT), // BufferLength NULL // StringLengthPtr ); // Some poorly-behaved drivers do not implement SQL_MAX_COLUMN_NAME_LEN, // and return SQL_ERROR instead of setting the value to 0 like the spec // requires. Bite the bullet and ignore any errors here, instead setting // the value to something sane like 128 ("An FIPS Intermediate // level-conformant driver will return at least 128."). if (!SQL_SUCCEEDED(return_code) || get_info_results.max_column_name_length == 0) { get_info_results.max_column_name_length = 128; // this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); // SetError("[odbc] Error getting information about maximum column length from the connection"); // return; } // valid transaction levels return_code = SQLGetInfo ( hDBC, // ConnectionHandle SQL_TXN_ISOLATION_OPTION, // InfoType &get_info_results.available_isolation_levels, // InfoValuePtr sizeof(SQLUINTEGER), // BufferLength NULL // StringLengthPtr ); // Some poorly-behaved drivers do not implement SQL_TXN_ISOLATION_OPTION, // and return SQL_ERROR. Bite the bullet again and ignore any errors here, // instead setting the bitmask to 0 so no isolation levels are listed as // supported. if (!SQL_SUCCEEDED(return_code)) { get_info_results.available_isolation_levels = 0; // this->errors = GetODBCErrors(SQL_HANDLE_DBC, hDBC); // SetError("[odbc] Error getting information about available transaction isolation options from the connection"); // return; } SQLUINTEGER sql_getdata_extensions_bitmask; // valid get data extensions return_code = SQLGetInfo ( hDBC, // ConnectionHandle SQL_GETDATA_EXTENSIONS, // InfoType (SQLPOINTER) &sql_getdata_extensions_bitmask, // InfoValuePtr IGNORED_PARAMETER, // BufferLength IGNORED_PARAMETER // StringLengthPtr ); if (!SQL_SUCCEEDED(return_code)) { // Some drivers don't feel the need to implement the // SQL_GETDATA_EXTENSIONS option for SQLGetInfo, so this call will // return an error. Instead of returning an error, just set all of // the SQLGetData extensions to false and continue. get_info_results.sql_get_data_supports.any_column = false; get_info_results.sql_get_data_supports.any_order = false; get_info_results.sql_get_data_supports.block = false; get_info_results.sql_get_data_supports.bound = false; get_info_results.sql_get_data_supports.output_params = false; } else { // call the bitmask to populate the sql_get_data_supports struct get_info_results.sql_get_data_supports.any_column = (bool) (sql_getdata_extensions_bitmask & SQL_GD_ANY_COLUMN); get_info_results.sql_get_data_supports.any_order = (bool) (sql_getdata_extensions_bitmask & SQL_GD_ANY_ORDER); get_info_results.sql_get_data_supports.block = (bool) (sql_getdata_extensions_bitmask & SQL_GD_BLOCK); get_info_results.sql_get_data_supports.bound = (bool) (sql_getdata_extensions_bitmask & SQL_GD_BOUND); get_info_results.sql_get_data_supports.output_params = (bool) (sql_getdata_extensions_bitmask & SQL_GD_OUTPUT_PARAMS); } } void OnOK() { Napi::Env env = Env(); Napi::HandleScope scope(env); // pass the HENV and HDBC values to the ODBCConnection constructor std::vector connectionArguments; connectionArguments.push_back(Napi::External::New(env, &hEnv)); // connectionArguments[0] connectionArguments.push_back(Napi::External::New(env, &hDBC)); // connectionArguments[1] connectionArguments.push_back(Napi::External::New(env, options)); // connectionArguments[2] connectionArguments.push_back(Napi::External::New(env, &get_info_results)); // connectionArguments[3] Napi::Value connection = ODBCConnection::constructor.New(connectionArguments); // pass the arguments to the callback function std::vector callbackArguments; callbackArguments.push_back(env.Null()); // callbackArguments[0] callbackArguments.push_back(connection); // callbackArguments[1] Callback().Call(callbackArguments); } public: ConnectAsyncWorker(HENV hEnv, SQLTCHAR *connectionStringPtr, ConnectionOptions *options, Napi::Function& callback) : ODBCAsyncWorker(callback), connectionStringPtr(connectionStringPtr), options(options), hEnv(hEnv) {} ~ConnectAsyncWorker() { delete options; delete[] connectionStringPtr; } }; // Connect Napi::Value ODBC::Connect(const Napi::CallbackInfo& info) { Napi::Env env = info.Env(); Napi::HandleScope scope(env); Napi::String connectionString; Napi::Function callback; SQLTCHAR *connectionStringPtr = nullptr; ConnectionOptions *options = new ConnectionOptions(); options->connectionTimeout = 0; options->loginTimeout = 0; options->fetchArray = false; if(info.Length() != 2) { Napi::TypeError::New(env, "connect(connectionString, callback) requires 2 parameters.").ThrowAsJavaScriptException(); return env.Null(); } if (info[0].IsString()) { connectionString = info[0].As(); connectionStringPtr = ODBC::NapiStringToSQLTCHAR(connectionString); } else if (info[0].IsObject()) { Napi::Object connectionObject = info[0].As(); if (connectionObject.Has("connectionString") && connectionObject.Get("connectionString").IsString()) { connectionString = connectionObject.Get("connectionString").As(); connectionStringPtr = ODBC::NapiStringToSQLTCHAR(connectionString); } else { Napi::TypeError::New(env, "connect: A configuration object must have a 'connectionString' property that is a string.").ThrowAsJavaScriptException(); return env.Null(); } if (connectionObject.Has("connectionTimeout") && connectionObject.Get("connectionTimeout").IsNumber()) { options->connectionTimeout = connectionObject.Get("connectionTimeout").As().Int32Value(); } if (connectionObject.Has("loginTimeout") && connectionObject.Get("loginTimeout").IsNumber()) { options->loginTimeout = connectionObject.Get("loginTimeout").As().Int32Value(); } if (connectionObject.Has("fetchArray") && connectionObject.Get("fetchArray").IsBoolean()) { options->fetchArray = connectionObject.Get("fetchArray").As(); } } else { Napi::TypeError::New(env, "connect: first parameter must be a string or an object.").ThrowAsJavaScriptException(); return env.Null(); } if (info[1].IsFunction()) { callback = info[1].As(); } else { Napi::TypeError::New(env, "connect: second parameter must be a function.").ThrowAsJavaScriptException(); return env.Null(); } ConnectAsyncWorker *worker = new ConnectAsyncWorker(hEnv, connectionStringPtr, options, callback); worker->Queue(); return env.Undefined(); } //////////////////////////////////////////////////////////////////////////////// ///////////////////////////// UTILITY FUNCTIONS //////////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Take a Napi::String, and convert it to an SQLTCHAR*, which maps to: // UNICODE : SQLWCHAR* // no UNICODE : SQLCHAR* SQLTCHAR* ODBC::NapiStringToSQLTCHAR(Napi::String string) { size_t byteCount = 0; #ifdef UNICODE std::u16string tempString = string.Utf16Value(); byteCount = (tempString.length() + 1) * 2; #else std::string tempString = string.Utf8Value(); byteCount = tempString.length() + 1; #endif SQLTCHAR *sqlString = new SQLTCHAR[byteCount]; std::memcpy(sqlString, tempString.c_str(), byteCount); return sqlString; } /****************************************************************************** **************************** BINDING PARAMETERS ****************************** *****************************************************************************/ /* * GetParametersFromArray * Array of parameters can hold either/and: * Value: * One value to bind, In/Out defaults to SQL_PARAM_INPUT, dataType defaults based on the value * Arrays:ns when you elect n * between 1 and 3 entries in lenth, with the following signfigance and default values: * 1. Value (REQUIRED): The value to bind * 2. In/Out (Optional): Defaults to SQL_PARAM_INPUT * 3. DataType (Optional): Defaults based on the value * Objects: * can hold any of the following properties (but requires at least 'value' property) * value (Requited): The value to bind * inOut (Optional): the In/Out type to use, Defaults to SQL_PARAM_INPUT * dataType (Optional): The data type, defaults based on the value * * */ // This function solves the problem of losing access to "Napi::Value"s when entering // an AsyncWorker. In Connection::Query, once we enter an AsyncWorker we do not leave it again, // but we can't call SQLNumParams and SQLDescribeParam until after SQLPrepare. So the array of // values to bind to parameters must be saved off in the closest, largest data type to then // convert to the right C Type once the SQL Type of the parameter is known. void ODBC::StoreBindValues(Napi::Array *values, Parameter **parameters) { uint32_t numParameters = values->Length(); for (uint32_t i = 0; i < numParameters; i++) { Napi::Value value = values->Get(i); Parameter *parameter = parameters[i]; if(value.IsNull()) { parameter->ValueType = SQL_C_DEFAULT; parameter->ParameterValuePtr = NULL; parameter->StrLen_or_IndPtr = SQL_NULL_DATA; #if NAPI_VERSION > 5 } else if (value.IsBigInt()) { // TODO: need to check for signed/unsigned? bool lossless = true; parameter->ValueType = SQL_C_SBIGINT; parameter->ParameterValuePtr = new SQLBIGINT(value.As().Int64Value(&lossless)); parameter->isbigint = true; #endif } else if (value.IsNumber()) { double double_val = value.As().DoubleValue(); int64_t int_val = value.As().Int64Value(); if (double_val == int_val) { parameter->ValueType = SQL_C_SBIGINT; parameter->ParameterValuePtr = new SQLBIGINT(value.As().Int64Value()); parameter->isbigint = false; } else { parameter->ValueType = SQL_C_DOUBLE; parameter->ParameterValuePtr = new SQLDOUBLE(value.As().DoubleValue()); } } else if (value.IsBoolean()) { parameter->ValueType = SQL_C_BIT; parameter->ParameterValuePtr = new bool(value.As().Value()); } else if (value.IsBuffer()) { Napi::Buffer bufferValue = value.As>(); parameter->ValueType = SQL_C_BINARY; parameter->BufferLength = bufferValue.Length(); parameter->ParameterValuePtr = new SQLCHAR[parameter->BufferLength](); parameter->StrLen_or_IndPtr = parameter->BufferLength; memcpy((SQLCHAR *) parameter->ParameterValuePtr, bufferValue.Data(), parameter->BufferLength); } else if (value.IsArrayBuffer()) { Napi::ArrayBuffer arrayBufferValue = value.As(); parameter->ValueType = SQL_C_BINARY; parameter->BufferLength = arrayBufferValue.ByteLength(); parameter->ParameterValuePtr = new SQLCHAR[parameter->BufferLength]; parameter->StrLen_or_IndPtr = parameter->BufferLength; memcpy((SQLCHAR *) parameter->ParameterValuePtr, arrayBufferValue.Data(), parameter->BufferLength); } else if (value.IsString()) { // Napi::String string = value.ToString(); // parameter->ValueType = SQL_C_WCHAR; // parameter->BufferLength = (string.Utf16Value().length() + 1) * sizeof(SQLWCHAR); // parameter->ParameterValuePtr = new SQLWCHAR[parameter->BufferLength]; // parameter->StrLen_or_IndPtr = SQL_NTS; // memcpy((SQLWCHAR*) parameter->ParameterValuePtr, string.Utf16Value().c_str(), parameter->BufferLength); Napi::String string = value.ToString(); parameter->ValueType = SQL_C_CHAR; parameter->BufferLength = (string.Utf8Value().length() + 1); parameter->ParameterValuePtr = new SQLCHAR[parameter->BufferLength](); parameter->StrLen_or_IndPtr = SQL_NTS; memcpy((SQLCHAR*) parameter->ParameterValuePtr, string.Utf8Value().c_str(), parameter->BufferLength); } else { // TODO: Throw error, don't support other types } } } SQLRETURN ODBC::DescribeParameters(SQLHSTMT hstmt, Parameter **parameters, SQLSMALLINT parameterCount) { SQLRETURN return_code = SQL_SUCCESS; // if no parameters, will return SQL_SUCCESS for (SQLSMALLINT i = 0; i < parameterCount; i++) { Parameter *parameter = parameters[i]; // "Except in calls to procedures, all parameters in SQL statements are input parameters." parameter->InputOutputType = SQL_PARAM_INPUT; return_code = SQLDescribeParam ( hstmt, // StatementHandle, i + 1, // ParameterNumber, ¶meter->ParameterType, // DataTypePtr, ¶meter->ColumnSize, // ParameterSizePtr, ¶meter->DecimalDigits, // DecimalDigitsPtr, ¶meter->Nullable // NullablePtr ); // if there is an error, return early and retrieve error in calling function if (!SQL_SUCCEEDED(return_code)) { return return_code; } } return return_code; } SQLRETURN ODBC::BindParameters(SQLHSTMT hstmt, Parameter **parameters, SQLSMALLINT parameterCount) { SQLRETURN return_code = SQL_SUCCESS; // if no parameters, will return SQL_SUCCESS for (int i = 0; i < parameterCount; i++) { Parameter* parameter = parameters[i]; return_code = SQLBindParameter( hstmt, // StatementHandle i + 1, // ParameterNumber parameter->InputOutputType, // InputOutputType parameter->ValueType, // ValueType parameter->ParameterType, // ParameterType parameter->ColumnSize, // ColumnSize parameter->DecimalDigits, // DecimalDigits parameter->ParameterValuePtr, // ParameterValuePtr parameter->BufferLength, // BufferLength ¶meter->StrLen_or_IndPtr // StrLen_or_IndPtr ); // If there was an error, return early if (!SQL_SUCCEEDED(return_code)) { return return_code; } } // If returns success, know that SQLBindParameter returned SUCCESS or // SUCCESS_WITH_INFO for all calls to SQLBindParameter. return return_code; } Napi::Object InitAll(Napi::Env env, Napi::Object exports) { ODBC::Init(env, exports); ODBCConnection::Init(env, exports); ODBCStatement::Init(env, exports); ODBCCursor::Init(env, exports); #ifdef dynodbc exports.Set(Napi::String::New(env, "loadODBCLibrary"), Napi::Function::New(env, ODBC::LoadODBCLibrary);()); #endif return exports; } #ifdef dynodbc Napi::Value ODBC::LoadODBCLibrary(const Napi::CallbackInfo& info) { Napi::HandleScope scope(env); REQ_STR_ARG(0, js_library); bool result = DynLoadODBC(*js_library); return (result) ? env.True() : env.False();W } #endif NODE_API_MODULE(odbc_bindings, InitAll)