sequel 5.2.0 → 5.3.0

data/spec/core/database_spec.rb

@@ -102,6 +102,18 @@ describe "A new Database" do
   end
 end
 
+describe "Database :connect_sqls option" do
+  it "should issue the each sql query for each new connection" do
+    db = Sequel.mock(:connect_sqls=>['SELECT 1', 'SELECT 2'])
+    db.sqls.must_equal ['SELECT 1', 'SELECT 2']
+    db['SELECT 3'].get
+    db.sqls.must_equal ['SELECT 3']
+    db.disconnect
+    db['SELECT 3'].get
+    db.sqls.must_equal ['SELECT 1', 'SELECT 2', 'SELECT 3']
+  end
+end
+
 describe "Database#freeze" do
   before do
     @db = Sequel.mock.freeze
@@ -510,6 +522,12 @@ describe "Database#extend_datasets custom methods" do
     ds.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
   end
 
+  it "should have dataset_module support a reverse method" do
+    @db.extend_datasets{reverse(:foo){:baz}}
+    ds.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz DESC'
+    ds.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz DESC'
+  end
+
   it "should have dataset_module support a select method" do
     @db.extend_datasets{select :foo, :baz}
     ds.foo.sql.must_equal 'SELECT baz FROM items'
@@ -2547,6 +2565,20 @@ describe "Database extensions" do
     Sequel.mock.a.must_equal 1
     Sequel.mock.b.must_equal 2
   end
+
+  it "should be loadable via the :extensions Database option" do
+    Sequel::Database.register_extension(:a, Module.new{def a; 1; end})
+    Sequel::Database.register_extension(:b, Module.new{def b; 2; end})
+    Sequel.mock(:extensions=>:a).a.must_equal 1
+    db = Sequel.mock(:extensions=>'a,b')
+    db.a.must_equal 1
+    db.b.must_equal 2
+    db = Sequel.mock(:extensions=>[:a, :b])
+    db.a.must_equal 1
+    db.b.must_equal 2
+    proc{Sequel.mock(:extensions=>nil).a}.must_raise NoMethodError
+    proc{Sequel.mock(:extensions=>Object.new)}.must_raise Sequel::Error
+  end
 end
 
 describe "Database specific exception classes" do

data/spec/core/dataset_spec.rb

@@ -378,6 +378,15 @@ describe "Dataset#where" do
     @dataset.where(nil).sql.must_equal "SELECT * FROM test WHERE NULL"
   end
   
+  deprecated "should handle nil block result has no existing filter" do
+    @dataset.where{nil}.sql.must_equal "SELECT * FROM test"
+  end
+
+  # SEQUEL54
+  it "should handle nil block result has no existing filter" do
+    @dataset.where{nil}.sql.must_equal "SELECT * FROM test WHERE NULL"
+  end if false
+  
   it "should just clone if given an empty array or hash argument" do
     @dataset.where({}).sql.must_equal @dataset.sql
     @dataset.where([]).sql.must_equal @dataset.sql
@@ -3568,6 +3577,16 @@ describe "Dataset#insert_sql" do
   it "should use unaliased table name" do
     @ds.from(Sequel.as(:items, :i)).insert_sql(1).must_equal "INSERT INTO items VALUES (1)"
   end
+
+  it "should hoist WITH clauses from query if the dataset doesn't support CTEs in subselects" do
+    @ds = @ds.with_extend do
+      Sequel::Dataset.def_sql_method(self, :insert, %w'with insert into columns values')
+      def supports_cte?(type=:select); true end
+      def supports_cte_in_subselect?; false end
+    end
+    @ds.insert_sql(@ds.from(:foo).with(:foo, @ds.select(:bar))).must_equal 'WITH foo AS (SELECT bar FROM items) INSERT INTO items SELECT * FROM foo'
+    @ds.insert_sql([:a], @ds.from(:foo).with(:foo, @ds.select(:bar))).must_equal 'WITH foo AS (SELECT bar FROM items) INSERT INTO items (a) SELECT * FROM foo'
+  end
 end
 
 describe "Dataset#inspect" do

data/spec/core/mock_adapter_spec.rb

@@ -577,6 +577,71 @@ describe "PostgreSQL support" do
     inf = -1.0/0.0
     @db[:test5].insert_sql(:value => inf).must_equal %q{INSERT INTO "test5" ("value") VALUES ('-Infinity')}
   end
+
+  it "Dataset#insert_conflict should respect expressions in the target argument" do
+    @ds = @db[:ic_test]
+    @ds.insert_conflict(:target=>:a).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"a\") DO NOTHING"
+    @ds.insert_conflict(:target=>:c, :conflict_where=>{:c_is_unique=>true}).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"c\") WHERE (\"c_is_unique\" IS TRUE) DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, :c]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", \"c\") DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.function(:round, :c)]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
+    @ds.insert_conflict(:target=>[:b, Sequel.virtual_row{|o| o.round(:c)}]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
+  end
+
+  it "should support creating and dropping foreign tables" do
+    @db.create_table(:t, :foreign=>:f, :options=>{:o=>1}){Integer :a}
+    @db.drop_table(:t, :foreign=>true)
+    @db.sqls.must_equal ['CREATE FOREIGN TABLE "t" ("a" integer) SERVER "f" OPTIONS (o \'1\')',
+      'DROP FOREIGN TABLE "t"']
+  end
+
+  it "#create_function and #drop_function should create and drop functions" do
+    @db.create_function('tf', 'SELECT 1', :returns=>:integer)
+    @db.drop_function('tf')
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ["CREATE FUNCTION tf() RETURNS integer LANGUAGE SQL AS 'SELECT 1'",
+      'DROP FUNCTION tf()']
+  end
+
+  it "#create_function and #drop_function should support options" do
+    @db.create_function('tf', 'SELECT $1 + $2', :args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'})
+    @db.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer])
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ["CREATE OR REPLACE FUNCTION tf(a integer, integer) RETURNS integer LANGUAGE SQL IMMUTABLE STRICT SECURITY DEFINER COST 2 SET search_path = public AS 'SELECT $1 + $2'",
+      'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE']
+  end
+
+  it "#create_language and #drop_language should create and drop languages" do
+    @db.create_language(:plpgsql)
+    @db.create_language(:plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b)
+    @db.drop_language(:plpgsql)
+    @db.drop_language(:plpgsql, :if_exists=>true, :cascade=>true)
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ['CREATE LANGUAGE plpgsql',
+      'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b',
+      'DROP LANGUAGE plpgsql',
+      'DROP LANGUAGE IF EXISTS plpgsql CASCADE']
+  end
+
+  it "#create_schema and #drop_schema should create and drop schemas" do
+    @db.create_schema(:sequel)
+    @db.create_schema(:sequel, :if_not_exists=>true, :owner=>:foo)
+    @db.drop_schema(:sequel)
+    @db.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
+    @db.sqls.must_equal ['CREATE SCHEMA "sequel"',
+      'CREATE SCHEMA IF NOT EXISTS "sequel" AUTHORIZATION "foo"',
+      'DROP SCHEMA "sequel"',
+      'DROP SCHEMA IF EXISTS "sequel" CASCADE']
+  end
+
+  it "#create_trigger and #drop_trigger should create and drop triggers" do
+    @db.create_trigger(:test, :identity, :tf, :each_row=>true)
+    @db.create_trigger(:test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a'])
+    @db.create_trigger(:test, :identity, :tf, :each_row=>true, :when=> {Sequel[:new][:name] => 'b'})
+    @db.drop_trigger(:test, :identity)
+    @db.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
+    @db.sqls.map{|s| s.gsub(/\s+/, ' ').strip}.must_equal ['CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW EXECUTE PROCEDURE tf()',
+      'CREATE TRIGGER identity AFTER INSERT ON "test" EXECUTE PROCEDURE tf(1, \'a\')',
+      %q{CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW WHEN ("new"."name" = 'b') EXECUTE PROCEDURE tf()},
+      'DROP TRIGGER identity ON "test"',
+      'DROP TRIGGER IF EXISTS identity ON "test" CASCADE']
+  end
 end
 
 describe "MySQL support" do

data/spec/extensions/association_pks_spec.rb

@@ -105,13 +105,11 @@ describe "Sequel::Plugins::AssociationPks" do
 
   it "should set associated pks correctly for a many_to_many association" do
     @Album.load(:id=>2).tag_pks = [1, 3]
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[2].must_equal 'BEGIN'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls[4].must_equal 'COMMIT'
-    sqls.length.must_equal 5
+    @db.sqls.must_equal ["DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))",
+      'SELECT tag_id FROM albums_tags WHERE (album_id = 2)',
+      'BEGIN',
+      'INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)',
+      'COMMIT']
   end
 
   it "should return correct right-side associated cpks for one_to_many associations" do
@@ -161,10 +159,8 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should set associated pks correctly for left-side cpks for a one_to_many association" do
     @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last], :delay_pks=>false
     @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks = [1, 2]
-    sqls = @db.sqls
-    sqls[0].must_match(/UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/)
-    sqls[1].must_match(/UPDATE instruments SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(instruments.first = 'F1'\) AND \(instruments.last = 'L1'\) AND \(id NOT IN \(1, 2\)\)\)/)
-    sqls.length.must_equal 2
+    @db.sqls.must_equal ["UPDATE instruments SET first = 'F1', last = 'L1' WHERE (id IN (1, 2))",
+      "UPDATE instruments SET first = NULL, last = NULL WHERE ((instruments.first = 'F1') AND (instruments.last = 'L1') AND (id NOT IN (1, 2)))"]
   end
 
   it "should set associated pks correctly for left-side cpks for a many_to_many association" do
@@ -209,10 +205,8 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do
     @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last], :order=>:week, :delay_pks=>false
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks = [[1997, 1], [1997, 2]]
-    sqls = @db.sqls
-    sqls[0].must_match(/UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/)
-    sqls[1].must_match(/UPDATE hits SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(hits.first = 'F1'\) AND \(hits.last = 'L1'\) AND \(\(year, week\) NOT IN \(\(1997, 1\), \(1997, 2\)\)\)\)/)
-    sqls.length.must_equal 2
+    @db.sqls.must_equal ["UPDATE hits SET first = 'F1', last = 'L1' WHERE ((year, week) IN ((1997, 1), (1997, 2)))",
+      "UPDATE hits SET first = NULL, last = NULL WHERE ((hits.first = 'F1') AND (hits.last = 'L1') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"]
   end
 
   it "should set associated right-side cpks correctly for left-side cpks for a many_to_many association" do
@@ -238,13 +232,11 @@ describe "Sequel::Plugins::AssociationPks" do
     album = @Album.load(:id=>2)
     album.use_transactions = true
     album.tag_pks = [1, 3]
-    sqls = @db.sqls
-    sqls[0].must_equal "BEGIN"
-    sqls[1].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[2].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls[4].must_equal "COMMIT"
-    sqls.length.must_equal 5
+    @db.sqls.must_equal ["BEGIN",
+      "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))",
+      'SELECT tag_id FROM albums_tags WHERE (album_id = 2)',
+      'INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)',
+      "COMMIT"]
   end
 
   it "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
@@ -264,22 +256,23 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
     @Tag.db_schema[:id][:type] = :integer
     @Album.load(:id=>2).tag_pks = %w'1 3'
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/)
-    sqls.length.must_equal 5
+    @db.sqls.must_equal ["DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))",
+      'SELECT tag_id FROM albums_tags WHERE (album_id = 2)',
+      'BEGIN',
+      'INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)',
+      'COMMIT']
   end
 
   it "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
     @Tag.db_schema[:id][:type] = :string
     @Album.load(:id=>2).tag_pks = %w'1 3'
-    sqls = @db.sqls
-    sqls[0].must_equal "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
-    sqls[1].must_equal 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
-    sqls[3].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/)
-    sqls[4].must_match(/INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/)
-    sqls.length.must_equal 6
+    sqls = @db.sqls.must_equal [
+      "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))",
+      'SELECT tag_id FROM albums_tags WHERE (album_id = 2)',
+      'BEGIN',
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (2, '1')",
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (2, '3')",
+      'COMMIT']
   end
 
   it "should automatically convert keys to numbers for appropriate integer primary key for composite key associations" do

data/spec/extensions/class_table_inheritance_spec.rb

@@ -274,25 +274,19 @@ describe "class_table_inheritance plugin" do
 
   it "should insert the correct rows into all tables when inserting into parent class" do
     Employee.create(:name=>'E')
-    sqls = @db.sqls
-    sqls.length.must_equal 1
-    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Employee)', '(E|Employee)'\)/)
+    @db.sqls.must_equal ["INSERT INTO employees (name, kind) VALUES ('E', 'Employee')"]
   end
     
   it "should insert the correct rows into all tables when inserting into subclass without separate table" do
     Intern.create(:name=>'E')
-    sqls = @db.sqls
-    sqls.length.must_equal 1
-    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Intern)', '(E|Intern)'\)/)
+    @db.sqls.must_equal ["INSERT INTO employees (name, kind) VALUES ('E', 'Intern')"]
   end
     
   it "should insert the correct rows into all tables when inserting" do
     Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
-    sqls = @db.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Ceo)', '(E|Ceo)'\)/)
-    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
-    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
+    @db.sqls.must_equal ["INSERT INTO employees (name, kind) VALUES ('E', 'Ceo')",
+      "INSERT INTO managers (id, num_staff) VALUES (1, 2)",
+      "INSERT INTO executives (id, num_managers) VALUES (1, 3)"]
   end
     
   it "should insert the correct rows into all tables when inserting when insert_select is supported" do
@@ -306,22 +300,18 @@ describe "class_table_inheritance plugin" do
       end)
     end
     Ceo.create(:num_managers=>3, :num_staff=>2, :name=>'E')
-    sqls = @db.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Ceo)', '(E|Ceo)'\) RETURNING \*/)
-    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\) RETURNING \*/)
-    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\) RETURNING \*/)
+    @db.sqls.must_equal ["INSERT INTO employees (name, kind) VALUES ('E', 'Ceo') RETURNING *",
+      "INSERT INTO managers (id, num_staff) VALUES (1, 2) RETURNING *",
+      "INSERT INTO executives (id, num_managers) VALUES (1, 3) RETURNING *"]
   end
     
   it "should insert the correct rows into all tables with a given primary key" do
     e = Ceo.new(:num_managers=>3, :num_staff=>2, :name=>'E')
     e.id = 2
     e.save
-    sqls = @db.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Ceo'|2), ('E'|'Ceo'|2), ('E'|'Ceo'|2)\)/)
-    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/)
-    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
+    @db.sqls.must_equal ["INSERT INTO employees (id, name, kind) VALUES (2, 'E', 'Ceo')",
+      "INSERT INTO managers (id, num_staff) VALUES (2, 2)",
+      "INSERT INTO executives (id, num_managers) VALUES (2, 3)"]
   end
 
   it "should update the correct rows in all tables when updating parent class" do
@@ -463,22 +453,18 @@ describe "class_table_inheritance plugin without sti_key with :alias option" do
 
   it "should insert the correct rows into all tables when inserting" do
     Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
-    sqls = @db.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \(name\) VALUES \('E'\)/)
-    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/)
-    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/)
-    end
+    @db.sqls.must_equal ["INSERT INTO employees (name) VALUES ('E')",
+      "INSERT INTO managers (id, num_staff) VALUES (1, 2)",
+      "INSERT INTO executives (id, num_managers) VALUES (1, 3)"]
+  end
     
   it "should insert the correct rows into all tables with a given primary key" do
     e = Executive.new(:num_managers=>3, :num_staff=>2, :name=>'E')
     e.id = 2
     e.save
-    sqls = @db.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_match(/INSERT INTO employees \((name|id), (name|id)\) VALUES \(('E'|2), ('E'|2)\)/)
-    sqls[1].must_match(/INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/)
-    sqls[2].must_match(/INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/)
+    @db.sqls.must_equal ["INSERT INTO employees (id, name) VALUES (2, 'E')",
+      "INSERT INTO managers (id, num_staff) VALUES (2, 2)",
+      "INSERT INTO executives (id, num_managers) VALUES (2, 3)"]
   end
 
   it "should update the correct rows in all tables when updating" do

data/spec/extensions/composition_spec.rb

@@ -53,11 +53,8 @@ describe "Composition plugin" do
 
   it "should set column values even when not validating" do
     @c.composition :date, :mapping=>[:year, :month, :day]
-    @c.load({}).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
-    sql = DB.sqls.last
-    sql.must_include("year = 4")
-    sql.must_include("month = 8")
-    sql.must_include("day = 12")
+    @c.load(id: 1).set(:date=>Date.new(4, 8, 12)).save(:validate=>false)
+    DB.sqls.must_equal ['UPDATE items SET year = 4, month = 8, day = 12 WHERE (id = 1)']
   end
 
   it ".compositions should return the reflection hash of compositions" do
@@ -81,10 +78,7 @@ describe "Composition plugin" do
     @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
     @o.date.must_equal Date.new(2, 4, 6)
     @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 4")
-    sql.must_include("month = 8")
-    sql.must_include("day = 12")
+    DB.sqls.must_equal ['UPDATE items SET year = 4, month = 8, day = 12 WHERE (id = 1)']
   end
 
   it "should allow call super in composition getter and setter method definition in class" do
@@ -187,9 +181,7 @@ describe "Composition plugin" do
     @o.date.month.must_equal 6
     @o.date = c.new(3, 4)
     @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 6")
-    sql.must_include("month = 12")
+    DB.sqls.must_equal ['UPDATE items SET year = 6, month = 12, day = 3 WHERE (id = 1)']
   end
 
   it ":mapping option should work with an array of two pairs of symbols" do
@@ -209,9 +201,7 @@ describe "Composition plugin" do
     @o.date.m.must_equal 6
     @o.date = c.new(3, 4)
     @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 6")
-    sql.must_include("month = 12")
+    DB.sqls.must_equal ['UPDATE items SET year = 6, month = 12, day = 3 WHERE (id = 1)']
   end
 
   it ":mapping option :composer should return nil if all values are nil" do
@@ -223,10 +213,7 @@ describe "Composition plugin" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.date = nil
     @o.save
-    sql = DB.sqls.last
-    sql.must_include("year = NULL")
-    sql.must_include("month = NULL")
-    sql.must_include("day = NULL")
+    DB.sqls.must_equal ['UPDATE items SET year = NULL, month = NULL, day = NULL WHERE (id = 1)']
   end
 
   it "should work with frozen instances" do
@@ -249,10 +236,7 @@ describe "Composition plugin" do
     o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
     o.date.must_equal Date.new(1, 2, 3)
     o.save
-    sql = DB.sqls.last
-    sql.must_include("year = 1")
-    sql.must_include("month = 2")
-    sql.must_include("day = 3")
+    DB.sqls.must_equal ['UPDATE items SET year = 1, month = 2, day = 3 WHERE (id = 1)']
   end
 
   it "should freeze composition metadata when freezing model class" do

data/spec/extensions/list_spec.rb

@@ -92,15 +92,14 @@ describe "List plugin" do
     @sc.create(:scope_id=>1).values.must_equal(:id=>1, :scope_id=>1, :position=>1)
     @sc.create(:scope_id=>1).values.must_equal(:id=>2, :scope_id=>1, :position=>2)
     @sc.create(:scope_id=>2).values.must_equal(:id=>3, :scope_id=>2, :position=>1)
-    sqls = @db.sqls
-    sqls.slice!(7).must_match(/INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/)
-    sqls.slice!(4).must_match(/INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \([12], [12]\)/)
-    sqls.slice!(1).must_match(/INSERT INTO items \((scope_id|position), (scope_id|position)\) VALUES \(1, 1\)/)
-    sqls.must_equal ["SELECT max(position) AS max FROM items WHERE (scope_id = 1) LIMIT 1",
+    @db.sqls.must_equal ["SELECT max(position) AS max FROM items WHERE (scope_id = 1) LIMIT 1",
+      'INSERT INTO items (scope_id, position) VALUES (1, 1)',
       "SELECT * FROM items WHERE (id = 1) ORDER BY scope_id, position LIMIT 1",
       "SELECT max(position) AS max FROM items WHERE (scope_id = 1) LIMIT 1",
+      'INSERT INTO items (scope_id, position) VALUES (1, 2)',
       "SELECT * FROM items WHERE (id = 2) ORDER BY scope_id, position LIMIT 1",
       "SELECT max(position) AS max FROM items WHERE (scope_id = 2) LIMIT 1",
+      'INSERT INTO items (scope_id, position) VALUES (2, 1)',
       "SELECT * FROM items WHERE (id = 3) ORDER BY scope_id, position LIMIT 1"]
   end
 

data/spec/extensions/many_through_many_spec.rb

@@ -462,12 +462,12 @@ describe Sequel::Model, "many_through_many" do
 
   it "should not add associations methods directly to class" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
-    im = @c1.instance_methods.collect{|x| x.to_s}
-    im.must_include('tags')
-    im.must_include('tags_dataset')
-    im2 = @c1.instance_methods(false).collect{|x| x.to_s}
-    im2.wont_include('tags')
-    im2.wont_include('tags_dataset')
+    im = @c1.instance_methods
+    im.must_include(:tags)
+    im.must_include(:tags_dataset)
+    im2 = @c1.instance_methods(false)
+    im2.wont_include(:tags)
+    im2.wont_include(:tags_dataset)
   end
 
   it "should support after_load association callback" do
@@ -603,11 +603,9 @@ describe "many_through_many eager loading methods" do
   it "should eagerly load multiple associations in a single call" do
     a = @c1.eager(:tags, :albums).all
     a.must_equal [@c1.load(:id=>1)]
-    sqls = DB.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_equal 'SELECT * FROM artists'
-    sqls[1..-1].must_include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
-    sqls[1..-1].must_include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
+    DB.sqls.must_equal ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))',
+      'SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))']
     a = a.first
     a.tags.must_equal [Tag.load(:id=>2)]
     a.albums.must_equal [Album.load(:id=>3)]
@@ -617,11 +615,9 @@ describe "many_through_many eager loading methods" do
   it "should eagerly load multiple associations in separate" do
     a = @c1.eager(:tags).eager(:albums).all
     a.must_equal [@c1.load(:id=>1)]
-    sqls = DB.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_equal 'SELECT * FROM artists'
-    sqls[1..-1].must_include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
-    sqls[1..-1].must_include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
+    DB.sqls.must_equal ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))',
+      'SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))']
     a = a.first
     a.tags.must_equal [Tag.load(:id=>2)]
     a.albums.must_equal [Album.load(:id=>3)]
@@ -1585,12 +1581,12 @@ describe Sequel::Model, "one_through_many" do
 
   it "should not add associations methods directly to class" do
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
-    im = @c1.instance_methods.collect{|x| x.to_s}
-    im.must_include('tag')
-    im.must_include('tag_dataset')
-    im2 = @c1.instance_methods(false).collect{|x| x.to_s}
-    im2.wont_include('tag')
-    im2.wont_include('tag_dataset')
+    im = @c1.instance_methods
+    im.must_include(:tag)
+    im.must_include(:tag_dataset)
+    im2 = @c1.instance_methods(false)
+    im2.wont_include(:tag)
+    im2.wont_include(:tag_dataset)
   end
 
   it "should support after_load association callback" do
@@ -1681,11 +1677,9 @@ describe "one_through_many eager loading methods" do
   it "should eagerly load multiple associations in a single call" do
     a = @c1.eager(:tag, :album).all
     a.must_equal [@c1.load(:id=>1)]
-    sqls = DB.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_equal 'SELECT * FROM artists'
-    sqls[1..-1].must_include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
-    sqls[1..-1].must_include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
+    DB.sqls.must_equal ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))',
+      'SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))']
     a = a.first
     a.tag.must_equal Tag.load(:id=>2)
     a.album.must_equal Album.load(:id=>3)
@@ -1695,11 +1689,9 @@ describe "one_through_many eager loading methods" do
   it "should eagerly load multiple associations in separate" do
     a = @c1.eager(:tag).eager(:album).all
     a.must_equal [@c1.load(:id=>1)]
-    sqls = DB.sqls
-    sqls.length.must_equal 3
-    sqls[0].must_equal 'SELECT * FROM artists'
-    sqls[1..-1].must_include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
-    sqls[1..-1].must_include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))')
+    DB.sqls.must_equal ['SELECT * FROM artists',
+      'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))',
+      'SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1))']
     a = a.first
     a.tag.must_equal Tag.load(:id=>2)
     a.album.must_equal Album.load(:id=>3)