activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.2

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

@@ -1,4 +1,4 @@
-require 'active_support'
+require "active_support"
 
 module ActiveRecord #:nodoc:
   # Custom create, update, delete methods functionality.
@@ -96,99 +96,99 @@ module ActiveRecord #:nodoc:
 
     private
 
-    # Creates a record with custom create method
-    # and returns its id.
-    def _create_record
-      # check if class has custom create method
-      if self.class.custom_create_method
-        # run before/after callbacks defined in model
-        run_callbacks(:create) do
-          # timestamp
-          if self.record_timestamps
-            current_time = current_time_from_proper_timezone
-
-            all_timestamp_attributes.each do |column|
-              if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
-                write_attribute(column.to_s, current_time)
+      # Creates a record with custom create method
+      # and returns its id.
+      def _create_record
+        # check if class has custom create method
+        if self.class.custom_create_method
+          # run before/after callbacks defined in model
+          run_callbacks(:create) do
+            # timestamp
+            if self.record_timestamps
+              current_time = current_time_from_proper_timezone
+
+              all_timestamp_attributes_in_model.each do |column|
+                if respond_to?(column) && respond_to?("#{column}=") && self.send(column).nil?
+                  write_attribute(column.to_s, current_time)
+                end
               end
             end
+            # run
+            create_using_custom_method
           end
-          # run
-          create_using_custom_method
+        else
+          super
         end
-      else
-        super
       end
-    end
 
-    def create_using_custom_method
-      log_custom_method("custom create method", "#{self.class.name} Create") do
-        self.id = instance_eval(&self.class.custom_create_method)
+      def create_using_custom_method
+        log_custom_method("custom create method", "#{self.class.name} Create") do
+          self.id = instance_eval(&self.class.custom_create_method)
+        end
+        @new_record = false
+        # Starting from ActiveRecord 3.0.3 @persisted is used instead of @new_record
+        @persisted = true
+        id
       end
-      @new_record = false
-      # Starting from ActiveRecord 3.0.3 @persisted is used instead of @new_record
-      @persisted = true
-      id
-    end
 
-    # Updates the associated record with custom update method
-    # Returns the number of affected rows.
-    def _update_record(attribute_names = @attributes.keys)
-      # check if class has custom update method
-      if self.class.custom_update_method
-        # run before/after callbacks defined in model
-        run_callbacks(:update) do
-          # timestamp
-          if should_record_timestamps?
-            current_time = current_time_from_proper_timezone
-
-            timestamp_attributes_for_update_in_model.each do |column|
-              column = column.to_s
-              next if attribute_changed?(column)
-              write_attribute(column, current_time)
+      # Updates the associated record with custom update method
+      # Returns the number of affected rows.
+      def _update_record(attribute_names = @attributes.keys)
+        # check if class has custom update method
+        if self.class.custom_update_method
+          # run before/after callbacks defined in model
+          run_callbacks(:update) do
+            # timestamp
+            if should_record_timestamps?
+              current_time = current_time_from_proper_timezone
+
+              timestamp_attributes_for_update_in_model.each do |column|
+                column = column.to_s
+                next if attribute_changed?(column)
+                write_attribute(column, current_time)
+              end
+            end
+            # update just dirty attributes
+            if partial_writes?
+              # Serialized attributes should always be written in case they've been
+              # changed in place.
+              update_using_custom_method(changed | (attributes.keys & self.class.columns.select { |column| column.is_a?(Type::Serialized) }))
+            else
+              update_using_custom_method(attributes.keys)
             end
           end
-          # update just dirty attributes
-          if partial_writes?
-            # Serialized attributes should always be written in case they've been
-            # changed in place.
-            update_using_custom_method(changed | (attributes.keys & self.class.columns.select {|column| column.is_a?(Type::Serialized)}))
-          else
-            update_using_custom_method(attributes.keys)
-          end
+        else
+          super
         end
-      else
-        super
       end
-    end
 
-    def update_using_custom_method(attribute_names)
-      return 0 if attribute_names.empty?
-      log_custom_method("custom update method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Update") do
-        instance_eval(&self.class.custom_update_method)
+      def update_using_custom_method(attribute_names)
+        return 0 if attribute_names.empty?
+        log_custom_method("custom update method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Update") do
+          instance_eval(&self.class.custom_update_method)
+        end
+        1
       end
-      1
-    end
 
-    # Deletes the record in the database with custom delete method
-    # and freezes this instance to reflect that no changes should
-    # be made (since they can't be persisted).
-    def destroy_using_custom_method
-      unless new_record? || @destroyed
-        log_custom_method("custom delete method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Destroy") do
-          instance_eval(&self.class.custom_delete_method)
+      # Deletes the record in the database with custom delete method
+      # and freezes this instance to reflect that no changes should
+      # be made (since they can't be persisted).
+      def destroy_using_custom_method
+        unless new_record? || @destroyed
+          log_custom_method("custom delete method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Destroy") do
+            instance_eval(&self.class.custom_delete_method)
+          end
         end
-      end
 
-      @destroyed = true
-      freeze
-    end
+        @destroyed = true
+        freeze
+      end
 
-    def log_custom_method(*args)
-      self.class.connection.send(:log, *args) { yield }
-    end
+      def log_custom_method(*args)
+        self.class.connection.send(:log, *args) { yield }
+      end
 
-    alias_method :update_record, :_update_record if private_method_defined?(:_update_record)
-    alias_method :create_record, :_create_record if private_method_defined?(:_create_record)
+      alias_method :update_record, :_update_record if private_method_defined?(:_update_record)
+      alias_method :create_record, :_create_record if private_method_defined?(:_create_record)
   end
 end

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

@@ -76,79 +76,50 @@ module ActiveRecord
         end
 
         def quote_table_name(name) #:nodoc:
-          name, link = name.to_s.split('@')
-          @quoted_table_names[name] ||= [name.split('.').map{|n| quote_column_name(n)}.join('.'), quote_database_link(link)].compact.join('@')
+          name, link = name.to_s.split("@")
+          @quoted_table_names[name] ||= [name.split(".").map { |n| quote_column_name(n) }.join("."), quote_database_link(link)].compact.join("@")
         end
 
         def quote_string(s) #:nodoc:
           s.gsub(/'/, "''")
         end
 
-        def quote(value, column = nil) #:nodoc:
-          super
-        end
-
         def _quote(value) #:nodoc:
           case value
           when ActiveRecord::OracleEnhanced::Type::NationalCharacterString::Data then
-             "N" << "'#{quote_string(value.to_s)}'"
+            "N" << "'#{quote_string(value.to_s)}'"
           when ActiveModel::Type::Binary::Data then
-            %Q{empty_#{ type_to_sql(column.type.to_sym).downcase rescue 'blob' }()}
+            "empty_blob()"
           when ActiveRecord::OracleEnhanced::Type::Text::Data then
-            %Q{empty_#{ type_to_sql(column.type.to_sym).downcase rescue 'clob' }()}
+            "empty_clob()"
           else
             super
           end
         end
 
         def quoted_true #:nodoc:
-          return "'#{self.class.boolean_to_string(true)}'" if emulate_booleans_from_strings
+          return "'Y'" if emulate_booleans_from_strings
           "1".freeze
         end
 
         def unquoted_true #:nodoc:
-          return "#{self.class.boolean_to_string(true)}" if emulate_booleans_from_strings
+          return "Y" if emulate_booleans_from_strings
           "1".freeze
         end
 
         def quoted_false #:nodoc:
-          return "'#{self.class.boolean_to_string(false)}'" if emulate_booleans_from_strings
+          return "'N'" if emulate_booleans_from_strings
           "0".freeze
         end
 
         def unquoted_false #:nodoc:
-          return "#{self.class.boolean_to_string(false)}" if emulate_booleans_from_strings
+          return "N" if emulate_booleans_from_strings
           "0".freeze
         end
 
-        def quote_date_with_to_date(value) #:nodoc:
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `quote_date_with_to_date` will be deprecated in future version of Oracle enhanced adapter.
-            Also this method should not be called directly. Let Abstract adapter `_quote` method handle it.
-          MSG
-          # should support that composite_primary_keys gem will pass date as string
-          value = quoted_date(value) if value.acts_like?(:date) || value.acts_like?(:time)
-          "TO_DATE('#{value}','YYYY-MM-DD HH24:MI:SS')"
-        end
-
-        def quote_timestamp_with_to_timestamp(value) #:nodoc:
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `quote_timestamp_with_to_timestamp` will be deprecated in future version of Oracle enhanced adapter.
-            Also this method should not be called directly. Let Abstract adapter `_quote` method handle it.
-          MSG
-          # add up to 9 digits of fractional seconds to inserted time
-          value = "#{quoted_date(value)}:#{("%.6f"%value.to_f).split('.')[1]}" if value.acts_like?(:time)
-          "TO_TIMESTAMP('#{value}','YYYY-MM-DD HH24:MI:SS:FF6')"
-        end
-
-        # Cast a +value+ to a type that the database understands.
-        def type_cast(value, column = nil)
-          super
-        end
-
         def _type_cast(value)
           case value
-          when Date, Time
+          when ActiveRecord::OracleEnhanced::Type::TimestampTz::Data
             if value.acts_like?(:time)
               zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
               value.respond_to?(zone_conversion_method) ? value.send(zone_conversion_method) : value
@@ -167,11 +138,11 @@ module ActiveRecord
 end
 
 # if MRI or YARV
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == 'ruby'
-  require 'active_record/connection_adapters/oracle_enhanced/oci_quoting'
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+  require "active_record/connection_adapters/oracle_enhanced/oci_quoting"
 # if JRuby
-elsif RUBY_ENGINE == 'jruby'
-  require 'active_record/connection_adapters/oracle_enhanced/jdbc_quoting'
+elsif RUBY_ENGINE == "jruby"
+  require "active_record/connection_adapters/oracle_enhanced/jdbc_quoting"
 else
   raise "Unsupported Ruby engine #{RUBY_ENGINE}"
 end

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

@@ -4,92 +4,88 @@ module ActiveRecord
       class SchemaCreation < AbstractAdapter::SchemaCreation
         private
 
-        def visit_ColumnDefinition(o)
-          case
-            when o.type.to_sym == :virtual
-              sql_type = type_to_sql(o.default[:type], o.limit, o.precision, o.scale) if o.default[:type]
-              return "#{quote_column_name(o.name)} #{sql_type} AS (#{o.default[:as]})"
-            when [:blob, :clob].include?(sql_type = type_to_sql(o.type.to_sym,  o.limit, o.precision, o.scale).downcase.to_sym)
+          def visit_ColumnDefinition(o)
+            if [:blob, :clob].include?(sql_type = type_to_sql(o.type,  o.options).downcase.to_sym)
               if (tablespace = default_tablespace_for(sql_type))
                 @lob_tablespaces ||= {}
                 @lob_tablespaces[o.name] = tablespace
               end
+            end
+            super
           end
-          super
-        end
 
-        def visit_TableDefinition(o)
-          create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
-          statements = o.columns.map { |c| accept c }
-          statements << accept(o.primary_keys) if o.primary_keys
+          def visit_TableDefinition(o)
+            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} "
+            statements = o.columns.map { |c| accept c }
+            statements << accept(o.primary_keys) if o.primary_keys
 
-          if supports_foreign_keys?
-            statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
-          end
+            if supports_foreign_keys_in_create?
+              statements.concat(o.foreign_keys.map { |to_table, options| foreign_key_in_create(o.name, to_table, options) })
+            end
 
-          create_sql << "(#{statements.join(', ')})" if statements.present?
+            create_sql << "(#{statements.join(', ')})" if statements.present?
 
-          unless o.temporary
-            @lob_tablespaces.each do |lob_column, tablespace|
-              create_sql << " LOB (#{quote_column_name(lob_column)}) STORE AS (TABLESPACE #{tablespace}) \n"
-            end if defined?(@lob_tablespaces)
-            create_sql << " ORGANIZATION #{o.organization}" if o.organization
-            if (tablespace = o.tablespace || default_tablespace_for(:table))
-              create_sql << " TABLESPACE #{tablespace}"
+            unless o.temporary
+              @lob_tablespaces.each do |lob_column, tablespace|
+                create_sql << " LOB (#{quote_column_name(lob_column)}) STORE AS (TABLESPACE #{tablespace}) \n"
+              end if defined?(@lob_tablespaces)
+              create_sql << " ORGANIZATION #{o.organization}" if o.organization
+              if (tablespace = o.tablespace || default_tablespace_for(:table))
+                create_sql << " TABLESPACE #{tablespace}"
+              end
             end
+            add_table_options!(create_sql, table_options(o))
+            create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+            create_sql
           end
-          add_table_options!(create_sql, table_options(o))
-          create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
-          create_sql
-        end
 
-        def default_tablespace_for(type)
-          (ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[type] ||
-           ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[native_database_types[type][:name]]) rescue nil
-        end
+          def default_tablespace_for(type)
+            (ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[type] ||
+             ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_tablespaces[native_database_types[type][:name]]) rescue nil
+          end
 
-        def add_column_options!(sql, options)
-          type = options[:type] || ((column = options[:column]) && column.type)
-          type = type && type.to_sym
-          # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
-          if options_include_default?(options)
-            if type == :text
-              sql << " DEFAULT #{@conn.quote(options[:default])}"
-            else
-              sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
+          def add_column_options!(sql, options)
+            type = options[:type] || ((column = options[:column]) && column.type)
+            type = type && type.to_sym
+            # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
+            if options_include_default?(options)
+              if type == :text
+                sql << " DEFAULT #{@conn.quote(options[:default])}"
+              else
+                sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}"
+              end
+            end
+            # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
+            if options[:null] == false
+              sql << " NOT NULL"
+            elsif options[:null] == true
+              sql << " NULL" unless type == :primary_key
+            end
+            # add AS expression for virtual columns
+            if options[:as].present?
+              sql << " AS (#{options[:as]})"
+            end
+            if options[:primary_key] == true
+              sql << " PRIMARY KEY"
             end
           end
-          # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
-          if options[:null] == false
-            sql << " NOT NULL"
-          elsif options[:null] == true
-            sql << " NULL" unless type == :primary_key
-          end
-          # add AS expression for virtual columns
-          if options[:as].present?
-            sql << " AS (#{options[:as]})"
-          end
-          if options[:primary_key] == true
-            sql << " PRIMARY KEY"
-          end
-        end
 
-        def action_sql(action, dependency)
-          if action == 'UPDATE'
-            raise ArgumentError, <<-MSG.strip_heredoc
+          def action_sql(action, dependency)
+            if action == "UPDATE"
+              raise ArgumentError, <<-MSG.strip_heredoc
               '#{action}' is not supported by Oracle
             MSG
-          end
-          case dependency
-          when :nullify then "ON #{action} SET NULL"
-          when :cascade  then "ON #{action} CASCADE"
-          else
-            raise ArgumentError, <<-MSG.strip_heredoc
+            end
+            case dependency
+            when :nullify then "ON #{action} SET NULL"
+            when :cascade  then "ON #{action} CASCADE"
+            else
+              raise ArgumentError, <<-MSG.strip_heredoc
               '#{dependency}' is not supported for #{action}
               Supported values are: :nullify, :cascade
             MSG
+            end
           end
-        end
       end
     end
   end

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

@@ -1,14 +1,32 @@
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
-      class ForeignKeyDefinition < ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
-        def name
-          if options[:name].length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
-            ActiveSupport::Deprecation.warn "Foreign key name #{options[:name]} is too long. It will not get shorten in later version of Oracle enhanced adapter"
-            'c'+Digest::SHA1.hexdigest(options[:name])[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
-          else
-            options[:name]
-          end
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          # This is a placeholder for future :auto_increment support
+          super
+        end
+
+        [
+          :raw
+        ].each do |column_type|
+          module_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{column_type}(*args, **options)
+              args.each { |name| column(name, :#{column_type}, options) }
+            end
+          CODE
+        end
+      end
+
+      class ReferenceDefinition < ActiveRecord::ConnectionAdapters::ReferenceDefinition # :nodoc:
+        def initialize(
+          name,
+          polymorphic: false,
+          index: true,
+          foreign_key: false,
+          type: :integer,
+          **options)
+          super
         end
       end
 
@@ -26,10 +44,9 @@ module ActiveRecord
         end
       end
 
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-      end
-
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
+
         attr_accessor :tablespace, :organization
         def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
           @tablespace = tablespace
@@ -37,51 +54,20 @@ module ActiveRecord
           super(name, temporary, options, as, comment: comment)
         end
 
-        def virtual(* args)
-          options = args.extract_options!
-          column_names = args
-          column_names.each { |name| column(name, :virtual, options) }
-        end
-
-        def column(name, type, options = {})
+        def new_column_definition(name, type, **options) # :nodoc:
           if type == :virtual
-            default = {:type => options[:type]}
-            if options[:as]
-              default[:as] = options[:as]
-            elsif options[:default]
-              warn "[DEPRECATION] virtual column `:default` option is deprecated.  Please use `:as` instead."
-              default[:as] = options[:default]
-            else
-              raise "No virtual column definition found."
-            end
-            options[:default] = default
+            raise "No virtual column definition found." unless options[:as]
+            type = options[:type]
           end
-          super(name, type, options)
-        end
-
-        private
-        def create_column_definition(name, type)
-          OracleEnhanced::ColumnDefinition.new name, type
+          super
         end
       end
 
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        def add_foreign_key(to_table, options)
-          @foreign_key_adds << OracleEnhanced::ForeignKeyDefinition.new(name, to_table, options)
-        end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table
-        def foreign_key(to_table, options = {})
-          ActiveSupport::Deprecation.warn "`foreign_key` option will be deprecated. Please use `references` option"
-          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
-          @base.add_foreign_key(@name, to_table, options)
-        end
-
-        def remove_foreign_key(options = {})
-          ActiveSupport::Deprecation.warn "`remove_foreign_key` option will be deprecated. Please use `remove_references` option"
-          @base.remove_foreign_key(@name, options)
-        end
+        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
       end
     end
   end