ibm_db 0.9.4 → 0.9.5

data/CHANGES

@@ -1,5 +1,20 @@
 Change Log
 ==============
+2008/06/24 (IBM_DB adapter 0.9.5, driver 0.9.5):
+  - Fixed Bug [#19222] --> Fixed fixture insertion of LOB columns for DB2 
+  - Fixed Bug [#19970] --> Fixed Table schema dumper also dump views
+  - Fixed Bug [#20053] --> Fixed CLOB data with special chars contains null characters upon retrieval
+  - Fixed Bug [#20762] --> IBM_DB adapter with Rails 2.1 fails on rake db:migrate
+  - Cleaned up fix for Bug [#19223] and [#19224], indexes are now dumped as array without schema qualified name.
+  - Support for Rails-2.0.2
+  - Support for Rails-2.1.0 
+      Rails-2.1.0 contains changes that generates Non-standard SQL in 2 noticed cases which won't work with SQL compliant databases like DB2
+       a. Handling Nullable columns in Table creation. [http://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/398-non-standard-sql-generated-in-column-definition-for-nullable-columns-in-create-table-ddl-rails-2-1#ticket-398-2]
+       	     A workaround for this problem is provided from within ibm_db adapter.
+       b. Handling has_and_belongs_to_many association. [http://rails.lighthouseapp.com/projects/8994/tickets/394-patch-fixed-non-standard-sql-generated-by-preloading-has_and_belongs_to_many-associations]. 
+       	     It is not possible to provide a workaround for this from within the ibm_db adapter. 
+             To workaround this problem please patch ActiveRecord-2.1.0 with the patch available at [http://rails.lighthouseapp.com/attachments/26975/association_preloading.diff]
+  
 2008/04/28 (IBM_DB adapter 0.9.4, driver 0.9.4):
   - Fixed bug [#19679]--> invalid values being returned for blank or null in fetch_assoc
   - Fixed bug [#19223] and [#19224]--> handling of composite and unique indexes incorrect

data/README

@@ -1,6 +1,6 @@
 =====================================================================
-README for the IBM_DB Adapter 0.9.2 and Driver 0.9.1 (2007/11/30)
-For ActiveRecord Version 1.15.5 (and Rails 1.2.5)
+README for the IBM_DB Adapter 0.9.5 and Driver 0.9.5 (2008/06/24)
+For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 
 Supported Operating Systems 
@@ -108,7 +108,7 @@ Ruby environment, including Rails, to interact with IBM data servers.
    $ ls -al vendor/plugins/
    $ irb
      irb(main):001:0> gem 'ibm_db'
-     irb(main):002:0> require 'ibm_db'    // notice the library path (different on win32)
+     irb(main):002:0> require 'ibm_db'    // notice the library path (different on win32, use require 'mswin32/ibm_db')
      irb(main):003:0> IBM_DB::connect 'sample', 'db2admin', 'secret'
    $ ./script/console
 
@@ -286,7 +286,14 @@ Limitations and known problems
    The IBM_DB adapter relies on IBM_DB driver (C extension) and the IBM Driver for ODBC and
    CLI to access databases on IBM data servers. Alternatively, you can either use the regular C
    implementation of Ruby, or use ActiveRecord-JDBC adapter to access databases.
-
+ - Query caching feature of ActiveRecord-2.0 not supported 
+ - When using ActiveRecord-2.1.0 it requires that ActiveRecord be patched, with the patch in the link below:
+ 		http://rails.lighthouseapp.com/attachments/26975/association_preloading.diff
+ 	The patch is required because, ActiveRecord 2.1.0 generates a non-standard SQL identifier,while preloading has_and_belongs_to_many associations,
+ 	which standard compliant databases like DB2 do not support. The bug report, against ActiveRecord, can be found in the link below
+ 		http://rails.lighthouseapp.com/projects/8994/tickets/394-patch-fixed-non-standard-sql-generated-by-preloading-has_and_belongs_to_many-associations
+ - ActiveRecord-2.1.0 test suite changes appropriate for DB2/IDS will be updated in the next release of the gem.
+ 		 	 
 To Do
 ====
  - Support ActiveRecord remove_column method for DB2 zOS version 9

data/ext/ibm_db.c

@@ -10,7 +10,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "0.9.4"
+#define MODULE_RELEASE "0.9.5"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -3750,7 +3750,8 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
       rb_throw("Connection is not active", Qnil);
     }
 
-    return_str = ALLOC_N(char, SQL_SQLSTATE_SIZE + 1);
+    return_str = ALLOC_N(char, DB2_MAX_ERR_MSG_LEN);
+	memset(return_str, 0, DB2_MAX_ERR_MSG_LEN);
 
     _ruby_ibm_db_check_sql_errors(conn_res->hdbc, SQL_HANDLE_DBC, -1, 0, return_str, DB2_ERRMSG, conn_res->errormsg_recno_tracker);
     if(conn_res->errormsg_recno_tracker - conn_res->error_recno_tracker >= 1)
@@ -4680,7 +4681,7 @@ static RETCODE _ruby_ibm_db_get_length(stmt_handle* stmt_res, SQLUSMALLINT col_n
 /* }}} */
      
 /* {{{ static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, int col_num, short ctype, void *buff, int in_length, SQLINTEGER *out_length) */
-static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_num, SQLSMALLINT ctype, SQLPOINTER buff, SQLLEN in_length, SQLINTEGER *out_length)
+static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_num, SQLSMALLINT ctype, SQLPOINTER buff, SQLLEN read_length, SQLLEN buff_length, SQLINTEGER *out_length)
 {
   RETCODE rc=SQL_SUCCESS;
   SQLHANDLE new_hstmt;
@@ -4692,9 +4693,9 @@ static RETCODE _ruby_ibm_db_get_data2(stmt_handle *stmt_res, SQLUSMALLINT col_nu
     return SQL_ERROR;
   }
 
-  rc = SQLGetSubString((SQLHSTMT)new_hstmt, stmt_res->column_info[col_num-1].loc_type,
-    stmt_res->column_info[col_num-1].lob_loc, 1, in_length, targetCType,
-    buff, in_length, out_length, &stmt_res->column_info[col_num-1].loc_ind);
+rc = SQLGetSubString((SQLHSTMT)new_hstmt, stmt_res->column_info[col_num-1].loc_type,
+    stmt_res->column_info[col_num-1].lob_loc, 1, read_length, targetCType,
+    buff, buff_length, out_length, &stmt_res->column_info[col_num-1].loc_ind);
   if ( rc == SQL_ERROR ) {
     _ruby_ibm_db_check_sql_errors((SQLHSTMT)new_hstmt, SQL_HANDLE_STMT, rc, 1, NULL, -1, 1);
   }
@@ -4860,7 +4861,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
           rb_throw("Failed to Allocate Memory for LOB Data", Qnil);
           return Qfalse;
         }
-        rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_CHAR, (void*)out_char_ptr, in_length+1, &out_length);
+        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);
         if (rc == SQL_ERROR) {
           return Qfalse;
         }
@@ -4900,7 +4901,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
               rb_throw("Failed to Allocate Memory for LOB Data", Qnil);
               return Qfalse;
             }
-            rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, lob_bind_type, (char *)out_ptr, in_length, &out_length);
+            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;
             }
@@ -4924,7 +4925,7 @@ VALUE ibm_db_result(int argc, VALUE *argv, VALUE self)
           rb_throw("Failed to Allocate Memory for XML Data", Qnil);
           return Qfalse;
         }
-        rc = _ruby_ibm_db_get_data2(stmt_res, col_num+1, SQL_C_BINARY, (SQLPOINTER)out_ptr, in_length, &out_length);
+        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;
         }
@@ -5214,7 +5215,7 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(int argc, VALUE *argv, int op)
               case BINARY:
                 out_ptr = (SQLPOINTER)ALLOC_N(char, tmp_length);
 
-                rc = _ruby_ibm_db_get_data2(stmt_res, i+1, lob_bind_type, (char *)out_ptr, tmp_length, &out_length);
+                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_length = 0;
@@ -5314,21 +5315,21 @@ static VALUE _ruby_ibm_db_bind_fetch_helper(int argc, VALUE *argv, int op)
               return Qfalse;
             }
 
-            rc = _ruby_ibm_db_get_data2(stmt_res, i+1, SQL_C_CHAR, out_ptr, tmp_length+1, &out_length);
+            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);
-              tmp_length = 0;
+              out_length = 0;
             } else {
               out_ptr[tmp_length] = '\0';
             }
 
             if ( op & FETCH_ASSOC ) {
-              rb_hash_aset(return_value, rb_str_new2((char*)stmt_res->column_info[i].name), rb_str_new((char*)out_ptr, tmp_length));
+              rb_hash_aset(return_value, rb_str_new2((char*)stmt_res->column_info[i].name), rb_str_new((char*)out_ptr, out_length));
             }
             if ( op == FETCH_INDEX ) {
-              rb_ary_store(return_value, i, rb_str_new((char*)out_ptr, tmp_length));
+              rb_ary_store(return_value, i, rb_str_new((char*)out_ptr, out_length));
             } else if ( op == FETCH_BOTH ) {
-              rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char*)out_ptr, tmp_length));
+              rb_hash_aset(return_value, INT2NUM(i), rb_str_new((char*)out_ptr, out_length));
             }
           }
           break;

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -479,11 +479,20 @@ requires credentials: username and password"
       def create_table(name, options = {})
         @servertype.setup_for_lob_table
         super
-        # force implicit id column (primary key) unless :id => false
-        unless !options[:id].nil? and
-               !options[:id]
-          @servertype.create_index_after_table(name)
-        end
+        
+        #Table definition is complete only when a unique index is created on the primarykey column for DB2 V8 on zOS
+        
+        #create index on id column if options[:id] is nil or id ==true
+        #else check if options[:primary_key]is not nil then create an unique index on that column
+        if  !options[:id].nil? || !options[:primary_key].nil?
+          if (!options[:id].nil? && options[:id] == true)
+            @servertype.create_index_after_table(name,"id")
+          elsif !options[:primary_key].nil?
+            @servertype.create_index_after_table(name,options[:primary_key].to_s)
+          end
+        else
+          @servertype.create_index_after_table(name,"id")
+        end 
       end
 
       # Returns an array of hashes with the column names as keys and
@@ -508,6 +517,28 @@ requires credentials: username and password"
         results
       end
 
+      #Returns an array of arrays containing the field values.
+      #This is an implementation for the abstract method
+      #+sql+ is the select query and +name+ is an optional description for logging
+      def select_rows(sql, name = nil)
+        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
+        sql.gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
+        
+        results = []
+        # Invokes the method +execute+ in order to log and execute the SQL
+        # IBM_DB::Statement is returned from which results can be fetched
+        if stmt = execute(sql, name)
+          begin
+            @servertype.select_rows(sql, name, stmt, results)
+          ensure
+            # Ensures to free the resources associated with the statement
+            IBM_DB::free_result stmt
+          end
+        end
+        # The array of record hashes is returned
+        results
+      end
+      
       # Returns a record hash with the column names as keys and column values
       # as values.
       def select_one(sql, name = nil)
@@ -516,6 +547,64 @@ requires credentials: username and password"
         select_all(sql,name).first
       end
 
+      #inserts values from fixtures
+      #overridden to handle LOB's fixture insertion, as, in normal inserts callbacks are triggered but during fixture insertion callbacks are not triggered
+      #hence only markers like @@@IBMBINARY@@@ will be inserted and are not updated to actual data
+      def insert_fixture(fixture, table_name)
+        insert_query = "INSERT INTO #{quote_table_name(table_name)} ( #{fixture.key_list})"
+        insert_values = []
+        params = []
+        if @servertype.instance_of? IBM_IDS
+          super
+          return
+        end
+        column_list = columns(table_name)
+        fixture.each do |item|
+          col = nil
+          column_list.each do |col|
+            if col.name == item.at(0)
+              break
+            end
+          end
+          if item.at(1).nil? || 
+              item.at(1) == {} || 
+              (item.at(1) == '' && !(col.type.to_sym == :text))
+          
+                params << 'NULL'
+          
+          elsif col.type.to_sym == :xml ||
+                 col.type.to_sym == :text ||
+                    col.type.to_sym == :binary 
+            #  Add a '?' for the parameter or a NULL if the value is nil or empty 
+            # (except for a CLOB field where '' can be a value)
+             insert_values << item.at(1)
+             params << '?'
+          else
+            insert_values << quote(item.at(1),col)
+            params << '?'
+          end 
+        end
+    
+        insert_query << " VALUES ("+ params.join(',') + ")"
+        unless stmt = IBM_DB::prepare(@connection, insert_query)
+           error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+           if error_msg && !error_msg.empty?
+             raise "Failed to prepare statement due to : #{error_msg}"
+           else
+             raise StandardError('Unexpected error during insert')
+           end
+        end
+    
+        #log_query(insert_query,'fixture insert')
+        log(insert_query,'fixture insert') do
+          unless IBM_DB::execute(stmt, insert_values)
+            raise "Failed to insert due to: #{IBM_DB::stmt_errormsg(stmt)}"
+          else
+            IBM_DB::free_result stmt
+          end
+        end
+      end
+      
       # Perform an insert and returns the last ID generated.
       # This can be the ID passed to the method or the one auto-generated by the database,
       # and retrieved by the +last_generated_id+ method.
@@ -644,37 +733,45 @@ requires credentials: username and password"
           # (IBM_DB doesn't accept quotes on numeric types)
           when Numeric
             # If the column type is text or string, return the quote value
-            if column && column.type == :text || column && column.type == :string
-              "'#{value}'"
+            if column && column.type.to_sym == :text || column && column.type.to_sym == :string
+              unless caller[0] =~ /insert_fixture/i
+                  "'#{value}'"
+              else
+                  "#{value}"
+              end 
             else
               # value is Numeric, column.type is not a string,
               # therefore it converts the number to string without quoting it
               value.to_s
             end
           when String, ActiveSupport::Multibyte::Chars
-          if column && column.type == :binary
+          if column && column.type.to_sym == :binary
             # If quoting is required for the insert/update of a BLOB
-            unless caller[0] =~ /add_column_options/i
-              # Invokes a convertion from string to binary
+              unless caller[0] =~ /add_column_options/i
+                 # Invokes a convertion from string to binary
                 @servertype.set_binary_value
-            else
-              # Quoting required for the default value of a column
+              else
+                # Quoting required for the default value of a column
                 @servertype.set_binary_default(value)
               end
-          elsif column && column.type == :text
+          elsif column && column.type.to_sym == :text
               unless caller[0] =~ /add_column_options/i
                 "'@@@IBMTEXT@@@'"
               else
-                @servertype.set_text_default(value)
+                @servertype.set_text_default(quote_string(value))
               end
-          elsif column && column.type == :xml
+          elsif column && column.type.to_sym == :xml
               unless caller[0] =~ /add_column_options/i
                 "'<ibm>@@@IBMXML@@@</ibm>'"
               else
                 "#{value}"
               end
           else
-            "'#{quote_string(value)}'"
+              unless caller[0] =~ /insert_fixture/i
+                "'#{quote_string(value)}'"
+              else
+                "#{value}"
+              end 
           end
           when TrueClass then quoted_true    # return '1' for true
           when FalseClass then quoted_false  # return '0' for false
@@ -770,7 +867,9 @@ requires credentials: username and password"
             # Fetches all the records available
             while tab = IBM_DB::fetch_assoc(stmt)
               # Adds the lowercase table name to the array
-              tables << tab["table_name"].downcase
+              if(tab["table_type"]== 'TABLE')  #check, so that only tables are dumped,IBM_DB::tables also returns views,alias etc in the schema
+                tables << tab["table_name"].downcase    
+              end
             end
           ensure
             IBM_DB::free_result(stmt)  # Free resources associated with the statement
@@ -795,9 +894,7 @@ requires credentials: username and password"
         # If so it returns an empty array of columns.
         return [] if table_name.strip.empty?
 
-        # +index_array+ will contain the resulting array
         indexes = []
-        index_array = []
         pk_index = nil
         index_schema = []
         
@@ -809,18 +906,19 @@ requires credentials: username and password"
         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) )
-               pk_index_name = pk_index_row[5].downcase
-               pk_index_columns = pk_index_row[3].map{|c| c.downcase}           # COLUMN_NAME
-               if pk_index 
-                   pk_index.columns = "#{pk_index.columns} , #{pk_index_columns}"
-               else
-                    pk_index = IndexDefinition.new(table_name, pk_index_name, true, pk_index_columns)
-                   
+              if pk_index_row[5] 
+                pk_index_name = pk_index_row[5].downcase
+                pk_index_columns = pk_index_row[3].map{|c| c.downcase}           # COLUMN_NAME
+                if pk_index 
+                  pk_index.columns = pk_index.columns + pk_index_columns
+                else
+                  pk_index = IndexDefinition.new(table_name, pk_index_name, true, pk_index_columns)
                 end
+              end 
             end
-          ensure  # Free resources associated with the statement
+        ensure  # Free resources associated with the statement
             IBM_DB::free_result(stmt) if stmt
           end
         else  # Handle driver execution errors
@@ -838,58 +936,56 @@ requires credentials: username and password"
         # "NON_UNIQUE:   #{index_stats[3]}"
         # "INDEX_NAME:   #{index_stats[5]}"
         # "COLUMN_NAME:  #{index_stats[8]}"
-      if stmt = IBM_DB::statistics( @connection, nil, 
+        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].map{|c| c.downcase}     # COLUMN_NAME
-            index_qualifier = index_stats[4]             #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].map{|c| c.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.downcase
-            end 
-            
           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 ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
-          if error_msg && !error_msg.empty?
-            raise "Failed to retrieve index metadata due to error: #{error_msg}"
-          else
-            raise StandardError('Unexpected error during index retrieval')
-          end
+            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            if error_msg && !error_msg.empty?
+              raise "Failed to retrieve index metadata due to error: #{error_msg}"
+            else
+              raise StandardError('Unexpected error during index retrieval')
+            end
         end
     
-    # remove the primary key index entry.... shouldnt be dumped by the dumper
+        # remove the primary key index entry.... should not be dumped by the dumper
     
-      i = 0
-      indexes.each do |index|
-        unless index.columns == pk_index.columns
-          index.name = "#{index_schema[i]}.#{index.name}"
-          index_array << index
-        end
+        i = 0
+        indexes.each do |index|
+          if pk_index && index.columns == pk_index.columns
+        	 indexes.delete_at(i)
+	        end
           i = i+1
-      end 
+        end 
         # Returns the indexes array
-        return index_array
+        return indexes
       end
       
       # Returns an array of Column objects for the table specified by +table_name+
@@ -1004,6 +1100,29 @@ requires credentials: username and password"
         @servertype.change_column(table_name, column_name, type, options)
       end
 
+      #overrides the abstract adapter method to generate proper sql
+      #specifying the column options, like default value and nullability clause
+      def add_column_options!(sql,options={})
+        #add default null option only if :default option is not specified and 
+        #:null option is not specified or is true
+        if (options[:default].nil? && (options[:null].nil? || options[:null] == true))
+          sql << " DEFAULT NULL"
+        else  
+          if( !options[:default].nil?)
+              #check, :column option is passed only in case of create_table but not in case of add_column
+            if (!options[:column].nil?)   
+              sql << " DEFAULT #{quote(options[:default],options[:column])}"
+            else
+              sql << " DEFAULT #{quote(options[:default])}" 
+            end 
+          end 
+          #append NOT NULL to sql only---
+          #---if options[:null] is not nil and is equal to false
+          unless options[:null] == nil 
+             sql << " NOT NULL" if (options[:null] == false)
+          end
+        end   
+      end
       # Sets a new default value for a column. This does not set the default
       # value to +NULL+, instead, it needs DatabaseStatements#execute which
       # can execute the appropriate SQL statement for setting the value.
@@ -1042,7 +1161,7 @@ requires credentials: username and password"
       def last_generated_id(stmt)
       end
 
-      def create_index_after_table (table_name)
+      def create_index_after_table (table_name,cloumn_name)
       end
 
       def setup_for_lob_table ()
@@ -1083,6 +1202,16 @@ To remove the column, the table must be dropped and recreated without the #{colu
         end
       end
 
+      def select_rows(sql, name, stmt, results)
+        # 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
+        end
+      end
+      
       def execute(sql, name = nil)
         begin
           if stmt = IBM_DB::exec(@adapter.connection, sql)
@@ -1177,9 +1306,13 @@ The column datatype change to [#{data_type}] is not supported by this data serve
           end
         end
         reorg_table(table_name)
+        if !options[:null].nil? && !options[:null]
+          execute "ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL"
+        end 
         if !options[:default].nil?
           change_column_default(table_name, column_name, options[:default])
         end
+        reorg_table(table_name)
       end
 
       # DB2 specific ALTER TABLE statement to add a default clause
@@ -1262,6 +1395,64 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         @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)
+                  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
+        # Assign the instance variables to nil. We will not be using them again
+        @offset = nil
+        @limit = nil
+      end
+      
       def execute(sql, name = nil)
         # Check if there is a limit and/or an offset
         # If so then make sure and use a static cursor type
@@ -1322,7 +1513,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # This method generates the default clob value specified for 
       # DB2 Dataservers
       def set_text_default(value)
-        "#{value}"
+        "'#{value}'"
       end
 
       # For DB2 Dataservers , the arguments to the meta-data functions
@@ -1375,8 +1566,8 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
 
     class IBM_DB2_ZOS < IBM_DB2
       # since v9 doesn't need, suggest putting it in HostedDataServer?      
-      def create_index_after_table(table_name)
-        @adapter.add_index(table_name, "id", :unique => true) 
+      def create_index_after_table(table_name,column_name)
+        @adapter.add_index(table_name, column_name, :unique => true) 
       end
 
       def remove_column(table_name, column_name)
@@ -1440,7 +1631,11 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       end
 
       def change_column(table_name, column_name, type, options)
-        execute "ALTER TABLE #{table_name} MODIFY #{column_name} #{@adapter.type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
+        if !options[:null].nil? && !options[:null]
+          execute "ALTER TABLE #{table_name} MODIFY #{column_name} #{@adapter.type_to_sql(type, options[:limit], options[:precision], options[:scale])} NOT NULL"
+        else
+          execute "ALTER TABLE #{table_name} MODIFY #{column_name} #{@adapter.type_to_sql(type, options[:limit], options[:precision], options[:scale])}"  
+        end 
         if !options[:default].nil?
            change_column_default(table_name, column_name, options[:default])
         end