activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/test/simple.rb

@@ -6,7 +6,24 @@ ActiveRecord::Base.default_timezone = :utc
 Time.zone = 'Moscow' if Time.respond_to?(:zone)
 
 module MigrationSetup
-  def setup
+
+  def setup 
+    setup!
+  end
+
+  def teardown
+    teardown!
+  end
+
+  def setup!
+    MigrationSetup.setup!
+  end
+
+  def teardown!
+    MigrationSetup.teardown!
+  end
+
+  def self.setup!
     DbTypeMigration.up
     CreateStringIds.up
     CreateEntries.up
@@ -15,10 +32,9 @@ module MigrationSetup
     CreateValidatesUniquenessOf.up
     CreateThings.up
     CreateCustomPkName.up
-    @connection = ActiveRecord::Base.connection
   end
 
-  def teardown
+  def self.teardown!
     DbTypeMigration.down
     CreateStringIds.down
     CreateEntries.down
@@ -27,12 +43,13 @@ module MigrationSetup
     CreateValidatesUniquenessOf.down
     CreateThings.down
     CreateCustomPkName.down
-    ActiveRecord::Base.clear_active_connections!
   end
+
 end
 
 module FixtureSetup
   include MigrationSetup
+
   def setup
     super
     @title = "First post!"
@@ -80,7 +97,7 @@ module DirtyAttributeTests
 
     with_partial_updates Entry, true do
       assert_queries(0) { 2.times { entry.save! } }
-      assert_equal old_updated_on, entry.reload.updated_on
+      assert_datetime_equal old_updated_on, entry.reload.updated_on
 
       assert_queries(1) { entry.title = 'bar'; entry.save! }
       assert_not_equal old_updated_on, entry.reload.updated_on
@@ -100,14 +117,6 @@ end
 module SimpleTestMethods
   include FixtureSetup
 
-  def test_substitute_binds_has_no_side_effect_on_binds_parameter
-    binds = [[Entry.columns_hash['title'], 'test1']]
-    binds2 = binds.dup
-    sql = 'select * from entries where title = ?'
-    Entry.connection.substitute_binds(sql, binds)
-    assert_equal binds2, binds
-  end
-
   def test_entries_created
     assert ActiveRecord::Base.connection.tables.find{|t| t =~ /^entries$/i}, "entries not created"
   end
@@ -161,12 +170,12 @@ module SimpleTestMethods
   end
 
   def test_create_partial_new_entry
-    new_entry = Entry.create(:title => "Blah")
-    new_entry2 = Entry.create(:title => "Bloh")
+    Entry.create(:title => "Blah")
+    Entry.create(:title => "Bloh")
   end
 
   def test_find_and_update_entry
-    post = Entry.find(:first)
+    post = Entry.first
     assert_equal @title, post.title
     assert_equal @content, post.content
     assert_equal @rating, post.rating
@@ -174,13 +183,13 @@ module SimpleTestMethods
     post.title = @new_title
     post.save
 
-    post = Entry.find(:first)
+    post = Entry.first
     assert_equal @new_title, post.title
   end
 
   def test_destroy_entry
     prev_count = Entry.count
-    post = Entry.find(:first)
+    post = Entry.first
     post.destroy
 
     assert_equal prev_count - 1, Entry.count
@@ -197,6 +206,7 @@ module SimpleTestMethods
   end
 
   if Time.respond_to?(:zone)
+    
     def test_save_time_with_utc
       current_zone = Time.zone
       default_zone = ActiveRecord::Base.default_timezone
@@ -205,21 +215,24 @@ module SimpleTestMethods
       my_time = Time.local now.year, now.month, now.day, now.hour, now.min, now.sec
       m = DbType.create! :sample_datetime => my_time
       m.reload
+
       assert_equal my_time, m.sample_datetime
     rescue
       Time.zone = current_zone
       ActiveRecord::Base.default_timezone = default_zone
     end
 
-    def test_save_time
+    def test_save_time_with_zone
       t = Time.now
       #precision will only be expected to the second.
-      time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
-      e = DbType.find(:first)
+      original_time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
+      time = original_time.in_time_zone
+      e = DbType.first
       e.sample_datetime = time
       e.save!
-      e = DbType.find(:first)
-      assert_equal time.in_time_zone, e.sample_datetime
+      e = DbType.first
+
+      assert_equal time, e.sample_datetime
     end
 
     def test_save_date_time
@@ -227,136 +240,148 @@ module SimpleTestMethods
       #precision will only be expected to the second.
       time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
       datetime = time.to_datetime
-      e = DbType.find(:first)
+      e = DbType.first
       e.sample_datetime = datetime
       e.save!
-      e = DbType.find(:first)
+      e = DbType.first
       assert_equal time, e.sample_datetime.localtime
     end
-
-    def test_save_time_with_zone
-      t = Time.now
-      #precision will only be expected to the second.
-      original_time = Time.local(t.year, t.month, t.day, t.hour, t.min, t.sec)
-      time = original_time.in_time_zone
-      e = DbType.find(:first)
-      e.sample_datetime = time
-      e.save!
-      e = DbType.find(:first)
-      assert_equal time, e.sample_datetime
-    end
+    
   end
 
-  def test_save_float
-    e = DbType.find(:first)
-    e.sample_float = 12.0
+  def test_save_time
+    # Ruby doesn't have a plain Time class without a date.
+    time = Time.utc(2012, 12, 18, 21, 10, 15, 0)
+    e = DbType.first
+    e.sample_time = time
     e.save!
+    e = DbType.first
 
-    e = DbType.find(:first)
-    assert_equal(12.0, e.sample_float)
+    assert_time_equal time, e.sample_time
   end
+  
+  def test_save_timestamp
+    timestamp = Time.utc(2012, 12, 18, 21, 10, 15, 0)
+    e = DbType.first
+    e.sample_timestamp = timestamp
+    e.save!
+    e = DbType.first
+    assert_timestamp_equal timestamp, e.sample_timestamp
+  end
+  
+  # TODO we do not support precision beyond seconds !
+  # def test_save_timestamp_with_usec
+  #   timestamp = Time.utc(1942, 11, 30, 01, 53, 59, 123_456)
+  #   e = DbType.first
+  #   e.sample_timestamp = timestamp
+  #   e.save!
+  #   e = DbType.first
+  #   assert_timestamp_equal timestamp, e.sample_timestamp
+  # end
 
   def test_save_date
     date = Date.new(2007)
-    e = DbType.find(:first)
+    e = DbType.first
     e.sample_date = date
     e.save!
-    e = DbType.find(:first)
-    if DbType.columns_hash["sample_date"].type == :datetime
-      # Oracle doesn't distinguish btw date/datetime
-      assert_equal date, e.sample_date.to_date
-    else
-      assert_equal date, e.sample_date
-    end
+    e = DbType.first
+    assert_date_type e.sample_date
+    assert_date_equal date, e.sample_date
+  end
+
+  def test_save_float
+    e = DbType.first
+    e.sample_float = 12.0
+    e.save!
+
+    e = DbType.first
+    assert_equal(12.0, e.sample_float)
   end
 
   def test_boolean
     # An unset boolean should default to nil
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal(nil, e.sample_boolean)
 
     e.sample_boolean = true
     e.save!
 
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal(true, e.sample_boolean)
   end
 
   def test_integer
     # An unset boolean should default to nil
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal(nil, e.sample_integer)
 
     e.sample_integer = 10
     e.save!
 
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal(10, e.sample_integer)
   end
 
   def test_text
     # An unset boolean should default to nil
-    e = DbType.find(:first)
+    e = DbType.first
 
-    # Oracle adapter initializes all CLOB fields with empty_clob() function,
-    # so they all have a initial value of an empty string ''
-    assert_equal(nil, e.sample_text) unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
+    assert_null_text e.sample_text
 
     e.sample_text = "ooop?"
     e.save!
 
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal("ooop?", e.sample_text)
   end
 
   def test_string
-    e = DbType.find(:first)
+    e = DbType.first
+
+    assert_empty_string e.sample_string
 
-    # An empty string is treated as a null value in Oracle: http://www.techonthenet.com/oracle/questions/empty_null.php
-    assert_equal('', e.sample_string) unless ActiveRecord::Base.connection.adapter_name =~ /oracle/i
     e.sample_string = "ooop?"
     e.save!
 
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal("ooop?", e.sample_string)
   end
 
   def test_save_binary
     #string is 60_000 bytes
-    binary_string = "\000ABCDEFGHIJKLMNOPQRSTUVWXYZ'\001\003"*1#2_000
-    e = DbType.find(:first)
+    binary_string = "\000ABCDEFGHIJKLMNOPQRSTUVWXYZ'\001\003" * 1 # 2_000
+    e = DbType.first
     e.sample_binary = binary_string
     e.save!
-    e = DbType.find(:first)
+    e = DbType.first
     assert_equal binary_string, e.sample_binary
   end
 
-  def test_default_decimal_should_keep_fractional_part
-    expected = 7.3
-    db_type = DbType.new(:sample_small_decimal => expected)
-    assert db_type.save
-    db_type = DbType.find(db_type.id)
-    assert_equal BigDecimal.new(expected.to_s), db_type.sample_small_decimal
-  end
-
-  def test_decimal_with_scale
+  def test_small_decimal
     test_value = 7.3
     db_type = DbType.new(:sample_small_decimal => test_value)
-    assert db_type.save
+    db_type.save!
     db_type = DbType.find(db_type.id)
     assert_kind_of BigDecimal, db_type.sample_small_decimal
     assert_equal BigDecimal.new(test_value.to_s), db_type.sample_small_decimal
   end
 
-  def test_decimal_with_zero_scale
+  def test_decimal # _with_zero_scale
     test_value = 7000.0
-    db_type = DbType.new(:sample_decimal => test_value)
-    assert db_type.save
+    db_type = DbType.create!(:sample_decimal => test_value)
     db_type = DbType.find(db_type.id)
     assert_kind_of Integer, db_type.sample_decimal
     assert_equal test_value.to_i, db_type.sample_decimal
   end
 
+  def test_big_decimal
+    test_value = 9876543210_9876543210_9876543210.0
+    db_type = DbType.create!(:big_decimal => test_value)
+    db_type = DbType.find(db_type.id)
+    assert_kind_of Bignum, db_type.big_decimal
+    assert_equal test_value, db_type.big_decimal
+  end
+  
   def test_negative_default_value
     assert_equal(-1, DbType.columns_hash['sample_integer_neg_default'].default)
     assert_equal(-1, DbType.new.sample_integer_neg_default)
@@ -364,33 +389,24 @@ module SimpleTestMethods
 
   def test_indexes
     # Only test indexes if we have implemented it for the particular adapter
-    if @connection.respond_to?(:indexes)
-      indexes = @connection.indexes(:entries)
+    if connection.respond_to?(:indexes)
+      indexes = connection.indexes(:entries)
       assert_equal(0, indexes.size)
 
       index_name = "entries_index"
-      @connection.add_index(:entries, :updated_on, :name => index_name)
+      connection.add_index(:entries, :updated_on, :name => index_name)
 
-      indexes = @connection.indexes(:entries)
+      indexes = connection.indexes(:entries)
       assert_equal(1, indexes.size)
       assert_equal "entries", indexes.first.table.to_s
       assert_equal index_name, indexes.first.name
       assert !indexes.first.unique
       assert_equal ["updated_on"], indexes.first.columns
+    else
+      puts "indexes not implemented for adapter: #{connection}"
     end
   end
 
-  def test_dumping_schema
-    require 'active_record/schema_dumper'
-    @connection.add_index :entries, :title
-    StringIO.open do |io|
-      ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, io)
-      assert_match(/add_index "entries",/, io.string)
-    end
-    @connection.remove_index :entries, :title
-
-  end
-
   def test_nil_values
     test = AutoId.create('value' => '')
     assert_nil AutoId.find(test.id).value
@@ -412,14 +428,15 @@ module SimpleTestMethods
 
   def test_reconnect
     assert_equal 1, Entry.count
-    @connection.reconnect!
+    ActiveRecord::Base.connection.reconnect!
     assert_equal 1, Entry.count
   end
 
-  if jruby?
+  if defined?(JRUBY_VERSION)
     def test_connection_valid
-      assert_raises(ActiveRecord::JDBCError) do
-        @connection.raw_connection.with_connection_retry_guard do |c|
+      assert_raise(ActiveRecord::JDBCError) do
+        connection = ActiveRecord::Base.connection
+        connection.raw_connection.with_connection_retry_guard do |c|
           begin
             stmt = c.createStatement
             stmt.execute "bogus sql"
@@ -433,7 +450,7 @@ module SimpleTestMethods
     class Animal < ActiveRecord::Base; end
 
     def test_fetching_columns_for_nonexistent_table_should_raise
-      assert_raises(ActiveRecord::ActiveRecordError,
+      assert_raise(ActiveRecord::ActiveRecordError,
                     ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
         Animal.columns
       end
@@ -534,22 +551,132 @@ module SimpleTestMethods
     end
   end
 
+  def test_substitute_binds_has_no_side_effect_on_binds_parameter
+    binds = [ [ Entry.columns_hash['title'], 'test1' ] ]
+    binds_dup = binds.dup
+    sql = 'SELECT * FROM entries WHERE title = ?'
+    Entry.connection.send :substitute_binds, sql, binds
+    assert_equal binds_dup, binds
+  end
+  
+  def test_find_by_sql_with_binds
+    Entry.create!(:title => 'qqq', :content => '', :rating => 4)
+    Entry.create!(:title => 'www', :content => '', :rating => 5)
+    Entry.create!(:title => 'www', :content => '', :rating => 6)
+    #ActiveRecord::Base.logger.level = Logger::DEBUG
+    sql = 'SELECT * FROM entries WHERE ( title = ? OR title = ? ) AND rating < ? AND rating > ?'
+    entries = Entry.find_by_sql [ sql, 'qqq', 'www', 6, 4 ]
+    assert_equal 1, entries.size
+  ensure
+    #ActiveRecord::Base.logger.level = Logger::WARN
+  end
+
+  def test_find_by_sql_with_named_binds
+    Entry.create!(:title => 'qqq', :content => '', :rating => 4)
+    Entry.create!(:title => 'www', :content => '', :rating => 5)
+    Entry.create!(:title => 'www', :content => '', :rating => 6)
+    #ActiveRecord::Base.logger.level = Logger::DEBUG
+    sql = 'SELECT * FROM entries WHERE ( title = :title OR title = :title ) AND rating < :upper AND rating > :lower'
+    entries = Entry.find_by_sql [ sql, { :title => 'www', :upper => 6, :lower => 4 } ]
+    assert_equal 1, entries.size
+  ensure
+    #ActiveRecord::Base.logger.level = Logger::WARN
+  end
+  
+  def test_create_bind_param_with_q_mark
+    str = "Don' botharrr talkin' like one, savvy? Right?!?"
+    db_type = DbType.create! :sample_string => str.dup
+    assert_equal str, db_type.reload.sample_string
+    
+    entry = Entry.create! :title => 'foo!', :content => 'bar?'
+    assert_equal 'foo!', entry.reload.title
+    assert_equal 'bar?', entry.content
+  end
+
+  def test_exec_update_bind_param_with_q_mark
+    entry = Entry.create! :title => 'foo!'
+    
+    sql = "UPDATE entries SET title = ? WHERE id = #{entry.id}"
+    connection.exec_update sql, 'UPDATE(with_q_mark)', [ [ nil, "bar?" ] ]
+    assert_equal 'bar?', entry.reload.title
+  end
+
+  def test_exec_insert_bind_param_with_q_mark
+    sql = "INSERT INTO entries(title) VALUES (?)"
+    connection.exec_insert sql, 'INSERT(with_q_mark)', [ [ nil, "bar?!?" ] ]
+    
+    entries = Entry.find_by_sql "SELECT * FROM entries WHERE title = 'bar?!?'"
+    assert entries.first
+  end
+
+  def test_raw_insert_bind_param_with_q_mark
+    sql = "INSERT INTO entries(title) VALUES (?)"
+    name = "INSERT(raw_with_q_mark)"
+    pk = nil; id_value = nil; sequence_name = nil
+    connection.insert sql, name, pk, id_value, sequence_name, [ [ nil, "?!huu!?" ] ]
+    assert Entry.exists?([ 'title LIKE ?', "%?!huu!?%" ])
+  end if Test::Unit::TestCase.ar_version('3.1') # no binds argument for <= 3.0
+  
+  def test_raw_update_bind_param_with_q_mark
+    entry = Entry.create! :title => 'foo!'
+    
+    sql = "UPDATE entries SET title = ? WHERE id = #{entry.id}"
+    name = "UPDATE(raw_with_q_mark)"
+    connection.update sql, name, [ [ nil, "bar?" ] ]
+    assert_equal 'bar?', entry.reload.title
+    
+    sql = "UPDATE entries SET title = ? WHERE id = ?"
+    connection.update sql, name, [ [ nil, "?baz?!?" ], [ nil, entry.id ] ]
+    assert_equal '?baz?!?', entry.reload.title
+  end if Test::Unit::TestCase.ar_version('3.1') # no binds argument for <= 3.0
+  
+  def test_raw_delete_bind_param_with_q_mark
+    entry = Entry.create! :title => 'foo?!?'
+    
+    sql = "DELETE FROM entries WHERE title = ?"
+    name = "DELETE(raw_with_q_mark)"
+    connection.delete sql, name, [ [ nil, "foo?!?" ] ]
+    assert ! Entry.exists?(entry.id)
+  end if Test::Unit::TestCase.ar_version('3.1') # no binds argument for <= 3.0
+  
   class ChangeEntriesTable < ActiveRecord::Migration
     def self.up
       change_table :entries do |t|
         t.string :author
-      end if respond_to?(:change_table)
+      end
     end
     def self.down
       change_table :entries do |t|
         t.remove :author
-      end if respond_to?(:change_table)
+      end
     end
   end
+
   def test_change_table
+    attributes = {
+      :title => 'welcome to the real world',
+      :content => '... TO BE CONTINUED ...', 
+      :author => 'kares'
+    }
+    assert_raise ActiveRecord::UnknownAttributeError do
+      Entry.create! attributes
+    end
+    
     ChangeEntriesTable.up
-    ChangeEntriesTable.down
-  end
+    Entry.reset_column_information
+    begin
+      Entry.create! attributes
+      if Entry.respond_to?(:where)
+        e = Entry.where :author => 'kares'
+      else # 2.3
+        e = Entry.all :conditions => { :author => 'kares' }
+      end
+      assert e.first
+    ensure
+      ChangeEntriesTable.down # rescue nil
+      Entry.reset_column_information
+    end
+  end # if Test::Unit::TestCase.ar_version('3.0')
 
   def test_string_id
     f = StringId.new
@@ -558,6 +685,28 @@ module SimpleTestMethods
     f = StringId.first #reload is essential
     assert_equal "some_string", f.id
   end
+
+  def test_handles_quotes_inside_of_strings
+    content_json = {
+      "comments" => [
+        "First I was like, \"What, you've got crazy pants\"",
+        "And then he was like, \"Yeah dude, total crazy pantalones\""
+      ]
+    }.to_json
+
+    post = Entry.new :title => 'comment entry'
+    post.content = content_json
+    post.save!
+
+    assert_equal content_json, post.reload.content
+  end
+
+  protected
+  
+  def assert_date_type(value)
+    assert_instance_of Date, value
+  end
+  
 end
 
 module MultibyteTestMethods
@@ -567,20 +716,20 @@ module MultibyteTestMethods
     def setup
       super
       config = ActiveRecord::Base.connection.config
-      @jdbc_driver = ActiveRecord::ConnectionAdapters::JdbcDriver.new(config[:driver])
-      @java_con = @jdbc_driver.connection(config[:url], config[:username], config[:password])
-      @java_con.setAutoCommit(true)
+      jdbc_driver = ActiveRecord::ConnectionAdapters::JdbcDriver.new(config[:driver])
+      @java_connection = jdbc_driver.connection(config[:url], config[:username], config[:password])
+      @java_connection.setAutoCommit(true)
     end
 
     def teardown
-      @java_con.close
-      @jdbc_driver = nil
+      @java_connection.close
       super
     end
 
     def test_select_multibyte_string
-      @java_con.createStatement().execute("insert into entries (id, title, content) values (1, 'テスト', '本文')")
-      entry = Entry.find(:first)
+      @java_connection.createStatement().
+        execute("insert into entries (id, title, content) values (1, 'テスト', '本文')")
+      entry = Entry.first
       assert_equal "テスト", entry.title
       assert_equal "本文", entry.content
       assert_equal entry, Entry.find_by_title("テスト")
@@ -588,7 +737,8 @@ module MultibyteTestMethods
 
     def test_update_multibyte_string
       Entry.create!(:title => "テスト", :content => "本文")
-      rs = @java_con.createStatement().executeQuery("select title, content from entries")
+      rs = @java_connection.createStatement().
+        executeQuery("select title, content from entries")
       assert rs.next
       assert_equal "テスト", rs.getString(1)
       assert_equal "本文", rs.getString(2)
@@ -639,29 +789,40 @@ module NonUTF8EncodingMethods
 end
 
 module XmlColumnTests
+  
   def self.included(base)
     base.send :include, Tests if ActiveRecord::VERSION::MAJOR > 3 ||
       (ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR >= 1)
   end
+  
   module Tests
+    
     def test_create_xml_column
-      assert_nothing_raised do
-        @connection.create_table :xml_testings do |t|
-          t.xml :xml_test
-        end
+      connection.create_table :xml_testings do |t|
+        t.xml :xml_test
       end
 
-      xml_test = @connection.columns(:xml_testings).detect do |c|
+      xml_column = connection.columns(:xml_testings).detect do |c|
         c.name == "xml_test"
       end
-
-      assert_equal "text", xml_test.sql_type
+      
+      assert_equal xml_sql_type, xml_column.sql_type
     ensure
-      @connection.drop_table :xml_testings rescue nil
+      connection.drop_table :xml_testings rescue nil
+    end
+    
+    protected
+    
+    def xml_sql_type
+      'text'
     end
+    
   end
+  
 end
+
 module ActiveRecord3TestMethods
+  
   def self.included(base)
     base.send :include, Tests if ActiveRecord::VERSION::MAJOR == 3
   end
@@ -684,14 +845,14 @@ module ActiveRecord3TestMethods
 
     def test_remove_nonexistent_index
       assert_raise(ArgumentError, ActiveRecord::StatementInvalid, ActiveRecord::JDBCError) do
-        @connection.remove_index :entries, :nonexistent_index
+        connection.remove_index :entries, :nonexistent_index
       end
     end
 
     def test_add_index_with_invalid_name_length
-      index_name = 'x' * (@connection.index_name_length + 1)
+      index_name = 'x' * (connection.index_name_length + 1)
       assert_raise(ArgumentError) do
-        @connection.add_index "entries", "title", :name => index_name
+        connection.add_index "entries", "title", :name => index_name
       end
     end
 
@@ -702,6 +863,7 @@ module ActiveRecord3TestMethods
       assert_equal 1, Thing.find(:all).size
     end
   end
+  
 end
 
 module ResetColumnInformationTestMethods
@@ -752,3 +914,45 @@ module ResetColumnInformationTestMethods
       end
     end
 end
+
+module ExplainSupportTestMethods
+  
+  PRINT_EXPLAIN_OUTPUT = java.lang.Boolean.getBoolean('explain.support.output')
+  
+  def test_supports_explain
+    assert ActiveRecord::Base.connection.supports_explain?
+  end
+  
+  def test_explain_without_binds
+    create_explain_data
+    
+    pp = ActiveRecord::Base.connection.explain(
+      "SELECT * FROM entries JOIN users on entries.user_id = users.id WHERE entries.rating > 0"
+    )
+    puts "\n"; puts pp if PRINT_EXPLAIN_OUTPUT
+    assert_instance_of String, pp
+  end
+  
+  def test_explain_with_binds
+    create_explain_data
+    
+    binds = [ [ Entry.columns.find { |col| col.name.to_s == 'rating' }, 0 ] ] 
+    pp = ActiveRecord::Base.connection.explain(
+      "SELECT * FROM entries JOIN users on entries.user_id = users.id WHERE entries.rating > ?", binds
+    )
+    puts "\n"; puts pp if PRINT_EXPLAIN_OUTPUT
+    assert_instance_of String, pp
+  end
+  
+  private
+  def create_explain_data
+    user_1 = User.create :login => 'user_1'
+    user_2 = User.create :login => 'user_2'
+
+    Entry.create :title => 'title_1', :content => 'content_1', :rating => 1, :user_id => user_1.id
+    Entry.create :title => 'title_2', :content => 'content_2', :rating => 2, :user_id => user_2.id
+    Entry.create :title => 'title_3', :content => 'content', :rating => 0, :user_id => user_1.id
+    Entry.create :title => 'title_4', :content => 'content', :rating => 0, :user_id => user_1.id
+  end
+  
+end