ibm_db 2.5.5 → 2.5.6

data/CHANGES

@@ -1,5 +1,10 @@
 Change Log
 ==============
+2011/02/07 (IBM_DB adapter 2.5.6, driver 2.5.6) :
+  - Fixed Bug #28622, #28881
+  - Decimal datatypes will now be returned as BigDecimal type from the driver
+  - Changes to rollback any active transaction in the connection destructor method if connection is not explicitly closed
+  - Changes to have a single gem file for ruby 1.8 and ruby 1.9
 2010/07/15 (IBM_DB adapter 2.5.5, driver 2.5.5) :
   - Support for datatype Graphic and Vargraphic in driver and adapter [27965]
   - Support for Bigint datatype in adapter.

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (2.5.5) and Driver (2.5.5) (2010/07/15)
+README for the IBM_DB Adapter (2.5.5) and Driver (2.5.5) (2011/02/07)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 
@@ -259,7 +259,9 @@ Limitations and known problems
  	- test_add_table_with_decimals
  	- test_native_types
  	- test_schema_dump_includes_decimal_options
-
+ - Usage with Rails-3.0.3/Rails-3.0.4
+	- To use with Rails-3.0.3/4 patch latest Arel with the patch available at https://gist.github.com/814491
+	
 Unicode Support
 ===============
   - Available only with Ruby version 1.9 and above

data/ext/ibm_db.c

@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "2.5.5"
+#define MODULE_RELEASE "2.5.6"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -321,6 +321,11 @@ void Init_ibm_db(void) {
 #define INI_STR(name) NULL
 /* }}} */
 
+/*Load necessary libraries*/
+static void ruby_ibm_db_load_necessary_libs() {
+  rb_eval_string("require \'bigdecimal\'");
+}
+
 static void ruby_ibm_db_init_globals(struct _ibm_db_globals *ibm_db_globals)
 {
   /* env handle */
@@ -415,10 +420,25 @@ static void _ruby_ibm_db_mark_conn_struct(conn_handle *handle)
 static void _ruby_ibm_db_free_conn_struct(conn_handle *handle)
 {
   int rc;
-  
+  end_tran_args *end_X_args;
+
   if ( handle != NULL ) {
     /* Disconnect from DB. If stmt is allocated, it is freed automatically*/
     if ( handle->handle_active ) {
+      if( handle->transaction_active == 1 && handle->auto_commit == 0 ) {
+        handle->transaction_active = 0;
+        end_X_args = ALLOC( end_tran_args );
+        memset(end_X_args,'\0',sizeof(struct _ibm_db_end_tran_args_struct));
+
+        end_X_args->hdbc            =  &(handle->hdbc);
+        end_X_args->handleType      =  SQL_HANDLE_DBC;
+        end_X_args->completionType  =  SQL_ROLLBACK; /*Note we are rolling back the transaction*/
+
+        _ruby_ibm_db_SQLEndTran( end_X_args );
+
+        ruby_xfree( end_X_args );
+
+      }
       rc = _ruby_ibm_db_SQLDisconnect_helper( &(handle->hdbc) );
       rc = SQLFreeHandle(SQL_HANDLE_DBC, handle->hdbc );
       rc = SQLFreeHandle(SQL_HANDLE_ENV, handle->henv );
@@ -826,6 +846,8 @@ void ruby_init_ibm_db()
   rb_attr(le_server_info, rb_intern("MAX_STATEMENT_LEN"), 1, 0, 0);
   rb_attr(le_server_info, rb_intern("MAX_TABLE_NAME_LEN"), 1, 0, 0);
   rb_attr(le_server_info, rb_intern("NON_NULLABLE_COLUMNS"), 1, 0, 0);
+
+  ruby_ibm_db_load_necessary_libs();
 }
 /*  */
 
@@ -1387,11 +1409,6 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
       }
     } else {
       option_num = NUM2LONG(data);
-      if (opt_key == SQL_ATTR_AUTOCOMMIT && option_num == SQL_AUTOCOMMIT_OFF) {
-        ((conn_handle*)handle)->auto_commit = 0;
-      } else if (opt_key == SQL_ATTR_AUTOCOMMIT && option_num == SQL_AUTOCOMMIT_ON) {
-        ((conn_handle*)handle)->auto_commit = 1;
-      }
 #ifdef PASE
       handleAttr_args->valuePtr = (SQLPOINTER)&option_num;
 #else
@@ -1422,6 +1439,13 @@ static VALUE _ruby_ibm_db_assign_options( void *handle, int type, long opt_key,
 #endif
         }
         return Qfalse;
+      } else {
+        if (opt_key == SQL_ATTR_AUTOCOMMIT && option_num == SQL_AUTOCOMMIT_OFF) {
+          ((conn_handle*)handle)->auto_commit = 0;
+        } else if (opt_key == SQL_ATTR_AUTOCOMMIT && option_num == SQL_AUTOCOMMIT_ON) {
+          ((conn_handle*)handle)->auto_commit        = 1;
+          ((conn_handle*)handle)->transaction_active = 0; /* Setting Autocommit to ON commits any open transaction*/
+        }
       }
     }
   } else {
@@ -2087,6 +2111,8 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
 
     conn_res->errorType              =  1;
 
+    conn_res->transaction_active     =  0; /*No transaction is active*/
+
     /* Set Options */
     if ( !NIL_P(*options) ) {
       rc = _ruby_ibm_db_parse_options( *options, SQL_HANDLE_DBC, conn_res, error );
@@ -2127,8 +2153,50 @@ static VALUE _ruby_ibm_db_connect_helper2( connect_helper_args *data ) {
         handleAttr_args = NULL;
         _ruby_ibm_db_free_conn_struct( conn_res );
         return Qnil;
-        break;
       }
+
+      /* Get the AUTOCOMMIT state from the CLI driver as cli driver could have changed autocommit status based on it's precedence  */
+      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 );
+      get_handleAttr_args->attribute    =  SQL_ATTR_AUTOCOMMIT;
+      get_handleAttr_args->valuePtr     =  (SQLPOINTER)(&conn_res->auto_commit);
+      get_handleAttr_args->buff_length  =  0;
+      get_handleAttr_args->out_length   =  NULL;
+
+      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, NULL, -1, 1, 0 );
+        rc = _ruby_ibm_db_SQLDisconnect_helper( &(conn_res->hdbc)  );
+        SQLFreeHandle( SQL_HANDLE_DBC, conn_res->hdbc );
+        SQLFreeHandle( SQL_HANDLE_ENV, conn_res->henv );
+        if( conn_res != NULL && conn_res->ruby_error_msg != NULL ) {
+
+#ifdef UNICODE_SUPPORT_VERSION
+          *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr("Failed to retrieve autocommit status during connection: "),
+                     _ruby_ibm_db_export_sqlwchar_to_utf8_rstr(conn_res->ruby_error_msg, conn_res->ruby_error_msg_len));
+#else
+          *error = rb_str_cat2(rb_str_new2("Connection failed: "),conn_res->ruby_error_msg);
+#endif
+        } else {
+#ifdef UNICODE_SUPPORT_VERSION
+          *error = _ruby_ibm_db_export_char_to_utf8_rstr("Failed to retrieve autocommit status during connection: <error message could not be retrieved>");
+#else
+          *error = rb_str_new2("Connection failed: <error message could not be retrieved>");
+#endif
+        }
+        ruby_xfree( handleAttr_args );
+        handleAttr_args = NULL;
+        _ruby_ibm_db_free_conn_struct( conn_res );
+        return Qnil;
+
+      }
+
 #ifdef CLI_DBC_SERVER_TYPE_DB2LUW
 #ifdef SQL_ATTR_DECFLOAT_ROUNDING_MODE
                                                                                          
@@ -2786,8 +2854,15 @@ VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self)
 
         if ( rc == SQL_ERROR ) {
           _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
+        } else {
+          conn_res->auto_commit = autocommit;
+
+          /* If autocommit is requested to be turned ON and there is a transaction in progress, the trasaction is committed.
+           * Hence set flag_transaction  to 0 indicating no transaction is in progress */ 
+          if( autocommit == SQL_AUTOCOMMIT_ON ) {
+            conn_res->transaction_active = 0;
+          } 
         }
-        conn_res->auto_commit = autocommit;
       }
       ruby_xfree( handleAttr_args );
       handleAttr_args = NULL;
@@ -3099,7 +3174,12 @@ VALUE ibm_db_bind_param(int argc, VALUE *argv, VALUE self)
   rb_scan_args(argc, argv, "35", &stmt, &r_param_no, &r_varname, 
     &r_param_type, &r_data_type, &r_precision, &r_scale, &r_size);
 
+#ifdef UNICODE_SUPPORT_VERSION
+  varname     = RSTRING_PTR(r_varname);
+  varname_len = RSTRING_LEN(r_varname);
+#else
   varname = rb_str2cstr(r_varname, &varname_len);
+#endif
 
   if (!NIL_P(r_param_type)) {
     param_type =  NUM2LONG(r_param_type);
@@ -5046,6 +5126,7 @@ VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self)
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
       return Qfalse;
     } else {
+      conn_res->transaction_active = 0; 
       return Qtrue;
     }
   }
@@ -5242,6 +5323,8 @@ VALUE ibm_db_exec(int argc, VALUE *argv, VALUE self)
         }
       }
 
+      conn_res->transaction_active = 1; /*A transaction begins with prepare of exec*/
+
       exec_direct_args->stmt_res    =  stmt_res;
 
       #ifdef GIL_RELEASE_VERSION
@@ -5432,6 +5515,8 @@ VALUE ibm_db_prepare(int argc, VALUE *argv, VALUE self)
 
     stmt_res = _ibm_db_new_stmt_struct(conn_res);
 
+    conn_res->transaction_active = 1; /*A transaction begins with prepare of exec*/
+
     /* Allocates the stmt handle */
     /* Prepares the statement */
     /* returns the stat_handle back to the calling function */
@@ -5515,6 +5600,7 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
 
 #ifdef UNICODE_SUPPORT_VERSION
   VALUE    bindData_utf16;
+  VALUE    tmpBuff;
 #endif
 
   SQLSMALLINT valueType;
@@ -5534,7 +5620,13 @@ static int _ruby_ibm_db_bind_parameter_helper(stmt_handle *stmt_res, param_node
 
   switch(TYPE(*bind_data)) {
     case T_BIGNUM:
+#ifdef UNICODE_SUPPORT_VERSION
+      tmpBuff      =  rb_big2str(*bind_data,10);
+      tmp_str      =  (SQLCHAR *) RSTRING_PTR(tmpBuff);
+      curr->ivalue =  RSTRING_LEN(tmpBuff);
+#else
       tmp_str = (SQLCHAR *) rb_str2cstr( rb_big2str(*bind_data,10), (long*)&curr->ivalue );
+#endif
 
       curr->svalue = (SQLCHAR *) ALLOC_N(char, curr->ivalue+1);
       memset(curr->svalue, '\0', curr->ivalue+1);
@@ -5842,7 +5934,13 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
       return SQL_ERROR;
     }
     curr->bind_indicator  =  0;
+
+#ifdef UNICODE_SUPPORT_VERSION
+    curr->svalue          =  (SQLCHAR *) RSTRING_PTR(*bind_data);
+    curr->ivalue          =  RSTRING_LEN(*bind_data);
+#else
     curr->svalue          =  (SQLCHAR *) rb_str2cstr(*bind_data, (long*) &curr->ivalue);
+#endif
 
     /* Bind file name string */
     rc = _ruby_ibm_db_SQLBindFileToParam_helper(stmt_res, curr);
@@ -6054,7 +6152,13 @@ void var_assign(char *name, VALUE value) {
   inspect   =  rb_intern("inspect");
   value     =  rb_funcall(value, inspect, 0);
 
+#ifdef UNICODE_SUPPORT_VERSION
+  expr      =  RSTRING_PTR(value);
+  expr_len  =  RSTRING_LEN(value);
+#else
   expr      =  rb_str2cstr(value, &expr_len);
+#endif
+
   statement =  ALLOC_N(char, strlen(name)+1+expr_len+1);
   strcpy(statement, name);
   strcat(statement, "=");
@@ -8017,6 +8121,7 @@ VALUE ibm_db_rollback(int argc, VALUE *argv, VALUE self)
       _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, conn_res->hdbc, SQL_HANDLE_DBC, rc, 1, NULL, NULL, -1, 1, 1 );
       return Qfalse;
     } else {
+      conn_res->transaction_active = 0;
       return Qtrue;
     }
   }
@@ -8623,6 +8728,8 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
   SQLINTEGER            out_length, tmp_length;
   SQLPOINTER            out_ptr;
 
+  char  *tmpStr       =  NULL;
+
   VALUE return_value  =  Qnil;
   VALUE colName       =  Qnil;
 
@@ -8887,9 +8994,6 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
         case SQL_TYPE_TIME:
         case SQL_TYPE_TIMESTAMP:
         case SQL_BIGINT:
-        case SQL_DECIMAL:
-        case SQL_NUMERIC:
-        case SQL_DECFLOAT:
 
           if ( op & FETCH_ASSOC ) {
             rb_hash_aset(return_value, colName, rb_str_new2((char *)row_data->str_val));
@@ -8900,6 +9004,34 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(ibm_db_fetch_helper_args *data)
             rb_hash_aset(return_value, INT2NUM(i), rb_str_new2((char *)row_data->str_val));
           }
           break;
+
+        case SQL_DECIMAL:
+        case SQL_NUMERIC:
+        case SQL_DECFLOAT:
+          tmpStr = ALLOC_N(char, strlen(row_data->str_val) + 19);
+
+          if(tmpStr == NULL ){
+           rb_warn( "Failed to Allocate Memory for Decimal Data" );
+           return Qnil; 
+          }
+
+          strcpy(tmpStr, "BigDecimal.new(\'");
+          strcat(tmpStr, row_data->str_val);
+          strcat(tmpStr, "\')");
+
+          if ( op & FETCH_ASSOC ) {
+            rb_hash_aset(return_value, colName, rb_eval_string(tmpStr));
+          }
+          if ( op == FETCH_INDEX ) {
+            rb_ary_store(return_value, i, rb_eval_string(tmpStr) );
+          } else if ( op == FETCH_BOTH ) {
+            rb_hash_aset( return_value, INT2NUM(i), rb_eval_string( tmpStr ) );
+          }
+
+          ruby_xfree(tmpStr);
+          tmpStr = NULL;
+
+          break;
         case SQL_SMALLINT:
           if ( op & FETCH_ASSOC ) {
             rb_hash_aset(return_value, colName, INT2NUM(row_data->s_val));

data/ext/ruby_ibm_db_cli.h

@@ -43,6 +43,7 @@ typedef struct _conn_handle_struct {
   long         c_case_mode;
   long         c_cursor_type;
   int          handle_active;
+  int          transaction_active;
   SQLSMALLINT  error_recno_tracker;
   SQLSMALLINT  errormsg_recno_tracker;
   int          flag_pconnect; /* Indicates that this connection is persistent */

data/lib/IBM_DB.rb

@@ -1,2 +1,2 @@
-require (RUBY_PLATFORM =~ /mswin32/ || RUBY_PLATFORM =~ /mingw32/ ) ? 'mswin32/ibm_db.so' : 'ibm_db.so'
+require (RUBY_PLATFORM =~ /mswin32/ || RUBY_PLATFORM =~ /mingw32/ ) ? 'mswin32/ibm_db' : 'ibm_db.so'
 require 'active_record/connection_adapters/ibm_db_adapter'

data/lib/active_record/connection_adapters/ibm_db_pstmt.rb

@@ -189,6 +189,67 @@ module ActiveRecord
 
     class << self
 
+      def validates_uniqueness_of(*attr_names)
+        configuration = { :case_sensitive => true }
+        configuration.update(attr_names.extract_options!)
+
+        validates_each(attr_names,configuration) do |record, attr_name, value|
+          # The check for an existing value should be run from a class that
+          # isn't abstract. This means working down from the current class
+          # (self), to the first non-abstract class. Since classes don't know
+          # their subclasses, we have to build the hierarchy between self and
+          # the record's class.
+          class_hierarchy = [record.class]
+          while class_hierarchy.first != self
+            class_hierarchy.insert(0, class_hierarchy.first.superclass)
+          end
+
+          # Now we can work our way down the tree to the first non-abstract
+          # class (which has a database table to query from).
+                    finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
+
+          column = finder_class.columns_hash[attr_name.to_s]
+
+          if value.nil?
+            comparison_operator = "IS NULL"
+          elsif column.text?
+            comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
+            value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
+          else
+            comparison_operator = "= ?"
+          end
+
+          sql_attribute = "#{record.class.quoted_table_name}.#{connection.quote_column_name(attr_name)}"
+
+          if value.nil? || (configuration[:case_sensitive] || !column.text?)
+            condition_sql = "#{sql_attribute} #{comparison_operator}"
+            condition_params = [value] if(!value.nil?) #Add the value only if not nil, because in case of nil comparison op is IS NULL
+          else
+            condition_sql = "LOWER(#{sql_attribute}) #{comparison_operator}"
+            condition_params = [value.mb_chars.downcase]
+          end
+
+          if scope = configuration[:scope]
+            Array(scope).map do |scope_item|
+              scope_value = record.send(scope_item)
+              condition_sql << " AND " << attribute_condition("#{record.class.quoted_table_name}.#{scope_item}", scope_value)
+              condition_params << scope_value
+            end
+          end
+
+          unless record.new_record?
+            condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
+            condition_params << record.send(:id)
+          end
+
+          finder_class.with_exclusive_scope do
+            if finder_class.exists?([condition_sql, *condition_params])
+              record.errors.add(attr_name, :taken, :default => configuration[:message], :value => value)
+            end
+          end
+        end
+      end
+
       def find_one(id, options)
         param_array = [quote_value(id,columns_hash[primary_key])]
         if options[:conditions]
@@ -1901,4 +1962,4 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     pstmt = @connection.prepare "DELETE FROM #{@connection.quote_table_name(table_name)}", 'Fixture Delete'
     @connection.prepared_delete(pstmt, nil)
   end
-end
+end

data/test/cases/adapter_test.rb

@@ -107,6 +107,17 @@ class AdapterTest < ActiveRecord::TestCase
     def test_show_nonexistent_variable_returns_nil
       assert_nil @connection.show_variable('foo_bar_baz')
     end
+
+    def test_not_specifying_database_name_for_cross_database_selects
+      begin
+        assert_nothing_raised do
+          ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['arunit'].except(:database))
+          ActiveRecord::Base.connection.execute "SELECT activerecord_unittest.pirates.*, activerecord_unittest2.courses.* FROM activerecord_unittest.pirates, activerecord_unittest2.courses"
+        end
+      ensure
+        ActiveRecord::Base.establish_connection 'arunit'
+      end
+    end
   end
 
   if current_adapter?(:PostgreSQLAdapter)
@@ -154,27 +165,38 @@ class AdapterTest < ActiveRecord::TestCase
     end
   end
 
-  unless current_adapter?(:IBM_DBAdapter)  
+  def test_uniqueness_violations_are_translated_to_specific_exception
+    @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      @connection.execute "INSERT INTO subscribers(nick) VALUES('me')"
+    end
+  end
+
+  def test_foreign_key_violations_are_translated_to_specific_exception
+    unless @connection.adapter_name == 'SQLite'
+      assert_raises(ActiveRecord::InvalidForeignKey) do
+        # Oracle adapter uses prefetched primary key values from sequence and passes them to connection adapter insert method
+        if @connection.prefetch_primary_key?
+          id_value = @connection.next_sequence_value(@connection.default_sequence_name("fk_test_has_fk", "id"))
+          @connection.execute "INSERT INTO fk_test_has_fk (id, fk_id) VALUES (#{id_value},0)"
+        else
+          @connection.execute "INSERT INTO fk_test_has_fk (fk_id) VALUES (0)"
+        end
+      end
+    end
+  end
+
+  unless current_adapter?(:IBM_DBAdapter)
     def test_add_limit_offset_should_sanitize_sql_injection_for_limit_without_comas
-     sql_inject = "1 select * from schema"
-     assert_equal " LIMIT 1", @connection.add_limit_offset!("", :limit=>sql_inject)
-     if current_adapter?(:MysqlAdapter)
-       assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
-     else
-       assert_equal " LIMIT 1 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
-     end
+      sql_inject = "1 select * from schema"
+      assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject))
+      assert_no_match(/schema/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
     end
 
     def test_add_limit_offset_should_sanitize_sql_injection_for_limit_with_comas
-     sql_inject = "1, 7 procedure help()"
-     if current_adapter?(:MysqlAdapter)
-       assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
-       assert_equal " LIMIT 7, 1", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
-     else
-       assert_equal " LIMIT 1,7", @connection.add_limit_offset!("", :limit=>sql_inject)
-       assert_equal " LIMIT 1,7 OFFSET 7", @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7)
-     end
-    end
-  end 
-  
+      sql_inject = "1, 7 procedure help()"
+      assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject))
+      assert_no_match(/procedure/, @connection.add_limit_offset!("", :limit=>sql_inject, :offset=>7))
+    end
+  end
 end