db2 2.6.2 → 2.7.0

data/ext/ruby_ibm_db.h

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2006, 2007, 2008, 2009, 2010           |
+  | (C) Copyright IBM Corporation 2006, 2007, 2008, 2009, 2010, 2012     |
   +----------------------------------------------------------------------+
   | Authors: Sushant Koduru, Lynh Nguyen, Kanchana Padmanabhan,          |
   |          Dan Scott, Helmut Tessarek, Kellen Bombardier, Sam Ruby     |
@@ -135,6 +135,9 @@ void Init_ibm_db();
 /* Function Declarations */
 
 VALUE ibm_db_connect(int argc, VALUE *argv, VALUE self);
+VALUE ibm_db_createDB(int argc, VALUE *argv, VALUE self);
+VALUE ibm_db_dropDB(int argc, VALUE *argv, VALUE self);
+VALUE ibm_db_createDBNX(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_commit(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_pconnect(int argc, VALUE *argv, VALUE self);
 VALUE ibm_db_autocommit(int argc, VALUE *argv, VALUE self);

data/ext/ruby_ibm_db_cli.c

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2009, 2010                             |
+  | (C) Copyright IBM Corporation 2009, 2010, 2012                       |
   +----------------------------------------------------------------------+
   | Authors: Praveen Devarao                                             |
   +----------------------------------------------------------------------+
@@ -372,6 +372,113 @@ int _ruby_ibm_db_SQLExecDirect_helper(exec_cum_prepare_args *data) {
   return rc;
 }
 
+/*
+   This function calls SQLCreateDb cli call
+*/
+int _ruby_ibm_db_SQLCreateDB_helper(create_drop_db_args *data) {
+  int rc = 0;
+#ifndef UNICODE_SUPPORT_VERSION
+  #ifdef _WIN32
+    HINSTANCE cliLib = NULL;
+    FARPROC sqlcreatedb;
+    cliLib = DLOPEN( LIBDB2 );
+    sqlcreatedb =  DLSYM( cliLib, "SQLCreateDb" );
+  #elif _AIX
+    void *cliLib = NULL;
+    typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
+    sqlcreatedbType sqlcreatedb;
+  /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
+    cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
+    sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
+  #else
+    void *cliLib = NULL;
+    typedef int (*sqlcreatedbType)( SQLHDBC, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER, SQLCHAR *, SQLINTEGER );
+    sqlcreatedbType sqlcreatedb;
+    cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
+    sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDb" );
+  #endif
+#else
+  #ifdef _WIN32
+    HINSTANCE cliLib = NULL;
+    FARPROC sqlcreatedb;
+    cliLib = DLOPEN( LIBDB2 );
+    sqlcreatedb =  DLSYM( cliLib, "SQLCreateDbW" );
+  #elif _AIX
+    void *cliLib = NULL;
+    typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
+    sqlcreatedbType sqlcreatedb;
+  /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
+    cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
+    sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
+  #else
+    void *cliLib = NULL;
+    typedef int (*sqlcreatedbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER, SQLWCHAR *, SQLINTEGER );
+    sqlcreatedbType sqlcreatedb;
+    cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
+    sqlcreatedb = (sqlcreatedbType) DLSYM( cliLib, "SQLCreateDbW" );
+  #endif
+#endif
+
+  rc = (*sqlcreatedb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len, 
+                            data->codeSet, (SQLINTEGER)data->codeSet_string_len,
+							data->mode, (SQLINTEGER)data->mode_string_len );
+  DLCLOSE( cliLib );
+  return rc;
+}
+
+/*
+   This function calls SQLDropDb cli call
+*/
+int _ruby_ibm_db_SQLDropDB_helper(create_drop_db_args *data) {
+  int rc = 0;
+#ifndef UNICODE_SUPPORT_VERSION
+  #ifdef _WIN32
+    HINSTANCE cliLib = NULL;
+    FARPROC sqldropdb;
+    cliLib = DLOPEN( LIBDB2 );
+    sqldropdb =  DLSYM( cliLib, "SQLDropDb" );
+  #elif _AIX
+    void *cliLib = NULL;
+    typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
+    sqldropdbType sqldropdb;
+  /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
+    cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
+    sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
+  #else
+    void *cliLib = NULL;
+    typedef int (*sqldropdbType)( SQLHDBC, SQLCHAR *, SQLINTEGER);
+    sqldropdbType sqldropdb;
+    cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
+    sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDb" );
+  #endif
+#else
+  #ifdef _WIN32
+    HINSTANCE cliLib = NULL;
+    FARPROC sqldropdb;
+    cliLib = DLOPEN( LIBDB2 );
+    sqldropdb =  DLSYM( cliLib, "SQLDropDbW" );
+  #elif _AIX
+    void *cliLib = NULL;
+    typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
+    sqldropdbType sqldropdb;
+  /* On AIX CLI library is in archive. Hence we will need to specify flags in DLOPEN to load a member of the archive*/
+    cliLib = DLOPEN( LIBDB2, RTLD_MEMBER | RTLD_LAZY );
+    sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
+  #else
+    void *cliLib = NULL;
+    typedef int (*sqldropdbType)( SQLHDBC, SQLWCHAR *, SQLINTEGER);
+    sqldropdbType sqldropdb;
+    cliLib = DLOPEN( LIBDB2, RTLD_LAZY );
+    sqldropdb = (sqldropdbType) DLSYM( cliLib, "SQLDropDbW" );
+  #endif
+#endif
+
+  rc = (*sqldropdb)( (SQLHSTMT) data->conn_res->hdbc, data->dbName, (SQLINTEGER)data->dbName_string_len );
+
+  DLCLOSE( cliLib );
+  return rc;
+}
+
 /*
    This function calls SQLPrepare cli call to prepare the given statement
 */

data/ext/ruby_ibm_db_cli.h

@@ -2,7 +2,7 @@
   +----------------------------------------------------------------------+
   |  Licensed Materials - Property of IBM                                |
   |                                                                      |
-  | (C) Copyright IBM Corporation 2009, 2010                             |
+  | (C) Copyright IBM Corporation 2009, 2010, 2012                       |
   +----------------------------------------------------------------------+
   | Authors: Praveen Devarao                                             |
   +----------------------------------------------------------------------+
@@ -11,6 +11,35 @@
 #ifndef RUBY_IBM_DB_CLI_H
 #define RUBY_IBM_DB_CLI_H
 
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+#ifdef _WIN32
+#define DLOPEN LoadLibrary
+#define DLSYM GetProcAddress
+#define DLCLOSE FreeLibrary
+#define LIBDB2 "db2cli.dll"
+#elif _AIX
+#define DLOPEN dlopen
+#define DLSYM dlsym
+#define DLCLOSE dlclose
+#ifdef __64BIT__
+/*64-bit library in the archive libdb2.a*/
+#define LIBDB2 "libdb2.a(shr_64.o)"
+#else
+/*32-bit library in the archive libdb2.a*/
+#define LIBDB2 "libdb2.a(shr.o)"
+#endif
+#else
+#define DLOPEN dlopen
+#define DLSYM dlsym
+#define DLCLOSE dlclose
+#define LIBDB2 "libdb2.so.1"
+#endif
+
 #include <ruby.h>
 #include <stdio.h>
 #include <string.h>
@@ -54,6 +83,8 @@ typedef struct _conn_handle_struct {
   SQLPOINTER   ruby_error_state;
   SQLSMALLINT  ruby_error_msg_len;
 
+  SQLINTEGER   sqlcode;
+
 } conn_handle;
 
 typedef union {
@@ -114,6 +145,7 @@ typedef struct _stmt_handle_struct {
   SQLPOINTER   ruby_stmt_err_msg;
   SQLPOINTER   ruby_stmt_err_state;
   SQLSMALLINT  ruby_stmt_err_msg_len;
+  SQLINTEGER   sqlcode;
 } stmt_handle;
 
 /* 
@@ -211,6 +243,25 @@ typedef struct _ibm_db_exec_direct_args_struct {
   long          stmt_string_len;
 } exec_cum_prepare_args;
 
+/* 
+    Structure holding the necessary info to be passed to SQLCreateDB and SQLDropDB CLI call
+*/
+typedef struct _ibm_db_create_drop_db_args_struct {
+  conn_handle   *conn_res;
+#ifdef UNICODE_SUPPORT_VERSION
+  SQLWCHAR      *dbName;
+  SQLWCHAR      *codeSet;
+  SQLWCHAR      *mode;
+#else
+  SQLCHAR       *dbName;
+  SQLCHAR       *codeSet;
+  SQLCHAR       *mode;
+#endif
+  long          dbName_string_len;
+  long          codeSet_string_len;
+  long          mode_string_len;
+} create_drop_db_args;
+
 /* 
     Structure holding the necessary info to be passed to SQLParamData and SQLPutData CLI call
 */
@@ -427,5 +478,7 @@ int _ruby_ibm_db_SQLGetConnectAttr_helper(get_handle_attr_args *data);
 int _ruby_ibm_db_SQLBindFileToParam_helper(stmt_handle *stmt_res, param_node *curr);
 int _ruby_ibm_db_SQLBindParameter_helper(bind_parameter_args *data);
 void _ruby_ibm_db_Statement_level_UBF(stmt_handle *stmt_res);
+int _ruby_ibm_db_SQLCreateDB_helper(create_drop_db_args *data);
+int _ruby_ibm_db_SQLDropDB_helper(create_drop_db_args *data);
 
 #endif  /* RUBY_IBM_DB_CLI_H */

data/lib/active_record/connection_adapters/ibm_db_adapter.rb

@@ -44,10 +44,15 @@ module ActiveRecord
               # (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.type != :text)
                 params << 'NULL'
               else
-                values << self[col.name]
+                if self.class.serialized_attributes[col.name]
+                  values << YAML.dump(self[col.name])
+                else
+                  values << self[col.name]
+                end
                 params << '?'
               end
               counter += 1
@@ -117,24 +122,31 @@ module ActiveRecord
       # Flag to decide if quoted literal replcement should take place. By default it is ON. Set it to OFF if using Pstmt
       set_quoted_literal_replacement = IBM_DB::QUOTED_LITERAL_REPLACEMENT_ON
 
-      # Retrieves the database alias (local catalog name) or remote name
-      # (for remote TCP/IP connections) from the +config+ hash
-      # or raises ArgumentError in case of failure.
-      if config.has_key?(:database)
-        database = config[:database].to_s
-      else
-        raise ArgumentError, "Missing argument: a database name needs to be specified."
-      end
-
       # Retrieves database user credentials from the +config+ hash
       # or raises ArgumentError in case of failure.
       if !config.has_key?(:username) || !config.has_key?(:password)
         raise ArgumentError, "Missing argument(s): Username/Password for #{config[:database]} is not specified"
       else
+        if(config[:username].to_s.nil? || config[:password].to_s.nil?)
+          raise ArgumentError, "Username/Password cannot be nil"
+        end
         username = config[:username].to_s
         password = config[:password].to_s
       end
 
+      if(config.has_key?(:dbops) && config[:dbops] == true)
+        return ConnectionAdapters::IBM_DBAdapter.new(nil, logger, config, {})
+      end
+
+      # Retrieves the database alias (local catalog name) or remote name
+      # (for remote TCP/IP connections) from the +config+ hash
+      # or raises ArgumentError in case of failure.
+      if config.has_key?(:database)
+        database = config[:database].to_s
+      else
+        raise ArgumentError, "Missing argument: a database name needs to be specified."
+      end
+
       # Providing default schema (username) when not specified
       config[:schema] = config.has_key?(:schema) ? config[:schema].to_s : config[:username].to_s
 
@@ -232,8 +244,6 @@ module ActiveRecord
             :binary
           when /smallint/i
             :boolean
-          when /bigint/i
-            :bigint
           when /int|serial/i
             :integer
           when /decimal|numeric|decfloat/i
@@ -481,7 +491,8 @@ module ActiveRecord
                 end
               when /DB2/i               # DB2 for zOS
                 case server_info.DBMS_VER
-                  when /09/             # DB2 for zOS version 9
+                  when /09/             # DB2 for zOS version 9 and version 10
+                  when /10/
                     @servertype = IBM_DB2_ZOS.new(self)
                   when /08/             # DB2 for zOS version 8
                     @servertype = IBM_DB2_ZOS_8.new(self)
@@ -513,6 +524,17 @@ module ActiveRecord
         else
           @start_id = 1
         end
+
+        #Check Arel version
+        begin
+          @arelVersion = Arel::VERSION.to_i
+        rescue
+          @arelVersion = 0
+        end
+
+        if(@arelVersion >=  3 )
+          @visitor = Arel::Visitors::IBM_DB.new self
+        end
       end
 
       # Optional connection attribute: database name space qualifier
@@ -563,6 +585,20 @@ module ActiveRecord
         end
       end
 
+      def self.visitor_for(pool)
+        Arel::Visitors::IBM_DB.new(pool)
+      end
+      
+      def to_sql(arel, binds = [])
+        if arel.respond_to?(:ast)
+          visitor.accept(arel.ast) do
+            quote(*binds.shift.reverse)
+          end
+        else
+          arel
+        end
+      end
+
       # This adapter supports migrations.
       # Current limitations:
       # +rename_column+ is not currently supported by the IBM data servers
@@ -599,6 +635,10 @@ module ActiveRecord
       # It connects to the database with the initially provided credentials
       def connect
         # If the type of connection is net based
+        if(@username.nil? || @password.nil?)
+          raise ArgumentError, "Username/Password cannot be nil"
+        end
+
         begin
           if @host
             @conn_string = "DRIVER={IBM DB2 ODBC DRIVER};\
@@ -641,6 +681,7 @@ module ActiveRecord
         # * true if succesfull
         # * false if the connection is already closed
         # * nil if an error is raised
+        return nil if @connection.nil? || @connection == false
         IBM_DB.close(@connection) rescue nil
       end
 
@@ -679,7 +720,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?
@@ -703,14 +744,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
@@ -734,20 +774,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?
@@ -758,13 +789,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
@@ -779,7 +844,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?
@@ -810,7 +875,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
@@ -870,7 +940,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
@@ -889,11 +959,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  = []
@@ -906,7 +995,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
@@ -948,6 +1037,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)
@@ -959,29 +1071,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
@@ -1022,9 +1117,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
@@ -1065,27 +1190,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
@@ -1121,6 +1245,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)
@@ -1133,6 +1258,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)
@@ -1173,14 +1300,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
 
@@ -1240,6 +1375,63 @@ module ActiveRecord
         }
       end
 
+      def build_conn_str_for_dbops()
+        connect_str = "DRIVER={IBM DB2 ODBC DRIVER};ATTACH=true;"
+        if(!@host.nil?)
+          connect_str << "HOSTNAME=#{@host};"
+          connect_str << "PORT=#{@port};"
+          connect_str << "PROTOCOL=TCPIP;"
+        end
+        connect_str << "UID=#{@username};PWD=#{@password};"
+        return connect_str
+      end
+
+      def drop_database(dbName)
+        connect_str = build_conn_str_for_dbops()
+
+        #Ensure connection is closed before trying to drop a database. 
+        #As a connect call would have been made by call seeing connection in active
+        disconnect!
+
+        begin
+          dropConn = IBM_DB.connect(connect_str, '', '')
+        rescue StandardError => connect_err
+          raise "Failed to connect to server due to: #{connect_err}"
+        end
+
+        if(IBM_DB.dropDB(dropConn,dbName))
+          IBM_DB.close(dropConn)
+          return true
+        else
+          error = IBM_DB.getErrormsg(dropConn, IBM_DB::DB_CONN)
+          IBM_DB.close(dropConn)
+          raise "Could not drop Database due to: #{error}"
+        end
+      end
+
+      def create_database(dbName, codeSet=nil, mode=nil)
+        connect_str = build_conn_str_for_dbops()
+
+        #Ensure connection is closed before trying to drop a database.
+        #As a connect call would have been made by call seeing connection in active
+        disconnect!
+
+        begin
+          createConn = IBM_DB.connect(connect_str, '', '')
+        rescue StandardError => connect_err
+          raise "Failed to connect to server due to: #{connect_err}"
+        end
+
+        if(IBM_DB.createDB(createConn,dbName,codeSet,mode))
+          IBM_DB.close(createConn)
+          return true
+        else
+          error = IBM_DB.getErrormsg(createConn, IBM_DB::DB_CONN)
+          IBM_DB.close(createConn)
+          raise "Could not create Database due to: #{error}"
+        end
+      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)
@@ -1272,13 +1464,16 @@ module ActiveRecord
         # Initializes the tables array
         tables = []
         # Retrieve table's metadata through IBM_DB driver
-        stmt = IBM_DB.tables(@connection, nil, @servertype.set_case(@schema))
+        stmt = IBM_DB.tables(@connection, nil, 
+                            @servertype.set_case(@schema))
         if(stmt)
           begin
             # Fetches all the records available
             while tab = IBM_DB.fetch_assoc(stmt)
               # Adds the lowercase table name to the array
-              tables << tab["table_name"].downcase
+              if(tab["table_type"]== 'TABLE')  #check, so that only tables are dumped,IBM_DB.tables also returns views,alias etc in the schema
+                tables << tab["table_name"].downcase    
+              end
             end
           rescue StandardError => fetch_error # Handle driver fetch errors
             error_msg = IBM_DB.getErrormsg(stmt, IBM_DB::DB_STMT )
@@ -1482,6 +1677,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
@@ -1600,6 +1797,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.
@@ -1653,7 +1859,7 @@ module ActiveRecord
       end
 
       def check_reserved_words(col_name)
-        col_name
+        col_name.to_s
       end
 
       # This is supported by the DB2 for Linux, UNIX, Windows data servers
@@ -1674,7 +1880,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
@@ -1693,6 +1900,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)
@@ -1714,6 +1922,7 @@ To remove the column, the table must be dropped and recreated without the #{colu
             raise error_msg
           end
         end
+        return results
       end
 
       # Praveen
@@ -1919,11 +2128,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
@@ -1973,6 +2185,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 )
@@ -2058,6 +2271,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           @offset = nil
           @limit = nil
         end
+        return results
       end
 
       # Praveen
@@ -2113,22 +2327,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 
@@ -2160,40 +2414,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
@@ -2250,7 +2470,7 @@ SET WITH DEFAULT #{@adapter.quote(default)}"
           if RESERVED_WORDS[col_name]
             '"' + RESERVED_WORDS[col_name] + '"'
           else
-            col_name
+            col_name.to_s
           end
         end
       else
@@ -2328,6 +2548,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
@@ -2553,3 +2787,68 @@ 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
+      # In case when using Rails-2.3.x there is no arel used due to which the constructor has to be defined explicitly
+      # to ensure the same code works on any version of Rails
+      
+      #Check Arel version
+      begin
+        @arelVersion = Arel::VERSION.to_i
+      rescue
+        @arelVersion = 0
+      end
+
+      if(@arelVersion >= 3)
+        def initialize connection
+          @connection     = connection
+          @schema_cache   = connection.schema_cache if(connection.respond_to?(:schema_cache))
+          @quoted_tables  = {}
+          @quoted_columns = {}
+          @last_column    = nil
+        end
+      end
+    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?),
+        ].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})
+        sql << " #{(visit(o.lock) if o.lock)}"
+        return sql
+      end
+
+    end
+  end
+end