activerecord-oracle_enhanced-adapter 1.6.9 → 1.7.0.beta1

data/lib/active_record/connection_adapters/oracle_enhanced/connection.rb

@@ -38,7 +38,7 @@ module ActiveRecord
           db_link = nil
           default_owner = @owner
         end
-        real_name = OracleEnhancedAdapter.valid_table_name?(name) ? name.upcase : name
+        real_name = ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.valid_table_name?(name) ? name.upcase : name
         if real_name.include?('.')
           table_owner, table_name = real_name.split('.')
         else
@@ -99,6 +99,11 @@ module ActiveRecord
       end
 
     end
+
+    # Returns array with major and minor version of database (e.g. [12, 1])
+    def database_version
+      raise NoMethodError, "Not implemented for this raw driver"
+    end 
     
     class OracleEnhancedConnectionException < StandardError #:nodoc:
     end

data/lib/active_record/connection_adapters/oracle_enhanced/database_statements.rb

@@ -16,11 +16,10 @@ module ActiveRecord
           reload_type_map
         end
 
-        def exec_query(sql, name = 'SQL', binds = [])
-          type_casted_binds = binds.map { |col, val|
-            [col, type_cast(val, col)]
-          }
-          log(sql, name, type_casted_binds) do
+        def exec_query(sql, name = 'SQL', binds = [], prepare: false)
+          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+
+          log(sql, name, binds) do
             cursor = nil
             cached = false
             if without_prepared_statement?(binds)
@@ -32,10 +31,7 @@ module ActiveRecord
 
               cursor = @statements[sql]
 
-              type_casted_binds.each_with_index do |bind, i|
-                col, val = bind
-                cursor.bind_param(i + 1, val, col)
-              end
+              cursor.bind_params(type_casted_binds)
 
               cached = true
             end
@@ -86,39 +82,21 @@ module ActiveRecord
           exec_query(sql, name, binds).rows
         end
 
-        # Executes an INSERT statement and returns the new record's ID
-        def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-          # if primary key value is already prefetched from sequence
-          # or if there is no primary key
-          if id_value || pk.nil?
-            execute(sql, name)
-            return id_value
-          end
-
-          sql_with_returning = sql + @connection.returning_clause(quote_column_name(pk))
-          log(sql, name) do
-            @connection.exec_with_returning(sql_with_returning)
-          end
-        end
-        protected :insert_sql
-
         # New method in ActiveRecord 3.1
         # Will add RETURNING clause in case of trigger generated primary keys
         def sql_for_insert(sql, pk, id_value, sequence_name, binds)
-          unless id_value || pk.nil? || (defined?(CompositePrimaryKeys) && pk.kind_of?(CompositePrimaryKeys::CompositeKeys))
+          unless id_value || pk == false || pk.nil? || (defined?(CompositePrimaryKeys) && pk.kind_of?(CompositePrimaryKeys::CompositeKeys))
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
-            returning_id_col = new_column("returning_id", nil, Type::Value.new, "number", true, "dual", true, true)
-            (binds = binds.dup) << [returning_id_col, nil]
+            (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, ActiveRecord::OracleEnhanced::Type::Integer.new)
           end
-          [sql, binds]
+          super
         end
 
         # New method in ActiveRecord 3.1
         def exec_insert(sql, name, binds, pk = nil, sequence_name = nil)
-          type_casted_binds = binds.map { |col, val|
-            [col, type_cast(val, col)]
-          }
-          log(sql, name, type_casted_binds) do
+          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+
+          log(sql, name, binds) do
             returning_id_col = returning_id_index = nil
             if without_prepared_statement?(binds)
               cursor = @connection.prepare(sql)
@@ -129,23 +107,15 @@ module ActiveRecord
 
               cursor = @statements[sql]
 
-              type_casted_binds.each_with_index do |bind, i|
-                col, val = bind
-                if col.returning_id?
-                  returning_id_col = [col]
-                  returning_id_index = i + 1
-                  cursor.bind_returning_param(returning_id_index, Integer)
-                else
-                  cursor.bind_param(i + 1, val, col)
-                end
-              end
+              cursor.bind_params(type_casted_binds)
             end
 
             cursor.exec_update
 
             rows = []
+            returning_id_index = 1 if sql =~ /:returning_id/
             if returning_id_index
-              returning_id = cursor.get_returning_param(returning_id_index, Integer)
+              returning_id = cursor.get_returning_param(returning_id_index, Integer).to_i
               rows << [returning_id]
             end
             ActiveRecord::Result.new(returning_id_col || [], rows)
@@ -154,24 +124,21 @@ module ActiveRecord
 
         # New method in ActiveRecord 3.1
         def exec_update(sql, name, binds)
-          type_casted_binds = binds.map { |col, val|
-            [col, type_cast(val, col)]
-          }
-          log(sql, name, type_casted_binds) do
+          type_casted_binds = binds.map { |attr| type_cast(attr.value_for_database) }
+
+          log(sql, name, binds) do
             cached = false
             if without_prepared_statement?(binds)
               cursor = @connection.prepare(sql)
             else
               cursor = if @statements.key?(sql)
-                @statements[sql]
-              else
-                @statements[sql] = @connection.prepare(sql)
-              end
+                         @statements[sql]
+                       else
+                         @statements[sql] = @connection.prepare(sql)
+                       end
+
+              cursor.bind_params(type_casted_binds)
 
-              type_casted_binds.each_with_index do |bind, i|
-                col, val = bind
-                cursor.bind_param(i + 1, val, col)
-              end
               cached = true
             end
 
@@ -248,12 +215,6 @@ module ActiveRecord
           end
         end
 
-        private
-
-        def select(sql, name = nil, binds = [])
-          exec_query(sql, name, binds)
-        end
-
       end
     end
   end

data/lib/active_record/connection_adapters/oracle_enhanced/jdbc_connection.rb

@@ -109,9 +109,8 @@ module ActiveRecord
           host, port = config[:host], config[:port]
           privilege = config[:privilege] && config[:privilege].to_s
 
-          # connection using TNS alias, or connection-string from DATABASE_URL
-          using_tns_alias = !host && !config[:url] && ENV['TNS_ADMIN']
-          if database && (using_tns_alias || host == 'connection-string')
+          # connection using TNS alias
+          if database && !host && !config[:url] && ENV['TNS_ADMIN']
             url = "jdbc:oracle:thin:@#{database}"
           else
             unless database.match(/^(\:|\/)/)
@@ -320,39 +319,64 @@ module ActiveRecord
         Cursor.new(self, @raw_connection.prepareStatement(sql))
       end
 
+      def database_version
+        @database_version ||= (md = raw_connection.getMetaData) && [md.getDatabaseMajorVersion, md.getDatabaseMinorVersion]
+      end
+
       class Cursor
         def initialize(connection, raw_statement)
           @connection = connection
           @raw_statement = raw_statement
         end
 
+        def bind_params( *bind_vars )
+          index = 1
+          bind_vars.flatten.each do |var|
+            if Hash === var
+              var.each { |key, val| bind_param key, val }
+            else
+              bind_param index, var
+              index += 1
+            end
+          end
+        end
+
         def bind_param(position, value, column = nil)
-          col_type = column && column.type
-          java_value = ruby_to_java_value(value, col_type)
+          if column
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              *******************************************************
+              Passing a column to `bind_param` will be deprecated.
+              `type_casted_binds` should be already type casted
+              so that `bind_param` should not need to know column.
+              *******************************************************
+            MSG
+          end
+
           case value
           when Integer
-            @raw_statement.setLong(position, java_value)
+            @raw_statement.setLong(position, value)
           when Float
-            @raw_statement.setFloat(position, java_value)
+            @raw_statement.setFloat(position, value)
           when BigDecimal
-            @raw_statement.setBigDecimal(position, java_value)
+            @raw_statement.setBigDecimal(position, value)
+          when Java::OracleSql::BLOB
+            @raw_statement.setBlob(position, value)
+          when ActiveRecord::OracleEnhanced::Type::Text::Data
+            @raw_statement.setClob(position, value)
+          when ActiveRecord::OracleEnhanced::Type::Raw
+            @raw_statement.setString(position, ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.encode_raw(value))
           when String
-            case col_type
-            when :text
-              @raw_statement.setClob(position, java_value)
-            when :binary
-              @raw_statement.setBlob(position, java_value)
-            when :raw
-              @raw_statement.setString(position, OracleEnhancedAdapter.encode_raw(java_value))
-            when :decimal
-              @raw_statement.setBigDecimal(position, java_value)
-            else
-              @raw_statement.setString(position, java_value)
-            end
+            @raw_statement.setString(position, value)
+          when Java::OracleSql::DATE
+            @raw_statement.setDATE(position, value)
           when Date, DateTime
-            @raw_statement.setDATE(position, java_value)
+            # TODO: Really needed or not
+            @raw_statement.setDATE(position, value)
+          when Java::JavaSql::Timestamp
+            @raw_statement.setTimestamp(position, value)
           when Time
-            @raw_statement.setTimestamp(position, java_value)
+            # TODO: Really needed or not
+            @raw_statement.setTimestamp(position, value)
           when NilClass
             if column && column.object_type?
               @raw_statement.setNull(position, java.sql.Types::STRUCT, column.sql_type)
@@ -428,38 +452,6 @@ module ActiveRecord
           @raw_statement.close
         end
 
-        private
-
-        def ruby_to_java_value(value, col_type = nil)
-          case value
-          when Fixnum, Float
-            value
-          when String
-            case col_type
-            when :text
-              clob = Java::OracleSql::CLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::CLOB::DURATION_SESSION)
-              clob.setString(1, value)
-              clob
-            when :binary
-              blob = Java::OracleSql::BLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
-              blob.setBytes(1, value.to_java_bytes)
-              blob
-            when :decimal
-              java.math.BigDecimal.new(value.to_s)
-            else
-              value
-            end
-          when BigDecimal
-            java.math.BigDecimal.new(value.to_s)
-          when Date, DateTime
-            Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
-          when Time
-            Java::java.sql.Timestamp.new(value.year-1900, value.month-1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
-          else
-            value
-          end
-        end
-
       end
 
       def select(sql, name = nil, return_column_names = false)
@@ -532,8 +524,6 @@ module ActiveRecord
           else
             BigDecimal.new(d.stringValue)
           end
-        when :BINARY_FLOAT
-          rset.getFloat(i)
         when :VARCHAR2, :CHAR, :LONG, :NVARCHAR2, :NCHAR
           rset.getString(i)
         when :DATE

data/lib/active_record/connection_adapters/oracle_enhanced/jdbc_quoting.rb

@@ -0,0 +1,35 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module JDBCQuoting
+        def _type_cast(value)
+          case value
+          when ActiveModel::Type::Binary::Data
+            blob = Java::OracleSql::BLOB.createTemporary(@connection.raw_connection, false, Java::OracleSql::BLOB::DURATION_SESSION)
+            blob.setBytes(1, value.to_s.to_java_bytes)
+            blob
+          when ActiveRecord::OracleEnhanced::Type::Text::Data
+            #TODO: may need CLOB specific handling
+            value.to_s
+          when Date, DateTime
+            Java::oracle.sql.DATE.new(value.strftime("%Y-%m-%d %H:%M:%S"))
+          when Time
+            Java::java.sql.Timestamp.new(value.year-1900, value.month-1, value.day, value.hour, value.min, value.sec, value.usec * 1000)
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        prepend JDBCQuoting
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced/oci_connection.rb

@@ -10,7 +10,7 @@ rescue LoadError => e
 end
 
 # check ruby-oci8 version
-required_oci8_version = [2, 0, 3]
+required_oci8_version = [2, 2, 0]
 oci8_version_ints = OCI8::VERSION.scan(/\d+/).map{|s| s.to_i}
 if (oci8_version_ints <=> required_oci8_version) < 0
   raise LoadError, "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version #{required_oci8_version.join('.')} or later."
@@ -117,26 +117,37 @@ module ActiveRecord
           @raw_cursor = raw_cursor
         end
 
-        def bind_param(position, value, column = nil)
-          if column && column.object_type?
-            if @connection.raw_connection.respond_to? :get_tdo_by_typename
-              @raw_cursor.bind_param(position, value, :named_type, column.sql_type)
+        def bind_params( *bind_vars )
+          index = 1
+          bind_vars.flatten.each do |var|
+            if Hash === var
+              var.each { |key, val| bind_param key, val }
             else
-              raise "Use ruby-oci8 2.1.6 or later to bind Oracle objects."
+              bind_param index, var
+              index += 1
             end
+          end
+        end
+
+        def bind_param(position, value, column = nil)
+          if column
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              *******************************************************
+              Passing a column to `bind_param` will be deprecated.
+              `type_casted_binds` should be already type casted
+              so that `bind_param` should not need to know column.
+              *******************************************************
+            MSG
+          end
+
+          if column && column.object_type?
+            @raw_cursor.bind_param(position, value, :named_type, column.sql_type)
           elsif value.nil?
             @raw_cursor.bind_param(position, nil, String)
           else
             case col_type = column && column.type
-            when :text, :binary
-              # ruby-oci8 cannot create CLOB/BLOB from ''
-              lob_value = value == '' ? ' ' : value
-              bind_type = col_type == :text ? OCI8::CLOB : OCI8::BLOB
-              ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
-              ora_value.size = 0 if value == ''
-              @raw_cursor.bind_param(position, ora_value)
             when :raw
-              @raw_cursor.bind_param(position, OracleEnhancedAdapter.encode_raw(value))
+              @raw_cursor.bind_param(position, ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.encode_raw(value))
             when :decimal
               @raw_cursor.bind_param(position, BigDecimal.new(value.to_s))
             else
@@ -216,7 +227,7 @@ module ActiveRecord
       def describe(name)
         # fall back to SELECT based describe if using database link
         return super if name.to_s.include?('@')
-        quoted_name = OracleEnhancedAdapter.valid_table_name?(name) ? name : "\"#{name}\""
+        quoted_name = ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting.valid_table_name?(name) ? name : "\"#{name}\""
         @raw_connection.describe(quoted_name)
       rescue OCIException => e
         if e.code == 4043
@@ -239,12 +250,12 @@ module ActiveRecord
 
       def typecast_result_value(value, get_lob_value)
         case value
-        when Integer
+        when Fixnum, Bignum
           value
         when String
           value
         when Float, BigDecimal
-          # return Integer if value is integer (to avoid issues with _before_type_cast values for id attributes)
+          # return Fixnum or Bignum if value is integer (to avoid issues with _before_type_cast values for id attributes)
           value == (v_to_i = value.to_i) ? v_to_i : value
         when OraNumber
           # change OraNumber value (returned in early versions of ruby-oci8 2.0.x) to BigDecimal
@@ -269,6 +280,10 @@ module ActiveRecord
         end
       end
 
+      def database_version
+        @database_version ||= (version = raw_connection.oracle_server_version) && [version.major, version.minor]
+      end
+
       private
 
       def date_without_time?(value)
@@ -317,11 +332,8 @@ module ActiveRecord
         # get session time_zone from configuration or from TZ environment variable
         time_zone = config[:time_zone] || ENV['TZ']
 
-        # using a connection string via DATABASE_URL
-        connection_string = if host == 'connection-string'
-          database
         # connection using host, port and database name
-        elsif host || port
+        connection_string = if host || port
           host ||= 'localhost'
           host = "[#{host}]" if host =~ /^[^\[].*:/  # IPv6
           port ||= 1521
@@ -332,6 +344,7 @@ module ActiveRecord
         else
           database
         end
+
         conn = OCI8.new username, password, connection_string, privilege
         conn.autocommit = true
         conn.non_blocking = true if async