ibm_db 3.0.5-x86-mingw32 → 5.0.5-x86-mingw32

data/ext/mkmf.log

@@ -0,0 +1,110 @@
+gil_release_version is:
+/* begin */
+1: #ifndef GIL_RELEASE_VERSION
+2: #define GIL_RELEASE_VERSION
+3: #endif
+/* end */
+
+unicode_support_version is:
+/* begin */
+1: #ifndef UNICODE_SUPPORT_VERSION
+2: #define UNICODE_SUPPORT_VERSION
+3: #endif
+/* end */
+
+have_library: checking for SQLConnect() in -ldb2cli... -------------------- yes
+
+"i686-w64-mingw32-gcc -o conftest.exe -IC:/Ruby26/include/ruby-2.6.0/i386-mingw32 -IC:/Ruby26/include/ruby-2.6.0/ruby/backward -IC:/Ruby26/include/ruby-2.6.0 -I. -IC:\clidriver\32-bit\clidriver/include -D__USE_MINGW_ANSI_STDIO=1 -DFD_SETSIZE=2048 -D_WIN32_WINNT=0x0600 -D__MINGW_USE_VC2005_COMPAT -D_FILE_OFFSET_BITS=64  -O3 -fno-fast-math conftest.c  -L. -LC:/Ruby26/lib -LC:\clidriver\32-bit\clidriver/lib -L. -pipe -s     -lmsvcrt-ruby260  -lshell32 -lws2_32 -liphlpapi -limagehlp -lshlwapi  "
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: #include <winsock2.h>
+4: #include <windows.h>
+5: int main(int argc, char **argv)
+6: {
+7:   return 0;
+8: }
+/* end */
+
+"i686-w64-mingw32-gcc -o conftest.exe -IC:/Ruby26/include/ruby-2.6.0/i386-mingw32 -IC:/Ruby26/include/ruby-2.6.0/ruby/backward -IC:/Ruby26/include/ruby-2.6.0 -I. -IC:\clidriver\32-bit\clidriver/include -D__USE_MINGW_ANSI_STDIO=1 -DFD_SETSIZE=2048 -D_WIN32_WINNT=0x0600 -D__MINGW_USE_VC2005_COMPAT -D_FILE_OFFSET_BITS=64  -O3 -fno-fast-math conftest.c  -L. -LC:/Ruby26/lib -LC:\clidriver\32-bit\clidriver/lib -L. -pipe -s     -lmsvcrt-ruby260 -ldb2cli  -lshell32 -lws2_32 -liphlpapi -limagehlp -lshlwapi  "
+conftest.c: In function 't':
+conftest.c:17:57: error: 'SQLConnect' undeclared (first use in this function); did you mean 'WSAConnect'?
+   17 | int t(void) { void ((*volatile p)()); p = (void ((*)()))SQLConnect; return !p; }
+      |                                                         ^~~~~~~~~~
+      |                                                         WSAConnect
+conftest.c:17:57: note: each undeclared identifier is reported only once for each function it appears in
+checked program was:
+/* begin */
+ 1: #include "ruby.h"
+ 2: 
+ 3: #include <winsock2.h>
+ 4: #include <windows.h>
+ 5: 
+ 6: /*top*/
+ 7: extern int t(void);
+ 8: int main(int argc, char **argv)
+ 9: {
+10:   if (argc > 1000000) {
+11:     int (* volatile tp)(void)=(int (*)(void))&t;
+12:     printf("%d", (*tp)());
+13:   }
+14: 
+15:   return 0;
+16: }
+17: int t(void) { void ((*volatile p)()); p = (void ((*)()))SQLConnect; return !p; }
+/* end */
+
+"i686-w64-mingw32-gcc -o conftest.exe -IC:/Ruby26/include/ruby-2.6.0/i386-mingw32 -IC:/Ruby26/include/ruby-2.6.0/ruby/backward -IC:/Ruby26/include/ruby-2.6.0 -I. -IC:\clidriver\32-bit\clidriver/include -D__USE_MINGW_ANSI_STDIO=1 -DFD_SETSIZE=2048 -D_WIN32_WINNT=0x0600 -D__MINGW_USE_VC2005_COMPAT -D_FILE_OFFSET_BITS=64  -O3 -fno-fast-math conftest.c  -L. -LC:/Ruby26/lib -LC:\clidriver\32-bit\clidriver/lib -L. -pipe -s     -lmsvcrt-ruby260 -ldb2cli  -lshell32 -lws2_32 -liphlpapi -limagehlp -lshlwapi  "
+checked program was:
+/* begin */
+ 1: #include "ruby.h"
+ 2: 
+ 3: #include <winsock2.h>
+ 4: #include <windows.h>
+ 5: 
+ 6: /*top*/
+ 7: extern int t(void);
+ 8: int main(int argc, char **argv)
+ 9: {
+10:   if (argc > 1000000) {
+11:     int (* volatile tp)(void)=(int (*)(void))&t;
+12:     printf("%d", (*tp)());
+13:   }
+14: 
+15:   return 0;
+16: }
+17: extern void SQLConnect();
+18: int t(void) { SQLConnect(); return 0; }
+/* end */
+
+--------------------
+
+have_header: checking for gil_release_version... -------------------- yes
+
+"i686-w64-mingw32-gcc -E -IC:/Ruby26/include/ruby-2.6.0/i386-mingw32 -IC:/Ruby26/include/ruby-2.6.0/ruby/backward -IC:/Ruby26/include/ruby-2.6.0 -I. -IC:\clidriver\32-bit\clidriver/include -D__USE_MINGW_ANSI_STDIO=1 -DFD_SETSIZE=2048 -D_WIN32_WINNT=0x0600 -D__MINGW_USE_VC2005_COMPAT -D_FILE_OFFSET_BITS=64  -O3 -fno-fast-math  conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: #include <winsock2.h>
+4: #include <windows.h>
+5: #include <gil_release_version>
+/* end */
+
+--------------------
+
+have_header: checking for unicode_support_version... -------------------- yes
+
+"i686-w64-mingw32-gcc -E -IC:/Ruby26/include/ruby-2.6.0/i386-mingw32 -IC:/Ruby26/include/ruby-2.6.0/ruby/backward -IC:/Ruby26/include/ruby-2.6.0 -I. -IC:\clidriver\32-bit\clidriver/include -D__USE_MINGW_ANSI_STDIO=1 -DFD_SETSIZE=2048 -D_WIN32_WINNT=0x0600 -D__MINGW_USE_VC2005_COMPAT -D_FILE_OFFSET_BITS=64  -O3 -fno-fast-math  conftest.c -o conftest.i"
+checked program was:
+/* begin */
+1: #include "ruby.h"
+2: 
+3: #include <winsock2.h>
+4: #include <windows.h>
+5: #include <unicode_support_version>
+/* end */
+
+--------------------
+

data/ext/unicode_support_version

@@ -0,0 +1,3 @@
+#ifndef UNICODE_SUPPORT_VERSION
+#define UNICODE_SUPPORT_VERSION
+#endif

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -1,7 +1,7 @@
 # +----------------------------------------------------------------------+
 # |  Licensed Materials - Property of IBM                                |
 # |                                                                      |
-# | (C) Copyright IBM Corporation 2006- 2016           					 |
+# | (C) Copyright IBM Corporation 2006- 2018           					 |
 # +----------------------------------------------------------------------+
 # |  Authors: Antonio Cangiano <cangiano@ca.ibm.com>                     |
 # |         : Mario Ds Briggs  <mario.briggs@in.ibm.com>                 |
@@ -9,115 +9,163 @@
 # |         : Arvind Gupta     <arvindgu@in.ibm.com>                     |
 # +----------------------------------------------------------------------+
 
+
 require 'active_record/connection_adapters/abstract_adapter'
-require 'arel/visitors/bind_visitor'
+require 'arel/visitors/visitor'
 require 'active_support/core_ext/string/strip'
+require 'active_record/type'
+require 'active_record/connection_adapters/sql_type_metadata'
+
+
+
+module CallChain
+  def self.caller_method(depth=1)
+		parse_caller(caller(depth+1).first).last
+	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 Relation
-    def insert(values)
-      primary_key_value = nil
 
-      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
+	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
       end
+			end
+		end
+	end
+  
+  
+ 
+	class Relation
 
-      im = arel.create_insert
-      im.into @table
+    def insert(values)
+			primary_key_value = nil
 
-      conn = @klass.connection
+			if primary_key && Hash === values
+				primary_key_value = values[values.keys.find { |k|
+				k.name == primary_key
+			}]
 
-      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 !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
 
-      substitutes.each_with_index do |tuple, i|
-        tuple[1] = conn.substitute_at(binds[i][0], i)
-      end
+			im = arel.create_insert
+			im.into @table
 
-      if values.empty? # empty insert
-        im.values = Arel.sql(connection.empty_insert_statement_value(klass.primary_key))
-      else
-        im.insert substitutes
-      end
+			conn = @klass.connection
 
-      conn.insert(
-        im,
-        'SQL',
-        primary_key,
-        primary_key_value,
-        nil,
-        binds)
-    end
-  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
+
+			#substitutes.each_with_index do |tuple, i|
+			#  tuple[1] = conn.substitute_at(binds[i][0], i)
+			#end
+
+			substitutes, binds = substitute_values values
 
-  class Base
+
+			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
+	
+	
+
+	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|		
-              # Adds the selected columns to the query
-              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
+		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]
+				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)
@@ -148,6 +196,7 @@ module ActiveRecord
     end # 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
     def self.ibm_db_connection(config)
@@ -160,16 +209,16 @@ module ActiveRecord
       end
 
       #if( config.has_key?(:parameterized) && config[:parameterized] == true )
-      #  require 'active_record/connection_adapters/ibm_db_pstmt'
-      #end
+       # 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(nil)
+      checkClass = ActiveRecord::ConnectionAdapters::TableDefinition.new(self,nil)
 	  if(checkClass.respond_to?(:indexes))
 	    isAr3 = false
 	  else
-	    isAr3 = true
+	    isAr3= true
 	  end
       # Converts all +config+ keys to symbols
       config = config.symbolize_keys
@@ -252,7 +301,6 @@ module ActiveRecord
           conn_string << "SECURITY=#{config[:security]};" if config.has_key?(:security)
           conn_string << "AUTHENTICATION=#{config[:authentication]};" if config.has_key?(:authentication)
           conn_string << "CONNECTTIMEOUT=#{config[:timeout]};" if config.has_key?(:timeout)
-        
           connection = IBM_DB.connect( conn_string, '', '', conn_options, set_quoted_literal_replacement )
         else
           # No host implies a local catalog-based connection: +database+ represents catalog alias
@@ -278,40 +326,144 @@ 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
+    	
+	module Quoting
+    def lookup_cast_type_from_column(column) # :nodoc:
+		  lookup_cast_type(column.sql_type_metadata)
+    end		
+	end
+	
+	module Savepoints
+    def create_savepoint(name = current_savepoint_name)
+			execute("SAVEPOINT #{name} ON ROLLBACK RETAIN CURSORS")
+		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
+					
+			if scale = schema_scale(column)
+			  spec[:scale] = scale
+			end
+						
+			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
+						
+			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  
+
+	end
+
     module SchemaStatements
-      def create_table_definition(name, temporary, options,as = nil)
+	
+    def internal_string_options_for_primary_key # :nodoc:
+			{ primary_key: true}		
+			{ version_options: "PRIMARY KEY NOT NULL"}					
+		 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
+	   
+=begin
+	  def create_table_definition(name, temporary, options,as = nil)
         TableDefinition.new self, name, temporary, 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?
+    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
+			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
+			execute schema_creation.accept(at)
+		end
+	end #end of Module SchemaStatements
 	
-    class IBM_DBColumn < Column
-
+		
+    #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)
@@ -321,239 +473,234 @@ module ActiveRecord
         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
 
-       private
-      # Mapping IBM data servers SQL datatypes to Ruby data types
-      def simplified_type(field_type)
-        case field_type
-          # if +field_type+ contains 'for bit data' handle it as a binary
-          when /for bit data/i
-            :binary
-          when /smallint/i
-            :boolean
-          when /int|serial/i
-            :integer
-          when /decimal|numeric|decfloat/i
-            :decimal
-          when /float|double|real/i
-            :float
-          when /timestamp|datetime/i
-            :timestamp
-          when /time/i
-            :time
-          when /date/i
-            :date
-          when /vargraphic/i
-            :vargraphic
-          when /graphic/i
-            :graphic
-          when /clob|text/i
-            :text
-          when /xml/i
-            :xml
-          when /blob|binary/i
-            :binary
-          when /char/i
-            :string
-          when /boolean/i
-            :boolean
-          when /rowid/i  # rowid is a supported datatype on z/OS and i/5
-            :rowid
-        end
-      end # method simplified_type
+		# 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
 
-    class Table
-      
-      #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 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
+	module ColumnMethods
+	
+      def primary_key(name, type = :primary_key, **options)
+			  column(name, type, options.merge(primary_key: true))
+		  end
+	  
+		##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 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 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
+		  #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
+		  def graphic(*args)
+			ibm_parse_column_attributes_args('graphic',*args)
+			return self
+		  end
 
-      def vargraphic(*args)
-        ibm_parse_column_attributes_args('vargraphic',*args)
-        return self
-      end
+		  def vargraphic(*args)
+			ibm_parse_column_attributes_args('vargraphic',*args)
+			return self
+		  end
 
-      def bigint(*args)
-        ibm_parse_column_attributes_args('bigint',*args)
-        return self
-      end
+		  def bigint(*args)
+			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)
-        ibm_parse_column_attributes_args('char',*args)
-        return self
-      end
-      alias_method :character, :char
-    end
+		  #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
+		  def char(*args)
+			ibm_parse_column_attributes_args('char',*args)
+			return self
+		  end
+		  alias_method :character, :char
+		end
 
-    class TableDefinition
+		#class TableDefinition    
+		class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+		 include ColumnMethods
 
-      def initialize(base, name=nil, temporary=nil, options=nil)
-        if(self.respond_to?(:indexes))
-          @ar3 = false
-        else
-          @ar3 = true
-        end
-        @columns = []
-        @columns_hash = {}
-        @indexes = {}
-        @base = base
-        @temporary = temporary
-        @options = options
-        @name = name
-        @foreign_keys = {}
-      end
+=begin
+		  def initialize(base, name=nil, temporary=nil, options=nil)
 
-      def native
-        @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
-      end
-      private :ibm_parse_column_attributes_args
+			if(self.respond_to?(:indexes))
+			  @ar3 = false
+			else
+			  @ar3 = true
+			end
 
-      #Method to support the new syntax of rails 2.0 migrations for columns of type xml 
-      def xml(*args )
-        ibm_parse_column_attributes_args('xml', *args)
-        return self
-      end
+			@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
 
-      #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
+		  def native
+			@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
+		  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 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 for columns of type xml 
+		  def xml(*args )
+			ibm_parse_column_attributes_args('xml', *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 double
+		  def double(*args)
+			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)
+			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)
+			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)
+			ibm_parse_column_attributes_args('vargraphic',*args)
+			return self
+		  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
-        if(@ar3)
-          column = ColumnDefinition.new(@base, name, type)
-        else
-          column = ColumnDefinition.new(name, type)
-        end
-        # 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
+		  def bigint(*args)
+			ibm_parse_column_attributes_args('bigint',*args)
+			return self
+		  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
+		  #Method to support the new syntax of rails 2.0 migrations (short-hand definitions) for columns of type char [character]
+		  def char(*args)
+			  ibm_parse_column_attributes_args('char',*args)
+		  	return self
+		  end
+		  alias_method :character, :char
+
+		  # Overrides the abstract adapter in order to handle
+		  # the DEFAULT option for the native XML datatype
+		  def column(name, type, options ={})
+      # construct a column definition where @base is adaptor instance
+			column = ColumnDefinition.new(name, type)
+			
+			# 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
 
-        unless @columns.nil? or @columns.include? column
-          @columns << column 
-        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
 
-        @columns_hash[name] = column
+			unless @columns.nil? or @columns.include? column
+			  @columns << column 
+			end
 
-        return self
-      end
-    end
+			@columns_hash[name] = column
+
+			return self
+		  end
+		end
+	end
 
     # The IBM_DB Adapter requires the native Ruby driver (ibm_db)
     # for IBM data servers (ibm_db.so).
@@ -597,11 +744,12 @@ module ActiveRecord
       end
 
       class BindSubstitution < Arel::Visitors::IBM_DB # :nodoc:
-          include Arel::Visitors::BindVisitor
+          include Arel::Visitors
       end
 
       def initialize(connection, ar3, logger, config, conn_options)
-        # Caching database connection configuration (+connect+ or +reconnect+ support)
+        # Caching database connection configuration (+connect+ or +reconnect+ support)\
+	@config = config
         @connection       = connection
 		@isAr3            = ar3
         @conn_options     = conn_options
@@ -631,7 +779,7 @@ module ActiveRecord
 
         # Calls the parent class +ConnectionAdapters+' initializer
         # which sets @connection, @logger, @runtime and @last_verification
-        super(@connection, logger)
+        super(@connection, logger, @config)
 
         if @connection
           server_info = IBM_DB.server_info( @connection )
@@ -763,7 +911,7 @@ module ActiveRecord
       rescue
         @arelVersion = 0
       end
-	if(@arelVersion < 6)	  
+	  if(@arelVersion < 6 )	  
 		  def to_sql(arel, binds = [])
 			if arel.respond_to?(:ast)
 			  visitor.accept(arel.ast) do
@@ -785,8 +933,11 @@ module ActiveRecord
 
       def supports_foreign_keys?
         true
+      end	  
+      
+      def 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. 
@@ -871,21 +1022,20 @@ module ActiveRecord
 
       def create_table(name, options = {})
         @servertype.setup_for_lob_table
-        super
-        
         #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")
+              @servertype.create_index_after_table(name,"id")
           elsif !options[:primary_key].nil?
-            @servertype.create_index_after_table(name,options[:primary_key].to_s)
+              @servertype.create_index_after_table(name,options[:primary_key].to_s)
           end
         else
-          @servertype.create_index_after_table(name,"id")
-        end 
+            @servertype.create_index_after_table(name,"id")
+        end
+          super(name, options)
       end
 
       # Returns an array of hashes with the column names as keys and
@@ -976,8 +1126,8 @@ module ActiveRecord
       end
 
       def select(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" )
+        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"
+        sql.gsub( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
 
         results = []
 
@@ -1005,7 +1155,7 @@ module ActiveRecord
       #+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" )
+        sql.gsub( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
         
         results = []
         # Invokes the method +execute+ in order to log and execute the SQL
@@ -1072,10 +1222,10 @@ module ActiveRecord
               break
             end
           end
+		  
           if item.at(1).nil? || 
               item.at(1) == {} || 			  
 			  (item.at(1) == '' && !(col.sql_type.to_s =~ /text|clob/i))
-          
                 params << 'NULL'
 				
 		  elsif (!col.nil? &&  (col.sql_type.to_s =~ /blob|binary|clob|text|xml/i)  )			
@@ -1137,12 +1287,12 @@ module ActiveRecord
         end
       end
 
-      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [] )
-        if(@arelVersion <  6 )
-		 sql, binds = [to_sql(arel),binds]
-		else
-		 sql, binds = sql_for_insert(to_sql(arel, binds), pk, id_value, sequence_name, binds) #[to_sql(arel),binds]
-		end
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, 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
 
         #unless IBM_DBAdapter.respond_to?(:exec_insert)
         if binds.nil? || binds.empty?
@@ -1150,7 +1300,8 @@ module ActiveRecord
         end
 
         clear_query_cache if defined? clear_query_cache
-        if stmt = exec_insert(sql, name, binds)
+		        
+		if stmt = exec_insert(sql, name, binds)
           begin
             @sql << sql
             return id_value || @servertype.last_generated_id(stmt)
@@ -1244,14 +1395,18 @@ module ActiveRecord
 
       # Executes and logs +sql+ commands and
       # returns a +IBM_DB.Statement+ object.
-      def execute(sql, name = nil)
+      def execute(sql, name=nil)
         # Logs and execute the sql instructions.
         # The +log+ method is defined in the parent class +AbstractAdapter+
-        log(sql, name) do
+	#sql='INSERT INTO ar_internal_metadata (key, value, created_at, updated_at) VALUES ('10', '10', '10', '10')
+        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)
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
@@ -1303,10 +1458,10 @@ module ActiveRecord
 
       def update(arel, name = nil, binds = [])
         if(@arelVersion <  6 )
-		sql = to_sql(arel)
-		else
-		sql = to_sql(arel,binds)
-		end
+		      sql = to_sql(arel)
+		    else
+		      sql = to_sql(arel,binds)
+		    end
 
         # Make sure the WHERE clause handles NULL's correctly
         sqlarray = sql.split(/\s*WHERE\s*/)
@@ -1364,6 +1519,7 @@ module ActiveRecord
       end
 
       def get_limit_offset_clauses(limit,offset)
+
         if limit && limit == 0
           clauses = @servertype.get_limit_offset_clauses(limit,0)
         else
@@ -1424,6 +1580,7 @@ module ActiveRecord
 
       # 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)}"
@@ -1431,7 +1588,7 @@ module ActiveRecord
           super
         end
       end
-
+=end
       def quote_value_for_pstmt(value, column=nil)
 
         return value.quoted_id if value.respond_to?(:quoted_id)
@@ -1460,75 +1617,82 @@ 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 
-              else
-                "#{value}"
-              end 
-          end
-          when TrueClass then quoted_true    # return '1' for true
-          when FalseClass then quoted_false  # return '0' for false
-          when nil        then "NULL"
-          when Date, Time then "'#{quoted_date(value)}'"
-          when Symbol     then "'#{quote_string(value.to_s)}'"
-          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(/'/, "''")
-      end
+    #   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
 
       # *true* is represented by a smallint 1, *false*
       # by 0, as no native boolean type exists in DB2.
@@ -1548,7 +1712,7 @@ module ActiveRecord
       #==============================================
       # SCHEMA STATEMENTS
       #==============================================
-
+	  	  
       # Returns a Hash of mappings from the abstract data types to the native
       # database types
       def native_database_types
@@ -1558,9 +1722,9 @@ module ActiveRecord
           :text        => { :name => "clob" },
           :integer     => { :name => "integer" },
           :float       => { :name => "float" },
-          :datetime    => { :name => @servertype.get_datetime_mapping },
-          :timestamp   => { :name => @servertype.get_datetime_mapping },
-          :time        => { :name => @servertype.get_time_mapping },
+          :datetime    => { :name => "timestamp" },
+          :timestamp   => { :name => "timestamp" },		  
+          :time        => { :name => "time" },
           :date        => { :name => "date" },
           :binary      => { :name => "blob" },
 
@@ -1575,8 +1739,8 @@ module ActiveRecord
           :char        => { :name => "char" },
           :double      => { :name => @servertype.get_double_mapping },
           :decfloat    => { :name => "decfloat"},
-          :graphic     => { :name => "graphic", :limit => 1},
-          :vargraphic  => { :name => "vargraphic", :limit => 1},
+          :graphic     => { :name => "graphic"},
+          :vargraphic  => { :name => "vargraphic"},
           :bigint      => { :name => "bigint"}
         }
       end
@@ -1638,16 +1802,90 @@ module ActiveRecord
         end
       end
 
+	    
+  
+  
+	   def valid_type?(type)		
+        #!native_database_types[type].nil?
+		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)
+      def type_to_sql(type, limit=nil, precision=nil, scale=nil )
+        if type.to_sym == :decimal
+          if limit.class == Hash
+            if limit.has_key?("precision".to_sym)
+              precision = limit[:precision]
+            end
+          end
+          if limit.class == Hash
+            if limit.has_key?("scale".to_sym)
+              scale = limit[:scale]
+            end
+          end
+          sql_segment = native_database_types[type.to_sym][:name].to_s
+          if !precision.nil? && !scale.nil?
+            sql_segment << "(#{precision},#{scale})"
+            return sql_segment
+          elsif scale.nil? && !precision.nil?
+            sql_segment << "(#{precision})"
+          else
+            return sql_segment
+          end
+        end
+
         if type.to_sym == :decfloat
           sql_segment = native_database_types[type.to_sym][:name].to_s
           sql_segment << "(#{precision})" if !precision.nil?
           return sql_segment
         end
-        
-        return super if limit.nil?
+
+	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?
+        else
+          return super if limit.nil?
+        end
 
         # strip off limits on data types not supporting them
         if @servertype.limit_not_supported_types.include? type.to_sym
@@ -1655,16 +1893,23 @@ module ActiveRecord
         elsif type.to_sym == :boolean
           return "smallint"
         else
-          return super
+          return super(type)
         end
-      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)
         # Initializes the tables array
@@ -1705,6 +1950,50 @@ module ActiveRecord
         return tables
       end
 
+###################################	  
+		
+
+	  # Retrieves views's metadata for a specified shema name
+      def views
+        # Initializes the tables array
+        tables = []
+        # Retrieve view's metadata through IBM_DB driver
+        stmt = IBM_DB.tables(@connection, nil, 
+                            @servertype.set_case(@schema))
+        if(stmt)
+          begin
+            # Fetches all the records available
+            while tab = IBM_DB.fetch_assoc(stmt)
+              # Adds the lowercase view's name to the array
+              if(tab["table_type"]== 'V')  #check, so that only views are dumped,IBM_DB.tables also returns tables,alias etc in the schema
+                tables << tab["table_name"].downcase    
+              end
+            end
+          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 "Failed to retrieve views metadata during fetch: #{error_msg}"
+            else
+              error_msg = "An unexpected error occurred during retrieval of views metadata"
+              error_msg = error_msg + ": #{fetch_error.message}" if !fetch_error.message.empty?
+              raise error_msg
+            end
+          ensure
+            IBM_DB.free_stmt(stmt)  if stmt # Free resources associated with the statement
+          end
+        else # Handle driver execution errors
+          error_msg = IBM_DB.getErrormsg(@connection, IBM_DB::DB_CONN )
+          if error_msg && !error_msg.empty?
+            raise "Failed to retrieve tables metadata due to error: #{error_msg}"
+          else
+            raise StandardError.new('An unexpected error occurred during retrieval of views metadata')
+          end
+        end
+        # Returns the tables array
+        return tables
+      end
+  
+	  
       # Returns the primary key of the mentioned table
       def primary_key(table_name)
         pk_name = nil
@@ -1741,7 +2030,7 @@ module ActiveRecord
 
       # Returns an array of non-primary key indexes for a specified table name
       def indexes(table_name, name = nil)
-                # to_s required because +table_name+ may be a symbol.
+        # 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.
         # If so it returns an empty array of columns.
@@ -1804,7 +2093,7 @@ module ActiveRecord
         if(stmt)
           begin
             while ( index_stats = IBM_DB.fetch_array(stmt) )
-                is_composite = false
+              is_composite = false
               if index_stats[5]             # INDEX_NAME
                 index_name = index_stats[5].downcase
                 index_unique = (index_stats[3] == 0)
@@ -1814,7 +2103,8 @@ module ActiveRecord
                 i = 0;
                 indexes.each do |index|
                   if index.name == index_name && index_schema[i] == index_qualifier
-                     index.columns = index.columns + index_columns
+                     #index.columns = index.columns + index_columns
+                     index.columns.concat index_columns
                      is_composite = true
                   end 
                   i = i+1
@@ -1860,10 +2150,92 @@ module ActiveRecord
         return indexes
       end
 
+	  
+      # Mapping IBM data servers SQL datatypes to Ruby data types
+      def simplified_type2(field_type)
+        case field_type
+          # if +field_type+ contains 'for bit data' handle it as a binary
+          when /for bit data/i
+            "binary"
+          when /smallint/i
+            "boolean"
+          when /int|serial/i
+            "integer"
+          when /decimal|numeric|decfloat/i
+            "decimal"
+          when /float|double|real/i
+            "float"
+          when /timestamp|datetime/i
+            "timestamp"
+          when /time/i
+            "time"
+          when /date/i
+            "date"
+          when /vargraphic/i
+            "vargraphic"
+          when /graphic/i
+            "graphic"
+          when /clob|text/i
+            "text"
+          when /xml/i
+            "xml"
+          when /blob|binary/i
+            "binary"
+          when /char/i
+            "string"
+          when /boolean/i
+            "boolean"
+          when /rowid/i  # rowid is a supported datatype on z/OS and i/5
+            "rowid"
+        end
+      end # method simplified_type
+	  
+	  
+	  # Mapping IBM data servers SQL datatypes to Ruby data types
+      def simplified_type(field_type)
+        case field_type
+          # if +field_type+ contains 'for bit data' handle it as a binary
+          when /for bit data/i
+            :binary
+          when /smallint/i
+            :boolean
+          when /int|serial/i
+            :integer
+          when /decimal|numeric|decfloat/i
+            :decimal
+          when /float|double|real/i
+            :float
+          when /timestamp|datetime/i
+            :timestamp
+          when /time/i
+            :time
+          when /date/i
+            :date
+          when /vargraphic/i
+            :vargraphic
+          when /graphic/i
+            :graphic
+          when /clob|text/i
+            :text
+          when /xml/i
+            :xml
+          when /blob|binary/i
+            :binary
+          when /char/i
+            :string
+          when /boolean/i
+            :boolean
+          when /rowid/i  # rowid is a supported datatype on z/OS and i/5
+            :rowid
+        end
+      end # method simplified_type
+	  
+	  
       # Returns an array of Column objects for the table specified by +table_name+
-      def columns(table_name, name = nil)
-        # to_s required because it may be a symbol.
+      def columns(table_name)
+      # to_s required because it may be a symbol.
         table_name = @servertype.set_case(table_name.to_s)
+				
         # Checks if a blank table name has been given.
         # If so it returns an empty array
         return [] if table_name.strip.empty?
@@ -1890,6 +2262,9 @@ module ActiveRecord
               # 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"]
               column_scale = col["decimal_digits"]
               # The initializer of the class Column, requires the +column_length+ to be declared 
@@ -1914,12 +2289,30 @@ module ActiveRecord
               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)				
-					columns << IBM_DBColumn.new(column_name, column_default_value, cast_type, column_type, column_nullable)
-				else
-					columns << IBM_DBColumn.new(column_name, column_default_value, column_type, column_nullable)
-				end
+                #if(@arelVersion >=  6 )				
+			
+			    #cast_type = lookup_cast_type(column_type)
+				
+				ruby_type = simplified_type2(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)
+											  
+				sqltype_metadata = SqlTypeMetadata.new(					
+					#sql_type: sql_type,
+					sql_type: original_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
               end
             end
           rescue StandardError => fetch_error # Handle driver fetch errors
@@ -1946,7 +2339,7 @@ module ActiveRecord
         return columns
       end
 	  	  
-	  def foreign_keys(table_name)        
+	  def 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.		
@@ -1995,8 +2388,9 @@ module ActiveRecord
         end
 	   #Returns the foreignKeys array
 	   return foreignKeys
-	end
-	def extract_foreign_key_action(specifier) # :nodoc:	      				
+    end
+    
+	  def extract_foreign_key_action(specifier) # :nodoc:	      			
 		  case specifier
           when 0; :cascade
 		  when 1; :restrict
@@ -2007,9 +2401,9 @@ module ActiveRecord
 	  
 	  def supports_disable_referential_integrity? #:nodoc:
           true
-      end
+    end
 
-      def disable_referential_integrity #:nodoc:
+    def disable_referential_integrity #:nodoc:
         if supports_disable_referential_integrity?
           alter_foreign_keys(tables, true)
         end
@@ -2020,7 +2414,7 @@ module ActiveRecord
           alter_foreign_keys(tables, false)
         end
 		
-      end
+    end
 	  
 	  def alter_foreign_keys(tables, not_enforced)
         enforced = not_enforced ? 'NOT ENFORCED' : 'ENFORCED'
@@ -2029,7 +2423,7 @@ module ActiveRecord
             execute("ALTER TABLE #{@servertype.set_case(fk.from_table)} ALTER FOREIGN KEY #{@servertype.set_case(fk.name)} #{enforced}")			
           end
         end
-	end
+	  end
 
       # Renames a table.
       # ==== Example
@@ -2070,7 +2464,7 @@ module ActiveRecord
       #Add distinct clause to the sql if there is no order by specified
       def distinct(columns, order_by)
         if order_by.nil?
-          "DISTINCT #{columns}"
+          "DISTINCT #{columns}" 
         else
           "#{columns}"
         end
@@ -2117,7 +2511,7 @@ module ActiveRecord
       #   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)}")
+	      execute("DROP INDEX #{index_name(table_name, options)}")
       end
 
       protected
@@ -2131,14 +2525,15 @@ module ActiveRecord
         register_class_with_limit 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.alias_type %r(blob)i,      'binary'
         m.alias_type %r(clob)i,      'text'
         m.alias_type %r(timestamp)i, 'datetime'
         m.alias_type %r(numeric)i,   'decimal'
         m.alias_type %r(number)i,    'decimal'
         m.alias_type %r(double)i,    'float'
-
+				
         m.register_type(%r(decimal)i) do |sql_type|
           scale = extract_scale(sql_type)
           precision = extract_precision(sql_type)
@@ -2166,7 +2561,7 @@ module ActiveRecord
     class IBM_DataServer
       def initialize(adapter, ar3)
         @adapter = adapter
-		@isAr3 = ar3
+	    	@isAr3 = ar3
       end
 
       def last_generated_id(stmt)
@@ -2273,7 +2668,9 @@ To remove the column, the table must be dropped and recreated without the #{colu
         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
         begin
           if stmt = IBM_DB.exec(@adapter.connection, sql)
             stmt   # Return the statement object
@@ -2287,6 +2684,25 @@ To remove the column, the table must be dropped and recreated without the #{colu
             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)
@@ -2345,7 +2761,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
       end
 
       def primary_key_definition(start_id)
-        return "INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH #{start_id}) PRIMARY KEY"
+        return "INTEGER GENERATED BY DEFAULT AS IDENTITY (START WITH #{start_id}) PRIMARY KEY NOT NULL"
       end
 
       # Returns the last automatically generated ID.
@@ -2395,6 +2811,9 @@ 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
         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}"
@@ -2412,6 +2831,7 @@ The column datatype change to [#{data_type}] is not supported by this data serve
         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)
@@ -2468,12 +2888,14 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           return retHash
         end
 
+		
         if (offset.nil?)
            retHash["endSegment"] = " FETCH FIRST #{limit} ROWS ONLY"
            return retHash
         end
 
-        if(limit.nil?)
+        #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}"
@@ -2484,7 +2906,13 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
         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 (  "
-        retHash["endSegment"] = " ) AS I) AS O WHERE sys_row_num BETWEEN #{offset+1} AND #{last_record}"
+        
+		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
 
@@ -3004,7 +3432,7 @@ end
       rescue
         arelVersion = 0
       end
-if(arelVersion >= 6)	
+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
@@ -3057,54 +3485,7 @@ end
     class IBM_DB < Arel::Visitors::ToSql
       private
 
-
-#Check Arel version
-      begin
-        @arelVersion = Arel::VERSION.to_i
-      rescue
-        @arelVersion = 0
-      end	  
-if(@arelVersion < 6)
-
-	  def visit_Arel_Nodes_Limit o, a=nil
-        visit o.expr
-      end
-
-      def visit_Arel_Nodes_Offset o, a=nil
-        visit o.expr
-      end
-      def visit_Arel_Nodes_SelectStatement o, a=nil
-        #Interim  fix for backward compatibility [Arel 4.0.0 and below]
-        if self.method(:visit_Arel_Nodes_SelectCore).arity == 1
-          sql = [
-            (visit(o.with) if o.with),
-            o.cores.map { |x| visit_Arel_Nodes_SelectCore x }.join,
-            ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-          ].compact.join ' '
-        else
-          sql = [
-            (visit(o.with) if o.with),
-            o.cores.map { |x| visit_Arel_Nodes_SelectCore x,a }.join,
-            ("ORDER BY #{o.orders.map { |x| visit x }.join(', ')}" unless o.orders.empty?),
-          ].compact.join ' '
-        end
-
-        if o.limit
-          limit = visit(o.limit)
-        else
-          limit = nil
-        end
-
-        if o.offset
-          offset = visit(o.offset)
-        else
-          offset = nil
-        end
-        @connection.add_limit_offset!(sql, {:limit => limit, :offset => offset})
-        sql << " #{(visit(o.lock) if o.lock)}"
-        return sql
-      end
-else
+        
       def visit_Arel_Nodes_Limit o,collector
         visit o.expr, collector
       end
@@ -3112,28 +3493,45 @@ else
       def visit_Arel_Nodes_Offset o,collector
         visit o.expr,collector
       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
+            end
+            collector << ")"
+          end
+          collector
+      end
       def visit_Arel_Nodes_SelectStatement o, collector
-
         if o.with
           collector = visit o.with, collector
-          collector << SPACE
+          collector << " "
         end
 
         collector = o.cores.inject(collector) { |c,x|
           visit_Arel_Nodes_SelectCore(x, c)
         }
 
-        unless o.orders.empty?
-          collector << SPACE
-          collector << ORDER_BY
+        unless o.orders.empty?          
+          collector << " ORDER BY "
           len = o.orders.length - 1
           o.orders.each_with_index { |x, i|
             collector = visit(x, collector)
-            collector << COMMA unless len == i
+            collector << "," unless len == i
           }
         end
 
+		
         if o.limit
           limcoll = Arel::Collectors::SQLString.new
           visit(o.limit,limcoll)
@@ -3141,7 +3539,7 @@ else
         else
           limit = nil
         end
-
+				
         if o.offset
           offcoll = Arel::Collectors::SQLString.new
           visit(o.offset,offcoll)
@@ -3149,28 +3547,26 @@ else
         else
           offset = nil
         end
-
+		
         limOffClause = @connection.get_limit_offset_clauses(limit,offset)
-
+		
         if( !limOffClause["startSegment"].empty? ) 
-          #collector.changeFirstSegment(limOffClause["startSegment"])		  
+          #collector.changeFirstSegment(limOffClause["startSegment"])	
           collector.value.prepend(limOffClause["startSegment"])		  
         end
         
         if( !limOffClause["endSegment"].empty? )
           #collector.changeEndSegment(limOffClause["endSegment"])
-          collector << SPACE
+          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)
-
+					
         collector = maybe_visit o.lock, collector
-
-	return collector
+		return collector
       end
-end	  
 	
     end
   end