activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.0.beta1

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

@@ -5,16 +5,16 @@ module ActiveRecord
         def _type_cast(value)
           case value
           when ActiveModel::Type::Binary::Data
-            lob_value = value == '' ? ' ' : value
+            lob_value = value == "" ? " " : value
             bind_type = OCI8::BLOB
             ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
-            ora_value.size = 0 if value == ''
+            ora_value.size = 0 if value == ""
             ora_value
           when ActiveRecord::OracleEnhanced::Type::Text::Data
-            lob_value = value.to_s == '' ? ' ' : value.to_s
+            lob_value = value.to_s == "" ? " " : value.to_s
             bind_type = OCI8::CLOB
             ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
-            ora_value.size = 0 if value.to_s == ''
+            ora_value.size = 0 if value.to_s == ""
             ora_value
           else
             super

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,76 +76,47 @@ 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_#{ type_to_sql(column.type.to_sym).downcase rescue 'blob' }()"
           when ActiveRecord::OracleEnhanced::Type::Text::Data then
-            %Q{empty_#{ type_to_sql(column.type.to_sym).downcase rescue 'clob' }()}
+            "empty_#{ type_to_sql(column.type.to_sym).downcase rescue '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
@@ -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