ibm_db 0.10.0 → 1.0.0

data/CHANGES

@@ -1,5 +1,20 @@
 Change Log
 ==============
+2008/11/06 (IBM_DB adapter 1.0.0, driver 0.10.0):
+  - Support for short-hand migration syntax for datatype char and double in create_table
+  - Support for short-hand migration syntax for datatypes xml, char and double in change_table
+  - Support for secure connections using SSL (SECURITY=SSL) feature of DB2 in Adapter
+      Note: - This is supported from client version V9.5fp2 and onwards
+  - Support for altering the nullability constraint of a column.
+  - Added correct mapping for datatype :double for DB2 and Informix (double precision)
+  - Method support_ddl_transactions? overridden to return true. Feature of Rails2.2 
+      IBM Dataservers support transactional migrations.
+  - Change in the style of accessing driver methods 
+      Changed from scope resolution operator to dot operator
+      IBM_DB::connect '<db_name>','<username>','<pwd>' to IBM_DB.connect '<db_name>','<username>','<pwd>'
+  - Fixed Bug [#22430] --> Fixed limit ignorance for type character [char]    
+  - ActiveRecord-2.1.2 test suite changes for IBM_DB   
+               
 2008/09/01 (IBM_DB adapter 0.10.0, driver 0.10.0):
   - Added Trusted Context support in Driver
   - Made changes for the correct Mapping of Informix DataTypes to Ruby DataTypes

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (0.10.0) and Driver (0.10.0) (2008/09/01)
+README for the IBM_DB Adapter (1.0.0) and Driver (0.10.0) (2008/11/06)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 
@@ -60,7 +60,7 @@ Note : -	1)	If using activerecord version below 2.0 then it requires that the ib
    D:\NewApp>irb
      irb(main):001:0> gem 'ibm_db'
      irb(main):002:0> require 'mswin32/ibm_db'   // notice the [mswin32] in the library path
-     irb(main):003:0> IBM_DB::connect 'sample', 'db2admin', 'secret'
+     irb(main):003:0> IBM_DB.connect 'sample', 'db2admin', 'secret'
    D:\NewApp>ruby script\console
 
 
@@ -99,7 +99,7 @@ Note : -	1)	If using activerecord version below 2.0 then it requires that the ib
    $ irb
      irb(main):001:0> gem 'ibm_db'
      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'
+     irb(main):003:0> IBM_DB.connect 'sample', 'db2admin', 'secret'
    $ 
 
   BUILD (optionally) ibm_db gem  from sources (ibm_db-x.x.x.tar.gz):

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -1,9 +1,11 @@
 # +----------------------------------------------------------------------+
 # |  Licensed Materials - Property of IBM                                |
 # |                                                                      |
-# | (C) Copyright IBM Corporation 2006, 2007.                            |
+# | (C) Copyright IBM Corporation 2006, 2007, 2008.                      |
 # +----------------------------------------------------------------------+
-# |  Author: Antonio Cangiano <cangiano@ca.ibm.com>                      |
+# |  Authors: Antonio Cangiano <cangiano@ca.ibm.com>                     |
+# |         : Mario Ds Briggs  <mario.briggs@in.ibm.com>                 |
+# |         : Praveen Devarao  <praveendrl@in.ibm.com>                   |
 # +----------------------------------------------------------------------+
 
 require 'active_record/connection_adapters/abstract_adapter'
@@ -62,8 +64,8 @@ module ActiveRecord
           end
           update_query << " WHERE #{self.class.primary_key} = #{id}"
 
-          unless stmt = IBM_DB::prepare(connection.connection, update_query)
-            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          unless stmt = IBM_DB.prepare(connection.connection, update_query)
+            error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
             if error_msg && !error_msg.empty?
               raise "Failed to rename table due to error: #{error_msg}"
             else
@@ -73,11 +75,11 @@ module ActiveRecord
           connection.log_query(update_query,'update of LOB/XML field(s)in handle_lobs')
 
           # rollback any failed LOB/XML field updates (and remove associated marker)
-          unless IBM_DB::execute(stmt, values)
+          unless IBM_DB.execute(stmt, values)
             connection.execute("ROLLBACK")
-            raise "Failed to insert/update LOB/XML field(s) due to: #{IBM_DB::stmt_errormsg(stmt)}"
+            raise "Failed to insert/update LOB/XML field(s) due to: #{IBM_DB.stmt_errormsg(stmt)}"
           else
-            IBM_DB::free_result stmt
+            IBM_DB.free_result stmt
           end
         end # if connection.sql
       end # if connection.kind_of?
@@ -138,7 +140,7 @@ requires credentials: username and password"
       end
 
       # Checks if a host name or address has been specified. If so, this implies a TCP/IP connection
-      # Returns IBM_DB::Connection object upon succesful DB connection to the database
+      # Returns IBM_DB.Connection object upon succesful DB connection to the database
       # If otherwise the connection fails, +false+ is returned
       if config.has_key?(:host)
         # Retrieves the host address/name
@@ -146,16 +148,22 @@ requires credentials: username and password"
         # A net address connection requires a port. If no port has been specified, 50000 is used by default
         port = config[:port] || 50000
         # Connects to the database using the database, host, port, username and password specified
-        connection = IBM_DB::connect "DRIVER={IBM DB2 ODBC DRIVER};\
-                                      DATABASE=#{database};\
-                                      HOSTNAME=#{host};\
-                                      PORT=#{port};\
-                                      PROTOCOL=TCPIP;\
-                                      UID=#{username};\
-                                      PWD=#{password};", '', '', conn_options
+        # Starting with DB2 9.1FP5 secure connections using SSL are supported. 
+        # On the client side using CLI this is supported from CLI version V95FP2 and onwards.
+        # This feature is set by specifying SECURITY=SSL in the connection string.
+        # Below connection string is constructed and SECURITY parameter is appended if the user has specified the :security option
+        conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
+                       DATABASE=#{database};\
+                       HOSTNAME=#{host};\
+                       PORT=#{port};\
+                       PROTOCOL=TCPIP;\
+                       UID=#{username};\
+                       PWD=#{password};"
+        conn_string << "SECURITY=#{config[:security]};" if config.has_key?(:security)
+        connection = IBM_DB.connect conn_string, '', '', conn_options
       else
         # No host implies a local catalog-based connection: +database+ represents catalog alias
-        connection = IBM_DB::connect( database, username, password, conn_options )
+        connection = IBM_DB.connect( database, username, password, conn_options )
       end
 
       # Verifies that the connection was succesfull
@@ -165,7 +173,7 @@ requires credentials: username and password"
         ConnectionAdapters::IBM_DBAdapter.new(connection, logger, config, conn_options)
       else
         # If the connection failed, it raises a Runtime error
-        raise "Failed to connect to the [#{database}] due to: #{IBM_DB::conn_errormsg}"
+        raise "Failed to connect to the [#{database}] due to: #{IBM_DB.conn_errormsg}"
       end
     end # method self.ibm_db_connection
   end # class Base
@@ -221,23 +229,87 @@ requires credentials: username and password"
           when /rowid/i  # rowid is a supported datatype on z/OS and i/5
             :rowid
         end
-       end # method simplified_type
-     end #class IBM_DBColumn
+      end # method simplified_type
+    end #class IBM_DBColumn
 
-    class TableDefinition
+    class Table
       
-      #Method to support the new syntax of rails 2.0 migrations for columns of type xml 
-      def xml(*args )
+      #Method to parse the passed arguments and create the ColumnDefinition object of the specified type
+      def ibm_parse_column_attributes_args(type, *args)
         options = {}
         if args.last.is_a?(Hash) 
           options = args.delete_at(args.length-1)
         end
         args.each do | name | 
-          column(name,'xml',options)
+          column name,type.to_sym,options
         end # end args.each
+      end
+      private :ibm_parse_column_attributes_args
+    
+      #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type xml 
+      #This method is different as compared to def char (sql is being issued explicitly 
+      #as compared to def char where method column(which will generate the sql is being called)
+      #in order to handle the DEFAULT and NULL option for the native XML datatype
+      def xml(*args ) 
+        options = {}
+        if args.last.is_a?(Hash) 
+          options = args.delete_at(args.length-1)
+        end
+        sql = "ALTER TABLE #{@base.quote_table_name(@table_name)} ADD COLUMN "
+        args.each do | name | 
+          sql << "#{@base.quote_column_name(name)} xml"
+          @base.execute(sql,"add_xml_column")
+        end  
+        return self
+      end
+
+      #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type double
+      def double(*args)
+        ibm_parse_column_attributes_args('double',*args)
+        return self
+      end
+      
+      #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
+      def char(*args)
+        ibm_parse_column_attributes_args('char',*args)
+        return self
+      end
+      alias_method :character, :char
+    end
+
+    class TableDefinition
+      
+      #Method to parse the passed arguments and create the ColumnDefinition object of the specified type
+      def ibm_parse_column_attributes_args(type, *args)
+        options = {}
+        if args.last.is_a?(Hash)
+          options = args.delete_at(args.length-1)
+        end
+        args.each do | name |
+          column(name,type,options)
+        end
+      end
+      private :ibm_parse_column_attributes_args
+      
+      #Method to support the new syntax of rails 2.0 migrations for columns of type xml 
+      def xml(*args )
+        ibm_parse_column_attributes_args('xml', *args)
+        return self
+      end
+      
+      #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type double
+      def double(*args)
+        ibm_parse_column_attributes_args('double',*args)
         return self
       end
       
+      #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
+      def char(*args)
+        ibm_parse_column_attributes_args('char',*args)
+        return self
+      end
+      alias_method :character, :char
+      
       # Overrides the abstract adapter in order to handle
       # the DEFAULT option for the native XML datatype
       def column(name, type, options ={})
@@ -296,6 +368,8 @@ requires credentials: username and password"
     # == remote TCP/IP connection (required when no local database catalog entry available)
     #   host:        'socrates'      // fully qualified hostname or IP address
     #   port:        '50000'         // data server TCP/IP port number
+    #   security:    'SSL'           // optional parameter enabling SSL encryption -
+    #                                // - Available only from CLI version V95fp2 and above
     # 
     # When schema is not specified, the username value is used instead.
     # 
@@ -321,7 +395,8 @@ requires credentials: username and password"
           @port   = config[:port] || 50000 # default port
         end
         @schema   = config[:schema]
-
+        @security = config[:security] || nil
+        
         # Caching database connection options (auditing and billing support)
         @app_user    = conn_options[:app_user]     if conn_options.has_key?(:app_user)
         @account     = conn_options[:account]      if conn_options.has_key?(:account)
@@ -333,7 +408,7 @@ requires credentials: username and password"
         super(@connection, logger)
 
         if @connection
-          server_info = IBM_DB::server_info( @connection )
+          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)
@@ -369,8 +444,8 @@ requires credentials: username and password"
       def app_user=(name)
         unless name == @app_user
           option = {IBM_DB::SQL_ATTR_INFO_USERID => "#{name}"}
-          if IBM_DB::set_option( @connection, option, 1 )
-            @app_user = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_USERID, 1 )
+          if IBM_DB.set_option( @connection, option, 1 )
+            @app_user = IBM_DB.get_option( @connection, IBM_DB::SQL_ATTR_INFO_USERID, 1 )
           end
         end
       end
@@ -379,8 +454,8 @@ requires credentials: username and password"
       def account=(name)
         unless name == @account
           option = {IBM_DB::SQL_ATTR_INFO_ACCTSTR => "#{name}"}
-          if IBM_DB::set_option( @connection, option, 1 )
-            @account = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_ACCTSTR, 1 )
+          if IBM_DB.set_option( @connection, option, 1 )
+            @account = IBM_DB.get_option( @connection, IBM_DB::SQL_ATTR_INFO_ACCTSTR, 1 )
           end
         end
       end
@@ -389,8 +464,8 @@ requires credentials: username and password"
       def application=(name)
         unless name == @application
           option = {IBM_DB::SQL_ATTR_INFO_APPLNAME => "#{name}"}
-          if IBM_DB::set_option( @connection, option, 1 )
-            @application = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_APPLNAME, 1 )
+          if IBM_DB.set_option( @connection, option, 1 )
+            @application = IBM_DB.get_option( @connection, IBM_DB::SQL_ATTR_INFO_APPLNAME, 1 )
           end
         end
       end
@@ -399,8 +474,8 @@ requires credentials: username and password"
       def workstation=(name)
         unless name == @workstation
           option = {IBM_DB::SQL_ATTR_INFO_WRKSTNNAME => "#{name}"}
-          if IBM_DB::set_option( @connection, option, 1 )
-            @workstation = IBM_DB::get_option( @connection, IBM_DB::SQL_ATTR_INFO_WRKSTNNAME, 1 )
+          if IBM_DB.set_option( @connection, option, 1 )
+            @workstation = IBM_DB.get_option( @connection, IBM_DB::SQL_ATTR_INFO_WRKSTNNAME, 1 )
           end
         end
       end
@@ -413,7 +488,14 @@ requires credentials: username and password"
       def supports_migrations?
         true
       end
-
+      
+      # This Adapter supports DDL transactions.
+      # This means CREATE TABLE and other DDL statements can be carried out as a transaction. 
+      # That is the statements executed can be ROLLED BACK in case of any error during the process.
+      def supports_ddl_transactions?
+        true
+      end
+      
       def log_query(sql, name) #:nodoc:
         # Used by handle_lobs
         log(sql,name){}
@@ -425,7 +507,7 @@ requires credentials: username and password"
 
       # Tests the connection status
       def active?
-        IBM_DB::active @connection
+        IBM_DB.active @connection
         rescue
           false
       end
@@ -435,18 +517,20 @@ requires credentials: username and password"
       def connect
         # If the type of connection is net based
         if @host
-          # Connects and assigns the resulting IBM_DB::Connection to the +@connection+ instance variable
-          @connection = IBM_DB::connect("DRIVER={IBM DB2 ODBC DRIVER};\
-                                         DATABASE=#{@database};\
-                                         HOSTNAME=#{@host};\
-                                         PORT=#{@port};\
-                                         PROTOCOL=TCPIP;\
-                                         UID=#{@username};\
-                                         PWD=#{@password};", '', '', @conn_options)
+          @conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
+                          DATABASE=#{@database};\
+                          HOSTNAME=#{@host};\
+                          PORT=#{@port};\
+                          PROTOCOL=TCPIP;\
+                          UID=#{@username};\
+                          PWD=#{@password};"
+          @conn_string << "SECURITY=#{@security};" if @security
+          # Connects and assigns the resulting IBM_DB.Connection to the +@connection+ instance variable
+          @connection = IBM_DB.connect(@conn_string, '', '', @conn_options)
         else
           # Connects to the database using the local alias (@database)
-          # and assigns the connection object (IBM_DB::Connection) to @connection
-          @connection = IBM_DB::connect(@database, @username, @password, @conn_options)
+          # and assigns the connection object (IBM_DB.Connection) to @connection
+          @connection = IBM_DB.connect(@database, @username, @password, @conn_options)
         end
         # Sets the schema if different from default (username)
         if @schema && @schema != @username
@@ -467,7 +551,7 @@ requires credentials: username and password"
         # * true if succesfull
         # * false if the connection is already closed
         # * nil if an error is raised
-        IBM_DB::close(@connection) rescue nil
+        IBM_DB.close(@connection) rescue nil
       end
 
       #==============================================
@@ -502,13 +586,13 @@ requires credentials: username and password"
         
         results = []
         # Invokes the method +execute+ in order to log and execute the SQL
-        # IBM_DB::Statement is returned from which results can be fetched
+        # IBM_DB.Statement is returned from which results can be fetched
         if stmt = execute(sql, name)
           begin
             @servertype.select_all(sql, name, stmt, results)
           ensure
             # Ensures to free the resources associated with the statement
-            IBM_DB::free_result stmt
+            IBM_DB.free_result stmt
           end
         end
         # The array of record hashes is returned
@@ -524,13 +608,13 @@ requires credentials: username and password"
         
         results = []
         # Invokes the method +execute+ in order to log and execute the SQL
-        # IBM_DB::Statement is returned from which results can be fetched
+        # 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
+            IBM_DB.free_result stmt
           end
         end
         # The array of record hashes is returned
@@ -584,8 +668,8 @@ requires credentials: username and password"
         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
+        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
@@ -595,10 +679,10 @@ requires credentials: username and password"
     
         #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)}"
+          unless IBM_DB.execute(stmt, insert_values)
+            raise "Failed to insert due to: #{IBM_DB.stmt_errormsg(stmt)}"
           else
-            IBM_DB::free_result stmt
+            IBM_DB.free_result stmt
           end
         end
       end
@@ -613,13 +697,13 @@ requires credentials: username and password"
             return id_value || @servertype.last_generated_id(stmt)
             # Ensures to free the resources associated with the statement
           ensure
-            IBM_DB::free_result(stmt)
+            IBM_DB.free_result(stmt)
           end
         end
       end
 
       # Executes and logs +sql+ commands and
-      # returns a +IBM_DB::Statement+ object.
+      # returns a +IBM_DB.Statement+ object.
       def execute(sql, name = nil)
         # Logs and execute the sql instructions.
         # The +log+ method is defined in the parent class +AbstractAdapter+
@@ -642,10 +726,10 @@ requires credentials: username and password"
           begin
             @sql = sql
             # Retrieves the number of affected rows
-            IBM_DB::num_rows(stmt)
+            IBM_DB.num_rows(stmt)
             # Ensures to free the resources associated with the statement
           ensure
-            IBM_DB::free_result(stmt)
+            IBM_DB.free_result(stmt)
           end
         end
       end
@@ -658,24 +742,24 @@ requires credentials: username and password"
       # Begins the transaction (and turns off auto-committing)
       def begin_db_transaction
         # Turns off the auto-commit
-        IBM_DB::autocommit(@connection, IBM_DB::SQL_AUTOCOMMIT_OFF)
+        IBM_DB.autocommit(@connection, IBM_DB::SQL_AUTOCOMMIT_OFF)
       end
 
       # Commits the transaction and turns on auto-committing
       def commit_db_transaction
         # Commits the transaction
-        IBM_DB::commit @connection rescue nil
+        IBM_DB.commit @connection rescue nil
         # Turns on auto-committing
-        IBM_DB::autocommit @connection, IBM_DB::SQL_AUTOCOMMIT_ON
+        IBM_DB.autocommit @connection, IBM_DB::SQL_AUTOCOMMIT_ON
       end
 
       # Rolls back the transaction and turns on auto-committing. Must be
       # done if the transaction block raises an exception or returns false
       def rollback_db_transaction
         # ROLLBACK the transaction
-        IBM_DB::rollback(@connection) rescue nil
+        IBM_DB.rollback(@connection) rescue nil
         # Turns on auto-committing
-        IBM_DB::autocommit @connection, IBM_DB::SQL_AUTOCOMMIT_ON
+        IBM_DB.autocommit @connection, IBM_DB::SQL_AUTOCOMMIT_ON
       end
 
 
@@ -829,7 +913,9 @@ requires credentials: username and password"
           :xml         => { :name => "xml"},
           :decimal     => { :name => "decimal" },
           :rowid       => { :name => "rowid" }, # rowid is a supported datatype on z/OS and i/5
-          :serial      => { :name => "serial" } # rowid is a supported datatype on Informix Dynamic Server
+          :serial      => { :name => "serial" }, # rowid is a supported datatype on Informix Dynamic Server
+          :char        => { :name => "char" },
+          :double      => { :name => @servertype.get_double_mapping }
         }
       end
 
@@ -839,8 +925,8 @@ requires credentials: username and password"
         return super if limit.nil?
 
         # strip off limits on data types not supporting them
-        if [:integer, :double, :date, :time, :timestamp, :xml].include? type
-          return type.to_s
+        if [:integer, :double, :date, :time, :timestamp, :xml].include? type.to_sym
+          return native_database_types[type.to_sym][:name].to_s
         elsif type.to_sym == :boolean
           return "smallint"
         else
@@ -859,21 +945,21 @@ requires credentials: username and password"
         # Initializes the tables array
         tables = []
         # Retrieve table's metadata through IBM_DB driver
-        if stmt = IBM_DB::tables(@connection, nil, 
+        if stmt = IBM_DB.tables(@connection, nil, 
                                  @servertype.set_case(@schema))
           begin
             # Fetches all the records available
-            while tab = IBM_DB::fetch_assoc(stmt)
+            while tab = IBM_DB.fetch_assoc(stmt)
               # Adds the lowercase table name to the array
-              if(tab["table_type"]== 'TABLE')  #check, so that only tables are dumped,IBM_DB::tables also returns views,alias etc in the schema
+              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
+            IBM_DB.free_result(stmt)  # Free resources associated with the statement
           end
         else # Handle driver execution errors
-          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve tables metadata due to error: #{error_msg}"
           else
@@ -901,11 +987,11 @@ requires credentials: username and password"
         #TABLE_NAME:: pk_index[2]
         #COLUMN_NAME:: pk_index[3]
         #PK_NAME:: pk_index[5]
-        if stmt = IBM_DB::primary_keys( @connection, nil, 
+        if stmt = IBM_DB.primary_keys( @connection, nil, 
                                       @servertype.set_case(@schema), 
                                       @servertype.set_case(table_name))
         begin
-            while ( pk_index_row = IBM_DB::fetch_array(stmt) )
+            while ( pk_index_row = IBM_DB.fetch_array(stmt) )
               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
@@ -917,10 +1003,10 @@ requires credentials: username and password"
               end 
             end
         ensure  # Free resources associated with the statement
-            IBM_DB::free_result(stmt) if stmt
+            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
+          error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve primary key metadata due to error: #{error_msg}"
           else
@@ -934,11 +1020,11 @@ 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) )
+          while ( index_stats = IBM_DB.fetch_array(stmt) )
               is_composite = false
             if index_stats[5]             # INDEX_NAME
               index_name = index_stats[5].downcase
@@ -962,10 +1048,10 @@ requires credentials: username and password"
             end
           end
         ensure  # Free resources associated with the statement
-          IBM_DB::free_result(stmt) if stmt
+          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
+            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
@@ -996,13 +1082,13 @@ requires credentials: username and password"
         # +columns+ will contain the resulting array
         columns = []
         # Statement required to access all the columns information
-        if stmt = IBM_DB::columns( @connection, nil, 
+        if stmt = IBM_DB.columns( @connection, nil, 
                                    @servertype.set_case(@schema), 
                                    @servertype.set_case(table_name) )
           begin
             # Fetches all the columns and assigns them to col.
             # +col+ is an hash with keys/value pairs for a column
-            while col = IBM_DB::fetch_assoc(stmt)
+            while col = IBM_DB.fetch_assoc(stmt)
               column_name = col["column_name"].downcase
               # Assigns the column default value.
               column_default_value = col["column_def"]
@@ -1041,17 +1127,17 @@ requires credentials: username and password"
               end
             end
           rescue StandardError  # Handle driver fetch errors
-            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
             if error_msg && !error_msg.empty?
               raise "Failed to retrieve column metadata during fetch: #{error_msg}"
             else
               raise
             end
           ensure  # Free resources associated with the statement
-            IBM_DB::free_result(stmt)
+            IBM_DB.free_result(stmt)
           end
         else  # Handle driver execution errors
-          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve column metadata due to error: #{error_msg}"
           else
@@ -1072,7 +1158,7 @@ requires credentials: username and password"
         stmt = execute(rename_table_sql)
         # Ensures to free the resources associated with the statement
         ensure
-          IBM_DB::free_result stmt if stmt
+          IBM_DB.free_result stmt if stmt
       end
 
       # Renames a column.
@@ -1121,6 +1207,7 @@ requires credentials: username and password"
           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.
@@ -1131,7 +1218,12 @@ requires credentials: username and password"
       def change_column_default(table_name, column_name, default)
         @servertype.change_column_default(table_name, column_name, default)
       end
-
+      
+      #Changes the nullability value of a column
+      def change_column_null(table_name, column_name, null, default = nil)
+        @servertype.change_column_null(table_name, column_name, null, default)
+      end
+      
       # Remove the given index from the table.
       #
       # Remove the suppliers_name_index in the suppliers table (legacy support, use the second or third forms).
@@ -1191,20 +1283,20 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def select_all(sql, name, stmt, results)
-        # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
+        # 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)
+        while single_hash = IBM_DB.fetch_assoc(stmt)
           # Add the record to the +results+ array
           results <<  single_hash
         end
       end
 
       def select_rows(sql, name, stmt, results)
-        # Fetches all the results available. IBM_DB::fetch_array(stmt) returns
+        # 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)
+        while single_array = IBM_DB.fetch_array(stmt)
           #Add the array to results array
           results <<  single_array
         end
@@ -1212,13 +1304,13 @@ To remove the column, the table must be dropped and recreated without the #{colu
       
       def execute(sql, name = nil)
         begin
-          if stmt = IBM_DB::exec(@adapter.connection, sql)
+          if stmt = IBM_DB.exec(@adapter.connection, sql)
             stmt   # Return the statement object
           else
-            raise StatementInvalid, IBM_DB::stmt_errormsg
+            raise StatementInvalid, IBM_DB.stmt_errormsg
           end
         rescue StandardError
-          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
           if error_msg && !error_msg.empty?
             raise "Failed to execute statement due to error: #{error_msg}"
           else
@@ -1240,9 +1332,15 @@ To remove the column, the table must be dropped and recreated without the #{colu
       def get_time_mapping
       end
 
+      def get_double_mapping
+      end
+    
       def change_column_default(table_name, column_name, default)
       end
 
+      def change_column_null(table_name, column_name, null, default)
+      end
+  
       def set_binary_default(value)
       end
 
@@ -1271,17 +1369,17 @@ To remove the column, the table must be dropped and recreated without the #{colu
       def last_generated_id(stmt)
         # Queries the db to obtain the last ID that was automatically generated
         sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
-        if stmt = IBM_DB::exec(@adapter.connection, sql)
+        if stmt = IBM_DB.exec(@adapter.connection, sql)
           begin
             # Fetches the only record available (containing the last id)
-            IBM_DB::fetch_row(stmt)
+            IBM_DB.fetch_row(stmt)
             # Retrieves and returns the result of the query with the last id.
-            IBM_DB::result(stmt,0)
+            IBM_DB.result(stmt,0)
           ensure  # Free resources associated with the statement
-            IBM_DB::free_result stmt
+            IBM_DB.free_result stmt
           end
         else
-          error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+          error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
           if error_msg && !error_msg.empty?
             raise "Failed to retrieve last generated id due to error: #{error_msg}"
           else
@@ -1304,25 +1402,45 @@ 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
+        change_column_null(table_name,column_name,options[:null],nil)
+        change_column_default(table_name, column_name, options[:default])
         reorg_table(table_name)
       end
 
       # DB2 specific ALTER TABLE statement to add a default clause
       def change_column_default(table_name, column_name, default)
         # SQL statement which alters column's default value
-        change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
+        if default.nil?
+          change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} DROP DEFAULT"   
+        else
+          change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
 SET WITH DEFAULT #{@adapter.quote(default)}"
+        end
         stmt = execute(change_column_sql)
+        reorg_table(table_name)
         ensure
-          IBM_DB::free_result stmt if stmt
+          IBM_DB.free_result stmt if stmt
       end
 
+      #DB2 specific ALTER TABLE statement to change the nullability of a column
+      def change_column_null(table_name, column_name, null, default)
+        if !default.nil?
+          change_column_default(table_name, column_name, default)
+        end 
+        reorg_table(table_name)
+        if !null.nil? 
+          if null
+            change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} DROP NOT NULL"
+          else
+            change_column_sql = "ALTER TABLE #{table_name} ALTER #{column_name} SET NOT NULL"
+          end     
+        end
+        stmt = execute(change_column_sql)
+        reorg_table(table_name)
+        ensure
+          IBM_DB.free_result stmt if stmt   
+      end
+    
       # This method returns the DB2 SQL type corresponding to the Rails
       # datetime/timestamp type
       def get_datetime_mapping
@@ -1335,21 +1453,26 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         return "time"
       end
 
-      # Fetches all the results available. IBM_DB::fetch_assoc(stmt) returns
+      #This method returns the DB2 SQL type corresponding to Rails double type
+      def get_double_mapping
+        return "double"
+      end
+      
+      # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
       # an hash for each single record.
       # The loop stops when there aren't any more valid records to fetch
       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
+          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)
+              if single_hash = IBM_DB.fetch_assoc(stmt, @offset + index + 1)
                 # Add the record to the +results+ array
                 results <<  single_hash
                 index = index + 1
@@ -1365,7 +1488,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
             # at @offset to @offset + @limit
             index = 0
             while (index < @offset + @limit)
-              if single_hash = IBM_DB::fetch_assoc(stmt)
+              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
@@ -1383,7 +1506,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           results
         # No limits or offsets specified
         else
-          while single_hash = IBM_DB::fetch_assoc(stmt)
+          while single_hash = IBM_DB.fetch_assoc(stmt)
             # Add the record to the +results+ array
             results <<  single_hash
           end
@@ -1393,21 +1516,21 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         @limit = nil
       end
 
-      # Fetches all the results available. IBM_DB::fetch_array(stmt) returns
+      # 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
+          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)
+              if single_array = IBM_DB.fetch_array(stmt, @offset + index + 1)
                 # Add the array to the +results+ array
                 results <<  single_array
                 index = index + 1
@@ -1423,7 +1546,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
             # at @offset to @offset + @limit
             index = 0
             while (index < @offset + @limit)
-              if single_array = IBM_DB::fetch_array(stmt)
+              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
@@ -1441,7 +1564,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           results
         # No limits or offsets specified
         else
-          while single_array = IBM_DB::fetch_array(stmt)
+          while single_array = IBM_DB.fetch_array(stmt)
             # Add the array to the +results+ array
             results <<  single_array
           end
@@ -1457,14 +1580,14 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
           begin
             # Set the cursor type to static so we can later utilize the offset and limit correctly
-            if stmt = IBM_DB::exec(@adapter.connection, sql, 
+            if stmt = IBM_DB.exec(@adapter.connection, sql, 
                       {IBM_DB::SQL_ATTR_CURSOR_TYPE => IBM_DB::SQL_CURSOR_STATIC})
               stmt   # Return the statement object
             else
-              raise StatementInvalid, IBM_DB::stmt_errormsg
+              raise StatementInvalid, IBM_DB.stmt_errormsg
             end
           rescue StandardError
-            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
             if error_msg && !error_msg.empty?
               raise "Failed to execute statement due to error: #{error_msg}"
             else
@@ -1473,13 +1596,13 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           end
         else
           begin
-            if stmt = IBM_DB::exec(@adapter.connection, sql)
+            if stmt = IBM_DB.exec(@adapter.connection, sql)
               stmt   # Return the statement object
             else
-              raise StatementInvalid, IBM_DB::stmt_errormsg
+              raise StatementInvalid, IBM_DB.stmt_errormsg
             end
           rescue StandardError
-            error_msg = IBM_DB::conn_errormsg ? IBM_DB::conn_errormsg : IBM_DB::stmt_errormsg
+            error_msg = IBM_DB.conn_errormsg ? IBM_DB.conn_errormsg : IBM_DB.stmt_errormsg
             if error_msg && !error_msg.empty?
               raise "Failed to execute statement due to error: #{error_msg}"
             else
@@ -1587,6 +1710,11 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           super
         end
       end
+      
+      def change_column_null(table_name, column_name, null, default)
+        raise NotImplementedError,
+        "DB2 for zOS data server does not support changing the column's nullability"
+      end
     end # class IBM_DB2_ZOS
 
     class IBM_DB2_ZOS_8 < IBM_DB2_ZOS
@@ -1609,6 +1737,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         raise NotImplementedError,
         "DB2 for zOS data server version 8 does not support changing the column default"
       end
+     
     end # class IBM_DB2_ZOS_8
     
     class IBM_DB2_I5 < IBM_DB2
@@ -1645,17 +1774,45 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # DEFAULT clause
       def change_column_default(table_name, column_name, default)
         sql_type = nil
+        is_nullable = true
         @adapter.columns(table_name).select do |col| 
            if (col.name == column_name)
               sql_type =  @adapter.type_to_sql(col.type, col.limit, col.precision, col.scale)
+              is_nullable = col.null 
            end
         end
         # SQL statement which alters column's default value
         change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type} DEFAULT #{@adapter.quote(default)}"
+        change_column_sql << " NOT NULL" unless is_nullable 
         stmt = execute(change_column_sql)
+        reorg_table(table_name)
         # Ensures to free the resources associated with the statement
         ensure
-          IBM_DB::free_result stmt if stmt
+          IBM_DB.free_result stmt if stmt
+      end
+
+      # IDS specific ALTER TABLE statement to change the nullability of a column
+      def change_column_null(table_name,column_name,null,default)
+        if !default.nil?
+          change_column_default table_name, column_name, default
+        end
+        sql_type = nil
+        @adapter.columns(table_name).select do |col| 
+          if (col.name == column_name)
+            sql_type =  @adapter.type_to_sql(col.type, col.limit, col.precision, col.scale)
+          end
+        end
+        if !null.nil?
+          if !null
+            change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type} NOT NULL"
+          else
+            change_column_sql = "ALTER TABLE #{table_name} MODIFY #{column_name} #{sql_type}"     
+          end 
+        end
+        stmt = execute(change_column_sql)
+        reorg_table(table_name)
+        ensure
+          IBM_DB.free_result stmt if stmt
       end
 
       # Reorganizes the table for column changes
@@ -1675,6 +1832,11 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         return "datetime hour to second"
       end
 
+      # This method returns the IDS SQL type corresponding to Rails double type
+      def get_double_mapping
+        return "double precision"
+      end
+
       # Handling offset/limit as per Informix requirements
       def query_offset_limit(sql, offset, limit)
         if limit != 0
@@ -1699,7 +1861,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # IDENTITY_VAL_LOCAL function. We used the "stmt" parameter to identify 
       # the statement resource from which to get the last generated value
       def last_generated_id(stmt)
-        IBM_DB::get_last_serial_value(stmt)
+        IBM_DB.get_last_serial_value(stmt)
       end
 
       # This method throws an error when trying to create a default value on a