ibm_db 1.1.1 → 1.5.0

data/ext/ruby_ibm_db_cli.h

@@ -0,0 +1,389 @@
+/*
+  +----------------------------------------------------------------------+
+  |  Licensed Materials - Property of IBM                                |
+  |                                                                      |
+  | (C) Copyright IBM Corporation 2009                                   |
+  +----------------------------------------------------------------------+
+  | Authors: Praveen Devarao                                             |
+  +----------------------------------------------------------------------+
+*/
+
+#ifndef RUBY_IBM_DB_CLI_H
+#define RUBY_IBM_DB_CLI_H
+
+#include <ruby.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sqlcli1.h>
+
+/* Defines a linked list structure for caching param data */
+typedef struct _param_cache_node {
+  SQLSMALLINT data_type;          /* Datatype */
+  SQLUINTEGER param_size;         /* param size */
+  SQLSMALLINT nullable;           /* is Nullable */
+  SQLSMALLINT scale;              /* Decimal scale */
+  SQLUINTEGER file_options;       /* File options if PARAM_FILE */
+  SQLINTEGER  bind_indicator;     /* indicator variable for SQLBindParameter */
+  int         param_num;              /* param number in stmt */
+  int         param_type;             /* Type of param - INP/OUT/INP-OUT/FILE */
+  int         size;                   /* Size of param */
+  char        *varname;               /* bound variable name */
+  long        ivalue;                 /* Temp storage value */
+  double      fvalue;                 /* Temp storage value */
+  char        *svalue;                /* Temp storage value */
+  struct _param_cache_node *next; /* Pointer to next node */
+} param_node;
+
+typedef struct _conn_handle_struct {
+  SQLHANDLE    henv;
+  SQLHANDLE    hdbc;
+  long         auto_commit;
+  long         c_bin_mode;
+  long         c_case_mode;
+  long         c_cursor_type;
+  int          handle_active;
+  SQLSMALLINT  error_recno_tracker;
+  SQLSMALLINT  errormsg_recno_tracker;
+  int          flag_pconnect; /* Indicates that this connection is persistent */
+
+  int  errorType;    /*Indicates Whether the error logged in ruby_error_msg is a statement error or connection error*/
+
+  char *ruby_error_msg;
+  char *ruby_error_state;
+
+} conn_handle;
+
+typedef union {
+  SQLINTEGER   i_val;
+  SQLDOUBLE    d_val;
+  SQLFLOAT     f_val;
+  SQLSMALLINT  s_val;
+  SQLCHAR      *str_val;
+} ibm_db_row_data_type;
+
+typedef struct {
+  SQLINTEGER            out_length;
+  ibm_db_row_data_type  data;
+} ibm_db_row_type;
+
+typedef struct _ibm_db_result_set_info_struct {
+  SQLCHAR      *name;
+  SQLSMALLINT  type;
+  SQLUINTEGER  size;
+  SQLSMALLINT  scale;
+  SQLSMALLINT  nullable;
+  SQLINTEGER   lob_loc;
+  SQLINTEGER   loc_ind;
+  SQLSMALLINT  loc_type;
+} ibm_db_result_set_info;
+
+typedef struct _row_hash_struct {
+  VALUE hash;
+} row_hash_struct;
+
+typedef struct _stmt_handle_struct {
+  SQLHANDLE    hdbc;
+  SQLHANDLE    hstmt;
+  long         s_bin_mode;
+  long         cursor_type;
+  long         s_case_mode;
+  SQLSMALLINT  error_recno_tracker;
+  SQLSMALLINT  errormsg_recno_tracker;
+
+  /* Parameter Caching variables */
+  param_node   *head_cache_list;
+  param_node   *current_node;
+
+  int          num_params;       /* Number of Params */
+  int          file_param;       /* if option passed in is FILE_PARAM */
+  int          num_columns;
+  int          is_executing;
+
+  ibm_db_result_set_info  *column_info;
+  ibm_db_row_type         *row_data;
+
+  char *ruby_stmt_err_msg;
+  char *ruby_stmt_err_state;
+} stmt_handle;
+
+/* 
+    Structure holding the data to be passed to SQLConnect or SQLDriverConnect CLI call 
+*/
+typedef struct _ibm_db_connect_args_struct {
+  char          *database;
+  char          *uid;
+  char          *password;
+  long          database_len;
+  long          uid_len;
+  long          password_len;
+  int           ctlg_conn;        /*Indicates if the connection is a cataloged connection or not*/
+  SQLHANDLE     *hdbc;
+} connect_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLEndTran CLI call
+*/
+typedef struct _ibm_db_end_tran_args_struct {
+  SQLHANDLE      *hdbc;
+  SQLSMALLINT    handleType;
+  SQLSMALLINT    completionType;
+} end_tran_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLDescribeparam CLI call
+*/
+typedef struct _ibm_db_describeparam_args_struct {
+  stmt_handle   *stmt_res;
+  SQLUSMALLINT  param_no;
+  SQLSMALLINT   sql_data_type;
+  SQLUINTEGER   sql_precision;
+  SQLSMALLINT   sql_scale;
+  SQLSMALLINT   sql_nullable;
+} describeparam_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLDescribeCol CLI call
+*/
+typedef struct _ibm_db_describecol_args_struct {
+  stmt_handle   *stmt_res;
+  SQLUSMALLINT  col_no;
+  SQLSMALLINT   name_length;
+  SQLSMALLINT   buff_length;
+} describecol_args;
+/*
+    Structure holding the necessary info to be passed to CLI calls like SQLColumns
+    SQLForeignKeys etc. The same structure is used to get the SP parameters, with table_name as proc_name
+*/
+typedef struct _ibm_db_metadata_args_struct {
+  stmt_handle   *stmt_res;
+  SQLCHAR       *qualifier;
+  SQLCHAR       *owner;
+  SQLCHAR       *table_name;
+  SQLCHAR       *proc_name;  /*Used for call SQLProcedureColumns*/
+  SQLCHAR       *column_name;
+  SQLCHAR       *table_type;
+  int           scope;       /*Used in SQLSpecialColumns To determine the scope of the unique row identifier*/
+  int           unique;      /*Used in SQLStatistics to determine if only unique indexes are to be fetched or all*/
+
+} metadata_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLPrepare and SQLExecDirect CLI call
+*/
+typedef struct _ibm_db_exec_direct_args_struct {
+  stmt_handle   *stmt_res;
+  SQLCHAR       *stmt_string;
+  long          stmt_string_len;
+} exec_cum_prepare_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLParamData and SQLPutData CLI call
+*/
+typedef struct _ibm_db_param_and_put_data_struct {
+  stmt_handle   *stmt_res;
+  SQLPOINTER    valuePtr;
+} param_cum_put_data_args;
+
+/* 
+    Structure holding the necessary info to be passed to SQLNextResult CLI call
+*/
+typedef struct _ibm_db_next_result_args_struct {
+  SQLHSTMT      *new_hstmt;
+  stmt_handle   *stmt_res;
+
+} next_result_args;
+
+/* 
+    Structure holding the necessary info to be passed to calls SQLNumResultCols/SQLRowcount/SQLNumParams
+*/
+typedef struct _ibm_db_row_col_count_struct {
+  stmt_handle    *stmt_res;
+  SQLINTEGER     count;
+} row_col_count_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLColAttributes
+*/
+typedef struct _ibm_db_col_attr_struct {
+  stmt_handle    *stmt_res;
+  SQLSMALLINT    col_num;
+  SQLSMALLINT    FieldIdentifier;
+  SQLINTEGER     num_attr;
+} col_attr_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLBindCol
+*/
+typedef struct _ibm_db_bind_col_struct {
+  stmt_handle    *stmt_res;
+  SQLUSMALLINT   col_num;
+  SQLSMALLINT    TargetType;
+  SQLPOINTER     TargetValuePtr;
+  SQLLEN         buff_length;
+  SQLLEN         *out_length;
+} bind_col_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetData
+*/
+typedef struct _ibm_db_get_data_args_struct {
+  stmt_handle    *stmt_res;
+  SQLSMALLINT    col_num;
+  SQLSMALLINT    targetType;
+  SQLPOINTER     *buff;
+  SQLLEN         buff_length;
+  SQLLEN         *out_length;
+} get_data_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetLength
+*/
+typedef struct _ibm_db_get_data_length_struct {
+  SQLHSTMT       *new_hstmt;
+  SQLSMALLINT    col_num;
+  stmt_handle    *stmt_res;
+  SQLINTEGER     *sLength;
+
+} get_length_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetSubString
+*/
+typedef struct _ibm_db_get_data_subString_struct {
+  SQLHSTMT       *new_hstmt;
+  SQLSMALLINT    col_num;
+  stmt_handle    *stmt_res;
+  SQLUINTEGER    forLength;
+  SQLSMALLINT    targetCType;
+  SQLPOINTER     buffer;
+  SQLLEN         buff_length;
+  SQLINTEGER     *out_length;
+
+} get_subString_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLFetchScroll and SQLFetch
+*/
+typedef struct _ibm_db_fetch_data_struct {
+  stmt_handle    *stmt_res;
+  SQLSMALLINT    fetchOrientation;
+  SQLLEN         fetchOffset;
+} fetch_data_args;
+
+/* 
+    Structure holding the necessary info to be passed to calls SQLSetStmtAttr/SQLSetConnectAttr/SQLEnvAttr
+*/
+typedef struct _ibm_db_set_handle_attr_struct {
+  SQLHANDLE    *handle;
+  SQLINTEGER   attribute;
+  SQLPOINTER   valuePtr;
+  SQLINTEGER   strLength;
+
+} set_handle_attr_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetStmtAttr and SQLGetConnectAttr
+*/
+typedef struct _ibm_db_get_handle_attr_struct {
+  SQLHANDLE    *handle;
+  SQLINTEGER   attribute;
+  SQLPOINTER   valuePtr;
+  SQLINTEGER   buff_length;
+  SQLINTEGER   *out_length;
+} get_handle_attr_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLBindParameter
+*/
+typedef struct _ibm_db_bind_parameter_struct {
+  stmt_handle    *stmt_res;
+  SQLSMALLINT    param_num;
+  SQLSMALLINT    IOType;
+  SQLSMALLINT    valueType;
+  SQLSMALLINT    paramType;
+  SQLULEN        colSize;
+  SQLSMALLINT    decimalDigits;
+  SQLPOINTER     paramValPtr;
+  SQLLEN         buff_length;
+  SQLLEN         *out_length;
+} bind_parameter_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetInfo
+*/
+typedef struct _ibm_db_get_info_struct {
+  conn_handle   *conn_res;
+  SQLUSMALLINT  infoType;
+  SQLPOINTER    infoValue;
+  SQLSMALLINT   buff_length;
+  SQLSMALLINT   *out_length;
+} get_info_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLGetDiagRec
+*/
+typedef struct _ibm_db_get_diagRec_struct {
+  SQLSMALLINT       hType;
+  SQLHANDLE         handle;
+  SQLSMALLINT       recNum;
+  SQLCHAR           *SQLState;
+  SQLINTEGER        *NativeErrorPtr;
+  SQLCHAR           *msgText;
+  SQLSMALLINT       buff_length;
+  SQLSMALLINT       *text_length_ptr;
+} get_diagRec_args;
+
+/* 
+    Structure holding the necessary info to be passed to call SQLFreestmt
+*/
+typedef struct _ibm_db_free_stmt_struct {
+  stmt_handle   *stmt_res;
+  SQLUSMALLINT  option;
+} free_stmt_args;
+
+int _ruby_ibm_db_SQLConnect_helper(connect_args *data);
+int _ruby_ibm_db_SQLDisconnect_helper(SQLHANDLE *hdbc);
+void _ruby_ibm_db_Connection_level_UBF(void *data);
+int _ruby_ibm_db_SQLEndTran(end_tran_args *endtran_args);
+int _ruby_ibm_db_SQLDescribeParam_helper(describeparam_args *data);
+int _ruby_ibm_db_SQLDescribeCol_helper(describecol_args *data);
+int _ruby_ibm_db_SQLBindCol_helper(bind_col_args *data);
+int _ruby_ibm_db_SQLColumnPrivileges_helper(metadata_args *data);
+int _ruby_ibm_db_SQLColumns_helper(metadata_args *data);
+int _ruby_ibm_db_SQLPrimaryKeys_helper(metadata_args *data);
+int _ruby_ibm_db_SQLForeignKeys_helper(metadata_args *data);
+int _ruby_ibm_db_SQLProcedureColumns_helper(metadata_args *data);
+int _ruby_ibm_db_SQLProcedures_helper(metadata_args *data);
+int _ruby_ibm_db_SQLSpecialColumns_helper(metadata_args *data);
+int _ruby_ibm_db_SQLStatistics_helper(metadata_args *data);
+int _ruby_ibm_db_SQLTablePrivileges_helper(metadata_args *data);
+int _ruby_ibm_db_SQLTables_helper(metadata_args *data);
+int _ruby_ibm_db_SQLExecDirect_helper(exec_cum_prepare_args *data);
+int _ruby_ibm_db_SQLPrepare_helper(exec_cum_prepare_args *data);
+int _ruby_ibm_db_SQLFreeStmt_helper(free_stmt_args *data);
+int _ruby_ibm_db_SQLExecute_helper(stmt_handle *stmt_res);
+int _ruby_ibm_db_SQLParamData_helper(param_cum_put_data_args *data);
+int _ruby_ibm_db_SQLColAttributes_helper(col_attr_args *data);
+int _ruby_ibm_db_SQLPutData_helper(param_cum_put_data_args *data);
+int _ruby_ibm_db_SQLGetData_helper(get_data_args *data);
+int _ruby_ibm_db_SQLGetLength_helper(get_length_args *data);
+int _ruby_ibm_db_SQLGetSubString_helper(get_subString_args *data);
+int _ruby_ibm_db_SQLNextResult_helper(next_result_args *data);
+int _ruby_ibm_db_SQLFetchScroll_helper(fetch_data_args *data);
+int _ruby_ibm_db_SQLFetch_helper(fetch_data_args *data);
+int _ruby_ibm_db_SQLNumResultCols_helper(row_col_count_args *data);
+int _ruby_ibm_db_SQLNumParams_helper(row_col_count_args *data);
+int _ruby_ibm_db_SQLRowCount_helper(row_col_count_args *data);
+int _ruby_ibm_db_SQLGetInfo_helper(get_info_args *data);
+int _ruby_ibm_db_SQLGetDiagRec_helper(get_diagRec_args *data);
+int _ruby_ibm_db_SQLSetStmtAttr_helper(set_handle_attr_args *data);
+int _ruby_ibm_db_SQLSetConnectAttr_helper(set_handle_attr_args *data);
+int _ruby_ibm_db_SQLSetEnvAttr_helper(set_handle_attr_args *data);
+int _ruby_ibm_db_SQLGetStmtAttr_helper(get_handle_attr_args *data);
+int _ruby_ibm_db_SQLGetConnectAttr_helper(get_handle_attr_args *data);
+int _ruby_ibm_db_SQLBindFileToParam_helper(stmt_handle *stmt_res, param_node *curr);
+int _ruby_ibm_db_SQLBindParameter_helper(bind_parameter_args *data);
+void _ruby_ibm_db_Statement_level_UBF(stmt_handle *stmt_res);
+
+#endif  /* RUBY_IBM_DB_CLI_H */

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -63,13 +63,12 @@ module ActiveRecord
             else
               update_query << "(" + params.join(',') + ")"
             end
-            
+
             update_query << " WHERE #{self.class.primary_key} = ?"
             values << self[self.class.primary_key.downcase]
             
             unless stmt = IBM_DB.prepare(connection.connection, update_query)
-              error_msg = IBM_DB.conn_errormsg 
-              error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+              error_msg = IBM_DB.getErrormsg( connection.connection, IBM_DB::DB_CONN )
               if error_msg && !error_msg.empty?
                 raise "Statement prepare for updating LOB/XML column failed : #{error_msg}"
               else
@@ -80,8 +79,9 @@ module ActiveRecord
 
             # rollback any failed LOB/XML field updates (and remove associated marker)
             unless IBM_DB.execute(stmt, values)
+              error_msg = "Failed to insert/update LOB/XML field(s) due to: #{IBM_DB.getErrormsg( stmt, IBM_DB::DB_STMT )}"
               connection.execute("ROLLBACK")
-              raise "Failed to insert/update LOB/XML field(s) due to: #{IBM_DB.stmt_errormsg(stmt)}"
+              raise error_msg
             else
               IBM_DB.free_result stmt
             end
@@ -146,44 +146,47 @@ module ActiveRecord
         end
       end
 
-      # Checks if a host name or address has been specified. If so, this implies a TCP/IP connection
-      # Returns IBM_DB.Connection object upon succesful DB connection to the database
-      # If otherwise the connection fails, +false+ is returned
-      if config.has_key?(:host)
-        # Retrieves the host address/name
-        host = config[:host]
-        # A net address connection requires a port. If no port has been specified, 50000 is used by default
-        port = config[:port] || 50000
-        # Connects to the database specified using the hostname, port, authentication type, username and password info
-        # Starting with DB2 9.1FP5 secure connections using SSL are supported. 
-        # On the client side using CLI this is supported from CLI version V95FP2 and onwards.
-        # This feature is set by specifying SECURITY=SSL in the connection string.
-        # Below connection string is constructed and SECURITY parameter is appended if the user has specified the :security option
-        conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
-                       DATABASE=#{database};\
-                       HOSTNAME=#{host};\
-                       PORT=#{port};\
-                       PROTOCOL=TCPIP;\
-                       UID=#{username};\
-                       PWD=#{password};"
-        conn_string << "SECURITY=#{config[:security]};" if config.has_key?(:security)
-        conn_string << "AUTHENTICATION=#{config[:authentication]};" if config.has_key?(:authentication)
-        conn_string << "CONNECTTIMEOUT=#{config[:timeout]};" if config.has_key?(:timeout)
+      begin
+        # Checks if a host name or address has been specified. If so, this implies a TCP/IP connection
+        # Returns IBM_DB.Connection object upon succesful DB connection to the database
+        # If otherwise the connection fails, +false+ is returned
+        if config.has_key?(:host)
+          # Retrieves the host address/name
+          host = config[:host]
+          # A net address connection requires a port. If no port has been specified, 50000 is used by default
+          port = config[:port] || 50000
+          # Connects to the database specified using the hostname, port, authentication type, username and password info
+          # Starting with DB2 9.1FP5 secure connections using SSL are supported. 
+          # On the client side using CLI this is supported from CLI version V95FP2 and onwards.
+          # This feature is set by specifying SECURITY=SSL in the connection string.
+          # Below connection string is constructed and SECURITY parameter is appended if the user has specified the :security option
+          conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
+                         DATABASE=#{database};\
+                         HOSTNAME=#{host};\
+                         PORT=#{port};\
+                         PROTOCOL=TCPIP;\
+                         UID=#{username};\
+                         PWD=#{password};"
+          conn_string << "SECURITY=#{config[:security]};" if config.has_key?(:security)
+          conn_string << "AUTHENTICATION=#{config[:authentication]};" if config.has_key?(:authentication)
+          conn_string << "CONNECTTIMEOUT=#{config[:timeout]};" if config.has_key?(:timeout)
         
-        connection = IBM_DB.connect conn_string, '', '', conn_options
-      else
-        # No host implies a local catalog-based connection: +database+ represents catalog alias
-        connection = IBM_DB.connect( database, username, password, conn_options )
+          connection = IBM_DB.connect conn_string, '', '', conn_options
+        else
+          # No host implies a local catalog-based connection: +database+ represents catalog alias
+          connection = IBM_DB.connect( database, username, password, conn_options )
+        end
+      rescue StandardError => connect_err
+        raise "Failed to connect to [#{database}] due to: #{connect_err}"
       end
-
-      # Verifies that the connection was succesfull
+      # Verifies that the connection was successful
       if connection
         # Creates an instance of *IBM_DBAdapter* based on the +connection+
         # and credentials provided in +config+
         ConnectionAdapters::IBM_DBAdapter.new(connection, logger, config, conn_options)
       else
-        # If the connection failed, it raises a Runtime error
-        raise "Failed to connect to [#{database}] due to: #{IBM_DB.conn_errormsg}"
+        # If the connection failure was not caught previoulsy, it raises a Runtime error
+        raise "An unexpected error occured during connect attempt to [#{database}]"
       end
     end # method self.ibm_db_connection
   end # class Base
@@ -278,13 +281,13 @@ module ActiveRecord
         ibm_parse_column_attributes_args('double',*args)
         return self
       end
-      
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type decfloat
       def decfloat(*args)
         ibm_parse_column_attributes_args('decfloat',*args)
         return self
       end
-      
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
       def char(*args)
         ibm_parse_column_attributes_args('char',*args)
@@ -306,13 +309,13 @@ module ActiveRecord
         end
       end
       private :ibm_parse_column_attributes_args
-      
+
       #Method to support the new syntax of rails 2.0 migrations for columns of type xml 
       def xml(*args )
         ibm_parse_column_attributes_args('xml', *args)
         return self
       end
-      
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type double
       def double(*args)
         ibm_parse_column_attributes_args('double',*args)
@@ -324,14 +327,14 @@ module ActiveRecord
         ibm_parse_column_attributes_args('decfloat',*args)
         return self
       end
-      
+
       #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
       def char(*args)
         ibm_parse_column_attributes_args('char',*args)
         return self
       end
       alias_method :character, :char
-      
+
       # Overrides the abstract adapter in order to handle
       # the DEFAULT option for the native XML datatype
       def column(name, type, options ={})
@@ -440,27 +443,37 @@ module ActiveRecord
 
         if @connection
           server_info = IBM_DB.server_info( @connection )
-          case server_info.DBMS_NAME
-            when /DB2\//i             # DB2 for Linux, Unix and Windows (LUW)
-              case server_info.DBMS_VER
-                when /09.07/i          # DB2 Version 9.7 (Cobra)
-                  @servertype = IBM_DB2_LUW_COBRA.new(self)
-                else                  # DB2 Version 9.5 or below
-                  @servertype = IBM_DB2_LUW.new(self)
-              end
-            when /DB2/i               # DB2 for zOS
-              case server_info.DBMS_VER
-                when /09/             # DB2 for zOS version 9
-                  @servertype = IBM_DB2_ZOS.new(self)
-                when /08/             # DB2 for zOS version 8
-                  @servertype = IBM_DB2_ZOS_8.new(self)
-                else                  # DB2 for zOS version 7
-                  raise "Only DB2 z/OS version 8 and above are currently supported"
-              end
-            when /AS/i                # DB2 for i5 (iSeries)
-              @servertype = IBM_DB2_I5.new(self)
-            when /IDS/i               # Informix Dynamic Server
-              @servertype = IBM_IDS.new(self)
+          if( server_info )
+            case server_info.DBMS_NAME
+              when /DB2\//i             # DB2 for Linux, Unix and Windows (LUW)
+                case server_info.DBMS_VER
+                  when /09.07/i          # DB2 Version 9.7 (Cobra)
+                    @servertype = IBM_DB2_LUW_COBRA.new(self)
+                  else                  # DB2 Version 9.5 or below
+                    @servertype = IBM_DB2_LUW.new(self)
+                end
+              when /DB2/i               # DB2 for zOS
+                case server_info.DBMS_VER
+                  when /09/             # DB2 for zOS version 9
+                    @servertype = IBM_DB2_ZOS.new(self)
+                  when /08/             # DB2 for zOS version 8
+                    @servertype = IBM_DB2_ZOS_8.new(self)
+                  else                  # DB2 for zOS version 7
+                    raise "Only DB2 z/OS version 8 and above are currently supported"
+                end
+              when /AS/i                # DB2 for i5 (iSeries)
+                @servertype = IBM_DB2_I5.new(self)
+              when /IDS/i               # Informix Dynamic Server
+                @servertype = IBM_IDS.new(self)
+              else
+                log( "server_info", "Forcing servertype to LUW: DBMS name could not be retrieved. Check if your client version is of the right level")
+                warn "Forcing servertype to LUW: DBMS name could not be retrieved. Check if your client version is of the right level"
+                @servertype = IBM_DB2_LUW.new(self)
+            end
+          else
+            error_msg = IBM_DB.getErrormsg( @connection, IBM_DB::DB_CONN )
+            IBM_DB.close( @connection )
+            raise "Cannot retrieve server information: #{error_msg}"
           end
         end
 
@@ -531,14 +544,14 @@ module ActiveRecord
       def supports_migrations?
         true
       end
-      
+
       # This Adapter supports DDL transactions.
       # This means CREATE TABLE and other DDL statements can be carried out as a transaction. 
       # That is the statements executed can be ROLLED BACK in case of any error during the process.
       def supports_ddl_transactions?
         true
       end
-      
+
       def log_query(sql, name) #:nodoc:
         # Used by handle_lobs
         log(sql,name){}
@@ -559,23 +572,28 @@ module ActiveRecord
       # It connects to the database with the initially provided credentials
       def connect
         # If the type of connection is net based
-        if @host
-          @conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
-                          DATABASE=#{@database};\
-                          HOSTNAME=#{@host};\
-                          PORT=#{@port};\
-                          PROTOCOL=TCPIP;\
-                          UID=#{@username};\
-                          PWD=#{@password};"
-          @conn_string << "SECURITY=#{@security};" if @security
-          @conn_string << "AUTHENTICATION=#{@authentication};" if @authentication
-          @conn_string << "CONNECTTIMEOUT=#{@timeout};"
-          # Connects and assigns the resulting IBM_DB.Connection to the +@connection+ instance variable
-          @connection = IBM_DB.connect(@conn_string, '', '', @conn_options)
-        else
-          # Connects to the database using the local alias (@database)
-          # and assigns the connection object (IBM_DB.Connection) to @connection
-          @connection = IBM_DB.connect(@database, @username, @password, @conn_options)
+        begin
+          if @host
+            @conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
+                            DATABASE=#{@database};\
+                            HOSTNAME=#{@host};\
+                            PORT=#{@port};\
+                            PROTOCOL=TCPIP;\
+                            UID=#{@username};\
+                            PWD=#{@password};"
+            @conn_string << "SECURITY=#{@security};" if @security
+            @conn_string << "AUTHENTICATION=#{@authentication};" if @authentication
+            @conn_string << "CONNECTTIMEOUT=#{@timeout};"
+            # Connects and assigns the resulting IBM_DB.Connection to the +@connection+ instance variable
+            @connection = IBM_DB.connect(@conn_string, '', '', @conn_options)
+          else
+            # Connects to the database using the local alias (@database)
+            # and assigns the connection object (IBM_DB.Connection) to @connection
+            @connection = IBM_DB.connect(@database, @username, @password, @conn_options)
+          end
+        rescue StandardError => connect_err
+          warn "Connection to database #{@database} failed: #{connect_err}"
+          @connection = false
         end
         # Sets the schema if different from default (username)
         if @schema && @schema != @username
@@ -632,16 +650,18 @@ module ActiveRecord
         results = []
         # Invokes the method +execute+ in order to log and execute the SQL
         # IBM_DB.Statement is returned from which results can be fetched
-        if stmt = execute(sql, name)
+        stmt = execute(sql, name)
+        if(stmt)
           begin
             @servertype.select(sql, name, stmt, results)
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
             else
-              raise "An unexpected error occurred during data retrieval"
+              error_msg = "An unexpected error occurred during data retrieval"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure
             # Ensures to free the resources associated with the statement
@@ -662,16 +682,18 @@ module ActiveRecord
         results = []
         # Invokes the method +execute+ in order to log and execute the SQL
         # IBM_DB.Statement is returned from which results can be fetched
-        if stmt = execute(sql, name)
+        stmt = execute(sql, name)
+        if(stmt)
           begin
             @servertype.select_rows(sql, name, stmt, results)
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error  # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
             else
-              raise "An unexpected error occurred during data retrieval"
+              error_msg = "An unexpected error occurred during data retrieval"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure
             # Ensures to free the resources associated with the statement
@@ -681,7 +703,7 @@ module ActiveRecord
         # The array of record hashes is returned
         results
       end
-      
+
       # Returns a record hash with the column names as keys and column values
       # as values.
       def select_one(sql, name = nil)
@@ -731,25 +753,25 @@ module ActiveRecord
     
         insert_query << " VALUES ("+ params.join(',') + ")"
         unless stmt = IBM_DB.prepare(@connection, insert_query)
-           error_msg = IBM_DB.conn_errormsg 
-           error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+           error_msg = IBM_DB.getErrormsg( @connection, IBM_DB::DB_CONN )
            if error_msg && !error_msg.empty?
-             raise "Failed to prepare statement due to : #{error_msg}"
+             raise "Failed to prepare statement for fixtures insert due to : #{error_msg}"
            else
-             raise StandardError.new('An unexpected error occurred during insert')
+             raise StandardError.new('An unexpected error occurred during preparing SQL for fixture insert')
            end
         end
     
         #log_query(insert_query,'fixture insert')
         log(insert_query,'fixture insert') do
           unless IBM_DB.execute(stmt, insert_values)
-            raise "Failed to insert due to: #{IBM_DB.stmt_errormsg(stmt)}"
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
+            raise "Failed to insert due to: #{error_msg}"
           else
             IBM_DB.free_result stmt
           end
         end
       end
-      
+
       # Perform an insert and returns the last ID generated.
       # This can be the ID passed to the method or the one auto-generated by the database,
       # and retrieved by the +last_generated_id+ method.
@@ -1037,8 +1059,9 @@ module ActiveRecord
         # Initializes the tables array
         tables = []
         # Retrieve table's metadata through IBM_DB driver
-        if stmt = IBM_DB.tables(@connection, nil, 
-                                 @servertype.set_case(@schema))
+        stmt = IBM_DB.tables(@connection, nil, 
+                            @servertype.set_case(@schema))
+        if(stmt)
           begin
             # Fetches all the records available
             while tab = IBM_DB.fetch_assoc(stmt)
@@ -1047,20 +1070,20 @@ module ActiveRecord
                 tables << tab["table_name"].downcase    
               end
             end
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve table metadata during fetch: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of table metadata"
+              error_msg = "An unexpected error occurred during retrieval of table metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure
             IBM_DB.free_result(stmt)  # Free resources associated with the statement
           end
         else # Handle driver execution errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          error_msg = IBM_DB.getErrormsg(@connection, IBM_DB::DB_CONN )
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve tables metadata due to error: #{error_msg}"
           else
@@ -1074,24 +1097,33 @@ module ActiveRecord
       # Returns the primary key of the mentioned table
       def primary_key(table_name)
         pk_name = nil
-        if stmt = IBM_DB.primary_keys( @connection, nil, 
-                                       @servertype.set_case(@schema), 
-                                       @servertype.set_case(table_name))
+        stmt = IBM_DB.primary_keys( @connection, nil, 
+                                    @servertype.set_case(@schema), 
+                                    @servertype.set_case(table_name))
+        if(stmt) 
           begin
             if ( pk_index_row = IBM_DB.fetch_array(stmt) )
               pk_name = pk_index_row[3].downcase
             end
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg( stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve primarykey metadata during fetch: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of primary metadata"
+              error_msg = "An unexpected error occurred during retrieval of primary key metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt) if stmt
           end
+        else
+          error_msg = IBM_DB.getErrormsg( @connection, IBM_DB::DB_CONN )
+          if error_msg && !error_msg.empty?
+            raise "Failed to retrieve primary key metadata due to error: #{error_msg}"
+          else
+            raise StandardError.new('An unexpected error occurred during primary key retrieval')
+          end
         end
         return pk_name
       end
@@ -1113,9 +1145,10 @@ module ActiveRecord
         #TABLE_NAME:: pk_index[2]
         #COLUMN_NAME:: pk_index[3]
         #PK_NAME:: pk_index[5]
-        if stmt = IBM_DB.primary_keys( @connection, nil, 
-                                      @servertype.set_case(@schema), 
-                                      @servertype.set_case(table_name))
+        stmt = IBM_DB.primary_keys( @connection, nil, 
+                                   @servertype.set_case(@schema), 
+                                   @servertype.set_case(table_name))
+        if(stmt)
           begin
             while ( pk_index_row = IBM_DB.fetch_array(stmt) )
               if pk_index_row[5] 
@@ -1128,36 +1161,36 @@ module ActiveRecord
                 end
               end 
             end
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve primarykey metadata during fetch: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of primary metadata"
+              error_msg = "An unexpected error occurred during retrieval of primary key metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt) if stmt
           end
         else  # Handle driver execution errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          error_msg = IBM_DB.getErrormsg(@connection, IBM_DB::DB_CONN )
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve primary key metadata due to error: #{error_msg}"
           else
             raise StandardError.new('An unexpected error occurred during primary key retrieval')
           end
         end
-        
-        
+
         # Query table statistics for all indexes on the table
         # "TABLE_NAME:   #{index_stats[2]}"
         # "NON_UNIQUE:   #{index_stats[3]}"
         # "INDEX_NAME:   #{index_stats[5]}"
         # "COLUMN_NAME:  #{index_stats[8]}"
-        if stmt = IBM_DB.statistics( @connection, nil, 
-                                      @servertype.set_case(@schema), 
-                                      @servertype.set_case(table_name), 1 )
+        stmt = IBM_DB.statistics( @connection, nil, 
+                                  @servertype.set_case(@schema), 
+                                  @servertype.set_case(table_name), 1 )
+        if(stmt)
           begin
             while ( index_stats = IBM_DB.fetch_array(stmt) )
                 is_composite = false
@@ -1182,20 +1215,20 @@ module ActiveRecord
                 end 
               end
             end
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve index metadata during fetch: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of index metadata"
+              error_msg = "An unexpected error occurred during retrieval of index metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt) if stmt
           end
         else  # Handle driver execution errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          error_msg = IBM_DB.getErrormsg(@connection, IBM_DB::DB_CONN )
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve index metadata due to error: #{error_msg}"
           else
@@ -1215,7 +1248,7 @@ module ActiveRecord
         # Returns the indexes array
         return indexes
       end
-      
+
       # Returns an array of Column objects for the table specified by +table_name+
       def columns(table_name, name = nil)
         # to_s required because it may be a symbol.
@@ -1226,9 +1259,10 @@ module ActiveRecord
         # +columns+ will contain the resulting array
         columns = []
         # Statement required to access all the columns information
-        if stmt = IBM_DB.columns( @connection, nil, 
+        stmt = IBM_DB.columns( @connection, nil, 
                                    @servertype.set_case(@schema), 
                                    @servertype.set_case(table_name) )
+        if(stmt)
           begin
             # Fetches all the columns and assigns them to col.
             # +col+ is an hash with keys/value pairs for a column
@@ -1270,20 +1304,20 @@ module ActiveRecord
                 columns << IBM_DBColumn.new(column_name, column_default_value, column_type, column_nullable)
               end
             end
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve column metadata during fetch: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of metadata"
+              error_msg = "An unexpected error occurred during retrieval of column metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt)
           end
         else  # Handle driver execution errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          error_msg = IBM_DB.getErrormsg(@connection, IBM_DB::DB_CONN )
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve column metadata due to error: #{error_msg}"
           else
@@ -1355,7 +1389,7 @@ module ActiveRecord
         end   
       end
 =end
-      
+
       # Sets a new default value for a column. This does not set the default
       # value to +NULL+, instead, it needs DatabaseStatements#execute which
       # can execute the appropriate SQL statement for setting the value.
@@ -1366,12 +1400,12 @@ module ActiveRecord
       def change_column_default(table_name, column_name, default)
         @servertype.change_column_default(table_name, column_name, default)
       end
-      
+
       #Changes the nullability value of a column
       def change_column_null(table_name, column_name, null, default = nil)
         @servertype.change_column_null(table_name, column_name, null, default)
       end
-      
+
       # Remove the given index from the table.
       #
       # Remove the suppliers_name_index in the suppliers table (legacy support, use the second or third forms).
@@ -1439,13 +1473,14 @@ To remove the column, the table must be dropped and recreated without the #{colu
             # Add the record to the +results+ array
             results <<  single_hash
           end
-        rescue StandardError  # Handle driver fetch errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+        rescue StandardError => fetch_error # Handle driver fetch errors
+          error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
           if error_msg && !error_msg.empty?
             raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
           else
-            raise "An unexpected error occurred during data retrieval"
+            error_msg = "An unexpected error occurred during data retrieval"
+            error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+            raise error_msg
           end
         ensure  # Free resources associated with the statement
           IBM_DB.free_result(stmt)
@@ -1461,30 +1496,30 @@ To remove the column, the table must be dropped and recreated without the #{colu
             #Add the array to results array
             results <<  single_array
           end
-        rescue StandardError  # Handle driver fetch errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+        rescue StandardError => fetch_error # Handle driver fetch errors
+          error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
           if error_msg && !error_msg.empty?
             raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
           else
-            raise "An unexpected error occurred during data retrieval"
+            error_msg = "An unexpected error occurred during data retrieval"
+            error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+            raise error_msg
           end
         ensure  # Free resources associated with the statement
           IBM_DB.free_result(stmt)
         end
       end
-      
+
       def execute(sql, name = nil)
         begin
           if stmt = IBM_DB.exec(@adapter.connection, sql)
             stmt   # Return the statement object
           else
-            raise StatementInvalid, IBM_DB.stmt_errormsg
+            raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
           end
-        rescue StandardError
-          error_msg = IBM_DB.conn_errormsg
-          if error_msg && !error_msg.empty?
-            raise "Failed to execute statement due to communication error: #{error_msg}"
+        rescue StandardError => exec_err
+          if exec_err && !exec_err.message.empty?
+            raise "Failed to execute statement due to: #{exec_err}"
           else 
             raise
           end
@@ -1545,26 +1580,27 @@ To remove the column, the table must be dropped and recreated without the #{colu
       def last_generated_id(stmt)
         # Queries the db to obtain the last ID that was automatically generated
         sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
-        if stmt = IBM_DB.exec(@adapter.connection, sql)
+        stmt = IBM_DB.exec(@adapter.connection, sql)
+        if(stmt)
           begin
             # Fetches the only record available (containing the last id)
             IBM_DB.fetch_row(stmt)
             # Retrieves and returns the result of the query with the last id.
             IBM_DB.result(stmt,0)
-          rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          rescue StandardError => fetch_error # Handle driver fetch errors
+            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve last generated id: #{error_msg}"
             else
-              raise "An unexpected error occurred during retrieval of last generated id"
+              error_msg = "An unexpected error occurred during retrieval of last generated id"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
             end
           ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt) if stmt
           end
         else
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          error_msg = IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve last generated id due to error: #{error_msg}"
           else
@@ -1642,7 +1678,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       def get_double_mapping
         return "double"
       end
-      
+
       # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
       # an hash for each single record.
       # The loop stops when there aren't any more valid records to fetch
@@ -1697,13 +1733,14 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
               results <<  single_hash
             end
           end
-        rescue StandardError  # Handle driver fetch errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+        rescue StandardError => fetch_error # Handle driver fetch errors
+          error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
           if error_msg && !error_msg.empty?
             raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
           else
-            raise "An unexpected error occurred during data retrieval"
+            error_msg = "An unexpected error occurred during data retrieval"
+            error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+            raise error_msg
           end
         ensure
           # Assign the instance variables to nil. We will not be using them again
@@ -1766,13 +1803,14 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
               results <<  single_array
             end
           end
-        rescue StandardError  # Handle driver fetch errors
-          error_msg = IBM_DB.conn_errormsg 
-          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+        rescue StandardError => fetch_error # Handle driver fetch errors
+          error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
           if error_msg && !error_msg.empty?
             raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
           else
-            raise "An unexpected error occurred during data retrieval"
+            error_msg = "An unexpected error occurred during data retrieval"
+            error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+            raise error_msg
           end
         ensure
           # Assign the instance variables to nil. We will not be using them again
@@ -1780,7 +1818,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           @limit = nil
         end
       end
-      
+
       def execute(sql, name = nil)
         # Check if there is a limit and/or an offset
         # If so then make sure and use a static cursor type
@@ -1791,30 +1829,24 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
                       {IBM_DB::SQL_ATTR_CURSOR_TYPE => IBM_DB::SQL_CURSOR_STATIC})
               stmt   # Return the statement object
             else
-              raise StatementInvalid, IBM_DB.stmt_errormsg
-            end
-          rescue StandardError
-            error_msg = IBM_DB.conn_errormsg
-            if error_msg && !error_msg.empty?
-              raise "Failed to execute statement due to communication error: #{error_msg}"
-            else
-              raise
+              raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
             end
+          rescue StandardError => exec_err
+            error_msg = "Failed to execute statement due to"
+            error_msg = error_msg + ": #{exec_err.message}" if !exec_err.message.empty?     
+            raise error_msg
           end
         else
           begin
             if stmt = IBM_DB.exec(@adapter.connection, sql)
               stmt   # Return the statement object
             else
-              raise StatementInvalid, IBM_DB.stmt_errormsg
-            end
-          rescue StandardError
-            error_msg = IBM_DB.conn_errormsg
-            if error_msg && !error_msg.empty?
-              raise "Failed to execute statement due to communication error: #{error_msg}"
-            else
-              raise
+              raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
             end
+          rescue StandardError => exec_err
+            error_msg = "Failed to execute statement due to"
+            error_msg = error_msg + ": #{exec_err.message}" if !exec_err.message.empty?     
+            raise error_msg
           end
         end
       end
@@ -1902,8 +1934,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
                    TO #{_new_column_name}"
 
           unless stmt = execute(rename_column_sql)
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            error_msg = IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
             if error_msg && !error_msg.empty?
               raise "Rename column failed : #{error_msg}"
             else
@@ -1968,8 +1999,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
                    TO #{_new_column_name}"
 
           unless stmt = execute(rename_column_sql)
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            error_msg = IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
             if error_msg && !error_msg.empty?
               raise "Rename column failed : #{error_msg}"
             else
@@ -1998,7 +2028,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           super
         end
       end
-      
+
       def change_column_null(table_name, column_name, null, default)
         raise NotImplementedError,
         "DB2 for zOS data server does not support changing the column's nullability"
@@ -2007,7 +2037,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
 
     class IBM_DB2_ZOS_8 < IBM_DB2_ZOS
       include HostedDataServer
-      
+
       # This call is needed on DB2 z/OS v8 for the creation of tables
       # with LOBs.  When issued, this call does the following:
       #   DB2 creates LOB table spaces, auxiliary tables, and indexes on auxiliary
@@ -2056,8 +2086,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
                #{new_column_name}"
 
           unless stmt = execute(rename_column_sql)
-            error_msg = IBM_DB.conn_errormsg 
-            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            error_msg = IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
             if error_msg && !error_msg.empty?
               raise "Rename column failed : #{error_msg}"
             else