activerecord-oracle_enhanced-adapter-with-schema 0.0.1

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -0,0 +1,260 @@
+# define accessors before requiring ruby-plsql as these accessors are used in clob writing callback and should be
+# available also if ruby-plsql could not be loaded
+ActiveRecord::Base.class_eval do
+  if respond_to? :class_attribute
+    class_attribute :custom_create_method, :custom_update_method, :custom_delete_method
+  elsif respond_to? :class_inheritable_accessor
+    class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
+  end
+end
+
+require 'active_support'
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    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)
+          include_with_custom_methods
+          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)
+          include_with_custom_methods
+          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)
+          include_with_custom_methods
+          self.custom_delete_method = block
+        end
+
+        if ActiveRecord::VERSION::MAJOR < 3
+          def create_method_name_before_custom_methods #:nodoc:
+            if private_method_defined?(:create_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
+              :create_without_timestamps
+            elsif private_method_defined?(:create_without_callbacks)
+              :create_without_callbacks
+            else
+              :create
+            end
+          end
+
+          def update_method_name_before_custom_methods #:nodoc:
+            if private_method_defined?(:update_without_dirty)
+              :update_without_dirty
+            elsif private_method_defined?(:update_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
+              :update_without_timestamps
+            elsif private_method_defined?(:update_without_callbacks)
+              :update_without_callbacks
+            else
+              :update
+            end
+          end
+
+          def destroy_method_name_before_custom_methods #:nodoc:
+            if public_method_defined?(:destroy_without_callbacks)
+              :destroy_without_callbacks
+            else
+              :destroy
+            end
+          end
+        end
+
+        private
+
+        def include_with_custom_methods
+          unless included_modules.include? InstanceMethods
+            include InstanceMethods
+          end
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        def self.included(base)
+          # alias methods just for ActiveRecord 2.x
+          # for ActiveRecord 3.0 will just redefine create, update, delete methods which call super
+          if ActiveRecord::VERSION::MAJOR < 3
+            base.instance_eval do
+              alias_method :create_without_custom_method, create_method_name_before_custom_methods
+              alias_method create_method_name_before_custom_methods, :create_with_custom_method
+              alias_method :update_without_custom_method, update_method_name_before_custom_methods
+              alias_method update_method_name_before_custom_methods, :update_with_custom_method
+              alias_method :destroy_without_custom_method, destroy_method_name_before_custom_methods
+              alias_method destroy_method_name_before_custom_methods, :destroy_with_custom_method
+              private :create, :update
+              public :destroy
+            end
+          end
+        end
+
+        if ActiveRecord::VERSION::MAJOR >= 3
+          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_destroy_callbacks { destroy_using_custom_method }
+              end
+            else
+              super
+            end
+          end
+        end
+
+        private
+
+        # Creates a record with custom create method
+        # and returns its id.
+        if ActiveRecord::VERSION::MAJOR < 3
+          def create_with_custom_method
+            # check if class has custom create method
+            self.class.custom_create_method ? create_using_custom_method : create_without_custom_method
+          end
+        else # ActiveRecord 3.x
+          def create
+            # check if class has custom create method
+            if self.class.custom_create_method
+              set_timestamps_before_custom_create_method
+              # run before/after callbacks defined in model
+              _run_create_callbacks { create_using_custom_method }
+            else
+              super
+            end
+          end
+        end
+
+        def create_using_custom_method
+          self.class.connection.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.
+        if ActiveRecord::VERSION::MAJOR < 3
+          def update_with_custom_method(attribute_names = @attributes.keys)
+            # check if class has custom create method
+            self.class.custom_update_method ? update_using_custom_method(attribute_names) : update_without_custom_method(attribute_names)
+          end
+        else # ActiveRecord 3.x
+          def update(attribute_names = @attributes.keys)
+            # check if class has custom update method
+            if self.class.custom_update_method
+              set_timestamps_before_custom_update_method
+              # run before/after callbacks defined in model
+              _run_update_callbacks do
+                # 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.serialized_attributes.keys))
+                else
+                  update_using_custom_method(attribute_names)
+                end
+              end
+            else
+              super
+            end
+          end
+        end
+
+        def update_using_custom_method(attribute_names)
+          return 0 if attribute_names.empty?
+          self.class.connection.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).
+        if ActiveRecord::VERSION::MAJOR < 3
+          def destroy_with_custom_method
+            # check if class has custom delete method
+            self.class.custom_delete_method ? destroy_using_custom_method : destroy_without_custom_method
+          end
+        end
+
+        def destroy_using_custom_method
+          unless new_record? || @destroyed
+            self.class.connection.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
+
+        if ActiveRecord::VERSION::MAJOR >= 3
+          def set_timestamps_before_custom_create_method
+            if record_timestamps
+              current_time = current_time_from_proper_timezone
+
+              write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
+              write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
+
+              write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
+              write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
+            end
+          end
+
+          def set_timestamps_before_custom_update_method
+            if record_timestamps && (!partial_updates? || changed?)
+              current_time = current_time_from_proper_timezone
+
+              write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+              write_attribute('updated_on', current_time) if respond_to?(:updated_on)
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend ActiveRecord::ConnectionAdapters::OracleEnhancedProcedures::ClassMethods
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  # public alias to log method which could be used from other objects
+  alias_method :log_custom_method, :log
+  public :log_custom_method
+end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_definitions.rb

@@ -0,0 +1,227 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class OracleEnhancedForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+    end
+
+    class OracleEnhancedSynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+    end
+
+    class OracleEnhancedIndexDefinition < Struct.new(:table, :name, :unique, :type, :parameters, :statement_parameters,
+      :tablespace, :columns) #:nodoc:
+    end
+
+    module OracleEnhancedColumnDefinition
+       def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :to_sql, :virtual_columns
+          alias to_s :to_sql
+        end
+       end
+
+      def to_sql_with_virtual_columns
+        if type == :virtual
+          sql_type = base.type_to_sql(default[:type], limit, precision, scale) if default[:type]
+          "#{base.quote_column_name(name)} #{sql_type} AS (#{default[:as]})"
+        else
+          to_sql_without_virtual_columns
+        end
+      end
+
+      def lob?
+        ['CLOB', 'BLOB'].include?(sql_type)
+      end
+    end
+
+    module OracleEnhancedSchemaDefinitions #:nodoc:
+      def self.included(base)
+        base::TableDefinition.class_eval do
+          include OracleEnhancedTableDefinition
+        end
+
+        base::ColumnDefinition.class_eval do
+          include OracleEnhancedColumnDefinition
+        end
+        
+        # Available starting from ActiveRecord 2.1
+        base::Table.class_eval do
+          include OracleEnhancedTable
+        end if defined?(base::Table)
+      end
+    end
+  
+    module OracleEnhancedTableDefinition
+      class ForeignKey < Struct.new(:base, :to_table, :options) #:nodoc:
+        def to_sql
+          base.foreign_key_definition(to_table, options)
+        end
+        alias to_s :to_sql
+      end
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :references, :foreign_keys
+          alias_method_chain :to_sql, :foreign_keys
+
+          alias_method_chain :column, :virtual_columns
+        end
+      end
+
+      def raw(name, options={})
+        column(name, :raw, options)
+      end
+
+      def virtual(* args)
+        options = args.extract_options!
+        column_names = args
+        column_names.each { |name| column(name, :virtual, options) }
+      end
+
+      def column_with_virtual_columns(name, type, options = {})
+        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
+        end
+        column_without_virtual_columns(name, type, options)
+      end
+    
+      # Adds a :foreign_key option to TableDefinition.references.
+      # If :foreign_key is true, a foreign key constraint is added to the table.
+      # You can also specify a hash, which is passed as foreign key options.
+      # 
+      # ===== Examples
+      # ====== Add goat_id column and a foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => true)
+      # ====== Add goat_id column and a cascading foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => {:dependent => :delete})
+      # 
+      # Note: No foreign key is created if :polymorphic => true is used.
+      # Note: If no name is specified, the database driver creates one for you!
+      def references_with_foreign_keys(*args)
+        options = args.extract_options!
+        fk_options = options.delete(:foreign_key)
+
+        if fk_options && !options[:polymorphic]
+          fk_options = {} if fk_options == true
+          args.each { |to_table| foreign_key(to_table, fk_options) }
+        end
+
+        references_without_foreign_keys(*(args << options))
+      end
+  
+      # Defines a foreign key for the table. +to_table+ can be a single Symbol, or
+      # an Array of Symbols. See SchemaStatements#add_foreign_key
+      #
+      # ===== Examples
+      # ====== Creating a simple foreign key
+      #  t.foreign_key(:people)
+      # ====== Defining the column
+      #  t.foreign_key(:people, :column => :sender_id)
+      # ====== Creating a named foreign key
+      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
+      # ====== Defining the column of the +to_table+.
+      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
+      def foreign_key(to_table, options = {})
+        if @base.respond_to?(:supports_foreign_keys?) && @base.supports_foreign_keys?
+          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+          foreign_keys << ForeignKey.new(@base, to_table, options)
+        else
+          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
+        end
+      end
+    
+      def to_sql_with_foreign_keys #:nodoc:
+        sql = to_sql_without_foreign_keys
+        sql << ', ' << (foreign_keys * ', ') unless foreign_keys.blank?
+        sql
+      end
+
+      def lob_columns
+        columns.select(&:lob?)
+      end
+    
+      private
+        def foreign_keys
+          @foreign_keys ||= []
+        end
+    end
+
+    module OracleEnhancedTable
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :references, :foreign_keys
+        end
+      end
+
+      # Adds a new foreign key to the table. +to_table+ can be a single Symbol, or
+      # an Array of Symbols. See SchemaStatements#add_foreign_key
+      #
+      # ===== Examples
+      # ====== Creating a simple foreign key
+      #  t.foreign_key(:people)
+      # ====== Defining the column
+      #  t.foreign_key(:people, :column => :sender_id)
+      # ====== Creating a named foreign key
+      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
+      # ====== Defining the column of the +to_table+.
+      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
+      def foreign_key(to_table, options = {})
+        if @base.respond_to?(:supports_foreign_keys?) && @base.supports_foreign_keys?
+          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+          @base.add_foreign_key(@table_name, to_table, options)
+        else
+          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
+        end
+      end
+  
+      # Remove the given foreign key from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_company_id_fk in the suppliers table.
+      #   t.remove_foreign_key :companies
+      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+      #   remove_foreign_key :column => :branch_id
+      # ====== Remove the foreign key named party_foreign_key in the accounts table.
+      #   remove_index :name => :party_foreign_key
+      def remove_foreign_key(options = {})
+        @base.remove_foreign_key(@table_name, options)
+      end
+    
+      # Adds a :foreign_key option to TableDefinition.references.
+      # If :foreign_key is true, a foreign key constraint is added to the table.
+      # You can also specify a hash, which is passed as foreign key options.
+      # 
+      # ===== Examples
+      # ====== Add goat_id column and a foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => true)
+      # ====== Add goat_id column and a cascading foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => {:dependent => :delete})
+      # 
+      # Note: No foreign key is created if :polymorphic => true is used.
+      def references_with_foreign_keys(*args)
+        options = args.extract_options!
+        polymorphic = options[:polymorphic]
+        fk_options = options.delete(:foreign_key)
+
+        references_without_foreign_keys(*(args << options))
+        # references_without_foreign_keys adds {:type => :integer}
+        args.extract_options!
+        if fk_options && !polymorphic
+          fk_options = {} if fk_options == true
+          args.each { |to_table| foreign_key(to_table, fk_options) }
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDefinitions
+end