ibm_db 5.2.0-x86-mingw32 → 5.3.2-x86-mingw32

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -1,7 +1,7 @@
 # +----------------------------------------------------------------------+
 # |  Licensed Materials - Property of IBM                                |
 # |                                                                      |
-# | (C) Copyright IBM Corporation 2006- 2018           					 |
+# | (C) Copyright IBM Corporation 2006 - 2022          					 |
 # +----------------------------------------------------------------------+
 # |  Authors: Antonio Cangiano <cangiano@ca.ibm.com>                     |
 # |         : Mario Ds Briggs  <mario.briggs@in.ibm.com>                 |
@@ -15,157 +15,190 @@ require 'arel/visitors/visitor'
 require 'active_support/core_ext/string/strip'
 require 'active_record/type'
 require 'active_record/connection_adapters/sql_type_metadata'
-
-
+require "active_record/connection_adapters/statement_pool"
+require 'active_record/connection_adapters'
 
 module CallChain
   def self.caller_method(depth=1)
-		parse_caller(caller(depth+1).first).last
-	end
-
-	private
+	parse_caller(caller(depth+1).first).last
+  end
 
-	# Copied from ActionMailer
-  def self.parse_caller(at)
-		if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
-			file   = Regexp.last_match[1]
-			line   = Regexp.last_match[2].to_i
-			method = Regexp.last_match[3]
-			[file, line, method]
-		end
-	end
+  private
+    # Copied from ActionMailer
+    def self.parse_caller(at)
+	  if /^(.+?):(\d+)(?::in `(.*)')?/ =~ at
+        file   = Regexp.last_match[1]
+        line   = Regexp.last_match[2].to_i
+        method = Regexp.last_match[3]
+        [file, line, method]
+      end
+    end
 end
 
-
 module ActiveRecord
-
-
-	class SchemaMigration < ActiveRecord::Base
-		class << self
+  class SchemaMigration < ActiveRecord::Base
+    class << self
       def create_table
-			  #puts "Calling method : " << CallChain.caller_method << "\n"
-        #puts "Calling method for create_table(): " << String(caller(start=1, length=nil) )
-				unless table_exists?
-					version_options = connection.internal_string_options_for_primary_key
-				  
-					connection.create_table(table_name,id:false) do |t|
-						t.string :version, version_options
-					end
+        unless connection.table_exists?(table_name)
+          connection.create_table(table_name, id: false) do |t|
+            t.string :version, **connection.internal_string_options_for_primary_key
+          end
+        end
       end
-			end
-		end
 	end
-  
-  
- 
-	class Relation
+  end
 
-    def insert(values)
-			primary_key_value = nil
+  module ConnectionAdapters
+    class SchemaDumper
+      private
+        def default_primary_key?(column)
+          schema_type(column) == :integer
+        end
 
-			if primary_key && Hash === values
-				primary_key_value = values[values.keys.find { |k|
-				k.name == primary_key
-			}]
+        def explicit_primary_key_default?(column)
+          column.bigint? and column.name == 'id'
+        end
+     end
 
-				if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
-					primary_key_value = connection.next_sequence_value(klass.sequence_name)
-					values[klass.arel_table[klass.primary_key]] = primary_key_value
-				end
-			end
+    class SchemaCreation
+      private
+        def visit_TableDefinition(o)
+          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
+          create_sql << "IF NOT EXISTS " if o.if_not_exists
+          create_sql << "#{quote_table_name(o.name)} "
 
-			im = arel.create_insert
-			im.into @table
+          statements = o.columns.map { |c| accept c }
+          statements << accept(o.primary_keys) if o.primary_keys
 
-			conn = @klass.connection
+          if supports_indexes_in_create?
+            statements.concat(o.indexes.map { |column_name, options| index_in_create(o.name, column_name, options) })
+          end
 
-			substitutes = values.sort_by { |arel_attr,_| arel_attr.name }
-			binds       = substitutes.map do |arel_attr, value|
-				[@klass.columns_hash[arel_attr.name], value]
-			end
+          if supports_foreign_keys?
+            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+          end
 
-			#substitutes.each_with_index do |tuple, i|
-			#  tuple[1] = conn.substitute_at(binds[i][0], i)
-			#end
+          if supports_check_constraints?
+            statements.concat(o.check_constraints.map { |expression, options| check_constraint_in_create(o.name, expression, options) })
+          end
 
-			substitutes, binds = substitute_values values
+          create_sql << "(#{statements.join(', ')})" if statements.present?
+          add_table_options!(create_sql, o)
+          create_sql << " AS (#{to_sql(o.as)}) WITH DATA" if o.as
+          create_sql
+        end
 
+        def add_column_options!(sql, options)
+          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          if options[:auto_increment] == true
+            sql << " GENERATED BY DEFAULT AS IDENTITY (START WITH 1000)"
+          end
+          if options[:primary_key] == true
+            sql << " PRIMARY KEY"
+          end
+          # must explicitly check for :null to allow change_column to work on migrations
+          if options[:null] == false
+            sql << " NOT NULL"
+          end
+          sql
+        end
+    end
+  end
+ 
+  class Relation
 
-			if values.empty? # empty insert
-				im.values = Arel.sql(connection.empty_insert_statement_value(klass.primary_key))
-			else
-				im.insert substitutes
-			end
-			conn.insert(
-				im,
-				'SQL',
-				primary_key,
-				primary_key_value,
-				nil,
-				binds)
-		end
-	end
-	
-	
+    def insert(values)
+      primary_key_value = nil
 
-	class Base
+      if primary_key && Hash === values
+        primary_key_value = values[values.keys.find { |k|
+        k.name == primary_key
+        }]
+
+        if !primary_key_value && connection.prefetch_primary_key?(klass.table_name)
+          primary_key_value = connection.next_sequence_value(klass.sequence_name)
+          values[klass.arel_table[klass.primary_key]] = primary_key_value
+        end
+      end
+
+      im = arel.create_insert
+	  im.into @table
+
+      conn = @klass.connection
+      substitutes = values.sort_by { |arel_attr,_| arel_attr.name }
+      binds       = substitutes.map do |arel_attr, value|
+        [@klass.columns_hash[arel_attr.name], value]
+      end
+
+      substitutes, binds = substitute_values values
+      if values.empty? # empty insert
+        im.values = Arel.sql(connection.empty_insert_statement_value(klass.primary_key, klass.table_name))
+      else
+		im.insert substitutes
+      end
+
+      conn.insert(im, 'SQL', primary_key, primary_key_value, nil, binds)
+    end
+  end
+
+  class Base
     # Method required to handle LOBs and XML fields. 
     # An after save callback checks if a marker has been inserted through
     # the insert or update, and then proceeds to update that record with 
     # the actual large object through a prepared statement (param binding).
     after_save :handle_lobs
-    def handle_lobs()	  
-		if self.class.connection.kind_of?(ConnectionAdapters::IBM_DBAdapter)
-			# Checks that the insert or update had at least a BLOB, CLOB or XML field
-			self.class.connection.sql.each do |clob_sql|
-				if clob_sql =~ /BLOB\('(.*)'\)/i || 
-					clob_sql =~ /@@@IBMTEXT@@@/i || 
-					clob_sql =~ /@@@IBMXML@@@/i ||
-					clob_sql =~ /@@@IBMBINARY@@@/i 
-					update_query = "UPDATE #{self.class.table_name} SET ("
-					counter = 0
-					values = []
-					params = []
-					# Selects only binary, text and xml columns
-					self.class.columns.select{|col| col.sql_type.to_s =~ /blob|binary|clob|text|xml/i }.each do |col|		
-						
-						if counter == 0
-							update_query << "#{col.name}"
-						else
-							update_query << ",#{col.name}"
-						end
-
-						# 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)
-						if self[col.name].nil? || 
-							self[col.name] == {} || 
-							self[col.name] == [] ||                
-							(self[col.name] == '' && !(col.sql_type.to_s =~ /text|clob/i))	
-								params << 'NULL'
-						else
-							if (col.cast_type.is_a?(::ActiveRecord::Type::Serialized))				
-							values << YAML.dump(self[col.name])		
-						else				  
-							values << self[col.name]		
-						end
-						params << '?'
-					end
-					counter += 1
-				end
-				# no subsequent update is required if no relevant columns are found
-				next if counter == 0
-
-				update_query << ") = "
-				# IBM_DB accepts 'SET (column) = NULL'  but not (NULL),
-				# therefore the sql needs to be changed for a single NULL field.
-				if params.size==1 && params[0] == 'NULL'
-					update_query << "NULL"
-				else
-					update_query << "(" + params.join(',') + ")"
-				end
-
-				update_query << " WHERE #{self.class.primary_key} = ?"
-				values << self[self.class.primary_key.downcase]
+    def handle_lobs()
+      if self.class.connection.kind_of?(ConnectionAdapters::IBM_DBAdapter)
+        # Checks that the insert or update had at least a BLOB, CLOB or XML field
+        self.class.connection.sql.each do |clob_sql|
+          if clob_sql =~ /BLOB\('(.*)'\)/i ||
+             clob_sql =~ /@@@IBMTEXT@@@/i  ||
+             clob_sql =~ /@@@IBMXML@@@/i   ||
+             clob_sql =~ /@@@IBMBINARY@@@/i
+            update_query = "UPDATE #{self.class.table_name} SET ("
+            counter = 0
+            values = []
+            params = []
+            # Selects only binary, text and xml columns
+            self.class.columns.select{|col| col.sql_type.to_s =~ /blob|binary|clob|text|xml/i }.each do |col|
+              if counter == 0
+                update_query << "#{col.name}"
+              else
+                update_query << ",#{col.name}"
+              end
+
+              # 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)
+              if self[col.name].nil?  ||
+                 self[col.name] == {} ||
+                 self[col.name] == [] ||
+                (self[col.name] == '' && !(col.sql_type.to_s =~ /text|clob/i))
+                params << 'NULL'
+              else
+                if (col.cast_type.is_a?(::ActiveRecord::Type::Serialized))
+                  values << YAML.dump(self[col.name])
+                else
+                  values << self[col.name]
+                end
+                params << '?'
+              end
+              counter += 1
+            end
+
+            # no subsequent update is required if no relevant columns are found
+            next if counter == 0
+
+            update_query << ") = "
+            # IBM_DB accepts 'SET (column) = NULL'  but not (NULL),
+            # therefore the sql needs to be changed for a single NULL field.
+            if params.size==1 && params[0] == 'NULL'
+              update_query << "NULL"
+            else
+              update_query << "(" + params.join(',') + ")"
+            end
+
+            update_query << " WHERE #{self.class.primary_key} = ?"
+            values << self[self.class.primary_key.downcase]
 
             begin
               unless stmt = IBM_DB.prepare(self.class.connection.connection, update_query)
@@ -176,14 +209,15 @@ module ActiveRecord
                   raise StandardError.new('An unexpected error occurred during update of LOB/XML column')
                 end
               end
-              self.class.connection.log_query(update_query,'update of LOB/XML field(s)in handle_lobs')
+
+			  self.class.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)
                 error_msg = "Failed to insert/update LOB/XML field(s) due to: #{IBM_DB.getErrormsg( stmt, IBM_DB::DB_STMT )}"
                 self.class.connection.execute("ROLLBACK")
                 raise error_msg
-              end
+               end
             rescue StandardError => error
               raise error
             ensure
@@ -194,8 +228,8 @@ module ActiveRecord
         self.class.connection.handle_lobs_triggered = true
       end # if connection.kind_of?
     end # handle_lobs
-    private :handle_lobs
 
+	private :handle_lobs
 	
     # Establishes a connection to a specified database using the credentials provided
     # with the +config+ argument. All the ActiveRecord objects will use this connection
@@ -208,10 +242,6 @@ module ActiveRecord
         raise LoadError, "Failed to load IBM_DB Ruby driver."
       end
 
-      #if( config.has_key?(:parameterized) && config[:parameterized] == true )
-       # require 'active_record/connection_adapters/ibm_db_pstmt'
-     # end
-
 	  # Check if class TableDefinition responds to indexes method to determine if we are on AR 3 or AR 4.
 	  # This is a interim hack ti ensure backward compatibility. To remove as we move out of AR 3 support or have a better way to determine which version of AR being run against.
       checkClass = ActiveRecord::ConnectionAdapters::TableDefinition.new(self,nil)
@@ -326,381 +356,308 @@ module ActiveRecord
     end
   end # class Base
 
-  
-
   module ConnectionAdapters
 	class Column 
-		def self.binary_to_string(value)
-			# Returns a string removing the eventual BLOB scalar function
-			value.to_s.gsub(/"SYSIBM"."BLOB"\('(.*)'\)/i,'\1')
-		end
-	end
+      def self.binary_to_string(value)
+        puts_log "binary_to_string"
+        # Returns a string removing the eventual BLOB scalar function
+        value.to_s.gsub(/"SYSIBM"."BLOB"\('(.*)'\)/i,'\1')
+      end
+    end
     	
 	module Quoting
-    def lookup_cast_type_from_column(column) # :nodoc:
-		  lookup_cast_type(column.sql_type_metadata)
-    end		
+      def lookup_cast_type_from_column(column) # :nodoc:
+        lookup_cast_type(column.sql_type_metadata.sql_type)
+      end
 	end
 	
 	module Savepoints
-    def create_savepoint(name = current_savepoint_name)
-			execute("SAVEPOINT #{name} ON ROLLBACK RETAIN CURSORS")
-		end
+      def create_savepoint(name = current_savepoint_name)
+        puts_log "create_savepoint"
+	    execute("SAVEPOINT #{name} ON ROLLBACK RETAIN CURSORS", "TRANSACTION")
+	  end
 	end
 	
 	
 	module ColumnDumper
       def prepare_column_options(column)
-			spec = {}
-						
-			if limit = schema_limit(column)
-			  spec[:limit] = limit
-			end
-						
-			if precision = schema_precision(column)
-			  spec[:precision] = precision
-			end
+        puts_log "prepare_column_options"
+        spec = {}
+
+        if limit = schema_limit(column)
+          spec[:limit] = limit
+        end
+
+        if precision = schema_precision(column)
+          spec[:precision] = precision
+        end
 					
-			if scale = schema_scale(column)
-			  spec[:scale] = scale
-			end
-						
-			default = schema_default(column) if column.has_default?
-			spec[:default]   = default unless default.nil?
+        if scale = schema_scale(column)
+          spec[:scale] = scale
+        end
 						
-			spec[:null] = 'false' unless column.null
+        default = schema_default(column) if column.has_default?
+        spec[:default]   = default unless default.nil?
+        spec[:null] = 'false' unless column.null
 
-			if collation = schema_collation(column)
-			  spec[:collation] = collation
-			end
+        if collation = schema_collation(column)
+          spec[:collation] = collation
+        end
 						
-			spec[:comment] = column.comment.inspect if column.comment.present?
+        spec[:comment] = column.comment.inspect if column.comment.present?
 			
-			spec
-		  end
-		  
-		  
-		def schema_limit(column)
-			limit = column.limit unless column.bigint?
-			#limit.inspect if limit && limit != native_database_types[column.type][:limit]
-			
-			limit.inspect if limit && limit != native_database_types[column.type.to_sym][:limit]
-			
-		end
-		  
-=begin
-			def column_spec_for_primary_key(column)
-			  if column.bigint?
-				spec = { id: :bigint.inspect }
-				spec[:default] = schema_default(column) || 'nil' unless column.auto_increment?
-			  else
-				#spec = super
-			  end
-			  #spec[:unsigned] = 'true' if column.unsigned?
-			  #spec
-			  ""
-			end
-=end  
+        spec
+      end
 
-	end
+      def schema_limit(column)
+        puts_log "schema_limit"
+        limit = column.limit unless column.bigint?
+        limit.inspect if limit && limit != native_database_types[column.type.to_sym][:limit]
+      end
+    end #end of module ColumnDumper
 
     module SchemaStatements
-	
-    def internal_string_options_for_primary_key # :nodoc:
-			{ primary_key: true}		
-			{ version_options: "PRIMARY KEY NOT NULL"}					
-		 end
+
+      def internal_string_options_for_primary_key # :nodoc:
+        { primary_key: true, null: false }
+      end
 		
-    def drop_table(table_name,options={})
-      execute("DROP TABLE #{quote_table_name(table_name)}", options)
-      #execute("DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}"
-		end
+      def drop_table(table_name, options={})
+        puts_log "drop_table"
+        if options[:if_exists]
+          execute("DROP TABLE IF EXISTS #{quote_table_name(table_name)}")
+        else
+          execute("DROP TABLE #{quote_table_name(table_name)}", options)
+        end
+      end
 	   
-=begin
-	  def create_table_definition(name, temporary, options,as = nil)
-        TableDefinition.new self, name, temporary, options
+      def create_table_definition(*args, **options)
+        puts_log "create_table_definition"
+        TableDefinition.new(self, *args, **options)
       end
-=end	  
-    def create_table_definition(*args, **options)
-			TableDefinition.new(self, *args, **options)
-		end
 	  
-    def remove_foreign_key(from_table, options_or_to_table = {})
-			return unless supports_foreign_keys?
-
-			if options_or_to_table.is_a?(Hash)		  
-			  options = options_or_to_table
-			else		  
-			  options = { column: foreign_key_column_for(options_or_to_table) }
-			end
-			
-			fk_name_to_delete = options.fetch(:name) do          
-			  fk_to_delete = foreign_keys(@servertype.set_case(from_table)).detect {|fk| "#{@servertype.set_case(fk.column)}" == "#{servertype.set_case(options[:column])}"}
-					  
-				if fk_to_delete
-					fk_to_delete.name
-				else
-					raise ArgumentError, "Table '#{from_table}' has no foreign key on column '#{options[:column]}'"
-				end
-			end
-			
-			at = create_alter_table from_table
-			at.drop_foreign_key fk_name_to_delete
-
-			execute schema_creation.accept(at)
-		end
 	end #end of Module SchemaStatements
-	
-		
-    #class IBM_DBColumn < Column
-	class IBM_DBColumn < ConnectionAdapters::Column # :nodoc:
-	#	delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
-	
-    def initialize(*)
-        super
-		end 
-		 
-		#def initialize(column_name, column_default_value, sqltype_metadata, column_nullable, table_name, default_function, collation, comment)        
-			#super(column_name, column_default_value, sqltype_metadata, column_nullable, table_name)		
-		#end
-	  
-      # Casts value (which is a String) to an appropriate instance
-=begin	  
-      def type_cast(value)
-        # Casts the database NULL value to nil
-        return nil if value == 'NULL'
-        # Invokes parent's method for default casts
+
+    class IBM_DBColumn < ConnectionAdapters::Column # :nodoc:
+      def initialize(*)
+        puts_log "15"
         super
       end
-=end
 
-		# Used to convert from BLOBs to Strings
-		def self.binary_to_string(value)
-			# Returns a string removing the eventual BLOB scalar function
-			value.to_s.gsub(/"SYSIBM"."BLOB"\('(.*)'\)/i,'\1')
-		end
-              
+      # Used to convert from BLOBs to Strings
+      def self.binary_to_string(value)
+        # Returns a string removing the eventual BLOB scalar function
+        value.to_s.gsub(/"SYSIBM"."BLOB"\('(.*)'\)/i,'\1')
+      end
     end #class IBM_DBColumn
 
-    
-	module ColumnMethods
-	
+    module ColumnMethods
       def primary_key(name, type = :primary_key, **options)
-			  column(name, type, options.merge(primary_key: true))
-		  end
+        puts_log "16"
+        column(name, type, options.merge(primary_key: true))
+      end
 	  
-		##class Table 
-		 class Table < ActiveRecord::ConnectionAdapters::Table
-		   include ColumnMethods
+      ##class Table
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include ColumnMethods
 		  
-		  #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.to_sym,options
-			end # end args.each
-		  end
-		  private :ibm_parse_column_attributes_args
+        #Method to parse the passed arguments and create the ColumnDefinition object of the specified type
+        def ibm_parse_column_attributes_args(type, *args)
+          puts_log "ibm_parse_column_attributes_args"
+          options = {}
+          if args.last.is_a?(Hash)
+            options = args.delete_at(args.length-1)
+          end
+          args.each do | name |
+            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_segment = "ALTER TABLE #{@base.quote_table_name(@table_name)} ADD COLUMN "
-			args.each do | name | 
-			  sql =  sql_segment + " #{@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 decfloat
-		  def decfloat(*args)
-			ibm_parse_column_attributes_args('decfloat',*args)
-			return self
-		  end
-
-		  def graphic(*args)
-			ibm_parse_column_attributes_args('graphic',*args)
-			return self
-		  end
+        #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 )
+          puts_log "18"
+          options = {}
+          if args.last.is_a?(Hash)
+            options = args.delete_at(args.length-1)
+          end
+          sql_segment = "ALTER TABLE #{@base.quote_table_name(@table_name)} ADD COLUMN "
+          args.each do | name |
+            sql =  sql_segment + " #{@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)
+          puts_log "19"
+		  ibm_parse_column_attributes_args('double',*args)
+		  return self
+		end
 
-		  def vargraphic(*args)
-			ibm_parse_column_attributes_args('vargraphic',*args)
-			return self
-		  end
+		#Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type decfloat
+		def decfloat(*args)
+          puts_log "20"
+		  ibm_parse_column_attributes_args('decfloat',*args)
+		  return self
+		end
 
-		  def bigint(*args)
-			ibm_parse_column_attributes_args('bigint',*args)
-			return self
-		  end
+		def graphic(*args)
+          puts_log "21"
+	      ibm_parse_column_attributes_args('graphic',*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
+		def vargraphic(*args)
+          puts_log "22"
+		  ibm_parse_column_attributes_args('vargraphic',*args)
+		  return self
 		end
 
-		#class TableDefinition    
-		class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
-		 include ColumnMethods
+		def bigint(*args)
+          puts_log "23"
+		  ibm_parse_column_attributes_args('bigint',*args)
+		  return self
+		end
 
-=begin
-		  def initialize(base, name=nil, temporary=nil, options=nil)
+		#Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
+		def char(*args)
+          puts_log "24"
+		  ibm_parse_column_attributes_args('char',*args)
+		  return self
+		end
+	    alias_method :character, :char
 
-			if(self.respond_to?(:indexes))
-			  @ar3 = false
-			else
-			  @ar3 = true
-			end
+      end # end of class Table
 
-			@columns = []
-			@columns_hash = {}
-			@indexes = {}
-			@base = base
-			@temporary = temporary
-			@options = options
-			@name = name
-			@foreign_keys = {}
-		  end
-=end
-		  
-		 def initialize(conn, name, temporary = false, options = nil, as = nil, comment: nil)
-			@connection = conn
-			@columns_hash = {}
-			@indexes = []
-			@foreign_keys = []
-			@primary_keys = nil
-			@temporary = temporary
-			@options = options
-			@as = as
-			@name = name
-			@comment = comment
-			##
-			#@base = base
-		  end
-		  
-		   def primary_keys(name = nil) # :nodoc:
-			@primary_keys = PrimaryKeyDefinition.new(name) if name
-			@primary_keys
-		  end
+	  class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+	    include ColumnMethods
 
-		  def native
-			@base.native_database_types
-		  end
+	    def native
+          puts_log "25"
+		  @base.native_database_types
+		end
 	 
-		  #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
+		#Method to parse the passed arguments and create the ColumnDefinition object of the specified type
+	    def ibm_parse_column_attributes_args(type, *args)
+          puts_log "26"
+          options = {}
+		  if args.last.is_a?(Hash)
+			options = args.delete_at(args.length-1)
 		  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
+		  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 (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 for columns of type xml 
+		def xml(*args )
+          puts_log "27"
+		  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 decfloat
-		  def decfloat(*args)
-			ibm_parse_column_attributes_args('decfloat',*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)
+          puts_log "28"
+		  ibm_parse_column_attributes_args('double',*args)
+		  return self
+		end
 
-		  def graphic(*args)
-			ibm_parse_column_attributes_args('graphic',*args)
-			return self
-		  end
+		#Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type decfloat
+		def decfloat(*args)
+          puts_log "29"
+		  ibm_parse_column_attributes_args('decfloat',*args)
+		  return self
+		end
 
-		  def vargraphic(*args)
-			ibm_parse_column_attributes_args('vargraphic',*args)
-			return self
-		  end
+		def graphic(*args)
+          puts_log "30"
+	      ibm_parse_column_attributes_args('graphic',*args)
+		  return self
+		end
 
-		  def bigint(*args)
-			ibm_parse_column_attributes_args('bigint',*args)
-			return self
-		  end
+		def vargraphic(*args)
+          puts_log "31"
+		  ibm_parse_column_attributes_args('vargraphic',*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
+		def bigint(*args)
+          puts_log "32"
+		  ibm_parse_column_attributes_args('bigint',*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)
+          puts_log "33"
+		  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, index: nil, **options)
+          puts_log "34 column"
+          name = name.to_s
+          type = type.to_sym if type
+            
+          if @columns_hash[name]
+            if @columns_hash[name].primary_key?
+              raise ArgumentError, "you can't redefine the primary key column '#{name}'. To define a custom primary key, pass { id: false } to create_table."
+            else
+              raise ArgumentError, "you can't define an already defined column '#{name}'."
+            end
+          end
 
-		  # Overrides the abstract adapter in order to handle
-		  # the DEFAULT option for the native XML datatype
-		  def column(name, type, options ={})
-      # construct a column definition where @base is adaptor instance
-			column = ColumnDefinition.new(name, type)
+          # construct a column definition where @base is adaptor instance
+		  column = new_column_definition(name, type, **options)
 			
-			# DB2 does not accept DEFAULT NULL option for XML
-			# for table create, but does accept nullable option
-			unless type.to_s == 'xml'
-			  column.null    = options[:null]
-			  column.default = options[:default]
-			else
-			  column.null    = options[:null]
-			  # Override column object's (instance of ColumnDefinition structure)
-			  # to_s which is expected to return the create_table SQL fragment
-			  # and bypass DEFAULT NULL option while still appending NOT NULL
-			  def column.to_s
-				sql = "#{base.quote_column_name(name)} #{type}"
-				unless self.null == nil
-				  sql << " NOT NULL" if (self.null == false)
-				end
-				return sql
+		  # DB2 does not accept DEFAULT NULL option for XML
+		  # for table create, but does accept nullable option
+		  unless type.to_s == 'xml'
+		    column.null    = options[:null]
+		    column.default = options[:default]
+		  else
+			column.null    = options[:null]
+			# Override column object's (instance of ColumnDefinition structure)
+			# to_s which is expected to return the create_table SQL fragment
+			# and bypass DEFAULT NULL option while still appending NOT NULL
+			def column.to_s
+			  sql = "#{base.quote_column_name(name)} #{type}"
+			  unless self.null == nil
+		        sql << " NOT NULL" if (self.null == false)
 			  end
+			  return sql
 			end
+          end
 
-			column.scale     = options[:scale]      if options[:scale]
-			column.precision = options[:precision]  if options[:precision]
-			# append column's limit option and yield native limits
-			if options[:limit]
-			  column.limit   = options[:limit]
-			elsif @base.native_database_types[type.to_sym]
-			  column.limit   = @base.native_database_types[type.to_sym][:limit] if @base.native_database_types[type.to_sym].has_key? :limit
-			end
+		  column.scale     = options[:scale]      if options[:scale]
+		  column.precision = options[:precision]  if options[:precision]
+		  # append column's limit option and yield native limits
+		  if options[:limit]
+		    column.limit   = options[:limit]
+		  elsif @base.native_database_types[type.to_sym]
+		    column.limit   = @base.native_database_types[type.to_sym][:limit] if @base.native_database_types[type.to_sym].has_key? :limit
+		  end
 
-			unless @columns.nil? or @columns.include? column
-			  @columns << column 
-			end
+		  unless @columns.nil? or @columns.include? column
+		    @columns << column
+		  end
 
-			@columns_hash[name] = column
+		  @columns_hash[name] = column
 
-			return self
-		  end
+		  return self
 		end
-	end
+	  end #end of class TableDefinition
+	end #end of module ColumnMethods
 
     # The IBM_DB Adapter requires the native Ruby driver (ibm_db)
     # for IBM data servers (ibm_db.so).
@@ -743,24 +700,36 @@ module ActiveRecord
         'IBM_DB'
       end
 
-      class BindSubstitution < Arel::Visitors::IBM_DB # :nodoc:
-          include Arel::Visitors
+      class StatementPool < ConnectionAdapters::StatementPool # :nodoc:
+        private
+          def dealloc(stmt)
+            #stmt.close unless stmt.closed?
+          end
+      end
+
+      def build_statement_pool
+        StatementPool.new(self.class.type_cast_config_to_integer(@config[:statement_limit]))
       end
 
       def initialize(connection, ar3, logger, config, conn_options)
         # Caching database connection configuration (+connect+ or +reconnect+ support)\
-	@config = config
+	    @config = config
         @connection       = connection
 		@isAr3            = ar3
         @conn_options     = conn_options
         @database         = config[:database]
         @username         = config[:username]
         @password         = config[:password]
+        @debug            = config[:debug]
         if config.has_key?(:host)
           @host           = config[:host]
           @port           = config[:port] || 50000 # default port
         end
-        @schema           = config[:schema]
+        if config.has_key?(:schema)
+          @schema         = config[:schema]
+        else
+          @schema         = config[:username]
+        end
         @security         = config[:security] || nil
         @authentication   = config[:authentication] || nil
         @timeout          = config[:timeout] || 0  # default timeout value is 0
@@ -800,7 +769,7 @@ module ActiveRecord
                     @servertype = IBM_DB2_ZOS.new(self, @isAr3)
                   when /10/
                     @servertype = IBM_DB2_ZOS.new(self, @isAr3)
-		  when /11/
+		          when /11/
                     @servertype = IBM_DB2_ZOS.new(self, @isAr3)
                   when /12/
                     @servertype = IBM_DB2_ZOS.new(self, @isAr3)
@@ -818,6 +787,7 @@ module ActiveRecord
                 warn "Forcing servertype to LUW: DBMS name could not be retrieved. Check if your client version is of the right level"
                 @servertype = IBM_DB2_LUW.new(self, @isAr3)
             end
+            @database_version = server_info.DBMS_VER
           else
             error_msg = IBM_DB.getErrormsg( @connection, IBM_DB::DB_CONN )
             IBM_DB.close( @connection )
@@ -857,8 +827,23 @@ module ActiveRecord
         end
       end
 
+      def get_database_version
+        @database_version
+      end
+
+      def prepared_statements?
+        puts_log "prepared_statements?"
+        @prepared_statements && !prepared_statements_disabled_cache.include?(object_id)
+      end
+      alias :prepared_statements :prepared_statements?
+
+      def bind_params_length
+        999
+      end
+
       # Optional connection attribute: database name space qualifier
       def schema=(name)
+        puts_log "schema="
         unless name == @schema
           @schema = name
           @servertype.set_schema(@schema)
@@ -867,6 +852,7 @@ module ActiveRecord
 
       # Optional connection attribute: authenticated application user
       def app_user=(name)
+        puts_log "app_user="
         unless name == @app_user
           option = {IBM_DB::SQL_ATTR_INFO_USERID => "#{name}"}
           if IBM_DB.set_option( @connection, option, 1 )
@@ -877,6 +863,7 @@ module ActiveRecord
 
       # Optional connection attribute: OS account (client workstation)
       def account=(name)
+        puts_log "account="
         unless name == @account
           option = {IBM_DB::SQL_ATTR_INFO_ACCTSTR => "#{name}"}
           if IBM_DB.set_option( @connection, option, 1 )
@@ -887,6 +874,7 @@ module ActiveRecord
 
       # Optional connection attribute: application name
       def application=(name)
+        puts_log "application="
         unless name == @application
           option = {IBM_DB::SQL_ATTR_INFO_APPLNAME => "#{name}"}
           if IBM_DB.set_option( @connection, option, 1 )
@@ -897,6 +885,7 @@ module ActiveRecord
 
       # Optional connection attribute: client workstation name
       def workstation=(name)
+        puts_log "workstation="
         unless name == @workstation
           option = {IBM_DB::SQL_ATTR_INFO_WRKSTNNAME => "#{name}"}
           if IBM_DB.set_option( @connection, option, 1 )
@@ -906,61 +895,101 @@ module ActiveRecord
       end
 
       def self.visitor_for(pool)
+        puts_log "visitor_for"
         Arel::Visitors::IBM_DB.new(pool)
       end
     
-	#Check Arel version
+	  #Check Arel version
       begin
         @arelVersion = Arel::VERSION.to_i
       rescue
         @arelVersion = 0
       end
 	  if(@arelVersion < 6 )	  
-		  def to_sql(arel, binds = [])
-			if arel.respond_to?(:ast)
-			  visitor.accept(arel.ast) do
-				quote(*binds.shift.reverse)
-			  end
-			else
-			  arel
+		def to_sql(arel, binds = [])
+		  if arel.respond_to?(:ast)
+		    visitor.accept(arel.ast) do
+			  quote(*binds.shift.reverse)
 			end
+		  else
+		    arel
 		  end
-	end
+		end
+	  end
+
       # This adapter supports migrations.
       # Current limitations:
       # +rename_column+ is not currently supported by the IBM data servers
       # +remove_column+ is not currently supported by the DB2 for zOS data server
       # Tables containing columns of XML data type do not support +remove_column+
       def supports_migrations?
+        puts_log "supports_migrations?"
         true
       end
 
       def supports_foreign_keys?
+        puts_log "supports_foreign_keys?"
         true
       end	  
       
       def supports_datetime_with_precision?
-	true
+        puts_log "supports_datetime_with_precision?"
+	    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?
+        puts_log "supports_ddl_transactions?"
+        true
+      end
+
+      def supports_explain?
+        puts_log "supports_explain?"
+        true
+      end
+
+      def supports_lazy_transactions?
+        puts_log "supports_lazy_transactions?"
+        true
+      end
+
+      def supports_comments?
+        true
+      end
+
+      def supports_views?
         true
       end
 
       def log_query(sql, name) #:nodoc:
+        puts_log "log_query"
         # Used by handle_lobs
         log(sql,name){}
       end
 
+      def supports_partitioned_indexes?
+        true
+      end
+
+      def puts_log (val)
+        begin
+#         puts val
+        rescue
+        end
+        if @debug == true
+          log(" IBM_DB = #{val}", "TRANSACTION"){}
+        end
+      end
+
       #==============================================
       # CONNECTION MANAGEMENT
       #==============================================
 
       # Tests the connection status
       def active?
+        puts_log "active?"
         IBM_DB.active @connection
         rescue
           false
@@ -969,6 +998,7 @@ module ActiveRecord
       # Private method used by +reconnect!+.
       # It connects to the database with the initially provided credentials
       def connect
+        puts_log "connect"
         # If the type of connection is net based
         if(@username.nil? || @password.nil?)
           raise ArgumentError, "Username/Password cannot be nil"
@@ -1006,6 +1036,7 @@ module ActiveRecord
 
       # Closes the current connection and opens a new one
       def reconnect!
+        puts_log "reconnect!"
         disconnect!
         connect
       end
@@ -1016,100 +1047,50 @@ module ActiveRecord
         # * true if succesfull
         # * false if the connection is already closed
         # * nil if an error is raised
+        puts_log "disconnect!"
         return nil if @connection.nil? || @connection == false
         IBM_DB.close(@connection) rescue nil
+        @connection = nil
+        reset_transaction
       end
 
       #==============================================
       # DATABASE STATEMENTS
       #==============================================
 
-      def create_table(name, options = {})
+      def create_table(name, id: :primary_key, primary_key: nil, force: nil, **options)
+        puts_log "create_table name=#{name}, id=#{id}, primary_key=#{primary_key}, force=#{force}"
+        puts_log "create_table Options = #{options}"
+        puts_log "primary_key_prefix_type = #{ActiveRecord::Base.primary_key_prefix_type}"
+        puts_log caller
         @servertype.setup_for_lob_table
         #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)
+        if  !id.nil? || !primary_key.nil?
+          if (!id.nil? && id == true)
+            @servertype.create_index_after_table(name,"id")
+          elsif !primary_key.nil?
+            @servertype.create_index_after_table(name,primary_key.to_s)
           end
         else
-            @servertype.create_index_after_table(name,"id")
+          @servertype.create_index_after_table(name,"id")
         end
-          super(name, options)
-      end
 
-      # 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 prepared_select(sql_param_hash, name = nil)
-        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
-
-        results = []
-        # Invokes the method +prepare+ in order prepare the SQL
-        # IBM_DB.Statement is returned from which the statement is executed and results fetched
-        pstmt = prepare(sql_param_hash["sqlSegment"], name)
-        if(execute_prepared_stmt(pstmt, sql_param_hash["paramArray"]))
-          begin
-            results = @servertype.select(pstmt)
-          rescue StandardError => fetch_error # Handle driver fetch errors
-            error_msg = IBM_DB.getErrormsg(pstmt, IBM_DB::DB_STMT )
-            if error_msg && !error_msg.empty?
-              raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
-            else
-              error_msg = "An unexpected error occurred during data retrieval"
-              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
-              raise error_msg
-            end
-          ensure
-            # Ensures to free the resources associated with the statement
-            IBM_DB.free_stmt(pstmt) if pstmt
-          end
+        #Just incase if id holds any other data type other than primary_key we override it,
+        #otherwise it misses "GENERATED BY DEFAULT AS IDENTITY (START WITH 1000)"
+        if !id.nil? && id != false && primary_key.nil? && ActiveRecord::Base.primary_key_prefix_type.nil?
+          primary_key = :id          
+          options[:auto_increment] = true if options[:auto_increment].nil? and (id == :integer or id == :bigint)
         end
-        # The array of record hashes is returned
-        results
-      end
 
-      # 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 prepared_select_values(sql_param_hash, name = nil)
-        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
-        results = []
-        # Invokes the method +prepare+ in order prepare the SQL
-        # IBM_DB.Statement is returned from which the statement is executed and results fetched
-        pstmt = prepare(sql_param_hash["sqlSegment"], name)
-        if(execute_prepared_stmt(pstmt, sql_param_hash["paramArray"]))
-          begin
-            results = @servertype.select_rows(sql_param_hash["sqlSegment"], name, pstmt, results)
-            if results
-              return results.map { |v| v[0] }
-            else
-              nil
-            end
-          rescue StandardError => fetch_error # Handle driver fetch errors
-            error_msg = IBM_DB.getErrormsg(pstmt, IBM_DB::DB_STMT )
-            if error_msg && !error_msg.empty?
-              raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
-            else
-              error_msg = "An unexpected error occurred during data retrieval"
-              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
-              raise error_msg
-            end
-          ensure
-            # Ensures to free the resources associated with the statement
-            IBM_DB.free_stmt(pstmt) if pstmt
-          end
-        end
-        # The array of record hashes is returned
-        results
+        super(name, id: id, primary_key: primary_key, force: force, **options)
       end
 
       #Calls the servertype select method to fetch the data
       def fetch_data(stmt)
+        puts_log "fetch_data"
         if(stmt)
           begin
             return @servertype.select(stmt)
@@ -1118,33 +1099,41 @@ module ActiveRecord
             if error_msg && !error_msg.empty?
               raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
             else
-              error_msg = "An unexpected error occurred during data retrieval"
               error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
               raise error_msg
             end
           ensure
           # Ensures to free the resources associated with the statement
-            IBM_DB.free_stmt(stmt) if stmt
+            if stmt
+              puts_log "Free Statement #{stmt}"
+              IBM_DB.free_stmt(stmt)
+            end
           end
         end
       end
 
       def select(sql, name = nil, binds = [])
+        puts_log "select #{sql}"
         # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"
-        sql.gsub( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
+        begin
+          sql.gsub( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
+        rescue
+          # ...
+        end
 
         results = []
 
         if(binds.nil? || binds.empty?)
           stmt = execute(sql, name)
         else
-          stmt = exec_query(sql, name, binds)
+          stmt = exec_query_ret_stmt(sql, name, binds, prepare = false)
         end
 
         cols = IBM_DB.resultCols(stmt)
 
         if( stmt ) 
           results = fetch_data(stmt)
+          puts_log "Results = #{results}"
         end
 
         if(@isAr3)
@@ -1154,57 +1143,96 @@ module ActiveRecord
         end
       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,binds = [])
-        # 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 !binds.nil? && !binds.empty?
-          param_array = binds.map do |column,value|
-            quote_value_for_pstmt(value, column)
-          end
-          return prepared_select({"sqlSegment" => sql, "paramArray" => param_array})
+      def translate_exception(exception, message:, sql:, binds:)
+        error_msg1 = /SQL0803N  One or more values in the INSERT statement, UPDATE statement, or foreign key update caused by a DELETE statement are not valid because the primary key, unique constraint or unique index identified by .* constrains table .* from having duplicate values for the index key/
+		error_msg2 = /SQL0204N  .* is an undefined name/
+		error_msg3 = /SQL0413N  Overflow occurred during numeric data type conversion/
+		error_msg4 = /SQL0407N  Assignment of a NULL value to a NOT NULL column .* is not allowed/
+		error_msg5 = /SQL0530N  The insert or update value of the FOREIGN KEY .* is not equal to any value of the parent key of the parent table/
+		error_msg6 = /SQL0532N  A parent row cannot be deleted because the relationship .* restricts the deletion/
+        error_msg7 = /SQL0433N  Value .* is too long/
+        error_msg8 = /CLI0109E  String data right truncation/
+        if !error_msg1.match(message).nil?
+          RecordNotUnique.new(message, sql: sql, binds: binds)
+		elsif !error_msg2.match(message).nil?
+          ArgumentError.new(message)
+		elsif !error_msg3.match(message).nil?
+          RangeError.new(message, sql: sql, binds: binds)
+        elsif !error_msg4.match(message).nil?
+          NotNullViolation.new(message, sql: sql, binds: binds)
+        elsif !error_msg5.match(message).nil? or !error_msg6.match(message).nil?
+          InvalidForeignKey.new(message, sql: sql, binds: binds)
+		elsif !error_msg7.match(message).nil? or !error_msg8.match(message).nil?
+          ValueTooLong.new(message, sql: sql, binds: binds)
+        elsif exception.message.match?(/called on a closed database/i)
+          ConnectionNotEstablished.new(exception)
+        else
+          super
         end
+      end
 
-        stmt = execute(sql, name)
-        if(stmt)
-          begin
-            results = @servertype.select_rows(sql, name, stmt, results)
-          rescue StandardError => fetch_error  # Handle driver fetch errors
-            error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
-            if error_msg && !error_msg.empty?
-              raise StatementInvalid,"Failed to retrieve data: #{error_msg}"
+      def build_truncate_statement(table_name)
+        puts_log "build_truncate_statement"
+        "DELETE FROM #{quote_table_name(table_name)}"
+      end
+
+      def build_fixture_statements(fixture_set)
+        fixture_set.flat_map do |table_name, fixtures|
+          next if fixtures.empty?
+          fixtures.map { |fixture| build_fixture_sql([fixture], table_name) }
+        end.compact
+      end
+      
+      def build_fixture_sql(fixtures, table_name)
+        puts_log "build_fixture_sql"
+        columns = schema_cache.columns_hash(table_name)
+
+        values_list = fixtures.map do |fixture|
+          fixture = fixture.stringify_keys
+          fixture = fixture.transform_keys(&:downcase)
+
+          unknown_columns = fixture.keys - columns.keys
+          if unknown_columns.any?
+            raise Fixture::FixtureError, %(table "#{table_name}" has no columns named #{unknown_columns.map(&:inspect).join(', ')}.)
+          end
+
+          columns.map do |name, column|
+            if fixture.key?(name)
+              type = lookup_cast_type_from_column(column)
+              with_yaml_fallback(type.serialize(fixture[name]))
             else
-              error_msg = "An unexpected error occurred during data retrieval"
-              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
-              raise error_msg
+              default_insert_value(column)
             end
-          ensure
-            # Ensures to free the resources associated with the statement
-            IBM_DB.free_stmt(stmt) if 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)
-        # Gets the first hash from the array of hashes returned by
-        # select_all
-      #  select_all(sql,name).first
-      #end
+        table = Arel::Table.new(table_name)
+        manager = Arel::InsertManager.new
+        manager.into(table)
+
+        if values_list.size == 1
+          values = values_list.shift
+          new_values = []
+          columns.each_key.with_index { |column, i|
+            unless values[i].equal?(DEFAULT_INSERT_VALUE)
+              new_values << values[i]
+              manager.columns << table[column]
+            end
+          }
+          values_list << new_values
+        else
+          columns.each_key { |column| manager.columns << table[column] }
+        end
+
+        manager.values = manager.create_values_list(values_list)
+        visitor.compile(manager.ast)
+      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)
+        puts_log "insert_fixture = #{fixture}"
         if(fixture.respond_to?(:keys))
           insert_query = "INSERT INTO #{quote_table_name(table_name)} ( #{fixture.keys.join(', ')})"
         else
@@ -1253,7 +1281,6 @@ module ActiveRecord
            end
         end
     
-        #log_query(insert_query,'fixture insert')
         log(insert_query,'fixture insert') do
           unless IBM_DB.execute(stmt, insert_values)
             error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
@@ -1266,19 +1293,24 @@ module ActiveRecord
       end
 
       def empty_insert_statement_value(pkey)
-        "(#{pkey}) VALUES (DEFAULT)"
+        if !pkey.nil?
+          "(#{pkey}) VALUES (DEFAULT)"
+        else
+          raise ArgumentError, "Empty Insert Statement not allowed in DB2"
+        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.
       def insert_direct(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        puts_log "insert_direct"
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql = []
           @handle_lobs_triggered = false
         end
 
-        clear_query_cache if defined? clear_query_cache
+        ActiveRecord::Base.clear_query_caches_for_current_thread
 
         if stmt = execute(sql, name)
           begin
@@ -1292,20 +1324,23 @@ module ActiveRecord
       end
 
       def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds=[])
+        puts_log "insert Binds = #{binds}"
         if(@arelVersion <  6)
-		      sql, binds = [to_sql(arel), binds]
-	      else
-		      sql, binds = [to_sql(arel),binds] #sql_for_insert(to_sql(arel, binds), binds) #[to_sql(arel),binds]
-	      end
+		  sql, binds = [to_sql(arel), binds]
+	    else
+		  sql, binds = to_sql_and_binds(arel, binds)
+        end
 
+        puts_log "Binds 2 = #{binds}"
+        puts_log "SQL = #{sql}"
         #unless IBM_DBAdapter.respond_to?(:exec_insert)
         if binds.nil? || binds.empty?
           return insert_direct(sql, name, pk, id_value, sequence_name)
         end
 
-        clear_query_cache if defined? clear_query_cache
+        ActiveRecord::Base.clear_query_caches_for_current_thread
 		        
-		if stmt = exec_insert(sql, name, binds)
+		if stmt = exec_insert_db2(sql, name, binds)
           begin
             @sql << sql
             return id_value || @servertype.last_generated_id(stmt)
@@ -1315,18 +1350,36 @@ module ActiveRecord
         end
       end
 
+      def exec_insert_db2(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
+        puts_log "exec_insert_db2"
+        sql, binds = sql_for_insert(sql, pk, binds)
+        exec_query_ret_stmt(sql, name, binds, prepare = false)
+      end
+
+      def last_inserted_id(result)
+        puts_log "last_inserted_id"
+        return result
+      end
+
+      def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil) # :nodoc:
+        puts_log "exec_insert"
+        value = insert(sql)
+        return value
+      end
+
       # Praveen
       # Performs an insert using the prepared statement 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.
       def prepared_insert(pstmt, param_array = nil, id_value = nil)
+        puts_log "prepared_insert"
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql                   = []
           @sql_parameter_values  = []
           @handle_lobs_triggered = false
         end
 
-        clear_query_cache if defined? clear_query_cache
+        ActiveRecord::Base.clear_query_caches_for_current_thread
 
         begin
           if execute_prepared_stmt(pstmt, param_array)
@@ -1345,6 +1398,7 @@ module ActiveRecord
       # Prepares and logs +sql+ commands and
       # returns a +IBM_DB.Statement+ object.
       def prepare(sql,name = nil)
+        puts_log "prepare"
         # The +log+ method is defined in the parent class +AbstractAdapter+
         @prepared_sql = sql
         log(sql,name) do
@@ -1356,17 +1410,15 @@ module ActiveRecord
       #Executes the prepared statement
       #ReturnsTrue on success and False on Failure
       def execute_prepared_stmt(pstmt, param_array = nil)
+        puts_log "execute_prepared_stmt"
+        puts_log "Param array = #{param_array}"
         if !param_array.nil? && param_array.size < 1
           param_array = nil
         end
 
         if( !IBM_DB.execute(pstmt, param_array) )
           error_msg = IBM_DB.getErrormsg(pstmt, IBM_DB::DB_STMT)
-          if !error_msg.empty?
-            error_msg = "Statement execution failed: " + error_msg
-          else
-            error_msg = "Statement execution failed"
-          end
+          puts_log "Error = #{error_msg}"
           IBM_DB.free_stmt(pstmt) if pstmt
           raise StatementInvalid, error_msg
         else
@@ -1374,45 +1426,117 @@ module ActiveRecord
         end
       end
 
+      READ_QUERY = ActiveRecord::ConnectionAdapters::AbstractAdapter.build_read_query_regexp(
+          :desc, :describe
+      ) # :nodoc:
+      private_constant :READ_QUERY
+
+      def write_query?(sql) # :nodoc:
+        !READ_QUERY.match?(sql)
+      rescue ArgumentError # Invalid encoding
+        !READ_QUERY.match?(sql.b)
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN ALL SET QUERYNO = 1 FOR #{to_sql(arel, binds)}"
+        stmt = execute(sql, "EXPLAIN")
+        result = select("select * from explain_statement where explain_level = 'P' and queryno = 1", "EXPLAIN")
+        return result[0]["total_cost"].to_s
+        # Ensures to free the resources associated with the statement
+        ensure
+          IBM_DB.free_stmt(stmt) if stmt
+      end
+
       # Executes +sql+ statement in the context of this connection using
       # +binds+ as the bind substitutes.  +name+ is logged along with
       # the executed +sql+ statement.
-      def exec_query(sql, name = 'SQL', binds = [])
+      # Here prepare argument is not used, by default this method creates prepared statment and execute.
+      def exec_query_ret_stmt(sql, name = 'SQL', binds = [], prepare = false)
+        puts_log "exec_query_ret_stmt"
+        check_if_write_query(sql)
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
         begin
-          param_array = binds.map do |column,value|
-            quote_value_for_pstmt(value, column)
+          puts_log "SQL = #{sql}"
+          puts_log "Binds = #{binds}"
+          param_array = type_casted_binds(binds)
+          puts_log "Param array = #{param_array}"
+
+          stmt = @servertype.prepare(sql, name)
+          if prepare 
+            @statements[sql] = stmt
+          end
+          
+          puts_log "Statement = #{stmt}"
+          log(sql, name, binds, param_array) do
+            if( stmt )
+              if(execute_prepared_stmt(stmt, param_array))
+                return stmt
+              end
+            else
+              return false
+            end
           end
-
-          stmt = prepare(sql, name)
-
-           if( stmt )
-             if(execute_prepared_stmt(stmt, param_array))
-               return stmt
-             end
-           else
-             return false
-           end
         ensure
           @offset = @limit = nil
         end
       end
 
+      def exec_query(sql, name = 'SQL', binds = [], prepare = false)
+        select_prepared(sql, name, binds, prepare)
+      end
+
+      def select_prepared(sql, name = nil, binds = [], prepare = true)
+        puts_log "select_prepared"
+        puts_log "select_prepared sql before = #{sql}"
+        puts_log "select_prepared Binds = #{binds}"
+        stmt = exec_query_ret_stmt(sql, name, binds, prepare)
+        if !/^select .*/i.match(sql).nil?
+          cols = IBM_DB.resultCols(stmt)
+
+          if( stmt )
+            results = fetch_data(stmt)
+          end
+
+          puts_log "select_prepared columns = #{cols}"
+          puts_log "select_prepared sql after = #{sql}"
+          puts_log "select_prepared result = #{results}"
+        else
+          cols = nil
+          result = nil
+        end
+        if(@isAr3)
+          return results
+        else
+          return ActiveRecord::Result.new(cols, results)
+        end
+      end
+
+      def check_if_write_query(sql) #For rails 7.1 just remove this function as it will be defined in AbstractAdapter class
+        if preventing_writes? && write_query?(sql)
+          raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
+        end
+      end
+
       # Executes and logs +sql+ commands and
       # 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+
-	#sql='INSERT INTO ar_internal_metadata (key, value, created_at, updated_at) VALUES ('10', '10', '10', '10')
+	    #sql='INSERT INTO ar_internal_metadata (key, value, created_at, updated_at) VALUES ('10', '10', '10', '10')
+        puts_log "execute"
+        puts_log "#{sql}"
+        check_if_write_query(sql)
+        materialize_transactions
+        mark_transaction_written_if_write(sql)
         log(sql , name) do
           @servertype.execute(sql, name)
         end
       end
 
-      def exec_insert(sql,name,binds,pk,sequence_name)
-      end
-
       # Executes an "UPDATE" SQL statement
       def update_direct(sql, name = nil)
+        puts_log "update_direct"
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql = []
           @handle_lobs_triggered = false
@@ -1433,13 +1557,14 @@ module ActiveRecord
 
       #Praveen
       def prepared_update(pstmt, param_array = nil )
+        puts_log "prepared_update"
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql                   = []
           @sql_parameter_values  = []
           @handle_lobs_triggered = false
         end
 
-        clear_query_cache if defined? clear_query_cache
+        ActiveRecord::Base.clear_query_caches_for_current_thread
 
         begin
           if execute_prepared_stmt(pstmt, param_array)
@@ -1461,11 +1586,12 @@ module ActiveRecord
       alias_method :prepared_delete, :prepared_update
 
       def update(arel, name = nil, binds = [])
+        puts_log "update"
         if(@arelVersion <  6 )
-		      sql = to_sql(arel)
-		    else
-		      sql = to_sql(arel,binds)
-		    end
+		  sql = to_sql(arel)
+		else
+          sql, binds = to_sql_and_binds(arel, binds)
+		end
 
         # Make sure the WHERE clause handles NULL's correctly
         sqlarray = sql.split(/\s*WHERE\s*/)
@@ -1482,13 +1608,13 @@ module ActiveRecord
           sql = sql + sqlarray[size-1]
         end
 
-        clear_query_cache if defined? clear_query_cache
+        ActiveRecord::Base.clear_query_caches_for_current_thread
 
         if binds.nil? || binds.empty?
           update_direct(sql, name)
         else
           begin
-            if stmt = exec_query(sql,name,binds)
+            if stmt = exec_query_ret_stmt(sql, name, binds, prepare = true)
               IBM_DB.num_rows(stmt)
             end
           ensure
@@ -1501,14 +1627,18 @@ module ActiveRecord
 
       # Begins the transaction (and turns off auto-committing)
       def begin_db_transaction
+        puts_log "begin_db_transaction"
+        log("begin transaction", "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
+        puts_log "commit_db_transaction"
+        log("commit transaction", "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
       end
@@ -1516,85 +1646,26 @@ module ActiveRecord
       # 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
+        puts_log "rollback_db_transaction"
+        log("rollback transaction", "TRANSACTION") {
         # ROLLBACK the transaction
-        IBM_DB.rollback(@connection) rescue nil
+        IBM_DB.rollback(@connection) rescue nil }
+        ActiveRecord::Base.clear_query_caches_for_current_thread
         # Turns on auto-committing
         IBM_DB.autocommit @connection, IBM_DB::SQL_AUTOCOMMIT_ON
       end
 
-      def get_limit_offset_clauses(limit,offset)
-
-        if limit && limit == 0
-          clauses = @servertype.get_limit_offset_clauses(limit,0)
-        else
-          clauses = @servertype.get_limit_offset_clauses(limit, offset)
-        end
-      end
-
-      # Modifies a sql statement in order to implement a LIMIT and an OFFSET.
-      # A LIMIT defines the number of rows that should be fetched, while
-      # an OFFSET defines from what row the records must be fetched.
-      # IBM data servers implement a LIMIT in SQL statements through:
-      # FETCH FIRST n ROWS ONLY, where n is the number of rows required.
-      # The implementation of OFFSET is more elaborate, and requires the usage of
-      # subqueries and the ROW_NUMBER() command in order to add row numbering
-      # as an additional column to a copy of the existing table.
-      # ==== Examples
-      # add_limit_offset!('SELECT * FROM staff', {:limit => 10})
-      # generates: "SELECT * FROM staff FETCH FIRST 10 ROWS ONLY"
-      #
-      # add_limit_offset!('SELECT * FROM staff', {:limit => 10, :offset => 30})
-      # generates "SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_rownum
-      # FROM (SELECT * FROM staff) AS I) AS O WHERE sys_row_num BETWEEN 31 AND 40"
-      def add_limit_offset!(sql, options)
-        limit = options[:limit]
-        offset = options[:offset]
-
-        # if the limit is zero
-        if limit && limit == 0
-          # Returns a query that will always generate zero records
-          # (e.g. WHERE sys_row_num BETWEEN 1 and 0)
-          if( @pstmt_support_on )
-            sql = @servertype.query_offset_limit!(sql, 0, limit, options)
-          else
-            sql = @servertype.query_offset_limit(sql, 0, limit)
-          end
-        # If there is a non-zero limit
-        else
-          # If an offset is specified builds the query with offset and limit,
-          # otherwise retrieves only the first +limit+ rows
-          if( @pstmt_support_on )
-            sql = @servertype.query_offset_limit!(sql, offset, limit, options)
-          else
-            sql = @servertype.query_offset_limit(sql, offset, limit)
-          end
-        end
-        # Returns the sql query in any case
-        sql
-      end # method add_limit_offset!
-
       def default_sequence_name(table, column) # :nodoc:
+        puts_log "72"
         "#{table}_#{column}_seq"
       end
 
-
       #==============================================
       # QUOTING
       #==============================================
 
-      # Quote date/time values for use in SQL input.
-      # Includes microseconds, if the value is a Time responding to usec.
-=begin
-      def quoted_date(value) #:nodoc:
-        if value.respond_to?(:usec)
-          "#{super}.#{sprintf("%06d", value.usec)}"
-        else
-          super
-        end
-      end
-=end
       def quote_value_for_pstmt(value, column=nil)
-
+        puts_log "quote_value_for_pstmt"
         return value.quoted_id if value.respond_to?(:quoted_id)
 
         case value
@@ -1621,98 +1692,52 @@ module ActiveRecord
             end
         end
       end
-      # Properly quotes the various data types.
-      # +value+ contains the data, +column+ is optional and contains info on the field
-    #   def quote(value, column=nil)
-    #     return value.quoted_id if value.respond_to?(:quoted_id)
-	  #     case value
-    #       # If it's a numeric value and the column sql_type is not a string, it shouldn't be quoted
-    #       # (IBM_DB doesn't accept quotes on numeric types)
-    #       when Numeric
-    #         # If the column sql_type is text or string, return the quote value
-    #         if (column && ( column.sql_type.to_s =~ /text|char/i ))
-    #           unless caller[0] =~ /insert_fixture/i
-		#           "'#{value}'"
-    #           else
-    #               "#{value}"
-    #           end 
-    #         else
-    #           # value is Numeric, column.sql_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.sql_type.to_s =~ /binary|blob/i && !(column.sql_type.to_s =~ /for bit data/i)				
-    #         # 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
-    #             @servertype.set_binary_value
-    #           else
-    #             # Quoting required for the default value of a column				
-    #             @servertype.set_binary_default(value)
-    #           end
-    #       elsif column && column.sql_type.to_s =~ /text|clob/i
-    #           unless caller[0] =~ /add_column_options/i
-    #             @servertype.set_text_default(quote_string(value))
-    #           else
-    #             @servertype.set_text_default(quote_string(value))
-    #           end
-    #       elsif column && column.sql_type.to_s =~ /xml/i
-    #           unless caller[0] =~ /add_column_options/i
-    #             "#{value}"
-    #           else
-    #             "#{value}"
-    #           end
-    #       else
-    #           unless caller[0] =~ /insert_fixture/i
-    #             super(value) 
-    #           else
-    #             "#{value}"
-    #           end 
-    #       end
-    #       #when TrueClass then quoted_true    # return '1' for true
-	  # when TrueClass 
-		#   quoted_true
-    #       #when FalseClass then quoted_false  # return '0' for false
-	  # when FalseClass
-		#   quoted_false
-    #       when nil
-		#   "NULL"
-    #       when Date
-		#   "'#{quoted_date(value)}'"
-	  # when Time
-		#   "'#{quoted_date(value)}'"
-    #       when Symbol
-		#   "'#{quote_string(value)}'"
-    #       else
-    #         unless caller[0] =~ /insert_fixture/i
-    #           "'#{quote_string(YAML.dump(value))}'"
-    #         else
-    #           "#{quote_string(YAML.dump(value))}"
-    #         end
-    #     end
-    #   end
-      # # Quotes a given string, escaping single quote (') characters.
-      # def quote_string(string)
-      #     #string.gsub(/'/, "''")
-	    #     string.gsub('\\', '\&\&').gsub("'", "''")
-      # end
+
+      # Quotes a given string, escaping single quote (') characters.
+      def quote_string(string)
+        puts_log "quote_string"
+        string.gsub(/'/, "''")
+	    #string.gsub('\\', '\&\&').gsub("'", "''")
+      end
 
       # *true* is represented by a smallint 1, *false*
       # by 0, as no native boolean type exists in DB2.
       # Numerics are not quoted in DB2.
       def quoted_true
-        "1"
+        puts_log "quoted_true"
+        "1".freeze
       end
 
       def quoted_false
-        "0"
+        puts_log "quoted_false"
+        "0".freeze
+      end
+
+      def unquoted_true
+        puts_log "unquoted_true"
+        1
+      end
+
+      def unquoted_false
+        puts_log "unquoted_false"
+        0
+      end
+
+      def quote_table_name(name)
+        puts_log "quote_table_name"
+        name
+        #@servertype.check_reserved_words(name).gsub('"', '').gsub("'",'')
       end
 
       def quote_column_name(name)
-         @servertype.check_reserved_words(name)
+        puts_log "quote_column_name"
+        @servertype.check_reserved_words(name).gsub('"', '').gsub("'",'')
       end
 
+      def quoted_binary(value)
+        puts_log "quoted_binary"
+        "CAST(x'#{value.hex}' AS BLOB)"
+      end
       #==============================================
       # SCHEMA STATEMENTS
       #==============================================
@@ -1721,7 +1746,7 @@ module ActiveRecord
       # database types
       def native_database_types
         {
-          :primary_key => { :name => @servertype.primary_key_definition(@start_id)},
+          :primary_key => { :name => @servertype.primary_key_definition(@start_id) },
           :string      => { :name => "varchar", :limit => 255 },
           :text        => { :name => "clob" },
           :integer     => { :name => "integer" },
@@ -1750,6 +1775,7 @@ module ActiveRecord
       end
 
       def build_conn_str_for_dbops()
+        puts_log "build_conn_str_for_dbops"
         connect_str = "DRIVER={IBM DB2 ODBC DRIVER};ATTACH=true;"
         if(!@host.nil?)
           connect_str << "HOSTNAME=#{@host};"
@@ -1761,6 +1787,7 @@ module ActiveRecord
       end
 
       def drop_database(dbName)
+        puts_log "drop_database"
         connect_str = build_conn_str_for_dbops()
 
         #Ensure connection is closed before trying to drop a database. 
@@ -1784,6 +1811,7 @@ module ActiveRecord
       end
 
       def create_database(dbName, codeSet=nil, mode=nil)
+        puts_log "create_database"
         connect_str = build_conn_str_for_dbops()
 
         #Ensure connection is closed before trying to drop a database.
@@ -1805,18 +1833,41 @@ module ActiveRecord
           raise "Could not create Database due to: #{error}"
         end
       end
-
-	    
-  
-  
-	   def valid_type?(type)		
-        #!native_database_types[type].nil?
-		native_database_types[type].nil?
+      
+      def valid_type?(type)
+        !native_database_types[type].nil?
       end
-	  
+
       # IBM data servers do not support limits on certain data types (unlike MySQL)
       # Limit is supported for the {float, decimal, numeric, varchar, clob, blob, graphic, vargraphic} data types.
       def type_to_sql(type, limit=nil, precision=nil, scale=nil )
+        puts_log "type_to_sql"
+        puts_log "Type = #{type}, Limit = #{limit}"
+
+        if type.to_sym == :binary and limit.class == Hash and limit.has_key?("limit".to_sym)
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          sql_segment << "(#{limit[:limit]})"
+          return sql_segment
+        end
+
+        if type.to_sym == :datetime and limit.class == Hash and limit.has_key?("precision".to_sym)
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          if limit[:precision].nil?
+            return sql_segment
+          elsif (0..12) === limit[:precision]
+            sql_segment << "(#{limit[:precision]})"
+            return sql_segment
+          else
+            raise ArgumentError, "No #{sql_segment} type has precision of #{limit[:precision]}. The allowed range of precision is from 0 to 12"
+          end
+        end
+
+        if type.to_sym == :string and limit.class == Hash and limit.has_key?("limit".to_sym)
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          sql_segment << "(#{limit[:limit]})"
+          return sql_segment
+        end
+
         if type.to_sym == :decimal
           if limit.class == Hash
             if limit.has_key?("precision".to_sym)
@@ -1834,6 +1885,9 @@ module ActiveRecord
             return sql_segment
           elsif scale.nil? && !precision.nil?
             sql_segment << "(#{precision})"
+            return sql_segment
+          elsif precision.nil? && !scale.nil?
+            raise ArgumentError, "Error adding decimal column: precision cannot be empty if scale is specified"
           else
             return sql_segment
           end
@@ -1845,50 +1899,48 @@ module ActiveRecord
           return sql_segment
         end
 
-	if type.to_sym == :vargraphic
-         sql_segment = native_database_types[type.to_sym][:name].to_s
-         if limit.class == Hash
-             if limit.has_key?("limit".to_sym)
-                limit1 = limit[:limit]
-                sql_segment << "(#{limit1})"
-             else
-                return "vargraphic(1)"
-             end
-	 else 
-	     if limit != nil
-                sql_segment << "(#{limit})"
-             else
-                return "vargraphic(1)"
-             end
-         end
-         return sql_segment
-        end
-
-	if type.to_sym == :graphic
-         sql_segment = native_database_types[type.to_sym][:name].to_s
-         if limit.class == Hash
-             if limit.has_key?("limit".to_sym)
-                limit1 = limit[:limit]
-                sql_segment << "(#{limit1})"
-             else
-                return "graphic(1)"
-             end
-	 else
-             if limit != nil
-                sql_segment << "(#{limit})"
-             else
-                return "graphic(1)"
-             end
-         end
-         return sql_segment
+	    if type.to_sym == :vargraphic
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          if limit.class == Hash
+            if limit.has_key?("limit".to_sym)
+              limit1 = limit[:limit]
+              sql_segment << "(#{limit1})"
+            else
+              return "vargraphic(1)"
+            end
+	      else
+	        if limit != nil
+              sql_segment << "(#{limit})"
+            else
+              return "vargraphic(1)"
+            end
+          end
+          return sql_segment
         end
 
-
+	    if type.to_sym == :graphic
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          if limit.class == Hash
+            if limit.has_key?("limit".to_sym)
+              limit1 = limit[:limit]
+              sql_segment << "(#{limit1})"
+            else
+              return "graphic(1)"
+            end
+	      else
+            if limit != nil
+              sql_segment << "(#{limit})"
+            else
+              return "graphic(1)"
+            end
+          end
+          return sql_segment
+        end
 
         if limit.class == Hash
-          return super if limit.has_key?("limit".to_sym).nil?
+          return super(type) if limit.has_key?("limit".to_sym).nil?
         else
-          return super if limit.nil?
+          return super(type) if limit.nil?
         end
 
         # strip off limits on data types not supporting them
@@ -1899,23 +1951,17 @@ module ActiveRecord
         else
           return super(type)
         end
-
       end
-	
-	
-	
-	
-	
-	
+
       # Returns the maximum length a table alias identifier can be.
       # IBM data servers (cross-platform) table limit is 128 characters
       def table_alias_length
         128
       end
-		 
 	  
       # Retrieves table's metadata for a specified shema name
       def tables(name = nil)
+        puts_log "tables"
         # Initializes the tables array
         tables = []
         # Retrieve table's metadata through IBM_DB driver
@@ -1954,16 +2000,13 @@ module ActiveRecord
         return tables
       end
 
-###################################	  
-		
-
 	  # Retrieves views's metadata for a specified shema name
       def views
+        puts_log "views"
         # Initializes the tables array
         tables = []
         # Retrieve view's metadata through IBM_DB driver
-        stmt = IBM_DB.tables(@connection, nil, 
-                            @servertype.set_case(@schema))
+        stmt = IBM_DB.tables(@connection, nil, @servertype.set_case(@schema))
         if(stmt)
           begin
             # Fetches all the records available
@@ -1996,18 +2039,19 @@ module ActiveRecord
         # Returns the tables array
         return tables
       end
-  
-	  
+
       # Returns the primary key of the mentioned table
       def primary_key(table_name)
-        pk_name = nil
+        puts_log "primary_key"
+        pk_name = []
         stmt = IBM_DB.primary_keys( @connection, nil, 
                                     @servertype.set_case(@schema), 
-                                    @servertype.set_case(table_name))
+                                    @servertype.set_case(table_name.to_s))
         if(stmt) 
           begin
-            if ( pk_index_row = IBM_DB.fetch_array(stmt) )
-              pk_name = pk_index_row[3].downcase
+            while ( pk_index_row = IBM_DB.fetch_array(stmt) )
+              puts_log "Primary_keys = #{pk_index_row}"
+              pk_name << pk_index_row[3].downcase
             end
           rescue StandardError => fetch_error # Handle driver fetch errors
             error_msg = IBM_DB.getErrormsg( stmt, IBM_DB::DB_STMT )
@@ -2029,11 +2073,19 @@ module ActiveRecord
             raise StandardError.new('An unexpected error occurred during primary key retrieval')
           end
         end
-        return pk_name
+        if pk_name.length() == 1
+          return pk_name[0]
+        elsif pk_name.empty?
+          return nil
+        else
+          return pk_name
+        end
       end
 
       # Returns an array of non-primary key indexes for a specified table name
       def indexes(table_name, name = nil)
+        puts_log "indexes"
+        puts_log "Table = #{table_name}"
         # to_s required because +table_name+ may be a symbol.
         table_name = table_name.to_s
         # Checks if a blank table name has been given.
@@ -2055,11 +2107,13 @@ module ActiveRecord
         if(stmt)
           begin
             while ( pk_index_row = IBM_DB.fetch_array(stmt) )
+              puts_log "Primary keys = #{pk_index_row}"
+              puts_log "pk_index = #{pk_index}"
               if pk_index_row[5] 
                 pk_index_name = pk_index_row[5].downcase
                 pk_index_columns = [pk_index_row[3].downcase]           # COLUMN_NAME
                 if pk_index 
-                  pk_index.columns = pk_index.columns + pk_index_columns
+                  pk_index.columns << pk_index_columns
                 else
                   pk_index = IndexDefinition.new(table_name, pk_index_name, true, pk_index_columns)
                 end
@@ -2115,7 +2169,10 @@ module ActiveRecord
                 end
               
                 unless is_composite 
-                  indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns)
+                  sql = "select remarks from syscat.indexes where tabname = #{quote(table_name.upcase)} and indname = #{quote(index_stats[5])}"
+                  comment = single_value_from_rows(select_prepared(sql).rows)
+
+                  indexes << IndexDefinition.new(table_name, index_name, index_unique, index_columns, comment: comment)
                   index_schema << index_qualifier
                 end 
               end
@@ -2143,6 +2200,7 @@ module ActiveRecord
     
         # remove the primary key index entry.... should not be dumped by the dumper
     
+        puts_log "Indexes 1 = #{pk_index}"
         i = 0
         indexes.each do |index|
           if pk_index && index.columns == pk_index.columns
@@ -2151,12 +2209,13 @@ module ActiveRecord
           i = i+1
         end 
         # Returns the indexes array
+        puts_log "Indexes 2 = #{indexes}"
         return indexes
       end
 
-	  
       # Mapping IBM data servers SQL datatypes to Ruby data types
       def simplified_type2(field_type)
+        puts_log "simplified_type2"
         case field_type
           # if +field_type+ contains 'for bit data' handle it as a binary
           when /for bit data/i
@@ -2193,10 +2252,10 @@ module ActiveRecord
             "rowid"
         end
       end # method simplified_type
-	  
-	  
+
 	  # Mapping IBM data servers SQL datatypes to Ruby data types
       def simplified_type(field_type)
+        puts_log "simplified_type"
         case field_type
           # if +field_type+ contains 'for bit data' handle it as a binary
           when /for bit data/i
@@ -2210,7 +2269,7 @@ module ActiveRecord
           when /float|double|real/i
             :float
           when /timestamp|datetime/i
-            :timestamp
+            :datetime
           when /time/i
             :time
           when /date/i
@@ -2233,11 +2292,35 @@ module ActiveRecord
             :rowid
         end
       end # method simplified_type
-	  
-	  
+	
+      def extract_value_from_default(default)
+        case default
+        when /IDENTITY GENERATED BY DEFAULT/i
+          nil
+        when /^null$/i
+          nil
+        # Quoted types
+        when /^'(.*)'$/m
+          $1.gsub("''", "'")
+        # Quoted types
+        when /^"(.*)"$/m
+          $1.gsub('""', '"')
+        # Numeric types
+        when /\A-?\d+(\.\d*)?\z/
+          $&
+        else
+          # Anything else is blank or some function
+          # and we can't know the value of that, so return nil.
+          nil
+        end
+      end
+ 
       # Returns an array of Column objects for the table specified by +table_name+
-      def columns(table_name)
+      def columns(table_name)        
+        default_blob_length = 1048576
       # to_s required because it may be a symbol.
+        puts_log "columns"
+        puts_log caller
         table_name = @servertype.set_case(table_name.to_s)
 				
         # Checks if a blank table name has been given.
@@ -2249,74 +2332,94 @@ module ActiveRecord
         stmt = IBM_DB.columns( @connection, nil, 
                                    @servertype.set_case(@schema), 
                                    @servertype.set_case(table_name) )
+#       sql = "select * from sysibm.sqlcolumns where table_name = #{quote(table_name.upcase)}"
+        if @debug == true
+          sql = "select * from syscat.columns  where tabname = #{quote(table_name.upcase)}"
+          puts_log "SYSIBM.SQLCOLUMNS = #{select_prepared(sql).rows}"
+        end
+
         if(stmt)
           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)
+              puts_log col
               column_name = col["column_name"].downcase
               # Assigns the column default value.
               column_default_value = col["column_def"]
-              # If there is no default value, it assigns NIL
-              column_default_value = nil if (column_default_value && column_default_value.upcase == 'NULL')
-              # If default value is IDENTITY GENERATED BY DEFAULT (this value is retrieved in case of id columns)
-              column_default_value = nil if (column_default_value && column_default_value.upcase =~ /IDENTITY GENERATED BY DEFAULT/i)
-              # Removes single quotes from the default value
-              column_default_value.gsub!(/^'(.*)'$/, '\1') unless column_default_value.nil?
+              default_value = extract_value_from_default(column_default_value)
               # Assigns the column type
               column_type = col["type_name"].downcase
+
               # Assigns the field length (size) for the column
 			  
-			  original_column_type = "#{column_type}"
-			  
-              column_length = col["column_size"]
+              if column_type =~ /integer|bigint/i
+                column_length = col["buffer_length"]
+              else
+                column_length = col["column_size"]
+              end
               column_scale = col["decimal_digits"]
               # The initializer of the class Column, requires the +column_length+ to be declared 
               # between brackets after the datatype(e.g VARCHAR(50)) for :string and :text types. 
               # If it's a "for bit data" field it does a subsitution in place, if not
               # it appends the (column_length) string on the supported data types
-              unless column_length.nil? || 
-                     column_length == '' || 
-                     column_type.sub!(/ \(\) for bit data/i,"(#{column_length}) FOR BIT DATA") || 
-                     !column_type =~ /char|lob|graphic/i
-                if column_type =~ /decimal/i
+              if column_type.match(/decimal|numeric/)
+                if column_length > 0 and column_scale > 0
                   column_type << "(#{column_length},#{column_scale})"
-                elsif column_type =~ /smallint|integer|double|date|time|timestamp|xml|bigint/i
-                  column_type << ""  # override native limits incompatible with table create
-                else
+                elsif column_length > 0 and column_scale == 0
                   column_type << "(#{column_length})"
                 end
+              elsif column_type.match(/timestamp/)
+                column_type << "(#{column_scale})"
+              elsif column_type.match(/varchar/) and column_length > 0
+                column_type << "(#{column_length})"
               end
-              # col["NULLABLE"] is 1 if the field is nullable, 0 if not.
+
               column_nullable = (col["nullable"] == 1) ? true : false
               # Make sure the hidden column (db2_generated_rowid_for_lobs) in DB2 z/OS isn't added to the list
-              if !(column_name =~ /db2_generated_rowid_for_lobs/i)
-                # Pushes into the array the *IBM_DBColumn* object, created by passing to the initializer
-                # +column_name+, +default_value+, +column_type+ and +column_nullable+.
-                #if(@arelVersion >=  6 )				
-			
-			    #cast_type = lookup_cast_type(column_type)
-				
-				ruby_type = simplified_type2(column_type)
+              if !(column_name.match(/db2_generated_rowid_for_lobs/i))
+				ruby_type = simplified_type(column_type)
 				precision = extract_precision(ruby_type)
-				
-				#type = type_map.lookup(column_type)
-				sql_type = type_to_sql(column_type, column_length, precision, column_scale)
-											  
+
+                if column_type.match(/timestamp|integer|bigint|date|time|blob/i)
+                  if column_type.match(/timestamp/i)
+                    precision = column_scale
+                    if !default_value.nil?
+                      default_value[10] = " "
+                      default_value[13] = ":"
+                      default_value[16] = ":"
+                    end
+                  elsif column_type.match(/time/i)
+                    if !default_value.nil?
+                      default_value[2] = ":"
+                      default_value[5] = ":"
+                    end
+                  end                  
+                  column_scale = nil
+                  if !(column_type.match(/blob/i) and column_length != default_blob_length) and !column_type.match(/bigint/i)
+                    column_length = nil
+                  end
+                elsif column_type.match(/decimal|numeric/)
+                  precision = column_length
+                  column_length = nil
+                end
+
+                if ruby_type.to_s == "boolean"
+                  column_type = "boolean"
+                end
+
+                default_function = extract_default_function(default_value, column_default_value)
+
 				sqltype_metadata = SqlTypeMetadata.new(					
 					#sql_type: sql_type,
-					sql_type: original_column_type,
+					sql_type: column_type,
 					type: ruby_type,
 					limit: column_length,
 					precision: precision,
 					scale: column_scale,
 				)
 				
-				columns << Column.new(column_name, column_default_value, sqltype_metadata, column_nullable, table_name)
-									
-				#else
-				#	columns << IBM_DBColumn.new(column_name, column_default_value, column_type, column_nullable)
-				#end
+				columns << Column.new(column_name, default_value, sqltype_metadata, column_nullable, default_function, comment: col["remarks"])
               end
             end
           rescue StandardError => fetch_error # Handle driver fetch errors
@@ -2340,10 +2443,20 @@ module ActiveRecord
           end
         end
         # Returns the columns array
+        puts_log "Inside def columns() #{columns}"
         return columns
       end
-	  	  
+	 
+      def extract_default_function(default_value, default)
+        default if has_default_function?(default_value, default)
+      end
+
+      def has_default_function?(default_value, default)
+        !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+      end
+
 	  def foreign_keys(table_name)	  
+        puts_log "foreign_keys #{table_name}"
         #fetch the foreign keys of the table using function foreign_keys        
 		#PKTABLE_NAME::  fk_row[2] Name of the table containing the primary key.
 		#PKCOLUMN_NAME:: fk_row[3] Name of the column containing the primary key.		
@@ -2359,15 +2472,16 @@ module ActiveRecord
 		
         if(stmt)
           begin
-            while ( fk_row = IBM_DB.fetch_array(stmt) )			  
+            while ( fk_row = IBM_DB.fetch_array(stmt) )
+              puts_log "foreign_keys fetch = #{fk_row}"
               options = {
-				column: fk_row[7],
-				name: fk_row[11],
-				primary_key: fk_row[3],
+				column: fk_row[7].downcase,
+				name: fk_row[11].downcase,
+				primary_key: fk_row[3].downcase,
 			  }			  			  			  
 			  options[:on_update] = extract_foreign_key_action(fk_row[9])	
 			  options[:on_delete] = extract_foreign_key_action(fk_row[10])
-			  foreignKeys << ForeignKeyDefinition.new(fk_row[6], table_name, options) 
+			  foreignKeys << ForeignKeyDefinition.new(fk_row[6].downcase, fk_row[2].downcase, options) 
             end			
 
           rescue StandardError => fetch_error # Handle driver fetch errors
@@ -2390,24 +2504,25 @@ module ActiveRecord
             raise StandardError.new('An unexpected error occurred during foreign key retrieval')		
           end		  
         end
-	   #Returns the foreignKeys array
-	   return foreignKeys
-    end
+	    #Returns the foreignKeys array
+	    return foreignKeys
+      end
     
-	  def extract_foreign_key_action(specifier) # :nodoc:	      			
-		  case specifier
-          when 0; :cascade
-		  when 1; :restrict
-		  when 2; :nullify
-		  when 3; :noaction		  
-          end
+      def extract_foreign_key_action(specifier) # :nodoc:
+        puts_log "extract_foreign_key_action"
+        case specifier
+        when 0; :cascade
+        when 1; :restrict
+	    when 2; :nullify
+        end
 	  end
 	  
 	  def supports_disable_referential_integrity? #:nodoc:
-          true
-    end
+        true
+      end
 
-    def disable_referential_integrity #:nodoc:
+      def disable_referential_integrity #:nodoc:
+        puts_log "disable_referential_integrity"
         if supports_disable_referential_integrity?
           alter_foreign_keys(tables, true)
         end
@@ -2416,43 +2531,293 @@ module ActiveRecord
       ensure
         if supports_disable_referential_integrity?
           alter_foreign_keys(tables, false)
-        end
-		
-    end
+        end		
+      end
 	  
 	  def alter_foreign_keys(tables, not_enforced)
+        puts_log "alter_foreign_keys"
         enforced = not_enforced ? 'NOT ENFORCED' : 'ENFORCED'
         tables.each do |table|
           foreign_keys(table).each do |fk|
-            execute("ALTER TABLE #{@servertype.set_case(fk.from_table)} ALTER FOREIGN KEY #{@servertype.set_case(fk.name)} #{enforced}")			
+            execute("ALTER TABLE #{@servertype.set_case(fk.from_table)} ALTER FOREIGN KEY #{@servertype.set_case(fk.name)} #{enforced}")
+          end
+        end
+	  end
+
+      def primary_keys(table_name) # :nodoc:
+        puts_log "primary_keys"
+        raise ArgumentError unless table_name.present?
+        primary_key(table_name)
+      end
+
+      # Adds comment for given table column or drops it if +comment+ is a +nil+
+      def change_column_comment(table_name, column_name, comment_or_changes) # :nodoc:
+        puts_log "change_column_comment"
+        clear_cache!
+        comment = extract_new_comment_value(comment_or_changes)
+        if comment.nil?
+          execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS ''"
+        else
+          execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS #{quote(comment)}"
+        end
+      end
+
+      # Adds comment for given table or drops it if +comment+ is a +nil+
+      def change_table_comment(table_name, comment_or_changes) # :nodoc:
+        puts_log "change_table_comment"
+        clear_cache!
+        comment = extract_new_comment_value(comment_or_changes)
+        if comment.nil?
+          execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS ''"
+        else
+          execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
+        end
+      end
+
+      def add_column(table_name, column_name, type, **options) # :nodoc:
+        puts_log "add_column"
+        clear_cache!
+        puts_log "add_column info #{table_name}, #{column_name}, #{type}, #{options}"
+        if (!type.nil? && type.to_s == "primary_key") or (options.key?(:primary_key) and options[:primary_key] == true)
+          if !type.nil? and type.to_s != "primary_key"
+            execute "ALTER TABLE #{table_name} ADD COLUMN #{column_name} #{type} NOT NULL DEFAULT 0"
+          else
+            execute "ALTER TABLE #{table_name} ADD COLUMN #{column_name} INTEGER NOT NULL DEFAULT 0"
           end
+          execute "ALTER TABLE #{table_name} alter column #{column_name} drop default"
+          execute "ALTER TABLE #{table_name} alter column #{column_name} set GENERATED BY DEFAULT AS IDENTITY (START WITH 1000)"
+          execute "ALTER TABLE #{table_name} add primary key (#{column_name})"
+        else
+          super
         end
+        change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+      end
+
+      def table_comment(table_name) # :nodoc:
+        puts_log "table_comment"
+        sql = "select remarks from syscat.tables where tabname = #{quote(table_name.upcase)}"
+        single_value_from_rows(select_prepared(sql).rows)
+      end
+
+      def add_index(table_name, column_name, **options) #:nodoc:
+        puts_log "add_index"
+        index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
+
+        return if if_not_exists && index_exists?(table_name, column_name, name: index.name)
+        if_not_exists = false if if_not_exists
+        create_index = CreateIndexDefinition.new(index, algorithm, if_not_exists)
+        result = execute schema_creation.accept(create_index)
+
+        execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment
+        result
+      end
+
+      def query_values(sql, name = nil) # :nodoc:
+        puts_log "query_values"
+        select_prepared(sql).rows.map(&:first)
+      end
+
+	  def data_source_sql(name = nil, type: nil)
+        puts_log "data_source_sql"
+		sql = +"SELECT tabname FROM (SELECT tabname, type FROM syscat.tables "
+		sql << " WHERE tabschema = #{quote(@schema.upcase)}) subquery"
+		if type || name
+		  conditions = []
+		  conditions << "subquery.type = #{quote(type.upcase)}" if type
+		  conditions << "subquery.tabname = #{quote(name.upcase)}" if name
+		  sql << " WHERE #{conditions.join(" AND ")}"
+		end
+		sql
 	  end
 
+      # Returns an array of table names defined in the database.
+      def tables
+        puts_log "tables"
+        query_values(data_source_sql(type: "T"), "SCHEMA").map(&:downcase)
+      end
+
+      # Checks to see if the table +table_name+ exists on the database.
+      #
+      #   table_exists?(:developers)
+      #
+      def table_exists?(table_name)
+        puts_log "table_exists? = #{table_name}"
+        query_values(data_source_sql(table_name, type: "T"), "SCHEMA").any? if table_name.present?
+      rescue NotImplementedError
+        tables.include?(table_name.to_s)
+      end
+
+      # Returns an array of view names defined in the database.
+      def views
+        puts_log "views"
+        query_values(data_source_sql(type: "V"), "SCHEMA").map(&:downcase)
+      end
+
+      # Checks to see if the view +view_name+ exists on the database.
+      #
+      #   view_exists?(:ebooks)
+      #
+      def view_exists?(view_name)
+        puts_log "view_exists?"
+        query_values(data_source_sql(view_name, type: "V"), "SCHEMA").any? if view_name.present?
+      rescue NotImplementedError
+        views.include?(view_name.to_s)
+      end
+
+      # Returns the relation names useable to back Active Record models.
+      # For most adapters this means all #tables and #views.
+      def data_sources
+        puts_log "data_sources"
+        query_values(data_source_sql, "SCHEMA").map(&:downcase)
+      rescue NotImplementedError
+        tables | views
+      end
+
+      def create_schema_dumper(options)
+        puts_log "create_schema_dumper"
+        SchemaDumper.create(self, options)
+      end
+
+      def table_options(table_name) # :nodoc:
+        puts_log "table_options"
+        if comment = table_comment(table_name)
+          { comment: comment }
+        end
+      end
+
       # Renames a table.
       # ==== Example
       # rename_table('octopuses', 'octopi')
       # Overriden to satisfy IBM data servers syntax
       def rename_table(name, new_name)
+	    puts_log "rename_table"
+        name = quote_column_name(name)
+        new_name = quote_column_name(new_name)
+        puts_log "90 old_table = #{name}, new_table = #{new_name}"
         # SQL rename table statement
+        index_list = indexes(name)
+        puts_log "Index List = #{index_list}"
+        drop_table_indexes(index_list)
         rename_table_sql = "RENAME TABLE #{name} TO #{new_name}"
         stmt = execute(rename_table_sql)
+        create_table_indexes(index_list, new_name)
         # Ensures to free the resources associated with the statement
         ensure
           IBM_DB.free_stmt(stmt) if stmt
       end
 
-      # Renames a column.
-      # ===== Example
-      #  rename_column(:suppliers, :description, :name)
-      def rename_column(table_name, column_name, new_column_name)
-        @servertype.rename_column(table_name, column_name, new_column_name)
+      def drop_table_indexes(index_list)
+        puts_log "drop_table_indexes"
+        index_list.each do |indexs|
+          remove_index(indexs.table, name: indexs.name)
+        end
+      end
+
+      def create_table_indexes(index_list, new_table)
+        puts_log "create_table_indexes"
+        index_list.each do |indexs|
+          generated_index_name = index_name(indexs.table, column: indexs.columns)
+          custom_index_name = indexs.name
+          
+          if generated_index_name == custom_index_name
+            add_index(new_table, indexs.columns, unique: indexs.unique)
+          else
+            add_index(new_table, indexs.columns, name: custom_index_name, unique: indexs.unique)
+          end
+        end
+      end
+
+      def drop_column_indexes(index_list, column_name)
+        puts_log "drop_column_indexes"
+        index_list.each do |indexs|
+          if indexs.columns.class == Array
+            next if !indexs.columns.include?(column_name)
+          else
+            next if indexs.columns != column_name
+          end
+          remove_index(indexs.table, name: indexs.name)
+        end
+      end
+
+      def create_column_indexes(index_list, column_name, new_column_name)
+        puts_log "create_column_indexes"
+        index_list.each do |indexs|
+          generated_index_name = index_name(indexs.table, column: indexs.columns)
+          custom_index_name = indexs.name
+          if indexs.columns.class == Array
+            next if !indexs.columns.include?(column_name)
+            indexs.columns[indexs.columns.index(column_name)] = new_column_name
+          else
+            next if indexs.columns != column_name
+            indexs.columns = new_column_name
+          end
+
+          if generated_index_name == custom_index_name
+            add_index(indexs.table, indexs.columns, unique: indexs.unique)
+          else
+            add_index(indexs.table, indexs.columns, name: custom_index_name, unique: indexs.unique)
+          end
+        end
+      end
+
+      # Renames a column in a table.
+      def rename_column(table_name, column_name, new_column_name) #:nodoc:
+        puts_log "rename_column"
+        column_name = quote_column_name(column_name)
+        new_column_name = quote_column_name(new_column_name)
+        puts_log "rename_column #{table_name}, #{column_name}, #{new_column_name}"
+        clear_cache!
+        index_list = indexes(table_name)
+        puts_log "Index List = #{index_list}"
+        fkey_list = foreign_keys(table_name)
+        puts_log "ForeignKey = #{fkey_list}"
+        drop_column_indexes(index_list, column_name)
+        fkey_removed = remove_foreign_key_byColumn(fkey_list, table_name, column_name)
+        execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
+        add_foreign_keyList(fkey_list, table_name, column_name, new_column_name) if fkey_removed
+        create_column_indexes(index_list, column_name, new_column_name)
+      end
+
+      def add_foreign_keyList(fkey_list, table_name, column_name, new_column_name)
+        puts_log "add_foreign_keyList = #{table_name}, #{column_name}, #{fkey_list}"
+        fkey_list.each do |fkey|
+          if fkey.options[:column] == column_name
+            add_foreign_key(table_name, fkey.to_table, column: new_column_name)
+          end
+        end
+      end
+
+      def remove_foreign_key_byColumn(fkey_list, table_name, column_name)
+        puts_log "remove_foreign_key_byColumn = #{table_name}, #{column_name}, #{fkey_list}"
+        fkey_removed = false
+        fkey_list.each do |fkey|
+          if fkey.options[:column] == column_name
+            remove_foreign_key(table_name, column: column_name)
+            fkey_removed = true
+          end
+        end
+        fkey_removed
+      end
+
+      def rename_index(table_name, old_name, new_name)
+	    puts_log "rename_index"
+        old_name = old_name.to_s
+        new_name = new_name.to_s
+        validate_index_length!(table_name, new_name)
+
+        # this is a naive implementation; some DBs may support this more efficiently (PostgreSQL, for instance)
+        old_index_def = indexes(table_name).detect { |i| i.name == old_name }
+        return unless old_index_def
+        remove_index(table_name, name: old_name)
+        add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
       end
 
       # Removes the column from the table definition.
       # ===== Examples
       #  remove_column(:suppliers, :qualification)
-      def remove_column(table_name, column_name)
+      def remove_column(table_name, column_name, type = nil, **options)
+        puts_log "remove_column"
+        return if options[:if_exists] == true && !column_exists?(table_name, column_name)
         @servertype.remove_column(table_name, column_name)
       end
 
@@ -2462,28 +2827,20 @@ module ActiveRecord
       #  change_column(:suppliers, :name, :string, :limit => 80)
       #  change_column(:accounts, :description, :text)
       def change_column(table_name, column_name, type, options = {})
+        puts_log "change_column"
         @servertype.change_column(table_name, column_name, type, options)
+        change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
       end
 
       #Add distinct clause to the sql if there is no order by specified
       def distinct(columns, order_by)
+        puts_log "distinct"
         if order_by.nil?
           "DISTINCT #{columns}" 
         else
           "#{columns}"
         end
       end
-	  
-	  def columns_for_distinct(columns, orders) #:nodoc:
-		  order_columns = orders.reject(&:blank?).map{ |s|
-			  # Convert Arel node to string
-			  s = s.to_sql unless s.is_a?(String)
-			  # Remove any ASC/DESC modifiers
-			  s.gsub(/\s+(?:ASC|DESC)\b/i, '')
-			   .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
-			}.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }			
-		  [super, *order_columns].join(', ')
-		end
 
       # Sets a new default value for a column. This does not set the default
       # value to +NULL+, instead, it needs DatabaseStatements#execute which
@@ -2493,43 +2850,42 @@ module ActiveRecord
       #  change_column_default(:accounts, :authorized, 1)
       # Method overriden to satisfy IBM data servers syntax.
       def change_column_default(table_name, column_name, default)
+        puts_log "change_column_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)
+        puts_log "change_column_null"
         @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).
-      #   remove_index :suppliers, :name
-      # Remove the index named accounts_branch_id in the accounts table.
-      #   remove_index :accounts, :column => :branch_id
-      # Remove the index named by_branch_party in the accounts table.
-      #   remove_index :accounts, :name => :by_branch_party
-      #
-      # You can remove an index on multiple columns by specifying the first column.
-      #   add_index :accounts, [:username, :password]
-      #   remove_index :accounts, :username
-      # Overriden to use the IBM data servers SQL syntax.
-      def remove_index(table_name, options = {})
-	      execute("DROP INDEX #{index_name(table_name, options)}")
+      def remove_index(table_name, column_name = nil, **options)
+        puts_log "remove_index"
+        return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+	    execute("DROP INDEX #{index_name_for_remove(table_name, column_name, options)}")
+      end
+
+      def column_for(table_name, column_name)
+        super
       end
 
       protected
-      def initialize_type_map(m) # :nodoc:
+      def initialize_type_map(m = type_map) # :nodoc:
+        puts_log "initialize_type_map"
         register_class_with_limit m, %r(boolean)i,   Type::Boolean
         register_class_with_limit m, %r(char)i,      Type::String
         register_class_with_limit m, %r(binary)i,    Type::Binary
         register_class_with_limit m, %r(text)i,      Type::Text
-        register_class_with_limit m, %r(date)i,      Type::Date
-        register_class_with_limit m, %r(time)i,      Type::Time
-        register_class_with_limit m, %r(datetime)i,  Type::DateTime
+        register_class_with_precision m, %r(date)i,      Type::Date
+        register_class_with_precision m, %r(time)i,      Type::Time
+        register_class_with_precision m, %r(datetime)i,  Type::DateTime
         register_class_with_limit m, %r(float)i,     Type::Float
-        register_class_with_limit m, %r(int)i,       Type::Integer
-		
+
+        m.register_type %r(^bigint)i,    Type::Integer.new(limit: 8)
+        m.register_type %r(^int)i,       Type::Integer.new(limit: 4)
+        m.register_type %r(^smallint)i,  Type::Integer.new(limit: 2)
+        m.register_type %r(^tinyint)i,   Type::Integer.new(limit: 1)
 		
         m.alias_type %r(blob)i,      'binary'
         m.alias_type %r(clob)i,      'text'
@@ -2552,13 +2908,20 @@ module ActiveRecord
 
         m.alias_type %r(xml)i,      'text'
         m.alias_type %r(for bit data)i,      'binary'
-        m.alias_type %r(smallint)i,      'boolean'
         m.alias_type %r(serial)i,      'int'
         m.alias_type %r(decfloat)i,      'decimal'
         m.alias_type %r(real)i,      'decimal'
         m.alias_type %r(graphic)i,      'binary'
         m.alias_type %r(rowid)i,      'int'
       end
+
+      class SchemaDumper < ConnectionAdapters::SchemaDumper
+        def dump(stream)    # Like in abstract class, we no need to call header() & trailer().
+          extensions(stream)
+          tables(stream)
+          stream
+        end
+      end
     end # class IBM_DBAdapter
 
     # This class contains common code across DB's (DB2 LUW, zOS, i5 and IDS)
@@ -2581,12 +2944,14 @@ module ActiveRecord
       end
 
       def check_reserved_words(col_name)
+        @adapter.puts_log "check_reserved_words"
         col_name.to_s
       end
 
       # This is supported by the DB2 for Linux, UNIX, Windows data servers
       # and by the DB2 for i5 data servers
       def remove_column(table_name, column_name)
+        @adapter.puts_log "remove_column"
         begin
           @adapter.execute "ALTER TABLE #{table_name} DROP #{column_name}"
           reorg_table(table_name)
@@ -2603,12 +2968,13 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def select(stmt)
+        @adapter.puts_log "select"
         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
         begin
-        if(@isAr3)
+          if(@isAr3)
             while single_hash = IBM_DB.fetch_assoc(stmt)
               # Add the record to the +results+ array
               results <<  single_hash
@@ -2633,6 +2999,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def select_rows(sql, name, stmt, results)
+        @adapter.puts_log "select_rows"
         # 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
@@ -2656,6 +3023,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
 
       # Praveen
       def prepare(sql,name = nil)
+        @adapter.puts_log "prepare"
         begin
           stmt = IBM_DB.prepare(@adapter.connection, sql)
           if( stmt )
@@ -2667,61 +3035,39 @@ To remove the column, the table must be dropped and recreated without the #{colu
           if prep_err && !prep_err.message.empty?
             raise "Failed to prepare sql #{sql} due to: #{prep_err}"
           else 
-            raise
+            raise "An unexpected error occurred during SQLprepare"
           end
         end
       end
 
       # Akhil Tcheck for if_exits added so that it will try to drop even if the table does not exit.
       def execute(sql, name = nil)
-      if name == nil || name.class == String
+        @adapter.puts_log "execute #{sql}"
+   
         begin
-          if stmt = IBM_DB.exec(@adapter.connection, sql)
+          if @adapter.connection == nil || @adapter.connection == false
+            raise ActiveRecord::ConnectionNotEstablished, "called on a closed database"
+          elsif stmt = IBM_DB.exec(@adapter.connection, sql)
             stmt   # Return the statement object
           else
-            raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
+            raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN ), sql
           end
         rescue StandardError => exec_err
           if exec_err && !exec_err.message.empty?
-            raise "Failed to execute statement due to: #{exec_err}"
+            @adapter.puts_log "104 error = #{exec_err.message}"
+            @adapter.puts_log "104 sql = #{sql}"
+            raise StatementInvalid
           else 
             raise
           end
         end
-      else
-        if name[:if_exists]
-          IBM_DB.exec(@adapter.connection, sql)
-        else
-          begin
-            if stmt = IBM_DB.exec(@adapter.connection, sql)
-              stmt   # Return the statement object
-            else
-              raise StatementInvalid, IBM_DB.getErrormsg(@adapter.connection, IBM_DB::DB_CONN )
-            end
-          rescue StandardError => exec_err
-            if exec_err && !exec_err.message.empty?
-              raise "Failed to execute statement due to: #{exec_err}"
-            else 
-              raise
-            end
-          end
-        end
-       end
       end
 
       def set_schema(schema)
+        @adapter.puts_log "set_schema"
         @adapter.execute("SET SCHEMA #{schema}")
       end
 
-      def query_offset_limit(sql, offset, limit)
-      end
-
-      def get_limit_offset_clauses(limit, offset)
-      end
-
-      def query_offset_limit!(sql, offset, limit, options)
-      end
-      
       def get_datetime_mapping
       end
 
@@ -2761,10 +3107,12 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def rename_column(table_name, column_name, new_column_name)
+        @adapter.puts_log "primary_key_definition"
         raise NotImplementedError, "rename_column is not implemented yet in the IBM_DB Adapter"
       end
 
       def primary_key_definition(start_id)
+        @adapter.puts_log "108"
         return "INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH #{start_id}) PRIMARY KEY NOT NULL"
       end
 
@@ -2773,6 +3121,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
       # The "stmt" parameter is ignored for DB2 but used for IDS
       def last_generated_id(stmt)
         # Queries the db to obtain the last ID that was automatically generated
+        @adapter.puts_log "last_generated_id"
         sql = "SELECT IDENTITY_VAL_LOCAL() FROM SYSIBM.SYSDUMMY1"
         stmt = IBM_DB.prepare(@adapter.connection, sql)
         if(stmt)
@@ -2781,7 +3130,8 @@ To remove the column, the table must be dropped and recreated without the #{colu
               # Fetches the only record available (containing the last id)
               IBM_DB.fetch_row(stmt)
               # Retrieves and returns the result of the query with the last id.
-              IBM_DB.result(stmt,0)
+              id_value = IBM_DB.result(stmt,0)
+              return id_value.to_i
             rescue StandardError => fetch_error # Handle driver fetch errors
               error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
               if error_msg && !error_msg.empty?
@@ -2815,33 +3165,54 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def change_column(table_name, column_name, type, options)
-        if !options[:default].nil?
-           change_column_default(table_name, column_name, options[:default])
-      else
+        @adapter.puts_log "change_column #{table_name.to_s}, #{column_name.to_s}, #{type.to_s}"
+        column = @adapter.column_for(table_name, column_name)
         data_type = @adapter.type_to_sql(type, options[:limit], options[:precision], options[:scale])
-        begin
-          execute "ALTER TABLE #{table_name} ALTER #{column_name} SET DATA TYPE #{data_type}"
-        rescue StandardError => exec_err
-          if exec_err.message.include?('SQLCODE=-190')
-            raise StatementInvalid, 
-            "Please consult documentation for compatible data types while changing column datatype. \
-The column datatype change to [#{data_type}] is not supported by this data server: #{exec_err}"
-          else
-            raise "#{exec_err}"
+
+        if column.sql_type != data_type
+          begin
+            execute "ALTER TABLE #{table_name} ALTER #{column_name} SET DATA TYPE #{data_type}"
+          rescue StandardError => exec_err
+            if exec_err.message.include?('SQLCODE=-190')
+              raise StatementInvalid, 
+              "Please consult documentation for compatible data types while changing column datatype. \
+               The column datatype change to [#{data_type}] is not supported by this data server: #{exec_err}"
+            else
+              raise "#{exec_err}"
+            end
           end
+          reorg_table(table_name)
+        end
+
+        if options.key?(:default)
+          change_column_default(table_name, column_name, options[:default])
+        end
+        if options.key?(:null)
+          change_column_null(table_name, column_name, options[:null], nil)
+        end
+      end
+
+      def extract_new_default_value(default_or_changes)
+	    @adapter.puts_log "extract_new_default_value"
+        if default_or_changes.is_a?(Hash) && default_or_changes.has_key?(:from) && default_or_changes.has_key?(:to)
+          default_or_changes[:to]
+        else
+          default_or_changes
         end
-        reorg_table(table_name)
-        change_column_null(table_name,column_name,options[:null],nil)
-        change_column_default(table_name, column_name, options[:default])
-        reorg_table(table_name)
       end
-    end
 
       # DB2 specific ALTER TABLE statement to add a default clause
       def change_column_default(table_name, column_name, default)
+        @adapter.puts_log "change_column_default #{table_name.to_s} #{column_name.to_s}"
+        @adapter.puts_log "Default: #{default}"
+
+        default = extract_new_default_value(default)
         # SQL statement which alters column's default value
-        change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} \
-SET WITH DEFAULT #{@adapter.quote(default)}"
+        if default.nil?
+          change_column_sql = "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET WITH DEFAULT NULL"
+        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)
@@ -2851,6 +3222,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
 
       #DB2 specific ALTER TABLE statement to change the nullability of a column
       def change_column_null(table_name, column_name, null, default)
+        @adapter.puts_log "change_column_null #{table_name.to_s} #{column_name.to_s}"
         if !default.nil?
           change_column_default(table_name, column_name, default)
         end 
@@ -2872,131 +3244,47 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       # This method returns the DB2 SQL type corresponding to the Rails
       # datetime/timestamp type
       def get_datetime_mapping
+        @adapter.puts_log "get_datetime_mapping"
         return "timestamp"
       end
 
       # This method returns the DB2 SQL type corresponding to the Rails
       # time type
       def get_time_mapping
+        @adapter.puts_log "get_time_mapping"
         return "time"
       end
 
       #This method returns the DB2 SQL type corresponding to Rails double type
       def get_double_mapping
+        @adapter.puts_log "get_double_mapping"
         return "double"
       end
 
-      def get_limit_offset_clauses(limit, offset)
-        retHash = {"endSegment"=> "", "startSegment" => ""}
-        if(offset.nil? && limit.nil?)
-          return retHash
-        end
-
-		
-        if (offset.nil?)
-           retHash["endSegment"] = " FETCH FIRST #{limit} ROWS ONLY"
-           return retHash
-        end
-
-        #if(limit.nil?)
-		if(limit.nil?)
-          #retHash["startSegment"] = "SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM ( SELECT "
-          retHash["startSegment"] = "SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (  "
-          retHash["endSegment"] = " ) AS I) AS O WHERE sys_row_num > #{offset}"
-          return retHash
-        end
-
-        # Defines what will be the last record
-        last_record = offset.to_i + limit.to_i
-        #retHash["startSegment"] = "SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM ( SELECT "
-        retHash["startSegment"] = "SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (  "
-        
-		if last_record < offset+1 		
-			retHash["endSegment"] = " ) AS I) AS O WHERE sys_row_num BETWEEN #{last_record} AND #{offset+1}"
-		else
-			retHash["endSegment"] = " ) AS I) AS O WHERE sys_row_num BETWEEN #{offset+1} AND #{last_record}"
-		end
-				
-        return retHash
-      end
-
-      def query_offset_limit(sql, offset, limit)
-        if(offset.nil? && limit.nil?)
-          return sql
-        end
-
-        if (offset.nil?)
-           return sql << " FETCH FIRST #{limit} ROWS ONLY"
-        end
-
-        if(limit.nil?)
-          sql.sub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
-          return sql << ") AS I) AS O WHERE sys_row_num > #{offset}"
-        end
-
-        # Defines what will be the last record
-        last_record = offset + limit
-        # Transforms the SELECT query in order to retrieve/fetch only
-        # a number of records after the specified offset.
-        # 'select' or 'SELECT' is replaced with the partial query below that adds the sys_row_num column
-        # to select with the condition of this column being between offset+1 and the offset+limit
-        sql.sub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
-        # The final part of the query is appended to include a WHERE...BETWEEN...AND condition,
-        # and retrieve only a LIMIT number of records starting from the OFFSET+1
-        sql << ") AS I) AS O WHERE sys_row_num BETWEEN #{offset+1} AND #{last_record}"
-      end
-
-      def query_offset_limit!(sql, offset, limit, options)
-        if(offset.nil? && limit.nil?)
-          options[:paramArray] = []
-          return sql
-        end
-
-        if (offset.nil?)
-           options[:paramArray] = []
-           return sql << " FETCH FIRST #{limit} ROWS ONLY"
-        end
-    
-        if(limit.nil?)
-          sql.sub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
-          sql << ") AS I) AS O WHERE sys_row_num > ?"
-          options[:paramArray] = [offset]
-          return 
-        end
-
-        # Defines what will be the last record
-        last_record = offset + limit
-        # Transforms the SELECT query in order to retrieve/fetch only
-        # a number of records after the specified offset.
-        # 'select' or 'SELECT' is replaced with the partial query below that adds the sys_row_num column
-        # to select with the condition of this column being between offset+1 and the offset+limit
-        sql.sub!(/SELECT/i,"SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM (SELECT")
-        # The final part of the query is appended to include a WHERE...BETWEEN...AND condition,
-        # and retrieve only a LIMIT number of records starting from the OFFSET+1
-        sql << ") AS I) AS O WHERE sys_row_num BETWEEN ? AND ?"
-        options[:paramArray] = [offset+1, last_record]
-      end
-
       # This method generates the default blob value specified for 
       # DB2 Dataservers
       def set_binary_default(value)
+        @adapter.puts_log "set_binary_default"
         "BLOB('#{value}')"
       end
 
       # This method generates the blob value specified for DB2 Dataservers
       def set_binary_value
+        @adapter.puts_log "set_binary_value"
         "BLOB('?')"
       end
 
       # This method generates the default clob value specified for 
       # DB2 Dataservers
       def set_text_default(value)
+        @adapter.puts_log "set_text_default"
         "'#{value}'"
       end
 
       # For DB2 Dataservers , the arguments to the meta-data functions
       # need to be in upper-case
       def set_case(value)
+        @adapter.puts_log "set_case"
         value.upcase
       end
     end # class IBM_DB2
@@ -3059,6 +3347,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       if rfile
         RESERVED_WORDS = open(rfile.to_s) {|f| YAML.load(f) }
         def check_reserved_words(col_name)
+          puts_log "164"
           if RESERVED_WORDS[col_name]
             '"' + RESERVED_WORDS[col_name] + '"'
           else
@@ -3140,28 +3429,6 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
     class IBM_DB2_ZOS_8 < IBM_DB2_ZOS
       include HostedDataServer
 
-      def get_limit_offset_clauses(limit, offset)
-        retHash = {"startSegment" => "", "endSegment" => ""}
-        if (!limit.nil?)
-           retHash["endSegment"] = " FETCH FIRST #{limit} ROWS ONLY"
-        end
-        return retHash
-      end
-
-      def query_offset_limit(sql, offset, limit)
-        if (!limit.nil?)
-           sql << " FETCH FIRST #{limit} ROWS ONLY"
-        end
-        return sql
-      end
-
-      def query_offset_limit!(sql, offset, limit, options)
-        if (!limit.nil?)
-           sql << " FETCH FIRST #{limit} ROWS ONLY"
-        end
-        options[:paramArray] = []
-      end
-
       # This call is needed on DB2 z/OS v8 for the creation of tables
       # with LOBs.  When issued, this call does the following:
       #   DB2 creates LOB table spaces, auxiliary tables, and indexes on auxiliary
@@ -3310,56 +3577,6 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         return "double precision"
       end
 
-      def get_limit_offset_clauses(limit, offset)
-        retHash = {"startSegment" => "", "endSegment" => ""}
-        if limit != 0
-          if !offset.nil?
-            # Modifying the SQL to utilize the skip and limit amounts
-            retHash["startSegment"] = " SELECT SKIP #{offset} LIMIT #{limit} "
-          else
-            # Modifying the SQL to retrieve only the first #{limit} rows
-            retHash["startSegment"] = " SELECT FIRST #{limit} "
-          end
-        else
-          retHash["startSegment"] = " SELECT * FROM (SELECT "
-          retHash["endSegment"] = " ) WHERE 0 = 1 "
-        end
-      end
-
-      # Handling offset/limit as per Informix requirements
-      def query_offset_limit(sql, offset, limit)
-        if limit != 0
-          if !offset.nil?
-            # Modifying the SQL to utilize the skip and limit amounts
-            sql.gsub!(/SELECT/i,"SELECT SKIP #{offset} LIMIT #{limit}")
-          else
-            # Modifying the SQL to retrieve only the first #{limit} rows
-            sql = sql.gsub!("SELECT","SELECT FIRST #{limit}")
-          end
-        else
-          # Modifying the SQL to ensure that no rows will be returned
-          sql.gsub!(/SELECT/i,"SELECT * FROM (SELECT")
-          sql << ") WHERE 0 = 1"
-        end
-      end
-
-      # Handling offset/limit as per Informix requirements
-      def query_offset_limit!(sql, offset, limit, options)
-        if limit != 0
-          if !offset.nil?
-            # Modifying the SQL to utilize the skip and limit amounts
-            sql.gsub!(/SELECT/i,"SELECT SKIP #{offset} LIMIT #{limit}")
-          else
-            # Modifying the SQL to retrieve only the first #{limit} rows
-            sql = sql.gsub!("SELECT","SELECT FIRST #{limit}")
-          end
-        else
-          # Modifying the SQL to ensure that no rows will be returned
-          sql.gsub!(/SELECT/i,"SELECT * FROM (SELECT")
-          sql << ") WHERE 0 = 1"
-        end
-      end
-
       # Method that returns the last automatically generated ID
       # on the given +@connection+. This method is required by the +insert+ 
       # method. IDS returns the last generated serial value in the SQLCA unlike 
@@ -3406,72 +3623,73 @@ end # module ActiveRecord
 
 module Arel
 #Check Arel version
-      begin
-        arelVersion = Arel::VERSION.to_i
-      rescue
-        arelVersion = 0
-      end
-if(arelVersion >= 6)
-module Collectors
-    class Bind
-      def changeFirstSegment(segment)
-        @parts[0] = segment
-      end
+  begin
+    arelVersion = Arel::VERSION.to_i
+  rescue
+    arelVersion = 0
+  end
+  if(arelVersion >= 6)
+    module Collectors
+      class Bind
+        def changeFirstSegment(segment)
+          @parts[0] = segment
+        end
 
-      def changeEndSegment(segment)
-        len = @parts.length
-        @parts[len] = segment
+        def changeEndSegment(segment)
+          len = @parts.length
+          @parts[len] = segment
+        end
       end
     end
   end
-end  
   
   module Visitors
     class Visitor #opening and closing the class to ensure backward compatibility
     end
 	
-#Check Arel version
-      begin
-        arelVersion = Arel::VERSION.to_i
-      rescue
-        arelVersion = 0
-      end
-if(arelVersion >= 6  && arelVersion <= 9)	
-    class ToSql < Arel::Visitors::Reduce #opening and closing the class to ensure backward compatibility
-      # In case when using Rails-2.3.x there is no arel used due to which the constructor has to be defined explicitly
-      # to ensure the same code works on any version of Rails
+    #Check Arel version
+    begin
+      arelVersion = Arel::VERSION.to_i
+    rescue
+      arelVersion = 0
+    end
+
+	if(arelVersion >= 6  && arelVersion <= 9)
+      class ToSql < Arel::Visitors::Reduce #opening and closing the class to ensure backward compatibility
+        # In case when using Rails-2.3.x there is no arel used due to which the constructor has to be defined explicitly
+        # to ensure the same code works on any version of Rails
       
-      #Check Arel version
-      begin
-        @arelVersion = Arel::VERSION.to_i
-      rescue
-        @arelVersion = 0
-      end
+        #Check Arel version
+        begin
+          @arelVersion = Arel::VERSION.to_i
+        rescue
+          @arelVersion = 0
+        end
 
-      if(@arelVersion >= 3)
-        def initialize connection
-          super()
-          @connection     = connection
-          @schema_cache   = connection.schema_cache if(connection.respond_to?(:schema_cache))
-          @quoted_tables  = {}
-          @quoted_columns = {}
-          @last_column    = nil
+        if(@arelVersion >= 3)
+          def initialize connection
+            super()
+            @connection     = connection
+            @schema_cache   = connection.schema_cache if(connection.respond_to?(:schema_cache))
+            @quoted_tables  = {}
+            @quoted_columns = {}
+            @last_column    = nil
+          end
         end
       end
-    end
-else
-	class ToSql < Arel::Visitors::Visitor #opening and closing the class to ensure backward compatibility    
-	# In case when using Rails-2.3.x there is no arel used due to which the constructor has to be defined explicitly
-      # to ensure the same code works on any version of Rails
+    else
+	  class ToSql < Arel::Visitors::Visitor #opening and closing the class to ensure backward compatibility
+	    # In case when using Rails-2.3.x there is no arel used due to which the constructor has to be defined explicitly
+        # to ensure the same code works on any version of Rails
                          
 		#Check Arel version
-		  begin
-			@arelVersion = Arel::VERSION.to_i
+		begin
+		  @arelVersion = Arel::VERSION.to_i
 		  rescue
 			@arelVersion = 0
 		  end
-	     if(@arelVersion >= 3)	
-		 def initialize connection
+	      if(@arelVersion >= 3)
+		  def initialize connection
 			super()		 
           @connection     = connection
           @schema_cache   = connection.schema_cache if(connection.respond_to?(:schema_cache))
@@ -3482,42 +3700,42 @@ else
 			  
       end
     end
-	
-end	
-      
-
-    class IBM_DB < Arel::Visitors::ToSql
-      private
+  end
 
-        
-      def visit_Arel_Nodes_Limit o,collector
-	collector << " FETCH FIRST "
+  class IBM_DB < Arel::Visitors::ToSql
+    private
+      def visit_Arel_Nodes_Limit(o, collector)
+        collector << " FETCH FIRST "
         visit o.expr, collector
-	collector << " ROWS ONLY "
+        collector << " ROWS ONLY "
       end
 
-      def visit_Arel_Nodes_Offset o,collector
-        visit o.expr,collector
+      def visit_Arel_Nodes_Offset(o, collector)
+        collector << " OFFSET "
+        visit o.expr, collector
+        collector << " ROWS"
       end
+
       def visit_Arel_Nodes_ValuesList(o, collector)
-          collector << "VALUES "
-          o.rows.each_with_index do |row, i|
-            collector << ", " unless i == 0
-            collector << "("
-            row.each_with_index do |value, k|
-            collector << ", " unless k == 0
-            case value
-              when Nodes::SqlLiteral, Nodes::BindParam
-                collector = visit(value, collector)
-                #collector << quote(value).to_s
-              else
-                collector << value.to_s
-              end
+        collector << "VALUES "
+        o.rows.each_with_index do |row, i|
+          collector << ", " unless i == 0
+          collector << "("
+          row.each_with_index do |value, k|
+          collector << ", " unless k == 0
+          case value
+            when Nodes::SqlLiteral, Nodes::BindParam
+              collector = visit(value, collector)
+              #collector << quote(value).to_s
+            else
+              collector << quote(value).to_s
             end
-            collector << ")"
           end
-          collector
+          collector << ")"
+        end
+        collector
       end
+      
       def visit_Arel_Nodes_SelectStatement o, collector
         if o.with
           collector = visit o.with, collector
@@ -3533,61 +3751,27 @@ end
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
             collector = visit(x, collector)
-            collector << "," unless len == i
+            collector << ", " unless len == i
           }
         end
 
-		
-#        if o.limit
-#          limcoll = Arel::Collectors::SQLString.new
-#          visit(o.limit,limcoll)
-#          limit = limcoll.value.to_i
-#        else
-#          limit = nil
-#        end
-#				
-#        if o.offset
-#          offcoll = Arel::Collectors::SQLString.new
-#          visit(o.offset,offcoll)
-#          offset = offcoll.value.to_i
-#        else
-#          offset = nil
-#        end
-#		
-#        limOffClause = @connection.get_limit_offset_clauses(limit,offset)
-#		
-#        if( !limOffClause["startSegment"].empty? ) 
-#          #collector.changeFirstSegment(limOffClause["startSegment"])	
-#          collector.value.prepend(limOffClause["startSegment"])		  
-#        end
-#        
-#        if( !limOffClause["endSegment"].empty? )
-#          #collector.changeEndSegment(limOffClause["endSegment"])
-#          collector << " "
-#          collector << limOffClause["endSegment"]
-#        end
-
-        #Initialize a new Collector and set its value to the sql string built so far with any limit and ofset modifications
-        #collector.reset(sql)
-       if (o.limit && o.offset.nil?)
-         visit(o.limit, collector)
-       end
-              if (o.offset && o.limit.nil?)
-         collector.value.prepend(" SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM ( ")
-         collector << (" ) AS I) AS O WHERE sys_row_num > ")
-         visit(o.offset, collector)
-       end
-
-       if (o.offset && o.limit)
-         collector.value.prepend(" SELECT O.* FROM (SELECT I.*, ROW_NUMBER() OVER () sys_row_num FROM ( ")
-         collector << (" ) AS I) AS O WHERE sys_row_num > ")
-         visit(o.offset, collector)
-         visit(o.limit, collector)
-       end 
-       collector = maybe_visit o.lock, collector
-       return collector
+        if (o.offset && o.limit)
+          visit_Arel_Nodes_Offset(o.offset, collector)
+          visit_Arel_Nodes_Limit(o.limit, collector)
+        elsif (o.offset && o.limit.nil?)
+          collector << " OFFSET "
+          visit o.offset.expr, collector
+          collector << " ROWS "
+          maybe_visit o.lock, collector
+        else
+          visit_Arel_Nodes_SelectOptions(o, collector)
+        end
+      end
+
+      # Locks are not supported in SQLite
+      def visit_Arel_Nodes_Lock(o, collector)
+        collector
       end
-	
     end
   end
 end