sequel 4.39.0 → 4.40.0

data/spec/integration/associations_test.rb

@@ -36,7 +36,7 @@ OneToOneEagerGraphLimitStrategies = shared_description do
     @album.update(:artist => @artist)
     diff_album = @diff_album.call
     ar = @pr.call[1]
-    ds = Artist.order(:artists__name)
+    ds = Artist.order(Sequel[:artists][:name])
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     a = ds.eager_graph_with_options(:first_album, limit_strategy).all
@@ -105,7 +105,7 @@ OneToManyEagerGraphLimitStrategies = shared_description do
     middle_album = @middle_album.call
     diff_album = @diff_album.call
     ar = @pr.call[1]
-    ds = Artist.order(:artists__name)
+    ds = Artist.order(Sequel[:artists][:name])
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_two_albums, limit_strategy).all
@@ -164,7 +164,7 @@ OneThroughOneEagerGraphLimitStrategies = shared_description do
   it "should correctly handle offsets when eager graphing one_through_one associations" do
     tu, tv = @other_tags.call
     al = @pr.call.first
-    ds = Album.order(:albums__name)
+    ds = Album.order(Sequel[:albums][:name])
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     als = ds.eager_graph_with_options(:first_tag, limit_strategy).all
@@ -220,7 +220,7 @@ ManyToManyEagerGraphLimitStrategies = shared_description do
     tu, tv = @other_tags.call
     al = @pr.call.first
     al.add_tag(tu)
-    ds = Album.order(:albums__name)
+    ds = Album.order(Sequel[:albums][:name])
     limit_strategy = {:limit_strategy=>(@els||{})[:eager_limit_strategy]}
     
     als = ds.eager_graph_with_options(:first_two_tags, limit_strategy).all
@@ -287,7 +287,7 @@ ManyThroughManyEagerGraphLimitStrategies = shared_description do
     al, ar, _ = @pr.call
     al.update(:artist=>ar)
     al.add_tag(tu)
-    ds = Artist.order(:artists__name)
+    ds = Artist.order(Sequel[:artists][:name])
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_two_tags, limit_strategy).all
@@ -350,7 +350,7 @@ OneThroughManyEagerGraphLimitStrategies = shared_description do
     al, ar, _ = @pr.call
     al.update(:artist=>ar)
     al.add_tag(tu)
-    ds = Artist.order(:artists__name)
+    ds = Artist.order(Sequel[:artists][:name])
     limit_strategy = {:limit_strategy=>@els[:eager_limit_strategy]}
     
     ars = ds.eager_graph_with_options(:first_tag, limit_strategy).all
@@ -1060,7 +1060,7 @@ FilterByAssociationsOneToOneLimitStrategies = shared_description do
     ds.exclude(:last_album=>@album).all.must_equal [@artist, ar]
     ds.exclude(:last_album=>diff_album).all.must_equal [ar]
 
-    Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(:albums__name=>diff_album.name) end
+    Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(Sequel[:albums][:name]=>diff_album.name) end
     ar.add_album(diff_album)
     ds.where(:first_album=>[@album, diff_album]).all.must_equal [ar]
     ds.exclude(:first_album=>[@album, diff_album]).all.must_equal [@artist]
@@ -1086,7 +1086,7 @@ FilterByAssociationsSingularLimitStrategies = shared_description do
     ds.where(ar.pk_hash).second_albums.all.must_equal []
     ds.where(ar.pk_hash).last_albums.all.must_equal []
 
-    Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(:albums__name=>diff_album.name) end
+    Artist.one_to_one :first_album, :clone=>:first_album do |ads| ads.where(Sequel[:albums][:name]=>diff_album.name) end
     ar.add_album(diff_album)
     ds.where(@artist.pk_hash).first_albums.all.must_equal []
     ds.where(ar.pk_hash).first_albums.all.must_equal [diff_album]
@@ -1122,8 +1122,8 @@ FilterByAssociationsSingularLimitStrategies = shared_description do
     ds.exclude(:last_tag=>tu).all.must_equal [@album]
     ds.exclude(:last_tag=>tv).all.must_equal [al]
 
-    Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
-    Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(:first_tag=>[@tag, tu]).all.must_equal [@album, al]
     ds.exclude(:first_tag=>[@tag, tu]).all.must_equal []
@@ -1149,8 +1149,8 @@ FilterByAssociationsSingularLimitStrategies = shared_description do
     ds.where(al.pk_hash).second_tags.all.must_equal []
     ds.where(al.pk_hash).last_tags.all.must_equal [tu]
 
-    Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
-    Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Album.one_through_one :first_tag, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Album.one_through_one :second_tag, :clone=>:second_tag do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(@album.pk_hash).first_tags.all.must_equal [tu]
     ds.where(@album.pk_hash).second_tags.all.must_equal [tv]
@@ -1196,8 +1196,8 @@ FilterByAssociationsSingularLimitStrategies = shared_description do
     ds.exclude(:last_tag=>tu).all.must_equal [@artist]
     ds.exclude(:last_tag=>tv).all.must_equal [ar]
 
-    Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
-    Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(:first_tag=>[@tag, tu]).all.must_equal [@artist, ar]
     ds.exclude(:first_tag=>[@tag, tu]).all.must_equal []
@@ -1225,8 +1225,8 @@ FilterByAssociationsSingularLimitStrategies = shared_description do
     ds.where(ar.pk_hash).second_tags.all.must_equal []
     ds.where(ar.pk_hash).last_tags.all.must_equal [tu]
 
-    Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
-    Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Artist.one_through_many :first_tag, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Artist.one_through_many :second_tag, :clone=>:second_tag do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(@artist.pk_hash).first_tags.all.must_equal [tu]
     ds.where(@artist.pk_hash).second_tags.all.must_equal [tv]
@@ -1275,7 +1275,7 @@ FilterByAssociationsOneToManyLimitStrategies = shared_description do
       ds.exclude(a=>diff_album).all.must_equal [ar]
     end
 
-    Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(:albums__name=>diff_album.name) end
+    Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(Sequel[:albums][:name]=>diff_album.name) end
     ar.add_album(diff_album)
     ds.where(:first_two_albums=>[@album, diff_album]).all.must_equal [ar]
     ds.exclude(:first_two_albums=>[@album, diff_album]).all.must_equal [@artist]
@@ -1306,7 +1306,7 @@ FilterByAssociationsLimitStrategies = shared_description do
     ds.where(ar.pk_hash).not_first_albums.all.must_equal []
     ds.where(ar.pk_hash).last_two_albums.all.must_equal []
 
-    Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(:albums__name=>[diff_album.name, middle_album.name]) end
+    Artist.one_to_one :first_two_albums, :clone=>:first_two_albums do |ads| ads.where(Sequel[:albums][:name]=>[diff_album.name, middle_album.name]) end
     ar.add_album(diff_album)
     ds.where(@artist.pk_hash).first_two_albums.all.must_equal [middle_album]
     ds.where(ar.pk_hash).first_two_albums.all.must_equal [diff_album]
@@ -1350,8 +1350,8 @@ FilterByAssociationsLimitStrategies = shared_description do
     ds.exclude(:last_two_tags=>tu).all.must_equal []
     ds.exclude(:last_two_tags=>tv).all.must_equal [al]
 
-    Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
-    Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(:first_two_tags=>[@tag, tu]).all.must_equal [@album, al]
     ds.exclude(:first_two_tags=>[@tag, tu]).all.must_equal []
@@ -1380,8 +1380,8 @@ FilterByAssociationsLimitStrategies = shared_description do
     ds.where(al.pk_hash).not_first_tags.all.must_equal []
     ds.where(al.pk_hash).last_two_tags.all.must_equal [tu]
 
-    Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
-    Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Album.many_to_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Album.many_to_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(@album.pk_hash).first_two_tags.all.must_equal [tu]
     ds.where(@album.pk_hash).second_two_tags.all.must_equal [tv]
@@ -1435,8 +1435,8 @@ FilterByAssociationsLimitStrategies = shared_description do
     ds.exclude(:last_two_tags=>tu).all.must_equal []
     ds.exclude(:last_two_tags=>tv).all.must_equal [ar]
 
-    Artist.many_through_many :first_two_tags, :clone=>:first_tag do |ads| ads.where(:tags__name=>tu.name) end
-    Artist.many_through_many :second_two_tags, :clone=>:first_tag do |ads| ads.where(:tags__name=>[tv.name, tu.name]) end
+    Artist.many_through_many :first_two_tags, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Artist.many_through_many :second_two_tags, :clone=>:first_tag do |ads| ads.where(Sequel[:tags][:name]=>[tv.name, tu.name]) end
 
     ds.where(:first_two_tags=>[@tag, tu]).all.must_equal [@artist, ar]
     ds.exclude(:first_two_tags=>[@tag, tu]).all.must_equal []
@@ -1467,8 +1467,8 @@ FilterByAssociationsLimitStrategies = shared_description do
     ds.where(ar.pk_hash).not_first_tags.all.must_equal []
     ds.where(ar.pk_hash).last_two_tags.all.must_equal [tu]
 
-    Artist.many_through_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(:tags__name=>tu.name) end
-    Artist.many_through_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(:tags__name=>[tu.name, tv.name]) end
+    Artist.many_through_many :first_two_tags, :clone=>:first_two_tags do |ads| ads.where(Sequel[:tags][:name]=>tu.name) end
+    Artist.many_through_many :second_two_tags, :clone=>:second_two_tags do |ads| ads.where(Sequel[:tags][:name]=>[tu.name, tv.name]) end
 
     ds.where(@artist.pk_hash).first_two_tags.all.must_equal [tu]
     ds.where(@artist.pk_hash).second_two_tags.all.must_equal [tv]
@@ -1624,6 +1624,7 @@ BasicRegularAndCompositeKeyAssociations = shared_description do
     Album.alias_tags.all.must_equal [@tag]
     Artist.albums.all.must_equal [@album]
     unless @no_many_through_many
+      Album.mthm_tags.all.must_equal [@tag]
       Album.first_tags.all.must_equal [@tag]
       Artist.tags.all.must_equal [@tag]
       Artist.first_tags.all.must_equal [@tag]
@@ -1848,28 +1849,30 @@ describe "Sequel::Model Simple Associations" do
       one_to_one :first_a_album, :clone=>:a_albums
       plugin :many_through_many
       many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]]
-      many_through_many :first_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>2, :graph_order=>:name
-      many_through_many :second_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>[2, 1], :graph_order=>:name
-      many_through_many :not_first_tags, :clone=>:tags, :order=>:tags__name, :limit=>[nil, 1], :graph_order=>:name
-      many_through_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:tags__name), :limit=>2, :graph_order=>Sequel.desc(:name)
-      many_through_many :t_tags, :clone=>:tags, :conditions=>{:tags__name=>'T'}
-      one_through_many :first_tag, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :order=>:tags__name, :graph_order=>:name, :class=>:Tag
+      many_through_many :first_two_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>2, :graph_order=>:name
+      many_through_many :second_two_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>[2, 1], :graph_order=>:name
+      many_through_many :not_first_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>[nil, 1], :graph_order=>:name
+      many_through_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(Sequel[:tags][:name]), :limit=>2, :graph_order=>Sequel.desc(:name)
+      many_through_many :t_tags, :clone=>:tags, :conditions=>{Sequel[:tags][:name]=>'T'}
+      one_through_many :first_tag, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :order=>Sequel[:tags][:name], :graph_order=>:name, :class=>:Tag
       one_through_many :second_tag, :clone=>:first_tag, :limit=>[nil, 1]
-      one_through_many :last_tag, :clone=>:first_tag, :order=>Sequel.desc(:tags__name), :graph_order=>Sequel.desc(:name)
-      one_through_many :t_tag, :clone=>:first_tag, :conditions=>{:tags__name=>'T'}
+      one_through_many :last_tag, :clone=>:first_tag, :order=>Sequel.desc(Sequel[:tags][:name]), :graph_order=>Sequel.desc(:name)
+      one_through_many :t_tag, :clone=>:first_tag, :conditions=>{Sequel[:tags][:name]=>'T'}
     end
     class ::Album < Sequel::Model(@db)
       plugin :dataset_associations
       many_to_one :artist, :reciprocal=>nil
       many_to_one :a_artist, :clone=>:artist, :conditions=>{:name=>'Ar'}, :key=>:artist_id
       many_to_many :tags, :right_key=>:tag_id
-      many_to_many :alias_tags, :clone=>:tags, :join_table=>:albums_tags___at
+      plugin :many_through_many
+      many_through_many :mthm_tags, [[:albums_tags, :album_id, :tag_id]], :class=>:Tag
+      many_to_many :alias_tags, :clone=>:tags, :join_table=>Sequel[:albums_tags].as(:at)
       many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
       many_to_many :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
       many_to_many :not_first_tags, :clone=>:tags, :order=>:name, :limit=>[nil, 1]
       many_to_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:name), :limit=>2
       many_to_many :t_tags, :clone=>:tags, :conditions=>{:name=>'T'}
-      many_to_many :alias_t_tags, :clone=>:t_tags, :join_table=>:albums_tags___at
+      many_to_many :alias_t_tags, :clone=>:t_tags, :join_table=>Sequel[:albums_tags].as(:at)
       one_through_one :first_tag, :clone=>:tags, :order=>:name
       one_through_one :second_tag, :clone=>:first_tag, :limit=>[nil, 1]
       one_through_one :last_tag, :clone=>:tags, :order=>Sequel.desc(:name)
@@ -1970,9 +1973,9 @@ describe "Sequel::Model Simple Associations" do
     @album.update(:artist => @artist)
     @album.add_tag(@tag)
     
-    Artist.set_dataset(:artists___ar)
-    Album.set_dataset(:albums___a)
-    Tag.set_dataset(:tags___t)
+    Artist.set_dataset(Sequel[:artists].as(:ar))
+    Album.set_dataset(Sequel[:albums].as(:a))
+    Tag.set_dataset(Sequel[:tags].as(:t))
     Artist.one_to_many :balbums, :class=>Album, :key=>:artist_id, :reciprocal=>nil
     Album.many_to_many :btags, :class=>Tag, :join_table=>:albums_tags, :right_key=>:tag_id
     Album.many_to_one :bartist, :class=>Artist, :key=>:artist_id
@@ -2069,17 +2072,17 @@ describe "Sequel::Model Simple Associations" do
   end
 
   it "should handle dataset associations with :dataset_associations_join options" do
-    Album.many_to_many :tags, :right_key=>:tag_id, :select=>[Sequel.expr(:tags).*, :albums_tags__tag_id___atid], :dataset_associations_join=>true
-    Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel.expr(:tags).*, :albums_tags__tag_id___atid, :albums__artist_id___aid], :dataset_associations_join=>true
+    Album.many_to_many :tags, :right_key=>:tag_id, :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:tag_id].as(:atid)], :dataset_associations_join=>true
+    Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel.expr(:tags).*, Sequel[:albums_tags][:tag_id].as(:atid), Sequel[:albums][:artist_id].as(:aid)], :dataset_associations_join=>true
 
-    Album.tags.order(:tags__name).first.must_equal nil
-    Artist.tags.order(:tags__name).first.must_equal nil
+    Album.tags.order(Sequel[:tags][:name]).first.must_equal nil
+    Artist.tags.order(Sequel[:tags][:name]).first.must_equal nil
 
     @album.add_tag(@tag)
     @artist.add_album(@album)
 
-    Album.tags.order(:tags__name).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id)
-    Artist.tags.order(:tags__name).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id, :aid=>@artist.id)
+    Album.tags.order(Sequel[:tags][:name]).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id)
+    Artist.tags.order(Sequel[:tags][:name]).first.must_equal Tag.load(:id=>@tag.id, :name=>"T", :atid=>@tag.id, :aid=>@artist.id)
   end
 end
 
@@ -2135,15 +2138,15 @@ describe "Sequel::Model Composite Key Associations" do
       one_to_one :first_a_album, :clone=>:a_albums
       plugin :many_through_many
       many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]]
-      many_through_many :first_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>2, :graph_order=>:name
-      many_through_many :second_two_tags, :clone=>:tags, :order=>:tags__name, :limit=>[2, 1], :graph_order=>:name
-      many_through_many :not_first_tags, :clone=>:tags, :order=>:tags__name, :limit=>[nil, 1], :graph_order=>:name
-      many_through_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:tags__name), :limit=>2, :graph_order=>Sequel.desc(:name)
-      many_through_many :t_tags, :clone=>:tags do |ds| ds.where(:tags__name=>'T') end
-      one_through_many :first_tag, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :order=>:tags__name, :graph_order=>:name, :class=>:Tag
+      many_through_many :first_two_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>2, :graph_order=>:name
+      many_through_many :second_two_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>[2, 1], :graph_order=>:name
+      many_through_many :not_first_tags, :clone=>:tags, :order=>Sequel[:tags][:name], :limit=>[nil, 1], :graph_order=>:name
+      many_through_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(Sequel[:tags][:name]), :limit=>2, :graph_order=>Sequel.desc(:name)
+      many_through_many :t_tags, :clone=>:tags do |ds| ds.where(Sequel[:tags][:name]=>'T') end
+      one_through_many :first_tag, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :order=>Sequel[:tags][:name], :graph_order=>:name, :class=>:Tag
       one_through_many :second_tag, :clone=>:first_tag, :limit=>[nil, 1]
-      one_through_many :last_tag, :clone=>:first_tag, :order=>Sequel.desc(:tags__name), :graph_order=>Sequel.desc(:name)
-      one_through_many :t_tag, :clone=>:first_tag do |ds| ds.where(:tags__name=>'T') end
+      one_through_many :last_tag, :clone=>:first_tag, :order=>Sequel.desc(Sequel[:tags][:name]), :graph_order=>Sequel.desc(:name)
+      one_through_many :t_tag, :clone=>:first_tag do |ds| ds.where(Sequel[:tags][:name]=>'T') end
     end
     class ::Album < Sequel::Model(@db)
       plugin :dataset_associations
@@ -2152,13 +2155,15 @@ describe "Sequel::Model Composite Key Associations" do
       many_to_one :artist, :key=>[:artist_id1, :artist_id2], :reciprocal=>nil
       many_to_one(:a_artist, :clone=>:artist){|ds| ds.where(:name=>'Ar')}
       many_to_many :tags, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
-      many_to_many :alias_tags, :clone=>:tags, :join_table=>:albums_tags___at
+      plugin :many_through_many
+      many_through_many :mthm_tags, [[:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>:Tag
+      many_to_many :alias_tags, :clone=>:tags, :join_table=>Sequel[:albums_tags].as(:at)
       many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
       many_to_many :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
       many_to_many :not_first_tags, :clone=>:tags, :order=>:name, :limit=>[nil, 1]
       many_to_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:name), :limit=>2
       many_to_many :t_tags, :clone=>:tags do |ds| ds.where(:name=>'T') end
-      many_to_many :alias_t_tags, :clone=>:t_tags, :join_table=>:albums_tags___at
+      many_to_many :alias_t_tags, :clone=>:t_tags, :join_table=>Sequel[:albums_tags].as(:at)
       one_through_one :first_tag, :clone=>:tags, :order=>:name
       one_through_one :second_tag, :clone=>:first_tag, :limit=>[nil, 1]
       one_through_one :last_tag, :clone=>:tags, :order=>Sequel.desc(:name)
@@ -2283,7 +2288,7 @@ describe "Sequel::Model pg_array_to_many" do
       pg_array_to_many :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
       pg_array_to_many :not_first_tags, :clone=>:tags, :order=>:name, :limit=>[nil, 1]
       pg_array_to_many :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:name), :limit=>2
-      pg_array_to_many :t_tags, :clone=>:tags do |ds| ds.where(:tags__name=>'T') end
+      pg_array_to_many :t_tags, :clone=>:tags do |ds| ds.where(Sequel[:tags][:name]=>'T') end
       pg_array_to_many :alias_t_tags, :clone=>:t_tags
     end
     class ::Tag < Sequel::Model(@db)
@@ -2364,7 +2369,7 @@ describe "Sequel::Model many_to_pg_array" do
       many_to_pg_array :second_two_tags, :clone=>:tags, :order=>:name, :limit=>[2, 1]
       many_to_pg_array :not_first_tags, :clone=>:tags, :order=>:name, :limit=>[nil, 1]
       many_to_pg_array :last_two_tags, :clone=>:tags, :order=>Sequel.desc(:name), :limit=>2
-      many_to_pg_array :t_tags, :clone=>:tags do |ds| ds.where(:tags__name=>'T') end
+      many_to_pg_array :t_tags, :clone=>:tags do |ds| ds.where(Sequel[:tags][:name]=>'T') end
       many_to_pg_array :alias_t_tags, :clone=>:t_tags
     end
     class ::Tag < Sequel::Model(@db)

data/spec/integration/dataset_test.rb

@@ -56,29 +56,29 @@ describe "Simple Dataset operations" do
   end
 
   it "should join correctly" do
-    @ds.join(:items___b, :id=>:id).select_all(:items).all.must_equal [{:id=>1, :number=>10}]
+    @ds.join(Sequel[:items].as(:b), :id=>:id).select_all(:items).all.must_equal [{:id=>1, :number=>10}]
   end
 
   it "should handle LATERAL subqueries correctly" do
     @ds << {:number=>20}
-    @ds.from(:items___i, @ds.where(:items__number=>:i__number).lateral).select_order_map([:i__number___n, :t1__number]).must_equal [[10, 10], [20, 20]]
-    @ds.from(:items___i).cross_join(@ds.where(:items__number=>:i__number).lateral).select_order_map([:i__number___n, :t1__number]).must_equal [[10, 10], [20, 20]]
-    @ds.from(:items___i).join(@ds.where(:items__number=>:i__number).lateral, 1=>1).select_order_map([:i__number___n, :t1__number]).must_equal [[10, 10], [20, 20]]
-    @ds.from(:items___i).join(@ds.where(:items__number=>:i__number).lateral, 1=>0).select_order_map([:i__number___n, :t1__number]).must_equal []
-    @ds.from(:items___i).left_join(@ds.from(:items___i2).where(:i2__number=>:i__number).lateral, 1=>1).select_order_map([:i__number___n, :t1__number]).must_equal [[10, 10], [20, 20]]
-    @ds.from(:items___i).left_join(@ds.from(:items___i2).where(:i2__number=>:i__number).lateral, 1=>0).select_order_map([:i__number___n, :t1__number]).must_equal [[10, nil], [20, nil]]
+    @ds.from(Sequel[:items].as(:i), @ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
+    @ds.from(Sequel[:items].as(:i)).cross_join(@ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
+    @ds.from(Sequel[:items].as(:i)).join(@ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral, 1=>1).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
+    @ds.from(Sequel[:items].as(:i)).join(@ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral, 1=>0).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal []
+    @ds.from(Sequel[:items].as(:i)).left_join(@ds.from(Sequel[:items].as(:i2)).where(Sequel[:i2][:number]=>Sequel[:i][:number]).lateral, 1=>1).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
+    @ds.from(Sequel[:items].as(:i)).left_join(@ds.from(Sequel[:items].as(:i2)).where(Sequel[:i2][:number]=>Sequel[:i][:number]).lateral, 1=>0).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, nil], [20, nil]]
   end if DB.dataset.supports_lateral_subqueries?
 
   it "should correctly deal with qualified columns and subselects" do
-    @ds.from_self(:alias=>:a).select(:a__id, Sequel.qualify(:a, :number)).all.must_equal [{:id=>1, :number=>10}]
-    @ds.join(@ds.as(:a), :id=>:id).select(:a__id, Sequel.qualify(:a, :number)).all.must_equal [{:id=>1, :number=>10}]
+    @ds.from_self(:alias=>:a).select(Sequel[:a][:id], Sequel.qualify(:a, :number)).all.must_equal [{:id=>1, :number=>10}]
+    @ds.join(@ds.as(:a), :id=>:id).select(Sequel[:a][:id], Sequel.qualify(:a, :number)).all.must_equal [{:id=>1, :number=>10}]
   end
 
   it "should graph correctly" do
     a =  [{:items=>{:id=>1, :number=>10}, :b=>{:id=>1, :number=>10}}]
     pr = proc{|t| @ds.graph(t, {:id=>:id}, :table_alias=>:b).extension(:graph_each).all.must_equal a}
     pr[:items]
-    pr[:items___foo]
+    pr[Sequel[:items].as(:foo)]
     pr[Sequel.identifier(:items)]
     pr[Sequel.identifier('items')]
     pr[Sequel.as(:items, :foo)]
@@ -260,25 +260,25 @@ describe "Simple Dataset operations" do
     @db.create_table!(:items2){primary_key :id2; Integer :number2}
     @db[:items2].insert(:number2=>10)
     @ds.from(:items, :items2).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
-    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.from(Sequel[:items].as(:i), Sequel[:items2].as(:i2)).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
     @ds.cross_join(:items2).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
-    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
-    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10, :id3=>1, :number3=>10}]
+    @ds.from(Sequel[:items].as(:i)).cross_join(Sequel[:items2].as(:i2)).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10}]
+    @ds.cross_join(Sequel[:items2].as(:i)).cross_join(@db[:items2].select(Sequel[:id2].as(:id3), Sequel[:number2].as(:number3))).order(:id).limit(2, 0).all.must_equal [{:id=>1, :number=>10, :id2=>1, :number2=>10, :id3=>1, :number3=>10}]
 
     @ds.from(:items, :items2).order(:id).limit(2, 1).all.must_equal []
-    @ds.from(:items___i, :items2___i2).order(:id).limit(2, 1).all.must_equal []
+    @ds.from(Sequel[:items].as(:i), Sequel[:items2].as(:i2)).order(:id).limit(2, 1).all.must_equal []
     @ds.cross_join(:items2).order(:id).limit(2, 1).all.must_equal []
-    @ds.from(:items___i).cross_join(:items2___i2).order(:id).limit(2, 1).all.must_equal []
-    @ds.cross_join(:items2___i).cross_join(@db[:items2].select(:id2___id3, :number2___number3)).order(:id).limit(2, 1).all.must_equal []
+    @ds.from(Sequel[:items].as(:i)).cross_join(Sequel[:items2].as(:i2)).order(:id).limit(2, 1).all.must_equal []
+    @ds.cross_join(Sequel[:items2].as(:i)).cross_join(@db[:items2].select(Sequel[:id2].as(:id3), Sequel[:number2].as(:number3))).order(:id).limit(2, 1).all.must_equal []
     @db.drop_table(:items2)
   end
   
   it "should fetch correctly with a limit and offset without an order" do
     @ds.limit(2, 1).all.must_equal []
-    @ds.join(:items___i, :id=>:id).select(:items__id___s, :i__id___id2).limit(2, 1).all.must_equal []
-    @ds.join(:items___i, :id=>:id).select(:items__id).limit(2, 1).all.must_equal []
-    @ds.join(:items___i, :id=>:id).select(Sequel.qualify(:items, :id)).limit(2, 1).all.must_equal []
-    @ds.join(:items___i, :id=>:id).select(Sequel.qualify(:items, :id).as(:s)).limit(2, 1).all.must_equal []
+    @ds.join(Sequel[:items].as(:i), :id=>:id).select(Sequel[:items][:id].as(:s), Sequel[:i][:id].as(:id2)).limit(2, 1).all.must_equal []
+    @ds.join(Sequel[:items].as(:i), :id=>:id).select(Sequel[:items][:id]).limit(2, 1).all.must_equal []
+    @ds.join(Sequel[:items].as(:i), :id=>:id).select(Sequel.qualify(:items, :id)).limit(2, 1).all.must_equal []
+    @ds.join(Sequel[:items].as(:i), :id=>:id).select(Sequel.qualify(:items, :id).as(:s)).limit(2, 1).all.must_equal []
   end
 
   it "should be orderable by column number" do
@@ -330,7 +330,7 @@ describe "Simple Dataset operations" do
   end
 
   it "should alias columns correctly" do
-    @ds.select(:id___x, :number___n).first.must_equal(:x=>1, :n=>10)
+    @ds.select(Sequel[:id].as(:x), Sequel[:number].as(:n)).first.must_equal(:x=>1, :n=>10)
   end
 
   it "should support table aliases with column aliases" do
@@ -700,17 +700,17 @@ if DB.dataset.supports_cte?
     end
     
     cspecify "should give correct results for recursive WITH", :db2 do
-      ds = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>nil), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi]).order(:id)
+      ds = @db[:t].select(Sequel[:i].as(:id), Sequel[:pi].as(:parent_id)).with_recursive(:t, @ds.filter(:parent_id=>nil), @ds.join(:t, :i=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi]).order(:id)
       ds.all.must_equal [{:parent_id=>nil, :id=>1}, {:parent_id=>nil, :id=>2}, {:parent_id=>1, :id=>3}, {:parent_id=>1, :id=>4}, {:parent_id=>3, :id=>5}, {:parent_id=>5, :id=>6}]
-      ps = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(:t__i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi]).order(:id).prepare(:select, :cte_sel)
+      ps = @db[:t].select(Sequel[:i].as(:id), Sequel[:pi].as(:parent_id)).with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(Sequel[:t][:i]=>:parent_id).select(Sequel[:i1][:id], Sequel[:i1][:parent_id]), :args=>[:i, :pi]).order(:id).prepare(:select, :cte_sel)
       ps.call(:n=>1).must_equal [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>3}, {:id=>6, :parent_id=>5}]
       ps.call(:n=>3).must_equal [{:id=>5, :parent_id=>3}, {:id=>6, :parent_id=>5}]
       ps.call(:n=>5).must_equal [{:id=>6, :parent_id=>5}]
     end
 
     it "should support joining a dataset with a CTE" do
-      @ds.inner_join(@db[:t].with(:t, @ds.filter(:parent_id=>nil)), :id => :id).select(:i1__id).order(:i1__id).map(:id).must_equal [1,2]
-      @db[:t].with(:t, @ds).inner_join(@db[:s].with(:s, @ds.filter(:parent_id=>nil)), :id => :id).select(:t__id).order(:t__id).map(:id).must_equal [1,2]
+      @ds.inner_join(@db[:t].with(:t, @ds.filter(:parent_id=>nil)), :id => :id).select(Sequel[:i1][:id]).order(Sequel[:i1][:id]).map(:id).must_equal [1,2]
+      @db[:t].with(:t, @ds).inner_join(@db[:s].with(:s, @ds.filter(:parent_id=>nil)), :id => :id).select(Sequel[:t][:id]).order(Sequel[:t][:id]).map(:id).must_equal [1,2]
     end
 
     it "should support a subselect in the FROM clause with a CTE" do
@@ -777,7 +777,7 @@ if DB.dataset.supports_returning?(:insert)
       h.must_equal(:id=>3)
       @ds.returning.insert(5, 6){|r| h = r}
       h.must_equal(:id=>5, :foo=>6)
-      @ds.returning(:id___foo, :foo___id).insert(7, 8){|r| h = r}
+      @ds.returning(Sequel[:id].as(:foo), Sequel[:foo].as(:id)).insert(7, 8){|r| h = r}
       h.must_equal(:id=>8, :foo=>7)
     end
   end
@@ -806,7 +806,7 @@ if DB.dataset.supports_returning?(:update) # Assume DELETE support as well
       @ds.returning.update(:id=>Sequel.+(:id, 1), :foo=>Sequel.*(:foo, 2)){|r| h << r}
       h.must_equal [{:id=>4, :foo=>16}]
       h.clear
-      @ds.returning(:id___foo, :foo___id).update(:id=>Sequel.+(:id, 1), :foo=>Sequel.*(:foo, 2)){|r| h << r}
+      @ds.returning(Sequel[:id].as(:foo), Sequel[:foo].as(:id)).update(:id=>Sequel.+(:id, 1), :foo=>Sequel.*(:foo, 2)){|r| h << r}
       h.must_equal [{:id=>32, :foo=>5}]
       h.clear
 
@@ -1072,13 +1072,13 @@ describe "Sequel::Dataset convenience methods" do
   end
   
   it "#group_and_count should support column aliases" do
-    @ds.group_and_count(:a___c).order{count(:a)}.all.must_equal []
+    @ds.group_and_count(Sequel[:a].as(:c)).order{count(:a)}.all.must_equal []
     @ds.insert(20, 10)
-    @ds.group_and_count(:a___c).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>20, :count=>1}]
+    @ds.group_and_count(Sequel[:a].as(:c)).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>20, :count=>1}]
     @ds.insert(20, 30)
-    @ds.group_and_count(:a___c).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>20, :count=>2}]
+    @ds.group_and_count(Sequel[:a].as(:c)).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>20, :count=>2}]
     @ds.insert(30, 30)
-    @ds.group_and_count(:a___c).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
+    @ds.group_and_count(Sequel[:a].as(:c)).order{count(:a)}.all.each{|h| h[:count] = h[:count].to_i}.must_equal [{:c=>30, :count=>1}, {:c=>20, :count=>2}]
   end
   
   it "#range should return the range between the maximum and minimum values" do
@@ -1112,10 +1112,10 @@ describe "Sequel::Dataset main SQL methods" do
   end
   
   it "#exists should return a usable exists clause" do
-    @ds.filter(@db[:d___c].filter(:c__a=>:d__b).exists).all.must_equal []
+    @ds.filter(@db[Sequel[:d].as(:c)].filter(Sequel[:c][:a]=>Sequel[:d][:b]).exists).all.must_equal []
     @ds.insert(20, 30)
     @ds.insert(10, 20)
-    @ds.filter(@db[:d___c].filter(:c__a=>:d__b).exists).all.must_equal [{:a=>10, :b=>20}]
+    @ds.filter(@db[Sequel[:d].as(:c)].filter(Sequel[:c][:a]=>Sequel[:d][:b]).exists).all.must_equal [{:a=>10, :b=>20}]
   end
   
   it "#filter and #exclude should work with placeholder strings" do
@@ -1147,7 +1147,7 @@ describe "Sequel::Dataset main SQL methods" do
   it "#select_group should work correctly when aliasing" do
     @ds.unordered!
     @ds.insert(20, 30)
-    @ds.select_group(:b___c).all.must_equal [{:c=>30}]
+    @ds.select_group(Sequel[:b].as(:c)).all.must_equal [{:c=>30}]
   end
   
   it "#having should work correctly" do
@@ -1224,36 +1224,36 @@ describe "Sequel::Dataset convenience methods" do
     @ds.select_map([:a]).must_equal [[1], [5]]
     @ds.select_map([:a, :b]).must_equal [[1, 2], [5, 6]]
 
-    @ds.select_map(:a___e).must_equal [1, 5]
-    @ds.select_map(:b___e).must_equal [2, 6]
-    @ds.select_map([:a___e, :b___f]).must_equal [[1, 2], [5, 6]]
-    @ds.select_map([:a__a___e, :a__b___f]).must_equal [[1, 2], [5, 6]]
-    @ds.select_map([Sequel.expr(:a__a).as(:e), Sequel.expr(:a__b).as(:f)]).must_equal [[1, 2], [5, 6]]
+    @ds.select_map(Sequel[:a].as(:e)).must_equal [1, 5]
+    @ds.select_map(Sequel[:b].as(:e)).must_equal [2, 6]
+    @ds.select_map([Sequel[:a].as(:e), Sequel[:b].as(:f)]).must_equal [[1, 2], [5, 6]]
+    @ds.select_map([Sequel[:a][:a].as(:e), Sequel[:a][:b].as(:f)]).must_equal [[1, 2], [5, 6]]
+    @ds.select_map([Sequel.expr(Sequel[:a][:a]).as(:e), Sequel.expr(Sequel[:a][:b]).as(:f)]).must_equal [[1, 2], [5, 6]]
     @ds.select_map([Sequel.qualify(:a, :a).as(:e), Sequel.qualify(:a, :b).as(:f)]).must_equal [[1, 2], [5, 6]]
     @ds.select_map([Sequel.identifier(:a).qualify(:a).as(:e), Sequel.qualify(:a, :b).as(:f)]).must_equal [[1, 2], [5, 6]]
   end
   
   it "should have working #select_order_map" do
     @ds.select_order_map(:a).must_equal [1, 5]
-    @ds.select_order_map(Sequel.desc(:a__b)).must_equal [6, 2]
-    @ds.select_order_map(Sequel.desc(:a__b___e)).must_equal [6, 2]
+    @ds.select_order_map(Sequel.desc(Sequel[:a][:b])).must_equal [6, 2]
+    @ds.select_order_map(Sequel.desc(Sequel[:a][:b].as(:e))).must_equal [6, 2]
     @ds.select_order_map(Sequel.qualify(:a, :b).as(:e)).must_equal [2, 6]
     @ds.select_order_map([:a]).must_equal [[1], [5]]
     @ds.select_order_map([Sequel.desc(:a), :b]).must_equal [[5, 6], [1, 2]]
 
-    @ds.select_order_map(:a___e).must_equal [1, 5]
-    @ds.select_order_map(:b___e).must_equal [2, 6]
-    @ds.select_order_map([Sequel.desc(:a___e), :b___f]).must_equal [[5, 6], [1, 2]]
-    @ds.select_order_map([Sequel.desc(:a__a___e), :a__b___f]).must_equal [[5, 6], [1, 2]]
-    @ds.select_order_map([Sequel.desc(:a__a), Sequel.expr(:a__b).as(:f)]).must_equal [[5, 6], [1, 2]]
+    @ds.select_order_map(Sequel[:a].as(:e)).must_equal [1, 5]
+    @ds.select_order_map(Sequel[:b].as(:e)).must_equal [2, 6]
+    @ds.select_order_map([Sequel.desc(Sequel[:a].as(:e)), Sequel[:b].as(:f)]).must_equal [[5, 6], [1, 2]]
+    @ds.select_order_map([Sequel.desc(Sequel[:a][:a].as(:e)), Sequel[:a][:b].as(:f)]).must_equal [[5, 6], [1, 2]]
+    @ds.select_order_map([Sequel.desc(Sequel[:a][:a]), Sequel.expr(Sequel[:a][:b]).as(:f)]).must_equal [[5, 6], [1, 2]]
     @ds.select_order_map([Sequel.qualify(:a, :a).desc, Sequel.qualify(:a, :b).as(:f)]).must_equal [[5, 6], [1, 2]]
     @ds.select_order_map([Sequel.identifier(:a).qualify(:a).desc, Sequel.qualify(:a, :b).as(:f)]).must_equal [[5, 6], [1, 2]]
   end
 
   it "should have working #select_hash" do
     @ds.select_hash(:a, :b).must_equal(1=>2, 5=>6)
-    @ds.select_hash(:a__a___e, :b).must_equal(1=>2, 5=>6)
-    @ds.select_hash(Sequel.expr(:a__a).as(:e), :b).must_equal(1=>2, 5=>6)
+    @ds.select_hash(Sequel[:a][:a].as(:e), :b).must_equal(1=>2, 5=>6)
+    @ds.select_hash(Sequel.expr(Sequel[:a][:a]).as(:e), :b).must_equal(1=>2, 5=>6)
     @ds.select_hash(Sequel.qualify(:a, :a).as(:e), :b).must_equal(1=>2, 5=>6)
     @ds.select_hash(Sequel.identifier(:a).qualify(:a).as(:e), :b).must_equal(1=>2, 5=>6)
     @ds.select_hash([:a, :c], :b).must_equal([1, 3]=>2, [5, 7]=>6)
@@ -1266,8 +1266,8 @@ describe "Sequel::Dataset convenience methods" do
     ds = @ds.order(*@ds.columns)
     ds.insert(1, 2, 3, 9)
     ds.select_hash_groups(:a, :d).must_equal(1=>[4, 9], 5=>[8])
-    ds.select_hash_groups(:a__a___e, :d).must_equal(1=>[4, 9], 5=>[8])
-    ds.select_hash_groups(Sequel.expr(:a__a).as(:e), :d).must_equal(1=>[4, 9], 5=>[8])
+    ds.select_hash_groups(Sequel[:a][:a].as(:e), :d).must_equal(1=>[4, 9], 5=>[8])
+    ds.select_hash_groups(Sequel.expr(Sequel[:a][:a]).as(:e), :d).must_equal(1=>[4, 9], 5=>[8])
     ds.select_hash_groups(Sequel.qualify(:a, :a).as(:e), :d).must_equal(1=>[4, 9], 5=>[8])
     ds.select_hash_groups(Sequel.identifier(:a).qualify(:a).as(:e), :d).must_equal(1=>[4, 9], 5=>[8])
     ds.select_hash_groups([:a, :c], :d).must_equal([1, 3]=>[4, 9], [5, 7]=>[8])
@@ -1371,15 +1371,15 @@ describe "Sequel::Dataset DSL support" do
   
   it "should work with qualifying" do
     @ds.insert(10, 20)
-    @ds.get(:a__b).must_equal 20
-    @ds.get{a__b}.must_equal 20
+    @ds.get(Sequel[:a][:b]).must_equal 20
+    @ds.get{a[:b]}.must_equal 20
     @ds.get(Sequel.qualify(:a, :b)).must_equal 20
   end
   
   it "should work with aliasing" do
     @ds.insert(10, 20)
-    @ds.get(:a__b___c).must_equal 20
-    @ds.get{a__b.as(c)}.must_equal 20
+    @ds.get(Sequel[:a][:b].as(:c)).must_equal 20
+    @ds.get{a[:b].as(c)}.must_equal 20
     @ds.get(Sequel.qualify(:a, :b).as(:c)).must_equal 20
     @ds.get(Sequel.as(:b, :c)).must_equal 20
   end