use a params hash so we know what bind parameters are used

activerecord/lib/active_record/relation/query_methods.rb

@@ -948,7 +948,7 @@ def build_where(opts, other = [])
     def create_binds(opts, idx)
       bindable, non_binds = opts.partition do |column, value|
         case value
-        when String, Integer
+        when String, Integer, ActiveRecord::StatementCache::Substitute
           @klass.columns_hash.include? column.to_s
         else
           false

activerecord/lib/active_record/statement_cache.rb

@@ -14,25 +14,64 @@ module ActiveRecord
   # The relation returned by the block is cached, and for each +execute+ call the cached relation gets duped.
   # Database is queried when +to_a+ is called on the relation.
   class StatementCache
+    Substitute = Struct.new :name
+
+    class Params
+      def [](name); Substitute.new name; end
+    end
+
+    class BindMap
+      def initialize(bind_values)
+        @value_map   = {}
+        @bind_values = bind_values
+
+        bind_values.each_with_index do |(column, value), i|
+          if Substitute === value
+            @value_map[value.name] = i
+          end
+        end
+      end
+
+      def bind(values)
+        bvs = @bind_values.map { |pair| pair.dup }
+        values.each { |k,v| bvs[@value_map[k]][1] = v }
+        bvs
+      end
+    end
+
     def initialize(block = Proc.new)
       @mutex    = Mutex.new
       @relation = nil
+      @sql      = nil
+      @binds    = nil
       @block    = block
+      @params   = Params.new
     end
 
-    def execute(*vals)
-      rel = relation vals
-      @mutex.synchronize do
-        rel.set_binds vals
-        rel.to_a
-      end
+    def execute(params)
+      rel = relation @params
+
+      arel  = rel.arel
+      klass = rel.klass
+      bv    = binds rel
+
+      klass.find_by_sql sql(klass, arel, bv), bv.bind(params)
     end
+    alias :call :execute
 
     private
-    def relation(values)
-      @relation || @mutex.synchronize {
-        @block.call(*values)
+    def binds(rel)
+      @binds || @mutex.synchronize { @binds ||= BindMap.new rel.bind_values }
+    end
+
+    def sql(klass, arel, bv)
+      @sql || @mutex.synchronize {
+        @sql ||= klass.connection.to_sql arel, bv
       }
     end
+
+    def relation(values)
+      @relation || @mutex.synchronize { @relation ||= @block.call(values) }
+    end
   end
 end

activerecord/test/cases/statement_cache_test.rb

@@ -7,6 +7,7 @@
 module ActiveRecord
   class StatementCacheTest < ActiveRecord::TestCase
     def setup
+      skip if current_adapter?(:Mysql2Adapter)
       @connection = ActiveRecord::Base.connection
     end
 
@@ -15,13 +16,13 @@ def test_statement_cache
       Book.create(name: "my book")
       Book.create(name: "my other book")
 
-      cache = StatementCache.new do |name|
-        Book.where(:name => name)
+      cache = StatementCache.new do |params|
+        Book.where(:name => params[:name])
       end
 
-      b = cache.execute "my book"
+      b = cache.execute name: "my book"
       assert_equal "my book", b[0].name
-      b = cache.execute "my other book"
+      b = cache.execute name: "my other book"
       assert_equal "my other book", b[0].name
     end
 
@@ -30,13 +31,13 @@ def test_statement_cache_id
       b1 = Book.create(name: "my book")
       b2 = Book.create(name: "my other book")
 
-      cache = StatementCache.new do |id|
-        Book.where(id: id)
+      cache = StatementCache.new do |params|
+        Book.where(id: params[:id])
       end
 
-      b = cache.execute b1.id
+      b = cache.execute id: b1.id
       assert_equal b1.name, b[0].name
-      b = cache.execute b2.id
+      b = cache.execute id: b2.id
       assert_equal b2.name, b[0].name
     end
 
@@ -53,18 +54,18 @@ def test_find_or_create_by
     #End
 
     def test_statement_cache_with_simple_statement
-      cache = ActiveRecord::StatementCache.new do
+      cache = ActiveRecord::StatementCache.new do |params|
         Book.where(name: "my book").where("author_id > 3")
       end
 
       Book.create(name: "my book", author_id: 4)
 
-      books = cache.execute
+      books = cache.execute({})
       assert_equal "my book", books[0].name
     end
 
     def test_statement_cache_with_complex_statement
-      cache = ActiveRecord::StatementCache.new do
+      cache = ActiveRecord::StatementCache.new do |params|
         Liquid.joins(:molecules => :electrons).where('molecules.name' => 'dioxane', 'electrons.name' => 'lepton')
       end
 
@@ -72,12 +73,12 @@ def test_statement_cache_with_complex_statement
       molecule = salty.molecules.create(name: 'dioxane')
       molecule.electrons.create(name: 'lepton')
 
-      liquids = cache.execute
+      liquids = cache.execute({})
       assert_equal "salty", liquids[0].name
     end
 
     def test_statement_cache_values_differ
-      cache = ActiveRecord::StatementCache.new do
+      cache = ActiveRecord::StatementCache.new do |params|
         Book.where(name: "my book")
       end
 
@@ -85,13 +86,13 @@ def test_statement_cache_values_differ
         Book.create(name: "my book")
       end
 
-      first_books = cache.execute
+      first_books = cache.execute({})
 
       3.times do
         Book.create(name: "my book")
       end
 
-      additional_books = cache.execute
+      additional_books = cache.execute({})
       assert first_books != additional_books
     end
   end