activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.0.beta1

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,10 +80,10 @@ 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
@@ -113,10 +113,6 @@ module ActiveRecord
           self.all_schema_indexes = nil
         end
 
-        def dump_schema_information #:nodoc:
-          super
-        end
-
         def insert_versions_sql(versions) # :nodoc:
           sm_table = quote_table_name(ActiveRecord::Migrator.schema_migrations_table_name)
 
@@ -137,18 +133,10 @@ module ActiveRecord
           end
         end
 
-        def initialize_schema_migrations_table
-          super
-        end
-
-        def update_table_definition(table_name, base) #:nodoc:
-          OracleEnhanced::Table.new(table_name, base)
-        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
@@ -173,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)}"
@@ -216,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
@@ -232,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
@@ -245,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
@@ -294,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:
@@ -308,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
@@ -366,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
@@ -382,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
@@ -412,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
@@ -426,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
 
@@ -465,48 +423,52 @@ module ActiveRecord
           end
         end
 
-        private
-
         def create_alter_table(name)
-          OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
+          ActiveRecord::ConnectionAdapters::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}"
+        def update_table_definition(table_name, base)
+          ActiveRecord::ConnectionAdapters::OracleEnhanced::Table.new(table_name, base)
+        end
+
+        private
+
+          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
-          tablespace_sql
-        end
 
-        def default_tablespace_for(type)
-          (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
-        end
+          def default_tablespace_for(type)
+            (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+          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}"
+          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
-          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 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
+            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)
+          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
@@ -517,28 +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)
+          def rebuild_primary_key_index_to_default_tablespace(table_name, options)
+            tablespace = default_tablespace_for(:index)
 
-          return unless tablespace
+            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')")
+            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
+            return unless index_name
 
-          execute("ALTER INDEX #{quote_column_name(index_name)} REBUILD TABLESPACE #{tablespace}")
-        end
+            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,8 +50,8 @@ 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

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

@@ -15,15 +15,15 @@ module ActiveRecord #:nodoc:
                     ORDER BY 1").each do |table_name|
           virtual_columns = virtual_columns_for(table_name)
           ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
-          cols = select_all(%Q{
+          cols = select_all("
             SELECT column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
             FROM all_tab_columns
             WHERE table_name = '#{table_name}'
             AND owner = SYS_CONTEXT('userenv', 'session_user')
             ORDER BY column_id
-          }).map do |row|
-            if(v = virtual_columns.find {|col| col['column_name'] == row['column_name']})
-              structure_dump_virtual_column(row, v['data_default'])
+          ").map do |row|
+            if (v = virtual_columns.find { |col| col["column_name"] == row["column_name"] })
+              structure_dump_virtual_column(row, v["data_default"])
             else
               structure_dump_column(row)
             end
@@ -43,35 +43,35 @@ module ActiveRecord #:nodoc:
 
       def structure_dump_column(column) #:nodoc:
         col = "\"#{column['column_name']}\" #{column['data_type']}"
-        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+        if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
           col << "(#{column['data_precision'].to_i}"
-          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
-          col << ')'
-        elsif column['data_type'].include?('CHAR') || column['data_type'] == 'RAW'
-          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
-          col <<  "(#{length})"
+          col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
+          col << ")"
+        elsif column["data_type"].include?("CHAR") || column["data_type"] == "RAW"
+          length = column["char_used"] == "C" ? column["char_length"].to_i : column["data_length"].to_i
+          col << "(#{length})"
         end
-        col << " DEFAULT #{column['data_default']}" if !column['data_default'].nil?
-        col << ' NOT NULL' if column['nullable'] == 'N'
+        col << " DEFAULT #{column['data_default']}" if !column["data_default"].nil?
+        col << " NOT NULL" if column["nullable"] == "N"
         col
       end
 
       def structure_dump_virtual_column(column, data_default) #:nodoc:
-        data_default = data_default.gsub(/"/, '')
+        data_default = data_default.gsub(/"/, "")
         col = "\"#{column['column_name']}\" #{column['data_type']}"
-        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+        if (column["data_type"] == "NUMBER") && !column["data_precision"].nil?
           col << "(#{column['data_precision'].to_i}"
-          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
-          col << ')'
-        elsif column['data_type'].include?('CHAR') || column['data_type'] == 'RAW'
-          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
-          col <<  "(#{length})"
+          col << ",#{column['data_scale'].to_i}" if !column["data_scale"].nil?
+          col << ")"
+        elsif column["data_type"].include?("CHAR") || column["data_type"] == "RAW"
+          length = column["char_used"] == "C" ? column["char_length"].to_i : column["data_length"].to_i
+          col << "(#{length})"
         end
         col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
       end
 
       def structure_dump_primary_key(table) #:nodoc:
-        opts = {:name => '', :cols => []}
+        opts = { name: "", cols: [] }
         pks = select_all(<<-SQL, "Primary Keys")
           SELECT a.constraint_name, a.column_name, a.position
             FROM all_cons_columns a
@@ -83,10 +83,10 @@ module ActiveRecord #:nodoc:
              AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
         pks.each do |row|
-          opts[:name] = row['constraint_name']
-          opts[:cols][row['position']-1] = row['column_name']
+          opts[:name] = row["constraint_name"]
+          opts[:cols][row["position"] - 1] = row["column_name"]
         end
-        opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ''
+        opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ""
       end
 
       def structure_dump_unique_keys(table) #:nodoc:
@@ -102,10 +102,10 @@ module ActiveRecord #:nodoc:
              AND c.owner = SYS_CONTEXT('userenv', 'current_schema')
         SQL
         uks.each do |uk|
-          keys[uk['constraint_name']] ||= []
-          keys[uk['constraint_name']][uk['position']-1] = uk['column_name']
+          keys[uk["constraint_name"]] ||= []
+          keys[uk["constraint_name"]][uk["position"] - 1] = uk["column_name"]
         end
-        keys.map do |k,v|
+        keys.map do |k, v|
           "ALTER TABLE #{table.upcase} ADD CONSTRAINT #{k} UNIQUE (#{v.join(',')})"
         end
       end
@@ -113,8 +113,8 @@ module ActiveRecord #:nodoc:
       def structure_dump_indexes(table_name) #:nodoc:
         indexes(table_name).map do |options|
           column_names = options[:columns]
-          options = {:name => options[:name], :unique => options[:unique]}
-          index_name   = index_name(table_name, :column => column_names)
+          options = { name: options[:name], unique: options[:unique] }
+          index_name = index_name(table_name, column: column_names)
           if Hash === options # legacy support, since this param was a string
             index_type = options[:unique] ? "UNIQUE" : ""
             index_name = options[:name] || index_name
@@ -164,22 +164,11 @@ module ActiveRecord #:nodoc:
       end
 
       def foreign_key_definition(to_table, options = {}) #:nodoc:
-        columns = Array(options[:column] || options[:columns])
+        column_sql = quote_column_name(options[:column] || "#{to_table.to_s.singularize}_id")
+        references = options[:references] ? options[:references].first : nil
+        references_sql = quote_column_name(options[:primary_key] || references || "id")
 
-        if columns.size > 1
-          # composite foreign key
-          columns_sql = columns.map {|c| quote_column_name(c)}.join(',')
-          references = options[:references] || columns
-          references_sql = references.map {|c| quote_column_name(c)}.join(',')
-        else
-          columns_sql = quote_column_name(columns.first || "#{to_table.to_s.singularize}_id")
-          references = options[:references] ? options[:references].first : nil
-          references_sql = quote_column_name(options[:primary_key] || references || "id")
-        end
-
-        table_name = to_table
-
-        sql = "FOREIGN KEY (#{columns_sql}) REFERENCES #{quote_table_name(table_name)}(#{references_sql})"
+        sql = "FOREIGN KEY (#{column_sql}) REFERENCES #{quote_table_name(to_table)}(#{references_sql})"
 
         case options[:dependent]
         when :nullify
@@ -199,17 +188,17 @@ module ActiveRecord #:nodoc:
                       AND name NOT LIKE 'BIN$%'
                       AND owner = SYS_CONTEXT('userenv', 'current_schema') ORDER BY type").each do |source|
           ddl = "CREATE OR REPLACE   \n"
-          select_all(%Q{
+          select_all("
                   SELECT text
                     FROM all_source
                    WHERE name = '#{source['name']}'
                      AND type = '#{source['type']}'
                      AND owner = SYS_CONTEXT('userenv', 'current_schema')
                    ORDER BY line
-                }).each do |row|
-            ddl << row['text']
+                ").each do |row|
+            ddl << row["text"]
           end
-          ddl << ";" unless ddl.strip[-1,1] == ';'
+          ddl << ";" unless ddl.strip[-1, 1] == ";"
           structure << ddl
         end
 
@@ -251,7 +240,7 @@ module ActiveRecord #:nodoc:
         end)
       end
 
-      def full_drop(preserve_tables=false) #:nodoc:
+      def full_drop(preserve_tables = false) #:nodoc:
         s = preserve_tables ? [] : [structure_drop]
         s << temp_table_drop if preserve_tables
         s << drop_sql_for_feature("view")
@@ -264,30 +253,6 @@ module ActiveRecord #:nodoc:
         s.join
       end
 
-      def add_column_options!(sql, options) #:nodoc:
-        type = options[:type] || ((column = options[:column]) && column.type)
-        type = type && type.to_sym
-        # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
-        if options_include_default?(options)
-          if type == :text
-            sql << " DEFAULT #{quote(options[:default])}"
-          else
-            # from abstract adapter
-            sql << " DEFAULT #{quote(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
-      end
-
       def execute_structure_dump(string)
         string.split(STATEMENT_TOKEN).each do |ddl|
           execute(ddl) unless ddl.blank?
@@ -296,44 +261,44 @@ module ActiveRecord #:nodoc:
 
       private
 
-      # virtual columns are an 11g feature.  This returns [] if feature is not
-      # present or none are found.
-      # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
-      def virtual_columns_for(table)
-        begin
-          select_all <<-SQL
+        # virtual columns are an 11g feature.  This returns [] if feature is not
+        # present or none are found.
+        # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
+        def virtual_columns_for(table)
+          begin
+            select_all <<-SQL
             SELECT column_name, data_default
               FROM all_tab_cols
              WHERE virtual_column = 'YES'
                AND owner = SYS_CONTEXT('userenv', 'session_user')
                AND table_name = '#{table.upcase}'
           SQL
-        # feature not supported previous to 11g
-        rescue ActiveRecord::StatementInvalid => _e
-          []
+          # feature not supported previous to 11g
+          rescue ActiveRecord::StatementInvalid => _e
+            []
+          end
         end
-      end
 
-      def drop_sql_for_feature(type)
-        short_type = type == 'materialized view' ? 'mview' : type
-        join_with_statement_token(
-        select_values("SELECT #{short_type}_name FROM all_#{short_type.tableize} where owner = SYS_CONTEXT('userenv', 'session_user')").map do |name|
-          "DROP #{type.upcase} \"#{name}\""
-        end)
-      end
+        def drop_sql_for_feature(type)
+          short_type = type == "materialized view" ? "mview" : type
+          join_with_statement_token(
+          select_values("SELECT #{short_type}_name FROM all_#{short_type.tableize} where owner = SYS_CONTEXT('userenv', 'session_user')").map do |name|
+            "DROP #{type.upcase} \"#{name}\""
+          end)
+        end
 
-      def drop_sql_for_object(type)
-        join_with_statement_token(
-        select_values("SELECT object_name FROM all_objects WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')").map do |name|
-          "DROP #{type.upcase} \"#{name}\""
-        end)
-      end
+        def drop_sql_for_object(type)
+          join_with_statement_token(
+          select_values("SELECT object_name FROM all_objects WHERE object_type = '#{type.upcase}' and owner = SYS_CONTEXT('userenv', 'session_user')").map do |name|
+            "DROP #{type.upcase} \"#{name}\""
+          end)
+        end
 
-      def join_with_statement_token(array)
-        string = array.join(STATEMENT_TOKEN)
-        string << STATEMENT_TOKEN unless string.blank?
-        string
-      end
+        def join_with_statement_token(array)
+          string = array.join(STATEMENT_TOKEN)
+          string << STATEMENT_TOKEN unless string.blank?
+          string
+        end
     end
   end
 end