activerecord-oracle_enhanced-adapter 1.2.1 → 1.2.2

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -12,16 +12,42 @@ module ActiveRecord #: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
@@ -35,7 +61,7 @@ module ActiveRecord #:nodoc:
         end
       end
       
-      module InstanceMethods
+      module InstanceMethods #:nodoc:
         def self.included(base)
           base.instance_eval do
             if private_instance_methods.include?('create_without_callbacks') || private_instance_methods.include?(:create_without_callbacks)

data/lib/active_record/connection_adapters/oracle_enhanced_schema_definitions.rb

@@ -0,0 +1,164 @@
+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
+
+    module OracleEnhancedSchemaDefinitions #:nodoc:
+      def self.included(base)
+        base::TableDefinition.class_eval do
+          include OracleEnhancedTableDefinition
+        end
+        
+        base::Table.class_eval do
+          include OracleEnhancedTable
+        end
+      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
+        end
+      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 * ', ') if foreign_keys.present?
+        sql
+      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

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -0,0 +1,122 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedSchemaDumper #:nodoc:
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :tables, :oracle_enhanced
+          alias_method_chain :indexes, :oracle_enhanced
+        end
+      end
+
+      private
+      
+      def tables_with_oracle_enhanced(stream)
+        @connection.tables.sort.each do |tbl|
+          # add table prefix or suffix for schema_migrations
+          next if [ActiveRecord::Migrator.proper_table_name('schema_migrations'), ignore_tables].flatten.any? do |ignored|
+            case ignored
+            when String; tbl == ignored
+            when Regexp; tbl =~ ignored
+            else
+              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+            end
+          end
+          # change table name inspect method
+          tbl.extend TableInspect
+          table(tbl, stream)
+          # add primary key trigger if table has it
+          primary_key_trigger(tbl, stream)
+          # add foreign keys if table has them
+          foreign_keys(tbl, stream)
+        end
+        synonyms(stream)
+      end
+
+      def primary_key_trigger(table_name, stream)
+        if @connection.respond_to?(:has_primary_key_trigger?) && @connection.has_primary_key_trigger?(table_name)
+          pk, pk_seq = @connection.pk_and_sequence_for(table_name)
+          stream.print "  add_primary_key_trigger #{table_name.inspect}"
+          stream.print ", :primary_key => \"#{pk}\"" if pk != 'id'
+          stream.print "\n\n"
+        end
+      end
+
+      def foreign_keys(table_name, stream)
+        if (foreign_keys = @connection.foreign_keys(table_name)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
+            statement_parts << foreign_key.to_table.inspect
+            statement_parts << (':name => ' + foreign_key.options[:name].inspect)
+            
+            if foreign_key.options[:column] != "#{foreign_key.to_table.singularize}_id"
+              statement_parts << (':column => ' + foreign_key.options[:column].inspect)
+            end
+            if foreign_key.options[:primary_key] != 'id'
+              statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+            end
+            if foreign_key.options[:dependent].present?
+              statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
+            end
+
+            '  ' + statement_parts.join(', ')
+          end
+
+          stream.puts add_foreign_key_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+
+      def synonyms(stream)
+        syns = @connection.synonyms
+        syns.each do |syn|
+          table_name = syn.table_name
+          table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
+          table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
+          stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, :force => true"
+          stream.puts
+        end
+        stream.puts unless syns.empty?
+      end
+
+      def indexes_with_oracle_enhanced(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          add_index_statements = indexes.map do |index|
+            # use table.inspect as it will remove prefix and suffix
+            statment_parts = [ ('add_index ' + table.inspect) ]
+            statment_parts << index.columns.inspect
+            statment_parts << (':name => ' + index.name.inspect)
+            statment_parts << ':unique => true' if index.unique
+
+            '  ' + statment_parts.join(', ')
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+
+      # remove table name prefix and suffix when doing #inspect (which is used in tables method)
+      module TableInspect #:nodoc:
+        def inspect
+          remove_prefix_and_suffix(self)
+        end
+        
+        private
+        def remove_prefix_and_suffix(table_name)
+          if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix}(.*)#{ActiveRecord::Base.table_name_suffix}\Z/
+            "\"#{$1}\""
+          else
+            "\"#{table_name}\""
+          end
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDumper
+end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -0,0 +1,224 @@
+require 'digest/sha1'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedSchemaStatementsExt
+      def supports_foreign_keys? #:nodoc:
+        true
+      end
+
+      # Create primary key trigger (so that you can skip primary key value in INSERT statement).
+      # By default trigger name will be "table_name_pkt", you can override the name with 
+      # :trigger_name option (but it is not recommended to override it as then this trigger will
+      # not be detected by ActiveRecord model and it will still do prefetching of sequence value).
+      #
+      #   add_primary_key_trigger :users
+      #
+      # You can also create primary key trigger using +create_table+ with :primary_key_trigger
+      # option:
+      #
+      #   create_table :users, :primary_key_trigger => true do |t|
+      #     # ...
+      #   end
+      #
+      def add_primary_key_trigger(table_name, options)
+        # call the same private method that is used for create_table :primary_key_trigger => true
+        create_primary_key_trigger(table_name, options)
+      end
+
+      # Adds a new foreign key to the +from_table+, referencing the primary key of +to_table+
+      # (syntax and partial implementation taken from http://github.com/matthuhiggins/foreigner)
+      #
+      # The foreign key will be named after the from and to tables unless you pass
+      # <tt>:name</tt> as an option.
+      #
+      # === Examples
+      # ==== Creating a foreign key
+      #  add_foreign_key(:comments, :posts)
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_post_id_fk FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a named foreign key
+      #  add_foreign_key(:comments, :posts, :name => 'comments_belongs_to_posts')
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_belongs_to_posts FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a cascading foreign_key on a custom column
+      #  add_foreign_key(:people, :people, :column => 'best_friend_id', :dependent => :nullify)
+      # generates
+      #  ALTER TABLE people ADD CONSTRAINT
+      #     people_best_friend_id_fk FOREIGN KEY (best_friend_id) REFERENCES people (id)
+      #     ON DELETE SET NULL
+      # 
+      # === Supported options
+      # [:column]
+      #   Specify the column name on the from_table that references the to_table. By default this is guessed
+      #   to be the singular name of the to_table with "_id" suffixed. So a to_table of :posts will use "post_id"
+      #   as the default <tt>:column</tt>.
+      # [:primary_key]
+      #   Specify the column name on the to_table that is referenced by this foreign key. By default this is
+      #   assumed to be "id".
+      # [:name]
+      #   Specify the name of the foreign key constraint. This defaults to use from_table and foreign key column.
+      # [:dependent]
+      #   If set to <tt>:delete</tt>, the associated records in from_table are deleted when records in to_table table are deleted.
+      #   If set to <tt>:nullify</tt>, the foreign key column is set to +NULL+.
+      def add_foreign_key(from_table, to_table, options = {})
+        column = options[:column] || "#{to_table.to_s.singularize}_id"
+        constraint_name = foreign_key_constraint_name(from_table, column, options)
+        sql = "ALTER TABLE #{quote_table_name(from_table)} ADD CONSTRAINT #{quote_column_name(constraint_name)} "
+        sql << foreign_key_definition(to_table, options)
+        execute sql
+      end
+
+      def foreign_key_definition(to_table, options = {}) #:nodoc:
+        column = options[:column] || "#{to_table.to_s.singularize}_id"
+        primary_key = options[:primary_key] || "id"
+        sql = "FOREIGN KEY (#{quote_column_name(column)}) REFERENCES #{quote_table_name(to_table)}(#{primary_key})"
+        case options[:dependent]
+        when :nullify
+          sql << " ON DELETE SET NULL"
+        when :delete
+          sql << " ON DELETE CASCADE"
+        end
+        sql
+      end
+
+      # Remove the given foreign key from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_company_id_fk in the suppliers table.
+      #   remove_foreign_key :suppliers, :companies
+      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+      #   remove_foreign_key :accounts, :column => :branch_id
+      # ====== Remove the foreign key named party_foreign_key in the accounts table.
+      #   remove_foreign_key :accounts, :name => :party_foreign_key
+      def remove_foreign_key(from_table, options)
+        if Hash === options
+          constraint_name = foreign_key_constraint_name(from_table, options[:column], options)
+        else
+          constraint_name = foreign_key_constraint_name(from_table, "#{options.to_s.singularize}_id")
+        end
+        execute "ALTER TABLE #{quote_table_name(from_table)} DROP CONSTRAINT #{quote_column_name(constraint_name)}"
+      end
+
+      private
+
+      def foreign_key_constraint_name(table_name, column, options = {})
+        constraint_name = original_name = options[:name] || "#{table_name}_#{column}_fk"
+        return constraint_name if constraint_name.length <= OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+        # leave just first three letters from each word
+        constraint_name = constraint_name.split('_').map{|w| w[0,3]}.join('_')
+        # generate unique name using hash function
+        if constraint_name.length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+          constraint_name = 'c'+Digest::SHA1.hexdigest(original_name)[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
+        end
+        @logger.warn "#{adapter_name} shortened foreign key constraint name #{original_name} to #{constraint_name}" if @logger
+        constraint_name
+      end
+      
+
+      public
+
+      # get table foreign keys for schema dump
+      def foreign_keys(table_name) #:nodoc:
+        (owner, desc_table_name, db_link) = @connection.describe(table_name)
+
+        fk_info = select_all(<<-SQL, 'Foreign Keys')
+          SELECT r.table_name to_table
+                ,rc.column_name primary_key
+                ,cc.column_name
+                ,c.constraint_name name
+                ,c.delete_rule
+            FROM user_constraints#{db_link} c, user_cons_columns#{db_link} cc,
+                 user_constraints#{db_link} r, user_cons_columns#{db_link} rc
+           WHERE c.owner = '#{owner}'
+             AND c.table_name = '#{desc_table_name}'
+             AND c.constraint_type = 'R'
+             AND cc.owner = c.owner
+             AND cc.constraint_name = c.constraint_name
+             AND r.constraint_name = c.r_constraint_name
+             AND r.owner = c.owner
+             AND rc.owner = r.owner
+             AND rc.constraint_name = r.constraint_name
+             AND rc.position = cc.position
+        SQL
+
+        fk_info.map do |row|
+          options = {:column => oracle_downcase(row['column_name']), :name => oracle_downcase(row['name']),
+            :primary_key => oracle_downcase(row['primary_key'])}
+          case row['delete_rule']
+          when 'CASCADE'
+            options[:dependent] = :delete
+          when 'SET NULL'
+            options[:dependent] = :nullify
+          end
+          OracleEnhancedForeignKeyDefinition.new(table_name, oracle_downcase(row['to_table']), options)
+        end
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      def disable_referential_integrity(&block) #:nodoc:
+        sql_constraints = <<-SQL
+        SELECT constraint_name, owner, table_name
+          FROM user_constraints
+          WHERE constraint_type = 'R'
+          AND status = 'ENABLED'
+        SQL
+        old_constraints = select_all(sql_constraints)
+        begin
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} DISABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+          yield
+        ensure
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} ENABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+        end
+      end
+
+      # Add synonym to existing table or view or sequence. Can be used to create local synonym to
+      # remote table in other schema or in other database
+      # Examples:
+      #
+      #   add_synonym :posts, "blog.posts"
+      #   add_synonym :posts_seq, "blog.posts_seq"
+      #   add_synonym :employees, "hr.employees@dblink", :force => true
+      #
+      def add_synonym(name, table_name, options = {})
+        sql = "CREATE"
+        if options[:force] == true
+          sql << " OR REPLACE"
+        end
+        sql << " SYNONYM #{quote_table_name(name)} FOR #{quote_table_name(table_name)}"
+        execute sql
+      end
+
+      # Remove existing synonym to table or view or sequence
+      # Example:
+      #
+      #   remove_synonym :posts, "blog.posts"
+      #
+      def remove_synonym(name)
+        execute "DROP SYNONYM #{quote_table_name(name)}"
+      end
+
+      # get synonyms for schema dump
+      def synonyms #:nodoc:
+        select_all("SELECT synonym_name, table_owner, table_name, db_link FROM user_synonyms").collect do |row|
+          OracleEnhancedSynonymDefinition.new(oracle_downcase(row['synonym_name']),
+            oracle_downcase(row['table_owner']), oracle_downcase(row['table_name']), oracle_downcase(row['db_link']))
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaStatementsExt
+end