activerecord-oracle_enhanced-adapter 1.7.3 → 1.8.0

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

@@ -1,4 +1,4 @@
-require 'digest/sha1'
+require "digest/sha1"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -80,11 +80,12 @@ module ActiveRecord
           if supports_comments? && !supports_comments_in_create?
             change_table_comment(table_name, comment) if comment
             td.columns.each do |column|
-              change_column_comment(table_name, column.name, column.comment) if column.comment
+              change_column_comment(table_name, column.name, column.comment) if column.comment.present?
             end
           end
-          td.indexes.each { |c,o| add_index table_name, c, o }
+          td.indexes.each { |c, o| add_index table_name, c, o }
 
+          rebuild_primary_key_index_to_default_tablespace(table_name, options)
         end
 
         def create_table_definition(*args)
@@ -112,22 +113,30 @@ module ActiveRecord
           self.all_schema_indexes = nil
         end
 
-        def dump_schema_information #:nodoc:
-          super
-        end
-
-        def initialize_schema_migrations_table
-          super
-        end
+        def insert_versions_sql(versions) # :nodoc:
+          sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
 
-        def update_table_definition(table_name, base) #:nodoc:
-          OracleEnhanced::Table.new(table_name, base)
+          if supports_multi_insert?
+            versions.inject("INSERT ALL\n") { |sql, version|
+              sql << "INTO #{sm_table} (version) VALUES (#{quote(version)})\n"
+            } << "SELECT * FROM DUAL\n"
+          else
+            if versions.is_a?(Array)
+              # called from ActiveRecord::Base.connection#dump_schema_information
+              versions.map { |version|
+                "INSERT INTO #{sm_table} (version) VALUES (#{quote(version)})"
+              }.join("\n\n/\n\n")
+            else
+              # called from ActiveRecord::Base.connection#assume_migrated_upto_version
+              "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)})"
+            end
+          end
         end
 
         def add_index(table_name, column_name, options = {}) #:nodoc:
           index_name, index_type, quoted_column_names, tablespace, index_options = add_index_options(table_name, column_name, options)
           execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{index_options}"
-          if index_type == 'UNIQUE'
+          if index_type == "UNIQUE"
             unless quoted_column_names =~ /\(.*\)/
               execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
             end
@@ -152,29 +161,18 @@ module ActiveRecord
           if index_name.to_s.length > max_index_length
             raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
           end
-          if index_name_exists?(table_name, index_name, false)
+          if table_exists?(table_name) && index_name_exists?(table_name, index_name)
             raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
           end
 
           quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
-           [index_name, index_type, quoted_column_names, tablespace, index_options]
+          [index_name, index_type, quoted_column_names, tablespace, index_options]
         end
 
         # Remove the given index from the table.
         # Gives warning if index does not exist
         def remove_index(table_name, options = {}) #:nodoc:
           index_name = index_name_for_remove(table_name, options)
-          unless index_name_exists?(table_name, index_name, true)
-            # sometimes options can be String or Array with column names
-            options = {} unless options.is_a?(Hash)
-            if options.has_key? :name
-              options_without_column = options.dup
-              options_without_column.delete :column
-              index_name_without_column = index_name(table_name, options_without_column)
-              return index_name_without_column if index_name_exists?(table_name, index_name_without_column, false)
-            end
-            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
-          end
           #TODO: It should execute only when index_type == "UNIQUE"
           execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
           execute "DROP INDEX #{quote_column_name(index_name)}"
@@ -195,11 +193,11 @@ module ActiveRecord
 
           # leave just first three letters from each word
           if shortened_name.length > identifier_max_length
-            shortened_name = shortened_name.split('_').map{|w| w[0,3]}.join('_')
+            shortened_name = shortened_name.split("_").map { |w| w[0, 3] }.join("_")
           end
           # generate unique name using hash function
           if shortened_name.length > identifier_max_length
-            shortened_name = 'i'+Digest::SHA1.hexdigest(default_name)[0,identifier_max_length-1]
+            shortened_name = "i" + Digest::SHA1.hexdigest(default_name)[0, identifier_max_length - 1]
           end
           @logger.warn "#{adapter_name} shortened default index name #{default_name} to #{shortened_name}" if @logger
           shortened_name
@@ -211,7 +209,12 @@ module ActiveRecord
         # as there's no way to determine the correct answer in that case.
         #
         # Will always query database and not index cache.
-        def index_name_exists?(table_name, index_name, default)
+        def index_name_exists?(table_name, index_name, default = nil)
+          unless default.nil?
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Passing default to #index_name_exists? is deprecated without replacement.
+            MSG
+          end
           (owner, table_name, db_link) = @connection.describe(table_name)
           result = select_value(<<-SQL)
             SELECT 1 FROM all_indexes#{db_link} i
@@ -224,31 +227,23 @@ module ActiveRecord
         end
 
         def rename_index(table_name, old_name, new_name) #:nodoc:
-          unless index_name_exists?(table_name, old_name, true)
-            raise ArgumentError, "Index name '#{old_name}' on table '#{table_name}' does not exist"
-          end
-          if new_name.length > allowed_index_name_length
-            raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{allowed_index_name_length} characters"
-          end
+          validate_index_length!(table_name, new_name)
           execute "ALTER INDEX #{quote_column_name(old_name)} rename to #{quote_column_name(new_name)}"
         ensure
           self.all_schema_indexes = nil
         end
 
+        def add_reference(table_name, *args)
+          ActiveRecord::ConnectionAdapters::OracleEnhanced::ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
+        end
+
         def add_column(table_name, column_name, type, options = {}) #:nodoc:
-          if type.to_sym == :virtual
-            type = options[:type]
-          end
           type = aliased_types(type.to_s, type)
-          add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} "
-          add_column_sql << type_to_sql(type, options[:limit], options[:precision], options[:scale]) if type
-
-          add_column_options!(add_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
-
-          add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name) if type
-
-          execute(add_column_sql)
-
+          at = create_alter_table table_name
+          at.add_column(column_name, type, options)
+          add_column_sql = schema_creation.accept at
+          add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name)
+          execute add_column_sql
           create_sequence_and_trigger(table_name, options) if type && type.to_sym == :primary_key
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         ensure
@@ -273,7 +268,7 @@ module ActiveRecord
             execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
           end
 
-          change_column table_name, column_name, column.sql_type, :null => null
+          change_column table_name, column_name, column.sql_type, null: null
         end
 
         def change_column(table_name, column_name, type, options = {}) #:nodoc:
@@ -287,14 +282,15 @@ module ActiveRecord
           if type.to_sym == :virtual
             type = options[:type]
           end
-          change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} "
-          change_column_sql << "#{type_to_sql(type, options[:limit], options[:precision], options[:scale])}" if type
-
-          add_column_options!(change_column_sql, options.merge(:type=>type, :column_name=>column_name, :table_name=>table_name))
-
-          change_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name]) if type
 
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column.name, type, options)
+          change_column_stmt = schema_creation.accept cd
+          change_column_stmt << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name]) if type
+          change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{change_column_stmt}"
           execute(change_column_sql)
+
+          change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         ensure
           clear_table_columns_cache(table_name)
         end
@@ -345,9 +341,9 @@ module ActiveRecord
         end
 
         # Maps logical Rails types to Oracle-specific data types.
-        def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) #:nodoc:
           # Ignore options for :text and :binary columns
-          return super(type, nil, nil, nil) if ['text', 'binary'].include?(type.to_s)
+          return super(type) if ["text", "binary"].include?(type.to_s)
 
           super
         end
@@ -361,28 +357,11 @@ module ActiveRecord
           SQL
         end
 
-        def add_foreign_key(from_table, to_table, options = {})
-          if options[:dependent]
-            ActiveSupport::Deprecation.warn "`:dependent` option will be deprecated. Please use `:on_delete` option"
-          end
-          case options[:dependent]  
-          when :delete then options[:on_delete] = :cascade
-          when :nullify then options[:on_delete] = :nullify
-          else
-          end
-
-          super
-        end
-
-        def remove_foreign_key(from_table, options_or_to_table = {})
-          super
-        end
-
         # 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')
+          fk_info = select_all(<<-SQL, "Foreign Keys")
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
@@ -391,7 +370,7 @@ module ActiveRecord
               FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc,
                    all_constraints#{db_link} r, all_cons_columns#{db_link} rc
              WHERE c.owner = '#{owner}'
-               AND c.table_name = '#{desc_table_name}'
+               AND c.table_name = q'[#{desc_table_name}]'
                AND c.constraint_type = 'R'
                AND cc.owner = c.owner
                AND cc.constraint_name = c.constraint_name
@@ -405,19 +384,19 @@ module ActiveRecord
 
           fk_info.map do |row|
             options = {
-              column: oracle_downcase(row['column_name']),
-              name: oracle_downcase(row['name']),
-              primary_key: oracle_downcase(row['references_column'])
+              column: oracle_downcase(row["column_name"]),
+              name: oracle_downcase(row["name"]),
+              primary_key: oracle_downcase(row["references_column"])
             }
-            options[:on_delete] = extract_foreign_key_action(row['delete_rule'])
-            OracleEnhanced::ForeignKeyDefinition.new(oracle_downcase(table_name), oracle_downcase(row['to_table']), options)
+            options[:on_delete] = extract_foreign_key_action(row["delete_rule"])
+            ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(oracle_downcase(table_name), oracle_downcase(row["to_table"]), options)
           end
         end
 
         def extract_foreign_key_action(specifier) # :nodoc:
           case specifier
-          when 'CASCADE'; :cascade
-          when 'SET NULL'; :nullify
+          when "CASCADE"; :cascade
+          when "SET NULL"; :nullify
           end
         end
 
@@ -434,59 +413,62 @@ module ActiveRecord
           old_constraints = select_all(sql_constraints)
           begin
             old_constraints.each do |constraint|
-              execute "ALTER TABLE #{constraint["table_name"]} DISABLE CONSTRAINT #{constraint["constraint_name"]}"
+              execute "ALTER TABLE #{quote_table_name(constraint["table_name"])} DISABLE CONSTRAINT #{quote_table_name(constraint["constraint_name"])}"
             end
             yield
           ensure
             old_constraints.each do |constraint|
-              execute "ALTER TABLE #{constraint["table_name"]} ENABLE CONSTRAINT #{constraint["constraint_name"]}"
+              execute "ALTER TABLE #{quote_table_name(constraint["table_name"])} ENABLE CONSTRAINT #{quote_table_name(constraint["constraint_name"])}"
             end
           end
         end
 
-        private
-
         def create_alter_table(name)
-          OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
-        end 
-
-        def tablespace_for(obj_type, tablespace_option, table_name=nil, column_name=nil)
-          tablespace_sql = ''
-          if tablespace = (tablespace_option || default_tablespace_for(obj_type))
-            tablespace_sql << if [:blob, :clob].include?(obj_type.to_sym)
-             " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
-            else
-             " TABLESPACE #{tablespace}"
-            end
-          end
-          tablespace_sql
+          ActiveRecord::ConnectionAdapters::OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
         end
 
-        def default_tablespace_for(type)
-          (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+        def update_table_definition(table_name, base)
+          ActiveRecord::ConnectionAdapters::OracleEnhanced::Table.new(table_name, base)
         end
 
+        private
 
-        def column_for(table_name, column_name)
-          unless column = columns(table_name).find { |c| c.name == column_name.to_s }
-            raise "No such column: #{table_name}.#{column_name}"
+          def tablespace_for(obj_type, tablespace_option, table_name = nil, column_name = nil)
+            tablespace_sql = ""
+            if tablespace = (tablespace_option || default_tablespace_for(obj_type))
+              if [:blob, :clob].include?(obj_type.to_sym)
+                tablespace_sql << " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
+              else
+                tablespace_sql << " TABLESPACE #{tablespace}"
+              end
+            end
+            tablespace_sql
           end
-          column
-        end
 
-        def create_sequence_and_trigger(table_name, options)
-          seq_name = options[:sequence_name] || default_sequence_name(table_name)
-          seq_start_value = options[:sequence_start_value] || default_sequence_start_value
-          execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
+          def default_tablespace_for(type)
+            (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+          end
 
-          create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
-        end
+          def column_for(table_name, column_name)
+            unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+              raise "No such column: #{table_name}.#{column_name}"
+            end
+            column
+          end
 
-        def create_primary_key_trigger(table_name, options)
-          seq_name = options[:sequence_name] || default_sequence_name(table_name)
-          trigger_name = options[:trigger_name] || default_trigger_name(table_name)
-          primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
-          execute compress_lines(<<-SQL)
+          def create_sequence_and_trigger(table_name, options)
+            seq_name = options[:sequence_name] || default_sequence_name(table_name)
+            seq_start_value = options[:sequence_start_value] || default_sequence_start_value
+            execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
+
+            create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
+          end
+
+          def create_primary_key_trigger(table_name, options)
+            seq_name = options[:sequence_name] || default_sequence_name(table_name)
+            trigger_name = options[:trigger_name] || default_trigger_name(table_name)
+            primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
+            execute compress_lines(<<-SQL)
             CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
             BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
             BEGIN
@@ -497,13 +479,28 @@ module ActiveRecord
               END IF;
             END;
           SQL
-        end
+          end
 
-        def default_trigger_name(table_name)
-          # truncate table name if necessary to fit in max length of identifier
-          "#{table_name.to_s[0,table_name_length-4]}_pkt"
-        end
+          def default_trigger_name(table_name)
+            # truncate table name if necessary to fit in max length of identifier
+            "#{table_name.to_s[0, table_name_length - 4]}_pkt"
+          end
+
+          def rebuild_primary_key_index_to_default_tablespace(table_name, options)
+            tablespace = default_tablespace_for(:index)
 
+            return unless tablespace
+
+            index_name = Base.connection.select_value(
+              "SELECT index_name FROM all_constraints
+                  WHERE table_name = #{quote(table_name.upcase)}
+                  AND constraint_type = 'P'
+                  AND owner = SYS_CONTEXT('userenv', 'current_schema')")
+
+            return unless index_name
+
+            execute("ALTER INDEX #{quote_column_name(index_name)} REBUILD TABLESPACE #{tablespace}")
+          end
       end
     end
   end

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

@@ -16,7 +16,7 @@ module ActiveRecord
         #     # ...
         #   end
         #
-        def add_primary_key_trigger(table_name, options={})
+        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
@@ -50,11 +50,10 @@ module ActiveRecord
         # get synonyms for schema dump
         def synonyms #:nodoc:
           select_all("SELECT synonym_name, table_owner, table_name, db_link FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'session_user')").collect do |row|
-            OracleEnhanced::SynonymDefinition.new(oracle_downcase(row['synonym_name']),
-              oracle_downcase(row['table_owner']), oracle_downcase(row['table_name']), oracle_downcase(row['db_link']))
+            OracleEnhanced::SynonymDefinition.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