sequel-association-filtering 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 650d4f992d2994676afd8b8cab81c98522dcd3a7f3c7700702fe2eeab78f7f64
-  data.tar.gz: dc67094e11cdefd1b267524de4cecc4fe7729025eb9bdcadd9cfd8aaf72e4794
+  metadata.gz: ff146b722b3e38c2309610aad40275960ac257b8cae86047fb25aa15b1c08e38
+  data.tar.gz: fd4d3faeef0debbcaabebc11418c5d4543ef17e46c709ca4e332d53eceab0790
 SHA512:
-  metadata.gz: 8c07e15a8e8c2f0160cc98c3ccbc0292e6257d1d70ebeb914209d7d4288179f5030689ec6159d7f26ba52f1e449b38c3d3f2c03824d48e07030d2c6ffd0bf6c9
-  data.tar.gz: 72490ad79e2f0b1a8cadb2150dccc0a9544f3c0ab018298407f4bce4deb549cd62935a505279c139b955c74b84fabb460e641fc2ada8d9e7025e95dff2e5fe3c
+  metadata.gz: c13509e8f28653f671101d17c861c4a03ff118c3f44233fb6a522423b5f7698535a56e712bacd4b22a250d82404cad96086caa5138089ac53bdfecd301257122
+  data.tar.gz: 4cc33a23a642c60143869391e8ca678d6cb6b3634695be26e607baa0818b2aa9ac4e6a130c67cb732d72078f0ff59710f55818c92de50509a57c64c9a05b76d6

data/lib/sequel/plugins/association_filtering.rb

@@ -49,7 +49,15 @@ module Sequel
               raise Error, "Unsupported reflection type: #{t}"
             end
 
-            ds.where(remote_keys => local_keys).select(1)
+            local_keys  = Array(local_keys)
+            remote_keys = Array(remote_keys)
+
+            ds.where(
+              remote_keys.
+              zip(local_keys).
+              map{|r,l| {r => l}}.
+              inject{|a,b| Sequel.&(a, b)}
+            ).select(1)
           end
         end
 

data/lib/sequel/plugins/association_filtering/version.rb

@@ -1,7 +1,7 @@
 module Sequel
   module Plugins
     module AssociationFiltering
-      VERSION = '0.0.1'
+      VERSION = '0.0.2'
     end
   end
 end

data/spec/basic_spec.rb

@@ -1,14 +1,31 @@
 require 'spec_helper'
 
 class BasicSpec < AssociationFilteringSpecs
+  before do
+    DB.create_table :artists do
+      primary_key :id
+    end
+
+    DB.run <<-SQL
+      INSERT INTO artists SELECT i FROM generate_series(1, 10) i;
+    SQL
+
+    class Artist < Sequel::Model
+    end
+  end
+
+  after do
+    DB.drop_table? :artists
+  end
+
   describe "association_filter" do
     it "with an unknown association should throw an error" do
       error =
         assert_raises(Sequel::Plugins::AssociationFiltering::Error) do
-          Album.association_filter(:widgets)
+          Artist.association_filter(:widgets)
         end
 
-      assert_equal "association widgets not found on model Album", error.message
+      assert_equal "association widgets not found on model BasicSpec::Artist", error.message
     end
   end
 end

data/spec/many_to_many_spec.rb

@@ -1,6 +1,50 @@
 require 'spec_helper'
 
-class AssociationFilteringSpec < AssociationFilteringSpecs
+class ManyToManySpec < AssociationFilteringSpecs
+  before do
+    drop_tables
+
+    DB.create_table :albums do
+      primary_key :id
+    end
+
+    DB.create_table :genres do
+      primary_key :id
+    end
+
+    DB.create_table :album_genres do
+      primary_key :id
+      foreign_key :album_id, :albums
+      foreign_key :genre_id, :genres
+
+      unique [:album_id, :genre_id]
+    end
+
+    DB.run <<-SQL
+      INSERT INTO albums SELECT i FROM generate_series(1, 100) i;
+      INSERT INTO genres SELECT i FROM generate_series(1, 10) i;
+
+      INSERT INTO album_genres (album_id, genre_id)
+        SELECT DISTINCT ceil(random() * 100), ceil(random() * 10) FROM generate_series(1, 300);
+    SQL
+
+    class Album < Sequel::Model
+      many_to_many :genres, class: 'ManyToManySpec::Genre', join_table: :album_genres
+    end
+
+    class Genre < Sequel::Model
+      many_to_many :albums, class: 'ManyToManySpec::Album', join_table: :album_genres
+    end
+  end
+
+  after do
+    drop_tables
+  end
+
+  def drop_tables
+    DB.drop_table? :album_genres, :genres, :albums
+  end
+
   describe "association_filter through a many_to_many_association" do
     it "should support an empty filter that checks for existence" do
       expected_count = DB[:album_genres].distinct(:album_id).count

data/spec/many_to_one_spec.rb

@@ -1,6 +1,40 @@
 require 'spec_helper'
 
-class AssociationFilteringSpec < AssociationFilteringSpecs
+class ManyToOneSpec < AssociationFilteringSpecs
+  before do
+    drop_tables
+
+    DB.create_table :artists do
+      primary_key :id
+    end
+
+    DB.create_table :albums do
+      primary_key :id
+      foreign_key :artist_id, :artists
+    end
+
+    DB.run <<-SQL
+      INSERT INTO artists SELECT i FROM generate_series(1, 10) i;
+      INSERT INTO albums (artist_id) SELECT (i % 10) + 1 FROM generate_series(1, 100) i;
+    SQL
+
+    class Artist < Sequel::Model
+      one_to_many :albums, class: 'ManyToOneSpec::Album'
+    end
+
+    class Album < Sequel::Model
+      many_to_one :artist, class: 'ManyToOneSpec::Artist'
+    end
+  end
+
+  after do
+    drop_tables
+  end
+
+  def drop_tables
+    DB.drop_table? :albums, :artists
+  end
+
   describe "association_filter through a many_to_one association" do
     it "should support a simple filter" do
       ds = Album.association_filter(:artist){|a| a.where{mod(id, 5) =~ 0}}

data/spec/one_to_many_spec.rb

@@ -1,23 +1,133 @@
 require 'spec_helper'
 
-class AssociationFilteringSpec < AssociationFilteringSpecs
-  describe "association_filter through a one_to_many association" do
-    it "should support a simple filter" do
-      ds = Album.association_filter(:tracks){|t| t.where(id: 40)}
-      assert_equal 1, ds.count
-      assert_equal %(SELECT * FROM "albums" WHERE (EXISTS (SELECT 1 FROM "tracks" WHERE (("tracks"."album_id" = "albums"."id") AND ("id" = 40))))), ds.sql
+class OneToManySpec < AssociationFilteringSpecs
+  describe "with a singular primary_key" do
+    before do
+      drop_tables
 
-      record = ds.first!
-      assert_includes record.tracks.map(&:id), 40
+      DB.create_table :artists do
+        primary_key :id
+      end
+
+      DB.create_table :albums do
+        primary_key :id
+        foreign_key :artist_id, :artists
+      end
+
+      DB.run <<-SQL
+        INSERT INTO artists SELECT i FROM generate_series(1, 10) i;
+        INSERT INTO albums (artist_id) SELECT (i % 10) + 1 FROM generate_series(1, 100) i;
+      SQL
+
+      class Artist < Sequel::Model
+        one_to_many :albums, class: 'OneToManySpec::Album'
+      end
+
+      class Album < Sequel::Model
+        many_to_one :artist, class: 'OneToManySpec::Artist'
+      end
+    end
+
+    after do
+      OneToManySpec.send(:remove_const, :Artist)
+      OneToManySpec.send(:remove_const, :Album)
+      drop_tables
+    end
+
+    def drop_tables
+      DB.drop_table? :albums, :artists
+    end
+
+    describe "association_filter through a one_to_many association" do
+      it "should support a simple filter" do
+        ds = Artist.association_filter(:albums){|t| t.where(id: 40)}
+        assert_equal 1, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE (EXISTS (SELECT 1 FROM "albums" WHERE (("albums"."artist_id" = "artists"."id") AND ("id" = 40))))), ds.sql
+
+        artist = ds.first!
+        assert_includes artist.albums.map(&:id), 40
+      end
+
+      it "should support an empty filter that checks for existence" do
+        ds = Artist.association_filter(:albums)
+        assert_equal 10, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE (EXISTS (SELECT 1 FROM "albums" WHERE ("albums"."artist_id" = "artists"."id")))), ds.sql
+
+        Album.where(artist_id: 5).delete
+        assert_equal 9, ds.count
+      end
+    end
+  end
+
+  describe "with a composite primary key" do
+    before do
+      drop_tables
+
+      DB.create_table :artists do
+        integer :id_1, null: false
+        integer :id_2, null: false
+        serial :serial_column
+
+        primary_key [:id_1, :id_2]
+      end
+
+      DB.create_table :albums do
+        integer :id_1, null: false
+        integer :id_2, null: false
+        integer :id_3, null: false
+        serial :serial_column
+
+        primary_key [:id_1, :id_2, :id_3]
+        foreign_key [:id_1, :id_2], :artists
+      end
+
+      DB.run <<-SQL
+        INSERT INTO artists (id_1, id_2)       SELECT i,j   FROM generate_series(1, 10) i CROSS JOIN generate_series(1, 10) j;
+        INSERT INTO albums  (id_1, id_2, id_3) SELECT i,j,k FROM generate_series(1, 10) i CROSS JOIN generate_series(1, 10) j CROSS JOIN generate_series(1, 10) k;
+      SQL
+
+      class Artist < Sequel::Model
+        set_primary_key [:id_1, :id_2]
+
+        one_to_many :albums, class: 'OneToManySpec::Album', key: [:id_1, :id_2]
+      end
+
+      class Album < Sequel::Model
+        set_primary_key [:id_1, :id_2, :id_3]
+
+        many_to_one :artist, class: 'OneToManySpec::Artist', key: [:id_1, :id_2]
+      end
+    end
+
+    after do
+      OneToManySpec.send(:remove_const, :Artist)
+      OneToManySpec.send(:remove_const, :Album)
+      drop_tables
+    end
+
+    def drop_tables
+      DB.drop_table? :albums, :artists
     end
 
-    it "should support an empty filter that checks for existence" do
-      ds = Album.association_filter(:tracks)
-      assert_equal 100, ds.count
-      assert_equal %(SELECT * FROM "albums" WHERE (EXISTS (SELECT 1 FROM "tracks" WHERE ("tracks"."album_id" = "albums"."id")))), ds.sql
+    describe "association_filter through a one_to_many association" do
+      it "should support a simple filter" do
+        ds = Artist.association_filter(:albums){|t| t.where(serial_column: 40)}
+
+        assert_equal 1, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE (EXISTS (SELECT 1 FROM "albums" WHERE (("albums"."id_1" = "artists"."id_1") AND ("albums"."id_2" = "artists"."id_2") AND ("serial_column" = 40))))), ds.sql
+
+        artist = ds.first!
+        assert_includes artist.albums.map(&:serial_column), 40
+      end
+
+      it "should support an empty filter that checks for existence" do
+        ds = Artist.association_filter(:albums)
+        assert_equal 100, ds.count
+        assert_equal %(SELECT * FROM "artists" WHERE (EXISTS (SELECT 1 FROM "albums" WHERE (("albums"."id_1" = "artists"."id_1") AND ("albums"."id_2" = "artists"."id_2"))))), ds.sql
 
-      Track.where(album_id: 50).delete
-      assert_equal 99, ds.count
+        Album.where(id_1: 5, id_2: 6).delete
+        assert_equal 99, ds.count
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -6,63 +6,6 @@ Sequel::Model.plugin :association_filtering
 
 DB = Sequel.connect "postgres:///sequel-association-filtering-test"
 
-DB.drop_table? :album_genres, :genres, :tracks, :albums, :artists
-
-DB.create_table :artists do
-  primary_key :id
-end
-
-DB.create_table :albums do
-  primary_key :id
-  foreign_key :artist_id, :artists
-end
-
-DB.create_table :tracks do
-  primary_key :id
-  foreign_key :album_id, :albums
-end
-
-DB.create_table :genres do
-  primary_key :id
-end
-
-DB.create_table :album_genres do
-  primary_key :id
-  foreign_key :album_id, :albums
-  foreign_key :genre_id, :genres
-
-  unique [:album_id, :genre_id]
-end
-
-class Artist < Sequel::Model
-  one_to_many :albums
-end
-
-class Album < Sequel::Model
-  many_to_one :artist
-  one_to_many :tracks
-
-  many_to_many :genres, join_table: :album_genres
-end
-
-class Track < Sequel::Model
-  many_to_one :album
-end
-
-class Genre < Sequel::Model
-  many_to_many :albums, join_table: :album_genres
-end
-
-DB.run <<-SQL
-  INSERT INTO artists SELECT i FROM generate_series(1, 10) i;
-  INSERT INTO albums (artist_id) SELECT (i % 10) + 1 FROM generate_series(1, 100) i;
-  INSERT INTO tracks (album_id) SELECT (i % 100) + 1 FROM generate_series(1, 1000) i;
-  INSERT INTO genres SELECT i FROM generate_series(1, 10) i;
-
-  INSERT INTO album_genres (album_id, genre_id)
-    SELECT DISTINCT ceil(random() * 100), ceil(random() * 10) FROM generate_series(1, 300);
-SQL
-
 require 'pry'
 require 'minitest/autorun'
 require 'minitest/pride'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-association-filtering
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Chris Hanks
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-09 00:00:00.000000000 Z
+date: 2018-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler