activerecord-oracle_enhanced-adapter 5.2.8 → 7.0.3

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

@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters
     # interface independent methods
     module OracleEnhanced
-      class Connection #:nodoc:
+      class Connection # :nodoc:
         def self.create(config)
           case ORACLE_ENHANCED_CONNECTION
           when :oci
@@ -19,16 +19,12 @@ module ActiveRecord
         attr_reader :raw_connection
 
         private
-
           # Used always by JDBC connection as well by OCI connection when describing tables over database link
           def describe(name)
             name = name.to_s
             if name.include?("@")
-              name, db_link = name.split("@")
-              default_owner = _select_value("SELECT username FROM all_db_links WHERE db_link = '#{db_link.upcase}'")
-              db_link = "@#{db_link}"
+              raise ArgumentError "db link is not supported"
             else
-              db_link = nil
               default_owner = @owner
             end
             real_name = OracleEnhanced::Quoting.valid_table_name?(name) ? name.upcase : name
@@ -37,33 +33,33 @@ 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#{db_link}
-          WHERE owner = '#{table_owner}'
-            AND table_name = '#{table_name}'
-          UNION ALL
-          SELECT owner, view_name table_name, 'VIEW' name_type
-          FROM all_views#{db_link}
-          WHERE owner = '#{table_owner}'
-            AND view_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, DECODE(db_link, NULL, table_name, table_name||'@'||db_link), 'SYNONYM' name_type
-          FROM all_synonyms#{db_link}
-          WHERE owner = '#{table_owner}'
-            AND synonym_name = '#{table_name}'
-          UNION ALL
-          SELECT table_owner, DECODE(db_link, NULL, table_name, table_name||'@'||db_link), 'SYNONYM' name_type
-          FROM all_synonyms#{db_link}
-          WHERE owner = 'PUBLIC'
-            AND synonym_name = '#{real_name}'
-        SQL
-            if result = _select_one(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, "CONNECTION", [table_owner, table_name, table_owner, table_name, table_owner, table_name, real_name])
               case result["name_type"]
               when "SYNONYM"
-                describe("#{result['owner'] && "#{result['owner']}."}#{result['table_name']}#{db_link}")
+                describe("#{result['owner'] && "#{result['owner']}."}#{result['table_name']}")
               else
-                db_link ? [result["owner"], result["table_name"], db_link] : [result["owner"], result["table_name"]]
+                [result["owner"], result["table_name"]]
               end
             else
               raise OracleEnhanced::ConnectionException, %Q{"DESC #{name}" failed; does it exist?}
@@ -85,7 +81,7 @@ module ActiveRecord
           # To avoid it is called from anywhere else, added _ at the beginning of the method name.
           def _oracle_downcase(column_name)
             return nil if column_name.nil?
-            column_name =~ /[a-z]/ ? column_name : column_name.downcase
+            /[a-z]/.match?(column_name) ? column_name : column_name.downcase
           end
 
           # _select_one and _select_value methods are expected to be called
@@ -96,14 +92,23 @@ module ActiveRecord
 
           # Returns a record hash with the column names as keys and column values
           # as values.
+          # binds is a array of native values in contrast to ActiveRecord::Relation::QueryAttribute
           def _select_one(arel, name = nil, binds = [])
-            result = select(arel)
-            result.first if result
+            cursor = prepare(arel)
+            cursor.bind_params(binds)
+            cursor.exec
+            columns = cursor.get_col_names.map do |col_name|
+              _oracle_downcase(col_name)
+            end
+            row = cursor.fetch
+            columns.each_with_index.map { |x, i| [x, row[i]] }.to_h if row
+          ensure
+            cursor.close
           end
 
           # Returns a single value from a record
           def _select_value(arel, name = nil, binds = [])
-            if result = _select_one(arel)
+            if result = _select_one(arel, name, binds)
               result.values.first
             end
           end
@@ -113,14 +118,14 @@ module ActiveRecord
       def database_version
         raise NoMethodError, "Not implemented for this raw driver"
       end
-      class ConnectionException < StandardError #:nodoc:
+      class ConnectionException < StandardError # :nodoc:
       end
     end
   end
 end
 
-# if MRI or YARV
-if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby"
+# if MRI or YARV or TruffleRuby
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby"
   ORACLE_ENHANCED_CONNECTION = :oci
   require "active_record/connection_adapters/oracle_enhanced/oci_connection"
 # if JRuby

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

@@ -86,7 +86,7 @@ module ActiveRecord
             create_index_column_trigger(table_name, index_name, options[:index_column], options[:index_column_trigger_on])
           end
 
-          sql = "CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}".dup
+          sql = +"CREATE INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)}"
           sql << " (#{quoted_column_name})"
           sql << " INDEXTYPE IS CTXSYS.CONTEXT"
           parameters = []
@@ -142,63 +142,62 @@ module ActiveRecord
         end
 
         private
-
           def create_datastore_procedure(table_name, procedure_name, column_names, options)
             quoted_table_name = quote_table_name(table_name)
             select_queries, column_names = column_names.partition { |c| c.to_s =~ /^\s*SELECT\s+/i }
             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? ? ', '.dup << options.inspect[1..-2] : ''}
+            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"
+                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
-              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".dup <<
-                  "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|
+                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".dup <<
-                    "IF LENGTH(l_#{col}) > 0 THEN\n" <<
-                    "DBMS_LOB.WRITEAPPEND(p_clob, LENGTH(l_#{col}), l_#{col});\n" <<
+                    +"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|
+                      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,17 +214,17 @@ 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)
             drop_ctx_preference(storage_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n".dup
+            sql = +"BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{storage_name}', 'BASIC_STORAGE');\n"
             ["I_TABLE_CLAUSE", "K_TABLE_CLAUSE", "R_TABLE_CLAUSE",
             "N_TABLE_CLAUSE", "I_INDEX_CLAUSE", "P_TABLE_CLAUSE"].each do |clause|
               default_clause = case clause
@@ -241,7 +240,7 @@ module ActiveRecord
 
           def create_lexer_preference(lexer_name, lexer_type, options)
             drop_ctx_preference(lexer_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n".dup
+            sql = +"BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{lexer_name}', '#{lexer_type}');\n"
             options.each do |key, value|
               plsql_value = case value
                             when String; "'#{value}'"
@@ -258,7 +257,7 @@ module ActiveRecord
 
           def create_wordlist_preference(wordlist_name, wordlist_type, options)
             drop_ctx_preference(wordlist_name)
-            sql = "BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n".dup
+            sql = +"BEGIN\nCTX_DDL.CREATE_PREFERENCE('#{wordlist_name}', '#{wordlist_type}');\n"
             options.each do |key, value|
               plsql_value = case value
                             when String; "'#{value}'"
@@ -281,13 +280,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_limits.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/deprecation"
+
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
@@ -7,7 +9,7 @@ module ActiveRecord
         # maximum length of Oracle identifiers
         IDENTIFIER_MAX_LENGTH = 30
 
-        def table_alias_length #:nodoc:
+        def table_alias_length # :nodoc:
           IDENTIFIER_MAX_LENGTH
         end
 
@@ -15,20 +17,13 @@ module ActiveRecord
         def table_name_length
           IDENTIFIER_MAX_LENGTH
         end
+        deprecate :table_name_length
 
         # the maximum length of a column name
         def column_name_length
           IDENTIFIER_MAX_LENGTH
         end
-
-        # Returns the maximum allowed length for an index name. This
-        # limit is enforced by rails and Is less than or equal to
-        # <tt>index_name_length</tt>. The gap between
-        # <tt>index_name_length</tt> is to allow internal rails
-        # opreations to use prefixes in temporary opreations.
-        def allowed_index_name_length
-          index_name_length
-        end
+        deprecate :column_name_length
 
         # the maximum length of an index name
         # supported by this database

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

@@ -9,38 +9,39 @@ module ActiveRecord
         # see: abstract/database_statements.rb
 
         # Executes a SQL statement
-        def execute(sql, name = nil)
-          log(sql, name) { @connection.exec(sql) }
-        end
+        def execute(sql, name = nil, async: false)
+          sql = transform_query(sql)
 
-        def clear_cache!
-          @statements.clear
-          reload_type_map
+          log(sql, name, async: async) { @connection.exec(sql) }
         end
 
-        def exec_query(sql, name = "SQL", binds = [], prepare: false)
+        def exec_query(sql, name = "SQL", binds = [], prepare: false, async: false)
+          sql = transform_query(sql)
+
           type_casted_binds = type_casted_binds(binds)
 
-          log(sql, name, binds, type_casted_binds) do
+          log(sql, name, binds, type_casted_binds, async: async) do
             cursor = nil
             cached = false
-            if without_prepared_statement?(binds)
-              cursor = @connection.prepare(sql)
-            else
-              unless @statements.key? sql
-                @statements[sql] = @connection.prepare(sql)
-              end
+            with_retry do
+              if without_prepared_statement?(binds)
+                cursor = @connection.prepare(sql)
+              else
+                unless @statements.key? sql
+                  @statements[sql] = @connection.prepare(sql)
+                end
 
-              cursor = @statements[sql]
+                cursor = @statements[sql]
 
-              cursor.bind_params(type_casted_binds)
+                cursor.bind_params(type_casted_binds)
 
-              cached = true
-            end
+                cached = true
+              end
 
-            cursor.exec
+              cursor.exec
+            end
 
-            if (name == "EXPLAIN") && sql =~ /^EXPLAIN/
+            if (name == "EXPLAIN") && sql.start_with?("EXPLAIN")
               res = true
             else
               columns = cursor.get_col_names.map do |col_name|
@@ -51,7 +52,7 @@ module ActiveRecord
               while row = cursor.fetch(fetch_options)
                 rows << row
               end
-              res = ActiveRecord::Result.new(columns, rows)
+              res = build_result(columns: columns, rows: rows)
             end
 
             cursor.close unless cached
@@ -65,7 +66,7 @@ module ActiveRecord
 
         def explain(arel, binds = [])
           sql = "EXPLAIN PLAN FOR #{to_sql(arel, binds)}"
-          return if sql =~ /FROM all_/
+          return if /FROM all_/.match?(sql)
           if ORACLE_ENHANCED_CONNECTION == :jdbc
             exec_query(sql, "EXPLAIN", binds)
           else
@@ -76,8 +77,8 @@ 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, id_value, sequence_name, binds)
-          unless id_value || pk == false || pk.nil? ||  pk.is_a?(Array)
+        def sql_for_insert(sql, pk, binds)
+          unless pk == false || pk.nil? || pk.is_a?(Array) || pk.is_a?(String)
             sql = "#{sql} RETURNING #{quote_column_name(pk)} INTO :returning_id"
             (binds = binds.dup) << ActiveRecord::Relation::QueryAttribute.new("returning_id", nil, Type::OracleEnhanced::Integer.new)
           end
@@ -91,41 +92,44 @@ 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, nil, 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
             cached = false
+            cursor = nil
             returning_id_col = returning_id_index = nil
-            if without_prepared_statement?(binds)
-              cursor = @connection.prepare(sql)
-            else
-              unless @statements.key?(sql)
-                @statements[sql] = @connection.prepare(sql)
-              end
+            with_retry do
+              if without_prepared_statement?(binds)
+                cursor = @connection.prepare(sql)
+              else
+                unless @statements.key?(sql)
+                  @statements[sql] = @connection.prepare(sql)
+                end
+
+                cursor = @statements[sql]
 
-              cursor = @statements[sql]
+                cursor.bind_params(type_casted_binds)
 
-              cursor.bind_params(type_casted_binds)
+                if /:returning_id/.match?(sql)
+                  # it currently expects that returning_id comes last part of binds
+                  returning_id_index = binds.size
+                  cursor.bind_returning_param(returning_id_index, Integer)
+                end
 
-              if sql =~ /:returning_id/
-                # it currently expects that returning_id comes last part of binds
-                returning_id_index = binds.size
-                cursor.bind_returning_param(returning_id_index, Integer)
+                cached = true
               end
 
-              cached = true
+              cursor.exec_update
             end
 
-            cursor.exec_update
-
             rows = []
             if returning_id_index
               returning_id = cursor.get_returning_param(returning_id_index, Integer).to_i
               rows << [returning_id]
             end
             cursor.close unless cached
-            ActiveRecord::Result.new(returning_id_col || [], rows)
+            build_result(columns: returning_id_col || [], rows: rows)
           end
         end
 
@@ -134,30 +138,32 @@ module ActiveRecord
           type_casted_binds = type_casted_binds(binds)
 
           log(sql, name, binds, type_casted_binds) do
-            cached = false
-            if without_prepared_statement?(binds)
-              cursor = @connection.prepare(sql)
-            else
-              if @statements.key?(sql)
-                cursor = @statements[sql]
+            with_retry do
+              cached = false
+              if without_prepared_statement?(binds)
+                cursor = @connection.prepare(sql)
               else
-                cursor = @statements[sql] = @connection.prepare(sql)
-              end
+                if @statements.key?(sql)
+                  cursor = @statements[sql]
+                else
+                  cursor = @statements[sql] = @connection.prepare(sql)
+                end
 
-              cursor.bind_params(type_casted_binds)
+                cursor.bind_params(type_casted_binds)
 
-              cached = true
-            end
+                cached = true
+              end
 
-            res = cursor.exec_update
-            cursor.close unless cached
-            res
+              res = cursor.exec_update
+              cursor.close unless cached
+              res
+            end
           end
         end
 
         alias :exec_delete :exec_update
 
-        def begin_db_transaction #:nodoc:
+        def begin_db_transaction # :nodoc:
           @connection.autocommit = false
         end
 
@@ -176,27 +182,27 @@ module ActiveRecord
           execute "SET TRANSACTION ISOLATION LEVEL  #{transaction_isolation_levels.fetch(isolation)}"
         end
 
-        def commit_db_transaction #:nodoc:
+        def commit_db_transaction # :nodoc:
           @connection.commit
         ensure
           @connection.autocommit = true
         end
 
-        def exec_rollback_db_transaction #:nodoc:
+        def exec_rollback_db_transaction # :nodoc:
           @connection.rollback
         ensure
           @connection.autocommit = true
         end
 
-        def create_savepoint(name = current_savepoint_name) #:nodoc:
-          execute("SAVEPOINT #{name}")
+        def create_savepoint(name = current_savepoint_name) # :nodoc:
+          execute("SAVEPOINT #{name}", "TRANSACTION")
         end
 
-        def exec_rollback_to_savepoint(name = current_savepoint_name) #:nodoc:
-          execute("ROLLBACK TO #{name}")
+        def exec_rollback_to_savepoint(name = current_savepoint_name) # :nodoc:
+          execute("ROLLBACK TO #{name}", "TRANSACTION")
         end
 
-        def release_savepoint(name = current_savepoint_name) #:nodoc:
+        def release_savepoint(name = current_savepoint_name) # :nodoc:
           # there is no RELEASE SAVEPOINT statement in Oracle
         end
 
@@ -207,7 +213,7 @@ module ActiveRecord
         end
 
         # Inserts the given fixture into the table. Overridden to properly handle lobs.
-        def insert_fixture(fixture, table_name) #:nodoc:
+        def insert_fixture(fixture, table_name) # :nodoc:
           super
 
           if ActiveRecord::Base.pluralize_table_names
@@ -222,17 +228,6 @@ module ActiveRecord
           end
         end
 
-        # fallback to non bulk fixture insert
-        def insert_fixtures(fixtures, table_name)
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `insert_fixtures` is deprecated and will be removed in the next version of Rails.
-            Consider using `insert_fixtures_set` for performance improvement.
-          MSG
-          fixtures.each do |fixture|
-            insert_fixture(fixture, table_name)
-          end
-        end
-
         def insert_fixtures_set(fixture_set, tables_to_delete = [])
           disable_referential_integrity do
             transaction(requires_new: true) do
@@ -253,17 +248,17 @@ module ActiveRecord
         end
 
         # Writes LOB values from attributes for specified columns
-        def write_lobs(table_name, klass, attributes, columns) #:nodoc:
+        def write_lobs(table_name, klass, attributes, columns) # :nodoc:
           id = quote(attributes[klass.primary_key])
           columns.each do |col|
             value = attributes[col.name]
             # changed sequence of next two lines - should check if value is nil before converting to yaml
-            next if value.blank?
-            if klass.attribute_types[col.name].is_a? Type::Serialized
-              value = klass.attribute_types[col.name].serialize(value)
-            end
+            next unless value
+            value = klass.attribute_types[col.name].serialize(value)
+            # value can be nil after serialization because ActiveRecord serializes [] and {} as nil
+            next unless value
             uncached do
-              unless lob_record = select_one(sql = <<-SQL.strip.gsub(/\s+/, " "), "Writable Large Object")
+              unless lob_record = select_one(sql = <<~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
@@ -274,6 +269,16 @@ module ActiveRecord
             end
           end
         end
+
+        private
+          def with_retry
+            @connection.with_retry do
+              yield
+            rescue
+              @statements.clear
+              raise
+            end
+          end
       end
     end
   end