ibm_db 2.5.6-x86-mingw32 → 2.5.7-x86-mingw32

data/CHANGES

@@ -1,5 +1,11 @@
 Change Log
 ==============
+2011/09/18 (IBM_DB adapter 2.5.7, driver 2.5.7) :
+  - Support for Rails-3.1.0
+  - Fixed bug #29052 -> prepare results in empty error message
+  - Support for continuation of method IBM_DB.conn_error and IBM_DB.conn_errormsg - #29324
+  - Test suite update as for Rails-3.1.0
+
 2011/02/07 (IBM_DB adapter 2.5.6, driver 2.5.6) :
   - Fixed Bug #28622, #28881
   - Decimal datatypes will now be returned as BigDecimal type from the driver

data/README

@@ -1,5 +1,5 @@
 =====================================================================
-README for the IBM_DB Adapter (2.5.5) and Driver (2.5.5) (2011/02/07)
+README for the IBM_DB Adapter (2.5.7) and Driver (2.5.7) (2011/09/18)
 For ActiveRecord Version >= 1.15.5 (and Rails >= 1.2.5)
 =====================================================================
 

data/ext/Makefile.nt32

@@ -4,12 +4,12 @@ SHELL = /bin/sh
 #### Start of system configuration section. ####
 
 srcdir = .
-topdir =$(TOP)/opendbad/win/ruby_1.8.6/lib/ruby/1.8/i386-mswin32
+topdir =$(TOP)/opendbad/win/ruby_win_exes/ruby_1.8.6/lib/ruby/1.8/i386-mswin32
 hdrdir = $(topdir)
 VPATH = $(srcdir);$(topdir);$(hdrdir)
 
 
-DESTDIR = $(TOP)/opendbad/win
+DESTDIR = $(TOP)/opendbad/win/ruby_win_exes
 prefix = $(DESTDIR)/ruby_1.8.6
 exec_prefix = $(DESTDIR)/ruby_1.8.6
 sitedir = $(prefix)/lib/ruby/site_ruby
@@ -51,7 +51,7 @@ RUBY_SO_NAME = msvcrt-ruby18
 arch = i386-mswin32
 sitearch = i386-msvcrt
 ruby_version = 1.8
-ruby = $(TOP)/opendbad/win/ruby_1.8.6/bin/ruby.exe
+ruby = $(TOP)/opendbad/win/ruby_win_exes/ruby_1.8.6/bin/ruby.exe
 RUBY = $(ruby:/=\)
 RM = $(RUBY) -run -e rm -- -f
 MAKEDIRS = @$(RUBY) -run -e mkdir -- -p

data/ext/Makefile.nt32.191

@@ -0,0 +1,212 @@
+
+SHELL = /bin/sh
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = $(TOP)/opendbad/win/ruby_win_exes/ruby191/include/ruby-1.9.1
+hdrdir = $(TOP)/opendbad/win/ruby_win_exes/ruby191/include/ruby-1.9.1
+arch_hdrdir = $(TOP)/opendbad/win/ruby_win_exes/ruby191/include/ruby-1.9.1/$(arch)
+VPATH = $(srcdir);$(arch_hdrdir)/ruby;$(hdrdir)/ruby
+
+DESTDIR = $(TOP)/opendbad/win/ruby_win_exes
+prefix = $(DESTDIR)/ruby191
+exec_prefix = $(prefix)
+bindir = $(exec_prefix)/bin
+sbindir = $(exec_prefix)/sbin
+libexecdir = $(exec_prefix)/libexec
+datadir = $(prefix)/share
+sysconfdir = $(prefix)/etc
+sharedstatedir = $(DESTDIR)/etc
+localstatedir = $(DESTDIR)/var
+libdir = $(exec_prefix)/lib
+includedir = $(prefix)/include
+oldincludedir = $(DESTDIR)/usr/include
+infodir = $(prefix)/info
+mandir = $(prefix)/man
+sitedir = $(prefix)/lib/$(RUBY_INSTALL_NAME)/site_ruby
+vendordir = $(prefix)/lib/$(RUBY_INSTALL_NAME)/vendor_ruby
+rubyhdrdir = $(includedir)/$(RUBY_INSTALL_NAME)-$(ruby_version)
+sitehdrdir = $(rubyhdrdir)/site_ruby
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+rubylibdir = $(libdir)/$(ruby_install_name)/$(ruby_version)
+archdir = $(rubylibdir)/$(arch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitearchdir = $(sitelibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+
+CC = cl -nologo
+CXX = $(CC)
+LIBRUBY = $(RUBY_SO_NAME).lib
+LIBRUBY_A = $(RUBY_SO_NAME)-static.lib
+LIBRUBYARG_SHARED = $(LIBRUBY)
+LIBRUBYARG_STATIC = $(LIBRUBY_A)
+OUTFLAG = -Fe
+COUTFLAG = -Fo
+
+RUBY_EXTCONF_H = unicode_support_version
+cflags   = 
+optflags = 
+debugflags = 
+warnflags = 
+CFLAGS   =  -MT -Zi  -O2b2xg- -G6 -Zm600 
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\"   
+CXXFLAGS = $(CFLAGS) -MT -Zi  -O2b2xg- -G6 -Zm600
+ldflags  = 
+dldflags = -link -incremental:no -debug -opt:ref -opt:icf -dll $(LIBPATH)
+archflag = 
+DLDFLAGS = $(ldflags) $(dldflags) $(archflag)
+LDSHARED = cl -nologo -LD
+LDSHAREDXX = $(LDSHARED)
+AR = lib -nologo
+EXEEXT = .exe
+
+RUBY_INSTALL_NAME = ruby
+RUBY_SO_NAME = msvcrt-ruby191
+arch = i386-mswin32
+sitearch = i386-msvcrt
+ruby_version = 1.9.1
+ruby = $(TOP)/opendbad/win/ruby_win_exes/ruby191/bin/ruby
+RUBY = $(ruby:/=\)
+RM = $(RUBY) -run -e rm -- -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = $(RUBY) -run -e rmdir -- -p
+MAKEDIRS = @$(RUBY) -run -e mkdir -- -p
+INSTALL = @$(RUBY) -run -e install -- -vp
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 0644
+COPY = copy > nul
+
+#### End of system configuration section. ####
+
+preload = 
+
+libpath = . $(libdir) C:/Progra~1/IBM/SQLLIB/lib
+LIBPATH =  -libpath:"." -libpath:"$(libdir)"
+DEFFILE = $(TARGET)-$(arch).def
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = vc*.pdb $(DEFFILE)
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = 
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED) db2cli.lib  oldnames.lib user32.lib advapi32.lib shell32.lib ws2_32.lib libcmt.lib 
+SRCS = ibm_db.c ruby_ibm_db_cli.c
+OBJS = ibm_db.obj ruby_ibm_db_cli.obj
+TARGET = ibm_db
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+
+TARGET_SO     = $(DLLIB)
+CLEANLIBS     = $(TARGET).so 
+CLEANOBJS     = *.obj $(TARGET).exp $(TARGET).lib $(TARGET).pdb *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-rb-default clean-rb
+		@-$(RM) $(CLEANLIBS:/=\) $(CLEANOBJS:/=\) $(CLEANFILES:/=\)
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean: clean distclean-so distclean-rb-default distclean-rb
+		@-$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		@-$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES:/=\)
+		@-$(RMDIRS) $(DISTCLEANDIRS:/=\)
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(RUBYARCHDIR)
+install-so: $(RUBYARCHDIR)/$(DLLIB)
+$(RUBYARCHDIR)/$(DLLIB): $(DLLIB)
+	$(INSTALL_PROG) $(DLLIB:/=\) $(RUBYARCHDIR:/=\)
+install-rb: pre-install-rb install-rb-default
+install-rb-default: pre-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+$(RUBYARCHDIR):
+	$(MAKEDIRS) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .cxx .cpp .obj
+
+{$(hdrdir)}.cc.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(topdir)}.cc.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(srcdir)}.cc.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+.cc.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(hdrdir)}.cxx.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(topdir)}.cxx.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(srcdir)}.cxx.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+.cxx.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(hdrdir)}.cpp.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(topdir)}.cpp.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(srcdir)}.cpp.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+.cpp.obj:
+	$(CXX) $(INCFLAGS) $(CXXFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tp$(<:\=/)
+
+{$(hdrdir)}.c.obj:
+	$(CC) $(INCFLAGS) $(CFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tc$(<:\=/)
+
+{$(topdir)}.c.obj:
+	$(CC) $(INCFLAGS) $(CFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tc$(<:\=/)
+
+{$(srcdir)}.c.obj:
+	$(CC) $(INCFLAGS) $(CFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tc$(<:\=/)
+
+.c.obj:
+	$(CC) $(INCFLAGS) $(CFLAGS) $(CPPFLAGS) $(COUTFLAG)$(@) -c -Tc$(<:\=/)
+
+$(DLLIB): $(DEFFILE) $(OBJS) Makefile
+	@-$(RM) $(@:/=\)
+	$(LDSHARED) -Fe$(@) $(OBJS) $(LIBS) $(LOCAL_LIBS) $(DLDFLAGS) -implib:$(*F:.so=)-$(arch).lib -pdb:$(*F:.so=)-$(arch).pdb -def:$(DEFFILE)
+
+
+
+$(DEFFILE): 
+	$(RUBY) -e "puts 'EXPORTS', 'Init_$(TARGET)'"  > $@
+
+$(OBJS): {.;$(VPATH)}$(hdrdir)/ruby.h {.;$(VPATH)}$(hdrdir)/ruby/defines.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H)

data/ext/ibm_db.c

@@ -12,7 +12,7 @@
   +----------------------------------------------------------------------+
 */
 
-#define MODULE_RELEASE "2.5.6"
+#define MODULE_RELEASE "2.5.7"
 
 #ifdef HAVE_CONFIG_H
 #include "config.h"
@@ -5197,7 +5197,7 @@ static int _ruby_ibm_db_do_prepare(conn_handle *conn_res, VALUE stmt, stmt_handl
     #endif
 
     if ( rc == SQL_ERROR ) {
-      _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 0, 
+      _ruby_ibm_db_check_sql_errors( conn_res, DB_CONN, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, 
                 NULL, NULL, -1, 1, 1 );
     }
   }
@@ -6381,7 +6381,8 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
 
     put_param_data_args->stmt_res  =  stmt_res;
 
-    while ( _ruby_ibm_db_SQLParamData_helper( put_param_data_args ) == SQL_NEED_DATA ) {
+    rc = _ruby_ibm_db_SQLParamData_helper( put_param_data_args );
+    while ( rc == SQL_NEED_DATA ) {
 
       /* passing data value for a parameter */
       rc  = _ruby_ibm_db_SQLPutData_helper(put_param_data_args);
@@ -6412,13 +6413,37 @@ static VALUE _ruby_ibm_db_execute_helper(stmt_bind_array *bind_array) {
 
         return Qnil;
       }
+	  rc = _ruby_ibm_db_SQLParamData_helper( put_param_data_args );
     }
 
     if (put_param_data_args != NULL) {
       ruby_xfree( put_param_data_args );
       put_param_data_args = NULL;
     }
+
+    if ( rc == SQL_ERROR ) {
+        _ruby_ibm_db_check_sql_errors( stmt_res, DB_STMT, stmt_res->hstmt, SQL_HANDLE_STMT, rc, 1, NULL, NULL, -1, 1, 0 );
+      if( stmt_res != NULL && stmt_res->ruby_stmt_err_msg != NULL ) {
+#ifdef UNICODE_SUPPORT_VERSION
+        *error = rb_str_concat( _ruby_ibm_db_export_char_to_utf8_rstr( "Sending data failed: "),
+                   _ruby_ibm_db_export_sqlwchar_to_utf8_rstr( stmt_res->ruby_stmt_err_msg,
+                                  stmt_res->ruby_stmt_err_msg_len )
+                 );
+#else
+        *error = rb_str_cat2(rb_str_new2("Sending data failed: "), stmt_res->ruby_stmt_err_msg );
+#endif
+      } else {
+#ifdef UNICODE_SUPPORT_VERSION
+        *error = _ruby_ibm_db_export_char_to_utf8_rstr("Sending data failed: <error message could not be retrieved>");
+#else
+        *error = rb_str_new2("Sending data failed: <error message could not be retrieved>");
+#endif
+      }
+
+      return Qnil;
+    }
   }
+
   return Qtrue;
 }
 /*
@@ -6642,7 +6667,7 @@ VALUE ibm_db_conn_errormsg(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "01", &connection);
 
-  rb_warn("Method conn_errormsg is deprecated, use getErrormsg");
+  /*rb_warn("Method conn_errormsg is deprecated, use getErrormsg");*/
 
   if (!NIL_P(connection)) {
     Data_Get_Struct(connection, conn_handle, conn_res);
@@ -6796,7 +6821,7 @@ VALUE ibm_db_conn_error(int argc, VALUE *argv, VALUE self)
 
   rb_scan_args(argc, argv, "01", &connection);
 
-  rb_warn("Method conn_error is deprecated, use getErrorstate");
+  /*rb_warn("Method conn_error is deprecated, use getErrorstate");*/
 
   if (!NIL_P(connection)) {
     Data_Get_Struct(connection, conn_handle, conn_res);

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -521,7 +521,7 @@ module ActiveRecord
                 end
               when /DB2/i               # DB2 for zOS
                 case server_info.DBMS_VER
-                  when /09/             # DB2 for zOS version 9
+                  when /09/ || /10/             # DB2 for zOS version 9 and version 10
                     @servertype = IBM_DB2_ZOS.new(self)
                   when /08/             # DB2 for zOS version 8
                     @servertype = IBM_DB2_ZOS_8.new(self)
@@ -603,6 +603,19 @@ module ActiveRecord
         end
       end
 
+      def self.visitor_for(pool)
+        Arel::Visitors::IBM_DB.new(pool)
+      end
+      
+      def to_sql(arel)
+        if arel.respond_to?(:ast)
+          visitor.accept(arel.ast)
+        else
+          arel
+        end
+
+      end
+
       # This adapter supports migrations.
       # Current limitations:
       # +rename_column+ is not currently supported by the IBM data servers
@@ -719,7 +732,7 @@ module ActiveRecord
         pstmt = prepare(sql_param_hash["sqlSegment"], name)
         if(execute_prepared_stmt(pstmt, sql_param_hash["paramArray"]))
           begin
-            @servertype.select(sql_param_hash["sqlSegment"], name, pstmt, results)
+            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?
@@ -743,14 +756,13 @@ module ActiveRecord
       # 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
-            @servertype.select_rows(sql_param_hash["sqlSegment"], name, pstmt, results)
+            results = @servertype.select_rows(sql_param_hash["sqlSegment"], name, pstmt, results)
             if results
               return results.map { |v| v[0] }
             else
@@ -774,20 +786,11 @@ module ActiveRecord
         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 select(sql, name = nil)
-        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
-        sql.gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
-        
-        results = []
-        # Invokes the method +execute+ in order to log and execute the SQL
-        # IBM_DB.Statement is returned from which results can be fetched
-        stmt = execute(sql, name)
+      #Calls the servertype select method to fetch the data
+      def fetch_data(stmt)
         if(stmt)
           begin
-            @servertype.select(sql, name, stmt, results)
+            return @servertype.select(stmt)
           rescue StandardError => fetch_error # Handle driver fetch errors
             error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
             if error_msg && !error_msg.empty?
@@ -798,13 +801,47 @@ module ActiveRecord
               raise error_msg
             end
           ensure
-            # Ensures to free the resources associated with the statement
+          # Ensures to free the resources associated with the statement
             IBM_DB.free_stmt(stmt) if stmt
           end
         end
+      end
+=begin
+      # Returns an array of hashes with the column names as keys and
+      # column values as values. +sql+ is the select query, 
+      # and +name+ is an optional description for logging
+      def select(sql, name = nil)
+        # Replaces {"= NULL" with " IS NULL"} OR {"IN (NULL)" with " IS NULL"}
+        sql.gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" )
+        
+        results = []
+        # Invokes the method +execute+ in order to log and execute the SQL
+        # IBM_DB.Statement is returned from which results can be fetched
+        stmt = execute(sql, name)
+
+        results = fetch_data(stmt)
         # The array of record hashes is returned
         results
       end
+=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" )
+
+        results = []
+
+        if(binds.nil? || binds.empty?)
+          stmt = execute(sql, name)
+        else
+          stmt = exec_query(sql, name, binds)
+        end
+
+        if( stmt ) 
+          results = fetch_data(stmt)
+        end
+
+        return results
+      end
 
       #Returns an array of arrays containing the field values.
       #This is an implementation for the abstract method
@@ -819,7 +856,7 @@ module ActiveRecord
         stmt = execute(sql, name)
         if(stmt)
           begin
-            @servertype.select_rows(sql, name, stmt, results)
+            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?
@@ -850,7 +887,12 @@ module ActiveRecord
       #overridden to handle LOB's fixture insertion, as, in normal inserts callbacks are triggered but during fixture insertion callbacks are not triggered
       #hence only markers like @@@IBMBINARY@@@ will be inserted and are not updated to actual data
       def insert_fixture(fixture, table_name)
-        insert_query = "INSERT INTO #{quote_table_name(table_name)} ( #{fixture.key_list})"
+        if(fixture.respond_to?(:keys))
+          insert_query = "INSERT INTO #{quote_table_name(table_name)} ( #{fixture.keys.join(', ')})"
+        else
+          insert_query = "INSERT INTO #{quote_table_name(table_name)} ( #{fixture.key_list})"
+        end
+
         insert_values = []
         params = []
         if @servertype.instance_of? IBM_IDS
@@ -910,7 +952,7 @@ module ActiveRecord
       # 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(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+      def insert_direct(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql = []
           @handle_lobs_triggered = false
@@ -929,11 +971,30 @@ module ActiveRecord
         end
       end
 
+      def insert(arel, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [] )
+        sql, binds = [to_sql(arel),binds]
+
+        #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
+        if stmt = exec_insert(sql, name, binds)
+          begin
+            @sql << sql
+            return id_value || @servertype.last_generated_id(stmt)
+          ensure
+            IBM_DB.free_stmt(stmt) if stmt
+          end
+        end
+      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)
+      def prepared_insert(pstmt, param_array = nil, id_value = nil)
         if @handle_lobs_triggered  #Ensure the array of sql is cleared if they have been handled in the callback
           @sql                   = []
           @sql_parameter_values  = []
@@ -946,7 +1007,7 @@ module ActiveRecord
           if execute_prepared_stmt(pstmt, param_array)
             @sql << @prepared_sql
             @sql_parameter_values << param_array
-            return @servertype.last_generated_id(pstmt)
+            return id_value || @servertype.last_generated_id(pstmt)
           end
         rescue StandardError => insert_err
           raise insert_err
@@ -988,6 +1049,29 @@ module ActiveRecord
         end
       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 = [])
+        begin
+          param_array = binds.map do |column,value|
+            quote_value_for_pstmt(value, column)
+          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
+
       # Executes and logs +sql+ commands and
       # returns a +IBM_DB.Statement+ object.
       def execute(sql, name = nil)
@@ -999,29 +1083,12 @@ module ActiveRecord
       end
 
       # Executes an "UPDATE" SQL statement
-      def update(sql, name = nil)
+      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
           @sql = []
           @handle_lobs_triggered = false
         end
 
-        clear_query_cache if defined? clear_query_cache
-        
-        # Make sure the WHERE clause handles NULL's correctly
-        sqlarray = sql.split(/\s*WHERE\s*/)
-        size = sqlarray.size
-        if size > 1
-          sql = sqlarray[0] + " WHERE "
-          if size > 2
-            1.upto size-2 do |index|
-              sqlarray[index].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[index].nil?
-              sql = sql + sqlarray[index] + " WHERE "
-            end
-          end
-          sqlarray[size-1].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[size-1].nil?
-          sql = sql + sqlarray[size-1]
-        end
-
         # Logs and execute the given sql query.
         if stmt = execute(sql, name)
           begin
@@ -1062,9 +1129,39 @@ module ActiveRecord
       # The delete method executes the delete
       # statement and returns the number of affected rows.
       # The method is an alias for +update+
-      alias_method :delete, :update
       alias_method :prepared_delete, :prepared_update
 
+      def update(arel, name = nil, binds = [])
+        sql = to_sql(arel)
+
+        # Make sure the WHERE clause handles NULL's correctly
+        sqlarray = sql.split(/\s*WHERE\s*/)
+        size = sqlarray.size
+        if size > 1
+          sql = sqlarray[0] + " WHERE "
+          if size > 2
+            1.upto size-2 do |index|
+              sqlarray[index].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[index].nil?
+              sql = sql + sqlarray[index] + " WHERE "
+            end
+          end
+          sqlarray[size-1].gsub!( /(=\s*NULL|IN\s*\(NULL\))/i, " IS NULL" ) unless sqlarray[size-1].nil?
+          sql = sql + sqlarray[size-1]
+        end
+
+        clear_query_cache if defined? clear_query_cache
+
+        if binds.nil? || binds.empty?
+          update_direct(sql, name)
+        else
+          if stmt = exec_query(sql,name,binds)
+            IBM_DB.num_rows(stmt)
+          end
+        end
+      end
+
+      alias_method :delete, :update
+
       # Begins the transaction (and turns off auto-committing)
       def begin_db_transaction
         # Turns off the auto-commit
@@ -1105,27 +1202,26 @@ module ActiveRecord
       # 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)
-        # If there is a limit
-        if limit = options[:limit]
-          # if the limit is zero
-          if 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
+        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
-            offset = options[:offset]
-            # 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
+            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
@@ -1161,6 +1257,7 @@ module ActiveRecord
           when Float, Fixnum, Bignum    then value
           # BigDecimals need to be output in a non-normalized form and quoted.
           when BigDecimal               then value.to_s('F')
+          when Numeric, Symbol          then value.to_s
           else
             if value.acts_like?(:date) || value.acts_like?(:time)
               quoted_date(value)
@@ -1173,6 +1270,8 @@ module ActiveRecord
       # 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 type is not a string, it shouldn't be quoted
           # (IBM_DB doesn't accept quotes on numeric types)
@@ -1213,14 +1312,22 @@ module ActiveRecord
               end
           else
               unless caller[0] =~ /insert_fixture/i
-                "'#{quote_string(value)}'"
+                super 
               else
                 "#{value}"
               end 
           end
           when TrueClass then quoted_true    # return '1' for true
           when FalseClass then quoted_false  # return '0' for false
-          else super                         # rely on superclass handling
+          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
 
@@ -1525,6 +1632,8 @@ module ActiveRecord
               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?
               # Assigns the column type
@@ -1643,6 +1752,15 @@ module ActiveRecord
       end
 =end
 
+      #Add distinct clause to the sql if there is no order by specified
+      def distinct(columns, order_by)
+        if order_by.nil?
+          "DISTINCT #{columns}"
+        else
+          "#{columns}"
+        end
+      end
+
       # Sets a new default value for a column. This does not set the default
       # value to +NULL+, instead, it needs DatabaseStatements#execute which
       # can execute the appropriate SQL statement for setting the value.
@@ -1717,7 +1835,8 @@ To remove the column, the table must be dropped and recreated without the #{colu
         end
       end
 
-      def select(sql, name, stmt, results)
+      def select(stmt)
+        results = []
         # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
         # an hash for each single record.
         # The loop stops when there aren't any more valid records to fetch
@@ -1736,6 +1855,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
             raise error_msg
           end
         end
+        return results
       end
 
       def select_rows(sql, name, stmt, results)
@@ -1757,6 +1877,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
             raise error_msg
           end
         end
+        return results
       end
 
       # Praveen
@@ -1962,11 +2083,14 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       def get_double_mapping
         return "double"
       end
-
+=begin
+      # Commenting this code, as offset handling is now part of sql and we need to handle it in select and also
+      # need not set cursor type during prepare or execute
       # Fetches all the results available. IBM_DB.fetch_assoc(stmt) returns
       # an hash for each single record.
       # The loop stops when there aren't any more valid records to fetch
-      def select(sql, name, stmt, results)
+      def select(stmt)
+        results = []
         begin
           if (!@offset.nil? && @offset >= 0) || (!@limit.nil? && @limit > 0)
             # We know at this point that there is an offset and/or a limit
@@ -2016,6 +2140,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
               # Add the record to the +results+ array
               results <<  single_hash
             end
+            return results
           end
         rescue StandardError => fetch_error # Handle driver fetch errors
           error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
@@ -2101,6 +2226,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           @offset = nil
           @limit = nil
         end
+        return results
       end
 
       # Praveen
@@ -2156,22 +2282,62 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           raise error_msg
         end
       end
-
+=end
       def query_offset_limit(sql, offset, limit)
-        @limit = limit
-        @offset = offset
+        if(offset.nil? && limit.nil?)
+          return sql
+        end
+
         if (offset.nil?)
-           sql << " FETCH FIRST #{limit} ROWS ONLY"
+           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)
-        @limit = limit
-        @offset = offset
+        if(offset.nil? && limit.nil?)
+          options[:paramArray] = []
+          return sql
+        end
+
         if (offset.nil?)
-           sql << " FETCH FIRST #{limit} ROWS ONLY"
+           options[:paramArray] = []
+           return sql << " FETCH FIRST #{limit} ROWS ONLY"
         end
-        options[:paramArray] = []
+    
+        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 
@@ -2203,40 +2369,6 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
       def reorg_table(table_name)
         execute("CALL ADMIN_CMD('REORG TABLE #{table_name}')")
       end
-
-      def query_offset_limit(sql, offset, limit)
-        if (offset.nil?)
-           return sql << " FETCH FIRST #{limit} ROWS ONLY"
-        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?)
-           options[:paramArray] = []
-           return sql << " FETCH FIRST #{limit} ROWS ONLY"
-        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
     end # class IBM_DB2_LUW
 
     class IBM_DB2_LUW_COBRA < IBM_DB2_LUW
@@ -2371,6 +2503,20 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
     class IBM_DB2_ZOS_8 < IBM_DB2_ZOS
       include HostedDataServer
 
+      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
@@ -2596,3 +2742,49 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
     end # class IBM_IDS
   end # module ConnectionAdapters
 end # module ActiveRecord
+
+module Arel
+  module Visitors
+    class Visitor #opening and closing the class to ensure backward compatibility
+    end
+
+    class ToSql < Arel::Visitors::Visitor #opening and closing the class to ensure backward compatibility
+    end
+
+    class IBM_DB < Arel::Visitors::ToSql
+      private
+
+      def visit_Arel_Nodes_Limit o
+        visit o.expr
+      end
+
+      def visit_Arel_Nodes_Offset o
+        visit o.expr
+      end
+
+      def visit_Arel_Nodes_SelectStatement o
+        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?),
+          (visit(o.lock) if o.lock),
+        ].compact.join ' '
+
+        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})
+        return sql
+      end
+
+    end
+  end
+end