sequel-impala 1.0.0

data/spec/migrator_test.rb

@@ -0,0 +1,240 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+Sequel.extension :migration
+describe Sequel::Migrator do
+  before do
+    @db = DB
+    @m = Sequel::Migrator
+  end
+  after do
+    @db.drop_table?(:schema_info, :schema_migrations, :sm1111, :sm1122, :sm2222, :sm2233, :sm3333, :sm11111, :sm22222)
+  end
+  
+  it "should be able to migrate up and down all the way successfully" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_info].get(:version).must_equal 3
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_info].get(:version).must_equal 0
+  end
+  
+  it "should be able to migrate up and down to specific versions successfully" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :sm1111, :sm2222].each{|n| @db.table_exists?(n).must_equal true}
+    @db.table_exists?(:sm3333).must_equal false
+    @db[:schema_info].get(:version).must_equal 2
+    @m.apply(@db, @dir, 1)
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db.table_exists?(:sm1111).must_equal true
+    @db[:schema_info].get(:version).must_equal 1
+  end
+
+  it "should correctly set migration version to the last successful migration if the migration raises an error when migrating up" do
+    @dir = 'spec/files/bad_up_migration'
+    proc{@m.apply(@db, @dir)}.must_raise Sequel::DatabaseError
+    [:schema_info, :sm11111].each{|n| @db.table_exists?(n).must_equal true}
+    @db.table_exists?(:sm22222).must_equal false
+    @db[:schema_info].get(:version).must_equal 1
+    @m.apply(@db, @dir, 0)
+    [:sm11111, :sm22222].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_info].get(:version).must_equal 0
+  end
+
+  it "should correctly set migration version to the last successful migration if the migration raises an error when migrating down" do
+    @dir = 'spec/files/bad_down_migration'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm11111, :sm22222].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_info].get(:version).must_equal 2
+    proc{@m.apply(@db, @dir, 0)}.must_raise Sequel::DatabaseError
+    [:sm22222].each{|n| @db.table_exists?(n).must_equal false}
+    @db.table_exists?(:sm11111).must_equal true
+    @db[:schema_info].get(:version).must_equal 1
+  end
+
+  it "should handle migrating up or down all the way with timestamped migrations" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb 1273253853_3_create_users.rb'
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal []
+  end
+
+  it "should handle migrating up or down to specific timestamps with timestamped migrations" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir, 1273253851)
+    [:schema_migrations, :sm1111, :sm2222].each{|n| @db.table_exists?(n).must_equal true}
+    @db.table_exists?(:sm3333).must_equal false
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb'
+    @m.apply(@db, @dir, 1273253849)
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db.table_exists?(:sm1111).must_equal true
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb'
+  end
+
+  it "should apply all missing files when migrating up with timestamped migrations" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm1122, :sm2222, :sm2233, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253850_create_artists.rb 1273253851_create_nodes.rb 1273253852_create_albums.rb 1273253853_3_create_users.rb'
+  end
+
+  it "should not apply down action to migrations where up action hasn't been applied" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir, 0)
+    [:sm1111, :sm1122, :sm2222, :sm2233, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal []
+  end
+
+  it "should handle updating to a specific timestamp when interleaving migrations with timestamps" do
+    @dir = 'spec/files/timestamped_migrations'
+    @m.apply(@db, @dir)
+    @dir = 'spec/files/interleaved_timestamped_migrations'
+    @m.apply(@db, @dir, 1273253851)
+    [:schema_migrations, :sm1111, :sm1122, :sm2222].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm2233, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253850_create_artists.rb 1273253851_create_nodes.rb'
+  end
+
+  it "should correctly update schema_migrations table when an error occurs when migrating up or down using timestamped migrations" do
+    @dir = 'spec/files/bad_timestamped_migrations'
+    proc{@m.apply(@db, @dir)}.must_raise Sequel::DatabaseError
+    [:schema_migrations, :sm1111, :sm2222].each{|n| @db.table_exists?(n).must_equal true}
+    @db.table_exists?(:sm3333).must_equal false
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253851_create_nodes.rb'
+    proc{@m.apply(@db, @dir, 0)}.must_raise Sequel::DatabaseError
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db.table_exists?(:sm1111).must_equal true
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb'
+  end
+
+  it "should handle multiple migrations with the same timestamp correctly" do
+    @dir = 'spec/files/duplicate_timestamped_migrations'
+    @m.apply(@db, @dir)
+    [:schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253853_create_nodes.rb 1273253853_create_users.rb'
+    @m.apply(@db, @dir, 1273253853)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb 1273253853_create_nodes.rb 1273253853_create_users.rb'
+    @m.apply(@db, @dir, 1273253849)
+    [:sm1111].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'1273253849_create_sessions.rb'
+    @m.apply(@db, @dir, 1273253848)
+    [:sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal []
+  end
+
+  it "should convert schema_info table to schema_migrations table" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :sm3333, :schema_migrations, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb 1273253852_create_albums.rb'
+
+    @m.apply(@db, @dir, 4)
+    [:schema_info, :schema_migrations, :sm1111, :sm2222, :sm3333].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb'
+
+    @m.apply(@db, @dir, 0)
+    [:schema_info, :schema_migrations].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm1111, :sm2222, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal []
+  end
+
+  it "should handle unapplied migrations when migrating schema_info table to schema_migrations table" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :sm1111, :sm2222].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir, 1273253850)
+    [:schema_info, :sm1111, :sm2222, :sm3333, :schema_migrations, :sm1122].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm2233].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb'
+  end
+
+  it "should handle unapplied migrations when migrating schema_info table to schema_migrations table and target is less than last integer migration version" do
+    @dir = 'spec/files/integer_migrations'
+    @m.apply(@db, @dir, 1)
+    [:schema_info, :sm1111].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :sm2222, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+
+    @dir = 'spec/files/convert_to_timestamp_migrations'
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :sm1111, :sm2222, :schema_migrations].each{|n| @db.table_exists?(n).must_equal true}
+    [:sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'001_create_sessions.rb 002_create_nodes.rb'
+
+    @m.apply(@db, @dir)
+    [:schema_info, :sm1111, :sm2222, :schema_migrations, :sm3333, :sm1122, :sm2233].each{|n| @db.table_exists?(n).must_equal true}
+    @db[:schema_migrations].select_order_map(:filename).must_equal %w'001_create_sessions.rb 002_create_nodes.rb 003_3_create_users.rb 1273253850_create_artists.rb 1273253852_create_albums.rb'
+  end
+
+  it "should handle reversible migrations" do
+    @dir = 'spec/files/reversible_migrations'
+    @db.drop_table?(:a, :b)
+    @m.apply(@db, @dir, 1)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a]
+
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a, :b]
+
+    @m.apply(@db, @dir, 3)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a, :c]
+
+    @m.apply(@db, @dir, 4)
+    [:schema_info, :b].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :a].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:b].columns.must_equal [:a, :c]
+
+    @m.apply(@db, @dir, 5)
+    [:schema_info, :b].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :a].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:b].columns.must_equal [:a, :c, :e]
+
+    @m.apply(@db, @dir, 4)
+    [:schema_info, :b].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :a].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:b].columns.must_equal [:a, :c]
+
+    @m.apply(@db, @dir, 3)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a, :c]
+
+    @m.apply(@db, @dir, 2)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a, :b]
+
+    @m.apply(@db, @dir, 1)
+    [:schema_info, :a].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :b].each{|n| @db.table_exists?(n).must_equal false}
+    @db[:a].columns.must_equal [:a]
+
+    @m.apply(@db, @dir, 0)
+    [:schema_info].each{|n| @db.table_exists?(n).must_equal true}
+    [:schema_migrations, :a, :b].each{|n| @db.table_exists?(n).must_equal false}
+  end
+end

data/spec/plugin_test.rb

@@ -0,0 +1,91 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+describe "date_arithmetic extension" do
+  asd = begin
+    require 'active_support/duration'
+    require 'active_support/inflector'
+    require 'active_support/core_ext/string/inflections'
+    true
+  rescue LoadError
+    false
+  end
+
+  before(:all) do
+    @db = DB
+    @db.extension(:date_arithmetic)
+    if @db.database_type == :sqlite
+      @db.use_timestamp_timezones = false
+    end
+    @date = Date.civil(2010, 7, 12)
+    @dt = Time.local(2010, 7, 12)
+    if asd
+      @d0 = ActiveSupport::Duration.new(0, [[:days, 0]])
+      @d1 = ActiveSupport::Duration.new(1, [[:days, 1]])
+      @d2 = ActiveSupport::Duration.new(1, [[:years, 1], [:months, 1], [:days, 1], [:minutes, 61], [:seconds, 1]])
+    end
+    @h0 = {:days=>0}
+    @h1 = {:days=>1, :years=>nil, :hours=>0}
+    @h2 = {:years=>1, :months=>1, :days=>1, :hours=>1, :minutes=>1, :seconds=>1}
+    @a1 = Time.local(2010, 7, 13)
+    @a2 = Time.local(2011, 8, 13, 1, 1, 1)
+    @s1 = Time.local(2010, 7, 11)
+    @s2 = Time.local(2009, 6, 10, 22, 58, 59)
+    @check = lambda do |meth, in_date, in_interval, should|
+      output = @db.get(Sequel.send(meth, in_date, in_interval))
+      output = Time.parse(output.to_s) unless output.is_a?(Time) || output.is_a?(DateTime)
+      output.year.must_equal should.year
+      output.month.must_equal should.month
+      output.day.must_equal should.day
+      output.hour.must_equal should.hour
+      output.min.must_equal should.min
+      output.sec.must_equal should.sec
+    end
+  end
+  after(:all) do
+    if @db.database_type == :sqlite
+      @db.use_timestamp_timezones = true
+    end
+  end
+
+  if asd
+    it "be able to use Sequel.date_add to add ActiveSupport::Duration objects to dates and datetimes" do
+      @check.call(:date_add, @date, @d0, @dt)
+      @check.call(:date_add, @date, @d1, @a1)
+      @check.call(:date_add, @date, @d2, @a2)
+
+      @check.call(:date_add, @dt, @d0, @dt)
+      @check.call(:date_add, @dt, @d1, @a1)
+      @check.call(:date_add, @dt, @d2, @a2)
+    end
+
+    it "be able to use Sequel.date_sub to subtract ActiveSupport::Duration objects from dates and datetimes" do
+      @check.call(:date_sub, @date, @d0, @dt)
+      @check.call(:date_sub, @date, @d1, @s1)
+      @check.call(:date_sub, @date, @d2, @s2)
+
+      @check.call(:date_sub, @dt, @d0, @dt)
+      @check.call(:date_sub, @dt, @d1, @s1)
+      @check.call(:date_sub, @dt, @d2, @s2)
+    end
+  end
+
+  it "be able to use Sequel.date_add to add interval hashes to dates and datetimes" do
+    @check.call(:date_add, @date, @h0, @dt)
+    @check.call(:date_add, @date, @h1, @a1)
+    @check.call(:date_add, @date, @h2, @a2)
+
+    @check.call(:date_add, @dt, @h0, @dt)
+    @check.call(:date_add, @dt, @h1, @a1)
+    @check.call(:date_add, @dt, @h2, @a2)
+  end
+
+  it "be able to use Sequel.date_sub to subtract interval hashes from dates and datetimes" do
+    @check.call(:date_sub, @date, @h0, @dt)
+    @check.call(:date_sub, @date, @h1, @s1)
+    @check.call(:date_sub, @date, @h2, @s2)
+
+    @check.call(:date_sub, @dt, @h0, @dt)
+    @check.call(:date_sub, @dt, @h1, @s1)
+    @check.call(:date_sub, @dt, @h2, @s2)
+  end
+end

data/spec/prepared_statement_test.rb

@@ -0,0 +1,327 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+describe "Prepared Statements and Bound Arguments" do
+  before do
+    @db = DB
+    @db.create_table!(:items) do
+      primary_key :id
+      integer :numb
+    end
+    @c = Class.new(Sequel::Model(:items))
+    @ds = @db[:items]
+    @ds.insert(:id=>1, :numb=>10)
+    @pr = @ds.requires_placeholder_type_specifiers? ? proc{|i| :"#{i}__integer"} : proc{|i| i}
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+  
+  it "should support bound variables when selecting" do
+    @ds.filter(:numb=>:$n).call(:each, :n=>10){|h| h.must_equal(:id=>1, :numb=>10)}
+    @ds.filter(:numb=>:$n).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).call(:all, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).call(:first, :n=>10).must_equal(:id=>1, :numb=>10)
+    @ds.filter(:numb=>:$n).call([:map, :numb], :n=>10).must_equal [10]
+    @ds.filter(:numb=>:$n).call([:to_hash, :id, :numb], :n=>10).must_equal(1=>10)
+    @ds.filter(:numb=>:$n).call([:to_hash_groups, :id, :numb], :n=>10).must_equal(1=>[10])
+  end
+    
+  it "should support blocks for each, select, all, and map when using bound variables" do
+    a = []
+    @ds.filter(:numb=>:$n).call(:each, :n=>10){|r| r[:numb] *= 2; a << r}; a.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).call(:select, :n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).call(:all, :n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).call([:map], :n=>10){|r| r[:numb] * 2}.must_equal [20]
+  end
+    
+  it "should support binding variables before the call with #bind" do
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:select).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:all).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>10).call(:first).must_equal(:id=>1, :numb=>10)
+    
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:select).must_equal [{:id=>1, :numb=>10}]
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:all).must_equal [{:id=>1, :numb=>10}]
+    @ds.bind(:n=>10).filter(:numb=>:$n).call(:first).must_equal(:id=>1, :numb=>10)
+  end
+  
+  it "should allow overriding variables specified with #bind" do
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:all, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).call(:first, :n=>10).must_equal(:id=>1, :numb=>10)
+    
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:select).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:all).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).bind(:n=>1).bind(:n=>10).call(:first).must_equal(:id=>1, :numb=>10)
+  end
+
+  it "should support placeholder literal strings with call" do
+    @ds.filter("numb = ?", :$n).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support named placeholder literal strings and handle multiple named placeholders correctly with call" do
+    @ds.filter("numb = :n", :n=>:$n).call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.insert(:id=>2, :numb=>20)
+    @ds.insert(:id=>3, :numb=>30)
+    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
+  end
+
+  it "should support datasets with static sql and placeholders with call" do
+    @db["SELECT * FROM items WHERE numb = ?", :$n].call(:select, :n=>10).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with call" do
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n)).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with exists with call" do
+    @ds.filter(:id=>:$i).filter(@ds.select(:numb).filter(:numb=>:$n).exists).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with literal strings with call" do
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).call(:select, :n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with static sql and placeholders with call" do
+    @ds.filter(:id=>:$i, :numb=>@db["SELECT numb FROM items WHERE numb = ?", :$n]).call(:select, :n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects of subselects with call" do
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n))).filter(:id=>:$j).call(:select, :n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+  
+  it "should support using a bound variable for a limit and offset" do
+    @ds.insert(:id=>2, :numb=>20)
+    ds = @ds.limit(:$n, :$n2).order(:id)
+    ds.call(:select, :n=>1, :n2=>0).must_equal [{:id=>1, :numb=>10}]
+    ds.call(:select, :n=>1, :n2=>1).must_equal [{:id=>2, :numb=>20}]
+    ds.call(:select, :n=>1, :n2=>2).must_equal []
+    ds.call(:select, :n=>2, :n2=>0).must_equal [{:id=>1, :numb=>10}, {:id=>2, :numb=>20}]
+    ds.call(:select, :n=>2, :n2=>1).must_equal [{:id=>2, :numb=>20}]
+  end
+
+  it "should support bound variables with insert" do
+    @ds.call(:insert, {:n=>20}, :numb=>:$n)
+    @ds.count.must_equal 2
+    @ds.order(:id).map(:numb).must_equal [10, 20]
+  end
+
+  it "should have insert return primary key value when using bound arguments" do
+    @ds.call(:insert, {:n=>20}, :numb=>:$n, :id=>2).must_equal nil
+    @ds.filter(:id=>2).first[:numb].must_equal 20
+  end
+
+  it "should support bound variables with delete" do
+    @ds.filter(:numb=>:$n).call(:delete, :n=>10).must_equal nil
+    @ds.count.must_equal 0
+  end
+
+  it "should support prepared statements when selecting" do
+    @ds.filter(:numb=>:$n).prepare(:each, :select_n)
+    @db.call(:select_n, :n=>10){|h| h.must_equal(:id=>1, :numb=>10)}
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n)
+    @db.call(:select_n, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).prepare(:all, :select_n)
+    @db.call(:select_n, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.filter(:numb=>:$n).prepare(:first, :select_n)
+    @db.call(:select_n, :n=>10).must_equal(:id=>1, :numb=>10)
+    @ds.filter(:numb=>:$n).prepare([:map, :numb], :select_n)
+    @db.call(:select_n, :n=>10).must_equal [10]
+    @ds.filter(:numb=>:$n).prepare([:to_hash, :id, :numb], :select_n)
+    @db.call(:select_n, :n=>10).must_equal(1=>10)
+  end
+
+  it "should support blocks for each, select, all, and map when using prepared statements" do
+    a = []
+    @ds.filter(:numb=>:$n).prepare(:each, :select_n).call(:n=>10){|r| r[:numb] *= 2; a << r}; a.must_equal [{:id=>1, :numb=>20}]
+    a = []
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2; a << r}; a.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n).call(:n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare(:all, :select_n).call(:n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.must_equal [{:id=>1, :numb=>20}]
+    @ds.filter(:numb=>:$n).prepare([:map], :select_n).call(:n=>10){|r| r[:numb] *= 2}.must_equal [20]
+    @db.call(:select_n, :n=>10){|r| r[:numb] *= 2}.must_equal [20]
+  end
+    
+  it "should support prepared statements being called multiple times with different arguments" do
+    @ds.filter(:numb=>:$n).prepare(:select, :select_n)
+    @db.call(:select_n, :n=>10).must_equal [{:id=>1, :numb=>10}]
+    @db.call(:select_n, :n=>0).must_equal []
+    @db.call(:select_n, :n=>10).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support placeholder literal strings with prepare" do
+    @ds.filter("numb = ?", :$n).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support named placeholder literal strings and handle multiple named placeholders correctly with prepare" do
+    @ds.filter("numb = :n", :n=>:$n).prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
+    @ds.insert(:id=>2, :numb=>20)
+    @ds.insert(:id=>3, :numb=>30)
+    @ds.filter("numb > :n1 AND numb < :n2 AND numb = :n3", :n3=>:$n3, :n2=>:$n2, :n1=>:$n1).call(:select, :n3=>20, :n2=>30, :n1=>10).must_equal [{:id=>2, :numb=>20}]
+  end
+
+  it "should support datasets with static sql and placeholders with prepare" do
+    @db["SELECT * FROM items WHERE numb = ?", :$n].prepare(:select, :seq_select).call(:n=>10).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with prepare" do
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n)).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with exists with prepare" do
+    @ds.filter(:id=>:$i).filter(@ds.select(:numb).filter(:numb=>:$n).exists).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with literal strings with prepare" do
+    @ds.filter(:id=>:$i, :numb=>@ds.select(:numb).filter("numb = ?", :$n)).prepare(:select, :seq_select).call(:n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects with static sql and placeholders with prepare" do
+    @ds.filter(:id=>:$i, :numb=>@db["SELECT numb FROM items WHERE numb = ?", :$n]).prepare(:select, :seq_select).call(:n=>10, :i=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+
+  it "should support subselects of subselects with prepare" do
+    @ds.filter(:id=>:$i).filter(:numb=>@ds.select(:numb).filter(:numb=>@ds.select(:numb).filter(:numb=>:$n))).filter(:id=>:$j).prepare(:select, :seq_select).call(:n=>10, :i=>1, :j=>1).must_equal [{:id=>1, :numb=>10}]
+  end
+  
+  it "should support using a prepared_statement for a limit and offset" do
+    @ds.insert(:id=>2, :numb=>20)
+    ps = @ds.limit(:$n, :$n2).order(:id).prepare(:select, :seq_select)
+    ps.call(:n=>1, :n2=>0).must_equal [{:id=>1, :numb=>10}]
+    ps.call(:n=>1, :n2=>1).must_equal [{:id=>2, :numb=>20}]
+    ps.call(:n=>1, :n2=>2).must_equal []
+    ps.call(:n=>2, :n2=>0).must_equal [{:id=>1, :numb=>10}, {:id=>2, :numb=>20}]
+    ps.call(:n=>2, :n2=>1).must_equal [{:id=>2, :numb=>20}]
+  end
+
+  it "should support prepared statements with insert" do
+    @ds.prepare(:insert, :insert_n, :numb=>:$n)
+    @db.call(:insert_n, :n=>20)
+    @ds.count.must_equal 2
+    @ds.order(:id).map(:numb).must_equal [10, 20]
+  end
+
+  it "should have insert return primary key value when using prepared statements" do
+    @ds.prepare(:insert, :insert_n, :numb=>:$n, :id=>2)
+    @db.call(:insert_n, :id=>2, :n=>20).must_equal nil
+    @ds.filter(:id=>2).first[:numb].must_equal 20
+  end
+
+  it "should support prepared statements with delete" do
+    @ds.filter(:numb=>:$n).prepare(:delete, :delete_n)
+    @db.call(:delete_n, :n=>10).must_equal nil
+    @ds.count.must_equal 0
+  end
+
+  it "model datasets should return model instances when using select, all, and first with bound variables" do
+    @c.filter(:numb=>:$n).call(:select, :n=>10).must_equal [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).call(:all, :n=>10).must_equal [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).call(:first, :n=>10).must_equal @c.load(:id=>1, :numb=>10)
+  end
+  
+  it "model datasets should return model instances when using select, all, and first with prepared statements" do
+    @c.filter(:numb=>:$n).prepare(:select, :select_n1)
+    @db.call(:select_n1, :n=>10).must_equal [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).prepare(:all, :select_n1)
+    @db.call(:select_n1, :n=>10).must_equal [@c.load(:id=>1, :numb=>10)]
+    @c.filter(:numb=>:$n).prepare(:first, :select_n1)
+    @db.call(:select_n1, :n=>10).must_equal @c.load(:id=>1, :numb=>10)
+  end
+end
+
+describe "Bound Argument Types" do
+  before do
+    @db = DB
+    @db.create_table!(:items) do
+      primary_key :id
+      DateTime :dt
+      String :s
+      Time :t
+      Float :f
+      TrueClass :b
+    end
+    @ds = @db[:items]
+    @vs = {:id=>1, :dt=>DateTime.civil(2010, 10, 12, 13, 14, 15), :f=>1.0, :s=>'str', :t=>Time.at(20101010), :b=>true}
+    @ds.insert(@vs)
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  it "should handle float type" do
+    @ds.filter(:f=>:$x).prepare(:first, :ps_float).call(:x=>@vs[:f])[:f].must_equal @vs[:f]
+  end
+
+  it "should handle string type" do
+    @ds.filter(:s=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:s])[:s].must_equal @vs[:s]
+  end
+
+  it "should handle boolean type" do
+    @ds.filter(:b=>:$x).prepare(:first, :ps_string).call(:x=>@vs[:b])[:b].must_equal @vs[:b]
+  end
+end
+
+describe "Dataset#unbind" do
+  before do
+    @ds = ds = DB[:items]
+    @ct = proc do |t, v|
+      DB.create_table!(:items) do
+        column :c, t
+      end
+      ds.insert(:c=>v)
+    end
+    @u = proc{|ds1| ds2, bv = ds1.unbind; ds2.call(:first, bv)}
+  end
+  after do
+    DB.drop_table?(:items)
+  end
+  
+  it "should unbind values assigned to equality and inequality statements" do
+    @ct[Integer, 10]
+    @u[@ds.filter(:c=>10)].must_equal(:c=>10)
+    @u[@ds.exclude(:c=>10)].must_equal nil
+    @u[@ds.filter{c < 10}].must_equal nil
+    @u[@ds.filter{c <= 10}].must_equal(:c=>10)
+    @u[@ds.filter{c > 10}].must_equal nil
+    @u[@ds.filter{c >= 10}].must_equal(:c=>10)
+  end
+
+  it "should handle numerics and strings" do
+    @ct[Integer, 10]
+    @u[@ds.filter(:c=>10)].must_equal(:c=>10)
+    @ct[Float, 0.0]
+    @u[@ds.filter{c < 1}].must_equal(:c=>0.0)
+    @ct[String, 'foo']
+    @u[@ds.filter(:c=>'foo')].must_equal(:c=>'foo')
+
+    DB.create_table!(:items) do
+      BigDecimal :c, :size=>[15,2]
+    end
+    @ds.insert(:c=>BigDecimal.new('1.1'))
+    @u[@ds.filter{c > 0}].must_equal(:c=>BigDecimal.new('1.1'))
+  end
+
+  it "should handle QualifiedIdentifiers" do
+    @ct[Integer, 10]
+    @u[@ds.filter{items__c > 1}].must_equal(:c=>10)
+  end
+
+  it "should handle deep nesting" do
+    DB.create_table!(:items) do
+      Integer :a
+      Integer :b
+      Integer :c
+      Integer :d
+    end
+    @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>4)=>1}, 0) => 1)].must_equal(:a=>2, :b=>0, :c=>3, :d=>5)
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].must_equal nil
+  end
+
+  it "should handle case where the same variable has the same value in multiple places " do
+    @ct[Integer, 1]
+    @u[@ds.filter{c > 1}.or{c < 1}.invert].must_equal(:c=>1)
+    @u[@ds.filter{c > 1}.or{c < 1}].must_equal nil
+  end
+end