ibm_db 1.5.0 → 2.0.0

data/CHANGES

@@ -1,5 +1,9 @@
 Change Log
 ==============
+2010/01/21 (IBM_DB adapter 2.0.0, driver 2.0.0) :
+  - Support for usage of parameterized SQL queries
+  - Exposed constant VERSION in the driver [Feature Request: #27231]
+
 2009/08/21 (IBM_DB adapter 1.5.0, driver 1.5.0) :
   - non-block enhancement in the ruby driver made for Ruby version 1.9. [support request #25023]
   - New API's getErrormsg and getErrorstate for retrieving error messages/state added

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2006, 2007, 2008, 2009 IBM Corporation
+Copyright (c) 2006, 2007, 2008, 2009, 2010 IBM Corporation
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the "Software"),

data/ParameterizedQueries README

@@ -0,0 +1,39 @@
++-------------------------------------------+-------------------------------------------+
+| README for Parameterized Queries Support in Ruby-on-Rails/ Activerecord applications  |
++-------------------------------------------+-------------------------------------------+
+
+Enabling Usage of Parameterized Queries with Ruby-on-Rails / Activerecord applications
+======================================================================================
+	To enable usage of parameterized SQL queries with Ruby-on-Rails/ActiveRecord applications, in your connection configuration (database.yml), set "parameterized" to true. By default "parameterized" is false (if not specified). A sample database.yml file showing development section with parameterized queries enabled looks as below
+
+development:
+  adapter:     ibm_db
+  username:    db2inst1
+  password:    secret
+  database:    devdb
+  #schema:      db2inst1
+  #host:        localhost
+  #port:        50000
+  #account:     my_account
+  #app_user:    my_app_user
+  #application: my_application
+  #workstation: my_workstation
+  parameterized: true
+
+Similarly for the other sections (test/production) of the database.yml file set "parameterized" to true to enable usage of parameterized SQL queries
+
+Supported Activerecord Versions
+===============================
+  Activerecord-2.3.3, Activerecord-2.3.4, Activerecord-2.3.5
+  
+Supported Operating Systems and Databases
+=========================================
+Refer the main README
+
+Feedback
+========
+  Your feedback is very much appreciated and expected through Rubyforge:
+   - rubyibm project:     http://rubyforge.org/projects/rubyibm/
+   - rubyibm forum:       http://rubyforge.org/forum/?group_id=2361
+   - rubyibm bug reports: http://rubyforge.org/tracker/?group_id=2361
+   - IBM_DB developers:   rubyibm-developers@rubyforge.org

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (1.5.0) and Driver (1.5.0) (2009/08/21)
+README for the IBM_DB Adapter (2.0.0) and Driver (2.0.0) (2010/01/21)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 

data/ext/ibm_db.c

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2006, 2007,2008, 2009                  |
+  | (C) Copyright IBM Corporation 2006, 2007,2008, 2009, 2010            |
   +----------------------------------------------------------------------+
   | Authors: Sushant Koduru, Lynh Nguyen, Kanchana Padmanabhan,          |
   |          Dan Scott, Helmut Tessarek, Sam Ruby, Kellen Bombardier,    |
@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "1.5.0"
+#define MODULE_RELEASE "2.0.0"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -31,7 +31,7 @@ static struct  _ibm_db_globals *ibm_db_globals;
 static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType, SQLHANDLE handle, SQLSMALLINT hType,
                                            int rc, int cpy_to_global, char* ret_str, int API, SQLSMALLINT recno, 
                                            int release_gil );
-static VALUE _ruby_ibm_db_assign_options( void* handle, int type, long opt_key, VALUE data, char *error );
+static VALUE _ruby_ibm_db_assign_options( void* handle, int type, long opt_key, VALUE data, VALUE *error );
 static void _ruby_ibm_db_clear_conn_err_cache();
 static void _ruby_ibm_db_clear_stmt_err_cache();
 static int  _ruby_ibm_db_set_decfloat_rounding_mode_client(SQLHANDLE hdbc);
@@ -44,7 +44,7 @@ typedef struct _stmt_bind_data_array {
   stmt_handle   *stmt_res;
   SQLSMALLINT   num;
   int           bind_params;
-  char          *error;
+  VALUE         *error;
 }stmt_bind_array;
 
 /*
@@ -55,7 +55,8 @@ typedef struct _ibm_db_connect_helper_args_struct {
   connect_args  *conn_args;
   int           isPersistent;
   VALUE         *options;
-  char          *error;
+  VALUE         *error;
+  int           literal_replacement;
 } connect_helper_args;
 
 /*
@@ -64,7 +65,7 @@ typedef struct _ibm_db_connect_helper_args_struct {
 typedef struct _ibm_db_result_args_struct {
   stmt_handle  *stmt_res;
   VALUE        column;
-  char         *error;
+  VALUE        *error;
 } ibm_db_result_args;
 
 /*
@@ -75,7 +76,7 @@ typedef struct _ibm_db_fetch_helper_struct {
   VALUE        row_number;
   int          arg_count;
   int          funcType;
-  char         *error;
+  VALUE        *error;
 } ibm_db_fetch_helper_args;
 
 void ruby_init_ibm_db();
@@ -241,10 +242,10 @@ static void ruby_ibm_db_init_globals(struct _ibm_db_globals *ibm_db_globals)
   /* env handle */
   ibm_db_globals->bin_mode = 1;
 
-  memset(ibm_db_globals->__ruby_conn_err_msg, 0, DB2_MAX_ERR_MSG_LEN);
-  memset(ibm_db_globals->__ruby_stmt_err_msg, 0, DB2_MAX_ERR_MSG_LEN);
-  memset(ibm_db_globals->__ruby_conn_err_state, 0, SQL_SQLSTATE_SIZE + 1);
-  memset(ibm_db_globals->__ruby_stmt_err_state, 0, SQL_SQLSTATE_SIZE + 1);
+  memset(ibm_db_globals->__ruby_conn_err_msg, '\0', DB2_MAX_ERR_MSG_LEN);
+  memset(ibm_db_globals->__ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN);
+  memset(ibm_db_globals->__ruby_conn_err_state, '\0', SQL_SQLSTATE_SIZE + 1);
+  memset(ibm_db_globals->__ruby_stmt_err_state, '\0', SQL_SQLSTATE_SIZE + 1);
 }
 /*  */
 
@@ -268,18 +269,20 @@ char *estrndup(char *data, int max) {
   return dup;
 }
 
-char *strtolower(char *data, int max) {
-  while (max--) {
-    data[max] = tolower(data[max]);
+void strtolower(char *data, int max) {
+  if( max > 0 ) {
+    while (max--) {
+      data[max] = tolower(data[max]);
+    }
   }
-  return data;
 }
 
-char *strtoupper(char *data, int max) {
-  while (max--) {
-    data[max] = toupper(data[max]);
+void strtoupper(char *data, int max) {
+  if( max > 0 ) {
+    while (max--) {
+      data[max] = toupper(data[max]);
+    }
   }
-  return data;
 }
 
 /*  static void _ruby_ibm_db_mark_conn_struct */
@@ -317,6 +320,7 @@ static void _ruby_ibm_db_free_conn_struct(conn_handle *handle)
       ruby_xfree( handle );
     }*/
     ruby_xfree( handle );
+    handle = NULL;
   }
 }
 /*  */
@@ -344,7 +348,10 @@ static void _ruby_ibm_db_mark_row_struct(row_hash_struct *handle)
 /*  static void _ruby_ibm_db_free_row_struct */
 static void _ruby_ibm_db_free_row_struct(row_hash_struct *handle)
 {
-  ruby_xfree( handle );
+  if ( handle != NULL ) {
+    ruby_xfree( handle );
+    handle = NULL;
+  }
 }
 /*  */
 
@@ -360,22 +367,28 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
     curr_ptr = handle->head_cache_list;
     prev_ptr = handle->head_cache_list;
 
-    while (curr_ptr != NULL) {
+    while ( curr_ptr != NULL ) {
       curr_ptr = curr_ptr->next;
 
-      if (prev_ptr->varname) {
+      if ( prev_ptr->varname != NULL ) {
         ruby_xfree( prev_ptr->varname );
+        prev_ptr->varname = NULL;
       }
 
-      if ( prev_ptr->svalue ) {
+      if ( prev_ptr->svalue != NULL ) {
         ruby_xfree( prev_ptr->svalue );
+        prev_ptr->svalue = NULL;
       }
       ruby_xfree( prev_ptr );
 
       prev_ptr = curr_ptr;
     }
+    handle->head_cache_list = NULL;
+    handle->num_params      = 0;
+    handle->current_node    = NULL;
+
     /* free row data cache */
-    if (handle->row_data) {
+    if ( handle->row_data ) {
       for (i=0; i<handle->num_columns;i++) {
         switch (handle->column_info[i].type) {
           case SQL_CHAR:
@@ -404,7 +417,10 @@ static void _ruby_ibm_db_free_result_struct(stmt_handle* handle)
     /* free column info cache */
     if ( handle->column_info ) {
       for (i=0; i<handle->num_columns; i++) {
-        ruby_xfree( handle->column_info[i].name );
+        if ( handle->column_info[i].name != NULL ) {
+          ruby_xfree( handle->column_info[i].name );
+          handle->column_info[i].name = NULL;
+        }
       }
       ruby_xfree( handle->column_info );
       handle->column_info = NULL;
@@ -421,7 +437,7 @@ static stmt_handle *_ibm_db_new_stmt_struct(conn_handle* conn_res)
   stmt_handle *stmt_res;
 
   stmt_res = ALLOC( stmt_handle );
-  memset( stmt_res, 0, sizeof(stmt_handle) );
+  memset( stmt_res, '\0', sizeof(stmt_handle) );
 
   /* Initialize stmt resource so parsing assigns updated options if needed */
   stmt_res->hdbc         =  conn_res->hdbc;
@@ -443,7 +459,8 @@ static stmt_handle *_ibm_db_new_stmt_struct(conn_handle* conn_res)
 
   stmt_res->row_data = NULL;
 
-  stmt_res->is_executing = 0;
+  stmt_res->is_executing    = 0;
+  stmt_res->is_freed        = 0;
 
   stmt_res->ruby_stmt_err_msg    =  NULL;
   stmt_res->ruby_stmt_err_state  =  NULL;
@@ -456,31 +473,47 @@ static stmt_handle *_ibm_db_new_stmt_struct(conn_handle* conn_res)
 static void _ruby_ibm_db_mark_stmt_struct(stmt_handle *handle)
 {
 }
+
 /*  */
 
-/*  static _ruby_ibm_db_free_stmt_struct */
-static void _ruby_ibm_db_free_stmt_struct(stmt_handle *handle)
+/*  static _ruby_ibm_db_free_stmt_handle_and_resources */
+static void _ruby_ibm_db_free_stmt_handle_and_resources(stmt_handle *handle)
 {
   int rc;
   if ( handle != NULL ) {
 
-    rc = SQLFreeHandle( SQL_HANDLE_STMT, handle->hstmt );
+    if( !handle->is_freed ) {
+      rc = SQLFreeHandle( SQL_HANDLE_STMT, handle->hstmt );
 
-    _ruby_ibm_db_free_result_struct( handle );
+      _ruby_ibm_db_free_result_struct( handle );
 
-    if( handle->ruby_stmt_err_msg) {
-      ruby_xfree( handle->ruby_stmt_err_msg );
-      handle->ruby_stmt_err_msg = NULL;
-    }
+      if( handle->ruby_stmt_err_msg != NULL ) {
+        ruby_xfree( handle->ruby_stmt_err_msg );
+        handle->ruby_stmt_err_msg = NULL;
+      }
 
-    if( handle->ruby_stmt_err_state) {
-      ruby_xfree( handle->ruby_stmt_err_state );
-      handle->ruby_stmt_err_state = NULL;
+      if( handle->ruby_stmt_err_state != NULL ) {
+        ruby_xfree( handle->ruby_stmt_err_state );
+        handle->ruby_stmt_err_state = NULL;
+      }
+      handle->is_freed = 1; /* Indicates that the handle is freed */
     }
+  }
+}
 
+/*  */
+
+/*  static _ruby_ibm_db_free_stmt_struct */
+static void _ruby_ibm_db_free_stmt_struct(stmt_handle *handle)
+{
+  int rc;
+  if ( handle != NULL ) {
+    _ruby_ibm_db_free_stmt_handle_and_resources( handle );
     ruby_xfree( handle );
+    handle = NULL;
   }
 }
+
 /*  */
 
 /* allow direct access to hash object as object attributes */
@@ -514,7 +547,7 @@ void ruby_init_ibm_db()
 #endif
 
   ibm_db_globals = ALLOC(struct _ibm_db_globals);
-  memset(ibm_db_globals, 0, sizeof(struct _ibm_db_globals));
+  memset(ibm_db_globals, '\0', sizeof(struct _ibm_db_globals));
 
   ruby_ibm_db_init_globals(ibm_db_globals);
 
@@ -592,6 +625,12 @@ void ruby_init_ibm_db()
   rb_define_const(mDB, "DB_CONN", INT2NUM(DB_CONN));
   /*Specifies resource Type passed is Statement Handle, for retrieving error message*/
   rb_define_const(mDB, "DB_STMT", INT2NUM(DB_STMT));
+  /*Specifies Quoted Literal replacement connection attribute is to be set*/
+  rb_define_const(mDB, "QUOTED_LITERAL_REPLACEMENT_ON", INT2NUM(SET_QUOTED_LITERAL_REPLACEMENT_ON));
+  /*Specifies Quoted Literal replacement connection attribute should not be set*/
+  rb_define_const(mDB, "QUOTED_LITERAL_REPLACEMENT_OFF", INT2NUM(SET_QUOTED_LITERAL_REPLACEMENT_OFF));
+  /*Specfies the version of the driver*/
+  rb_define_const(mDB, "VERSION",rb_str_new2(MODULE_RELEASE));
 
   rb_global_variable(&persistent_list);
 
@@ -699,7 +738,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
   memset(msg, '\0', SQL_MAX_MESSAGE_LENGTH + 1);
   memset(sqlstate, '\0', SQL_SQLSTATE_SIZE + 1);
 
-  get_DiagRec_args  =  ALLOC_N(get_diagRec_args, sizeof(struct _ibm_db_get_diagRec_struct));
+  get_DiagRec_args  =  ALLOC(get_diagRec_args);
   memset(get_DiagRec_args,'\0',sizeof(struct _ibm_db_get_diagRec_struct));
 
   get_DiagRec_args->hType            =   hType;
@@ -762,14 +801,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
               }
 
               if( conn_res->ruby_error_msg == NULL ) {
-                conn_res->ruby_error_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
+                conn_res->ruby_error_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
               }
 
               memset( conn_res->ruby_error_state,'\0', SQL_SQLSTATE_SIZE+1 );
-              memset( conn_res->ruby_error_msg,'\0', DB2_MAX_ERR_MSG_LEN );
+              memset( conn_res->ruby_error_msg,'\0', DB2_MAX_ERR_MSG_LEN+1 );
 
               strncpy(conn_res->ruby_error_state, (char*)sqlstate, SQL_SQLSTATE_SIZE+1 );
-              strncpy(conn_res->ruby_error_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN );
+              strncpy(conn_res->ruby_error_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN+1 );
 
               break;
 
@@ -786,14 +825,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
                   }
 
                   if( conn_res->ruby_error_msg == NULL ) {
-                    conn_res->ruby_error_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
+                    conn_res->ruby_error_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
                   }
 
                   memset( conn_res->ruby_error_state,'\0', SQL_SQLSTATE_SIZE+1 );
-                  memset( conn_res->ruby_error_msg,'\0', DB2_MAX_ERR_MSG_LEN );
+                  memset( conn_res->ruby_error_msg,'\0', DB2_MAX_ERR_MSG_LEN+1 );
 
                   strncpy(conn_res->ruby_error_state, (char*)sqlstate, SQL_SQLSTATE_SIZE+1 );
-                  strncpy(conn_res->ruby_error_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN );
+                  strncpy(conn_res->ruby_error_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN+1 );
 
                   break;
 
@@ -807,14 +846,14 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
                   }
 
                   if( stmt_res->ruby_stmt_err_msg == NULL ) {
-                    stmt_res->ruby_stmt_err_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
+                    stmt_res->ruby_stmt_err_msg = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
                   }
 
                   memset( stmt_res->ruby_stmt_err_state, '\0', SQL_SQLSTATE_SIZE+1 );
-                  memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+                  memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
                   strncpy(stmt_res->ruby_stmt_err_state, (char*)sqlstate, SQL_SQLSTATE_SIZE+1 );
-                  strncpy(stmt_res->ruby_stmt_err_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN );
+                  strncpy(stmt_res->ruby_stmt_err_msg, (char*)errMsg, DB2_MAX_ERR_MSG_LEN+1 );
 
                   break; 
 
@@ -825,7 +864,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
                 conn_errormsg and conn_error are removed
               */
               strncpy(IBM_DB_G(__ruby_stmt_err_state), (char*)sqlstate, SQL_SQLSTATE_SIZE+1);
-              strncpy(IBM_DB_G(__ruby_stmt_err_msg), (char*)errMsg, DB2_MAX_ERR_MSG_LEN);
+              strncpy(IBM_DB_G(__ruby_stmt_err_msg), (char*)errMsg, DB2_MAX_ERR_MSG_LEN+1);
 
               break;
 
@@ -842,7 +881,7 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
             return;
           case DB_ERRMSG:
             if ( ret_str != NULL ) {
-              strncpy(ret_str, (char*)msg, DB2_MAX_ERR_MSG_LEN);
+              strncpy(ret_str, (char*)msg, DB2_MAX_ERR_MSG_LEN+1);
             }
             return;
           default:
@@ -859,9 +898,9 @@ static void _ruby_ibm_db_check_sql_errors( void *conn_or_stmt, int resourceType,
 /*  */
 
 /*  
-   static void _ruby_ibm_db_assign_options( void *handle, int type, long opt_key, VALUE data, char *error )
+   static void _ruby_ibm_db_assign_options( void *handle, int type, long opt_key, VALUE data, VALUE *error )
 */
-static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key, VALUE data, char *error )
+static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key, VALUE data, VALUE *error )
 {
   int    rc            =  0;
   long   option_num    =  0;
@@ -884,7 +923,7 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
           ((stmt_handle*)handle)->s_case_mode = CASE_NATURAL;
           break;
         default:
-          sprintf(error,"ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
+          *error = rb_str_new2("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
           return Qfalse;
       }
     } else if (type == SQL_HANDLE_DBC) {
@@ -899,15 +938,15 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
           ((conn_handle*)handle)->c_case_mode = CASE_NATURAL;
           break;
         default:
-          sprintf(error,"ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
+          *error = rb_str_new2("ATTR_CASE attribute must be one of CASE_LOWER, CASE_UPPER, or CASE_NATURAL");
           return Qfalse;
       }
     } else {
-      sprintf(error,"Connection or statement handle must be passed in.");
+      *error = rb_str_new2("Connection or statement handle must be passed in");
       return Qfalse;
     }
   } else if (type == SQL_HANDLE_STMT) {
-    handleAttr_args = ALLOC_N(set_handle_attr_args,sizeof(struct _ibm_db_set_handle_attr_struct));
+    handleAttr_args = ALLOC( set_handle_attr_args );
     memset(handleAttr_args,'\0',sizeof(struct _ibm_db_set_handle_attr_struct));
 
     handleAttr_args->handle      =  &((stmt_handle *)handle)->hstmt;
@@ -927,7 +966,13 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( handle, DB_STMT, (SQLHSTMT)((stmt_handle *)handle)->hstmt, 
                   SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error,"Setting of statement attribute failed: %s", ((stmt_handle *)handle)->ruby_stmt_err_msg);
+        ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        if( handle != NULL && ((stmt_handle *)handle)->ruby_stmt_err_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Setting of statement attribute failed: "), ((stmt_handle *)handle)->ruby_stmt_err_msg);
+        } else {
+          *error = rb_str_new2("Setting of statement attribute failed: <error message could not be retrieved>");
+        }
         return Qfalse;
       }
     } else {
@@ -950,12 +995,18 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( handle, DB_STMT, (SQLHSTMT)((stmt_handle *)handle)->hstmt, 
                   SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error,"Setting of statement attribute failed: %s", ((stmt_handle *)handle)->ruby_stmt_err_msg);
+        ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        if( handle != NULL && ((stmt_handle *)handle)->ruby_stmt_err_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Setting of statement attribute failed: "), ((stmt_handle *)handle)->ruby_stmt_err_msg);
+        } else {
+          *error = rb_str_new2("Setting of statement attribute failed: <error message could not be retrieved>");
+        }
         return Qfalse;
       }
     }
   } else if (type == SQL_HANDLE_DBC) {
-    handleAttr_args = ALLOC_N(set_handle_attr_args,sizeof(struct _ibm_db_set_handle_attr_struct));
+    handleAttr_args = ALLOC( set_handle_attr_args );
     memset(handleAttr_args,'\0',sizeof(struct _ibm_db_set_handle_attr_struct));
 
     handleAttr_args->handle      =  &((conn_handle*)handle)->hdbc;
@@ -975,7 +1026,13 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( handle, DB_CONN, (SQLHDBC)((conn_handle *)handle)->hdbc, 
                   SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error,"Setting of connection attribute failed: %s", ((conn_handle *)handle)->ruby_error_msg);
+        ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        if( handle != NULL && ((conn_handle *)handle)->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Setting of connection attribute failed: "), ((conn_handle *)handle)->ruby_error_msg);
+        } else {
+          *error =  rb_str_new2("Setting of connection attribute failed: <error message could not be retrieved>");
+        }
         return Qfalse;
       }
     } else {
@@ -996,12 +1053,18 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( handle, DB_CONN, (SQLHDBC)((conn_handle *)handle)->hdbc, 
                   SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0);
-        sprintf(error,"Setting of connection attribute failed: %s", ((conn_handle *)handle)->ruby_error_msg);
+        ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        if( handle != NULL && ((conn_handle *)handle)->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Setting of connection attribute failed: "), ((conn_handle *)handle)->ruby_error_msg);
+        } else {
+          *error = rb_str_new2("Setting of connection attribute failed: <error message could not be retrieved>");
+        }
         return Qfalse;
       }
     }
   } else {
-      sprintf(error,"Connection or statement handle must be passed in.");
+      *error = rb_str_new2("Connection or statement handle must be passed in");
       return Qfalse;
   }
 
@@ -1015,9 +1078,9 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
 }
 /*  */
 
-/*  static int _ruby_ibm_db_parse_options( VALUE options, int type, void *handle)
+/*  static int _ruby_ibm_db_parse_options( VALUE options, int type, void *handle, VALUE *error)
 */
-static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle, char *error )
+static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle, VALUE *error )
 {
   int   numOpts = 0, i = 0;
   VALUE keys;
@@ -1061,12 +1124,12 @@ static int _ruby_ibm_db_parse_options ( VALUE options, int type, void *handle, c
 static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
 {
   int rc = -1, i;
-  SQLCHAR *tmp_name;
+  SQLCHAR tmp_name[BUFSIZ];
 
   row_col_count_args *result_cols_args = NULL;
   describecol_args   *describecolargs  = NULL;
 
-  result_cols_args = ALLOC_N(row_col_count_args,sizeof(struct _ibm_db_row_col_count_struct));
+  result_cols_args = ALLOC( row_col_count_args );
   memset(result_cols_args,'\0',sizeof(struct _ibm_db_row_col_count_struct));
 
   result_cols_args->stmt_res =  stmt_res;
@@ -1077,6 +1140,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
   if ( rc == SQL_ERROR || result_cols_args->count == 0) {
     _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
     ruby_xfree( result_cols_args );
+    result_cols_args = NULL;
     return -1;
   }
   stmt_res->num_columns = result_cols_args->count;
@@ -1084,7 +1148,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
   stmt_res->column_info = ALLOC_N(ibm_db_result_set_info, result_cols_args->count);
   memset(stmt_res->column_info, 0, sizeof(ibm_db_result_set_info)*(result_cols_args->count));
 
-  describecolargs = ALLOC_N(describecol_args,sizeof(struct _ibm_db_describecol_args_struct));
+  describecolargs = ALLOC( describecol_args );
   memset(describecolargs,'\0',sizeof(struct _ibm_db_describecol_args_struct));
 
   describecolargs->stmt_res     =  stmt_res;
@@ -1095,7 +1159,7 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
     stmt_res->column_info[i].loc_ind  = 0;
     stmt_res->column_info[i].loc_type = 0;
 
-    stmt_res->column_info[i].name = (SQLCHAR*)ALLOC_N(char, BUFSIZ);
+    stmt_res->column_info[i].name = tmp_name;
     memset(stmt_res->column_info[i].name, '\0', BUFSIZ);
 
     describecolargs->col_no       =  i + 1;
@@ -1108,14 +1172,16 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
       _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
       ruby_xfree( result_cols_args );
       ruby_xfree( describecolargs );
+      ruby_xfree( stmt_res->column_info );
+      result_cols_args       =  NULL;
+      describecolargs        =  NULL;
+      stmt_res->column_info  =  NULL;
       return -1;
     }
     if ( describecolargs->name_length <= 0 ) {
-      ruby_xfree( stmt_res->column_info[i].name );
       stmt_res->column_info[i].name = (SQLCHAR *)estrdup("");
     } else if ( describecolargs->name_length >= BUFSIZ ) {
       /* column name is longer than BUFSIZ, free the previously allocate memory and reallocate new*/
-      ruby_xfree( stmt_res->column_info[i].name );
 
       stmt_res->column_info[i].name = (SQLCHAR*)ALLOC_N(char, describecolargs->name_length+1);
       describecolargs->buff_length  =  describecolargs->name_length + 1;
@@ -1126,12 +1192,14 @@ static int _ruby_ibm_db_get_result_set_info(stmt_handle *stmt_res)
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
         ruby_xfree( describecolargs );
         ruby_xfree( result_cols_args );
+        ruby_xfree( stmt_res->column_info );
+        result_cols_args       =  NULL;
+        describecolargs        =  NULL;
+        stmt_res->column_info  =  NULL;
         return -1;
       }
     } else {
-      tmp_name = stmt_res->column_info[i].name;
-      stmt_res->column_info[i].name = (SQLCHAR*) estrndup( (char *)tmp_name, describecolargs->name_length );
-      ruby_xfree( tmp_name );
+      stmt_res->column_info[i].name = (SQLCHAR*) estrdup( (char *)tmp_name );
     }
   }
 
@@ -1161,9 +1229,9 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
   bind_col_args *bindCol_args = NULL;
 
   stmt_res->row_data = ALLOC_N(ibm_db_row_type, stmt_res->num_columns);
-  memset(stmt_res->row_data,0,sizeof(ibm_db_row_type)*stmt_res->num_columns);
+  memset(stmt_res->row_data,'\0',sizeof(ibm_db_row_type)*stmt_res->num_columns);
 
-  bindCol_args = ALLOC_N(bind_col_args,sizeof(struct _ibm_db_bind_col_struct));
+  bindCol_args = ALLOC( bind_col_args );
   memset(bindCol_args,'\0',sizeof(struct _ibm_db_bind_col_struct));
 
   bindCol_args->stmt_res  =  stmt_res;
@@ -1381,8 +1449,8 @@ static int _ruby_ibm_db_bind_column_helper(stmt_handle *stmt_res)
 */
 static void _ruby_ibm_db_clear_stmt_err_cache()
 {
-  memset(IBM_DB_G(__ruby_stmt_err_msg), 0, DB2_MAX_ERR_MSG_LEN);
-  memset(IBM_DB_G(__ruby_stmt_err_state), 0, SQL_SQLSTATE_SIZE + 1);
+  memset(IBM_DB_G(__ruby_stmt_err_msg), '\0', DB2_MAX_ERR_MSG_LEN);
+  memset(IBM_DB_G(__ruby_stmt_err_state), '\0', SQL_SQLSTATE_SIZE + 1);
 }
 
 /*  static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data )
@@ -1397,7 +1465,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
   connect_args *conn_args    =  data->conn_args;
   VALUE        *options      =  data->options;
   int          isPersistent  =  data->isPersistent;
-  char         *error        =  data->error;
+  VALUE        *error        =  data->error;
 
   int   rc       =  0;
   int   reused   =  0;
@@ -1412,7 +1480,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
   conn_alive = 1;
 
-  handleAttr_args = ALLOC_N(set_handle_attr_args,sizeof(struct _ibm_db_set_handle_attr_struct));
+  handleAttr_args = ALLOC( set_handle_attr_args );
   memset(handleAttr_args,'\0',sizeof(struct _ibm_db_set_handle_attr_struct));
 
   do {
@@ -1427,7 +1495,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
         Data_Get_Struct(entry, conn_handle, conn_res);
 #ifndef PASE /* i5/OS server mode is persistant */
         /* Need to reinitialize connection? */
-        get_handleAttr_args = ALLOC_N(get_handle_attr_args,sizeof(struct _ibm_db_get_handle_attr_struct));
+        get_handleAttr_args = ALLOC( get_handle_attr_args );
         memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
 
         get_handleAttr_args->handle       =  &( conn_res->hdbc );
@@ -1439,6 +1507,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
         rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
 
         ruby_xfree( get_handleAttr_args );
+        get_handleAttr_args = NULL;
 
         if ( (rc == SQL_SUCCESS) && conn_alive ) {
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
@@ -1453,9 +1522,12 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
     if ( conn_res == NULL ) {
       conn_res = ALLOC(conn_handle);
-      memset(conn_res, 0, sizeof(conn_handle));
+      memset(conn_res, '\0', sizeof(conn_handle));
     }
 
+    /* handle not active as of yet */
+    conn_res->handle_active = 0;
+
     /* We need to set this early, in case we get an error below,
       so we know how to free the connection */
     conn_res->flag_pconnect = isPersistent;
@@ -1469,7 +1541,12 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
       if (rc != SQL_SUCCESS) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->henv, SQL_HANDLE_ENV, rc, 1, NULL, -1, 1, 0 );
         ruby_xfree( handleAttr_args );
-        sprintf(error,"Allocation of environment handle failed:%s", conn_res->ruby_error_msg);
+        handleAttr_args = NULL;
+        if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Allocation of environment handle failed: "), conn_res->ruby_error_msg);
+        } else {
+          *error = rb_str_new2("Allocation of environment handle failed: <error message could not be retrieved>");
+        }
         return Qnil;
         break;
       }
@@ -1490,8 +1567,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
       if (rc != SQL_SUCCESS) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->henv, SQL_HANDLE_ENV, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error, "Setting of Environemnt Attribute during connection failed: %s",conn_res->ruby_error_msg);
+        if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Setting of Environemnt Attribute during connection failed: "),conn_res->ruby_error_msg);
+        } else {
+          *error = rb_str_new2("Setting of Environemnt Attribute during connection failed: <error message could not be retrieved>");
+        }
         ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
         _ruby_ibm_db_free_conn_struct( conn_res );
         return Qnil;
         break;
@@ -1503,8 +1586,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
       rc = SQLAllocHandle( SQL_HANDLE_DBC, conn_res->henv, &(conn_res->hdbc) );
       if (rc != SQL_SUCCESS) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->henv, SQL_HANDLE_ENV, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error, "Allocation of connection handle failed: %s",conn_res->ruby_error_msg);
+        if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Allocation of connection handle failed: "),conn_res->ruby_error_msg);
+        } else {
+          *error = rb_str_new2("Allocation of connection handle failed: <error message could not be retrieved>");
+        }
         ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
         _ruby_ibm_db_free_conn_struct( conn_res );
         return Qnil;
         break;
@@ -1554,14 +1643,14 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
     conn_res->errorType              =  1;
 
-    /* handle not active as of yet */
-    conn_res->handle_active = 0;
-
     /* Set Options */
     if ( !NIL_P(*options) ) {
       rc = _ruby_ibm_db_parse_options( *options, SQL_HANDLE_DBC, conn_res, error );
       if (rc != SQL_SUCCESS) {
         ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        rc = SQLFreeHandle(SQL_HANDLE_DBC, conn_res->hdbc );
+        rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
         _ruby_ibm_db_free_conn_struct( conn_res );
         return Qnil;
       }
@@ -1582,8 +1671,13 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
         SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
         SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
-        sprintf(error, "Connection failed: %s",conn_res->ruby_error_msg);
+        if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Connection failed: "),conn_res->ruby_error_msg);
+        } else {
+          *error = rb_str_new2("Connection failed: <error message could not be retrieved>");
+        }
         ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
         _ruby_ibm_db_free_conn_struct( conn_res );
         return Qnil;
         break;
@@ -1604,7 +1698,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
       server = ALLOC_N(char, 2048);
       memset(server, 0, sizeof(server));
 
-      getInfo_args = ALLOC_N(get_info_args,sizeof(struct _ibm_db_get_info_struct));
+      getInfo_args = ALLOC( get_info_args );
       memset(getInfo_args,'\0',sizeof(struct _ibm_db_get_info_struct));
 
       getInfo_args->conn_res     =  conn_res;
@@ -1624,6 +1718,10 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
       ruby_xfree( getInfo_args );
       ruby_xfree( server );
+      getInfo_args = NULL;
+      server       = NULL;
+
+      rc = SQL_SUCCESS; /*Setting rc to SQL_SUCCESS, because the below block may or may not be executed*/
 
     /* Set SQL_ATTR_REPLACE_QUOTED_LITERALS connection attribute to
      * enable CLI numeric literal feature. This is equivalent to
@@ -1634,7 +1732,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
      */
 #ifndef PASE
       /* Only enable this feature if we are not connected to an Informix data server */
-      if (!is_informix) {
+      if (!is_informix && data->literal_replacement == SET_QUOTED_LITERAL_REPLACEMENT_ON ) {
         handleAttr_args->handle      =  &( conn_res->hdbc );
         handleAttr_args->strLength   =  SQL_IS_INTEGER;
         handleAttr_args->attribute   =  SQL_ATTR_REPLACE_QUOTED_LITERALS;
@@ -1648,7 +1746,7 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
       }
 #else
       /* Only enable this feature if we are not connected to an Informix data server */
-      if (!is_informix) {
+      if (!is_informix && data->literal_replacement == SET_QUOTED_LITERAL_REPLACEMENT_ON ) {
         handleAttr_args->handle      =  &( conn_res->hdbc );
         handleAttr_args->strLength   =  SQL_IS_INTEGER;
         handleAttr_args->attribute   =  SQL_ATTR_REPLACE_QUOTED_LITERALS;
@@ -1682,15 +1780,18 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
       rb_hash_aset(persistent_list, rb_str_new2(hKey), entry);
     }
     ruby_xfree( hKey );
+    hKey = NULL;
   }
 
   if ( rc < SQL_SUCCESS ) {
     if (conn_res != NULL && conn_res->handle_active) {
       rc = SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc);
+      rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
     }
 
     /* free memory */
     if (conn_res != NULL) {
+      conn_res->handle_active = 0;
       _ruby_ibm_db_free_conn_struct(conn_res);
     }
 
@@ -1718,28 +1819,34 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
   connect_helper_args *helper_args  =  NULL;
 
   VALUE r_db, r_uid, r_passwd, options,return_value;
+  VALUE r_literal_replacement = Qnil;
 
-  char  error[DB2_MAX_ERR_MSG_LEN + 28];
+  VALUE error = Qnil;
 
-  rb_scan_args(argc, argv, "31", &r_db, &r_uid, &r_passwd, &options);
+  rb_scan_args(argc, argv, "32", &r_db, &r_uid, &r_passwd, &options, &r_literal_replacement );
 
-  memset( error,'\0',DB2_MAX_ERR_MSG_LEN + 28 );
   /* Allocate the mwmory for necessary components */
 
-  conn_args = ALLOC_N(connect_args, sizeof(struct _ibm_db_connect_args_struct));
+  conn_args = ALLOC( connect_args );
   memset(conn_args,'\0',sizeof(struct _ibm_db_connect_args_struct));
 
   conn_args->database   =  rb_str2cstr(r_db, &(conn_args->database_len));
   conn_args->uid        =  rb_str2cstr(r_uid, &(conn_args->uid_len));
   conn_args->password   =  rb_str2cstr(r_passwd, &(conn_args->password_len));
 
-  helper_args = ALLOC_N(connect_helper_args, sizeof(struct _ibm_db_connect_helper_args_struct));
+  helper_args = ALLOC( connect_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_connect_helper_args_struct));
 
-  helper_args->conn_args     =  conn_args;
-  helper_args->isPersistent  =  isPersistent;
-  helper_args->options       =  &options;
-  helper_args->error         =  error;
+  helper_args->conn_args              =  conn_args;
+  helper_args->isPersistent           =  isPersistent;
+  helper_args->options                =  &options;
+  helper_args->error                  =  &error;
+
+  if( !NIL_P(r_literal_replacement) ) {
+    helper_args->literal_replacement  =  NUM2INT(r_literal_replacement);
+  } else {
+    helper_args->literal_replacement  =  SET_QUOTED_LITERAL_REPLACEMENT_ON; /*QUOTED LITERAL replacemnt is ON by default*/
+  }
 
   /* Call the function where the actual logic is being run*/
   #ifdef GIL_RELEASE_VERSION
@@ -1751,7 +1858,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
 
   /* Free the memory allocated */
   if(conn_args != NULL) {
-    /* Memory to structure elements is not allocated explicitly hence it is automatically freed by Ruby 
+    /* Memory to structure elements of helper_args is not allocated explicitly hence it is automatically freed by Ruby.
        Dont try to explicitly free it, else a double free exception is thrown and the application will crash
        with memory dump.
     */
@@ -1766,7 +1873,7 @@ static VALUE _ruby_ibm_db_connect_helper( int argc, VALUE *argv, int isPersisten
   }
 
   if( return_value == Qnil ){
-    rb_throw( error, Qnil );
+    rb_throw( RSTRING_PTR(error), Qnil );
   }
   return return_value;
 }
@@ -1788,7 +1895,7 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
 
   SQLCHAR *stmt = (SQLCHAR *)"values current decfloat rounding mode";
 
-  exec_direct_args = ALLOC_N(exec_cum_prepare_args,sizeof(struct _ibm_db_exec_direct_args_struct));
+  exec_direct_args = ALLOC( exec_cum_prepare_args );
   memset(exec_direct_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
 
   exec_direct_args->stmt_string       =  stmt;
@@ -1799,15 +1906,15 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
 
   if ( rc == SQL_ERROR ) {
     if( conn_res->ruby_error_msg == NULL){
-      conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN );
+      conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN+1 );
     }
-    memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+    memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
     _ruby_ibm_db_check_sql_errors( conn_res , DB_CONN, (SQLHSTMT) rnd_mode->stmt_res->hstmt,
              SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
   } else {
 
-    bindCol_args = ALLOC_N(bind_col_args,sizeof(struct _ibm_db_bind_col_struct));
+    bindCol_args = ALLOC( bind_col_args );
     memset(bindCol_args,'\0',sizeof(struct _ibm_db_bind_col_struct));
 
     bindCol_args->stmt_res        =  rnd_mode->stmt_res;
@@ -1821,16 +1928,16 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
 
     if ( rc == SQL_ERROR ) {
       if( conn_res->ruby_error_msg == NULL){
-        conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN );
+        conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN+1 );
       }
-      memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+      memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, (SQLHSTMT)rnd_mode->stmt_res->hstmt,
                SQL_HANDLE_STMT, rc, 1, NULL ,-1, 1, 0);
 
     } else {
 
-      fetch_args = ALLOC_N(fetch_data_args,sizeof(struct _ibm_db_fetch_data_struct));
+      fetch_args = ALLOC( fetch_data_args );
       memset(fetch_args,'\0',sizeof(struct _ibm_db_fetch_data_struct));
 
       fetch_args->stmt_res = rnd_mode->stmt_res;
@@ -1839,9 +1946,9 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(_rounding_mode
 
       if ( rc == SQL_ERROR ) {
         if( conn_res->ruby_error_msg == NULL){
-          conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN );
+          conn_res->ruby_error_msg = ALLOC_N( char, DB2_MAX_ERR_MSG_LEN+1 );
         }
-        memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+        memset(conn_res->ruby_error_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, (SQLHSTMT) rnd_mode->stmt_res->hstmt,
                   SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
@@ -1892,7 +1999,7 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client( set_handle_attr_args
 
     SQLHANDLE hdbc = *(data->handle);
     
-    rnd_mode =  ALLOC_N(_rounding_mode,sizeof(struct _rounding_mode_struct));
+    rnd_mode =  ALLOC( _rounding_mode );
     memset(rnd_mode,'\0',sizeof(struct _rounding_mode_struct));
 
     stmt_res = _ibm_db_new_stmt_struct(conn_res);
@@ -1903,12 +2010,20 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client( set_handle_attr_args
     if (rc == SQL_ERROR) {
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, hdbc, SQL_HANDLE_DBC, rc, 1,
                 NULL, -1, 1, 0 );
+      ruby_xfree( rnd_mode );
+      ruby_xfree( stmt_res );
+      rnd_mode = NULL;
+      stmt_res = NULL;
       return rc;
     }
 
+    rnd_mode->stmt_res = stmt_res;
+
     _ruby_ibm_db_set_decfloat_rounding_mode_client_helper(rnd_mode, conn_res);
 
     _ruby_ibm_db_free_stmt_struct( rnd_mode->stmt_res );
+    rnd_mode->stmt_res = NULL;
+    stmt_res           = NULL;
 
     data->strLength   =  SQL_NTS;
     data->attribute   =  SQL_ATTR_DECFLOAT_ROUNDING_MODE;
@@ -1921,6 +2036,9 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client( set_handle_attr_args
 
     rc  =  _ruby_ibm_db_SQLSetConnectAttr_helper( data );
 
+    ruby_xfree( rnd_mode );
+    rnd_mode = NULL;
+
     return rc;
 }
 #endif
@@ -1933,8 +2051,8 @@ static int _ruby_ibm_db_set_decfloat_rounding_mode_client( set_handle_attr_args
 static void _ruby_ibm_db_clear_conn_err_cache()
 {
   /* Clear out the cached conn messages */
-  memset(IBM_DB_G(__ruby_conn_err_msg), 0, DB2_MAX_ERR_MSG_LEN);
-  memset(IBM_DB_G(__ruby_conn_err_state), 0, SQL_SQLSTATE_SIZE + 1);
+  memset(IBM_DB_G(__ruby_conn_err_msg), '\0', DB2_MAX_ERR_MSG_LEN);
+  memset(IBM_DB_G(__ruby_conn_err_state), '\0', SQL_SQLSTATE_SIZE + 1);
 }
 /*  */
 
@@ -1942,7 +2060,7 @@ static void _ruby_ibm_db_clear_conn_err_cache()
  *
  * ===Description
  *
- * resource IBM_DB.connect ( string database, string username, string password [, array options] )
+ * resource IBM_DB.connect ( string database, string username, string password [, array options, int set_replace_quoted_literal] )
  *
  * Creates a new connection to an IBM DB2 Universal Database, IBM Cloudscape, or Apache Derby database.
  * ==Parameters
@@ -1983,6 +2101,12 @@ static void _ruby_ibm_db_clear_conn_err_cache()
  *          Passing the SQL_CURSOR_KEYSET_DRIVEN value specifies a scrollable cursor for a statement resource.
  *          This mode enables random access to rows in a result set, but currently is supported
  *          only by IBM DB2 Universal Database. 
+ * ====<em>set_replace_quoted_literal</em>
+ *    This variable indicates if the CLI Connection attribute SQL_ATTR_REPLACE_QUOTED_LITERAL is to be set or not
+ *    To turn it ON pass  IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_ON
+ *    To turn it OFF pass IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_OFF
+ *
+ *    Default Setting: - IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_ON
  *
  * ==Return Values
  * Returns a connection handle resource if the connection attempt is successful.
@@ -2001,7 +2125,7 @@ VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self)
  * IBM_DB.pconnect --  Returns a persistent connection to a database
  * 
  * ===Description
- * resource IBM_DB.pconnect ( string database, string username, string password [, array options] )
+ * resource IBM_DB.pconnect ( string database, string username, string password [, array options, int set_replace_quoted_literal] )
  * 
  * Returns a persistent connection to an IBM DB2 Universal Database, IBM Cloudscape,
  * or Apache Derby database.
@@ -2039,6 +2163,12 @@ VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self)
  *         Passing the SQL_CURSOR_KEYSET_DRIVEN value specifies a scrollable cursor for a statement resource.
  *         This mode enables random access to rows in a result set, but currently is supported only
  *         by IBM DB2 Universal Database. 
+ * ====<em>set_replace_quoted_literal</em>
+ *    This variable indicates if the CLI Connection attribute SQL_ATTR_REPLACE_QUOTED_LITERAL is to be set or not
+ *    To turn it ON pass  IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_ON
+ *    To turn it OFF pass IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_OFF
+ *
+ *    Default Setting: - IBM_DB::SET_QUOTED_LITERAL_REPLACEMENT_ON
  * 
  * ===Return Values
  * 
@@ -2112,7 +2242,7 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
     if (argc == 2) {
       autocommit = FIX2INT(value);
       if(autocommit != (conn_res->auto_commit)) {
-        handleAttr_args = ALLOC_N(set_handle_attr_args,sizeof(struct _ibm_db_set_handle_attr_struct));
+        handleAttr_args = ALLOC( set_handle_attr_args );
         memset(handleAttr_args,'\0',sizeof(struct _ibm_db_set_handle_attr_struct));
 
         handleAttr_args->handle      =  &( conn_res->hdbc );
@@ -2166,7 +2296,7 @@ static void _ruby_ibm_db_add_param_cache( stmt_handle *stmt_res, int param_no, c
   if ( curr == NULL || curr->param_num != param_no ) {
     /* Allocate memory and make new node to be added */
     tmp_curr = ALLOC(param_node);
-    memset(tmp_curr, 0, sizeof(param_node));
+    memset(tmp_curr, '\0', sizeof(param_node));
 
     /* assign values */
     tmp_curr->data_type     =  data_type;
@@ -2177,6 +2307,8 @@ static void _ruby_ibm_db_add_param_cache( stmt_handle *stmt_res, int param_no, c
     tmp_curr->file_options  =  SQL_FILE_READ;
     tmp_curr->param_type    =  param_type;
     tmp_curr->size          =  size;
+    tmp_curr->varname       =  NULL;
+    tmp_curr->svalue        =  NULL;
 
     /* Set this flag in stmt_res if a FILE INPUT is present */
     if ( param_type == PARAM_FILE) {
@@ -2209,6 +2341,16 @@ static void _ruby_ibm_db_add_param_cache( stmt_handle *stmt_res, int param_no, c
     curr->param_type    =  param_type;
     curr->size          =  size;
 
+    if( curr->varname != NULL ) {
+      ruby_xfree( curr->varname );
+    }
+    curr->varname = NULL;
+
+    if( curr->svalue != NULL ) {
+      ruby_xfree( curr->svalue );
+    }
+    curr->svalue = NULL;
+
     /* Set this flag in stmt_res if a FILE INPUT is present */
     if ( param_type == PARAM_FILE) {
       stmt_res->file_param = 1;
@@ -2218,7 +2360,6 @@ static void _ruby_ibm_db_add_param_cache( stmt_handle *stmt_res, int param_no, c
     /* Var lengths can be variable and different in both cases. */
     /* This shouldn't happen often anyway */
     if ( varname != NULL) {
-      ruby_xfree( curr->varname );
       curr->varname = estrndup(varname, varname_len);
     }
   }
@@ -2233,7 +2374,6 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
   int   rc            =  0;
   VALUE return_value  =  Qtrue;
 
-  char  error[DB2_MAX_ERR_MSG_LEN + 13];
 
   /* Check for Param options */
   switch (argc) {
@@ -2250,8 +2390,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-        sprintf(error, "Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
-        rb_warn( error );
+        rb_warn("Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
         return_value = Qfalse;
         break;
       }
@@ -2272,8 +2411,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-        sprintf(error, "Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
-        rb_warn( error );
+        rb_warn("Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
         return_value = Qfalse;
         break;
       }
@@ -2294,8 +2432,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-        sprintf(error, "Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
-        rb_warn( error );
+        rb_warn("Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
         return_value = Qfalse;
         break;
       }
@@ -2317,8 +2454,7 @@ VALUE ibm_db_bind_param_helper(int argc, char * varname, long varname_len ,long
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-        sprintf(error, "Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
-        rb_warn( error );
+        rb_warn("Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
         return_value = Qfalse;
         break;
       }
@@ -2445,7 +2581,7 @@ VALUE ibm_db_bind_param(int argc, VALUE *argv, VALUE self)
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
 
-    desc_param_args = ALLOC_N(describeparam_args,sizeof(struct _ibm_db_describeparam_args_struct));
+    desc_param_args = ALLOC( describeparam_args );
     memset(desc_param_args,'\0',sizeof(struct _ibm_db_describeparam_args_struct));
 
     desc_param_args->param_no          =  NUM2INT(r_param_no);
@@ -2515,7 +2651,7 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
     if ( conn_res->handle_active && !conn_res->flag_pconnect ) {
       /* Disconnect from DB. If stmt is allocated, it is freed automatically */
       if (conn_res->auto_commit == 0) {
-        end_X_args = ALLOC_N(end_tran_args,sizeof(struct _ibm_db_end_tran_args_struct));
+        end_X_args = ALLOC( end_tran_args );
         memset(end_X_args,'\0',sizeof(struct _ibm_db_end_tran_args_struct));
 
         end_X_args->hdbc            =  &(conn_res->hdbc);
@@ -2561,6 +2697,8 @@ VALUE ibm_db_close(int argc, VALUE *argv, VALUE self)
 
           connection = Qnil;
 
+          rc = SQLFreeHandle(SQL_HANDLE_ENV, conn_res->henv );
+
           return_value = Qtrue;
         }
       }
@@ -2638,7 +2776,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "14", &connection, 
     &r_qualifier, &r_owner, &r_table_name, &r_column_name);
 
-  col_privileges_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_privileges_args = ALLOC( metadata_args );
   memset(col_privileges_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_privileges_args->qualifier    =  NULL;
@@ -2688,6 +2826,7 @@ VALUE ibm_db_column_privileges(int argc, VALUE *argv, VALUE self)
                       NULL, -1, 1, 1 );
 
             _ruby_ibm_db_free_stmt_struct( stmt_res );
+            stmt_res = NULL;
 
             return_value = Qfalse;
           } else {
@@ -2778,7 +2917,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "14", &connection, 
     &r_qualifier, &r_owner, &r_table_name, &r_column_name);
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -2798,6 +2937,8 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -2827,6 +2968,7 @@ VALUE ibm_db_columns(int argc, VALUE *argv, VALUE self)
                       NULL, -1, 1, 1 );
 
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
 
           return_value = Qfalse;
         } else {
@@ -2914,7 +3056,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "4", &connection, 
     &r_qualifier, &r_owner, &r_table_name);
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -2934,6 +3076,8 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -2961,6 +3105,7 @@ VALUE ibm_db_foreign_keys(int argc, VALUE *argv, VALUE self)
                     NULL, -1, 1, 1 );
 
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
 
           return_value = Qfalse;
         } else {
@@ -3039,7 +3184,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "4", &connection, 
     &r_qualifier, &r_owner, &r_table_name);
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -3059,6 +3204,8 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3085,6 +3232,7 @@ VALUE ibm_db_primary_keys(int argc, VALUE *argv, VALUE self)
                     NULL, -1, 1, 1 );
 
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
 
           return_value = Qfalse;
         } else {
@@ -3184,7 +3332,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "5", &connection, 
     &r_qualifier, &r_owner, &r_proc_name, &r_column_name);
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -3204,6 +3352,8 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3233,6 +3383,7 @@ VALUE ibm_db_procedure_columns(int argc, VALUE *argv, VALUE self)
                     NULL, -1, 1, 1 );
 
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
 
           return_value = Qfalse;
         } else {
@@ -3311,7 +3462,7 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "4", &connection, 
     &r_qualifier, &r_owner, &r_proc_name);
 
-  proc_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  proc_metadata_args = ALLOC( metadata_args );
   memset(proc_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   proc_metadata_args->qualifier  =  NULL;
@@ -3330,6 +3481,8 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3355,6 +3508,9 @@ VALUE ibm_db_procedures(int argc, VALUE *argv, VALUE self)
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, 
                     NULL, -1, 1, 1 );
 
+          _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
+
           return_value = Qfalse;
         } else {
           return_value = Data_Wrap_Struct(le_stmt_struct,
@@ -3449,7 +3605,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "5", &connection, &r_qualifier,
     &r_owner, &r_table_name, &r_scope);
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -3470,6 +3626,8 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3499,6 +3657,7 @@ VALUE ibm_db_special_columns(int argc, VALUE *argv, VALUE self)
                     NULL, -1, 1, 1 );
 
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
 
           return_value = Qfalse;
         } else {
@@ -3610,7 +3769,7 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
 
   metadata_args *col_metadata_args = NULL;
 
-  col_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  col_metadata_args = ALLOC( metadata_args );
   memset(col_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   col_metadata_args->qualifier    =  NULL;
@@ -3633,6 +3792,8 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) { 
@@ -3661,6 +3822,9 @@ VALUE ibm_db_statistics(int argc, VALUE *argv, VALUE self)
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, 
                     NULL, -1, 1, 1 );
 
+          _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
+
           return_value = Qfalse;
         } else {
           return_value = Data_Wrap_Struct(le_stmt_struct,
@@ -3741,7 +3905,7 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "13", &connection, &r_qualifier,
           &r_owner, &r_table_name);
 
-  table_privileges_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  table_privileges_args = ALLOC( metadata_args );
   memset(table_privileges_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   table_privileges_args->qualifier   =  NULL;
@@ -3760,6 +3924,8 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3786,6 +3952,9 @@ VALUE ibm_db_table_privileges(int argc, VALUE *argv, VALUE self)
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, 
                   NULL, -1, 1, 1 );
 
+          _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
+
           return_value = Qfalse;
         } else {
           return_value = Data_Wrap_Struct(le_stmt_struct,
@@ -3867,7 +4036,7 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "14", &connection, 
     &r_qualifier, &r_owner, &r_table_name, &r_table_type);
 
-  table_metadata_args = ALLOC_N(metadata_args,sizeof(struct _ibm_db_metadata_args_struct));
+  table_metadata_args = ALLOC( metadata_args );
   memset(table_metadata_args,'\0',sizeof(struct _ibm_db_metadata_args_struct));
 
   table_metadata_args->qualifier    =  NULL;
@@ -3888,6 +4057,8 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
       rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
       if (rc == SQL_ERROR) {
         _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+        ruby_xfree( stmt_res );
+        stmt_res = NULL;
         return_value = Qfalse;
       } else {
         if (!NIL_P(r_qualifier)) {
@@ -3917,6 +4088,9 @@ VALUE ibm_db_tables(int argc, VALUE *argv, VALUE self)
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, 
                     NULL, -1, 1, 1 );
 
+          _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
+
           return_value = Qfalse;
         } else {
           return_value = Data_Wrap_Struct(le_stmt_struct,
@@ -3977,7 +4151,7 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
       return Qfalse;
     }
 
-    end_X_args = ALLOC_N(end_tran_args,sizeof(struct _ibm_db_end_tran_args_struct));
+    end_X_args = ALLOC( end_tran_args );
     memset(end_X_args,'\0',sizeof(struct _ibm_db_end_tran_args_struct));
 
     end_X_args->hdbc            =  &(conn_res->hdbc);
@@ -4016,19 +4190,20 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
                                    VALUE options)
 {
   int   rc;
-  char  error[100];
+
+  VALUE  error         =  Qnil;
 
   exec_cum_prepare_args  *prepare_args  =  NULL;
 
   /* get the string and its length */
   if ( !NIL_P(stmt) ) {
-    prepare_args = ALLOC_N(exec_cum_prepare_args,sizeof(struct _ibm_db_exec_direct_args_struct));
+    prepare_args = ALLOC( exec_cum_prepare_args );
     memset(prepare_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
 
     prepare_args->stmt_string = (SQLCHAR*)rb_str2cstr(stmt, &(prepare_args->stmt_string_len));
   } else {
-    ruby_xfree( stmt_res );
     rb_warn("Supplied parameter is invalid");
+    stmt_res->is_freed = 1; /* At this point there is no handle allocated or resource used hence is_freed is set to 1*/
     return SQL_ERROR;
   }
 
@@ -4041,11 +4216,11 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
   } else {
 
     if ( !NIL_P(options) ) {
-      rc = _ruby_ibm_db_parse_options( options, SQL_HANDLE_STMT, stmt_res, error );
+      rc = _ruby_ibm_db_parse_options( options, SQL_HANDLE_STMT, stmt_res, &error );
       if ( rc == SQL_ERROR ) {
         ruby_xfree( prepare_args );
-        _ruby_ibm_db_free_stmt_struct( stmt_res );
-        rb_warn( error );
+        prepare_args = NULL;
+        rb_warn( RSTRING_PTR(error) );
         return rc;
       }
     }
@@ -4127,7 +4302,7 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
   exec_cum_prepare_args *exec_direct_args = NULL;
 
   int rc;
-  char error[100];
+  VALUE error = Qnil;
 
   /* This function basically is a wrap of the _ruby_ibm_db_do_prepare and _ruby_ibm_db_execute_stmt */
   /* After completing statement execution, it returns the statement resource */
@@ -4142,7 +4317,7 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
     }
 
     if (!NIL_P(stmt)) {
-      exec_direct_args = ALLOC_N(exec_cum_prepare_args,sizeof(struct _ibm_db_exec_direct_args_struct));
+      exec_direct_args = ALLOC( exec_cum_prepare_args );
       memset(exec_direct_args,'\0',sizeof(struct _ibm_db_exec_direct_args_struct));
 
       exec_direct_args->stmt_string = (SQLCHAR*)rb_str2cstr(stmt, &(exec_direct_args->stmt_string_len));
@@ -4161,15 +4336,19 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
     rc = SQLAllocHandle(SQL_HANDLE_STMT, conn_res->hdbc, &(stmt_res->hstmt));
     if ( rc < SQL_SUCCESS ) {
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
+      ruby_xfree( stmt_res );
+      stmt_res = NULL;
       return_value = Qfalse;
     } else {
 
       if (!NIL_P(options)) {
-        rc = _ruby_ibm_db_parse_options( options, SQL_HANDLE_STMT, stmt_res, error );
+        rc = _ruby_ibm_db_parse_options( options, SQL_HANDLE_STMT, stmt_res, &error );
         if ( rc == SQL_ERROR ) {
           _ruby_ibm_db_free_stmt_struct( stmt_res );
+          stmt_res = NULL;
           ruby_xfree( exec_direct_args );
-          rb_warn( error );
+          exec_direct_args = NULL;
+          rb_warn( RSTRING_PTR(error) );
           return Qfalse;
         }
       }
@@ -4189,6 +4368,7 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
                   SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
 
         _ruby_ibm_db_free_stmt_struct( stmt_res );
+        stmt_res = NULL;
 
         return_value = Qfalse;
       } else {
@@ -4229,10 +4409,8 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
  */
 VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
 {
-  VALUE stmt  =  Qnil;
-  int rc      =  0;
-
-  char error[DB2_MAX_ERR_MSG_LEN + 16];
+  VALUE stmt   =  Qnil;
+  int   rc     =  0;
 
   stmt_handle         *stmt_res       =  NULL;
   free_stmt_args      *freeStmt_args  =  NULL;
@@ -4242,7 +4420,7 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
     if ( stmt_res->hstmt ) {
-      freeStmt_args = ALLOC_N(free_stmt_args, sizeof( struct _ibm_db_free_stmt_struct ) );
+      freeStmt_args = ALLOC( free_stmt_args  );
       memset(freeStmt_args, '\0', sizeof( struct _ibm_db_free_stmt_struct ) );
 
       freeStmt_args->stmt_res  =  stmt_res;
@@ -4256,15 +4434,15 @@ VALUE ibm_db_free_result(int argc, VALUE *argv, VALUE self)
       #endif
 
       ruby_xfree( freeStmt_args );
+      freeStmt_args = NULL;
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-        sprintf(error, "Statement Free Failed: %s", stmt_res->ruby_stmt_err_msg);
-        rb_warn( error );
+        rb_warn( "Statement Free Failed: %s", stmt_res->ruby_stmt_err_msg);
         return Qfalse;
       }
     }
-    _ruby_ibm_db_free_result_struct(stmt_res);
+    _ruby_ibm_db_free_result_struct( stmt_res );
   } else {
     rb_warn("Supplied parameter is invalid");
     return Qfalse;
@@ -4331,7 +4509,6 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
   stmt_handle *stmt_res;
 
   int rc;
-  char error[DB2_MAX_ERR_MSG_LEN + 16];
 
   rb_scan_args(argc, argv, "21", &connection, &stmt, &options);
 
@@ -4357,9 +4534,9 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
 
     if ( rc < SQL_SUCCESS ) {
       _ruby_ibm_db_free_stmt_struct(stmt_res);
+      stmt_res = NULL;
 
-      sprintf(error, "Statement Prepare Failed: %s", conn_res->ruby_error_msg);
-      rb_warn( error );
+      rb_warn("Statement Prepare Failed: %s", conn_res->ruby_error_msg);
 
       return_value = Qfalse;
     } else {
@@ -4381,7 +4558,7 @@ static param_node* build_list( stmt_handle *stmt_res, int param_no, SQLSMALLINT
 
   /* Allocate memory and make new node to be added */
   tmp_curr = ALLOC(param_node);
-  memset(tmp_curr,0,sizeof(param_node));
+  memset(tmp_curr,'\0',sizeof(param_node));
   /* assign values */
   tmp_curr->data_type    =  data_type;
   tmp_curr->param_size   =  precision;
@@ -4390,6 +4567,8 @@ static param_node* build_list( stmt_handle *stmt_res, int param_no, SQLSMALLINT
   tmp_curr->param_num    =  param_no;
   tmp_curr->file_options =  SQL_FILE_READ;
   tmp_curr->param_type   =  SQL_PARAM_INPUT;
+  tmp_curr->varname      =  NULL;
+  tmp_curr->svalue       =  NULL;
 
   while ( curr != NULL ) {
     prev = curr;
@@ -4417,12 +4596,13 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
   int origlen       = 0;
   int is_known_type = 1;
 
+  SQLCHAR     *tmp_str;
   SQLSMALLINT valueType;
   SQLPOINTER  paramValuePtr;
 
   bind_parameter_args  *bindParameter_args = NULL;
 
-  bindParameter_args =  ALLOC_N(bind_parameter_args,sizeof(struct _ibm_db_bind_parameter_struct));
+  bindParameter_args =  ALLOC( bind_parameter_args );
   memset(bindParameter_args,'\0',sizeof(struct _ibm_db_bind_parameter_struct));
 
   bindParameter_args->stmt_res       =  stmt_res;
@@ -4434,7 +4614,11 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
 
   switch(TYPE(*bind_data)) {
     case T_BIGNUM:
-      curr->svalue = rb_str2cstr( rb_big2str(*bind_data,10), &curr->ivalue );
+      tmp_str = (SQLCHAR *) rb_str2cstr( rb_big2str(*bind_data,10), (long*)&curr->ivalue );
+
+      curr->svalue = (SQLCHAR *) ALLOC_N(char, curr->ivalue+1);
+      memset(curr->svalue, '\0', curr->ivalue+1);
+      memcpy(curr->svalue, tmp_str, curr->ivalue);
 
       bindParameter_args->valueType    =  SQL_C_CHAR;
       bindParameter_args->paramValPtr  =  curr->svalue;
@@ -4450,7 +4634,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
       if(curr->data_type == SQL_BIGINT) {
         valueType = SQL_C_DEFAULT;
       } else {
-        valueType = SQL_C_LONG;
+        valueType = SQL_C_SBIGINT;
       }
 
       bindParameter_args->valueType    =  valueType;
@@ -4467,7 +4651,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
     case T_FALSE:
       curr->ivalue = 0;
 
-      bindParameter_args->valueType    =  SQL_C_LONG;
+      bindParameter_args->valueType    =  SQL_C_SBIGINT;
       bindParameter_args->paramValPtr  =  &curr->ivalue;
       bindParameter_args->buff_length  =  0;
       bindParameter_args->out_length   =  NULL;
@@ -4480,7 +4664,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
     case T_TRUE:
       curr->ivalue = 1;
 
-      bindParameter_args->valueType    =  SQL_C_LONG;
+      bindParameter_args->valueType    =  SQL_C_SBIGINT;
       bindParameter_args->paramValPtr  =  &curr->ivalue;
       bindParameter_args->buff_length  =  0;
       bindParameter_args->out_length   =  NULL;
@@ -4504,7 +4688,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
       break;
 
     case T_STRING:
-      curr->svalue = rb_str2cstr( *bind_data, &curr->ivalue );
+      tmp_str = (SQLCHAR *) rb_str2cstr( *bind_data, (long*) &curr->ivalue );
       origlen = curr->ivalue;
       /*
        * An extra parameter is given by the client to pick the size of the string
@@ -4520,11 +4704,15 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
             curr->ivalue = curr->param_size;
           }
         }
-        curr->svalue = memcpy(ALLOC_N(char, curr->ivalue+1), curr->svalue, origlen);
+        curr->svalue = (SQLCHAR *) ALLOC_N(char, curr->ivalue+1);
+        memset(curr->svalue, '\0', origlen);
+        memcpy(curr->svalue, tmp_str, origlen);
         curr->svalue[origlen] = '\0';
       }
       else { 
-        curr->svalue = memcpy(ALLOC_N(char, curr->ivalue+1), curr->svalue, curr->ivalue);
+        curr->svalue = (SQLCHAR *) ALLOC_N(char, curr->ivalue+1);
+        memset(curr->svalue, '\0', origlen);
+        memcpy(curr->svalue, tmp_str, curr->ivalue);
         curr->svalue[curr->ivalue] = '\0'; 
       }
 
@@ -4639,7 +4827,7 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
       return SQL_ERROR;
     }
     curr->bind_indicator  =  0;
-    curr->svalue          =  rb_str2cstr(*bind_data, &curr->ivalue);
+    curr->svalue          =  (SQLCHAR *) rb_str2cstr(*bind_data, (long*) &curr->ivalue);
 
     /* Bind file name string */
     rc = _ruby_ibm_db_SQLBindFileToParam_helper(stmt_res, curr);
@@ -4656,9 +4844,9 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
   return rc;
 }
 /*
-  static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res)
+  static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, VALUE *error)
 */
-static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, char *error ) {
+static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, VALUE *error ) {
   int rc;
   VALUE bind_data;          /* Data value from symbol table */
   param_node *curr = NULL;  /* To traverse the list */
@@ -4674,7 +4862,11 @@ static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, char *error ) {
     rc  = _ruby_ibm_db_bind_data( stmt_res, curr, &bind_data);
 
     if ( rc == SQL_ERROR ) {
-      sprintf(error, "Binding Error 1: %s", stmt_res->ruby_stmt_err_msg );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+        *error = rb_str_cat2(rb_str_new2("Binding Error 1: "), stmt_res->ruby_stmt_err_msg );
+      } else {
+        *error = rb_str_new2("Binding Error 1: <error message could not be retrieved>");
+      }
       return rc;
     }
     curr = curr->next;
@@ -4684,10 +4876,10 @@ static int _ruby_ibm_db_bind_param_list(stmt_handle *stmt_res, char *error ) {
 }
 /*  */
 
-/*  static int _ruby_ibm_db_execute_helper2(stmt_res, data, int bind_cmp_list, int bind_params, char *error )
+/*  static int _ruby_ibm_db_execute_helper2(stmt_res, data, int bind_cmp_list, int bind_params, VALUE *error )
   */
 static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int bind_cmp_list, 
-                                        int bind_params, char *error )
+                                        int bind_params, VALUE *error )
 {
   int rc            =  SQL_SUCCESS;
   param_node *curr  =  NULL;  /* To traverse the list */
@@ -4714,7 +4906,7 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
           parameter and then bind it.
         */
 
-        desc_param_args = ALLOC_N(describeparam_args,sizeof(struct _ibm_db_describeparam_args_struct));
+        desc_param_args = ALLOC( describeparam_args );
         memset(desc_param_args,'\0',sizeof(struct _ibm_db_describeparam_args_struct));
 
         desc_param_args->param_no          =  ++stmt_res->num_params;
@@ -4729,7 +4921,11 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
 
         if ( rc == SQL_ERROR ) {
           _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-          sprintf(error, "Describe Param Failed: %s", stmt_res->ruby_stmt_err_msg );
+          if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+            *error = rb_str_cat2(rb_str_new2("Describe Param Failed: "), stmt_res->ruby_stmt_err_msg );
+          } else {
+            *error = rb_str_new2("Describe Param Failed: <error message could not be retrieved>");
+          }
 
           if(desc_param_args != NULL) {
             ruby_xfree( desc_param_args );
@@ -4750,7 +4946,11 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
         rc = _ruby_ibm_db_bind_data( stmt_res, curr, data );
 
         if ( rc == SQL_ERROR ) {
-          sprintf(error, "Binding Error 2: %s", stmt_res->ruby_stmt_err_msg );
+          if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+            *error = rb_str_cat2(rb_str_new2("Binding Error 2: "), stmt_res->ruby_stmt_err_msg );
+          } else {
+            *error = rb_str_new2("Binding Error 2: <error message could not be retrieved>");
+          }
           return rc;
         }
       } else {
@@ -4765,7 +4965,11 @@ static int _ruby_ibm_db_execute_helper2(stmt_handle *stmt_res, VALUE *data, int
           rc  =  _ruby_ibm_db_bind_data( stmt_res, curr, data);
 
           if ( rc == SQL_ERROR ) {
-            sprintf(error, "Binding Error 2: %s", stmt_res->ruby_stmt_err_msg );
+            if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+              *error = rb_str_cat2(rb_str_new2("Binding Error 2: "), stmt_res->ruby_stmt_err_msg );
+            } else {
+              *error = rb_str_new2("Binding Error 2: <error message could not be retrieved>");
+            }
             return rc;
           }
           stmt_res->current_node  =  curr->next;
@@ -4798,13 +5002,14 @@ void var_assign(char *name, VALUE value) {
   strcat(statement, expr);
   rb_eval_string( statement );
   ruby_xfree( statement );
+  statement = NULL;
 #endif
 }
 
 /* 
-  static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array)
+  static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array, VALUE *error)
 */
-static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array, char *error ) {
+static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array, VALUE *error ) {
   int rc, numOpts, i = 0;
 
   VALUE data;
@@ -4817,13 +5022,11 @@ static VALUE _ruby_ibm_db_desc_and_bind_param_list(stmt_bind_array *bind_array,
 
   if (numOpts > bind_array->num) {
     /* More are passed in -- Warning - Use the max number present */
-    sprintf(error, "%d params bound not matching %d required", numOpts, bind_array->num);
-    rb_warn(error);
-    memset( error, '\0', DB2_MAX_ERR_MSG_LEN + 23 );
+    rb_warn("Number of params passed in are more than bound parameters");
     numOpts = bind_array->num;
   } else if (numOpts < bind_array->num) {
     /* If there are less params passed in, than are present -- Error */
-    sprintf(error, "%d params bound not matching %d required", numOpts, bind_array->num);
+    *error = rb_str_new2("Number of params passed in are less than bound parameters");
     return Qnil;
   }
 
@@ -4852,7 +5055,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
   VALUE        ret_value = Qtrue;
   stmt_handle  *stmt_res = NULL;
 
-  char         *error    = NULL;
+  VALUE *error;
   int rc = 0;
 
   SQLSMALLINT              num                       =  0;
@@ -4865,7 +5068,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
 
   /* Free any cursors that might have been allocated in a previous call to SQLExecute */
 
-  freeStmt_args = ALLOC_N(free_stmt_args, sizeof( struct _ibm_db_free_stmt_struct ) );
+  freeStmt_args = ALLOC( free_stmt_args );
   memset(freeStmt_args, '\0', sizeof( struct _ibm_db_free_stmt_struct ) );
 
   freeStmt_args->stmt_res  =  stmt_res;
@@ -4874,8 +5077,9 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
   _ruby_ibm_db_SQLFreeStmt_helper( freeStmt_args );
 
   ruby_xfree( freeStmt_args );
+  freeStmt_args = NULL;
 
-  num_params_args = ALLOC_N(row_col_count_args,sizeof(struct _ibm_db_row_col_count_struct));
+  num_params_args = ALLOC( row_col_count_args );
   memset(num_params_args,'\0',sizeof(struct _ibm_db_row_col_count_struct));
 
   num_params_args->stmt_res  =  stmt_res;
@@ -4886,13 +5090,19 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
     ruby_xfree( num_params_args );
-    sprintf(error, "Execute Failed due to: %s", stmt_res->ruby_stmt_err_msg );
+    num_params_args = NULL;
+    if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+      *error = rb_str_cat2(rb_str_new2("Execute Failed due to: "), stmt_res->ruby_stmt_err_msg );
+    } else {
+      *error = rb_str_new2("Execute Failed due to: <error message could not be retrieved>");
+    }
     return Qnil;
   }
 
   num  =  num_params_args->count;
 
   ruby_xfree( num_params_args );
+  num_params_args = NULL;
 
   if ( num != 0 ) {
 
@@ -4903,7 +5113,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
       /* Make sure IBM_DB.bind_param has been called */
       /* If the param list is NULL -- ERROR */
       if (TYPE( *(bind_array->parameters_array) ) != T_ARRAY) {
-        sprintf(error, "Param is not an array");
+        *error = rb_str_new2("Param is not an array");
         return Qnil;
       }
 
@@ -4913,7 +5123,7 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
         return Qnil;
       }
       if(ret_value == Qfalse) {
-          return Qfalse;
+        return Qfalse;
       }
 
     } else {
@@ -4921,17 +5131,17 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
       /* No additional params passed in. Use values already bound. */
       if ( num > stmt_res->num_params ) {
         /* More parameters than we expected */
-        sprintf(error, "%d params bound not matching %d required", stmt_res->num_params, num);
+        *error = rb_str_new2("Number of params passed are more than bound parameters");
         return Qnil;
       } else if ( num < stmt_res->num_params ) {
         /* Fewer parameters than we expected */
-        sprintf(error, "%d params bound not matching %d required", stmt_res->num_params, num);
+        *error = rb_str_new2("Number of params passed are less than bound parameters");
         return Qnil;
       }
 
       /* Param cache node list is empty -- No params bound */
       if ( stmt_res->head_cache_list == NULL ) {
-        sprintf(error, "Parameters not bound");
+        *error = rb_str_new2("Parameters not bound");
         return Qnil;
       } else {
         /* The 1 denotes that you work with the whole list */
@@ -4951,13 +5161,17 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-    sprintf(error, "Statement Execute Failed: %s", stmt_res->ruby_stmt_err_msg );
+    if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+      *error = rb_str_cat2(rb_str_new2("Statement Execute Failed: "), stmt_res->ruby_stmt_err_msg );
+    } else {
+      *error = rb_str_new2("Statement Execute Failed: <error message could not be retrieved>");
+    }
     return Qnil;
   }
 
   if ( rc == SQL_NEED_DATA ) {
 
-    put_param_data_args = ALLOC_N(param_cum_put_data_args,sizeof(struct _ibm_db_param_and_put_data_struct));
+    put_param_data_args = ALLOC( param_cum_put_data_args );
     memset(put_param_data_args,'\0',sizeof(struct _ibm_db_param_and_put_data_struct));
 
     put_param_data_args->stmt_res  =  stmt_res;
@@ -4969,7 +5183,11 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
 
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-        sprintf(error, "Sending data failed: %s", stmt_res->ruby_stmt_err_msg );
+        if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+          *error = rb_str_cat2(rb_str_new2("Sending data failed: "), stmt_res->ruby_stmt_err_msg );
+        } else {
+          *error = rb_str_new2("Sending data failed: <error message could not be retrieved>");
+        }
 
         if (put_param_data_args != NULL) {
           ruby_xfree( put_param_data_args );
@@ -5022,7 +5240,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
   /* This is used to loop over the param cache */
   param_node *tmp_curr, *prev_ptr, *curr_ptr;
 
-  char error[DB2_MAX_ERR_MSG_LEN + 23];
+  VALUE error = Qnil;
 
   rb_scan_args(argc, argv, "11", &stmt, &parameters_array);
 
@@ -5039,14 +5257,14 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
     /* This ensures that each call to IBM_DB.execute start from scratch */
     stmt_res->current_node = stmt_res->head_cache_list;
 
-    bind_array = ALLOC_N(stmt_bind_array,sizeof(struct _stmt_bind_data_array));
+    bind_array = ALLOC( stmt_bind_array );
     memset(bind_array,'\0',sizeof(struct _stmt_bind_data_array));
 
     bind_array->parameters_array  =  &parameters_array;
     bind_array->stmt_res          =  stmt_res;
     bind_array->bind_params       =  0;
     bind_array->num               =  0;
-    bind_array->error             =  error;
+    bind_array->error             =  &error;
 
     #ifdef GIL_RELEASE_VERSION
       ret_value = rb_thread_blocking_region( (void *)_ruby_ibm_db_execute_helper, bind_array,
@@ -5056,8 +5274,9 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
     #endif
 
     if( ret_value == Qnil || ret_value == Qfalse ) {
-      rb_warn( error, Qnil );
+      rb_warn( RSTRING_PTR(error) );
       ruby_xfree( bind_array );
+      bind_array = NULL;
       return Qfalse;
     }
 
@@ -5071,8 +5290,14 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
         curr_ptr = curr_ptr->next;
 
         /* Free Values */
-        if ( prev_ptr->svalue) {
+        if ( prev_ptr->svalue != NULL ) {
           ruby_xfree( prev_ptr->svalue );
+          prev_ptr->svalue = NULL;
+        }
+
+        if ( prev_ptr->varname != NULL ) {
+          ruby_xfree( prev_ptr->varname );
+          prev_ptr->varname = NULL;
         }
 
         ruby_xfree( prev_ptr );
@@ -5082,6 +5307,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
 
       stmt_res->head_cache_list =  NULL;
       stmt_res->num_params      =  0;
+      stmt_res->current_node    =  NULL;
     } else {
       /* Bind the IN/OUT Params back into the active symbol table */
       tmp_curr = stmt_res->head_cache_list;
@@ -5105,7 +5331,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
                   var_assign(tmp_curr->varname, rb_float_new(tmp_curr->fvalue));
                   break;
                 default:
-                  var_assign(tmp_curr->varname, rb_str_new2(tmp_curr->svalue));
+                  var_assign(tmp_curr->varname, rb_str_new2((char *)tmp_curr->svalue));
                   break;
               }
 
@@ -5162,6 +5388,7 @@ VALUE ibm_db_execute(int argc, VALUE *argv, VALUE self)
 VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
 {
   VALUE       connection  = Qnil;
+  VALUE       ret_val     = Qnil;
   conn_handle *conn_res   = NULL;
   char        *return_str = NULL;  /* This variable is used by _ruby_ibm_db_check_sql_errors to return err strings */
 
@@ -5177,8 +5404,8 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
       return Qnil;
     }
 
-    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-    memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+    memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
     _ruby_ibm_db_check_sql_errors(conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, -1, 0, return_str, DB_ERRMSG, conn_res->errormsg_recno_tracker, 1 );
 
@@ -5187,7 +5414,10 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
 
     conn_res->errormsg_recno_tracker++;
 
-    return rb_str_new2(return_str);
+    ret_val  =  rb_str_new2(return_str);
+    ruby_xfree( return_str );
+
+    return ret_val;
   } else {
     return rb_str_new2(IBM_DB_G(__ruby_conn_err_msg));
   }
@@ -5219,6 +5449,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
 VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
 {
   VALUE        stmt        =  Qnil;
+  VALUE        ret_val     =  Qnil;
   stmt_handle  *stmt_res   =  NULL;
   char         *return_str =  NULL; /* This variable is used by _ruby_ibm_db_check_sql_errors to return err strings */
 
@@ -5229,8 +5460,8 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
 
-    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-    memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+    memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
     _ruby_ibm_db_check_sql_errors(stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, -1, 0, 
              return_str, DB_ERRMSG, stmt_res->errormsg_recno_tracker, 1);
@@ -5240,7 +5471,10 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
 
     stmt_res->errormsg_recno_tracker++;
 
-    return rb_str_new2(return_str);
+    ret_val  =  rb_str_new2(return_str);
+    ruby_xfree( return_str );
+
+    return ret_val;
   } else {
     return rb_str_new2(IBM_DB_G(__ruby_stmt_err_msg));
   }
@@ -5280,6 +5514,7 @@ VALUE ibm_db_stmt_errormsg(int argc, VALUE *argv, VALUE self)
 VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
 {
   VALUE         connection = Qnil;
+  VALUE         ret_val    = Qnil;
   conn_handle   *conn_res  = NULL;
 
   char *return_str = NULL; /* This variable is used by _ruby_ibm_db_check_sql_errors to return err strings */
@@ -5297,7 +5532,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
     }
 
     return_str = ALLOC_N(char, SQL_SQLSTATE_SIZE + 1);
-    memset(return_str, 0, SQL_SQLSTATE_SIZE + 1);
+    memset(return_str, '\0', SQL_SQLSTATE_SIZE + 1);
 
     _ruby_ibm_db_check_sql_errors(conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, -1, 0, 
               return_str, DB_ERR_STATE, conn_res->error_recno_tracker, 1);
@@ -5308,7 +5543,10 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
 
     conn_res->error_recno_tracker++;
 
-    return rb_str_new2(return_str);
+    ret_val = rb_str_new2(return_str);
+    ruby_xfree( return_str );
+
+    return ret_val;
   } else {
     return rb_str_new2(IBM_DB_G(__ruby_conn_err_state));
   }
@@ -5342,6 +5580,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
 VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
 {
   VALUE       stmt         =  Qnil;
+  VALUE       ret_val      =  Qnil;
   stmt_handle *stmt_res    =  NULL;
   char        *return_str  =  NULL; /* This variable is used by _ruby_ibm_db_check_sql_errors to return err strings */
 
@@ -5352,8 +5591,8 @@ VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
 
-    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-    memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+    memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
     _ruby_ibm_db_check_sql_errors(stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, -1, 0, 
                  return_str, DB_ERR_STATE, stmt_res->error_recno_tracker, 1 );
@@ -5364,7 +5603,10 @@ VALUE ibm_db_stmt_error(int argc, VALUE *argv, VALUE self)
 
     stmt_res->error_recno_tracker++;
 
-    return rb_str_new2(return_str);
+    ret_val = rb_str_new2(return_str);
+    ruby_xfree( return_str );
+
+    return ret_val;
   } else {
     return rb_str_new2(IBM_DB_G(__ruby_stmt_err_state));
   }
@@ -5435,8 +5677,8 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
           return_value  =  rb_str_new2( conn_res->ruby_error_msg );
         } else {
 
-          return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-          memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+          return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+          memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
           _ruby_ibm_db_check_sql_errors(conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, -1, 0, return_str, 
                        DB_ERRMSG, conn_res->errormsg_recno_tracker, 1 );
@@ -5446,6 +5688,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
           }
 
           return_value = rb_str_new2(return_str);
+          ruby_xfree( return_str );
         }
         conn_res->errormsg_recno_tracker++;
       }
@@ -5455,8 +5698,8 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
       if( stmt_res->errormsg_recno_tracker == 1 && stmt_res->ruby_stmt_err_msg != NULL ) {
         return_value  =  rb_str_new2( stmt_res->ruby_stmt_err_msg );
       } else {
-        return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-        memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+        return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+        memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
         _ruby_ibm_db_check_sql_errors(stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, -1, 0, 
                       return_str, DB_ERRMSG, stmt_res->errormsg_recno_tracker, 1);
@@ -5466,6 +5709,7 @@ VALUE ibm_db_getErrormsg(int argc, VALUE *argv, VALUE self)
         }
 
         return_value = rb_str_new2(return_str);
+        ruby_xfree( return_str );
       }
       stmt_res->errormsg_recno_tracker++;
     } /*End of Resource Type check */
@@ -5545,8 +5789,8 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
           return_value  =  rb_str_new2( conn_res->ruby_error_state );
         } else {
 
-          return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-          memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+          return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+          memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
           _ruby_ibm_db_check_sql_errors(conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, -1, 0, return_str, 
                        DB_ERRMSG, conn_res->error_recno_tracker, 1 );
@@ -5556,6 +5800,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
           }
 
           return_value = rb_str_new2(return_str);
+          ruby_xfree( return_str );
         }
         conn_res->error_recno_tracker++;
       }
@@ -5565,8 +5810,8 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
       if( stmt_res->error_recno_tracker == 1 && stmt_res->ruby_stmt_err_state != NULL ) {
         return_value  =  rb_str_new2( stmt_res->ruby_stmt_err_state );
       } else {
-        return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
-        memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
+        return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1);
+        memset(return_str, '\0', DB2_MAX_ERR_MSG_LEN+1);
 
         _ruby_ibm_db_check_sql_errors(stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, -1, 0, 
                       return_str, DB_ERRMSG, stmt_res->error_recno_tracker, 1);
@@ -5576,6 +5821,7 @@ VALUE ibm_db_getErrorstate(int argc, VALUE *argv, VALUE self)
         }
 
         return_value = rb_str_new2(return_str);
+        ruby_xfree( return_str );
       }
       stmt_res->error_recno_tracker++;
     } /*End of Resource Type check */
@@ -5630,9 +5876,9 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
 
     if ( rc < SQL_SUCCESS ) {
       if ( stmt_res->ruby_stmt_err_msg == NULL ) {
-        stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN );
+        stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1 );
       }
-      memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+      memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
       _ruby_ibm_db_check_sql_errors( stmt_res , DB_STMT, stmt_res->hdbc, SQL_HANDLE_DBC, rc, 0, 
                 stmt_res->ruby_stmt_err_msg, 1, 1, 1 );
@@ -5640,7 +5886,7 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
       ret_value = Qfalse;
     } else {
 
-      nextresultparams = ALLOC_N(next_result_args,sizeof(struct _ibm_db_next_result_args_struct));
+      nextresultparams = ALLOC( next_result_args );
       memset(nextresultparams,'\0',sizeof(struct _ibm_db_next_result_args_struct));
 
       nextresultparams->stmt_res  =  stmt_res;
@@ -5666,7 +5912,7 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
         /* Initialize stmt resource members with default values. */
         /* Parsing will update options if needed */
         new_stmt_res = ALLOC(stmt_handle);
-        memset(new_stmt_res, 0, sizeof(stmt_handle));
+        memset(new_stmt_res, '\0', sizeof(stmt_handle));
 
         new_stmt_res->s_bin_mode      =  stmt_res->s_bin_mode;
         new_stmt_res->cursor_type     =  stmt_res->cursor_type;
@@ -5680,6 +5926,7 @@ VALUE ibm_db_next_result(int argc, VALUE *argv, VALUE self)
         new_stmt_res->row_data        =  NULL;
         new_stmt_res->hstmt           =  new_hstmt;
         new_stmt_res->hdbc            =  stmt_res->hdbc;
+        new_stmt_res->is_freed        =  0;
 
         ret_value = Data_Wrap_Struct(le_stmt_struct,
             _ruby_ibm_db_mark_stmt_struct, _ruby_ibm_db_free_stmt_struct,
@@ -5729,14 +5976,12 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
 
   row_col_count_args *result_cols_args = NULL;
 
-  char error[DB2_MAX_ERR_MSG_LEN + 15];
-
   rb_scan_args(argc, argv, "1", &stmt);
 
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
 
-    result_cols_args = ALLOC_N(row_col_count_args,sizeof(struct _ibm_db_row_col_count_struct));
+    result_cols_args = ALLOC( row_col_count_args );
     memset(result_cols_args,'\0',sizeof(struct _ibm_db_row_col_count_struct));
 
     result_cols_args->stmt_res  =  stmt_res;
@@ -5751,9 +5996,7 @@ VALUE ibm_db_num_fields(int argc, VALUE *argv, VALUE self)
 
     if ( rc == SQL_ERROR ) {
       _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-      sprintf(error, "Failed to retrieve the number of fields: %s", stmt_res->ruby_stmt_err_msg );
-
-      rb_warn( error );
+      rb_warn("Failed to retrieve the number of fields: %s", stmt_res->ruby_stmt_err_msg );
       ret_val = Qfalse;
     } else {
       ret_val = INT2NUM(result_cols_args->count);
@@ -5813,17 +6056,15 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
   stmt_handle *stmt_res;
   int rc = 0;
 
-  row_col_count_args *row_count_args = NULL;
-
-  char error[DB2_MAX_ERR_MSG_LEN + 10 ];
+  sql_row_count_args *row_count_args = NULL;
 
   rb_scan_args(argc, argv, "1", &stmt);
 
   if (!NIL_P(stmt)) {
     Data_Get_Struct(stmt, stmt_handle, stmt_res);
 
-    row_count_args = ALLOC_N(row_col_count_args,sizeof(struct _ibm_db_row_col_count_struct));
-    memset(row_count_args,'\0',sizeof(struct _ibm_db_row_col_count_struct));
+    row_count_args = ALLOC( sql_row_count_args );
+    memset(row_count_args,'\0',sizeof(struct _ibm_db_row_count_struct));
 
     row_count_args->stmt_res  =  stmt_res;
     row_count_args->count     =  0;
@@ -5837,9 +6078,7 @@ VALUE ibm_db_num_rows(int argc, VALUE *argv, VALUE self)
 
     if ( rc == SQL_ERROR ) {
       _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
-      sprintf(error, "Retrieval of number of rows failed: %s", stmt_res->ruby_stmt_err_msg );
-
-      rb_warn( error );
+      rb_warn("Retrieval of number of rows failed: %s", stmt_res->ruby_stmt_err_msg );
       ret_val = Qfalse;
     } else {
       ret_val = INT2NUM( row_count_args->count );
@@ -6011,7 +6250,7 @@ VALUE ibm_db_field_display_size(int argc, VALUE *argv, VALUE self)
     ret_val = Qfalse;
   } else {
 
-    colattr_args = ALLOC_N( col_attr_args,sizeof(struct _ibm_db_col_attr_struct) );
+    colattr_args = ALLOC( col_attr_args );
     memset( colattr_args,'\0',sizeof(struct _ibm_db_col_attr_struct) );
 
     colattr_args->stmt_res        =  stmt_res;
@@ -6357,7 +6596,7 @@ VALUE ibm_db_field_width(int argc, VALUE *argv, VALUE self)
     ret_val = Qfalse;
   } else {
 
-    colattr_args = ALLOC_N( col_attr_args,sizeof(struct _ibm_db_col_attr_struct) );
+    colattr_args = ALLOC( col_attr_args );
     memset( colattr_args,'\0',sizeof(struct _ibm_db_col_attr_struct) );
 
     colattr_args->stmt_res         =  stmt_res;
@@ -6464,7 +6703,7 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
       return Qfalse;
     }
 
-    end_X_args = ALLOC_N(end_tran_args,sizeof(struct _ibm_db_end_tran_args_struct));
+    end_X_args = ALLOC( end_tran_args );
     memset(end_X_args,'\0',sizeof(struct _ibm_db_end_tran_args_struct));
 
     end_X_args->hdbc            =  &(conn_res->hdbc);
@@ -6497,7 +6736,7 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
 /*  */
 
 /*  
- * IBM_DB.free_stmt --  Frees resources associated with the indicated statement resource
+ * IBM_DB.free_stmt --  Frees the indicated statement handle and any resources associated with it
  * 
  * ===Description
  * bool IBM_DB.free_stmt ( resource stmt )
@@ -6514,10 +6753,22 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
  * 
  * Returns TRUE on success or FALSE on failure. 
  *
- * ===DEPRECATED
  */
 VALUE ibm_db_free_stmt(int argc, VALUE *argv, VALUE self)
 {
+  VALUE        stmt         =  Qnil;
+  stmt_handle  *stmt_res    =  NULL;
+
+  rb_scan_args(argc, argv, "1", &stmt);
+
+  if (!NIL_P(stmt)) {
+    Data_Get_Struct(stmt, stmt_handle, stmt_res);
+
+    _ruby_ibm_db_free_stmt_handle_and_resources( stmt_res );
+
+  } else {
+    rb_warn("Statement resource passed for freeing is not valid");
+  }
   return Qtrue;
 }
 /*  */
@@ -6528,7 +6779,7 @@ static RETCODE _ruby_ibm_db_get_data(stmt_handle *stmt_res, int col_num, short c
   RETCODE rc = SQL_SUCCESS;
   get_data_args *getData_args;
 
-  getData_args = ALLOC_N(get_data_args, sizeof(struct _ibm_db_get_data_args_struct) );
+  getData_args = ALLOC( get_data_args );
   memset(getData_args,'\0',sizeof(struct _ibm_db_get_data_args_struct));
 
   getData_args->stmt_res    =  stmt_res;
@@ -6565,16 +6816,16 @@ static RETCODE _ruby_ibm_db_get_length(stmt_handle* stmt_res, SQLUSMALLINT col_n
 
   if ( rc < SQL_SUCCESS ) {
     if( stmt_res->ruby_stmt_err_msg == NULL ) {
-      stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN );
+      stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1 );
     }
-    memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+    memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
     _ruby_ibm_db_check_sql_errors( stmt_res , DB_STMT, stmt_res->hdbc, SQL_HANDLE_DBC, rc, 0, 
               stmt_res->ruby_stmt_err_msg, 1, 1, 0 );
     return SQL_ERROR;
   }
 
-  getLength_args = ALLOC_N(get_length_args, sizeof(struct _ibm_db_get_data_length_struct) );
+  getLength_args = ALLOC( get_length_args );
   memset(getLength_args,'\0',sizeof(struct _ibm_db_get_data_length_struct));
 
   getLength_args->new_hstmt    =  &( new_hstmt);
@@ -6611,9 +6862,9 @@ static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_nu
 
   if ( rc < SQL_SUCCESS ) {
     if( stmt_res->ruby_stmt_err_msg == NULL ) {
-      stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN );
+      stmt_res->ruby_stmt_err_msg  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN+1 );
     }
-    memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN );
+    memset( stmt_res->ruby_stmt_err_msg, '\0', DB2_MAX_ERR_MSG_LEN+1 );
 
     _ruby_ibm_db_check_sql_errors( stmt_res , DB_STMT, stmt_res->hdbc, SQL_HANDLE_DBC, rc, 0, 
               stmt_res->ruby_stmt_err_msg, 1, 1, 0 );
@@ -6621,7 +6872,7 @@ static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_nu
     return SQL_ERROR;
   }
 
-  getSubString_args = ALLOC_N(get_subString_args, sizeof(struct _ibm_db_get_data_subString_struct) );
+  getSubString_args = ALLOC( get_subString_args );
   memset(getSubString_args,'\0', sizeof(struct _ibm_db_get_data_subString_struct) );
 
   getSubString_args->new_hstmt    =  &new_hstmt;
@@ -6698,17 +6949,17 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
   /* get column header info*/
   if ( stmt_res->column_info == NULL ) {
     if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
-      data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-      memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-      sprintf(data->error, "Column information cannot be retrieved: %s", stmt_res->ruby_stmt_err_msg );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+        *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
+      } else {
+        *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
+      }
       return Qnil;
     }
   }
 
   if(col_num < 0 || col_num >= stmt_res->num_columns) {
-    data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-    memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-    sprintf(data->error, "Column ordinal out of range" );
+    *(data->error) = rb_str_new2("Column ordinal out of range" );
     return Qnil;
   }
 
@@ -6733,9 +6984,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
         in_length = stmt_res->column_info[col_num].size+1;
         out_ptr = (SQLPOINTER)ALLOC_N(char,in_length);
       if ( out_ptr == NULL ) {
-        data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-        memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-        sprintf(data->error, "Failed to Allocate Memory" );
+        rb_warn( "Failed to Allocate Memory while trying to retrieve the result" );
         return Qnil;
       }
       rc = _ruby_ibm_db_get_data(stmt_res, col_num+1, SQL_C_CHAR, out_ptr, in_length, &out_length);
@@ -6748,6 +6997,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
       } else {
         return_value = rb_str_new2((char*)out_ptr);
         ruby_xfree( out_ptr );
+        out_ptr = NULL;
         return return_value;
       }
       break; 
@@ -6789,9 +7039,7 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
       }
       out_char_ptr = (char*)ALLOC_N(char,in_length+1);
       if ( out_char_ptr == NULL ) {
-        data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-        memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-        sprintf(data->error, "Failed to Allocate Memory for LOB Data" );
+        rb_warn( "Failed to Allocate Memory for LOB Data" );
         return Qnil;
       }
       rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_CHAR, (void*)out_char_ptr, in_length, in_length+1, &out_length);
@@ -6799,7 +7047,11 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
         return Qfalse;
       }
 
-      return rb_str_new2(out_char_ptr);
+      return_value = rb_str_new2(out_char_ptr);
+      ruby_xfree( out_char_ptr );
+      out_char_ptr = NULL;
+
+      return return_value;
       break;
 
     case SQL_BLOB:
@@ -6830,16 +7082,18 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
         case BINARY:
           out_ptr = (SQLPOINTER)ALLOC_N(char,in_length);
           if ( out_ptr == NULL ) {
-            data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-            memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-            sprintf(data->error, "Failed to Allocate Memory for LOB Data" );
+            rb_warn( "Failed to Allocate Memory for LOB Data" );
             return Qnil;
           }
           rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, lob_bind_type, (char *)out_ptr, in_length, in_length, &out_length);
           if (rc == SQL_ERROR) {
             return Qfalse;
           }
-          return rb_str_new((char*)out_ptr,out_length);
+          return_value = rb_str_new((char*)out_ptr,out_length);
+          ruby_xfree( out_ptr );
+          out_ptr = NULL;
+
+          return return_value;
         default:
           break;
       }
@@ -6855,16 +7109,18 @@ static VALUE _ruby_ibm_db_result_helper(ibm_db_result_args *data) {
       }
       out_ptr = (SQLPOINTER)ALLOC_N(char, in_length);
       if ( out_ptr == NULL ) {
-        data->error = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-        memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-        sprintf(data->error, "Failed to Allocate Memory for LOB Data" );
+        rb_warn( "Failed to Allocate Memory for LOB Data" );
         return Qnil;
       }
       rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_BINARY, (SQLPOINTER)out_ptr, in_length, in_length, &out_length);
       if (rc == SQL_ERROR) {
         return Qfalse;
       }
-      return rb_str_new((char*)out_ptr,out_length);
+      return_value = rb_str_new((char*)out_ptr,out_length);
+      ruby_xfree( out_ptr );
+      out_ptr  =  NULL;
+
+      return return_value;
 
     default:
       break;
@@ -6900,14 +7156,14 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
   VALUE ret_val                    =  Qfalse;
   VALUE stmt                       =  Qnil;
 
-  char *error  =  NULL;
+  VALUE error  =  Qnil;
 
-  result_args = ALLOC_N(ibm_db_result_args,sizeof(struct _ibm_db_result_args_struct));
+  result_args = ALLOC( ibm_db_result_args );
   memset(result_args,'\0',sizeof(struct _ibm_db_result_args_struct));
 
   result_args->stmt_res   =  NULL;
   result_args->column     =  Qnil;
-  result_args->error      =  NULL;
+  result_args->error      =  &error;
 
   rb_scan_args(argc, argv, "2", &stmt, &(result_args->column) );
 
@@ -6921,8 +7177,6 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
       ret_val = _ruby_ibm_db_result_helper( result_args );
     #endif
 
-    error  =  result_args->error;
-
   } else {
     rb_warn("Invalid Statement resource specified");
     ret_val = Qnil;
@@ -6934,9 +7188,8 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
     result_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil) {
-    rb_warn( error );
-    ruby_xfree( error );
+  if( error != Qnil && ret_val == Qnil) {
+    rb_warn( RSTRING_PTR(error) );
     ret_val = Qnil;
   }
 
@@ -6976,9 +7229,11 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
   /* get column header info*/
   if ( stmt_res->column_info == NULL ) {
     if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
-      data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-      memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-      sprintf(data->error, "Column information cannot be retrieved: %s", stmt_res->ruby_stmt_err_msg );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+        *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
+      } else {
+        *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
+      }
       return Qnil;
     }
   }
@@ -6987,16 +7242,18 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
   if ( stmt_res->row_data == NULL ) {
     rc = _ruby_ibm_db_bind_column_helper(stmt_res);
     if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO ) {
-      data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-      memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-      sprintf(data->error, "Column binding cannot be done: %s", stmt_res->ruby_stmt_err_msg );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+        *(data->error) = rb_str_cat2(rb_str_new2("Column binding cannot be done: "), stmt_res->ruby_stmt_err_msg );
+      } else {
+        *(data->error) = rb_str_new2("Column binding cannot be done: <error message could not be retrieved>");
+      }
       return Qnil;
     }
   }
 
   /* check if row_number is present */
   if (data->arg_count == 2 && row_number > 0) {
-    fetch_args = ALLOC_N(fetch_data_args,sizeof(struct _ibm_db_fetch_data_struct));
+    fetch_args = ALLOC( fetch_data_args );
     memset(fetch_args,'\0',sizeof(struct _ibm_db_fetch_data_struct));
 
     fetch_args->stmt_res  =  stmt_res;
@@ -7034,13 +7291,11 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
     }
 #endif /*PASE*/
   } else if (data->arg_count == 2 && row_number < 0) {
-    data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-    memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-    sprintf(data->error, "Requested row number must be a positive value");
+    *(data->error) = rb_str_new2("Requested row number must be a positive value");
     return Qnil;
   } else {
     /*row_number is NULL or 0; just fetch next row*/
-    fetch_args = ALLOC_N(fetch_data_args,sizeof(struct _ibm_db_fetch_data_struct));
+    fetch_args = ALLOC( fetch_data_args );
     memset(fetch_args,'\0',sizeof(struct _ibm_db_fetch_data_struct));
 
     fetch_args->stmt_res  =  stmt_res;
@@ -7058,9 +7313,11 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
     return Qfalse;
   } else if ( rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
     _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 0 );
-    data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-    memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-    sprintf(data->error, "Fetch Failure: %s", stmt_res->ruby_stmt_err_msg );
+    if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+      *(data->error) = rb_str_cat2(rb_str_new2("Fetch Failure: "), stmt_res->ruby_stmt_err_msg );
+    } else {
+      *(data->error) = rb_str_new2("Fetch Failure: <error message could not be retrieved>");
+    }
     return Qnil;
   }
   /* copy the data over return_value */
@@ -7077,10 +7334,10 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
 
     switch(stmt_res->s_case_mode) {
       case CASE_LOWER:
-        stmt_res->column_info[i].name = (SQLCHAR*)strtolower((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
+        strtolower((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
         break;
       case CASE_UPPER:
-        stmt_res->column_info[i].name = (SQLCHAR*)strtoupper((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
+        strtoupper((char*)stmt_res->column_info[i].name, strlen((char*)stmt_res->column_info[i].name));
         break;
       case CASE_NATURAL:
       default:
@@ -7105,20 +7362,18 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
           /* i5/OS will xlate from EBCIDIC to ASCII (via SQLGetData) */
           tmp_length =  stmt_res->column_info[i].size;
           out_ptr    =  (SQLPOINTER)ALLOC_N(char, tmp_length+1);
-          memset(out_ptr,0,tmp_length+1);
           if ( out_ptr == NULL ) {
-            data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-            memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-            sprintf(data->error, "Failed to allocate Memory");
+            rb_warn( "Failed to allocate Memory");
             return Qnil;
           }
+          memset(out_ptr,'\0',tmp_length+1);
           rc = _ruby_ibm_db_get_data(stmt_res, i+1, SQL_C_CHAR, out_ptr, tmp_length+1, &out_length);
           if ( rc == SQL_ERROR ) {
             ruby_xfree( out_ptr );
+            out_ptr = NULL;
             return Qfalse;
           }
           if (out_length == SQL_NULL_DATA) {
-            ruby_xfree( out_ptr );
             if ( op & FETCH_ASSOC ) {
               rb_hash_aset(return_value, rb_str_new2((char*)stmt_res->column_info[i].name), Qnil);
             }
@@ -7134,6 +7389,8 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
               rb_ary_store(return_value, i, rb_str_new2((char *)out_ptr));
             }
           }
+          ruby_xfree( out_ptr );
+          out_ptr = NULL;
           break;
 #endif /* PASE */
         case SQL_TYPE_DATE:
@@ -7268,7 +7525,9 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
                 rc = _ruby_ibm_db_get_data2(stmt_res, i+1, lob_bind_type, (char *)out_ptr, tmp_length, tmp_length, &out_length);
                 if (rc == SQL_ERROR) {
                   ruby_xfree( out_ptr );
+                  out_ptr = NULL;
                   out_length = 0;
+                  return Qfalse;
                 }
 
                 if ( op & FETCH_ASSOC ) {
@@ -7279,6 +7538,10 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
                 } else if ( op == FETCH_BOTH ) {
                   rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char*)out_ptr, out_length));
                 }
+
+                ruby_xfree( out_ptr );
+                out_ptr = NULL;
+                out_length = 0;
                 break;
               default:
                 break;
@@ -7299,9 +7562,11 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
           rc      =  _ruby_ibm_db_get_data(stmt_res, i+1, SQL_C_BINARY, NULL, 0, (SQLINTEGER *)&tmp_length);
 
           if ( rc == SQL_ERROR ) {
-            data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-            memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-            sprintf(data->error, "Failed to Determine XML Size: %s", stmt_res->ruby_stmt_err_msg );
+            if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+              *(data->error) = rb_str_cat2(rb_str_new2("Failed to Determine XML Size: "), stmt_res->ruby_stmt_err_msg );
+            } else {
+              *(data->error) = rb_str_new2("Failed to Determine XML Size: <error message could not be retrieved>");
+            }
             return Qnil;
           }
 
@@ -7318,14 +7583,13 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
             out_ptr = (SQLPOINTER)ALLOC_N(char, tmp_length);
 
             if ( out_ptr == NULL ) {
-              data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-              memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-              sprintf(data->error,"Failed to Allocate Memory for XML Data");
+              rb_warn( "Failed to Allocate Memory for XML Data" );
               return Qnil;
             }
             rc = _ruby_ibm_db_get_data(stmt_res, i+1, SQL_C_BINARY, out_ptr, tmp_length, &out_length);
             if (rc == SQL_ERROR) {
               ruby_xfree( out_ptr );
+              out_ptr = NULL;
               return Qfalse;
             }
 
@@ -7337,6 +7601,8 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
             } else if ( op == FETCH_BOTH ) {
               rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char *)out_ptr, out_length));
             }
+            ruby_xfree( out_ptr );
+            out_ptr = NULL;
           }
           break;
 
@@ -7365,16 +7631,16 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
             out_ptr = (SQLPOINTER)ALLOC_N(char, tmp_length+1);
 
             if ( out_ptr == NULL ) {
-              data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-              memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-              sprintf(data->error,"Failed to Allocate Memory for LOB Data");
+              rb_warn( "Failed to Allocate Memory for LOB Data" );
               return Qnil;
             }
 
             rc = _ruby_ibm_db_get_data2(stmt_res, i+1, SQL_C_CHAR, out_ptr, tmp_length, tmp_length+1, &out_length);
             if (rc == SQL_ERROR) {
               ruby_xfree( out_ptr );
+              out_ptr =  NULL;
               out_length = 0;
+              return Qfalse;
             } else {
               out_ptr[tmp_length] = '\0';
             }
@@ -7387,6 +7653,8 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
             } else if ( op == FETCH_BOTH ) {
               rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char*)out_ptr, out_length));
             }
+            ruby_xfree( out_ptr );
+            out_ptr = NULL;
           }
           break;
 
@@ -7418,14 +7686,16 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
   /* get column header info*/
   if ( stmt_res->column_info == NULL ) {
     if (_ruby_ibm_db_get_result_set_info(stmt_res)<0) {
-      data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-      memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-      sprintf(data->error, "Column information cannot be retrieved: %s", stmt_res->ruby_stmt_err_msg );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+        *(data->error) = rb_str_cat2(rb_str_new2("Column information cannot be retrieved: "), stmt_res->ruby_stmt_err_msg );
+      } else {
+        *(data->error) = rb_str_new2("Column information cannot be retrieved: <error message could not be retrieved>");
+      }
       return Qnil;
     }
   } 
 
-  fetch_args = ALLOC_N(fetch_data_args,sizeof(struct _ibm_db_fetch_data_struct));
+  fetch_args = ALLOC( fetch_data_args );
   memset(fetch_args,'\0',sizeof(struct _ibm_db_fetch_data_struct));
 
   fetch_args->stmt_res = stmt_res;
@@ -7452,9 +7722,7 @@ static int _ruby_ibm_db_fetch_row_helper( ibm_db_fetch_helper_args *data) {
     }
 #endif /*PASE*/
   } else if (data->arg_count == 2 && row_number < 0) {
-    data->error  =  ALLOC_N(char, DB2_MAX_ERR_MSG_LEN + 30 );
-    memset(data->error, '\0', DB2_MAX_ERR_MSG_LEN + 30 );
-    sprintf(data->error, "Requested row number must be a positive value");
+    *(data->error) = rb_str_new2("Requested row number must be a positive value");
     return Qnil;
   } else {
       /*row_number is NULL or 0; just fetch next row*/
@@ -7513,11 +7781,9 @@ VALUE ibm_db_fetch_row(int argc, VALUE *argv, VALUE self)
   VALUE stmt             =  Qnil;
   VALUE ret_val          =  Qnil;
 
-  char        *error     =  NULL;
+  VALUE        error     =  Qnil;
   stmt_handle *stmt_res  =  NULL;
 
-  char  diagnose_msg[DB2_MAX_ERR_MSG_LEN + 30];
-
   ibm_db_fetch_helper_args *helper_args = NULL;
 
   rb_scan_args(argc, argv, "11", &stmt, &row_number);
@@ -7529,13 +7795,13 @@ VALUE ibm_db_fetch_row(int argc, VALUE *argv, VALUE self)
     return Qfalse;
   }
 
-  helper_args = ALLOC_N(ibm_db_fetch_helper_args,sizeof(struct _ibm_db_fetch_helper_struct));
+  helper_args = ALLOC( ibm_db_fetch_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_fetch_helper_struct));
 
   helper_args->stmt_res    =  stmt_res;
   helper_args->row_number  =  row_number;
   helper_args->arg_count   =  argc;
-  helper_args->error       =  NULL;
+  helper_args->error       =  &error;
 
   #ifdef GIL_RELEASE_VERSION
     ret_val = rb_thread_blocking_region( (void *)_ruby_ibm_db_fetch_row_helper, helper_args,
@@ -7544,18 +7810,14 @@ VALUE ibm_db_fetch_row(int argc, VALUE *argv, VALUE self)
     ret_val = _ruby_ibm_db_fetch_row_helper( helper_args );
   #endif
 
-  error  =  helper_args->error;
-
   /*Free Memory Allocated*/
   if ( helper_args != NULL) {
     ruby_xfree( helper_args );
     helper_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil ) {
-    sprintf(diagnose_msg, "%s", error );
-    ruby_xfree( error );
-    rb_throw(diagnose_msg,Qnil);
+  if( error != Qnil && ret_val == Qnil ) {
+    rb_throw( RSTRING_PTR(error),Qnil );
   }
 
   return ret_val;
@@ -7590,8 +7852,7 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
   VALUE stmt             =  Qnil;
   VALUE ret_val          =  Qnil;
 
-  char  *error           =  NULL;
-  char  diagnose_msg[DB2_MAX_ERR_MSG_LEN + 30];
+  VALUE  error           =  Qnil;
 
   stmt_handle *stmt_res  =  NULL;
 
@@ -7606,13 +7867,13 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
     return Qfalse;
   }
 
-  helper_args = ALLOC_N(ibm_db_fetch_helper_args,sizeof(struct _ibm_db_fetch_helper_struct));
+  helper_args = ALLOC( ibm_db_fetch_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_fetch_helper_struct));
 
   helper_args->stmt_res   =  stmt_res;
   helper_args->row_number =  row_number;
   helper_args->arg_count  =  argc;
-  helper_args->error      =  NULL;
+  helper_args->error      =  &error;
   helper_args->funcType   =  FETCH_ASSOC;
 
   #ifdef GIL_RELEASE_VERSION
@@ -7622,18 +7883,14 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
     ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
   #endif
 
-  error  =  helper_args->error;
-
   /*Free Memory Allocated*/
   if ( helper_args != NULL) {
     ruby_xfree( helper_args );
     helper_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil ) {
-    sprintf(diagnose_msg, "%s", error );
-    ruby_xfree( error );
-    rb_throw( error, Qnil );
+  if( error != Qnil && ret_val == Qnil ) {
+    rb_throw( RSTRING_PTR(error), Qnil );
   }
 
   return ret_val;
@@ -7674,12 +7931,11 @@ VALUE ibm_db_fetch_assoc(int argc, VALUE *argv, VALUE self) {
  */
 VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
 {
-  VALUE row_number       =  Qnil;
-  VALUE stmt             =  Qnil;
-  VALUE ret_val          =  Qnil;
+  VALUE     row_number   =  Qnil;
+  VALUE     stmt         =  Qnil;
+  VALUE     ret_val      =  Qnil;
 
-  char        *error     =  NULL;
-  char  diagnose_msg[DB2_MAX_ERR_MSG_LEN + 30];
+  VALUE     error        =  Qnil;
 
   stmt_handle *stmt_res  =  NULL;
 
@@ -7698,13 +7954,13 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
 
   row_res     = ALLOC(row_hash_struct);
 
-  helper_args = ALLOC_N(ibm_db_fetch_helper_args,sizeof(struct _ibm_db_fetch_helper_struct));
+  helper_args = ALLOC( ibm_db_fetch_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_fetch_helper_struct));
 
   helper_args->stmt_res   =  stmt_res;
   helper_args->row_number =  row_number;
   helper_args->arg_count  =  argc;
-  helper_args->error      =  NULL;
+  helper_args->error      =  &error;
   helper_args->funcType   =  FETCH_ASSOC;
 
   #ifdef GIL_RELEASE_VERSION
@@ -7714,18 +7970,14 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
     row_res->hash = _ruby_ibm_db_bind_fetch_helper( helper_args );
   #endif
 
-  error  =  helper_args->error;
-
   /*Free Memory Allocated*/
   if ( helper_args != NULL) {
     ruby_xfree( helper_args );
     helper_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil ) {
-    sprintf(diagnose_msg, "%s", error );
-    ruby_xfree( error );
-    rb_throw( error, Qnil );
+  if( error != Qnil && ret_val == Qnil ) {
+    rb_throw( RSTRING_PTR(error), Qnil );
   }
 
   if (RTEST(row_res->hash)) {
@@ -7734,6 +7986,7 @@ VALUE ibm_db_fetch_object(int argc, VALUE *argv, VALUE self)
         row_res);
   } else {
     ruby_xfree( row_res );
+    row_res = NULL;
     return Qfalse;
   }
 }
@@ -7769,11 +8022,9 @@ VALUE ibm_db_fetch_array(int argc, VALUE *argv, VALUE self)
   VALUE stmt             =  Qnil;
   VALUE ret_val          =  Qnil;
 
-  char        *error     =  NULL;
+  VALUE        error     =  Qnil;
   stmt_handle *stmt_res  =  NULL;
 
-  char  diagnose_msg[DB2_MAX_ERR_MSG_LEN + 30];
-
   ibm_db_fetch_helper_args *helper_args = NULL;
 
   rb_scan_args(argc, argv, "11", &stmt, &row_number);
@@ -7785,13 +8036,13 @@ VALUE ibm_db_fetch_array(int argc, VALUE *argv, VALUE self)
     return Qfalse;
   }
 
-  helper_args = ALLOC_N(ibm_db_fetch_helper_args,sizeof(struct _ibm_db_fetch_helper_struct));
+  helper_args = ALLOC( ibm_db_fetch_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_fetch_helper_struct));
 
   helper_args->stmt_res    =  stmt_res;
   helper_args->row_number  =  row_number;
   helper_args->arg_count   =  argc;
-  helper_args->error       =  NULL;
+  helper_args->error       =  &error;
   helper_args->funcType    =  FETCH_INDEX;
 
   #ifdef GIL_RELEASE_VERSION
@@ -7801,18 +8052,14 @@ VALUE ibm_db_fetch_array(int argc, VALUE *argv, VALUE self)
     ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
   #endif
 
-  error  =  helper_args->error;
-
   /*Free Memory Allocated*/
   if ( helper_args != NULL) {
     ruby_xfree( helper_args );
     helper_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil ) {
-    sprintf(diagnose_msg, "%s", error );
-    ruby_xfree( error );
-    rb_throw( error, Qnil );
+  if( error != Qnil && ret_val == Qnil ) {
+    rb_throw( RSTRING_PTR(error), Qnil );
   }
 
   return ret_val;
@@ -7851,11 +8098,9 @@ VALUE ibm_db_fetch_both(int argc, VALUE *argv, VALUE self)
   VALUE stmt             =  Qnil;
   VALUE ret_val          =  Qnil;
 
-  char        *error     =  NULL;
+  VALUE        error     =  Qnil;
   stmt_handle *stmt_res  =  NULL;
 
-  char  diagnose_msg[DB2_MAX_ERR_MSG_LEN + 30];
-
   ibm_db_fetch_helper_args *helper_args = NULL;
 
   rb_scan_args(argc, argv, "11", &stmt, &row_number);
@@ -7867,13 +8112,13 @@ VALUE ibm_db_fetch_both(int argc, VALUE *argv, VALUE self)
     return Qfalse;
   }
 
-  helper_args = ALLOC_N(ibm_db_fetch_helper_args,sizeof(struct _ibm_db_fetch_helper_struct));
+  helper_args = ALLOC( ibm_db_fetch_helper_args );
   memset(helper_args,'\0',sizeof(struct _ibm_db_fetch_helper_struct));
 
   helper_args->stmt_res    =  stmt_res;
   helper_args->row_number  =  row_number;
   helper_args->arg_count   =  argc;
-  helper_args->error       =  NULL;
+  helper_args->error       =  &error;
   helper_args->funcType    =  FETCH_BOTH;
 
   #ifdef GIL_RELEASE_VERSION
@@ -7883,18 +8128,14 @@ VALUE ibm_db_fetch_both(int argc, VALUE *argv, VALUE self)
     ret_val = _ruby_ibm_db_bind_fetch_helper( helper_args );
   #endif
 
-  error  =  helper_args->error;
-
   /*Free Memory Allocated*/
   if ( helper_args != NULL) {
     ruby_xfree( helper_args );
     helper_args = NULL;
   }
 
-  if( error != NULL && ret_val == Qnil ) {
-    sprintf(diagnose_msg, "%s", error );
-    ruby_xfree( error );
-    rb_throw( error, Qnil );
+  if( error != Qnil && ret_val == Qnil ) {
+    rb_throw( RSTRING_PTR(error), Qnil );
   }
 
   return ret_val;
@@ -7936,7 +8177,7 @@ VALUE ibm_db_set_option(int argc, VALUE *argv, VALUE self)
   int  rc   =  0;
   long type =  0;
 
-  char error[DB2_MAX_ERR_MSG_LEN];
+  VALUE error = Qnil;
 
   rb_scan_args(argc, argv, "3", &conn_or_stmt, &r_options, &r_type);
 
@@ -7947,9 +8188,9 @@ VALUE ibm_db_set_option(int argc, VALUE *argv, VALUE self)
       Data_Get_Struct(conn_or_stmt, conn_handle, conn_res);
 
       if ( !NIL_P(r_options) ) {
-        rc = _ruby_ibm_db_parse_options( r_options, SQL_HANDLE_DBC, conn_res, error );
+        rc = _ruby_ibm_db_parse_options( r_options, SQL_HANDLE_DBC, conn_res, &error );
         if (rc == SQL_ERROR) {
-          rb_warn( error );
+          rb_warn( RSTRING_PTR(error) );
           return Qfalse;
         }
       }
@@ -7957,9 +8198,9 @@ VALUE ibm_db_set_option(int argc, VALUE *argv, VALUE self)
       Data_Get_Struct( conn_or_stmt, stmt_handle, stmt_res );
 
       if ( !NIL_P(r_options) ) {
-        rc = _ruby_ibm_db_parse_options( r_options, SQL_HANDLE_STMT, stmt_res, error );
+        rc = _ruby_ibm_db_parse_options( r_options, SQL_HANDLE_STMT, stmt_res, &error );
         if (rc == SQL_ERROR) {
-          rb_warn( error );
+          rb_warn( RSTRING_PTR(error) );
           return Qfalse;
         }
       }
@@ -7994,12 +8235,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DBMS_NAME", rb_str_new2(buffer255));
@@ -8010,12 +8250,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer11;
   getInfo_args->buff_length  =  sizeof( buffer11 );
 
-  memset(buffer11, 0, sizeof(buffer11));
+  memset(buffer11, '\0', sizeof(buffer11));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DBMS_VER", rb_str_new2(buffer11));
@@ -8033,7 +8272,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DB_CODEPAGE", INT2NUM(bufferint32));
@@ -8045,12 +8283,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DB_NAME", rb_str_new2(buffer255));
@@ -8062,12 +8299,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@INST_NAME", rb_str_new2(buffer255));
@@ -8078,12 +8314,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@SPECIAL_CHARS", rb_str_new2(buffer255));
@@ -8095,12 +8330,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer2k;
   getInfo_args->buff_length  =  sizeof( buffer2k );
 
-  memset(buffer2k, 0, sizeof(buffer2k));
+  memset(buffer2k, '\0', sizeof(buffer2k));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     char *keyword, *last;
@@ -8130,7 +8364,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     if( bitmask & SQL_TXN_READ_UNCOMMITTED ) {
@@ -8163,7 +8396,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     VALUE array;
@@ -8200,7 +8432,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args);
     return Qfalse;
   } else {
     switch (bufferint32) {
@@ -8227,12 +8458,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer11;
   getInfo_args->buff_length  =  sizeof( buffer11 );
 
-  memset(buffer11, 0, sizeof(buffer11));
+  memset(buffer11, '\0', sizeof(buffer11));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     if( strcmp((char *)buffer11, "Y") == 0 ) {
@@ -8247,12 +8477,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer11;
   getInfo_args->buff_length  =  sizeof( buffer11 );
 
-  memset(buffer11, 0, sizeof(buffer11));
+  memset(buffer11, '\0', sizeof(buffer11));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@IDENTIFIER_QUOTE_CHAR", rb_str_new2(buffer11));
@@ -8263,12 +8492,11 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer11;
   getInfo_args->buff_length  =  sizeof( buffer11 );
 
-  memset(buffer11, 0, sizeof(buffer11));
+  memset(buffer11, '\0', sizeof(buffer11));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     if( strcmp(buffer11, "Y") == 0 ) {
@@ -8288,7 +8516,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_COL_NAME_LEN", INT2NUM(bufferint16));
@@ -8304,7 +8531,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_ROW_SIZE", INT2NUM(bufferint32));
@@ -8321,7 +8547,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_IDENTIFIER_LEN", INT2NUM(bufferint16));
@@ -8337,7 +8562,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_INDEX_SIZE", INT2NUM(bufferint32));
@@ -8353,7 +8577,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_PROC_NAME_LEN", INT2NUM(bufferint16));
@@ -8369,7 +8592,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_SCHEMA_NAME_LEN", INT2NUM(bufferint16));
@@ -8385,7 +8607,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_STATEMENT_LEN", INT2NUM(bufferint32));
@@ -8401,7 +8622,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@MAX_TABLE_NAME_LEN", INT2NUM(bufferint16));
@@ -8417,7 +8637,6 @@ static VALUE ibm_db_server_info_helper( get_info_args *getInfo_args ) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     VALUE rv = Qnil;
@@ -8526,7 +8745,7 @@ VALUE ibm_db_server_info(int argc, VALUE *argv, VALUE self)
       return Qfalse;
     }
 
-    getInfo_args = ALLOC_N(get_info_args,sizeof(struct _ibm_db_get_info_struct));
+    getInfo_args = ALLOC( get_info_args );
     memset(getInfo_args,'\0',sizeof(struct _ibm_db_get_info_struct));
 
     getInfo_args->conn_res     =  conn_res;
@@ -8573,12 +8792,11 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DRIVER_NAME", rb_str_new2(buffer255));
@@ -8589,12 +8807,11 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DRIVER_VER", rb_str_new2(buffer255));
@@ -8605,12 +8822,11 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DATA_SOURCE_NAME", rb_str_new2(buffer255));
@@ -8621,12 +8837,11 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@DRIVER_ODBC_VER", rb_str_new2(buffer255));
@@ -8638,12 +8853,11 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
   getInfo_args->infoValue    =  (SQLPOINTER)buffer255;
   getInfo_args->buff_length  =  sizeof( buffer255 );
 
-  memset(buffer255, 0, sizeof(buffer255));
+  memset(buffer255, '\0', sizeof(buffer255));
   rc = _ruby_ibm_db_SQLGetInfo_helper( getInfo_args );
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@ODBC_VER", rb_str_new2(buffer255));
@@ -8660,7 +8874,6 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     switch (bufferint16) {
@@ -8690,7 +8903,6 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@APPL_CODEPAGE", INT2NUM(bufferint32));
@@ -8706,7 +8918,6 @@ static VALUE ibm_db_client_info_helper( get_info_args *getInfo_args) {
 
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 0 );
-    ruby_xfree( getInfo_args );
     return Qfalse;
   } else {
     rb_iv_set(return_value, "@CONN_CODEPAGE", INT2NUM(bufferint32));
@@ -8774,7 +8985,7 @@ VALUE ibm_db_client_info(int argc, VALUE *argv, VALUE self)
       return Qfalse;
     }
 
-    getInfo_args = ALLOC_N(get_info_args,sizeof(struct _ibm_db_get_info_struct));
+    getInfo_args = ALLOC( get_info_args );
     memset(getInfo_args,'\0',sizeof(struct _ibm_db_get_info_struct));
 
     getInfo_args->conn_res     =  conn_res;
@@ -8834,7 +9045,7 @@ VALUE ibm_db_active(int argc, VALUE *argv, VALUE self)
   if (!NIL_P(connection)) {
     Data_Get_Struct(connection, conn_handle, conn_res);
 #ifndef PASE
-    get_handleAttr_args = ALLOC_N(get_handle_attr_args,sizeof(struct _ibm_db_get_handle_attr_struct));
+    get_handleAttr_args = ALLOC( get_handle_attr_args );
     memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
 
     get_handleAttr_args->handle       =  &( conn_res->hdbc );
@@ -8846,6 +9057,7 @@ VALUE ibm_db_active(int argc, VALUE *argv, VALUE self)
     rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
 
     ruby_xfree( get_handleAttr_args );
+    get_handleAttr_args = NULL;
 
     if ( rc == SQL_ERROR ) {
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
@@ -8896,6 +9108,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
   VALUE conn_or_stmt        =  Qnil;
   VALUE option              =  Qnil;
   VALUE r_type              =  Qnil;
+  VALUE ret_val             =  Qnil;
 
   SQLCHAR     *value        =  NULL;
   SQLINTEGER  value_int     =  0;
@@ -8927,8 +9140,9 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
         op_integer=(SQLINTEGER)FIX2INT(option);
         /* ACCTSTR_LEN is the largest possible length of the options to retrieve */
         value = (SQLCHAR *)ALLOC_N(char, ACCTSTR_LEN + 1);
+        memset(value,'\0', ACCTSTR_LEN + 1);
 
-        get_handleAttr_args = ALLOC_N(get_handle_attr_args,sizeof(struct _ibm_db_get_handle_attr_struct));
+        get_handleAttr_args = ALLOC( get_handle_attr_args );
         memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
 
         get_handleAttr_args->handle      =  &( conn_res->hdbc );
@@ -8940,12 +9154,17 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
         rc = _ruby_ibm_db_SQLGetConnectAttr_helper( get_handleAttr_args );
 
         ruby_xfree( get_handleAttr_args );
+        get_handleAttr_args = NULL;
 
         if (rc == SQL_ERROR) {
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, -1, 1, 1 );
-          return Qfalse;
+          ret_val = Qfalse;
+        } else {
+          ret_val = rb_str_new2((char *)value);
         }
-        return rb_str_new2((char *)value);
+        ruby_xfree( value );
+        value = NULL;
+        return ret_val;
       } else {
         rb_warn("No options specified");
         return Qfalse;
@@ -8959,7 +9178,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
         op_integer=(SQLINTEGER)FIX2INT(option);
         /* Checking that the option to get is the cursor type because that is what we support here */
         if (op_integer == SQL_ATTR_CURSOR_TYPE) {
-          get_handleAttr_args = ALLOC_N(get_handle_attr_args,sizeof(struct _ibm_db_get_handle_attr_struct));
+          get_handleAttr_args = ALLOC( get_handle_attr_args );
           memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
 
           get_handleAttr_args->handle      =  &( stmt_res->hstmt );
@@ -8971,6 +9190,7 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
           rc = _ruby_ibm_db_SQLGetStmtAttr_helper( get_handleAttr_args );
 
           ruby_xfree( get_handleAttr_args );
+          get_handleAttr_args = NULL;
 
           if (rc == SQL_ERROR) {
             _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
@@ -9017,7 +9237,9 @@ VALUE ibm_db_get_option(int argc, VALUE *argv, VALUE self)
  */
 VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self)
 {
-  VALUE   stmt   = Qnil;
+  VALUE   stmt    = Qnil;
+  VALUE   ret_val = Qnil;
+
   char    *value = NULL;
 
   stmt_handle *stmt_res;
@@ -9034,7 +9256,7 @@ VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self)
     /* We allocate a buffer of size 31 as per recommendations from the CLI IDS team */
     value = (char *) ALLOC_N(char, 31);
 
-    get_handleAttr_args = ALLOC_N(get_handle_attr_args,sizeof(struct _ibm_db_get_handle_attr_struct));
+    get_handleAttr_args = ALLOC( get_handle_attr_args );
     memset(get_handleAttr_args,'\0',sizeof(struct _ibm_db_get_handle_attr_struct));
 
     get_handleAttr_args->handle      =  &( stmt_res->hstmt );
@@ -9046,12 +9268,17 @@ VALUE ibm_db_get_last_serial_value(int argc, VALUE *argv, VALUE self)
     rc = _ruby_ibm_db_SQLGetStmtAttr_helper( get_handleAttr_args );
 
     ruby_xfree( get_handleAttr_args );
+    get_handleAttr_args = NULL;
 
     if ( rc == SQL_ERROR ) {
       _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, (SQLHSTMT)stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1, 1 );
       return Qfalse;
     }
-    return INT2NUM(atoi( value ));
+    ret_val = INT2NUM(atoi( value ));
+    ruby_xfree( value );
+    value = NULL;
+
+    return ret_val;
   }
   else {
     rb_warn("Supplied statement handle is invalid");