sequel 4.8.0 → 4.9.0

data/spec/core/dataset_spec.rb

@@ -3254,46 +3254,30 @@ describe "Dataset#grep" do
   end
 end
 
-describe "Dataset default #fetch_rows, #insert, #update, #delete, #with_sql_delete, #truncate, #execute" do
+describe "Dataset default #fetch_rows, #insert, #update, #delete, #truncate, #execute" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock(:servers=>{:read_only=>{}}, :autoid=>1)
     @ds = @db[:items]
   end
 
   specify "#delete should execute delete SQL" do
-    @db.should_receive(:execute).once.with('DELETE FROM items', :server=>:default)
-    @ds.delete
-    @db.should_receive(:execute_dui).once.with('DELETE FROM items', :server=>:default)
-    @ds.delete
-  end
-
-  specify "#with_sql_delete should execute delete SQL" do
-    sql = 'DELETE FROM foo'
-    @db.should_receive(:execute).once.with(sql, :server=>:default)
-    @ds.with_sql_delete(sql)
-    @db.should_receive(:execute_dui).once.with(sql, :server=>:default)
-    @ds.with_sql_delete(sql)
+    @ds.delete.should == 0
+    @db.sqls.should == ["DELETE FROM items"]
   end
 
   specify "#insert should execute insert SQL" do
-    @db.should_receive(:execute).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
-    @ds.insert([])
-    @db.should_receive(:execute_insert).once.with('INSERT INTO items DEFAULT VALUES', :server=>:default)
-    @ds.insert([])
+    @ds.insert([]).should == 1
+    @db.sqls.should == ["INSERT INTO items DEFAULT VALUES"]
   end
 
   specify "#update should execute update SQL" do
-    @db.should_receive(:execute).once.with('UPDATE items SET number = 1', :server=>:default)
-    @ds.update(:number=>1)
-    @db.should_receive(:execute_dui).once.with('UPDATE items SET number = 1', :server=>:default)
-    @ds.update(:number=>1)
+    @ds.update(:number=>1).should == 0
+    @db.sqls.should == ["UPDATE items SET number = 1"]
   end
   
   specify "#truncate should execute truncate SQL" do
-    @db.should_receive(:execute).once.with('TRUNCATE TABLE items', :server=>:default)
-    @ds.truncate.should == nil
-    @db.should_receive(:execute_ddl).once.with('TRUNCATE TABLE items', :server=>:default)
     @ds.truncate.should == nil
+    @db.sqls.should == ["TRUNCATE TABLE items"]
   end
   
   specify "#truncate should raise an InvalidOperation exception if the dataset is filtered" do
@@ -3302,8 +3286,71 @@ describe "Dataset default #fetch_rows, #insert, #update, #delete, #with_sql_dele
   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')
+    @db.sqls.should == ["SELECT 1 -- read_only"]
+  end
+end
+
+describe "Dataset#with_sql_*" do
+  before do
+    @db = Sequel.mock(:servers=>{:read_only=>{}}, :autoid=>1, :fetch=>{:id=>1})
+    @ds = @db[:items]
+  end
+
+  specify "#with_sql_insert should execute given insert SQL" do
+    @ds.with_sql_insert('INSERT INTO foo (1)').should == 1
+    @db.sqls.should == ["INSERT INTO foo (1)"]
+  end
+
+  specify "#with_sql_delete should execute given delete SQL" do
+    @ds.with_sql_delete('DELETE FROM foo').should == 0
+    @db.sqls.should == ["DELETE FROM foo"]
+  end
+
+  specify "#with_sql_update should execute given update SQL" do
+    @ds.with_sql_update('UPDATE foo SET a = 1').should == 0
+    @db.sqls.should == ["UPDATE foo SET a = 1"]
+  end
+
+  specify "#with_sql_all should return all rows from running the SQL" do
+    @ds.with_sql_all('SELECT * FROM foo').should == [{:id=>1}]
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_all should yield each row to the block" do
+    a = []
+    @ds.with_sql_all('SELECT * FROM foo'){|r| a << r}
+    a.should == [{:id=>1}]
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_each should yield each row to the block" do
+    a = []
+    @ds.with_sql_each('SELECT * FROM foo'){|r| a << r}
+    a.should == [{:id=>1}]
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_first should return first row" do
+    @ds.with_sql_first('SELECT * FROM foo').should == {:id=>1}
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_first should return nil if no rows returned" do
+    @db.fetch = []
+    @ds.with_sql_first('SELECT * FROM foo').should == nil
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_single_value should return first value from first row" do
+    @ds.with_sql_single_value('SELECT * FROM foo').should == 1
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
+  end
+
+  specify "#with_sql_single_value should return nil if no rows returned" do
+    @db.fetch = []
+    @ds.with_sql_single_value('SELECT * FROM foo').should == nil
+    @db.sqls.should == ["SELECT * FROM foo -- read_only"]
   end
 end
 
@@ -4314,7 +4361,7 @@ describe "Dataset emulating bitwise operator support" do
     @ds = Sequel::Database.new.dataset
     @ds.quote_identifiers = true
     def @ds.complex_expression_sql_append(sql, op, args)
-      sql << complex_expression_arg_pairs(args){|a, b| "bitand(#{literal(a)}, #{literal(b)})"}
+      complex_expression_arg_pairs_append(sql, args){|a, b| Sequel.function(:bitand, a, b)}
     end
   end
 
@@ -4562,6 +4609,49 @@ describe "Dataset#paged_each" do
     @ds.limit(nil, 2).paged_each(:rows_per_fetch=>3, &@proc)
     @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 2", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 5", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 8", "SELECT * FROM test ORDER BY x LIMIT 3 OFFSET 11"]
   end
+
+  it "should support :strategy=>:filter" do
+    @ds._fetch = @db.each_slice(5).to_a
+    @ds.paged_each(:rows_per_fetch=>5, :strategy=>:filter, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY x LIMIT 5", "SELECT * FROM test WHERE (x > 4) ORDER BY x LIMIT 5", "SELECT * FROM test WHERE (x > 9) ORDER BY x LIMIT 5"]
+    @rows.should == @db
+
+    @rows = []
+    db = @db.map{|h| h[:y] = h[:x] % 5; h[:z] = h[:x] % 9; h}.sort_by{|h| [h[:z], -h[:y], h[:x]]}
+    @ds._fetch = db.each_slice(5).to_a
+    @ds.order(Sequel.identifier(:z), Sequel.desc(Sequel.qualify(:test, :y)), Sequel.asc(:x)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY z, test.y DESC, x ASC LIMIT 5",
+      "SELECT * FROM test WHERE ((z > 3) OR ((z = 3) AND (test.y < 3)) OR ((z = 3) AND (test.y = 3) AND (x > 3))) ORDER BY z, test.y DESC, x ASC LIMIT 5",
+      "SELECT * FROM test WHERE ((z > 8) OR ((z = 8) AND (test.y < 3)) OR ((z = 8) AND (test.y = 3) AND (x > 8))) ORDER BY z, test.y DESC, x ASC LIMIT 5"]
+    @rows.should == db
+  end
+
+  it "should support :strategy=>:filter with :filter_values option" do
+    db = @db.map{|h| h[:y] = h[:x] % 5; h[:z] = h[:x] % 9; h}.sort_by{|h| [h[:z], -h[:y], h[:x]]}
+    @ds._fetch = db.each_slice(5).to_a
+    @ds.order(Sequel.identifier(:z), Sequel.desc(Sequel.qualify(:test, :y) * 2), Sequel.asc(:x)).paged_each(:rows_per_fetch=>5, :strategy=>:filter, :filter_values=>proc{|row, expr| [row[expr[0].value], row[expr[1].args.first.column] * expr[1].args.last, row[expr[2]]]}, &@proc)
+    @ds.db.sqls[1...-1].should == ["SELECT * FROM test ORDER BY z, (test.y * 2) DESC, x ASC LIMIT 5",
+      "SELECT * FROM test WHERE ((z > 3) OR ((z = 3) AND ((test.y * 2) < 6)) OR ((z = 3) AND ((test.y * 2) = 6) AND (x > 3))) ORDER BY z, (test.y * 2) DESC, x ASC LIMIT 5",
+      "SELECT * FROM test WHERE ((z > 8) OR ((z = 8) AND ((test.y * 2) < 6)) OR ((z = 8) AND ((test.y * 2) = 6) AND (x > 8))) ORDER BY z, (test.y * 2) DESC, x ASC LIMIT 5"]
+    @rows.should == db
+  end
+end
+
+describe "Dataset#current_datetime" do
+  after do
+    Sequel.datetime_class = Time
+  end
+
+  it "should return an instance of Sequel.datetime_class for the current datetime" do
+    t = Sequel::Dataset.new(nil).current_datetime 
+    t.should be_a_kind_of(Time)
+    (Time.now - t < 0.1).should == true
+
+    Sequel.datetime_class = DateTime
+    t = Sequel::Dataset.new(nil).current_datetime 
+    t.should be_a_kind_of(DateTime)
+    (DateTime.now - t < (0.1/86400)).should == true
+  end
 end
 
 describe "Dataset#escape_like" do
@@ -4693,3 +4783,58 @@ describe "Dataset mutation methods" do
     dsc.graph!(dsc, {:b=>:c}, :table_alias=>:foo).ungraphed!.opts[:graph].should be_nil
   end
 end
+
+describe "Dataset emulated complex expression operators" do
+  before do
+    @ds = Sequel.mock[:test]
+    def @ds.complex_expression_sql_append(sql, op, args)
+      case op
+      when :&, :|, :^, :%, :<<, :>>, :'B~'
+        complex_expression_emulate_append(sql, op, args)
+      else
+        super
+      end
+    end
+    @n = Sequel.expr(:x).sql_number
+  end
+
+  it "should emulate &" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:&, @n)).should == "x"
+    @ds.literal(@n & 1).should == "BITAND(x, 1)"
+    @ds.literal(@n & 1 & 2).should == "BITAND(BITAND(x, 1), 2)"
+  end
+
+  it "should emulate |" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:|, @n)).should == "x"
+    @ds.literal(@n | 1).should == "BITOR(x, 1)"
+    @ds.literal(@n | 1 | 2).should == "BITOR(BITOR(x, 1), 2)"
+  end
+
+  it "should emulate ^" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:^, @n)).should == "x"
+    @ds.literal(@n ^ 1).should == "BITXOR(x, 1)"
+    @ds.literal(@n ^ 1 ^ 2).should == "BITXOR(BITXOR(x, 1), 2)"
+  end
+
+  it "should emulate %" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:%, @n)).should == "x"
+    @ds.literal(@n % 1).should == "MOD(x, 1)"
+    @ds.literal(@n % 1 % 2).should == "MOD(MOD(x, 1), 2)"
+  end
+
+  it "should emulate >>" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:>>, @n)).should == "x"
+    @ds.literal(@n >> 1).should == "(x / power(2, 1))"
+    @ds.literal(@n >> 1 >> 2).should == "(x / power(2, 1) / power(2, 2))"
+  end
+
+  it "should emulate <<" do
+    @ds.literal(Sequel::SQL::NumericExpression.new(:<<, @n)).should == "x"
+    @ds.literal(@n << 1).should == "(x * power(2, 1))"
+    @ds.literal(@n << 1 << 2).should == "(x * power(2, 1) * power(2, 2))"
+  end
+
+  it "should emulate B~" do
+    @ds.literal(~@n).should == "((0 - x) - 1)"
+  end
+end

data/spec/core/expression_filters_spec.rb

@@ -714,7 +714,7 @@ describe "Sequel core extension replacements" do
   end
 
   it "Sequel.& should join all arguments given with AND" do
-    l(Sequel.&(:a), "(a)")
+    l(Sequel.&(:a), "a")
     l(Sequel.&(:a, :b=>:c), "(a AND (b = c))")
     l(Sequel.&(:a, {:b=>:c}, Sequel.lit('d')), "(a AND (b = c) AND d)")
   end
@@ -724,7 +724,7 @@ describe "Sequel core extension replacements" do
   end
 
   it "Sequel.| should join all arguments given with OR" do
-    l(Sequel.|(:a), "(a)")
+    l(Sequel.|(:a), "a")
     l(Sequel.|(:a, :b=>:c), "(a OR (b = c))")
     l(Sequel.|(:a, {:b=>:c}, Sequel.lit('d')), "(a OR (b = c) OR d)")
   end
@@ -808,7 +808,7 @@ describe "Sequel core extension replacements" do
 
   it "Sequel.{+,-,*,/} should accept arguments and use the appropriate operator" do
     %w'+ - * /'.each do |op|
-      l(Sequel.send(op, 1), '(1)')
+      l(Sequel.send(op, 1), '1')
       l(Sequel.send(op, 1, 2), "(1 #{op} 2)")
       l(Sequel.send(op, 1, 2, 3), "(1 #{op} 2 #{op} 3)")
     end

data/spec/core/object_graph_spec.rb

@@ -104,11 +104,20 @@ describe Sequel::Dataset, "graphing" do
 
     it "should accept a SQL::Identifier as the dataset" do
       ds = @ds1.graph(Sequel.identifier(:lines), :x=>:id)
-      ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines AS lines ON (lines.x = points.id)'
+      ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
       ds = @ds1.graph(Sequel.identifier('lines'), :x=>:id)
       ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN lines AS lines ON (lines.x = points.id)'
     end
 
+    it "should handle a SQL::Identifier with double underscores correctly" do
+      ds = @ds1.graph(Sequel.identifier(:lin__es), :x=>:id)
+      ds.sql.should == 'SELECT points.id, points.x, points.y, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM points LEFT OUTER JOIN lin__es ON (lin__es.x = points.id)'
+      ds = @ds1.from(Sequel.identifier(:poi__nts)).graph(Sequel.identifier(:lin__es), :x=>:id)
+      ds.sql.should == 'SELECT poi__nts.id, poi__nts.name, poi__nts.x, poi__nts.y, poi__nts.lines_x, lin__es.id AS lin__es_id, lin__es.name AS lin__es_name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x AS lin__es_lines_x FROM poi__nts LEFT OUTER JOIN lin__es ON (lin__es.x = poi__nts.id)'
+      ds = @ds1.from(Sequel.identifier(:poi__nts).qualify(:foo)).graph(Sequel.identifier(:lin__es).qualify(:bar), :x=>:id)
+      ds.sql.should == 'SELECT foo.poi__nts.id, foo.poi__nts.x, foo.poi__nts.y, foo.poi__nts.graph_id, lin__es.id AS lin__es_id, lin__es.name, lin__es.x AS lin__es_x, lin__es.y AS lin__es_y, lin__es.lines_x FROM foo.poi__nts LEFT OUTER JOIN bar.lin__es AS lin__es ON (lin__es.x = foo.poi__nts.id)'
+    end
+
     it "should accept a SQL::QualifiedIdentifier as the dataset" do
       ds = @ds1.graph(Sequel.qualify(:schema, :lines), :x=>:id)
       ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN schema.lines AS lines ON (lines.x = points.id)'
@@ -120,6 +129,13 @@ describe Sequel::Dataset, "graphing" do
       ds.sql.should == 'SELECT points.id, points.x, points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM points LEFT OUTER JOIN schema.lines AS lines ON (lines.x = points.id)'
     end
 
+    it "should handle a qualified identifier as the source" do
+      ds = @ds1.from(:schema__points).graph(:lines, :x=>:id)
+      ds.sql.should == 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
+      ds = @ds1.from(Sequel.qualify(:schema, :points)).graph(:lines, :x=>:id)
+      ds.sql.should == 'SELECT schema.points.id, schema.points.x, schema.points.y, lines.id AS lines_id, lines.x AS lines_x, lines.y AS lines_y, lines.graph_id FROM schema.points LEFT OUTER JOIN lines ON (lines.x = schema.points.id)'
+    end
+
     it "should accept a SQL::AliasedExpression as the dataset" do
       ds = @ds1.graph(Sequel.as(:lines, :foo), :x=>:id)
       ds.sql.should == 'SELECT points.id, points.x, points.y, foo.id AS foo_id, foo.x AS foo_x, foo.y AS foo_y, foo.graph_id FROM points LEFT OUTER JOIN lines AS foo ON (foo.x = points.id)'

data/spec/core/placeholder_literalizer_spec.rb

@@ -0,0 +1,128 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Dataset::PlaceholderLiteralizer" do
+  before do
+    @c = Sequel::Dataset::PlaceholderLiteralizer
+    @db = Sequel.mock
+    @ds = @db[:items]
+    @h = {:id=>1}
+    @ds.db.fetch = @h
+  end
+  
+  specify "should handle calls with no placeholders" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>1)}
+    loader.first.should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should handle calls with a single placeholder" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.first(1).should == @h
+    loader.first(2).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)", "SELECT * FROM items WHERE (a = 2)"]
+  end
+  
+  specify "should handle calls with multiple placeholders" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg).where(:b=>Sequel.+(pl.arg, 1)).where(pl.arg)}
+    loader.first(1, :c, :id=>1).should == @h
+    loader.first(2, :d, :id=>2).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE ((a = 1) AND (b = (c + 1)) AND (id = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = (d + 1)) AND (id = 2))"]
+  end
+  
+  specify "should handle calls with a placeholders used as filter arguments" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(pl.arg)}
+    loader.first(:id=>1).should == @h
+    loader.first(proc{a(b)}).should == @h
+    loader.first("a = 1").should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE (id = 1)", "SELECT * FROM items WHERE a(b)", "SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should handle calls with a placeholders used as right hand side of condition specifiers" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.first(1).should == @h
+    loader.first([1, 2]).should == @h
+    loader.first(nil).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)", "SELECT * FROM items WHERE (a IN (1, 2))", "SELECT * FROM items WHERE (a IS NULL)"]
+  end
+  
+  specify "should handle calls with a placeholder used multiple times" do
+    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(:a=>a).where(:b=>a)}
+    loader.first(1).should == @h
+    loader.first(2).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE ((a = 1) AND (b = 1))", "SELECT * FROM items WHERE ((a = 2) AND (b = 2))"]
+  end
+  
+  specify "should handle calls with a placeholder used multiple times in different capacities" do
+    loader = @c.loader(@ds){|pl, ds| a = pl.arg; ds.where(a).where(:b=>a)}
+    loader.first("a = 1").should == @h
+    loader.first(["a = ?", 2]).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE ((a = 1) AND (b = 'a = 1'))", "SELECT * FROM items WHERE ((a = 2) AND (b IN ('a = ?', 2)))"]
+  end
+  
+  specify "should handle calls with manually specified argument positions" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg(1)).where(:b=>pl.arg(0))}
+    loader.first(1, 2).should == @h
+    loader.first(2, 1).should == @h
+    @db.sqls.should == ["SELECT * FROM items WHERE ((a = 2) AND (b = 1))", "SELECT * FROM items WHERE ((a = 1) AND (b = 2))"]
+  end
+  
+  specify "should handle dataset with row procs" do
+    @ds.row_proc = proc{|r| {:foo=>r[:id]+1}}
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.first(1).should == {:foo=>2}
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should return all rows for #all" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.all(1).should == [@h]
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should iterate over block for #all" do
+    a = []
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.all(1){|r| a << r}.should == [@h]
+    a.should == [@h]
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should iterate over block for #each" do
+    a = []
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.each(1){|r| a << r}
+    a.should == [@h]
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 1)"]
+  end
+  
+  specify "should return first value for #get" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    loader.get(2).should == 1
+    @db.sqls.should == ["SELECT * FROM items WHERE (a = 2)"]
+  end
+
+  specify "should raise an error if called with an incorrect number of arguments" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg)}
+    proc{loader.first}.should raise_error(Sequel::Error)
+    proc{loader.first(1, 2)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if called with an incorrect number of arguments when manually providing argument positions" do
+    loader = @c.loader(@ds){|pl, ds| ds.where(:a=>pl.arg(1))}
+    proc{loader.first}.should raise_error(Sequel::Error)
+    proc{loader.first(1)}.should raise_error(Sequel::Error)
+    proc{loader.first(1, 2, 3)}.should raise_error(Sequel::Error)
+  end
+
+  specify "should raise an error if argument literalized into a different string than returned by query" do
+    o = Object.new
+    def o.wrap(v)
+      @v = v
+      self
+    end
+    def o.sql_literal(ds)
+      ds.literal(@v)
+    end
+    proc{@c.loader(@ds){|pl, ds| ds.where(o.wrap(pl.arg))}}.should raise_error(Sequel::Error)
+  end
+end

data/spec/core/schema_spec.rb

@@ -701,6 +701,12 @@ describe "DB#create_table!" do
     @db.create_table!(:cats){|*a|}
     @db.sqls.should == ['DROP TABLE cats', 'CREATE TABLE cats ()']
   end
+  
+  specify "should use IF EXISTS if the database supports it" do
+    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.create_table!(:cats){|*a|}
+    @db.sqls.should == ['DROP TABLE IF EXISTS cats', 'CREATE TABLE cats ()']
+  end
 end
 
 describe "DB#create_table?" do
@@ -775,6 +781,54 @@ describe "DB#create_join_table" do
   end
 end
   
+describe "DB#create_join_table?" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should create the table if it does not already exist" do
+    meta_def(@db, :table_exists?){|a| false}
+    @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+
+  specify "should not create the table if it already exists" do
+    meta_def(@db, :table_exists?){|a| true}
+    @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == []
+  end
+
+  specify "should use IF NOT EXISTS if the database supports it" do
+    meta_def(@db, :supports_create_table_if_not_exists?){true}
+    @db.create_join_table?(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['CREATE TABLE IF NOT EXISTS cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+end
+  
+describe "DB#create_join_table!" do
+  before do
+    @db = Sequel.mock
+  end
+  
+  specify "should drop the table first if it already exists" do
+    meta_def(@db, :table_exists?){|a| true}
+    @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['DROP TABLE cats_dogs', 'CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+
+  specify "should not drop the table if it doesn't exists" do
+    meta_def(@db, :table_exists?){|a| false}
+    @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+
+  specify "should use IF EXISTS if the database supports it" do
+    meta_def(@db, :supports_drop_table_if_exists?){true}
+    @db.create_join_table!(:cat_id=>:cats, :dog_id=>:dogs)
+    @db.sqls.should == ['DROP TABLE IF EXISTS cats_dogs', 'CREATE TABLE cats_dogs (cat_id integer NOT NULL REFERENCES cats, dog_id integer NOT NULL REFERENCES dogs, PRIMARY KEY (cat_id, dog_id))', 'CREATE INDEX cats_dogs_dog_id_cat_id_index ON cats_dogs (dog_id, cat_id)']
+  end
+end
+  
 describe "DB#drop_join_table" do
   before do
     @db = Sequel.mock