pmacs-activerecord-oracle_enhanced-adapter 1.4.2.rc1 → 1.5.5.1

data/lib/active_record/connection_adapters/oracle_enhanced_column.rb

@@ -2,34 +2,63 @@ module ActiveRecord
   module ConnectionAdapters #:nodoc:
     class OracleEnhancedColumn < Column
 
-      attr_reader :table_name, :forced_column_type, :nchar, :virtual_column_data_default #:nodoc:
+      attr_reader :table_name, :forced_column_type, :nchar, :virtual_column_data_default, :returning_id #:nodoc:
 
-      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil, virtual=false) #:nodoc:
+      def initialize(name, default, sql_type = nil, null = true, table_name = nil, forced_column_type = nil, virtual=false, returning_id=false) #:nodoc:
         @table_name = table_name
         @forced_column_type = forced_column_type
         @virtual = virtual
         @virtual_column_data_default = default.inspect if virtual
-        default = nil if virtual
-        super(name, default, sql_type, null)
+        @returning_id = returning_id
+        if virtual
+          default_value = nil
+        else
+          default_value = self.class.extract_value_from_default(default)
+        end
+        super(name, default_value, sql_type, null)
         # Is column NCHAR or NVARCHAR2 (will need to use N'...' value quoting for these data types)?
         # Define only when needed as adapter "quote" method will check at first if instance variable is defined.
         @nchar = true if @type == :string && sql_type[0,1] == 'N'
+        @object_type = sql_type.include? '.'
       end
 
       def type_cast(value) #:nodoc:
-        return OracleEnhancedColumn::string_to_raw(value) if type == :raw
-        return guess_date_or_time(value) if type == :datetime && OracleEnhancedAdapter.emulate_dates
-        super
+        case type
+        when :raw
+          OracleEnhancedColumn.string_to_raw(value)
+        when :datetime
+          OracleEnhancedAdapter.emulate_dates ? guess_date_or_time(value) : super
+        when :float
+          !value.nil? ? self.class.value_to_decimal(value) : super
+        else
+          super
+        end
+      end
+
+      def type_cast_code(var_name)
+        type == :float ? "#{self.class.name}.value_to_decimal(#{var_name})" : super
+      end
+
+      def klass
+        type == :float ? BigDecimal : super
       end
 
       def virtual?
         @virtual
       end
 
+      def returning_id?
+        @returning_id
+      end
+
       def lob?
         self.sql_type =~ /LOB$/i
       end
 
+      def object_type?
+        @object_type
+      end
+
       # convert something to a boolean
       # added y as boolean value
       def self.value_to_boolean(value) #:nodoc:
@@ -71,12 +100,14 @@ module ActiveRecord
         forced_column_type ||
         case field_type
         when /decimal|numeric|number/i
-          if OracleEnhancedAdapter.emulate_booleans && field_type == 'NUMBER(1)'
+          if OracleEnhancedAdapter.emulate_booleans && field_type.upcase == "NUMBER(1)"
             :boolean
           elsif extract_scale(field_type) == 0 ||
                 # if column name is ID or ends with _ID
                 OracleEnhancedAdapter.emulate_integers_by_column_name && OracleEnhancedAdapter.is_integer_column?(name, table_name)
             :integer
+          elsif field_type.upcase == "NUMBER"
+            OracleEnhancedAdapter.number_datatype_coercion
           else
             :decimal
           end
@@ -104,6 +135,15 @@ module ActiveRecord
         end
       end
 
+      def self.extract_value_from_default(default)
+        case default
+          when String
+            default.gsub(/''/, "'")
+          else
+            default
+        end
+      end
+
       def guess_date_or_time(value)
         value.respond_to?(:hour) && (value.hour == 0 and value.min == 0 and value.sec == 0) ?
           Date.new(value.year, value.month, value.day) : value

data/lib/active_record/connection_adapters/oracle_enhanced_column_dumper.rb

@@ -0,0 +1,77 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedColumnDumper #:nodoc:
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :column_spec,            :oracle_enhanced
+          alias_method_chain :prepare_column_options, :oracle_enhanced
+          alias_method_chain :migration_keys,         :oracle_enhanced
+
+          def oracle_enhanced_adapter?
+          # return original method if not using 'OracleEnhanced'
+            if (rails_env = defined?(Rails.env) ? Rails.env : (defined?(RAILS_ENV) ? RAILS_ENV : nil)) &&
+                ActiveRecord::Base.configurations[rails_env] &&
+                ActiveRecord::Base.configurations[rails_env]['adapter'] != 'oracle_enhanced'
+              return false
+            else
+              return true
+            end
+          end
+        end
+      end
+
+      def column_spec_with_oracle_enhanced(column, types)
+        # return original method if not using 'OracleEnhanced'
+        return column_spec_without_oracle_enhanced(column, types) unless oracle_enhanced_adapter?
+        
+        spec = prepare_column_options(column, types)
+        (spec.keys - [:name, :type]).each do |k|
+          key_s = (k == :virtual_type ? "type: " : "#{k.to_s}: ")
+          spec[k] = key_s + spec[k]
+        end
+        spec
+      end
+
+      def prepare_column_options_with_oracle_enhanced(column, types)
+        # return original method if not using 'OracleEnhanced'
+        return prepare_column_options_without_oracle_enhanced(column, types) unless oracle_enhanced_adapter?
+
+        spec = {}
+
+        spec[:name]      = column.name.inspect
+        spec[:type]      = column.virtual? ? 'virtual' : column.type.to_s
+        spec[:limit]     = column.limit.inspect if column.limit != types[column.type][:limit] && column.type != :decimal
+        spec[:precision] = column.precision.inspect if !column.precision.nil?
+        spec[:scale]     = column.scale.inspect if !column.scale.nil?
+        spec[:null]      = 'false' if !column.null
+        spec[:as]        = column.virtual_column_data_default if column.virtual?
+        spec[:default]   = default_string(column.default) if column.has_default? && !column.virtual?
+
+        if column.virtual?
+          # Supports backwards compatibility with older OracleEnhancedAdapter versions where 'NUMBER' virtual column type is not included in dump
+          if column.sql_type != "NUMBER" || ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.number_datatype_coercion != :decimal
+            spec[:virtual_type] = column.type.inspect
+          end
+        end
+
+        spec
+      end
+
+      def migration_keys_with_oracle_enhanced
+        # TODO `& column_specs.map(&:keys).flatten` should be exetuted here
+        # return original method if not using 'OracleEnhanced'
+        return migration_keys_without_oracle_enhanced unless oracle_enhanced_adapter?
+
+        [:name, :limit, :precision, :scale, :default, :null, :as, :virtual_type]
+      end
+
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::ColumnDumper.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedColumnDumper
+end

data/lib/active_record/connection_adapters/oracle_enhanced_connection.rb

@@ -4,18 +4,13 @@ module ActiveRecord
     class OracleEnhancedConnection #:nodoc:
 
       def self.create(config)
-        connection = create_connection(config)
-        unless connection.nil?
-          connection.after_initialize(config)
-        end
-        connection
-      end
-
-      def after_initialize(config)
-        schema = config[:schema]
-        unless schema.blank?
-          exec "alter session set current_schema = #{schema}"
-          @owner = schema.upcase
+        case ORACLE_ENHANCED_CONNECTION
+        when :oci
+          OracleEnhancedOCIConnection.new(config)
+        when :jdbc
+          OracleEnhancedJDBCConnection.new(config)
+        else
+          nil
         end
       end
 
@@ -103,22 +98,11 @@ module ActiveRecord
         result.map { |r| r.values.first }
       end
 
-
-      protected
-      def self.create_connection(config)
-        case ORACLE_ENHANCED_CONNECTION
-        when :oci
-          OracleEnhancedOCIConnection.new(config)
-        when :jdbc
-          OracleEnhancedJDBCConnection.new(config)
-        else
-          nil
-        end
-      end
     end
     
     class OracleEnhancedConnectionException < StandardError #:nodoc:
     end
+
   end
 end
 

data/lib/active_record/connection_adapters/oracle_enhanced_context_index.rb

@@ -329,19 +329,10 @@ module ActiveRecord
 
       module ContextIndexClassMethods
         # Add context index condition.
-        case ::ActiveRecord::VERSION::MAJOR
-        when 3
-          def contains(column, query, options ={})
-            score_label = options[:label].to_i || 1
-            where("CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query).
-              order("SCORE(#{score_label}) DESC")
-          end
-        when 2
-          def contains(column, query, options ={})
-            score_label = options[:label].to_i || 1
-            scoped(:conditions => ["CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query],
-              :order => "SCORE(#{score_label}) DESC")
-          end
+        def contains(column, query, options ={})
+          score_label = options[:label].to_i || 1
+          where("CONTAINS(#{connection.quote_column_name(column)}, ?, #{score_label}) > 0", query).
+            order("SCORE(#{score_label}) DESC")
         end
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_database_tasks.rb

@@ -0,0 +1,61 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class OracleEnhancedAdapter
+      class DatabaseTasks
+        delegate :connection, :establish_connection, :to => ActiveRecord::Base
+
+        def initialize(config)
+          @config = config
+        end
+
+        def create
+          print "Please provide the SYSTEM password for your Oracle installation\n>"
+          system_password = $stdin.gets.strip
+          establish_connection(@config.merge('username' => 'SYSTEM', 'password' => system_password))
+          begin
+            connection.execute "CREATE USER #{@config['username']} IDENTIFIED BY #{@config['password']}"
+          rescue => e
+            if e.message =~ /ORA-01920/ # user name conflicts with another user or role name
+              connection.execute "ALTER USER #{@config['username']} IDENTIFIED BY #{@config['password']}"
+            else
+              raise e
+            end
+          end
+          connection.execute "GRANT unlimited tablespace TO #{@config['username']}"
+          connection.execute "GRANT create session TO #{@config['username']}"
+          connection.execute "GRANT create table TO #{@config['username']}"
+          connection.execute "GRANT create sequence TO #{@config['username']}"
+        end
+
+        def drop
+          establish_connection(@config)
+          connection.execute_structure_dump(connection.full_drop)
+        end
+
+        def purge
+          drop
+          connection.execute('PURGE RECYCLEBIN') rescue nil
+        end
+
+        def structure_dump(filename)
+          establish_connection(@config)
+          File.open(filename, 'w:utf-8') { |f| f << connection.structure_dump }
+          if connection.supports_migrations?
+            File.open(filename, 'a') { |f| f << connection.dump_schema_information }
+          end
+          if @config['structure_dump'] == 'db_stored_code'
+             File.open(filename, 'a') { |f| f << connection.structure_dump_db_stored_code }
+          end
+        end
+
+        def structure_load(filename)
+          establish_connection(@config)
+          connection.execute_structure_dump(File.read(filename))
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Tasks::DatabaseTasks.register_task(/(oci|oracle)/, ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DatabaseTasks)
+

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -4,20 +4,22 @@ module ActiveRecord #:nodoc:
 
       module InstanceMethods #:nodoc:
         private
-        
+
         def _field_changed?(attr, old, value)
           if column = column_for_attribute(attr)
             # Added also :decimal type
-            if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0) && value.blank?
-              # For nullable integer columns, NULL gets stored in database for blank (i.e. '') values.
+            if ([:integer, :decimal, :float].include? column.type) && column.null && (old.nil? || old == 0) && value.blank?
+              # For nullable integer/decimal/float columns, NULL gets stored in database for blank (i.e. '') values.
               # Hence we don't record it as a change if the value changes from nil to ''.
               # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
               # be typecast back to 0 (''.to_i => 0)
               value = nil
-            # Oracle stores empty string '' as NULL
-            # therefore need to convert empty string value to nil if old value is nil
             elsif column.type == :string && column.null && old.nil?
+              # Oracle stores empty string '' as NULL
+              # therefore need to convert empty string value to nil if old value is nil
               value = nil if value == ''
+            elsif old == 0 && value.is_a?(String) && value.present? && non_zero?(value)
+              value = nil
             else
               value = column.type_cast(value)
             end
@@ -25,7 +27,11 @@ module ActiveRecord #:nodoc:
 
           old != value
         end
-        
+
+        def non_zero?(value)
+          value !~ /\A0+(\.0+)?\z/
+        end
+
       end
 
     end
@@ -35,10 +41,5 @@ end
 if ActiveRecord::Base.method_defined?(:changed?)
   ActiveRecord::Base.class_eval do
     include ActiveRecord::ConnectionAdapters::OracleEnhancedDirty::InstanceMethods
-    # Starting with rails 3.2.9 the method #field_changed?
-    # was renamed to #_field_changed?
-    if private_method_defined?(:field_changed?)
-      alias_method :field_changed?, :_field_changed?
-    end
   end
-end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -2,24 +2,36 @@ begin
   require "java"
   require "jruby"
 
-  # ojdbc6.jar or ojdbc5.jar file should be in JRUBY_HOME/lib or should be in ENV['PATH'] or load path
+  # ojdbc7.jar, ojdbc6.jar or ojdbc5.jar file should be in application ./lib directory or in load path or in ENV['PATH']
 
   java_version = java.lang.System.getProperty("java.version")
-  ojdbc_jar = if java_version =~ /^1.5/
-    "ojdbc5.jar"
-  elsif java_version >= '1.6'
-    "ojdbc6.jar"
+  ojdbc_jars = if java_version =~ /^1.5/
+    %w(ojdbc5.jar)
+  elsif java_version =~ /^1.6/
+    %w(ojdbc6.jar)
+  elsif java_version >= '1.7'
+    # Oracle 11g client ojdbc6.jar is also compatible with Java 1.7
+    # Oracle 12c client provides new ojdbc7.jar
+    %w(ojdbc7.jar ojdbc6.jar)
   else
     nil
   end
 
-  unless ojdbc_jar.nil? || ENV_JAVA['java.class.path'] =~ Regexp.new(ojdbc_jar)
+  if ojdbc_jars && ENV_JAVA['java.class.path'] !~ Regexp.new(ojdbc_jars.join('|'))
     # On Unix environment variable should be PATH, on Windows it is sometimes Path
-    env_path = (ENV["PATH"] || ENV["Path"] || '').split(/[:;]/)
+    env_path = (ENV["PATH"] || ENV["Path"] || '').split(File::PATH_SEPARATOR)
     # Look for JDBC driver at first in lib subdirectory (application specific JDBC file version)
     # then in Ruby load path and finally in environment PATH
-    if ojdbc_jar_path = ['./lib'].concat($LOAD_PATH).concat(env_path).find{|d| File.exists?(File.join(d,ojdbc_jar))}
-      require File.join(ojdbc_jar_path,ojdbc_jar)
+    ['./lib'].concat($LOAD_PATH).concat(env_path).detect do |dir|
+      # check any compatible JDBC driver in the priority order
+      ojdbc_jars.any? do |ojdbc_jar|
+        if File.exists?(file_path = File.join(dir, ojdbc_jar))
+          puts "WARNING: JDK #{java_version} is not officially supported by #{ojdbc_jar}" if java_version >= '1.8'
+          puts "See http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-faq-090281.html#01_03 for supported versions"
+          require file_path
+          true
+        end
+      end
     end
   end
 
@@ -33,7 +45,7 @@ begin
 
 rescue LoadError, NameError
   # JDBC driver is unavailable.
-  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install #{ojdbc_jar || "Oracle JDBC"} library."
+  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install #{ojdbc_jars ? ojdbc_jars.join(' or ') : "Oracle JDBC"} library."
 end
 
 
@@ -86,7 +98,7 @@ module ActiveRecord
             @raw_connection = @raw_connection.innermost_delegate
           elsif @raw_connection.respond_to?(:getUnderlyingConnection)
             @pooled_connection = @raw_connection
-            @raw_connection = @raw_connection.underlying_connection            
+            @raw_connection = @raw_connection.underlying_connection
           end
 
           config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
@@ -149,8 +161,14 @@ module ActiveRecord
 
         self.autocommit = true
 
-        # default schema owner
-        @owner = username.upcase unless username.nil?
+        schema = config[:schema] && config[:schema].to_s
+        if schema.blank?
+          # default schema owner
+          @owner = username.upcase unless username.nil?
+        else
+          exec "alter session set current_schema = #{schema}"
+          @owner = schema
+        end
 
         @raw_connection
       end
@@ -285,7 +303,7 @@ module ActiveRecord
             # else
             #   nil
             # end
-            
+
             # Workaround with CallableStatement
             s = @raw_connection.prepareCall("BEGIN #{sql}; END;")
             s.registerOutParameter(1, java.sql.Types::BIGINT)
@@ -309,7 +327,8 @@ module ActiveRecord
           @raw_statement = raw_statement
         end
 
-        def bind_param(position, value, col_type = nil)
+        def bind_param(position, value, column = nil)
+          col_type = column && column.type
           java_value = ruby_to_java_value(value, col_type)
           case value
           when Integer
@@ -336,10 +355,14 @@ module ActiveRecord
           when Time
             @raw_statement.setTimestamp(position, java_value)
           when NilClass
-            # TODO: currently nil is always bound as NULL with VARCHAR type.
-            # When nils will actually be used by ActiveRecord as bound parameters
-            # then need to pass actual column type.
-            @raw_statement.setNull(position, java.sql.Types::VARCHAR)
+            if column && column.object_type?
+              @raw_statement.setNull(position, java.sql.Types::STRUCT, column.sql_type)
+            else
+              # TODO: currently nil is always bound as NULL with VARCHAR type.
+              # When nils will actually be used by ActiveRecord as bound parameters
+              # then need to pass actual column type.
+              @raw_statement.setNull(position, java.sql.Types::VARCHAR)
+            end
           else
             raise ArgumentError, "Don't know how to bind variable with type #{value.class}"
           end