activerecord-jdbc-adapter 70.0-java → 70.1-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79e198f6d1579290fb0eeb3597282367757655bcff41b3e848a788b557573706
-  data.tar.gz: 935a5c332bf06b2d77ca47ae6fc92128cbf450e1c50d64a293ef02ef2a04ad07
+  metadata.gz: '095c3d28051b253315cdd1bec95a83683f3240b0f3315cfb8f9c3c4c0d124f41'
+  data.tar.gz: 13b5d48e4c1b0b16811da5a361cfd9bb687727b5bbad2f5b750540b0232408ee
 SHA512:
-  metadata.gz: b124009ca502a4e24c88a5fc1ff0a8a307e1850db491ae0cf12f0388753cccb575fff87f2421ec725dc9a945e335d2f6f8de1c7734ee6887f887d380e6726a68
-  data.tar.gz: 82faa67a43955a2ff946510c3a77826365eb6dbd3adc7e7c81eecd83da03ce10ca37f0100a32b7089a3ef88014797a2960561851c701d695fe943f11f2712aae
+  metadata.gz: bc4801f970c8651e0ce8076b6544bf56d0e4decd77a9463439a8d5692f767aab896786680197c25b52d510465837290604970689b1b6cba26708385038f1fa39
+  data.tar.gz: 47e1df847914baefffadb80537b1ffd9dfcb218b2f5bfd26addefad934be7b31a0ade446c5838bea88b81897c34b13a7cef8e6b840540e89f4627f950949549c

data/Rakefile

@@ -26,7 +26,7 @@
 
 require 'rake/clean'
 
-CLEAN.include 'derby*', 'test.db.*', '*test.sqlite3', 'test/reports'
+CLEAN.include 'test.db.*', '*test.sqlite3', 'test/reports'
 CLEAN.include 'lib/**/*.jar', 'MANIFEST.MF', '*.log', 'target/*'
 
 task :default => :jar # RubyGems extention will do a bare `rake' e.g. :

data/activerecord-jdbc-adapter.gemspec

@@ -47,6 +47,6 @@ Gem::Specification.new do |gem|
   #gem.add_development_dependency 'test-unit-context', '>= 0.3.0'
   #gem.add_development_dependency 'mocha', '~> 0.13.1'
 
-  gem.rdoc_options = ["--main", "README.md", "-SHN", "-f", "darkfish"]
+  gem.rdoc_options = ["--main", "README.md"]
 end
 

data/lib/arel/visitors/compat.rb

@@ -4,44 +4,16 @@ module Arel
 
       protected
 
-      if ToSql.instance_method('visit').arity == 1
-        def do_visit(x, a); visit(x); end # a = nil
-      else # > AREL 4.0
-        def do_visit(x, a); visit(x, a); end
-      end
+      def do_visit(x, a); visit(x, a); end
 
-      if ToSql.instance_method('visit_Arel_Nodes_SelectCore').arity == 1
-        def do_visit_select_core(x, a) # a = nil
-          visit_Arel_Nodes_SelectCore(x)
-        end
-      else # > AREL 4.0
-        def do_visit_select_core(x, a)
-          visit_Arel_Nodes_SelectCore(x, a)
-        end
+      def do_visit_select_core(x, a)
+        visit_Arel_Nodes_SelectCore(x, a)
       end
 
       private
 
-      if ArJdbc::AR42
-        if Arel::VERSION < '6.0.2'
-          def limit_for(limit_or_node)
-            if limit_or_node.respond_to?(:expr)
-              expr = limit_or_node.expr
-              # NOTE(uwe): Different behavior for Arel 6.0.0 and 6.0.2
-              expr.respond_to?(:value) ? expr.value.to_i : expr.to_i
-            else
-              limit_or_node
-            end
-          end
-        else
-          def limit_for(limit_or_node)
-            limit_or_node.respond_to?(:expr) ? limit_or_node.expr.to_i : limit_or_node
-          end
-        end
-      else
-        def limit_for(limit_or_node)
-          limit_or_node.respond_to?(:expr) ? limit_or_node.expr.to_i : limit_or_node
-        end
+      def limit_for(limit_or_node)
+        limit_or_node.respond_to?(:expr) ? limit_or_node.expr.to_i : limit_or_node
       end
       module_function :limit_for
 

data/lib/arel/visitors/h2.rb

@@ -7,19 +7,7 @@ module Arel
       def visit_Arel_Nodes_SelectStatement(o, *)
         o.limit ||= Arel::Nodes::Limit.new(-1) if o.offset
         super
-      end if ArJdbc::AR42
-
-      def limit_offset sql, o
-        offset = o.offset || 0
-        offset = offset.expr unless (offset.nil? || offset == 0)
-        if limit = o.limit
-          "SELECT LIMIT #{offset} #{limit_for(limit)} #{sql[7..-1]}"
-        elsif offset > 0
-          "SELECT LIMIT #{offset} -1 #{sql[7..-1]}" # removes "SELECT "
-        else
-          sql
-        end
-      end unless ArJdbc::AR42
+      end
     end
   end
 end

data/lib/arel/visitors/hsqldb.rb

@@ -6,27 +6,7 @@ module Arel
       def visit_Arel_Nodes_SelectStatement(o, *)
         o.limit ||= Arel::Nodes::Limit.new(0) if o.offset
         super
-      end if ArJdbc::AR42
-
-      def visit_Arel_Nodes_SelectStatement o, a = nil
-        sql = limit_offset(o.cores.map { |x| do_visit_select_core x, a }.join, o)
-        sql << " ORDER BY #{o.orders.map { |x| do_visit x, a }.join(', ')}" unless o.orders.empty?
-        sql
-      end unless ArJdbc::AR42
-
-      private
-
-      def limit_offset sql, o
-        offset = o.offset || 0
-        offset = offset.expr unless (offset.nil? || offset == 0)
-        if limit = o.limit
-          "SELECT LIMIT #{offset} #{limit_for(limit)} #{sql[7..-1]}"
-        elsif offset > 0
-          "SELECT LIMIT #{offset} 0 #{sql[7..-1]}" # removes "SELECT "
-        else
-          sql
-        end
-      end unless ArJdbc::AR42
+      end
     end
   end
 end

data/lib/arel/visitors/sql_server.rb

@@ -11,44 +11,6 @@ module Arel
 
       private
 
-      def visit_Arel_Nodes_SelectStatement(*args) # [o] AR <= 4.0 [o, a] on 4.1
-        o, a = args.first, args.last
-
-        return _visit_Arel_Nodes_SelectStatement(*args) if ! o.limit && ! o.offset
-
-        unless o.orders.empty?
-          select_order_by = do_visit_columns o.orders, a, 'ORDER BY '
-        end
-
-        select_count = false; sql = ''
-        o.cores.each do |x|
-          x = x.dup
-          core_order_by = select_order_by || determine_order_by(x, a)
-          if select_count? x
-            x.projections = [
-              Arel::Nodes::SqlLiteral.new(core_order_by ? over_row_num(core_order_by) : '*')
-            ]
-            select_count = true
-          else
-            # NOTE: this should really be added here and we should built the
-            # wrapping SQL but than #replace_limit_offset! assumes it does that
-            # ... MS-SQL adapter code seems to be 'hacked' by a lot of people
-            #x.projections << Arel::Nodes::SqlLiteral.new over_row_num(order_by)
-          end
-          sql << do_visit_select_core(x, a)
-        end
-
-        #sql = "SELECT _t.* FROM (#{sql}) as _t WHERE #{get_offset_limit_clause(o)}"
-        select_order_by ||= "ORDER BY #{@connection.determine_order_clause(sql)}"
-        replace_limit_offset!(sql, limit_for(o.limit), o.offset && o.offset.value.to_i, select_order_by)
-
-        sql = "SELECT COUNT(*) AS count_id FROM (#{sql}) AS subquery" if select_count
-
-        add_lock!(sql, :lock => o.lock && true)
-
-        sql
-      end unless ArJdbc::AR42
-
       # @private
       MAX_LIMIT_VALUE = 9_223_372_036_854_775_807
 
@@ -60,14 +22,6 @@ module Arel
         super
       end
 
-      def visit_Arel_Nodes_Lock o, a = nil
-        # MS-SQL doesn't support "SELECT...FOR UPDATE".  Instead, it needs
-        # WITH(ROWLOCK,UPDLOCK) specified after each table in the FROM clause.
-        #
-        # we return nothing here and add the appropriate stuff with #add_lock!
-        #do_visit o.expr, a
-      end unless ArJdbc::AR42
-
       def visit_Arel_Nodes_Top o, a = nil
         # `top` wouldn't really work here:
         #   User.select("distinct first_name").limit(10)
@@ -76,29 +30,6 @@ module Arel
         a || ''
       end
 
-      def visit_Arel_Nodes_Limit o, a = nil
-        "TOP (#{do_visit o.expr, a})"
-      end unless ArJdbc::AR42
-
-      def visit_Arel_Nodes_Ordering o, a = nil
-        expr = do_visit o.expr, a
-        if o.respond_to?(:direction)
-          "#{expr} #{o.ascending? ? 'ASC' : 'DESC'}"
-        else
-          expr
-        end
-      end unless ArJdbc::AR42
-
-      def visit_Arel_Nodes_Bin o, a = nil
-        expr = o.expr; sql = do_visit expr, a
-        if expr.respond_to?(:val) && expr.val.is_a?(Numeric)
-          sql
-        else
-          sql << " #{::ArJdbc::MSSQL.cs_equality_operator} "
-          sql
-        end
-      end unless ArJdbc::AR42
-
       private
 
       def self.possibly_private_method_defined?(name)
@@ -140,25 +71,7 @@ module Arel
           visit(x, sql); sql << ', ' unless i == last
         end
         sql.value
-      end if ArJdbc::AR42
-
-      def do_visit_columns(colls, a, sql)
-        non_simple_order = /\sASC|\sDESC|\sCASE|\sCOLLATE|[\.,\[\(]/i # MIN(width)
-
-        last = colls.size - 1
-        colls.each_with_index do |x, i|
-          coll = do_visit(x, a)
-
-          if coll !~ non_simple_order && coll.to_i == 0
-            sql << @connection.quote_column_name(coll)
-          else
-            sql << coll
-          end
-
-          sql << ', ' unless i == last
-        end
-        sql
-      end if Arel::VERSION < '4.0.0'
+      end
 
       def over_row_num order_by
         "ROW_NUMBER() OVER (#{order_by}) as _row_num"
@@ -174,20 +87,6 @@ module Arel
         end
       end
 
-      def table_from_select_core core
-        table_finder = lambda do |x|
-          case x
-          when Arel::Table
-            x
-          when Arel::Nodes::SqlLiteral
-            Arel::Table.new(x, @engine)
-          when Arel::Nodes::Join
-            table_finder.call(x.left)
-          end
-        end
-        table_finder.call(core.froms)
-      end if ActiveRecord::VERSION::STRING < '3.2'
-
       def primary_key_from_table t
         return unless t
         return t.primary_key if t.primary_key
@@ -219,7 +118,7 @@ module Arel
       include ArJdbc::MSSQL::LimitHelpers::SqlServer2000ReplaceLimitOffset
     end
 
-    load 'arel/visitors/sql_server/ng42.rb' if ArJdbc::AR42
+    load 'arel/visitors/sql_server/ng42.rb'
 
   end
 end

data/lib/arjdbc/abstract/database_statements.rb

@@ -10,6 +10,8 @@ module ArJdbc
       NO_BINDS = [].freeze
 
       def exec_insert(sql, name = nil, binds = NO_BINDS, pk = nil, sequence_name = nil)
+        sql = transform_query(sql)
+
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -31,6 +33,8 @@ module ArJdbc
       # It appears that at this point (AR 5.0) "prepare" should only ever be true
       # if prepared statements are enabled
       def exec_query(sql, name = nil, binds = NO_BINDS, prepare: false, async: false)
+        sql = transform_query(sql)
+
         if preventing_writes? && write_query?(sql)
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -52,6 +56,8 @@ module ArJdbc
       end
 
       def exec_update(sql, name = nil, binds = NO_BINDS)
+        sql = transform_query(sql)
+
         if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
@@ -70,6 +76,8 @@ module ArJdbc
       alias :exec_delete :exec_update
 
       def execute(sql, name = nil, async: false)
+        sql = transform_query(sql)
+        
         if preventing_writes? && write_query?(sql)
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end

data/lib/arjdbc/discover.rb

@@ -23,26 +23,6 @@ module ArJdbc
     require('arjdbc/sqlite3') || true if name =~ /sqlite/i
   end
   
-  # Other supported adapters :
-
-  extension :Derby do |name, config|
-    if name =~ /derby/i
-      require 'arjdbc/derby'
-
-      if config && config[:username].nil? # set the database schema name (:username) :
-        begin
-          ArJdbc.with_meta_data_from_data_source_if_any(config) do
-            |meta_data| config[:username] = meta_data.getUserName
-          end
-        rescue => e
-          ArJdbc.warn("failed to set :username from (Derby) database meda-data: #{e.inspect}")
-        end
-      end
-
-      true
-    end
-  end
-
   extension :H2 do |name|
     require('arjdbc/h2') || true if name =~ /\.h2\./i
   end
@@ -54,51 +34,4 @@ module ArJdbc
   extension :MSSQL do |name|
     require('arjdbc/mssql') || true if name =~ /sqlserver|tds|Microsoft SQL/i
   end
-
-  extension :DB2 do |name, config|
-    if name =~ /db2/i && name !~ /as\/?400/i && config[:url] !~ /^jdbc:derby:net:/
-      require 'arjdbc/db2'
-      true
-    end
-  end
-  
-  extension :AS400 do |name, config|
-    # The native JDBC driver always returns "DB2 UDB for AS/400"
-    if name =~ /as\/?400/i
-      require 'arjdbc/db2'
-      require 'arjdbc/db2/as400'
-      true
-    end
-  end
-
-  # NOTE: following ones are likely getting deprecated :
-  
-  extension :FireBird do |name|
-    if name =~ /firebird/i
-      require 'arjdbc/firebird'
-      true
-    end
-  end
-
-  extension :Sybase do |name|
-    if name =~ /sybase|tds/i
-      require 'arjdbc/sybase'
-      true
-    end
-  end
-  
-  extension :Informix do |name|
-    if name =~ /informix/i
-      require 'arjdbc/informix'
-      true
-    end
-  end
-
-  extension :Mimer do |name|
-    if name =~ /mimer/i
-      require 'arjdbc/mimer'
-      true
-    end
-  end
-  
 end

data/lib/arjdbc/jdbc/column.rb

@@ -28,21 +28,6 @@ module ActiveRecord
           end
         end
 
-        if ArJdbc::AR52
-          # undefined method `cast' for #<ActiveRecord::ConnectionAdapters::SqlTypeMetadata> on AR52
-        else
-          default = args[0].cast(default)
-
-          sql_type = args.delete_at(1)
-          type = args.delete_at(0)
-
-          args.unshift(SqlTypeMetadata.new(:sql_type => sql_type, :type => type))
-        end
-
-        # super <= 4.1: (name, default, sql_type = nil, null = true)
-        # super >= 4.2: (name, default, cast_type, sql_type = nil, null = true)
-        # super >= 5.0: (name, default, sql_type_metadata = nil, null = true)
-
         super(name, default, *args)
         init_column(name, default, *args)
       end
@@ -80,18 +65,8 @@ module ActiveRecord
       end
 
       class << self
-
-        include Jdbc::TypeCast if ::ActiveRecord::VERSION::STRING >= '4.2'
-
-        if ActiveRecord::VERSION::MAJOR > 3 && ActiveRecord::VERSION::STRING < '4.2'
-
-          # @private provides compatibility between AR 3.x/4.0 API
-          def string_to_date(value); value_to_date(value) end
-
-        end
-
+        include Jdbc::TypeCast
       end
-
     end
   end
 end

data/lib/arjdbc/jdbc.rb

@@ -1,13 +1,6 @@
 require 'active_support/deprecation'
 
 module ArJdbc
-
-  # @private
-  AR42 = ::ActiveRecord::VERSION::STRING >= '4.2'
-
-  # @private
-  AR52 = ::ActiveRecord::VERSION::STRING >= '5.2'
-
   class << self
 
     # @private Internal API

data/lib/arjdbc/oracle/adapter.rb

@@ -285,7 +285,7 @@ module ArJdbc
           execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
         end
       end
-    end if AR42
+    end
 
     # @private
     def add_index_options(table_name, column_name, options = {})
@@ -309,7 +309,7 @@ module ArJdbc
 
       quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
       [ index_name, index_type, quoted_column_names, tablespace, index_options ]
-    end if AR42
+    end
 
     # @override
     def remove_index(table_name, options = {})
@@ -327,12 +327,7 @@ module ArJdbc
       end
       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)}"
-    end if AR42
-
-    # @private
-    def remove_index(table_name, options = {})
-      execute "DROP INDEX #{index_name(table_name, options)}"
-    end unless AR42
+    end
 
     def change_column_default(table_name, column_name, default)
       execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
@@ -361,25 +356,11 @@ module ArJdbc
         "RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
     end
 
-    if ActiveRecord::VERSION::MAJOR >= 4
-
     # @override
     def remove_column(table_name, column_name, type = nil, options = {})
       do_remove_column(table_name, column_name)
     end
 
-    else
-
-    # @override
-    def remove_column(table_name, *column_names)
-      for column_name in column_names.flatten
-        do_remove_column(table_name, column_name)
-      end
-    end
-    alias remove_columns remove_column
-
-    end
-
     def do_remove_column(table_name, column_name)
       execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)}"
     end

data/lib/arjdbc/postgresql/adapter.rb

@@ -21,6 +21,7 @@ require 'arjdbc/abstract/transaction_support'
 require 'arjdbc/postgresql/base/array_decoder'
 require 'arjdbc/postgresql/base/array_encoder'
 require 'arjdbc/postgresql/name'
+require 'active_model'
 
 module ArJdbc
   # Strives to provide Rails built-in PostgreSQL adapter (API) compatibility.
@@ -320,6 +321,38 @@ module ArJdbc
       exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
     end
 
+    # Returns a list of defined enum types, and their values.
+    def enum_types
+      query = <<~SQL
+          SELECT
+            type.typname AS name,
+            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
+          FROM pg_enum AS enum
+          JOIN pg_type AS type
+            ON (type.oid = enum.enumtypid)
+          GROUP BY type.typname;
+      SQL
+      exec_query(query, "SCHEMA").cast_values
+    end
+
+    # Given a name and an array of values, creates an enum type.
+    def create_enum(name, values)
+      sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      query = <<~SQL
+          DO $$
+          BEGIN
+              IF NOT EXISTS (
+                SELECT 1 FROM pg_type t
+                WHERE t.typname = '#{name}'
+              ) THEN
+                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
+              END IF;
+          END
+          $$;
+      SQL
+      exec_query(query)
+    end
+
     # Returns the configured supported identifier length supported by PostgreSQL
     def max_identifier_length
       @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
@@ -672,6 +705,37 @@ module ActiveRecord::ConnectionAdapters
   class PostgreSQLAdapter < AbstractAdapter
     class_attribute :create_unlogged_tables, default: false
 
+    ##
+    # :singleton-method:
+    # PostgreSQL allows the creation of "unlogged" tables, which do not record
+    # data in the PostgreSQL Write-Ahead Log. This can make the tables faster,
+    # but significantly increases the risk of data loss if the database
+    # crashes. As a result, this should not be used in production
+    # environments. If you would like all created tables to be unlogged in
+    # the test environment you can add the following line to your test.rb
+    # file:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
+    class_attribute :create_unlogged_tables, default: false
+
+    ##
+    # :singleton-method:
+    # PostgreSQL supports multiple types for DateTimes. By default, if you use +datetime+
+    # in migrations, Rails will translate this to a PostgreSQL "timestamp without time zone".
+    # Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to
+    # store DateTimes as "timestamp with time zone":
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz
+    #
+    # Or if you are adding a custom type:
+    #
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
+    #   ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type
+    #
+    # If you're using +:ruby+ as your +config.active_record.schema_format+ and you change this
+    # setting, you should immediately run <tt>bin/rails db:migrate</tt> to update the types in your schema.rb.
+    class_attribute :datetime_type, default: :timestamp
+
     # Try to use as much of the built in postgres logic as possible
     # maybe someday we can extend the actual adapter
     include ActiveRecord::ConnectionAdapters::PostgreSQL::ReferentialIntegrity
@@ -735,11 +799,96 @@ module ActiveRecord::ConnectionAdapters
 
     private
 
-    # Prepared statements aren't schema aware so we need to make sure we
-    # store different PreparedStatement objects for different schemas
+    FEATURE_NOT_SUPPORTED = "0A000" # :nodoc:
+
+    def execute_and_clear(sql, name, binds, prepare: false, async: false)
+      sql = transform_query(sql)
+      check_if_write_query(sql)
+
+      if !prepare || without_prepared_statement?(binds)
+        result = exec_no_cache(sql, name, binds, async: async)
+      else
+        result = exec_cache(sql, name, binds, async: async)
+      end
+      begin
+        ret = yield result
+      ensure
+        # Is this really result in AR PG?
+#        result.clear
+      end
+      ret
+    end
+
+    def exec_no_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+
+      # make sure we carry over any changes to ActiveRecord.default_timezone that have been
+      # made since we established the connection
+      update_typemap_for_default_timezone
+
+      type_casted_binds = type_casted_binds(binds)
+      log(sql, name, binds, type_casted_binds, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_params(sql, type_casted_binds)
+        end
+      end
+    end
+
+    def exec_cache(sql, name, binds, async: false)
+      materialize_transactions
+      mark_transaction_written_if_write(sql)
+      update_typemap_for_default_timezone
+
+      stmt_key = prepare_statement(sql, binds)
+      type_casted_binds = type_casted_binds(binds)
+
+      log(sql, name, binds, type_casted_binds, stmt_key, async: async) do
+        ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+          @connection.exec_prepared(stmt_key, type_casted_binds)
+        end
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless is_cached_plan_failure?(e)
+
+      # Nothing we can do if we are in a transaction because all commands
+      # will raise InFailedSQLTransaction
+      if in_transaction?
+        raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
+      else
+        @lock.synchronize do
+          # outside of transactions we can simply flush this query and retry
+          @statements.delete sql_key(sql)
+        end
+        retry
+      end
+    end
+
+    # Annoyingly, the code for prepared statements whose return value may
+    # have changed is FEATURE_NOT_SUPPORTED.
+    #
+    # This covers various different error types so we need to do additional
+    # work to classify the exception definitively as a
+    # ActiveRecord::PreparedStatementCacheExpired
+    #
+    # Check here for more details:
+    # https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
+    def is_cached_plan_failure?(e)
+      pgerror = e.cause
+      pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
+        pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "RevalidateCachedQuery"
+    rescue
+      false
+    end
+
+    def in_transaction?
+      open_transactions > 0
+    end
+
+    # Returns the statement identifier for the client side cache
+    # of statements
     def sql_key(sql)
       "#{schema_search_path}-#{sql}"
     end
-
   end
 end