sequel 2.3.0 → 2.4.0

data/lib/sequel_core/exceptions.rb

@@ -4,15 +4,6 @@ module Sequel
     
     # Raised when Sequel is unable to load a specified adapter.
     class AdapterNotFound < Error ; end
-    
-    # Raise when an invalid expression is encountered inside a block filter.
-    class InvalidExpression < Error; end
-                                       
-    # Represents an Invalid filter.    
-    class InvalidFilter < Error ; end
-    
-    # Represents an invalid join type.
-    class InvalidJoinType < Error ; end
 
     # Raised on an invalid operation.
     class InvalidOperation < Error; end
@@ -35,8 +26,5 @@ module Sequel
     # Rollback is a special error used to rollback a transactions.
     # A transaction block will catch this error and won't pass further up the stack.
     class Rollback < Error ; end
-    
-    # Should be raised inside a worker loop to tell it to stop working.
-    class WorkerStop < RuntimeError ; end
   end  
 end

data/lib/sequel_model/base.rb

@@ -62,7 +62,7 @@ module Sequel
        insert_multiple intersect interval invert_order join join_table last 
        left_outer_join limit map multi_insert naked order order_by order_more 
        paginate print query range reverse_order right_outer_join select 
-       select_all select_more set set_graph_aliases single_value size to_csv to_hash
+       select_all select_more server set set_graph_aliases single_value size to_csv to_hash
        transform union uniq unfiltered unordered update where'.map{|x| x.to_sym}
 
     # Instance variables that are inherited in subclasses
@@ -79,7 +79,6 @@ module Sequel
     # first before a dataset lookup is attempted unless a hash is supplied.
     def self.[](*args)
       args = args.first if (args.size == 1)
-      raise(Error::InvalidFilter, "Did you mean to supply a hash?") if args === true || args === false
 
       if Hash === args
         dataset[args]

data/lib/sequel_model/plugins.rb

@@ -35,7 +35,7 @@ module Sequel
       if m.const_defined?("DatasetMethods")
         dataset.meta_def(:"#{plugin}_opts") {args.first}
         dataset.extend(m::DatasetMethods)
-        def_dataset_method(*m::DatasetMethods.instance_methods)
+        def_dataset_method(*m::DatasetMethods.public_instance_methods)
       end
     end
     metaalias :is_a, :is

data/spec/adapters/ado_spec.rb

@@ -1,17 +1,46 @@
 require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 unless defined?(ADO_DB)
-  ADO_DB = Sequel.connect(:adapter => 'ado', :driver => "{Microsoft Access Driver (*.mdb)}; DBQ=c:\\Nwind.mdb")
+  ADO_DB = Sequel.ado(:host => 'MY_SQL_SERVER', :database => 'MyDB', :user => 'my_pwd', :password => 'my_usr')
 end
 
 context "An ADO dataset" do
-  setup do
+  before(:each) do
     ADO_DB.create_table!(:items) { text :name }
   end
-
+  
   specify "should not raise exceptions when working with empty datasets" do
     lambda {
       ADO_DB[:items].all
     }.should_not raise_error
   end
 end
+
+context "An MSSQL dataset" do
+  before(:each) do
+    ADO_DB.create_table!(:items) { text :name }
+  end
+
+  specify "should assign a default name to anonymous columns" do
+    col = ADO_DB.fetch('SELECT COUNT(*) FROM items').columns[0]
+    col.to_s.should == '(no column name)'
+  end
+
+  specify "should support counting" do
+    ADO_DB[:items] << {:name => 'my name' }
+    ADO_DB[:items].count.should == 1
+  end
+
+  specify "should support first" do
+    ADO_DB[:items] << {:name => 'x' }
+    ADO_DB[:items] << {:name => 'y' }
+    ADO_DB[:items].first[:name].should == 'x'
+  end
+
+  specify "should support limit" do
+    3.times do
+      ADO_DB[:items] << {:name => 'my name' }
+    end
+    ADO_DB[:items].limit(2).all.size.should == 2
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -41,13 +41,6 @@ context "A MySQL database" do
   teardown do
     Sequel.convert_tinyint_to_bool = true
   end
-  
-  specify "should provide disconnect functionality" do
-    @db.tables
-    @db.pool.size.should == 1
-    @db.disconnect
-    @db.pool.size.should == 0
-  end
 
   specify "should provide the server version" do
     @db.server_version.should >= 40000
@@ -64,6 +57,12 @@ context "A MySQL database" do
       {:id => 3, :name => 'ghi'}
     ]
   end
+  
+  specify "should provide disconnect functionality" do
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
 
   specify "should convert Mysql::Errors to Sequel::Errors" do
    proc{@db << "SELECT 1 + blah;"}.should raise_error(Sequel::Error)
@@ -319,7 +318,7 @@ context "MySQL join expressions" do
   end
 
   specify "should raise error for :full_outer join requests." do
-    lambda{@ds.join_table(:full_outer, :nodes)}.should raise_error(Sequel::Error::InvalidJoinType)
+    lambda{@ds.join_table(:full_outer, :nodes)}.should raise_error(Sequel::Error)
   end
   specify "should support natural left joins" do
     @ds.join_table(:natural_left, :nodes).sql.should == \

data/spec/integration/prepared_statement_test.rb

@@ -0,0 +1,106 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+describe "Prepared Statements and Bound Arguments" do
+  before do
+    INTEGRATION_DB.create_table!(:items) do
+      primary_key :id
+      integer :number
+    end
+    @c = Class.new(Sequel::Model(:items))
+    @ds = INTEGRATION_DB[:items]
+    @ds.insert(:number=>10)
+    @ds.meta_def(:ba) do |sym|
+      prepared_arg_placeholder == '$' ? :"#{sym}__int" : sym
+    end
+    clear_sqls
+  end
+  after do
+    INTEGRATION_DB.drop_table(:items)
+  end
+  
+  specify "should support bound variables with select, all, and first" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:select, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == {:id=>1, :number=>10}
+  end
+
+  specify "should support bound variables with insert" do
+    @ds.call(:insert, {:n=>20, :i=>100}, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+
+  specify "should have insert return primary key value when using bound arguments" do
+    @ds.call(:insert, {:n=>20}, :number=>@ds.ba(:$n)).should == 2
+    @ds.filter(:id=>2).first[:number].should == 20
+  end
+
+  specify "should support bound variables with delete" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:delete, :n=>10).should == 1
+    @ds.count.should == 0
+  end
+
+  specify "should support bound variables with update" do
+    @ds.filter(:number=>@ds.ba(:$n)).call(:update, {:n=>10, :nn=>20}, :number=>:number+@ds.ba(:$nn)).should == 1
+    @ds.all.should == [{:id=>1, :number=>30}]
+  end
+  
+  specify "should support prepared statements with select, first, and all" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:select, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:all, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [{:id=>1, :number=>10}]
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == {:id=>1, :number=>10}
+    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+      # Work around for open prepared statements on a table not allowing the
+      # dropping of a table when using SQLite over JDBC
+      INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
+    end
+  end
+
+  specify "should support prepared statements with insert" do
+    @ds.prepare(:insert, :insert_n, :id=>@ds.ba(:$i), :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>20, :i=>100)
+    @ds.count.should == 2
+    @ds.order(:id).all.should == [{:id=>1, :number=>10}, {:id=>100, :number=>20}]
+  end
+
+  specify "should have insert return primary key value when using prepared statements" do
+    @ds.prepare(:insert, :insert_n, :number=>@ds.ba(:$n))
+    INTEGRATION_DB.call(:insert_n, :n=>20).should == 2
+    @ds.filter(:id=>2).first[:number].should == 20
+  end
+
+  specify "should support prepared statements with delete" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:delete, :delete_n)
+    INTEGRATION_DB.call(:delete_n, :n=>10).should == 1
+    @ds.count.should == 0
+  end
+
+  specify "should support prepared statements with update" do
+    @ds.filter(:number=>@ds.ba(:$n)).prepare(:update, :update_n, :number=>:number+@ds.ba(:$nn))
+    INTEGRATION_DB.call(:update_n, :n=>10, :nn=>20).should == 1
+    @ds.all.should == [{:id=>1, :number=>30}]
+  end
+  
+  specify "model datasets should return model instances when using select, all, and first with bound variables" do
+    @c.filter(:number=>@ds.ba(:$n)).call(:select, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).call(:all, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).call(:first, :n=>10).should == @c.load(:id=>1, :number=>10)
+  end
+  
+  specify "model datasets should return model instances when using select, all, and first with prepared statements" do
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:select, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:all, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == [@c.load(:id=>1, :number=>10)]
+    @c.filter(:number=>@ds.ba(:$n)).prepare(:first, :select_n)
+    INTEGRATION_DB.call(:select_n, :n=>10).should == @c.load(:id=>1, :number=>10)
+    if INTEGRATION_DB.uri =~ /jdbc:sqlite:/
+      # Work around for open prepared statements on a table not allowing the
+      # dropping of a table when using SQLite over JDBC
+      INTEGRATION_DB.synchronize{|c| c.prepared_statements[:select_n][1].close}
+    end
+  end
+end

data/spec/sequel_core/connection_pool_spec.rb

@@ -56,9 +56,9 @@ context "A connection pool handling connections" do
   end
 
   specify "#make_new should not make more than max_size connections" do
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == :got_connection
-    @cpool.send(:make_new).should == nil
+    @cpool.send(:make_new, :default).should == :got_connection
+    @cpool.send(:make_new, :default).should == :got_connection
+    @cpool.send(:make_new, :default).should == nil
     @cpool.created_count.should == 2
   end
 end
@@ -341,6 +341,65 @@ context "ConnectionPool#disconnect" do
   end
 end
 
+context "A connection pool with multiple servers" do
+  setup do
+    @invoked_counts = Hash.new(0)
+    @pool = Sequel::ConnectionPool.new(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| "#{server}#{@invoked_counts[server] += 1}"}
+  end
+  
+  specify "should use the :default server by default" do
+    @pool.size.should == 0
+    @pool.hold do |c|
+      c.should == "default1"
+      @pool.allocated.should == {Thread.current=>"default1"}
+    end
+    @pool.available_connections.should == ["default1"]
+    @pool.size.should == 1
+    @invoked_counts.should == {:default=>1}
+  end
+
+  specify "should use the requested server if server is given" do
+    @pool.size(:read_only).should == 0
+    @pool.hold(:read_only) do |c|
+      c.should == "read_only1"
+      @pool.allocated(:read_only).should == {Thread.current=>"read_only1"}
+    end
+    @pool.available_connections(:read_only).should == ["read_only1"]
+    @pool.size(:read_only).should == 1
+    @invoked_counts.should == {:read_only=>1}
+  end
+  
+  specify "#hold should only yield connections for the server requested" do
+    @pool.hold(:read_only) do |c|
+      c.should == "read_only1"
+      @pool.allocated(:read_only).should == {Thread.current=>"read_only1"}
+      @pool.hold do |d|
+        d.should == "default1"
+        @pool.hold do |e|
+          e.should == d
+          @pool.hold(:read_only){|b| b.should == c}
+        end
+        @pool.allocated.should == {Thread.current=>"default1"}
+      end
+    end
+    @invoked_counts.should == {:read_only=>1, :default=>1}
+  end
+  
+  specify "#disconnect should disconnect from all servers" do
+    @pool.hold(:read_only){}
+    @pool.hold{}
+    conns = []
+    @pool.size.should == 1
+    @pool.size(:read_only).should == 1
+    @pool.disconnect{|c| conns << c}
+    conns.sort.should == %w'default1 read_only1'
+    @pool.size.should == 0
+    @pool.size(:read_only).should == 0
+    @pool.hold(:read_only){|c| c.should == 'read_only2'}
+    @pool.hold{|c| c.should == 'default2'}
+  end
+end
+
 context "SingleThreadedPool" do
   setup do
     @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS){1234}
@@ -361,3 +420,46 @@ context "SingleThreadedPool" do
     @pool.conn.should be_nil
   end
 end
+
+context "A single threaded pool with multiple servers" do
+  setup do
+    @pool = Sequel::SingleThreadedPool.new(CONNECTION_POOL_DEFAULTS.merge(:servers=>{:read_only=>{}})){|server| server}
+  end
+  
+  specify "should use the :default server by default" do
+    @pool.hold{|c| c.should == :default}
+    @pool.conn.should == :default
+  end
+
+  specify "should use the requested server if server is given" do
+    @pool.hold(:read_only){|c| c.should == :read_only}
+    @pool.conn(:read_only).should == :read_only
+  end
+  
+  specify "#hold should only yield connections for the server requested" do
+    @pool.hold(:read_only) do |c|
+      c.should == :read_only
+      @pool.hold do |d|
+        d.should == :default
+        @pool.hold do |e|
+          e.should == d
+          @pool.hold(:read_only){|b| b.should == c}
+        end
+      end
+    end
+    @pool.conn.should == :default
+    @pool.conn(:read_only).should == :read_only
+  end
+  
+  specify "#disconnect should disconnect from all servers" do
+    @pool.hold(:read_only){}
+    @pool.hold{}
+    conns = []
+    @pool.conn.should == :default
+    @pool.conn(:read_only).should == :read_only
+    @pool.disconnect{|c| conns << c}
+    conns.sort_by{|x| x.to_s}.should == [:default, :read_only]
+    @pool.conn.should == nil
+    @pool.conn(:read_only).should == nil
+  end
+end

data/spec/sequel_core/database_spec.rb

@@ -150,7 +150,7 @@ end
 context "Database#<<" do
   setup do
     @c = Class.new(Sequel::Database) do
-      define_method(:execute) {|sql| sql}
+      define_method(:execute) {|sql, opts| sql}
     end
     @db = @c.new({})
   end
@@ -238,7 +238,7 @@ end
 class DummyDatabase < Sequel::Database
   attr_reader :sqls
   
-  def execute(sql)
+  def execute(sql, opts={})
     @sqls ||= []
     @sqls << sql
   end
@@ -455,7 +455,7 @@ end
 
 class Dummy3Database < Sequel::Database
   attr_reader :sql, :transactions
-  def execute(sql); @sql ||= []; @sql << sql; end
+  def execute(sql, opts={}); @sql ||= []; @sql << sql; end
 
   class DummyConnection
     def initialize(db); @db = db; end
@@ -962,3 +962,41 @@ context "Database#get" do
     @db.sqls.last.should == 'SELECT version()'
   end
 end
+
+context "Database#call" do
+  specify "should call the prepared statement with the given name" do
+    db = MockDatabase.new
+    db[:items].prepare(:select, :select_all)
+    db.call(:select_all).should == [{:id => 1, :x => 1}]
+    db[:items].filter(:n=>:$n).prepare(:select, :select_n)
+    db.call(:select_n, :n=>1).should == [{:id => 1, :x => 1}]
+    db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (n = 1)']
+  end
+end
+
+context "Database#server_opts" do
+  specify "should return the general opts if no :servers option is used" do
+    opts = {:host=>1, :database=>2}
+    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>1, :database=>2}
+  end
+  
+  specify "should return the general opts if entry for the server is present in the :servers option" do
+    opts = {:host=>1, :database=>2, :servers=>{}}
+    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>1, :database=>2}
+  end
+  
+  specify "should return the general opts merged with the specific opts if given as a hash" do
+    opts = {:host=>1, :database=>2, :servers=>{:server1=>{:host=>3}}}
+    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>3, :database=>2}
+  end
+  
+  specify "should return the sgeneral opts merged with the specific opts if given as a proc" do
+    opts = {:host=>1, :database=>2, :servers=>{:server1=>proc{|db| {:host=>4}}}}
+    MockDatabase.new(opts).send(:server_opts, :server1).should == {:host=>4, :database=>2}
+  end
+  
+  specify "should raise an error if the specific opts is not a proc or hash" do
+    opts = {:host=>1, :database=>2, :servers=>{:server1=>2}}
+    proc{MockDatabase.new(opts).send(:server_opts, :server1)}.should raise_error(Sequel::Error)
+  end
+end

data/spec/sequel_core/dataset_spec.rb

@@ -2244,7 +2244,7 @@ context "Dataset#multi_insert" do
     @dbc = Class.new do
       attr_reader :sqls
       
-      def execute(sql)
+      def execute(sql, opts={})
         @sqls ||= []
         @sqls << sql
       end
@@ -2717,7 +2717,7 @@ context "Dataset#create_view" do
     @dbc = Class.new(Sequel::Database) do
       attr_reader :sqls
       
-      def execute(sql)
+      def execute(sql, opts={})
         @sqls ||= []
         @sqls << sql
       end
@@ -2738,7 +2738,7 @@ context "Dataset#create_or_replace_view" do
     @dbc = Class.new(Sequel::Database) do
       attr_reader :sqls
       
-      def execute(sql)
+      def execute(sql, opts={})
         @sqls ||= []
         @sqls << sql
       end
@@ -2950,7 +2950,7 @@ context "Dataset.dataset_classes" do
   end
 end
 
-context "Dataset default #fetch_rows, #insert, #update, and #delete" do
+context "Dataset default #fetch_rows, #insert, #update, and #delete, #execute" do
   setup do
     @db = Sequel::Database.new
     @ds = @db[:items]
@@ -2961,17 +2961,127 @@ context "Dataset default #fetch_rows, #insert, #update, and #delete" do
   end
 
   specify "#delete should execute delete SQL" do
-    @db.should_receive(:execute).once.with('DELETE FROM items')
+    @db.should_receive(:execute).once.with('DELETE FROM items', :server=>:default)
     @ds.delete
   end
 
   specify "#insert should execute insert SQL" do
-    @db.should_receive(:execute).once.with('INSERT INTO items DEFAULT VALUES')
+    @db.should_receive(:execute).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
     @ds.insert([])
   end
 
   specify "#update should execute update SQL" do
-    @db.should_receive(:execute).once.with('UPDATE items SET number = 1')
+    @db.should_receive(:execute).once.with('UPDATE items SET number = 1', :server=>:default)
     @ds.update(:number=>1)
   end
+  
+  specify "#execute should execute the SQL on the database" do
+    @db.should_receive(:execute).once.with('SELECT 1', :server=>:read_only)
+    @ds.send(:execute, 'SELECT 1')
+  end
+end
+
+context "Dataset prepared statements and bound variables " do
+  setup do
+    @db = Sequel::Database.new
+    @db.meta_eval{attr_accessor :sqls}
+    @db.sqls = []
+    def @db.execute(sql, opts={})
+      @sqls << sql
+    end
+    @ds = @db[:items]
+    def @ds.fetch_rows(sql, &block)
+      execute(sql)
+    end
+  end
+  
+  specify "#call should take a type and bind hash and interpolate it" do
+    @ds.filter(:num=>:$n).call(:select, :n=>1)
+    @ds.filter(:num=>:$n).call(:first, :n=>1)
+    @ds.filter(:num=>:$n).call(:delete, :n=>1)
+    @ds.filter(:num=>:$n).call(:update, {:n=>1, :n2=>2}, :num=>:$n2)
+    @ds.call(:insert, {:n=>1}, :num=>:$n)
+    @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1) LIMIT 1',
+      'DELETE FROM items WHERE (num = 1)',
+      'UPDATE items SET num = 2 WHERE (num = 1)',
+      'INSERT INTO items (num) VALUES (1)']
+  end
+    
+  specify "#prepare should take a type and name and store it in the database for later use with call" do
+    pss = []
+    pss << @ds.filter(:num=>:$n).prepare(:select, :sn)
+    pss << @ds.filter(:num=>:$n).prepare(:first, :fn)
+    pss << @ds.filter(:num=>:$n).prepare(:delete, :dn)
+    pss << @ds.filter(:num=>:$n).prepare(:update, :un, :num=>:$n2)
+    pss << @ds.prepare(:insert, :in, :num=>:$n)
+    @db.prepared_statements.keys.sort_by{|k| k.to_s}.should == [:dn, :fn, :in, :sn, :un]
+    [:sn, :fn, :dn, :un, :in].each_with_index{|x, i| @db.prepared_statements[x].should == pss[i]}
+    @db.call(:sn, :n=>1)
+    @db.call(:fn, :n=>1)
+    @db.call(:dn, :n=>1)
+    @db.call(:un, :n=>1, :n2=>2)
+    @db.call(:in, :n=>1)
+    @db.sqls.should == ['SELECT * FROM items WHERE (num = 1)',
+      'SELECT * FROM items WHERE (num = 1) LIMIT 1',
+      'DELETE FROM items WHERE (num = 1)',
+      'UPDATE items SET num = 2 WHERE (num = 1)',
+      'INSERT INTO items (num) VALUES (1)']
+  end
+    
+  specify "#inspect should indicate it is a prepared statement with the prepared SQL" do
+    @ds.filter(:num=>:$n).prepare(:select, :sn).inspect.should == \
+      '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = $n)">'
+  end
 end
+
+context Sequel::Dataset::UnnumberedArgumentMapper do
+  setup do
+    @db = Sequel::Database.new
+    @db.meta_eval{attr_accessor :sqls}
+    @db.sqls = []
+    def @db.execute(sql, opts={})
+      @sqls << [sql, *opts[:arguments]]
+    end
+    @ds = @db[:items].filter(:num=>:$n)
+    def @ds.fetch_rows(sql, &block)
+      execute(sql)
+    end
+    def @ds.execute(sql, opts={}, &block)
+      @db.execute(sql, {:arguments=>bind_arguments}.merge(opts))
+    end
+    @ps = @ds.prepare(:select, :sn)
+    @ps.extend(Sequel::Dataset::UnnumberedArgumentMapper)
+  end
+
+  specify "#inspect should show the actual SQL submitted to the database" do
+    @ps.inspect.should == '<Sequel::Dataset/PreparedStatement "SELECT * FROM items WHERE (num = ?)">'
+  end
+  
+  specify "should submitted the SQL to the database with placeholders and bind variables" do
+    @ps.call(:n=>1)
+    @db.sqls.should == [["SELECT * FROM items WHERE (num = ?)", 1]]
+  end
+end
+
+context "Sequel::Dataset#server" do
+  specify "should set the server to use for the dataset" do
+    @db = Sequel::Database.new
+    @ds = @db[:items].server(:s)
+    sqls = []
+    @db.meta_def(:execute) do |sql, opts|
+      sqls << [sql, opts[:server]]
+    end
+    def @ds.fetch_rows(sql, &block)
+      execute(sql)
+    end
+    @ds.all
+    @ds.server(:i).insert(:a=>1)
+    @ds.server(:d).delete
+    @ds.server(:u).update(:a=>:a+1)
+    sqls.should == [['SELECT * FROM items', :s],
+      ['INSERT INTO items (a) VALUES (1)', :i],
+      ['DELETE FROM items', :d],
+      ['UPDATE items SET a = (a + 1)', :u]]
+  end
+end