sequel 5.20.0 → 5.49.0

data/spec/extensions/csv_serializer_spec.rb

@@ -1,183 +0,0 @@
-require_relative "spec_helper"
-
-require 'csv' 
-
-describe "Sequel::Plugins::CsvSerializer" do
-  before do
-    artist = @Artist = Class.new(Sequel::Model(:artists))
-    @Artist.class_eval do
-      def self.name; 'Artist' end
-      unrestrict_primary_key
-      plugin :csv_serializer
-      columns :id, :name
-      def_column_accessor :id, :name
-      @db_schema = {:id=>{:type=>:integer}}
-    end
-    @Album = Class.new(Sequel::Model(:albums))
-    @Album.class_eval do
-      def self.name; 'Album' end
-      unrestrict_primary_key
-      attr_accessor :blah
-      plugin :csv_serializer
-      columns :id, :name, :artist_id
-      def_column_accessor :id, :name, :artist_id
-      @db_schema = {:id=>{:type=>:integer}, :artist_id=>{:type=>:integer}}
-      many_to_one :artist, :class=>artist
-    end
-    @artist = @Artist.load(:id=>2, :name=>'YJM')
-    @artist.associations[:albums] = []
-    @album = @Album.load(:id=>1, :name=>'RF')
-    @album.artist = @artist
-    @album.blah = 'Blah'
-  end
-
-  it "should round trip successfully" do
-    @Artist.from_csv(@artist.to_csv).must_equal @artist
-    @Album.from_csv(@album.to_csv).must_equal @album
-  end
-
-  it "should handle ruby objects in values" do
-    @Artist.send(:define_method, :name=) do |v|
-      super(Date.parse(v))
-    end
-    a = @Artist.load(:name=>Date.today)
-    opts = {:columns=>[:name]}
-    @Artist.from_csv(a.to_csv(opts), opts).must_equal a
-  end
-
-  it "should handle the :only option" do
-    @Artist.from_csv(@artist.to_csv(:only=>:name), :only=>:name).must_equal @Artist.load(:name=>@artist.name)
-    @Album.from_csv(@album.to_csv(:only=>[:id, :name]), :only=>[:id, :name]).must_equal @Album.load(:id=>@album.id, :name=>@album.name)
-  end
-
-  it "should handle the :except option" do
-    @Artist.from_csv(@artist.to_csv(:except=>:id), :except=>:id).must_equal @Artist.load(:name=>@artist.name)
-    @Album.from_csv(@album.to_csv(:except=>[:id, :artist_id]), :except=>[:id, :artist_id]).must_equal @Album.load(:name=>@album.name)
-  end
-
-  it "should handle the :include option for arbitrary attributes" do
-    @Album.from_csv(@album.to_csv(:include=>:blah), :include=>:blah).blah.must_equal @album.blah
-  end
-
-  it "should handle multiple inclusions using an array for the :include option" do
-    a = @Album.from_csv(@album.to_csv(:include=>[:blah]), :include=>:blah)
-    a.blah.must_equal @album.blah
-  end
-
-  it "#from_csv should set column values" do
-    @artist.from_csv('AS', :only=>:name)
-    @artist.name.must_equal 'AS'
-    @artist.id.must_equal 2
-
-    @artist.from_csv('1', :only=>:id)
-    @artist.name.must_equal 'AS'
-    @artist.id.must_equal 1
-  end
-
-  it ".array_from_csv should support :headers to specify headers" do
-    @albums = @Album.array_from_csv("AS,2\nDF,3", :headers=>['name', 'artist_id'])
-    @albums.map(&:name).must_equal %w'AS DF'
-    @albums.map(&:artist_id).must_equal [2, 3]
-
-    @albums = @Album.array_from_csv("2,AS\n3,DF", :headers=>[nil, 'name'])
-    @albums.map(&:name).must_equal %w'AS DF'
-    @albums.map(&:artist_id).must_equal [nil, nil]
-  end
-
-  it ".from_csv should support :headers to specify headers" do
-    @album = @Album.from_csv('AS,2', :headers=>['name', 'artist_id'])
-    @album.name.must_equal 'AS'
-    @album.artist_id.must_equal 2
-
-    @album = @Album.from_csv('2,AS', :headers=>[nil, 'name'])
-    @album.name.must_equal 'AS'
-    @album.artist_id.must_be_nil
-  end
-
-  it "#from_csv should support :headers to specify headers" do
-    @album.from_csv('AS,2', :headers=>['name'])
-    @album.name.must_equal 'AS'
-    @album.artist_id.must_equal 2
-
-    @album.from_csv('2,AS', :headers=>[nil, 'name'])
-    @album.name.must_equal 'AS'
-    @album.artist_id.must_equal 2
-  end
-
-  it "should support a to_csv class and dataset method" do
-    @Album.dataset = @Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
-    @Artist.dataset = @Artist.dataset.with_fetch(:id=>2, :name=>'YJM')
-    @Album.columns(:id, :name, :artist_id)
-    @Album.db_schema.replace(:id=>{:type=>:integer}, :artist_id=>{:type=>:integer})
-    @Album.array_from_csv(@Album.to_csv).must_equal [@album]
-    @Album.array_from_csv(@Album.dataset.to_csv(:only=>:name), :only=>:name).must_equal [@Album.load(:name=>@album.name)]
-  end
-
-  it "should have dataset to_csv method respect :array option" do
-    a = @Album.new(:id=>1, :name=>'RF', :artist_id=>3)
-    @Album.array_from_csv(@Album.to_csv(:array=>[a])).must_equal [a]
-  end
-
-  it "#to_csv should respect class options" do
-    @Album = Class.new(Sequel::Model(:albums))
-    artist = @Artist
-    @Album.class_eval do
-      attr_accessor :blah
-      plugin :csv_serializer, :except => :id, :write_headers=>true, :include=>:blah
-      columns :id, :name, :artist_id
-      many_to_one :artist, :class=>artist
-    end
-    @album = @Album.load(:id=>2, :name=>'JK')
-    @album.artist = @artist
-    @album.blah = 'Gak'
-
-    @album.to_csv.must_equal "name,artist_id,blah\nJK,2,Gak\n"
-    @album.to_csv(:write_headers=>false).must_equal "JK,2,Gak\n"
-    @album.to_csv(:headers=>[:name]).must_equal "name\nJK\n"
-    @album.to_csv(:headers=>[:name, :id]).must_equal "name,id\nJK,2\n"
-    @album.to_csv(:only=>[:name]).must_equal "name,blah\nJK,Gak\n"
-    @album.to_csv(:except=>nil).must_equal "id,name,artist_id,blah\n2,JK,2,Gak\n"
-    @album.to_csv(:except=>[:blah]).must_equal "id,name,artist_id\n2,JK,2\n"
-  end
-
-  it "should store the default options in csv_serializer_opts" do
-    @Album.csv_serializer_opts.must_equal({})
-    c = Class.new(@Album)
-    @Album.csv_serializer_opts[:include] = :blah
-    c.plugin :csv_serializer, :naked=>false
-    c.csv_serializer_opts.must_equal(:naked=>false)
-    @Album.csv_serializer_opts.must_equal(:include=>:blah)
-  end
-
-  it "should work correctly when subclassing" do
-    @Artist2 = Class.new(@Artist)
-    @Artist2.plugin :csv_serializer, :only=>:name
-    @Artist3 = Class.new(@Artist2)
-    @Artist3.from_csv(@Artist3.load(:id=>2, :name=>'YYY').to_csv).must_equal @Artist3.load(:name=>'YYY')
-  end
-
-  it "should raise an error if attempting to set a restricted column and :all_columns is not used" do
-    @Artist.restrict_primary_key
-    proc{@Artist.from_csv(@artist.to_csv)}.must_raise(Sequel::MassAssignmentRestriction)
-  end
-
-  it "should use a dataset's selected columns" do
-    columns = [:id]
-    ds = @Artist.select(*columns).limit(1)
-    ds.send(:columns=, columns)
-    ds.with_fetch(:id => 10).to_csv(:write_headers => true).must_equal "id\n10\n"
-  end
-
-  it "should pass all the examples from the documentation" do
-    @album.to_csv(:write_headers=>true).must_equal "id,name,artist_id\n1,RF,2\n"
-    @album.to_csv(:only=>:name).must_equal "RF\n"
-    @album.to_csv(:except=>[:id, :artist_id]).must_equal "RF\n"
-  end
-
-  it "should freeze csv serializier opts when model class is frozen" do
-    @Album.csv_serializer_opts[:only] = [:id]
-    @Album.freeze
-    @Album.csv_serializer_opts.frozen?.must_equal true
-    @Album.csv_serializer_opts[:only].frozen?.must_equal true
-  end
-end

data/spec/extensions/current_datetime_timestamp_spec.rb

@@ -1,27 +0,0 @@
-require_relative "spec_helper"
-
-describe "current_datetime_timestamp extension" do
-  before do
-    @ds = Sequel.mock[:table].extension(:current_datetime_timestamp)
-  end
-  after do
-    Sequel.datetime_class = Time
-  end
-
-  it "should have current_timestamp respect Sequel.datetime_class" do
-    t = Sequel::Dataset.new(nil).current_datetime 
-    t.must_be_kind_of(Time)
-    (Time.now - t < 0.1).must_equal true
-
-    Sequel.datetime_class = DateTime
-    t = Sequel::Dataset.new(nil).current_datetime 
-    t.must_be_kind_of(DateTime)
-    (DateTime.now - t < (0.1/86400)).must_equal true
-  end
-
-  it "should have current_timestamp value be literalized as CURRENT_TIMESTAMP" do
-    @ds.literal(@ds.current_datetime).must_equal 'CURRENT_TIMESTAMP'
-    Sequel.datetime_class = DateTime
-    @ds.literal(@ds.current_datetime).must_equal 'CURRENT_TIMESTAMP'
-  end
-end

data/spec/extensions/dataset_associations_spec.rb

@@ -1,365 +0,0 @@
-require_relative "spec_helper"
-
-describe "Sequel::Plugins::DatasetAssociations" do
-  before do
-    @db = Sequel.mock(:host=>'postgres')
-    @db.extend_datasets do
-      def quote_identifiers?; false end
-      def supports_window_functions?; true; end
-      def supports_distinct_on?; true; end
-    end
-    @Base = Class.new(Sequel::Model)
-    @Base.plugin :dataset_associations
-
-    @Artist = Class.new(@Base)
-    @Album = Class.new(@Base)
-    @Tag = Class.new(@Base)
-    @Track = Class.new(@Base)
-
-    def @Artist.name; 'Artist' end
-    def @Album.name; 'Album' end
-    def @Tag.name; 'Tag' end
-    def @Track.name; 'Track' end
-
-    @Artist.dataset = @db[:artists]
-    @Album.dataset = @db[:albums]
-    @Tag.dataset = @db[:tags]
-    @Track.dataset = @db[:tracks]
-
-    @Artist.columns :id, :name
-    @Album.columns :id, :name, :artist_id
-    @Tag.columns :id, :name
-
-    @Album.plugin :many_through_many
-    @Artist.plugin :many_through_many
-    @Track.plugin :many_through_many
-    @Artist.plugin :pg_array_associations
-    @Tag.plugin :pg_array_associations
-    @Artist.one_to_many :albums, :class=>@Album
-    @Artist.one_to_one :first_album, :class=>@Album
-    @Album.many_to_one :artist, :class=>@Artist
-    @Album.many_to_many :tags, :class=>@Tag
-    @Album.many_through_many :mthm_tags, [[:albums_tags, :album_id, :tag_id]], :class=>@Tag
-    @Album.one_through_one :first_tag, :class=>@Tag, :right_key=>:tag_id
-    @Tag.many_to_many :albums, :class=>@Album
-    @Artist.pg_array_to_many :artist_tags, :class=>@Tag, :key=>:tag_ids
-    @Tag.many_to_pg_array :artists, :class=>@Artist
-    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
-    @Artist.one_through_many :otag, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
-    @Track.many_through_many :artist_tracks, [[:albums, :id, :artist_id], [:albums, :artist_id, :id]], :class=>@Track, :left_primary_key=>:album_id, :right_primary_key=>:album_id
-  end
-
-  it "should work for many_to_one associations" do
-    ds = @Album.artists
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Artist
-    ds.sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
-  end
-
-  it "should work for one_to_many associations" do
-    ds = @Artist.albums
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Album
-    ds.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
-  end
-
-  it "should work for one_to_one associations" do
-    ds = @Artist.first_albums
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Album
-    ds.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
-  end
-
-  it "should work for many_to_many associations" do
-    ds = @Album.tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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))))"
-  end
-
-  it "should work for one_through_one associations" do
-    ds = @Album.first_tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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))))"
-  end
-
-  it "should work for many_through_many associations" do
-    ds = @Artist.tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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))))"
-  end
-
-  it "should work for self referential many_through_many associations" do
-    ds = @Track.artist_tracks
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Track
-    ds.sql.must_equal "SELECT tracks.* FROM tracks WHERE (tracks.album_id IN (SELECT albums_0.id FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums AS albums_0 ON (albums_0.artist_id = albums.artist_id) INNER JOIN tracks AS tracks_0 ON (tracks_0.album_id = albums_0.id) WHERE (albums.id IN (SELECT tracks.album_id FROM tracks))))"
-  end
-
-  it "should work for many_through_many associations with a single join table" do
-    ds = @Album.mthm_tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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))))"
-  end
-
-  it "should work for one_through_many associations" do
-    ds = @Artist.otags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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))))"
-  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).*, Sequel[:albums_tags][:foo]]
-    ds = @Album.tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) 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))))"
-  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).*, Sequel[:albums_tags][:foo]]
-    ds = @Album.first_tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) 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))))"
-  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).*, Sequel[:albums_tags][:foo]]
-    ds = @Artist.tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) 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))))"
-  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).*, Sequel[:albums_tags][:foo]]
-    ds = @Artist.otags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.sql.must_equal "SELECT tags.*, albums_tags.foo FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) 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))))"
-  end
-
-  it "should work for pg_array_to_many associations" do
-    ds = @Artist.artist_tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.sql.must_equal "SELECT * FROM tags WHERE (id IN (SELECT unnest(artists.tag_ids) FROM artists))"
-  end
-
-  it "should work for many_to_pg_array associations" do
-    ds = @Tag.artists
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Artist
-    ds.sql.must_equal "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), false)"
-  end
-
-  it "should have an associated method that takes an association symbol" do
-    ds = @Album.associated(:artist)
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Artist
-    ds.sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums.artist_id FROM albums))"
-  end
-
-  it "should raise an Error if an invalid association is given to associated" do
-    proc{@Album.associated(:foo)}.must_raise(Sequel::Error)
-  end
-
-  it "should raise an Error if an unrecognized association type is used" do
-    @Album.association_reflection(:artist)[:type] = :foo
-    proc{@Album.artists}.must_raise(Sequel::Error)
-  end
-
-  it "should work correctly when chaining" do
-    ds = @Artist.albums.tags
-    ds.must_be_kind_of(Sequel::Dataset)
-    ds.model.must_equal @Tag
-    ds.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 WHERE (albums.artist_id IN (SELECT artists.id FROM artists))))))"
-  end
-
-  it "should deal correctly with filters before the association method" do
-    @Artist.filter(:id=>1).albums.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists WHERE (id = 1)))"
-  end
-
-  it "should deal correctly with filters after the association method" do
-    @Artist.albums.filter(:id=>1).sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
-  end
-
-  it "should deal correctly with block on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums do |ds| ds.filter(:id=>1..100) end
-    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
-  end
-
-  it "should deal correctly with :conditions option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :conditions=>{:id=>1..100}
-    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
-  end
-
-  it "should deal correctly with :distinct option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :distinct=>true
-    @Artist.albums.sql.must_equal "SELECT DISTINCT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
-  end
-
-  it "should deal correctly with :eager option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :eager=>:tags
-    @Artist.albums.opts[:eager].must_equal(:tags=>nil)
-  end
-
-  it "should deal correctly with :eager_block option on the association, ignoring the association block" do
-    @Artist.one_to_many :albums, :clone=>:albums, :eager_block=>proc{|ds| ds.filter(:id=>1..100)} do |ds| ds.filter(:id=>2..200) end
-    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id >= 1) AND (id <= 100))"
-  end
-
-  it "should deal correctly with :extend option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :extend=>Module.new{def foo(x) filter(:id=>x) end}
-    @Artist.albums.foo(1).sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (id = 1))"
-  end
-
-  it "should deal correctly with :order option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :order=>:name
-    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists)) ORDER BY name"
-  end
-
-  it "should deal correctly with :select option on the association" do
-    @Artist.one_to_many :albums, :clone=>:albums, :select=>[:id, :name]
-    @Artist.albums.sql.must_equal "SELECT id, name FROM albums WHERE (albums.artist_id IN (SELECT artists.id FROM artists))"
-  end
-
-  it "should deal correctly with :order option for one_to_one associations" do
-    @Artist.one_to_one :first_album, :clone=>:first_album, :order=>:name
-    @Artist.first_albums.sql.must_equal 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT DISTINCT ON (albums.artist_id) albums.id FROM albums ORDER BY albums.artist_id, name))) ORDER BY name'
-  end
-
-  it "should deal correctly with :limit option for one_to_many associations" do
-    @Artist.one_to_many :albums, :clone=>:albums, :limit=>10, :order=>:name
-    @Artist.albums.sql.must_equal 'SELECT * FROM albums WHERE ((albums.artist_id IN (SELECT artists.id FROM artists)) AND (albums.id IN (SELECT id FROM (SELECT albums.id, row_number() OVER (PARTITION BY albums.artist_id ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
-  end
-
-  it "should deal correctly with :order option for one_through_one associations" do
-    @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=>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=>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=>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
-
-describe "Sequel::Plugins::DatasetAssociations with composite keys" do
-  before do
-    @db = Sequel.mock
-    @db.extend_datasets do
-      def supports_window_functions?; true; end
-      def supports_distinct_on?; true; end
-    end
-    @Base = Class.new(Sequel::Model)
-    @Base.plugin :dataset_associations
-
-    @Artist = Class.new(@Base)
-    @Album = Class.new(@Base)
-    @Tag = Class.new(@Base)
-
-    def @Artist.name; 'Artist' end
-    def @Album.name; 'Album' end
-    def @Tag.name; 'Tag' end
-
-    @Artist.dataset = @db[:artists]
-    @Album.dataset = @db[:albums]
-    @Tag.dataset = @db[:tags]
-
-    @Artist.set_primary_key([:id1, :id2])
-    @Album.set_primary_key([:id1, :id2])
-    @Tag.set_primary_key([:id1, :id2])
-
-    @Artist.columns :id1, :id2, :name
-    @Album.columns :id1, :id2, :name, :artist_id1, :artist_id2
-    @Tag.columns :id1, :id2, :name
-
-    @Artist.plugin :many_through_many
-    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id1, :artist_id2]
-    @Artist.one_to_one :first_album, :class=>@Album, :key=>[:artist_id1, :artist_id2]
-    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id1, :artist_id2]
-    @Album.many_to_many :tags, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
-    @Album.one_through_one :first_tag, :class=>@Tag, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
-    @Tag.many_to_many :albums, :class=>@Album, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
-    @Artist.many_through_many :tags, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
-    @Artist.one_through_many :otag, [[:albums, [:artist_id1, :artist_id2], [:id1, :id2]], [:albums_tags, [:album_id1, :album_id2], [:tag_id1, :tag_id2]]], :class=>@Tag
-  end
-
-  it "should work for many_to_one associations" do
-    @Album.artists.sql.must_equal "SELECT * FROM artists WHERE ((artists.id1, artists.id2) IN (SELECT albums.artist_id1, albums.artist_id2 FROM albums))"
-  end
-
-  it "should work for one_to_many associations" do
-    @Artist.albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
-  end
-
-  it "should work for one_to_one associations" do
-    @Artist.first_albums.sql.must_equal "SELECT * FROM albums WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))"
-  end
-
-  it "should work for many_to_many associations" do
-    @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))))"
-  end
-
-  it "should work for one_through_one associations" do
-    @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))))"
-  end
-
-  it "should work for many_through_many associations" do
-    @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))))"
-  end
-
-  it "should work for one_through_many associations" do
-    @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))))"
-  end
-
-  it "should work correctly when chaining" do
-    @Artist.albums.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 WHERE ((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists))))))"
-  end
-
-  it "should deal correctly with :order option for one_to_one associations" do
-    @Artist.one_to_one :first_album, :clone=>:first_album, :order=>:name
-    @Artist.first_albums.sql.must_equal 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT DISTINCT ON (albums.artist_id1, albums.artist_id2) albums.id1, albums.id2 FROM albums ORDER BY albums.artist_id1, albums.artist_id2, name))) ORDER BY name'
-  end
-
-  it "should deal correctly with :limit option for one_to_many associations" do
-    @Artist.one_to_many :albums, :clone=>:albums, :limit=>10, :order=>:name
-    @Artist.albums.sql.must_equal 'SELECT * FROM albums WHERE (((albums.artist_id1, albums.artist_id2) IN (SELECT artists.id1, artists.id2 FROM artists)) AND ((albums.id1, albums.id2) IN (SELECT id1, id2 FROM (SELECT albums.id1, albums.id2, row_number() OVER (PARTITION BY albums.artist_id1, albums.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM albums) AS t1 WHERE (x_sequel_row_number_x <= 10)))) ORDER BY name'
-  end
-
-  it "should deal correctly with :order option for one_through_one associations" do
-    @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=>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=>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=>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/dataset_source_alias_spec.rb

@@ -1,51 +0,0 @@
-require_relative "spec_helper"
-
-describe "dataset_source_alias extension" do
-  before do
-    @db = Sequel.mock
-    @db.extension(:dataset_source_alias)
-  end
-
-  it "should automatically alias datasets to their first source in #from" do
-    @db[@db[:a]].sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a, @db[:b]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
-  end
-
-  it "should handle virtual row blocks in #from" do
-    @db.dataset.from{|_| @db[:a]}.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db.dataset.from(:a){|_| @db[:b]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM b) AS b'
-  end
-
-  it "should automatically alias datasets to their first source in #join" do
-    @db[:a].cross_join(@db[:b]).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS b'
-  end
-
-  it "should handle :table_alias option when joining" do
-    @db[:a].cross_join(@db[:b], :table_alias=>:c).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT * FROM b) AS c'
-  end
-
-  it "should handle aliasing issues automatically" do
-    @db[:a, @db[:a]].sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1'
-    @db.dataset.from(:a, @db[:a]){|_| @db[:a]}.cross_join(@db[:a]).sql.must_equal 'SELECT * FROM a, (SELECT * FROM a) AS a_0, (SELECT * FROM a) AS a_1 CROSS JOIN (SELECT * FROM a) AS a_2'
-  end
-
-  it "should handle from_self" do
-    @db[:a].from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM a) AS a'
-    @db[:a].from_self.from_self.sql.must_equal 'SELECT * FROM (SELECT * FROM (SELECT * FROM a) AS a) AS a'
-  end
-
-  it "should handle datasets without sources" do
-    @db[@db.select(1)].sql.must_equal 'SELECT * FROM (SELECT 1) AS t1'
-    @db[:t, @db.select(1)].sql.must_equal 'SELECT * FROM t, (SELECT 1) AS t1'
-    @db[:a].cross_join(@db.select(1)).sql.must_equal 'SELECT * FROM a CROSS JOIN (SELECT 1) AS t1'
-  end
-
-  it "should handle datasets selecting from functions" do
-    @db.dataset.from{|o| @db[o.f(:a)]}.sql.must_equal 'SELECT * FROM (SELECT * FROM f(a)) AS t1'
-  end
-
-  it "should handle datasets with literal SQL" do
-    @db.from(@db['SELECT c FROM d']).sql.must_equal 'SELECT * FROM (SELECT c FROM d) AS t1'
-  end
-end