sequel 4.45.0 → 4.46.0

data/spec/extensions/column_select_spec.rb

@@ -24,26 +24,29 @@ describe "Sequel::Plugins::ColumnSelect" do
     @Album.dataset.sql.must_equal 'SELECT albs.id, albs.a, albs.b, albs.c FROM albs'
   end
 
-  it "should handle qualified tables" do
+  with_symbol_splitting "should handle splittable symbols" do
     @Album.dataset = :s__albums
     @Album.plugin :column_select
     @Album.dataset.sql.must_equal 'SELECT s.albums.id, s.albums.a, s.albums.b, s.albums.c FROM s.albums'
 
+    @Album.dataset = :albums___a
+    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
+
+    @Album.dataset = :s__albums___a
+    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
+  end
+
+  it "should handle qualified tables" do
     @Album.dataset = Sequel.qualify(:s2, :albums)
+    @Album.plugin :column_select
     @Album.dataset.sql.must_equal 'SELECT s2.albums.id, s2.albums.a, s2.albums.b, s2.albums.c FROM s2.albums'
   end
 
   it "should handle aliases" do
-    @Album.dataset = :albums___a
     @Album.plugin :column_select
-    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM albums AS a'
-
     @Album.dataset = Sequel.as(:albums, :b)
     @Album.dataset.sql.must_equal 'SELECT b.id, b.a, b.b, b.c FROM albums AS b'
 
-    @Album.dataset = :s__albums___a
-    @Album.dataset.sql.must_equal 'SELECT a.id, a.a, a.b, a.c FROM s.albums AS a'
-
     @Album.dataset = @Album.db[:albums].from_self
     @Album.dataset.sql.must_equal 'SELECT t1.id, t1.a, t1.b, t1.c FROM (SELECT * FROM albums) AS t1'
 
@@ -60,7 +63,7 @@ describe "Sequel::Plugins::ColumnSelect" do
     @Album.dataset.sql.must_equal 'SELECT name, artist FROM albums'
   end
 
-  it "should not add a explicit column selection on existing dataset with multiple tables" do
+  deprecated "should not add a explicit column selection on existing dataset with multiple tables" do
     @Album.dataset = @Album.db.from(:a1, :a2)
     @Album.plugin :column_select
     @Album.dataset.sql.must_equal 'SELECT * FROM a1, a2'
@@ -69,6 +72,15 @@ describe "Sequel::Plugins::ColumnSelect" do
     @Album.dataset.sql.must_equal 'SELECT * FROM a1 CROSS JOIN a2'
   end
 
+  it "should add a explicit column selection on existing dataset with a subquery" do
+    @Album.dataset = @Album.db.from(:a1, :a2).from_self(:alias=>:foo)
+    @Album.plugin :column_select
+    @Album.dataset.sql.must_equal 'SELECT foo.id, foo.a, foo.b, foo.c FROM (SELECT * FROM a1, a2) AS foo'
+
+    @Album.dataset = @Album.db.from(:a1).cross_join(:a2).from_self(:alias=>:foo)
+    @Album.dataset.sql.must_equal 'SELECT foo.id, foo.a, foo.b, foo.c FROM (SELECT * FROM a1 CROSS JOIN a2) AS foo'
+  end
+
   it "should use explicit column selection for many_to_many associations" do
     @Album.plugin :column_select
     @Album.many_to_many :albums, :class=>@Album, :left_key=>:l, :right_key=>:r, :join_table=>:j

data/spec/extensions/columns_introspection_spec.rb

@@ -20,17 +20,17 @@ describe "columns_introspection extension" do
     @db.sqls.length.must_equal 0
   end
 
-  it "should handle qualified symbols without a database query" do
+  with_symbol_splitting "should handle qualified symbols without a database query" do
     @ds.select(:t__x).columns.must_equal [:x]
     @db.sqls.length.must_equal 0
   end
 
-  it "should handle aliased symbols without a database query" do
+  with_symbol_splitting "should handle aliased symbols without a database query" do
     @ds.select(:x___a).columns.must_equal [:a]
     @db.sqls.length.must_equal 0
   end
 
-  it "should handle qualified and aliased symbols without a database query" do
+  with_symbol_splitting "should handle qualified and aliased symbols without a database query" do
     @ds.select(:t__x___a).columns.must_equal [:a]
     @db.sqls.length.must_equal 0
   end

data/spec/extensions/core_refinements_spec.rb

@@ -20,6 +20,9 @@ describe "Core refinements" do
   
   it "should support NOT via Symbol#~" do
     @d.l(~:x).must_equal 'NOT x'
+  end
+
+  with_symbol_splitting "should support NOT via Symbol#~ for splittable symbols" do
     @d.l(~:x__y).must_equal 'NOT x.y'
   end
   
@@ -97,7 +100,7 @@ describe "Core refinements" do
     @d.lit([:x.sql_function(1), 'y.z'.lit].sql_string_join(', ')).must_equal "(x(1) || ', ' || y.z)"
     @d.lit([:x, 1, :y].sql_string_join).must_equal "(x || '1' || y)"
     @d.lit([:x, 1, :y].sql_string_join(', ')).must_equal "(x || ', ' || '1' || ', ' || y)"
-    @d.lit([:x, 1, :y].sql_string_join(:y__z)).must_equal "(x || y.z || '1' || y.z || y)"
+    @d.lit([:x, 1, :y].sql_string_join(Sequel[:y][:z])).must_equal "(x || y.z || '1' || y.z || y)"
     @d.lit([:x, 1, :y].sql_string_join(1)).must_equal "(x || '1' || '1' || '1' || y)"
     @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).must_equal "(x || y.x || x.y || y)"
     @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).must_equal "(x || y || a || b)"
@@ -148,7 +151,7 @@ describe "Array#case and Hash#case" do
     @d.literal([[:x, :y]].case(:z)).must_equal '(CASE WHEN x THEN y ELSE z END)'
     @d.literal([[:x, :y], [:a, :b]].case(:z)).must_equal '(CASE WHEN x THEN y WHEN a THEN b ELSE z END)'
     @d.literal([[:x, :y], [:a, :b]].case(:z, :exp)).must_equal '(CASE exp WHEN x THEN y WHEN a THEN b ELSE z END)'
-    @d.literal([[:x, :y], [:a, :b]].case(:z, :exp__w)).must_equal '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
+    @d.literal([[:x, :y], [:a, :b]].case(:z, Sequel[:exp][:w])).must_equal '(CASE exp.w WHEN x THEN y WHEN a THEN b ELSE z END)'
   end
 
   it "should return SQL CASE expression with expression even if nil" do
@@ -173,8 +176,8 @@ describe "Array#sql_value_list and #sql_array" do
   end
 
   it "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]]).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
-    @d.filter("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
+    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]])).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x = 1) AND (y = 2)))'
+    @d.filter(Sequel.lit("(a, b) IN ?", [[:x, 1], [:y, 2]].sql_value_list)).sql.must_equal 'SELECT * WHERE ((a, b) IN ((x, 1), (y, 2)))'
   end
 
   it "should be no difference when used as a hash value" do
@@ -237,7 +240,9 @@ describe "#desc" do
   
   it "should format a DESC clause for a column ref" do
     @ds.literal(:test.desc).must_equal 'test DESC'
+  end
     
+  with_symbol_splitting "should format a DESC clause for a column ref with splittable symbol" do
     @ds.literal(:items__price.desc).must_equal 'items.price DESC'
   end
 
@@ -253,7 +258,9 @@ describe "#asc" do
   
   it "should format a ASC clause for a column ref" do
     @ds.literal(:test.asc).must_equal 'test ASC'
+  end
     
+  with_symbol_splitting "should format a ASC clause for a column ref with splittable symbol" do
     @ds.literal(:items__price.asc).must_equal 'items.price ASC'
   end
 
@@ -269,7 +276,9 @@ describe "#as" do
   
   it "should format a AS clause for a column ref" do
     @ds.literal(:test.as(:t)).must_equal 'test AS t'
+  end
     
+  with_symbol_splitting "should format a AS clause for a column ref with splittable symbols" do
     @ds.literal(:items__price.as(:p)).must_equal 'items.price AS p'
   end
 
@@ -289,13 +298,7 @@ describe "Column references" do
   
   it "should be quoted properly" do
     @ds.literal(:xyz).must_equal "`xyz`"
-    @ds.literal(:xyz__abc).must_equal "`xyz`.`abc`"
-
     @ds.literal(:xyz.as(:x)).must_equal "`xyz` AS `x`"
-    @ds.literal(:xyz__abc.as(:x)).must_equal "`xyz`.`abc` AS `x`"
-
-    @ds.literal(:xyz___x).must_equal "`xyz` AS `x`"
-    @ds.literal(:xyz__abc___x).must_equal "`xyz`.`abc` AS `x`"
   end
   
   it "should be quoted properly in SQL functions" do
@@ -311,6 +314,13 @@ describe "Column references" do
   
   it "should be quoted properly in a cast function" do
     @ds.literal(:x.cast(:integer)).must_equal "CAST(`x` AS integer)"
+  end
+
+  with_symbol_splitting "should be quoted properly when using splittable symbols" do
+    @ds.literal(:xyz__abc).must_equal "`xyz`.`abc`"
+    @ds.literal(:xyz__abc.as(:x)).must_equal "`xyz`.`abc` AS `x`"
+    @ds.literal(:xyz___x).must_equal "`xyz` AS `x`"
+    @ds.literal(:xyz__abc___x).must_equal "`xyz`.`abc` AS `x`"
     @ds.literal(:x__y.cast('varchar(20)')).must_equal "CAST(`x`.`y` AS varchar(20))"
   end
 end
@@ -337,7 +347,7 @@ describe "Symbol#*" do
     @ds.literal(:abc.*(5)).must_equal '(abc * 5)'
   end
 
-  it "should support qualified symbols if no argument" do
+  with_symbol_splitting "should support qualified symbols if no argument" do
     @ds.literal(:xyz__abc.*).must_equal 'xyz.abc.*'
   end
 end
@@ -360,6 +370,10 @@ describe "Symbol" do
   end
 
   it "should be able to qualify an identifier" do
+    @ds.literal(:xyz.identifier.qualify(Sequel[:xyz][:abc])).must_equal '"xyz"."abc"."xyz"'
+  end
+
+  with_symbol_splitting "should be able to qualify an identifier with qualified symbol" do
     @ds.literal(:xyz.identifier.qualify(:xyz__abc)).must_equal '"xyz"."abc"."xyz"'
   end
 
@@ -398,9 +412,12 @@ describe "Symbol" do
     @ds.literal(:abc.cast(:integer)).must_equal "CAST(abc AS integer)"
   end
 
+  with_symbol_splitting "should support sql array accesses via sql_subscript for splittable symbols" do
+    @ds.literal(:abc__def.sql_subscript(1)).must_equal "abc.def[1]"
+  end
+
   it "should support sql array accesses via sql_subscript" do
     @ds.literal(:abc.sql_subscript(1)).must_equal "abc[1]"
-    @ds.literal(:abc__def.sql_subscript(1)).must_equal "abc.def[1]"
     @ds.literal(:abc.sql_subscript(1)|2).must_equal "abc[1, 2]"
     @ds.literal(:abc.sql_subscript(1)[2]).must_equal "abc[1][2]"
   end

data/spec/extensions/dataset_associations_spec.rb

@@ -100,7 +100,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
   end
 
   it "should work for many_to_many associations with :dataset_association_join=>true" do
-    @Album.many_to_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    @Album.many_to_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:foo]]
     ds = @Album.tags
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Tag
@@ -108,7 +108,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
   end
 
   it "should work for one_through_one associations with :dataset_association_join=>true" do
-    @Album.one_through_one :first_tag, :clone=>:first_tag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    @Album.one_through_one :first_tag, :clone=>:first_tag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:foo]]
     ds = @Album.first_tags
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Tag
@@ -116,7 +116,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
   end
 
   it "should work for many_through_many associations with :dataset_association_join=>true" do
-    @Artist.many_through_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    @Artist.many_through_many :tags, :clone=>:tags, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:foo]]
     ds = @Artist.tags
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Tag
@@ -124,7 +124,7 @@ describe "Sequel::Plugins::DatasetAssociations" do
   end
 
   it "should work for one_through_many associations with :dataset_association_join=>true" do
-    @Artist.one_through_many :otag, :clone=>:otag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, :albums_tags__foo]
+    @Artist.one_through_many :otag, :clone=>:otag, :dataset_associations_join=>true, :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:foo]]
     ds = @Artist.otags
     ds.must_be_kind_of(Sequel::Dataset)
     ds.model.must_equal @Tag
@@ -227,22 +227,22 @@ describe "Sequel::Plugins::DatasetAssociations" do
   end
 
   it "should deal correctly with :order option for one_through_one associations" do
-    @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>:tags__name
+    @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>Sequel[:tags][:name]
     @Album.first_tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT DISTINCT ON (albums_tags.album_id) albums_tags.album_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) ORDER BY albums_tags.album_id, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_to_many associations" do
-    @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
+    @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>Sequel[:tags][:name]
     @Album.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) WHERE (((albums_tags.album_id) IN (SELECT albums.id FROM albums)) AND ((albums_tags.album_id, tags.id) IN (SELECT b, c FROM (SELECT albums_tags.album_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_tags.album_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :order option for one_through_many associations" do
-    @Artist.one_through_many :otag, :clone=>:otag, :order=>:tags__name
+    @Artist.one_through_many :otag, :clone=>:otag, :order=>Sequel[:tags][:name]
     @Artist.otags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT DISTINCT ON (albums.artist_id) albums.artist_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) ORDER BY albums.artist_id, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_through_many associations" do
-    @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
+    @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>Sequel[:tags][:name]
     @Artist.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id) INNER JOIN tags ON (tags.id = albums_tags.tag_id) WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND ((albums.artist_id, tags.id) IN (SELECT b, c FROM (SELECT albums.artist_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums.artist_id ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id)) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 end
@@ -331,22 +331,22 @@ describe "Sequel::Plugins::DatasetAssociations with composite keys" do
   end
 
   it "should deal correctly with :order option for one_through_one associations" do
-    @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>:tags__name
+    @Album.one_through_one :first_tag, :clone=>:first_tag, :order=>Sequel[:tags][:name]
     @Album.first_tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums_tags.album_id1, albums_tags.album_id2) albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) ORDER BY albums_tags.album_id1, albums_tags.album_id2, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_to_many associations" do
-    @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
+    @Album.many_to_many :tags, :clone=>:tags, :limit=>10, :order=>Sequel[:tags][:name]
     @Album.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) WHERE (((albums_tags.album_id1, albums_tags.album_id2) IN (SELECT albums.id1, albums.id2 FROM albums)) AND ((albums_tags.album_id1, albums_tags.album_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums_tags.album_id1 AS b, albums_tags.album_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums_tags.album_id1, albums_tags.album_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :order option for one_through_many associations" do
-    @Artist.one_through_many :otag, :clone=>:otag, :order=>:tags__name
+    @Artist.one_through_many :otag, :clone=>:otag, :order=>Sequel[:tags][:name]
     @Artist.otags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.artist_id1, albums.artist_id2, tags.id1, tags.id2 FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2)) ORDER BY albums.artist_id1, albums.artist_id2, tags.name))))) ORDER BY tags.name'
   end
 
   it "should deal correctly with :limit option for many_through_many associations" do
-    @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>:tags__name
+    @Artist.many_through_many :tags, :clone=>:tags, :limit=>10, :order=>Sequel[:tags][:name]
     @Artist.tags.sql.must_equal 'SELECT tags.* FROM tags WHERE ((tags.id1, tags.id2) IN (SELECT albums_tags.tag_id1, albums_tags.tag_id2 FROM artists INNER JOIN albums ON ((albums.artist_id1 = artists.id1) AND (albums.artist_id2 = artists.id2)) INNER JOIN albums_tags ON ((albums_tags.album_id1 = albums.id1) AND (albums_tags.album_id2 = albums.id2)) INNER JOIN tags ON ((tags.id1 = albums_tags.tag_id1) AND (tags.id2 = albums_tags.tag_id2)) WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.artist_id1, albums.artist_id2, tags.id1, tags.id2) IN (SELECT b, c, d, e FROM (SELECT albums.artist_id1 AS b, albums.artist_id2 AS c, tags.id1 AS d, tags.id2 AS e, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY tags.name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id1 = tags.id1) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id1 = albums_tags.album_id1) AND (albums.id2 = albums_tags.album_id2))) AS t1 WHERE (x_sequel_row_number_x <= 10)))))) ORDER BY tags.name'
   end
 end

data/spec/extensions/def_dataset_method_spec.rb

@@ -0,0 +1,100 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Model, ".def_dataset_method" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.plugin :def_dataset_method
+  end
+  
+  it "should add a method to the dataset and model if called with a block argument" do
+    @c.def_dataset_method(:return_3){3}
+    @c.return_3.must_equal 3
+    @c.dataset.return_3.must_equal 3
+  end
+
+  it "should handle weird method names" do
+    @c.def_dataset_method(:"return 3"){3}
+    @c.send(:"return 3").must_equal 3
+    @c.dataset.send(:"return 3").must_equal 3
+  end
+
+  it "should not add a model method if the model already responds to the method" do
+    @c.instance_eval do
+      def foo
+        1
+      end
+
+      private
+
+      def bar
+        2
+      end
+
+      def_dataset_method(:foo){3}
+      def_dataset_method(:bar){4}
+    end
+    @c.foo.must_equal 1
+    @c.dataset.foo.must_equal 3
+    @c.send(:bar).must_equal 2
+    @c.dataset.bar.must_equal 4
+  end
+
+  it "should add all passed methods to the model if called without a block argument" do
+    @c.def_dataset_method(:return_3, :return_4)
+    proc{@c.return_3}.must_raise(NoMethodError)
+    proc{@c.return_4}.must_raise(NoMethodError)
+    @c.dataset = @c.dataset.with_extend do
+      def return_3; 3; end
+      def return_4; 4; end
+    end
+    @c.return_3.must_equal 3
+    @c.return_4.must_equal 4
+  end
+
+  it "should cache calls and readd methods if set_dataset is used" do
+    @c.def_dataset_method(:return_3){3}
+    @c.set_dataset :items
+    @c.return_3.must_equal 3
+    @c.dataset.return_3.must_equal 3
+  end
+
+  it "should readd methods to subclasses, if set_dataset is used in a subclass" do
+    @c.def_dataset_method(:return_3){3}
+    c = Class.new(@c)
+    c.set_dataset :items
+    c.return_3.must_equal 3
+    c.dataset.return_3.must_equal 3
+  end
+end
+
+describe Sequel::Model, ".subset" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.plugin :def_dataset_method
+    DB.reset
+  end
+
+  it "should create a filter on the underlying dataset" do
+    proc {@c.new_only}.must_raise(NoMethodError)
+    
+    @c.subset(:new_only){age < 'new'}
+    
+    @c.new_only.sql.must_equal "SELECT * FROM items WHERE (age < 'new')"
+    @c.dataset.new_only.sql.must_equal "SELECT * FROM items WHERE (age < 'new')"
+    
+    @c.subset(:pricey){price > 100}
+    
+    @c.pricey.sql.must_equal "SELECT * FROM items WHERE (price > 100)"
+    @c.dataset.pricey.sql.must_equal "SELECT * FROM items WHERE (price > 100)"
+    
+    @c.pricey.new_only.sql.must_equal "SELECT * FROM items WHERE ((price > 100) AND (age < 'new'))"
+    @c.new_only.pricey.sql.must_equal "SELECT * FROM items WHERE ((age < 'new') AND (price > 100))"
+  end
+
+  it "should not override existing model methods" do
+    def @c.active() true end
+    @c.subset(:active, :active)
+    @c.active.must_equal true
+  end
+end
+

data/spec/extensions/error_sql_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "error_sql extension" do
   before do
-    @db = Sequel.mock(:fetch=>proc{|sql| @db.log_yield(sql){raise StandardError}}).extension(:error_sql)
+    @db = Sequel.mock(:fetch=>proc{|sql| @db.log_connection_yield(sql, nil){raise StandardError}}).extension(:error_sql)
   end
 
   it "should have Sequel::DatabaseError#sql give the SQL causing the error" do

data/spec/extensions/finder_spec.rb

@@ -0,0 +1,260 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe Sequel::Model, ".finder" do
+  before do
+    @h = {:id=>1}
+    @db = Sequel.mock(:fetch=>@h)
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.instance_eval do
+      def foo(a, b)
+        where(:bar=>a).order(b)
+      end
+    end
+    @c.plugin :finder
+    @o = @c.load(@h)
+    @db.sqls
+  end
+
+  it "should create a method that calls the method given and returns the first instance" do
+    @c.finder :foo
+    @c.first_foo(1, 2).must_equal @o
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  it "should work correctly when subclassing" do
+    @c.finder(:foo)
+    @sc = Class.new(@c)
+    @sc.set_dataset :foos
+    @db.sqls
+    @sc.first_foo(1, 2).must_equal @sc.load(@h)
+    @sc.first_foo(3, 4).must_equal @sc.load(@h)
+    @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  it "should work correctly when dataset is modified" do
+    @c.finder(:foo)
+    @c.first_foo(1, 2).must_equal @o
+    @c.set_dataset :foos
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  it "should create a method based on the given block if no method symbol provided" do
+    @c.finder(:name=>:first_foo){|pl, ds| ds.where(pl.arg).limit(1)}
+    @c.first_foo(:id=>1).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+  end
+
+  it "should raise an error if both a block and method symbol given" do
+    proc{@c.finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if two option hashes are provided" do
+    proc{@c.finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
+  end
+
+  it "should support :type option" do
+    @c.finder :foo, :type=>:all
+    @c.finder :foo, :type=>:each
+    @c.finder :foo, :type=>:get
+
+    a = []
+    @c.all_foo(1, 2){|r| a << r}.must_equal [@o]
+    a.must_equal [@o]
+   
+    a = []
+    @c.each_foo(3, 4){|r| a << r}
+    a.must_equal [@o]
+
+    @c.get_foo(5, 6).must_equal 1
+
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4", "SELECT * FROM items WHERE (bar = 5) ORDER BY 6 LIMIT 1"]
+  end
+
+  it "should support :name option" do
+    @c.finder :foo, :name=>:find_foo
+    @c.find_foo(1, 2).must_equal @o
+    @c.find_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  it "should support :arity option" do
+    def @c.foobar(*b)
+      ds = dataset
+      b.each_with_index do |a, i|
+        ds = ds.where(i=>a)
+      end
+      ds
+    end
+    @c.finder :foobar, :arity=>1, :name=>:find_foobar_1
+    @c.finder :foobar, :arity=>2, :name=>:find_foobar_2
+    @c.find_foobar_1(:a)
+    @c.find_foobar_2(:a, :b)
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1"]
+  end
+
+  it "should support :mod option" do
+    m = Module.new
+    @c.finder :foo, :mod=>m
+    proc{@c.first_foo}.must_raise NoMethodError
+    @c.extend m
+    @c.first_foo(1, 2).must_equal @o
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1"]
+  end
+
+  it "should raise error when calling with the wrong arity" do
+    @c.finder :foo
+    proc{@c.first_foo(1)}.must_raise Sequel::Error
+    proc{@c.first_foo(1,2,3)}.must_raise Sequel::Error
+  end
+end
+
+describe Sequel::Model, ".prepared_finder" do
+  before do
+    @h = {:id=>1}
+    @db = Sequel.mock(:fetch=>@h)
+    @db.extend_datasets do
+      def select_sql
+        sql = super
+        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
+        sql
+      end
+    end
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.instance_eval do
+      def foo(a, b)
+        where(:bar=>a).order(b)
+      end
+    end
+    @c.plugin :finder
+    @o = @c.load(@h)
+    @db.sqls
+  end
+
+  it "should create a method that calls the method given and returns the first instance" do
+    @c.prepared_finder :foo
+    @c.first_foo(1, 2).must_equal @o
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
+  end
+
+  it "should work correctly when subclassing" do
+    @c.prepared_finder(:foo)
+    @sc = Class.new(@c)
+    @sc.set_dataset :foos
+    @db.sqls
+    @sc.first_foo(1, 2).must_equal @sc.load(@h)
+    @sc.first_foo(3, 4).must_equal @sc.load(@h)
+    @db.sqls.must_equal ["SELECT * FROM foos WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
+  end
+
+  it "should work correctly when dataset is modified" do
+    @c.prepared_finder(:foo)
+    @c.first_foo(1, 2).must_equal @o
+    @c.set_dataset :foos
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM foos LIMIT 1", "SELECT * FROM foos WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
+  end
+
+  it "should create a method based on the given block if no method symbol provided" do
+    @c.prepared_finder(:name=>:first_foo){|a1| where(:id=>a1).limit(1)}
+    @c.first_foo(1).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (id = 1) LIMIT 1 -- prepared"]
+  end
+
+  it "should raise an error if both a block and method symbol given" do
+    proc{@c.prepared_finder(:foo, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
+  end
+
+  it "should raise an error if two option hashes are provided" do
+    proc{@c.prepared_finder({:name2=>:foo}, :name=>:first_foo){|pl, ds| ds.where(pl.arg)}}.must_raise(Sequel::Error)
+  end
+
+  it "should support :type option" do
+    @c.prepared_finder :foo, :type=>:all
+    @c.prepared_finder :foo, :type=>:each
+
+    a = []
+    @c.all_foo(1, 2){|r| a << r}.must_equal [@o]
+    a.must_equal [@o]
+   
+    a = []
+    @c.each_foo(3, 4){|r| a << r}
+    a.must_equal [@o]
+
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 -- prepared"]
+  end
+
+  it "should support :name option" do
+    @c.prepared_finder :foo, :name=>:find_foo
+    @c.find_foo(1, 2).must_equal @o
+    @c.find_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
+  end
+
+  it "should support :arity option" do
+    def @c.foobar(*b)
+      ds = dataset
+      b.each_with_index do |a, i|
+        ds = ds.where(i=>a)
+      end
+      ds
+    end
+    @c.prepared_finder :foobar, :arity=>1, :name=>:find_foobar_1
+    @c.prepared_finder :foobar, :arity=>2, :name=>:find_foobar_2
+    @c.find_foobar_1(:a)
+    @c.find_foobar_2(:a, :b)
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (0 = a) LIMIT 1 -- prepared", "SELECT * FROM items WHERE ((0 = a) AND (1 = b)) LIMIT 1 -- prepared"]
+  end
+
+  it "should support :mod option" do
+    m = Module.new
+    @c.prepared_finder :foo, :mod=>m
+    proc{@c.first_foo}.must_raise NoMethodError
+    @c.extend m
+    @c.first_foo(1, 2).must_equal @o
+    @c.first_foo(3, 4).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared", "SELECT * FROM items WHERE (bar = 3) ORDER BY 4 LIMIT 1 -- prepared"]
+  end
+
+  it "should handle models with names" do
+    def @c.name; 'foobar' end
+    @c.prepared_finder :foo
+    @c.first_foo(1, 2).must_equal @o
+    @db.sqls.must_equal ["SELECT * FROM items WHERE (bar = 1) ORDER BY 2 LIMIT 1 -- prepared"]
+  end
+end
+
+describe "Sequel::Model.freeze" do
+  it "should freeze the model class and not allow any changes" do
+    model = Class.new(Sequel::Model(:items))
+    model.plugin :finder
+    model.finder(:name=>:f_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    model.freeze
+    model.f_by_name('a').must_equal model.call(:id=>1, :x=>1)
+    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+  end
+
+  it "should freeze a model class without a dataset without breaking" do
+    model = Class.new(Sequel::Model)
+    model.plugin :finder
+    model.freeze
+    proc{model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}}.must_raise RuntimeError, TypeError
+  end
+
+  it "should allow subclasses of frozen model classes to work correctly" do
+    model = Class.new(Sequel::Model(:items))
+    model.plugin :finder
+    model.freeze
+    model = Class.new(model)
+    model.dataset = :items2
+
+    model.dataset_module{}
+    model.plugin Module.new
+    model.finder(:name=>:first_by_name){|pl, ds| ds.where(:name=>pl.arg).limit(1)}
+    model.first_by_name('a').values.must_equal(:id=>1, :x=>1)
+  end
+end
+