activerecord-oracle_enhanced-adapter 8.1.0-java

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

@@ -0,0 +1,195 @@
+# 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_updates?
+              # 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, &block)
+        self.class.connection.send(:log, *args, &block)
+      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,186 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module Quoting
+        extend ActiveSupport::Concern
+        # QUOTING ==================================================
+        #
+        # see: abstract/quoting.rb
+        QUOTED_COLUMN_NAMES = Concurrent::Map.new # :nodoc:
+        QUOTED_TABLE_NAMES = Concurrent::Map.new # :nodoc:
+
+        module ClassMethods # :nodoc:
+          def column_name_matcher
+            /
+          \A
+          (
+            (?:
+              # "table_name"."column_name" | function(one or no argument)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+            )
+            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+          end
+
+          def column_name_with_order_matcher
+            /
+          \A
+          (
+            (?:
+              # "table_name"."column_name" | function(one or no argument)
+              ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+") | \w+\((?:|\g<2>)\))
+            )
+            (?:\s+ASC|\s+DESC)?
+            (?:\s+NULLS\s+(?:FIRST|LAST))?
+          )
+          (?:\s*,\s*\g<1>)*
+          \z
+        /ix
+          end
+
+          def quote_column_name(name) # :nodoc:
+            name = name.to_s
+            QUOTED_COLUMN_NAMES[name] ||= if /\A[a-z][a-z_0-9$#]*\Z/.match?(name)
+              "\"#{name.upcase}\""
+            else
+              # remove double quotes which cannot be used inside quoted identifier
+              "\"#{name.delete('"')}\""
+            end
+          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(".")
+          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
+
+        # 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 (#).
+        # Oracle strongly discourages you from using $ and # in nonquoted identifiers.
+        NONQUOTED_OBJECT_NAME = /[[:alpha:]][\w$#]{0,29}/
+        VALID_TABLE_NAME = /\A(?:#{NONQUOTED_OBJECT_NAME}\.)?#{NONQUOTED_OBJECT_NAME}?\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_string(s) # :nodoc:
+          s.gsub(/'/, "''")
+        end
+
+        def quote(value) # :nodoc:
+          case value
+          when Type::OracleEnhanced::CharacterString::Data then
+            "'#{quote_string(value.to_s)}'"
+          when Type::OracleEnhanced::NationalCharacterString::Data then
+            +"N" << "'#{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"
+        end
+
+        def unquoted_true # :nodoc:
+          return "Y" if emulate_booleans_from_strings
+          "1"
+        end
+
+        def quoted_false # :nodoc:
+          return "'N'" if emulate_booleans_from_strings
+          "0"
+        end
+
+        def unquoted_false # :nodoc:
+          return "N" if emulate_booleans_from_strings
+          "0"
+        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.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
+          when Type::OracleEnhanced::CharacterString::Data
+            value
+          else
+            super
+          end
+        end
+
+        private
+          def oracle_downcase(column_name)
+            return nil if column_name.nil?
+            /[a-z]/.match?(column_name) ? column_name : column_name.downcase
+          end
+      end
+    end
+  end
+end
+
+# if MRI or YARV or TruffleRuby
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby"
+  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 < 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
+            o.cast_type = lookup_cast_type(sql_type)
+            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
+
+            if use_foreign_keys?
+              statements.concat(o.foreign_keys.map { |fk| accept fk })
+            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, 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
+                '#{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
+                '#{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

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          # This is a placeholder for future :auto_increment support
+          super
+        end
+
+        [
+          :raw,
+          :timestamptz,
+          :timestampltz,
+          :ntext
+        ].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
+
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name) # :nodoc:
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_accessor :parameters, :statement_parameters, :tablespace
+
+        def initialize(table, name, unique, columns, orders, type, parameters, statement_parameters, tablespace)
+          @parameters = parameters
+          @statement_parameters = statement_parameters
+          @tablespace = tablespace
+          super(table, name, unique, columns, orders: orders, type: type)
+        end
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include OracleEnhanced::ColumnMethods
+
+        attr_accessor :tablespace, :organization
+        def initialize(
+          conn,
+          name,
+          temporary: false,
+          options: nil,
+          as: nil,
+          tablespace: nil,
+          organization: nil,
+          comment: nil,
+          **
+        )
+          @tablespace = tablespace
+          @organization = organization
+          super(conn, name, temporary: temporary, options: options, as: as, comment: comment)
+        end
+
+        def new_column_definition(name, type, **options) # :nodoc:
+          if type == :virtual
+            raise "No virtual column definition found." unless options[:as]
+            type = options[:type]
+          end
+          super
+        end
+
+        def references(*args, **options)
+          super(*args, type: :integer, **options)
+        end
+        alias :belongs_to :references
+
+        private
+          def valid_column_definition_options
+            super + [ :as, :sequence_name, :sequence_start_value, :type ]
+          end
+      end
+
+      class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include OracleEnhanced::ColumnMethods
+      end
+    end
+  end
+end