ibm_db 1.0.5 → 1.1.0

data/CHANGES

@@ -1,5 +1,13 @@
 Change Log
 ==============
+2009/06/17 (IBM_DB adapter 1.1.0, driver 1.1.0) :
+  - Support for Activerecord's Query Cache Mechanism
+  - rename_column support for DB2 on LUW version 9.7, DB2 on zOS 9 and enhanced rename_column support for Informix Dynamic Server
+  - Support for parameterized timestamp datatype feature of DB2 on LUW Version 9.7
+  - Enhanced support for Bigint datatype along with support for Bigserial datatype (with client version 9.7 and above) of IDS
+  - Callback method handle_lobs enhanced by making it to use prepared statements completely
+  - Handling of exceptions during fetch operations enabled
+
 2009/03/24 (IBM_DB adapter 1.0.5, driver 1.0.5) :
   - Support for Ruby-1.9.1
   - Support for SQLRowcount in driver

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (1.0.5) and Driver (1.0.5) (2009/03/24)
+README for the IBM_DB Adapter (1.1.0) and Driver (1.1.0) (2009/06/17)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 

data/ext/ibm_db.c

@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "1.0.5"
+#define MODULE_RELEASE "1.1.0"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -3315,10 +3315,25 @@ static int _ruby_ibm_db_bind_data( stmt_handle *stmt_res, param_node *curr, VALU
   }
 
   switch(TYPE(*bind_data)) {
+    case T_BIGNUM:
+      curr->svalue = rb_str2cstr(rb_big2str(*bind_data,10), &curr->ivalue);
+      rc = SQLBindParameter(stmt_res->hstmt, curr->param_num,
+        curr->param_type, SQL_C_CHAR, curr->data_type,
+        curr->param_size, curr->scale, curr->svalue, 0, NULL);
+      if ( rc == SQL_ERROR ) {
+        _ruby_ibm_db_check_sql_errors(stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1);
+      }
+      break;
+
     case T_FIXNUM:
-      curr->ivalue = FIX2INT(*bind_data);
+      curr->ivalue = FIX2LONG(*bind_data);
+      if(curr->data_type == SQL_BIGINT) {
+        valueType = SQL_C_DEFAULT;
+      } else {
+        valueType = SQL_C_LONG;
+      }
       rc = SQLBindParameter(stmt_res->hstmt, curr->param_num,
-        curr->param_type, SQL_C_LONG, curr->data_type,
+        curr->param_type, valueType, curr->data_type,
         curr->param_size, curr->scale, &curr->ivalue, 0, NULL);
       if ( rc == SQL_ERROR ) {
         _ruby_ibm_db_check_sql_errors(stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1);

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -64,7 +64,8 @@ module ActiveRecord
               update_query << "(" + params.join(',') + ")"
             end
             
-            update_query << " WHERE #{self.class.primary_key} = '#{self[self.class.primary_key.downcase]}'"
+            update_query << " WHERE #{self.class.primary_key} = ?"
+            values << self[self.class.primary_key.downcase]
             
             unless stmt = IBM_DB.prepare(connection.connection, update_query)
               error_msg = IBM_DB.conn_errormsg 
@@ -441,7 +442,12 @@ module ActiveRecord
           server_info = IBM_DB.server_info( @connection )
           case server_info.DBMS_NAME
             when /DB2\//i             # DB2 for Linux, Unix and Windows (LUW)
-              @servertype = IBM_DB2_LUW.new(self)
+              case server_info.DBMS_VER
+                when /09.07/i          # DB2 Version 9.7 (Cobra)
+                  @servertype = IBM_DB2_LUW_COBRA.new(self)
+                else                  # DB2 Version 9.5 or below
+                  @servertype = IBM_DB2_LUW.new(self)
+              end
             when /DB2/i               # DB2 for zOS
               case server_info.DBMS_VER
                 when /09/             # DB2 for zOS version 9
@@ -612,7 +618,7 @@ module ActiveRecord
       # Returns an array of hashes with the column names as keys and
       # column values as values. +sql+ is the select query, 
       # and +name+ is an optional description for logging
-      def select_all(sql, name = nil)
+      def select(sql, name = nil)
         # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
         sql.gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
         
@@ -621,7 +627,15 @@ module ActiveRecord
         # IBM_DB.Statement is returned from which results can be fetched
         if stmt = execute(sql, name)
           begin
-            @servertype.select_all(sql, name, stmt, results)
+            @servertype.select(sql, name, stmt, results)
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+            else
+              raise "An unexpected error occurred during data retrieval"
+            end
           ensure
             # Ensures to free the resources associated with the statement
             IBM_DB.free_result stmt
@@ -644,6 +658,14 @@ module ActiveRecord
         if stmt = execute(sql, name)
           begin
             @servertype.select_rows(sql, name, stmt, results)
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+            else
+              raise "An unexpected error occurred during data retrieval"
+            end
           ensure
             # Ensures to free the resources associated with the statement
             IBM_DB.free_result stmt
@@ -729,7 +751,9 @@ module ActiveRecord
           @sql = []
           @handle_lobs_triggered = false
         end
-        
+
+        clear_query_cache if defined? clear_query_cache
+
         if stmt = execute(sql, name)
           begin
             @sql << sql
@@ -757,6 +781,8 @@ module ActiveRecord
           @sql = []
           @handle_lobs_triggered = false
         end
+
+        clear_query_cache if defined? clear_query_cache
         
         # Make sure the WHERE clause handles NULL's correctly
         sqlarray = sql.split(/\s*WHERE\s*/)
@@ -984,7 +1010,7 @@ module ActiveRecord
         return super if limit.nil?
 
         # strip off limits on data types not supporting them
-        if [:integer, :double, :date, :time, :timestamp, :xml].include? type.to_sym
+        if @servertype.limit_not_supported_types.include? type.to_sym
           return native_database_types[type.to_sym][:name].to_s
         elsif type.to_sym == :boolean
           return "smallint"
@@ -1014,6 +1040,14 @@ module ActiveRecord
                 tables << tab["table_name"].downcase    
               end
             end
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Failed to retrieve table metadata during fetch: #{error_msg}"
+            else
+              raise "An unexpected error occurred during retrieval of table metadata"
+            end
           ensure
             IBM_DB.free_result(stmt)  # Free resources associated with the statement
           end
@@ -1050,7 +1084,7 @@ module ActiveRecord
         if stmt = IBM_DB.primary_keys( @connection, nil, 
                                       @servertype.set_case(@schema), 
                                       @servertype.set_case(table_name))
-        begin
+          begin
             while ( pk_index_row = IBM_DB.fetch_array(stmt) )
               if pk_index_row[5] 
                 pk_index_name = pk_index_row[5].downcase
@@ -1062,7 +1096,15 @@ module ActiveRecord
                 end
               end 
             end
-        ensure  # Free resources associated with the statement
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Failed to retrieve primarykey metadata during fetch: #{error_msg}"
+            else
+              raise "An unexpected error occurred during retrieval of primary metadata"
+            end
+          ensure  # Free resources associated with the statement
             IBM_DB.free_result(stmt) if stmt
           end
         else  # Handle driver execution errors
@@ -1084,33 +1126,41 @@ module ActiveRecord
         if stmt = IBM_DB.statistics( @connection, nil, 
                                       @servertype.set_case(@schema), 
                                       @servertype.set_case(table_name), 1 )
-        begin
-          while ( index_stats = IBM_DB.fetch_array(stmt) )
-              is_composite = false
-            if index_stats[5]             # INDEX_NAME
-              index_name = index_stats[5].downcase
-              index_unique = (index_stats[3] == 0)
-              index_columns = [index_stats[8].downcase]     # COLUMN_NAME
-              index_qualifier = index_stats[4].downcase             #Index_Qualifier
-              # Create an IndexDefinition object and add to the indexes array
-              i = 0;
-              indexes.each do |index|
-                if index.name == index_name && index_schema[i] == index_qualifier
-                   index.columns = index.columns + index_columns
-                   is_composite = true
+          begin
+            while ( index_stats = IBM_DB.fetch_array(stmt) )
+                is_composite = false
+              if index_stats[5]             # INDEX_NAME
+                index_name = index_stats[5].downcase
+                index_unique = (index_stats[3] == 0)
+                index_columns = [index_stats[8].downcase]     # COLUMN_NAME
+                index_qualifier = index_stats[4].downcase             #Index_Qualifier
+                # Create an IndexDefinition object and add to the indexes array
+                i = 0;
+                indexes.each do |index|
+                  if index.name == index_name && index_schema[i] == index_qualifier
+                     index.columns = index.columns + index_columns
+                     is_composite = true
+                  end 
+                  i = i+1
+                end
+              
+                unless is_composite 
+                  indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns)
+                  index_schema << index_qualifier
                 end 
-                i = i+1
               end
-              
-              unless is_composite 
-                indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns)
-                index_schema << index_qualifier
-              end 
             end
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Failed to retrieve index metadata during fetch: #{error_msg}"
+            else
+              raise "An unexpected error occurred during retrieval of index metadata"
+            end
+          ensure  # Free resources associated with the statement
+            IBM_DB.free_result(stmt) if stmt
           end
-        ensure  # Free resources associated with the statement
-          IBM_DB.free_result(stmt) if stmt
-        end
         else  # Handle driver execution errors
           error_msg = IBM_DB.conn_errormsg 
           error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
@@ -1348,13 +1398,25 @@ To remove the column, the table must be dropped and recreated without the #{colu
         end
       end
 
-      def select_all(sql, name, stmt, results)
+      def select(sql, name, stmt, results)
         # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
         # an hash for each single record.
         # The loop stops when there aren't any more valid records to fetch
-        while single_hash = IBM_DB.fetch_assoc(stmt)
-          # Add the record to the +results+ array
-          results <<  single_hash
+        begin
+          while single_hash = IBM_DB.fetch_assoc(stmt)
+            # Add the record to the +results+ array
+            results <<  single_hash
+          end
+        rescue StandardError  # Handle driver fetch errors
+          error_msg = IBM_DB.conn_errormsg 
+          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          if error_msg && !error_msg.empty?
+            raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+          else
+            raise "An unexpected error occurred during data retrieval"
+          end
+        ensure  # Free resources associated with the statement
+          IBM_DB.free_result(stmt)
         end
       end
 
@@ -1362,9 +1424,21 @@ To remove the column, the table must be dropped and recreated without the #{colu
         # Fetches all the results available. IBM_DB.fetch_array(stmt) returns
         # an array representing a row in a result set.
         # The loop stops when there aren't any more valid records to fetch
-        while single_array = IBM_DB.fetch_array(stmt)
-          #Add the array to results array
-          results <<  single_array
+        begin
+          while single_array = IBM_DB.fetch_array(stmt)
+            #Add the array to results array
+            results <<  single_array
+          end
+        rescue StandardError  # Handle driver fetch errors
+          error_msg = IBM_DB.conn_errormsg 
+          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          if error_msg && !error_msg.empty?
+            raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+          else
+            raise "An unexpected error occurred during data retrieval"
+          end
+        ensure  # Free resources associated with the statement
+          IBM_DB.free_result(stmt)
         end
       end
       
@@ -1418,6 +1492,10 @@ To remove the column, the table must be dropped and recreated without the #{colu
 
       def set_case(value)
       end
+
+      def limit_not_supported_types
+        [:integer, :double, :date, :time, :timestamp, :xml]
+      end
     end # class IBM_DataServer
 
     class IBM_DB2 < IBM_DataServer
@@ -1441,8 +1519,16 @@ To remove the column, the table must be dropped and recreated without the #{colu
             IBM_DB.fetch_row(stmt)
             # Retrieves and returns the result of the query with the last id.
             IBM_DB.result(stmt,0)
+          rescue StandardError  # Handle driver fetch errors
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Failed to retrieve last generated id: #{error_msg}"
+            else
+              raise "An unexpected error occurred during retrieval of last generated id"
+            end
           ensure  # Free resources associated with the statement
-            IBM_DB.free_result stmt
+            IBM_DB.free_result(stmt) if stmt
           end
         else
           error_msg = IBM_DB.conn_errormsg 
@@ -1494,7 +1580,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         if !default.nil?
           change_column_default(table_name, column_name, default)
         end 
-        reorg_table(table_name)
+        #reorg_table(table_name)
         if !null.nil? 
           if null
             change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} DROP NOT NULL"
@@ -1528,117 +1614,139 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
       # an hash for each single record.
       # The loop stops when there aren't any more valid records to fetch
-      def select_all(sql, name, stmt, results)
-        if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
-          # We know at this point that there is an offset and/or a limit
-          # Check if the cursor type is set correctly
-          cursor_type = IBM_DB.get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
-          @offset = 0 if @offset.nil?
-          if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
-            index = 0
-            # Get @limit rows starting at @offset
-            while (index < @limit)
-              # We increment the offset by 1 because for DB2 the offset of the initial row is 1 instead of 0
-              if single_hash = IBM_DB.fetch_assoc(stmt, @offset + index + 1)
-                # Add the record to the +results+ array
-                results <<  single_hash
-                index = index + 1
-              else
-                # break from the while loop
-                break 
-              end
-            end
-          else # cursor != IBM_DB::SQL_CURSOR_STATIC
-            # If the result set contains a LOB, the cursor type will never be SQL_CURSOR_STATIC
-            # because DB2 does not allow this. We can't use the offset mechanism because the cursor 
-            # is not scrollable. In this case, ignore first @offset rows and return rows starting 
-            # at @offset to @offset + @limit
-            index = 0
-            while (index < @offset + @limit)
-              if single_hash = IBM_DB.fetch_assoc(stmt)
-                # Add the record to the +results+ array only from row @offset to @offset + @limit
-                if (index >= @offset)
+      def select(sql, name, stmt, results)
+        begin
+          if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
+            # We know at this point that there is an offset and/or a limit
+            # Check if the cursor type is set correctly
+            cursor_type = IBM_DB.get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
+            @offset = 0 if @offset.nil?
+            if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
+              index = 0
+              # Get @limit rows starting at @offset
+              while (index < @limit)
+                # We increment the offset by 1 because for DB2 the offset of the initial row is 1 instead of 0
+                if single_hash = IBM_DB.fetch_assoc(stmt, @offset + index + 1)
+                  # Add the record to the +results+ array
                   results <<  single_hash
+                  index = index + 1
+                else
+                  # break from the while loop
+                  break 
+                end
+              end
+            else # cursor != IBM_DB::SQL_CURSOR_STATIC
+              # If the result set contains a LOB, the cursor type will never be SQL_CURSOR_STATIC
+              # because DB2 does not allow this. We can't use the offset mechanism because the cursor 
+              # is not scrollable. In this case, ignore first @offset rows and return rows starting 
+              # at @offset to @offset + @limit
+              index = 0
+              while (index < @offset + @limit)
+                if single_hash = IBM_DB.fetch_assoc(stmt)
+                  # Add the record to the +results+ array only from row @offset to @offset + @limit
+                  if (index >= @offset)
+                    results <<  single_hash
+                  end
+                  index = index + 1
+                else
+                  # break from the while loop
+                  break
                 end
-                index = index + 1
-              else
-                # break from the while loop
-                break
               end
             end
+          # This is the case where limit is set to zero
+          # Simply return an empty +results+
+          elsif (!@limit.nil? && @limit == 0)
+            results
+          # No limits or offsets specified
+          else
+            while single_hash = IBM_DB.fetch_assoc(stmt)
+              # Add the record to the +results+ array
+              results <<  single_hash
+            end
           end
-        # This is the case where limit is set to zero
-        # Simply return an empty +results+
-        elsif (!@limit.nil? && @limit == 0)
-          results
-        # No limits or offsets specified
-        else
-          while single_hash = IBM_DB.fetch_assoc(stmt)
-            # Add the record to the +results+ array
-            results <<  single_hash
+        rescue StandardError  # Handle driver fetch errors
+          error_msg = IBM_DB.conn_errormsg 
+          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          if error_msg && !error_msg.empty?
+            raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+          else
+            raise "An unexpected error occurred during data retrieval"
           end
+        ensure
+          # Assign the instance variables to nil. We will not be using them again
+          @offset = nil
+          @limit = nil
         end
-        # Assign the instance variables to nil. We will not be using them again
-        @offset = nil
-        @limit = nil
       end
 
       # Fetches all the results available. IBM_DB.fetch_array(stmt) returns
       # an array for each single record.
       # The loop stops when there aren't any more valid records to fetch
       def select_rows(sql, name, stmt, results)
-        if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
-          # We know at this point that there is an offset and/or a limit
-          # Check if the cursor type is set correctly
-          cursor_type = IBM_DB.get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
-          @offset = 0 if @offset.nil?
-          if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
-            index = 0
-            # Get @limit rows starting at @offset
-            while (index < @limit)
-              # We increment the offset by 1 because for DB2 the offset of the initial row is 1 instead of 0
-              if single_array = IBM_DB.fetch_array(stmt, @offset + index + 1)
-                # Add the array to the +results+ array
-                results <<  single_array
-                index = index + 1
-              else
-                # break from the while loop
-                break 
-              end
-            end
-          else # cursor != IBM_DB::SQL_CURSOR_STATIC
-            # If the result set contains a LOB, the cursor type will never be SQL_CURSOR_STATIC
-            # because DB2 does not allow this. We can't use the offset mechanism because the cursor 
-            # is not scrollable. In this case, ignore first @offset rows and return rows starting 
-            # at @offset to @offset + @limit
-            index = 0
-            while (index < @offset + @limit)
-              if single_array = IBM_DB.fetch_array(stmt)
-                # Add the array to the +results+ array only from row @offset to @offset + @limit
-                if (index >= @offset)
+        begin
+          if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
+            # We know at this point that there is an offset and/or a limit
+            # Check if the cursor type is set correctly
+            cursor_type = IBM_DB.get_option stmt, IBM_DB::SQL_ATTR_CURSOR_TYPE, 0
+            @offset = 0 if @offset.nil?
+            if (cursor_type == IBM_DB::SQL_CURSOR_STATIC)
+              index = 0
+              # Get @limit rows starting at @offset
+              while (index < @limit)
+                # We increment the offset by 1 because for DB2 the offset of the initial row is 1 instead of 0
+                if single_array = IBM_DB.fetch_array(stmt, @offset + index + 1)
+                  # Add the array to the +results+ array
                   results <<  single_array
+                  index = index + 1
+                else
+                  # break from the while loop
+                  break 
                 end
-                index = index + 1
-              else
-                # break from the while loop
-                break
               end
+            else # cursor != IBM_DB::SQL_CURSOR_STATIC
+              # If the result set contains a LOB, the cursor type will never be SQL_CURSOR_STATIC
+              # because DB2 does not allow this. We can't use the offset mechanism because the cursor 
+              # is not scrollable. In this case, ignore first @offset rows and return rows starting 
+              # at @offset to @offset + @limit
+              index = 0
+              while (index < @offset + @limit)
+                if single_array = IBM_DB.fetch_array(stmt)
+                  # Add the array to the +results+ array only from row @offset to @offset + @limit
+                  if (index >= @offset)
+                    results <<  single_array
+                  end
+                  index = index + 1
+                else
+                  # break from the while loop
+                  break
+                end
+              end
+            end
+          # This is the case where limit is set to zero
+          # Simply return an empty +results+
+          elsif (!@limit.nil? && @limit == 0)
+            results
+          # No limits or offsets specified
+          else
+            while single_array = IBM_DB.fetch_array(stmt)
+              # Add the array to the +results+ array
+              results <<  single_array
             end
           end
-        # This is the case where limit is set to zero
-        # Simply return an empty +results+
-        elsif (!@limit.nil? && @limit == 0)
-          results
-        # No limits or offsets specified
-        else
-          while single_array = IBM_DB.fetch_array(stmt)
-            # Add the array to the +results+ array
-            results <<  single_array
+        rescue StandardError  # Handle driver fetch errors
+          error_msg = IBM_DB.conn_errormsg 
+          error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+          if error_msg && !error_msg.empty?
+            raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+          else
+            raise "An unexpected error occurred during data retrieval"
           end
+        ensure
+          # Assign the instance variables to nil. We will not be using them again
+          @offset = nil
+          @limit = nil
         end
-        # Assign the instance variables to nil. We will not be using them again
-        @offset = nil
-        @limit = nil
       end
       
       def execute(sql, name = nil)
@@ -1734,6 +1842,51 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       end
     end # class IBM_DB2_LUW
 
+    class IBM_DB2_LUW_COBRA < IBM_DB2_LUW
+      # Cobra supports parameterised timestamp, 
+      # hence overriding following method to allow timestamp datatype to be parameterised
+      def limit_not_supported_types
+        [:integer, :double, :date, :time, :xml]
+      end
+
+      # Alter table column for renaming a column
+      # This feature is supported for against DB2 V97 and above only
+      def rename_column(table_name, column_name, new_column_name)
+        _table_name      = table_name.to_s
+        _column_name     = column_name.to_s
+        _new_column_name = new_column_name.to_s
+
+        nil_condition    = _table_name.nil? || _column_name.nil? || _new_column_name.nil?
+        empty_condition  = _table_name.empty? || 
+                             _column_name.empty? || 
+                               _new_column_name.empty? unless nil_condition
+
+        if nil_condition || empty_condition
+          raise ArgumentError,"One of the arguments passed to rename_column is empty or nil"
+        end
+
+        begin
+          rename_column_sql = "ALTER TABLE #{_table_name} RENAME COLUMN #{_column_name} \
+                   TO #{_new_column_name}"
+
+          unless stmt = execute(rename_column_sql)
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Rename column failed : #{error_msg}"
+            else
+              raise StandardError.new('An unexpected error occurred during renaming the column')
+            end
+          end
+
+          reorg_table(_table_name)
+
+        ensure
+          IBM_DB.free_stmt stmt if stmt
+        end #End of begin
+      end # End of rename_column
+    end #IBM_DB2_LUW_COBRA
+
     module HostedDataServer
       require 'pathname'
       #find DB2-i5-zOS rezerved words file relative path
@@ -1763,6 +1916,42 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         "remove_column is not supported by the DB2 for zOS data server"
       end  
 
+      #Alter table column for renaming a column
+      def rename_column(table_name, column_name, new_column_name)
+        _table_name      = table_name.to_s
+        _column_name     = column_name.to_s
+        _new_column_name = new_column_name.to_s
+
+        nil_condition    = _table_name.nil? || _column_name.nil? || _new_column_name.nil?
+        empty_condition  = _table_name.empty? || 
+                             _column_name.empty? || 
+                               _new_column_name.empty? unless nil_condition
+
+        if nil_condition || empty_condition
+          raise ArgumentError,"One of the arguments passed to rename_column is empty or nil"
+        end
+
+        begin
+          rename_column_sql = "ALTER TABLE #{_table_name} RENAME COLUMN #{_column_name} \
+                   TO #{_new_column_name}"
+
+          unless stmt = execute(rename_column_sql)
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Rename column failed : #{error_msg}"
+            else
+              raise StandardError.new('An unexpected error occurred during renaming the column')
+            end
+          end
+
+          reorg_table(_table_name)
+
+        ensure
+          IBM_DB.free_stmt stmt if stmt
+        end #End of begin
+      end # End of rename_column
+
       # DB2 z/OS only allows NULL or "" (empty) string as DEFAULT value for a BLOB column. 
       # For non-empty string and non-NULL values, the server returns error
       def set_binary_default(value)
@@ -1795,6 +1984,10 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         execute "SET CURRENT RULES = 'STD'"
       end
 
+      def rename_column(table_name, column_name, new_column_name)
+        raise NotImplementedError, "rename_column is not implemented for DB2 on zOS 8"
+      end
+
       def change_column_default(table_name, column_name, default)
         raise NotImplementedError,
         "DB2 for zOS data server version 8 does not support changing the column default"
@@ -1811,9 +2004,41 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       def set_schema(schema)
       end
 
+      # IDS specific ALTER TABLE statement to rename a column
       def rename_column(table_name, column_name, new_column_name)
-        execute "RENAME COLUMN #{table_name}.#{column_name} TO #{new_column_name}"
-      end
+        _table_name      = table_name.to_s
+        _column_name     = column_name.to_s
+        _new_column_name = new_column_name.to_s
+
+        nil_condition    = _table_name.nil? || _column_name.nil? || _new_column_name.nil?
+        empty_condition  = _table_name.empty? || 
+                             _column_name.empty? || 
+                               _new_column_name.empty? unless nil_condition
+
+        if nil_condition || empty_condition
+          raise ArgumentError,"One of the arguments passed to rename_column is empty or nil"
+        end
+
+        begin
+          rename_column_sql = "RENAME COLUMN #{table_name}.#{column_name} TO \
+               #{new_column_name}"
+
+          unless stmt = execute(rename_column_sql)
+            error_msg = IBM_DB.conn_errormsg 
+            error_msg = IBM_DB.stmt_errormsg if error_msg.empty?
+            if error_msg && !error_msg.empty?
+              raise "Rename column failed : #{error_msg}"
+            else
+              raise StandardError.new('An unexpected error occurred during renaming the column')
+            end
+          end
+
+          reorg_table(_table_name)
+
+        ensure
+          IBM_DB.free_stmt stmt if stmt
+        end #End of begin
+      end # End of rename_column
 
       def primary_key
         return "SERIAL(100) PRIMARY KEY"

data/test/cases/migration_test.rb

@@ -28,6 +28,14 @@ if ActiveRecord::Base.connection.supports_migrations?
   class MigrationTest < ActiveRecord::TestCase
     self.use_transactional_fixtures = false
 
+    if (current_adapter?(:IBM_DBAdapter))
+      #Rename is supported only for server zOS 9 , DB2 COBRA and Informix
+      server_type = ActiveRecord::Base.connection.servertype.class.name
+      @ibm_db_rename_supported =  server_type.include?('::IBM_DB2_LUW_COBRA') ||
+                          server_type.class.name.include?('::IBM_IDS') ||
+        (server_type.include?('IBM_DB2_ZOS') && !server_type.include?('IBM_DB2_ZOS_8'))
+    end
+
     fixtures :people
 
     def setup
@@ -556,109 +564,111 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert !Person.column_methods_hash.include?(:last_name)
     end
 
-  unless current_adapter?(:IBM_DBAdapter) # rename not supported
-    def test_add_rename
-      Person.delete_all
+    if (!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported)
+      def test_add_rename
+        Person.delete_all
   
-      begin
-        Person.connection.add_column "people", "girlfriend", :string
-        Person.reset_column_information
-        Person.create :girlfriend => 'bobette'
+        begin
+          Person.connection.add_column "people", "girlfriend", :string
+          Person.reset_column_information
+          Person.create :girlfriend => 'bobette'
   
-        Person.connection.rename_column "people", "girlfriend", "exgirlfriend"
+          Person.connection.rename_column "people", "girlfriend", "exgirlfriend"
     
-        Person.reset_column_information
-        bob = Person.find(:first)
+          Person.reset_column_information
+          bob = Person.find(:first)
 
-        assert_equal "bobette", bob.exgirlfriend
-      ensure
-        Person.connection.remove_column("people", "girlfriend") rescue nil
-        Person.connection.remove_column("people", "exgirlfriend") rescue nil
-      end
+          assert_equal "bobette", bob.exgirlfriend
+        ensure
+          Person.connection.remove_column("people", "girlfriend") rescue nil
+          Person.connection.remove_column("people", "exgirlfriend") rescue nil
+        end
 
-    end
+      end
   
-    def test_rename_column_using_symbol_arguments
-      begin
-        names_before = Person.find(:all).map(&:first_name)
-        Person.connection.rename_column :people, :first_name, :nick_name
-        Person.reset_column_information
-        assert Person.column_names.include?("nick_name")
-        assert_equal names_before, Person.find(:all).map(&:nick_name)
-      ensure
-        Person.connection.remove_column("people","nick_name")
-        Person.connection.add_column("people","first_name", :string)
+      def test_rename_column_using_symbol_arguments
+        begin
+          names_before = Person.find(:all).map(&:first_name)
+          Person.connection.rename_column :people, :first_name, :nick_name
+          Person.reset_column_information
+          assert Person.column_names.include?("nick_name")
+          assert_equal names_before, Person.find(:all).map(&:nick_name)
+        ensure
+          Person.connection.remove_column("people","nick_name")
+          Person.connection.add_column("people","first_name", :string)
+        end
       end
-    end
 
-    def test_rename_column
-      begin
-        names_before = Person.find(:all).map(&:first_name)
-        Person.connection.rename_column "people", "first_name", "nick_name"
-        Person.reset_column_information
-        assert Person.column_names.include?("nick_name")
-        assert_equal names_before, Person.find(:all).map(&:nick_name)
-      ensure
-        Person.connection.remove_column("people","nick_name")
-        Person.connection.add_column("people","first_name", :string)
+      def test_rename_column
+        begin
+          names_before = Person.find(:all).map(&:first_name)
+          Person.connection.rename_column "people", "first_name", "nick_name"
+          Person.reset_column_information
+          assert Person.column_names.include?("nick_name")
+          assert_equal names_before, Person.find(:all).map(&:nick_name)
+        ensure
+          Person.connection.remove_column("people","nick_name")
+          Person.connection.add_column("people","first_name", :string)
+        end
       end
-    end
 
-    def test_rename_column_preserves_default_value_not_null
-      begin
-        default_before = Developer.connection.columns("developers").find { |c| c.name == "salary" }.default
-        assert_equal 70000, default_before
-        Developer.connection.rename_column "developers", "salary", "anual_salary"
-        Developer.reset_column_information
-        assert Developer.column_names.include?("anual_salary")
-        default_after = Developer.connection.columns("developers").find { |c| c.name == "anual_salary" }.default
-        assert_equal 70000, default_after
-      ensure
-        Developer.connection.rename_column "developers", "anual_salary", "salary"
-        Developer.reset_column_information
+      def test_rename_column_preserves_default_value_not_null
+        begin
+          default_before = Developer.connection.columns("developers").find { |c| c.name == "salary" }.default
+          assert_equal 70000, default_before
+          Developer.connection.rename_column "developers", "salary", "anual_salary"
+          Developer.reset_column_information
+          assert Developer.column_names.include?("anual_salary")
+          default_after = Developer.connection.columns("developers").find { |c| c.name == "anual_salary" }.default
+          assert_equal 70000, default_after
+        ensure
+          Developer.connection.rename_column "developers", "anual_salary", "salary"
+          Developer.reset_column_information
+        end
       end
-    end
 
-    def test_rename_nonexistent_column
-      ActiveRecord::Base.connection.create_table(:hats) do |table|
-        table.column :hat_name, :string, :default => nil
-      end
-      exception = if current_adapter?(:PostgreSQLAdapter)
-        ActiveRecord::StatementInvalid
-      else
-        ActiveRecord::ActiveRecordError
-      end
-      assert_raise(exception) do
-        Person.connection.rename_column "hats", "nonexistent", "should_fail"
+      def test_rename_nonexistent_column
+        ActiveRecord::Base.connection.create_table(:hats) do |table|
+          table.column :hat_name, :string, :default => nil
+        end
+        exception = if current_adapter?(:PostgreSQLAdapter)
+          ActiveRecord::StatementInvalid
+        else
+          ActiveRecord::ActiveRecordError
+        end
+        assert_raise(exception) do
+          Person.connection.rename_column "hats", "nonexistent", "should_fail"
+        end
+      ensure
+        ActiveRecord::Base.connection.drop_table(:hats)
       end
-    ensure
-      ActiveRecord::Base.connection.drop_table(:hats)
-    end
 
-    def test_rename_column_with_sql_reserved_word
-      begin
-        assert_nothing_raised { Person.connection.rename_column "people", "first_name", "group" }
-        Person.reset_column_information
-        assert Person.column_names.include?("group")
-      ensure
-        Person.connection.remove_column("people", "group") rescue nil
-        Person.connection.add_column("people", "first_name", :string) rescue nil
+      def test_rename_column_with_sql_reserved_word
+        begin
+          assert_nothing_raised { Person.connection.rename_column "people", "first_name", "group" }
+          Person.reset_column_information
+          assert Person.column_names.include?("group")
+        ensure
+          Person.connection.remove_column("people", "group") rescue nil
+          Person.connection.add_column("people", "first_name", :string) rescue nil
+        end
       end
     end
 
-    def test_rename_column_with_an_index
-      ActiveRecord::Base.connection.create_table(:hats) do |table|
-        table.column :hat_name, :string, :limit => 100
-        table.column :hat_size, :integer
-      end
-      Person.connection.add_index :hats, :hat_name
-      assert_nothing_raised do
-        Person.connection.rename_column "hats", "hat_name", "name"
+    unless (current_adapter?(:IBM_DBAdapter)) #Cannot alter a object when there is another object depending on it
+      def test_rename_column_with_an_index
+        ActiveRecord::Base.connection.create_table(:hats) do |table|
+          table.column :hat_name, :string, :limit => 100
+          table.column :hat_size, :integer
+        end
+        Person.connection.add_index :hats, :hat_name
+        assert_nothing_raised do
+          Person.connection.rename_column "hats", "hat_name", "name"
+        end
+      ensure
+        ActiveRecord::Base.connection.drop_table(:hats)
       end
-    ensure
-      ActiveRecord::Base.connection.drop_table(:hats)
-    end
-  end 
+    end 
 
     def test_remove_column_with_index
       ActiveRecord::Base.connection.create_table(:hats) do |table|
@@ -672,30 +682,32 @@ if ActiveRecord::Base.connection.supports_migrations?
       ActiveRecord::Base.connection.drop_table(:hats)
     end
 
-    def test_remove_column_with_multi_column_index
-      ActiveRecord::Base.connection.create_table(:hats) do |table|
-        table.column :hat_name, :string, :limit => 100
-        table.column :hat_size, :integer
-        table.column :hat_style, :string, :limit => 100
-      end
-      ActiveRecord::Base.connection.add_index "hats", ["hat_style", "hat_size"], :unique => true
+    unless (current_adapter?(:IBM_DBAdapter)) #Cannot alter a object when there is another object depending on it
+      def test_remove_column_with_multi_column_index
+        ActiveRecord::Base.connection.create_table(:hats) do |table|
+          table.column :hat_name, :string, :limit => 100
+          table.column :hat_size, :integer
+          table.column :hat_style, :string, :limit => 100
+        end
+        ActiveRecord::Base.connection.add_index "hats", ["hat_style", "hat_size"], :unique => true
 
-      assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") }
-    ensure
-      ActiveRecord::Base.connection.drop_table(:hats)
+        assert_nothing_raised { Person.connection.remove_column("hats", "hat_size") }
+      ensure
+        ActiveRecord::Base.connection.drop_table(:hats)
+      end
     end
 
-  unless current_adapter?(:IBM_DBAdapter) #incompatible types changes
-    def test_change_type_of_not_null_column
-      assert_nothing_raised do
-      Topic.connection.change_column "topics", "written_on", :datetime, :null => false
-      Topic.reset_column_information
+    unless current_adapter?(:IBM_DBAdapter) #incompatible types changes
+      def test_change_type_of_not_null_column
+        assert_nothing_raised do
+          Topic.connection.change_column "topics", "written_on", :datetime, :null => false
+          Topic.reset_column_information
 
-      Topic.connection.change_column "topics", "written_on", :datetime, :null => false
-      Topic.reset_column_information
+          Topic.connection.change_column "topics", "written_on", :datetime, :null => false
+          Topic.reset_column_information
+        end
       end
-    end
-  end 
+    end 
 
     def test_rename_table
       begin
@@ -844,7 +856,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       assert_equal false, person_klass.columns_hash["wealth"].null
 
       # rename column to see that column doesn't lose its not null and/or default definition
-      unless current_adapter?(:IBM_DBAdapter) #rename_column is not implemented in IBM_DBAdapetr
+      if (!current_adapter?(:IBM_DBAdapter) || @ibm_db_rename_supported) 
         person_klass.connection.rename_column "testings", "wealth", "money"
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["wealth"]
@@ -853,7 +865,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end 
 
       # change column
-      unless current_adapter?(:IBM_DBAdapter)
+      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
         person_klass.connection.change_column "testings", "money", :integer, :null => false, :default => 1000
         person_klass.reset_column_information
         assert_equal 1000, person_klass.columns_hash["money"].default
@@ -866,7 +878,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end   
 
       # change column, make it nullable and clear default
-      unless current_adapter?(:IBM_DBAdapter)
+      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
         person_klass.connection.change_column "testings", "money", :integer, :null => true, :default => nil
         person_klass.reset_column_information
         assert_nil person_klass.columns_hash["money"].default
@@ -879,7 +891,7 @@ if ActiveRecord::Base.connection.supports_migrations?
       end   
 
       # change_column_null, make it not nullable and set null values to a default value
-      unless current_adapter?(:IBM_DBAdapter)
+      unless (current_adapter?(:IBM_DBAdapter) && !@ibm_db_rename_supported)
         person_klass.connection.execute('UPDATE testings SET money = NULL')
         person_klass.connection.change_column_null "testings", "money", false, 2000
         person_klass.reset_column_information

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ibm_db
 version: !ruby/object:Gem::Version 
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors: 
 - IBM
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-24 00:00:00 +05:30
+date: 2009-06-16 00:00:00 +05:30
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,48 +34,31 @@ extra_rdoc_files:
 - MANIFEST
 files: 
 - README
-- lib
-- lib/active_record
-- lib/active_record/connection_adapters
 - lib/active_record/connection_adapters/ibm_db_adapter.rb
-- lib/active_record/vendor
 - lib/active_record/vendor/db2-i5-zOS.yaml
 - lib/IBM_DB.rb
-- test
-- test/connections
-- test/connections/native_ibm_db
 - test/connections/native_ibm_db/connection.rb
-- test/models
 - test/models/warehouse_thing.rb
-- test/cases
 - test/cases/finder_test.rb
 - test/cases/attribute_methods_test.rb
 - test/cases/schema_dumper_test.rb
 - test/cases/validations_test.rb
 - test/cases/fixtures_test.rb
 - test/cases/calculations_test.rb
-- test/cases/query_cache_test.rb
 - test/cases/migration_test.rb
 - test/cases/base_test.rb
-- test/cases/associations
 - test/cases/associations/has_many_through_associations_test.rb
 - test/cases/associations/has_and_belongs_to_many_associations_test.rb
 - test/cases/associations/eager_test.rb
 - test/cases/associations/cascaded_eager_loading_test.rb
 - test/cases/associations/join_model_test.rb
 - test/cases/adapter_test.rb
-- test/schema
-- test/schema/zOS
 - test/schema/zOS/ibm_db_specific_schema.rb
-- test/schema/ids
 - test/schema/ids/ibm_db_specific_schema.rb
-- test/schema/i5
 - test/schema/i5/ibm_db_specific_schema.rb
 - test/schema/schema.rb
-- test/schema/luw
 - test/schema/luw/ibm_db_specific_schema.rb
 - test/ibm_db_test.rb
-- ext
 - ext/ruby_ibm_db.h
 - ext/Makefile.nt32
 - ext/extconf.rb
@@ -86,6 +69,8 @@ files:
 - MANIFEST
 has_rdoc: true
 homepage: http://rubyforge.org/projects/rubyibm/
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -106,9 +91,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - ActiveRecord, at least 1.15.1
 rubyforge_project: rubyibm
-rubygems_version: 1.3.1
+rubygems_version: 1.3.3
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: "Rails Driver and Adapter for IBM Data Servers: {DB2 on Linux/Unix/Windows, DB2 on zOS, DB2 on i5/OS, Informix (IDS)}"
 test_files: 
 - test/ibm_db_test.rb

data/test/cases/query_cache_test.rb

@@ -1,124 +0,0 @@
-require "cases/helper"
-require 'models/topic'
-require 'models/reply'
-require 'models/task'
-require 'models/course'
-require 'models/category'
-require 'models/post'
-
-unless current_adapter?(:IBM_DBAdapter)
-  class QueryCacheTest < ActiveRecord::TestCase
-    fixtures :tasks, :topics, :categories, :posts, :categories_posts
-    
-    def test_find_queries
-      assert_queries(2) { Task.find(1); Task.find(1) }
-    end
-    
-    def test_find_queries_with_cache
-      Task.cache do
-        assert_queries(1) { Task.find(1); Task.find(1) }
-      end
-    end
-    
-    def test_count_queries_with_cache
-      Task.cache do
-        assert_queries(1) { Task.count; Task.count }
-      end
-    end
-    
-    def test_query_cache_dups_results_correctly
-      Task.cache do
-        now  = Time.now.utc
-        task = Task.find 1
-        assert_not_equal now, task.starting
-        task.starting = now
-        task.reload
-        assert_not_equal now, task.starting
-      end
-    end
-    
-    def test_cache_is_flat
-      Task.cache do
-        Topic.columns # don't count this query
-        assert_queries(1) { Topic.find(1); Topic.find(1); }
-      end
-      
-      ActiveRecord::Base.cache do
-        assert_queries(1) { Task.find(1); Task.find(1) }
-      end
-    end
-    
-    def test_cache_does_not_wrap_string_results_in_arrays
-      Task.cache do
-        assert_instance_of String, Task.connection.select_value("SELECT count(*) AS count_all FROM tasks")
-      end
-    end
-  end
-  
-  class QueryCacheExpiryTest < ActiveRecord::TestCase
-    fixtures :tasks, :posts, :categories, :categories_posts
-    
-    def test_find
-      Task.connection.expects(:clear_query_cache).times(1)
-      
-      assert !Task.connection.query_cache_enabled
-      Task.cache do
-        assert Task.connection.query_cache_enabled
-        Task.find(1)
-        
-        Task.uncached do
-          assert !Task.connection.query_cache_enabled
-          Task.find(1)
-        end
-        
-        assert Task.connection.query_cache_enabled
-      end
-      assert !Task.connection.query_cache_enabled
-    end
-    
-    def test_update
-      Task.connection.expects(:clear_query_cache).times(2)
-      
-      Task.cache do
-        task = Task.find(1)
-        task.starting = Time.now.utc
-        task.save!
-      end
-    end
-    
-    def test_destroy
-      Task.connection.expects(:clear_query_cache).times(2)
-      
-      Task.cache do
-        Task.find(1).destroy
-      end
-    end
-    
-    def test_insert
-      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-      
-      Task.cache do
-        Task.create!
-      end
-    end
-    
-    def test_cache_is_expired_by_habtm_update
-      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-      ActiveRecord::Base.cache do
-        c = Category.find(:first)
-        p = Post.find(:first)
-        p.categories << c
-      end
-    end
-    
-    def test_cache_is_expired_by_habtm_delete
-      ActiveRecord::Base.connection.expects(:clear_query_cache).times(2)
-      ActiveRecord::Base.cache do
-        c = Category.find(1)
-        p = Post.find(1)
-        assert p.categories.any?
-        p.categories.delete_all
-      end
-    end
-  end
-end