activerecord-oracle_enhanced-adapter 6.0.0.beta1 → 6.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88d4ded25c413bd3ad25d89e39551c5709e070365d687c515bca47e8c8f327fa
-  data.tar.gz: 7e3c7a298c9e4fed4a66c08a8085883ecaf52698841fdf91bbd5fc98213dac41
+  metadata.gz: 20b3aea35f3c42e8485b1b11ec0c5a549e0571b81522e5608abea0a6916d38f8
+  data.tar.gz: 53379822a99628e864639ed410712386bbf025de3c75ac5f9aa99e33fa0cf170
 SHA512:
-  metadata.gz: 7c90e048c399283b8125ae3aa6929140ead8db07cab427894993445ceb09d0c0665080444a28be6e8609fb26387b5d6bca50f1de2623c090626e2b4275c01d74
-  data.tar.gz: db3ff9ab3f530b13074bd7dc9cf2146c0da1756e9a8c57429567f1122716dc0bc03e5724e35cb7e0349830e686146379f404b554f265a3292850608043797b66
+  metadata.gz: 9c928e3b86ca4f34e45ad25ca37737f605fddfae4ae5b9205812f05079655a46fa748aa6f70d926b41269574bcc811bb297396ae60325a10211ffb3854b6b08e
+  data.tar.gz: 1e8e54cab8bb27dc6754f559a19ee5ed60dfcad8835b6352ffd60304cd122294f326bf02bf93bd458410f8d319d2e707457d09292a9bfde56dcddc041e53e0fd

data/History.md

@@ -1,4 +1,28 @@
-## 6.0.0.beta1 / 2018-03-18
+## 6.0.0.rc1 / 2019-04-25
+
+* Major changes
+  * Support Rails 6.0.0 rc1
+  * Address `ORA-01795: maximum number of expressions in a list is 1000`
+    - These changes has been made to Rails itself [rails/rails#35838, rails/rails#36074]
+
+* Changes and bug fixes
+  * Cache database version in schema cache [#1859]
+  * Except `table_name` from column objects [#1860]
+  * Remove unused `sequence_name` in `sql_for_insert` [#1861]
+  * Use squiggly heredoc to strip odd indentation in the executed SQL [#1869]
+  * Use Active Support `String#squish` instead of `String#strip.gsub` [#1871]
+
+* CI
+  * Revert "Add `allow_railures` for jruby-head until #1833 resolved" [#1862]
+  * CI against JRuby 9.2.7.0 [#1864]
+  * Use newer Code Climate analysis model, version 2 [#1868]
+  * CI against Ruby 2.6.3 [#1870]
+
+* RuboCop
+  * Bump RuboCop version to 0.67 [#1867]
+  * Enable `Layout/SpaceBeforeComment` cop [#1863]
+
+## 6.0.0.beta1 / 2019-03-18
 
 * Major changes
 

data/VERSION

@@ -1 +1 @@
-6.0.0.beta1
+6.0.0.rc1

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

@@ -6,8 +6,8 @@ module ActiveRecord
       class Column < ActiveRecord::ConnectionAdapters::Column
         delegate :virtual, to: :sql_type_metadata, allow_nil: true
 
-        def initialize(name, default, sql_type_metadata = nil, null = true, table_name = nil, comment = nil) #:nodoc:
-          super(name, default, sql_type_metadata, null, table_name, comment: comment)
+        def initialize(name, default, sql_type_metadata = nil, null = true, comment: nil) #:nodoc:
+          super(name, default, sql_type_metadata, null, comment: comment)
         end
 
         def virtual?

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

@@ -34,27 +34,27 @@ module ActiveRecord
             else
               table_owner, table_name = default_owner, real_name
             end
-            sql = <<-SQL.strip.gsub(/\s+/, " ")
-          SELECT owner, table_name, 'TABLE' name_type
-          FROM all_tables
-          WHERE owner = '#{table_owner}'
-            AND table_name = '#{table_name}'
-          UNION ALL
-          SELECT owner, view_name table_name, 'VIEW' name_type
-          FROM all_views
-          WHERE owner = '#{table_owner}'
-            AND view_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, table_name, 'SYNONYM' name_type
-          FROM all_synonyms
-          WHERE owner = '#{table_owner}'
-            AND synonym_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, table_name, 'SYNONYM' name_type
-          FROM all_synonyms
-          WHERE owner = 'PUBLIC'
-            AND synonym_name = '#{real_name}'
-        SQL
+            sql = <<~SQL.squish
+              SELECT owner, table_name, 'TABLE' name_type
+              FROM all_tables
+              WHERE owner = '#{table_owner}'
+                AND table_name = '#{table_name}'
+              UNION ALL
+              SELECT owner, view_name table_name, 'VIEW' name_type
+              FROM all_views
+              WHERE owner = '#{table_owner}'
+                AND view_name = '#{table_name}'
+              UNION ALL
+              SELECT table_owner, table_name, 'SYNONYM' name_type
+              FROM all_synonyms
+              WHERE owner = '#{table_owner}'
+                AND synonym_name = '#{table_name}'
+              UNION ALL
+              SELECT table_owner, table_name, 'SYNONYM' name_type
+              FROM all_synonyms
+              WHERE owner = 'PUBLIC'
+                AND synonym_name = '#{real_name}'
+            SQL
             if result = _select_one(sql)
               case result["name_type"]
               when "SYNONYM"

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

@@ -149,56 +149,56 @@ module ActiveRecord
             select_queries = select_queries.map { |s| s.strip.gsub(/\s+/, " ") }
             keys, selected_columns = parse_select_queries(select_queries)
             quoted_column_names = (column_names + keys).map { |col| quote_column_name(col) }
-            execute <<-SQL
-            CREATE OR REPLACE PROCEDURE #{quote_table_name(procedure_name)}
-              (p_rowid IN	      ROWID,
-              p_clob	IN OUT NOCOPY CLOB) IS
-              -- add_context_index_parameters #{(column_names + select_queries).inspect}#{!options.empty? ? +', ' << options.inspect[1..-2] : ''}
-              #{
-              selected_columns.map do |cols|
-                cols.map do |col|
-                  raise ArgumentError, "Alias #{col} too large, should be 28 or less characters long" unless col.length <= 28
-                  "l_#{col} VARCHAR2(32767);\n"
-                end.join
-              end.join
-              } BEGIN
-              FOR r1 IN (
-                SELECT #{quoted_column_names.join(', ')}
-                FROM	 #{quoted_table_name}
-                WHERE  #{quoted_table_name}.ROWID = p_rowid
-              ) LOOP
+            execute <<~SQL
+              CREATE OR REPLACE PROCEDURE #{quote_table_name(procedure_name)}
+                (p_rowid IN	      ROWID,
+                p_clob	IN OUT NOCOPY CLOB) IS
+                -- add_context_index_parameters #{(column_names + select_queries).inspect}#{!options.empty? ? +', ' << options.inspect[1..-2] : ''}
                 #{
-                (column_names.map do |col|
-                  col = col.to_s
-                  +"DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
-                  "IF LENGTH(r1.#{col}) > 0 THEN\n" <<
-                  "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(r1.#{col}), r1.#{col});\n" <<
-                  "END IF;\n" <<
-                  "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 3}, '</#{col}>');\n"
-                end.join) <<
-                (selected_columns.zip(select_queries).map do |cols, query|
-                  (cols.map do |col|
-                    "l_#{col} := '';\n"
-                  end.join) <<
-                  "FOR r2 IN (\n" <<
-                  query.gsub(/:(\w+)/, "r1.\\1") << "\n) LOOP\n" <<
-                  (cols.map do |col|
-                    "l_#{col} := l_#{col} || r2.#{col} || CHR(10);\n"
-                  end.join) <<
-                  "END LOOP;\n" <<
-                  (cols.map do |col|
+                selected_columns.map do |cols|
+                  cols.map do |col|
+                    raise ArgumentError, "Alias #{col} too large, should be 28 or less characters long" unless col.length <= 28
+                    "l_#{col} VARCHAR2(32767);\n"
+                  end.join
+                end.join
+                } BEGIN
+                FOR r1 IN (
+                  SELECT #{quoted_column_names.join(', ')}
+                  FROM	 #{quoted_table_name}
+                  WHERE  #{quoted_table_name}.ROWID = p_rowid
+                ) LOOP
+                  #{
+                  (column_names.map do |col|
                     col = col.to_s
                     +"DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
-                    "IF LENGTH(l_#{col}) > 0 THEN\n" <<
-                    "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
+                    "IF LENGTH(r1.#{col}) > 0 THEN\n" <<
+                    "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(r1.#{col}), r1.#{col});\n" <<
                     "END IF;\n" <<
                     "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 3}, '</#{col}>');\n"
+                  end.join) <<
+                  (selected_columns.zip(select_queries).map do |cols, query|
+                    (cols.map do |col|
+                      "l_#{col} := '';\n"
+                    end.join) <<
+                    "FOR r2 IN (\n" <<
+                    query.gsub(/:(\w+)/, "r1.\\1") << "\n) LOOP\n" <<
+                    (cols.map do |col|
+                      "l_#{col} := l_#{col} || r2.#{col} || CHR(10);\n"
+                    end.join) <<
+                    "END LOOP;\n" <<
+                    (cols.map do |col|
+                      col = col.to_s
+                      +"DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 2}, '<#{col}>');\n" <<
+                      "IF LENGTH(l_#{col}) > 0 THEN\n" <<
+                      "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
+                      "END IF;\n" <<
+                      "DBMS_LOB.WRITEAPPEND(p_clob, #{col.length + 3}, '</#{col}>');\n"
+                    end.join)
                   end.join)
-                end.join)
-                }
-              END LOOP;
-            END;
-          SQL
+                  }
+                END LOOP;
+              END;
+            SQL
           end
 
           def parse_select_queries(select_queries)
@@ -215,12 +215,12 @@ module ActiveRecord
 
           def create_datastore_preference(datastore_name, procedure_name)
             drop_ctx_preference(datastore_name)
-            execute <<-SQL
-            BEGIN
-              CTX_DDL.CREATE_PREFERENCE('#{datastore_name}', 'USER_DATASTORE');
-              CTX_DDL.SET_ATTRIBUTE('#{datastore_name}', 'PROCEDURE', '#{procedure_name}');
-            END;
-          SQL
+            execute <<~SQL
+              BEGIN
+                CTX_DDL.CREATE_PREFERENCE('#{datastore_name}', 'USER_DATASTORE');
+                CTX_DDL.SET_ATTRIBUTE('#{datastore_name}', 'PROCEDURE', '#{procedure_name}');
+              END;
+            SQL
           end
 
           def create_storage_preference(storage_name, tablespace)
@@ -281,13 +281,13 @@ module ActiveRecord
             trigger_name = default_index_column_trigger_name(index_name)
             columns = Array(index_column_source)
             quoted_column_names = columns.map { |col| quote_column_name(col) }.join(", ")
-            execute <<-SQL
-            CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
-            BEFORE UPDATE OF #{quoted_column_names} ON #{quote_table_name(table_name)} FOR EACH ROW
-            BEGIN
-              :new.#{quote_column_name(index_column)} := '1';
-            END;
-          SQL
+            execute <<~SQL
+              CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
+              BEFORE UPDATE OF #{quoted_column_names} ON #{quote_table_name(table_name)} FOR EACH ROW
+              BEGIN
+                :new.#{quote_column_name(index_column)} := '1';
+              END;
+            SQL
           end
 
           def drop_index_column_trigger(index_name)

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

@@ -76,7 +76,7 @@ module ActiveRecord
 
         # New method in ActiveRecord 3.1
         # Will add RETURNING clause in case of trigger generated primary keys
-        def sql_for_insert(sql, pk, sequence_name, binds)
+        def sql_for_insert(sql, pk, binds)
           unless pk == false || pk.nil? || pk.is_a?(Array)
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
             (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, Type::OracleEnhanced::Integer.new)
@@ -91,7 +91,7 @@ module ActiveRecord
 
         # New method in ActiveRecord 3.1
         def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil)
-          sql, binds = sql_for_insert(sql, pk, sequence_name, binds)
+          sql, binds = sql_for_insert(sql, pk, binds)
           type_casted_binds = type_casted_binds(binds)
 
           log(sql, name, binds, type_casted_binds) do
@@ -252,7 +252,7 @@ module ActiveRecord
               value = klass.attribute_types[col.name].serialize(value)
             end
             uncached do
-              unless lob_record = select_one(<<-SQL.strip.gsub(/\s+/, " "), "Writable Large Object")
+              unless lob_record = select_one(<<~SQL.squish, "Writable Large Object")
                 SELECT #{quote_column_name(col.name)} FROM #{quote_table_name(table_name)}
                 WHERE #{quote_column_name(klass.primary_key)} = #{id} FOR UPDATE
               SQL

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

@@ -76,17 +76,17 @@ module ActiveRecord
           def action_sql(action, dependency)
             if action == "UPDATE"
               raise ArgumentError, <<~MSG
-              '#{action}' is not supported by Oracle
-            MSG
+                '#{action}' is not supported by Oracle
+              MSG
             end
             case dependency
             when :nullify then "ON #{action} SET NULL"
             when :cascade  then "ON #{action} CASCADE"
             else
               raise ArgumentError, <<~MSG
-              '#{dependency}' is not supported for #{action}
-              Supported values are: :nullify, :cascade
-            MSG
+                '#{dependency}' is not supported for #{action}
+                Supported values are: :nullify, :cascade
+              MSG
             end
           end
       end

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

@@ -85,6 +85,8 @@ module ActiveRecord #:nodoc:
           def table(table, stream)
             columns = @connection.columns(table)
             begin
+              self.table_name = table
+
               tbl = StringIO.new
 
               # first dump primary key column
@@ -144,6 +146,8 @@ module ActiveRecord #:nodoc:
               stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
               stream.puts "#   #{e.message}"
               stream.puts
+            ensure
+              self.table_name = nil
             end
           end
 
@@ -164,8 +168,7 @@ module ActiveRecord #:nodoc:
 
           def extract_expression_for_virtual_column(column)
             column_name = column.name
-            table_name = column.table_name
-            @connection.select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+            @connection.select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
               select data_default from all_tab_columns
               where owner = SYS_CONTEXT('userenv', 'current_schema')
               and table_name = :table_name

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

@@ -11,16 +11,16 @@ module ActiveRecord
         # see: abstract/schema_statements.rb
 
         def tables #:nodoc:
-          select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables")
-          SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
-          FROM all_tables
-          WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
-          AND secondary = 'N'
-          minus
-          SELECT DECODE(mview_name, UPPER(mview_name), LOWER(mview_name), mview_name)
-          FROM all_mviews
-          WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
-        SQL
+          select_values(<<~SQL.squish, "tables")
+            SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
+            FROM all_tables
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+            AND secondary = 'N'
+            minus
+            SELECT DECODE(mview_name, UPPER(mview_name), LOWER(mview_name), mview_name)
+            FROM all_mviews
+            WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
         end
 
         def data_sources
@@ -43,12 +43,12 @@ module ActiveRecord
             table_owner, table_name = default_owner, real_name
           end
 
-          select_values(<<-SQL.strip.gsub(/\s+/, " "), "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
-          SELECT owner, table_name
-          FROM all_tables
-          WHERE owner = :owner
-          AND table_name = :table_name
-        SQL
+          select_values(<<~SQL.squish, "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
+            SELECT owner, table_name
+            FROM all_tables
+            WHERE owner = :owner
+            AND table_name = :table_name
+          SQL
         end
 
         def data_source_exists?(table_name)
@@ -59,23 +59,23 @@ module ActiveRecord
         end
 
         def views # :nodoc:
-          select_values(<<-SQL.strip.gsub(/\s+/, " "), "views")
+          select_values(<<~SQL.squish, "views")
             SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         def materialized_views #:nodoc:
-          select_values(<<-SQL.strip.gsub(/\s+/, " "), "materialized views")
+          select_values(<<~SQL.squish, "materialized views")
             SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
         end
 
         # get synonyms for schema dump
         def synonyms
-          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms")
-          SELECT synonym_name, table_owner, table_name
-          FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'current_schema')
-        SQL
+          result = select_all(<<~SQL.squish, "synonyms")
+            SELECT synonym_name, table_owner, table_name
+            FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
 
           result.collect do |row|
              OracleEnhanced::SynonymDefinition.new(oracle_downcase(row["synonym_name"]),
@@ -87,7 +87,7 @@ module ActiveRecord
           (_owner, table_name) = @connection.describe(table_name)
           default_tablespace_name = default_tablespace
 
-          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "indexes", [bind_string("table_name", table_name)])
+          result = select_all(<<~SQL.squish, "indexes", [bind_string("table_name", table_name)])
             SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
               i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
               LOWER(i.tablespace_name) AS tablespace_name,
@@ -117,7 +117,7 @@ module ActiveRecord
               statement_parameters = nil
               if row["index_type"] == "DOMAIN" && row["ityp_owner"] == "CTXSYS" && row["ityp_name"] == "CONTEXT"
                 procedure_name = default_datastore_procedure(row["index_name"])
-                source = select_values(<<-SQL.strip.gsub(/\s+/, " "), "procedure", [bind_string("procedure_name", procedure_name.upcase)]).join
+                source = select_values(<<~SQL.squish, "procedure", [bind_string("procedure_name", procedure_name.upcase)]).join
                   SELECT text
                   FROM all_source
                   WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -361,7 +361,7 @@ module ActiveRecord
         # Will always query database and not index cache.
         def index_name_exists?(table_name, index_name)
           (_owner, table_name) = @connection.describe(table_name)
-          result = select_value(<<-SQL.strip.gsub(/\s+/, " "), "index name exists")
+          result = select_value(<<~SQL.squish, "index name exists")
             SELECT 1 FROM all_indexes i
             WHERE i.owner = SYS_CONTEXT('userenv', 'current_schema')
                AND i.table_owner = SYS_CONTEXT('userenv', 'current_schema')
@@ -477,8 +477,9 @@ module ActiveRecord
           clear_table_columns_cache(table_name)
         end
 
-        def change_table_comment(table_name, comment)
+        def change_table_comment(table_name, comment_or_changes)
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           if comment.nil?
             execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS ''"
           else
@@ -486,14 +487,15 @@ module ActiveRecord
           end
         end
 
-        def change_column_comment(table_name, column_name, comment) #:nodoc:
+        def change_column_comment(table_name, column_name, comment_or_changes)
           clear_cache!
+          comment = extract_new_comment_value(comment_or_changes)
           execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS '#{comment}'"
         end
 
         def table_comment(table_name) #:nodoc:
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name)])
+          select_value(<<~SQL.squish, "Table comment", [bind_string("table_name", table_name)])
             SELECT comments FROM all_tab_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -509,7 +511,7 @@ module ActiveRecord
         def column_comment(table_name, column_name) #:nodoc:
           # TODO: it  does not exist in Abstract adapter
           (_owner, table_name) = @connection.describe(table_name)
-          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Column comment", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
+          select_value(<<~SQL.squish, "Column comment", [bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
             SELECT comments FROM all_col_comments
             WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
               AND table_name = :table_name
@@ -526,7 +528,7 @@ module ActiveRecord
         end
 
         def tablespace(table_name)
-          select_value(<<-SQL.strip.gsub(/\s+/, " "), "tablespace")
+          select_value(<<~SQL.squish, "tablespace")
             SELECT tablespace_name
             FROM all_tables
             WHERE table_name='#{table_name.to_s.upcase}'
@@ -538,7 +540,7 @@ module ActiveRecord
         def foreign_keys(table_name) #:nodoc:
           (_owner, desc_table_name) = @connection.describe(table_name)
 
-          fk_info = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys", [bind_string("desc_table_name", desc_table_name)])
+          fk_info = select_all(<<~SQL.squish, "Foreign Keys", [bind_string("desc_table_name", desc_table_name)])
             SELECT r.table_name to_table
                   ,rc.column_name references_column
                   ,cc.column_name
@@ -580,12 +582,12 @@ module ActiveRecord
         # REFERENTIAL INTEGRITY ====================================
 
         def disable_referential_integrity(&block) #:nodoc:
-          old_constraints = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys to disable and enable")
-          SELECT constraint_name, owner, table_name
-            FROM all_constraints
-            WHERE constraint_type = 'R'
-            AND status = 'ENABLED'
-            AND owner = SYS_CONTEXT('userenv', 'current_schema')
+          old_constraints = select_all(<<~SQL.squish, "Foreign Keys to disable and enable")
+            SELECT constraint_name, owner, table_name
+              FROM all_constraints
+              WHERE constraint_type = 'R'
+              AND status = 'ENABLED'
+              AND owner = SYS_CONTEXT('userenv', 'current_schema')
           SQL
           begin
             old_constraints.each do |constraint|
@@ -652,8 +654,7 @@ module ActiveRecord
                              default_value,
                              type_metadata,
                              field["nullable"] == "Y",
-                             table_name,
-                             field["column_comment"]
+                             comment: field["column_comment"]
                       )
           end
 
@@ -697,7 +698,7 @@ module ActiveRecord
 
             return unless tablespace
 
-            index_name = select_value(<<-SQL.strip.gsub(/\s+/, " "), "Index name for primary key",  [bind_string("table_name", table_name.upcase)])
+            index_name = select_value(<<~SQL.squish, "Index name for primary key",  [bind_string("table_name", table_name.upcase)])
               SELECT index_name FROM all_constraints
                   WHERE table_name = :table_name
                   AND constraint_type = 'P'