activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module OCIQuoting
+        def _type_cast(value)
+          case value
+          when ActiveModel::Type::Binary::Data
+            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
+          when Type::OracleEnhanced::Text::Data
+            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
+          when Type::OracleEnhanced::NationalCharacterText::Data
+            lob_value = value.to_s == "" ? " " : value.to_s
+            bind_type = OCI8::NCLOB
+            ora_value = bind_type.new(@connection.raw_oci_connection, lob_value)
+            ora_value.size = 0 if value.to_s == ""
+            ora_value
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        prepend OCIQuoting
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "active_support"
+
+module ActiveRecord #:nodoc:
+  # Custom create, update, delete methods functionality.
+  #
+  # Example:
+  #
+  #   class Employee < ActiveRecord::Base
+  #     include ActiveRecord::OracleEnhancedProcedures
+  #
+  #     set_create_method do
+  #       plsql.employees_pkg.create_employee(
+  #         :p_first_name => first_name,
+  #         :p_last_name => last_name,
+  #         :p_employee_id => nil
+  #       )[:p_employee_id]
+  #     end
+  #
+  #     set_update_method do
+  #       plsql.employees_pkg.update_employee(
+  #         :p_employee_id => id,
+  #         :p_first_name => first_name,
+  #         :p_last_name => last_name
+  #       )
+  #     end
+  #
+  #     set_delete_method do
+  #       plsql.employees_pkg.delete_employee(
+  #         :p_employee_id => id
+  #       )
+  #     end
+  #   end
+  #
+  module OracleEnhancedProcedures #:nodoc:
+    module ClassMethods
+      # Specify custom create method which should be used instead of Rails generated INSERT statement.
+      # Provided block should return ID of new record.
+      # Example:
+      #   set_create_method do
+      #     plsql.employees_pkg.create_employee(
+      #       :p_first_name => first_name,
+      #       :p_last_name => last_name,
+      #       :p_employee_id => nil
+      #     )[:p_employee_id]
+      #   end
+      def set_create_method(&block)
+        self.custom_create_method = block
+      end
+
+      # Specify custom update method which should be used instead of Rails generated UPDATE statement.
+      # Example:
+      #   set_update_method do
+      #     plsql.employees_pkg.update_employee(
+      #       :p_employee_id => id,
+      #       :p_first_name => first_name,
+      #       :p_last_name => last_name
+      #     )
+      #   end
+      def set_update_method(&block)
+        self.custom_update_method = block
+      end
+
+      # Specify custom delete method which should be used instead of Rails generated DELETE statement.
+      # Example:
+      #   set_delete_method do
+      #     plsql.employees_pkg.delete_employee(
+      #       :p_employee_id => id
+      #     )
+      #   end
+      def set_delete_method(&block)
+        self.custom_delete_method = block
+      end
+    end
+
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        class_attribute :custom_create_method
+        class_attribute :custom_update_method
+        class_attribute :custom_delete_method
+      end
+    end
+
+    def destroy #:nodoc:
+      # check if class has custom delete method
+      if self.class.custom_delete_method
+        # wrap destroy in transaction
+        with_transaction_returning_status do
+          # run before/after callbacks defined in model
+          run_callbacks(:destroy) { destroy_using_custom_method }
+        end
+      else
+        super
+      end
+    end
+
+    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_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
+        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)
+        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 will_save_change_to_attribute?(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
+        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)
+        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)
+          end
+        end
+
+        @destroyed = true
+        freeze
+      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)
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        # QUOTING ==================================================
+        #
+        # see: abstract/quoting.rb
+
+        def quote_column_name(name) #:nodoc:
+          name = name.to_s
+          @quoted_column_names[name] ||= begin
+            # if only valid lowercase column characters in name
+            if name =~ /\A[a-z][a-z_0-9\$#]*\Z/
+              "\"#{name.upcase}\""
+            else
+              # remove double quotes which cannot be used inside quoted identifier
+              "\"#{name.gsub('"', '')}\""
+            end
+          end
+        end
+
+        # This method is used in add_index to identify either column name (which is quoted)
+        # or function based index (in which case function expression is not quoted)
+        def quote_column_name_or_expression(name) #:nodoc:
+          name = name.to_s
+          case name
+          # if only valid lowercase column characters in name
+          when /^[a-z][a-z_0-9\$#]*$/
+            "\"#{name.upcase}\""
+          when /^[a-z][a-z_0-9\$#\-]*$/i
+            "\"#{name}\""
+          # if other characters present then assume that it is expression
+          # which should not be quoted
+          else
+            name
+          end
+        end
+
+        # Used only for quoting database links as the naming rules for links
+        # differ from the rules for column names. Specifically, link names may
+        # include periods.
+        def quote_database_link(name)
+          case name
+          when NONQUOTED_DATABASE_LINK
+            %Q("#{name.upcase}")
+          else
+            name
+          end
+        end
+
+        # Names must be from 1 to 30 bytes long with these exceptions:
+        # * Names of databases are limited to 8 bytes.
+        # * Names of database links can be as long as 128 bytes.
+        #
+        # Nonquoted identifiers cannot be Oracle Database reserved words
+        #
+        # Nonquoted identifiers must begin with an alphabetic character from
+        # your database character set
+        #
+        # Nonquoted identifiers can contain only alphanumeric characters from
+        # your database character set and the underscore (_), dollar sign ($),
+        # and pound sign (#). Database links can also contain periods (.) and
+        # "at" signs (@). Oracle strongly discourages you from using $ and # in
+        # nonquoted identifiers.
+        NONQUOTED_OBJECT_NAME   = /[[:alpha:]][\w$#]{0,29}/
+        NONQUOTED_DATABASE_LINK = /[[:alpha:]][\w$#\.@]{0,127}/
+        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}(?:@#{NONQUOTED_DATABASE_LINK})?\Z/
+
+        # unescaped table name should start with letter and
+        # contain letters, digits, _, $ or #
+        # can be prefixed with schema name
+        # CamelCase table names should be quoted
+        def self.valid_table_name?(name) #:nodoc:
+          object_name = name.to_s
+          !!(object_name =~ VALID_TABLE_NAME && !mixed_case?(object_name))
+        end
+
+        def self.mixed_case?(name)
+          object_name = name.include?(".") ? name.split(".").second : name
+          !!(object_name =~ /[A-Z]/ && object_name =~ /[a-z]/)
+        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("@")
+        end
+
+        def quote_string(s) #:nodoc:
+          s.gsub(/'/, "''")
+        end
+
+        def _quote(value) #:nodoc:
+          case value
+          when Type::OracleEnhanced::NationalCharacterString::Data then
+            "N".dup << "'#{quote_string(value.to_s)}'"
+          when ActiveModel::Type::Binary::Data then
+            "empty_blob()"
+          when Type::OracleEnhanced::Text::Data then
+            "empty_clob()"
+          when Type::OracleEnhanced::NationalCharacterText::Data then
+            "empty_nclob()"
+          else
+            super
+          end
+        end
+
+        def quoted_true #:nodoc:
+          return "'Y'" if emulate_booleans_from_strings
+          "1".freeze
+        end
+
+        def unquoted_true #:nodoc:
+          return "Y" if emulate_booleans_from_strings
+          "1".freeze
+        end
+
+        def quoted_false #:nodoc:
+          return "'N'" if emulate_booleans_from_strings
+          "0".freeze
+        end
+
+        def unquoted_false #:nodoc:
+          return "N" if emulate_booleans_from_strings
+          "0".freeze
+        end
+
+        def _type_cast(value)
+          case value
+          when Type::OracleEnhanced::TimestampTz::Data, Type::OracleEnhanced::TimestampLtz::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
+            else
+              value
+            end
+          when Type::OracleEnhanced::NationalCharacterString::Data
+            value.to_s
+          else
+            super
+          end
+        end
+
+        private
+
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+            column_name =~ /[a-z]/ ? column_name : column_name.downcase
+          end
+      end
+    end
+  end
+end
+
+# if MRI or YARV
+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"
+else
+  raise "Unsupported Ruby engine #{RUBY_ENGINE}"
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      class SchemaCreation < AbstractAdapter::SchemaCreation
+        private
+
+          def visit_ColumnDefinition(o)
+            if [:blob, :clob, :nclob].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
+
+          def visit_TableDefinition(o)
+            create_sql = "CREATE#{' GLOBAL TEMPORARY' if o.temporary} TABLE #{quote_table_name(o.name)} ".dup
+            statements = o.columns.map { |c| accept c }
+            statements << accept(o.primary_keys) if o.primary_keys
+
+            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?
+
+            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 #{to_sql(o.as)}" if o.as
+            create_sql
+          end
+
+          def default_tablespace_for(type)
+            OracleEnhancedAdapter.default_tablespaces[type]
+          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/NCLOB columns, which would otherwise get "quoted" incorrectly
+            if options_include_default?(options)
+              if type == :text
+                sql << " DEFAULT #{@conn.quote(options[:default])}"
+              elsif type == :ntext
+                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
+
+          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
+              '#{dependency}' is not supported for #{action}
+              Supported values are: :nullify, :cascade
+            MSG
+            end
+          end
+      end
+    end
+  end
+end