active_record_extended 1.1.0 → 2.0.0

data/spec/query_methods/unionize_spec.rb

@@ -3,112 +3,113 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Union Methods" do
-  let!(:person_one)     { Person.create!(number: 8) }
-  let!(:person_two)     { Person.create!(number: 10) }
-  let!(:person_three)   { Person.create!(number: 1) }
-  let!(:person_one_pl)  { ProfileL.create!(person: person_one, likes: 100) }
-  let!(:person_two_pl)  { ProfileL.create!(person: person_two, likes: 200) }
+  let!(:user_one)     { User.create!(number: 8) }
+  let!(:user_two)     { User.create!(number: 10) }
+  let!(:user_three)   { User.create!(number: 1) }
+  let!(:user_one_pl)  { ProfileL.create!(user: user_one, likes: 100) }
+  let!(:user_two_pl)  { ProfileL.create!(user: user_two, likes: 200) }
 
   shared_examples_for "standard set of errors" do
-    let(:person_one_query)  { Person.select(:id).where(id: person_one.id) }
-    let(:person_two_query)  { Person.select(:id, :tags).where(id: person_two.id) }
+    let(:user_one_query)  { User.select(:id).where(id: user_one.id) }
+    let(:user_two_query)  { User.select(:id, :tags).where(id: user_two.id) }
     let(:misaligned_cmd)    { raise("required to override this 'let' statement") }
     let(:lacking_union_cmd) { raise("required to override this 'let' statement") }
 
     it "should raise an error if the select statements do not align" do
       expect { misaligned_cmd.to_a }.to(
-        raise_error(ActiveRecord::StatementInvalid, /each [[:alpha:]]+ query must have the same number of columns/),
+        raise_error(ActiveRecord::StatementInvalid, /each [[:alpha:]]+ query must have the same number of columns/)
       )
     end
 
     it "should raise an argument error if there are less then two union statements" do
       expect { lacking_union_cmd.to_a }.to(
-        raise_error(ArgumentError, "You are required to provide 2 or more unions to join!"),
+        raise_error(ArgumentError, "You are required to provide 2 or more unions to join!")
       )
     end
   end
 
   describe ".union" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union(person_one_query) }
+      let!(:misaligned_cmd)    { User.union(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union(user_one_query) }
     end
 
     it "should return two users that match the where conditions" do
-      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id))
-      expect(query).to match_array([person_one, person_three])
+      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id))
+      expect(query).to match_array([user_one, user_three])
     end
 
     it "should allow joins on union statements" do
-      query = Person.union(Person.where(id: person_one.id), Person.joins(:profile_l).where.not(id: person_one.id))
-      expect(query).to match_array([person_one, person_two])
+      query = User.union(User.where(id: user_one.id), User.joins(:profile_l).where.not(id: user_one.id))
+      expect(query).to match_array([user_one, user_two])
     end
 
     it "should eliminate duplicate results" do
-      expected_ids = Person.pluck(:id)
-      query        = Person.union(Person.select(:id), Person.select(:id))
+      expected_ids = User.pluck(:id)
+      query        = User.union(User.select(:id), User.select(:id))
       expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
     end
   end
 
   describe ".union.all" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.all(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.all(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.all(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.all(user_one_query) }
     end
 
     it "should keep duplicate results from each union statement" do
-      expected_ids = Person.pluck(:id) * 2
-      query        = Person.union.all(Person.select(:id), Person.select(:id))
+      expected_ids = User.pluck(:id) * 2
+      query        = User.union.all(User.select(:id), User.select(:id))
       expect(query.pluck(:id)).to have_attributes(size: expected_ids.size).and(match_array(expected_ids))
     end
   end
 
   describe ".union.except" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.except(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.except(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.except(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.except(user_one_query) }
     end
 
     it "should eliminate records that match a given except statement" do
-      query = Person.union.except(Person.select(:id), Person.select(:id).where(id: person_one.id))
-      expect(query).to match_array([person_two, person_three])
+      query = User.union.except(User.select(:id), User.select(:id).where(id: user_one.id))
+      expect(query).to match_array([user_two, user_three])
     end
   end
 
   describe "union.intersect" do
     it_behaves_like "standard set of errors" do
-      let!(:misaligned_cmd)    { Person.union.intersect(person_one_query, person_two_query) }
-      let!(:lacking_union_cmd) { Person.union.intersect(person_one_query) }
+      let!(:misaligned_cmd)    { User.union.intersect(user_one_query, user_two_query) }
+      let!(:lacking_union_cmd) { User.union.intersect(user_one_query) }
     end
 
     it "should find records with similar attributes" do
-      ProfileL.create!(person: person_three, likes: 120)
+      ProfileL.create!(user: user_three, likes: 120)
 
       query =
-        Person.union.intersect(
-          Person.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
-          Person.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150"),
+        User.union.intersect(
+          User.select(:id, "profile_ls.likes").joins(:profile_l).where(profile_ls: { likes: 100 }),
+          User.select(:id, "profile_ls.likes").joins(:profile_l).where("profile_ls.likes < 150")
         )
 
-      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([person_one_pl.id]))
-      expect(query.first.likes).to eq(person_one_pl.likes)
+      expect(query.pluck(:id)).to have_attributes(size: 1).and(eq([user_one_pl.id]))
+      expect(query.first.likes).to eq(user_one_pl.likes)
     end
   end
 
   describe "union.as" do
     let(:query) do
-      Person.select("happy_people.id")
-            .union(Person.where(id: person_one.id), Person.where(id: person_three.id))
-            .union_as(:happy_people)
+      User
+        .select("happy_users.id")
+        .union(User.where(id: user_one.id), User.where(id: user_three.id))
+        .union_as(:happy_users)
     end
 
-    it "should return two people" do
+    it "should return two users" do
       expect(query.size).to eq(2)
     end
 
-    it "should return two peoples id's" do
-      expect(query.map(&:id)).to match_array([person_one.id, person_three.id])
+    it "should return two userss id's" do
+      expect(query.map(&:id)).to match_array([user_one.id, user_three.id])
     end
 
     it "should alias the tables being union'd but still allow for accessing table methods" do
@@ -120,43 +121,42 @@ RSpec.describe "Active Record Union Methods" do
 
   describe "union.order_union" do
     it "should order the .union commands" do
-      query = Person.union(Person.where(id: person_one.id), Person.where(id: person_three.id)).order_union(id: :desc)
-      expect(query).to eq([person_three, person_one])
+      query = User.union(User.where(id: user_one.id), User.where(id: user_three.id)).order_union(id: :desc)
+      expect(query).to eq([user_three, user_one])
     end
 
     it "should order the .union.all commands" do
       query =
-        Person.union.all(
-          Person.where(id: person_one.id),
-          Person.where(id: person_three.id),
+        User.union.all(
+          User.where(id: user_one.id),
+          User.where(id: user_three.id)
         ).order_union(id: :desc)
 
-      expect(query).to eq([person_three, person_one])
+      expect(query).to eq([user_three, user_one])
     end
 
     it "should order the union.except commands" do
-      query = Person.union.except(Person.order(id: :asc), Person.where(id: person_one.id)).order_union(id: :desc)
-      expect(query).to eq([person_three, person_two])
+      query = User.union.except(User.order(id: :asc), User.where(id: user_one.id)).order_union(id: :desc)
+      expect(query).to eq([user_three, user_two])
     end
 
     it "should order the .union.intersect commands" do
       query =
-        Person.union.intersect(
-          Person.where("id < ?", person_three.id),
-          Person.where("id >= ?", person_one.id),
+        User.union.intersect(
+          User.where("id < ?", user_three.id),
+          User.where("id >= ?", user_one.id)
         ).order_union(id: :desc)
 
-      expect(query).to eq([person_two, person_one])
+      expect(query).to eq([user_two, user_one])
     end
   end
 
   describe "union.reorder_union" do
     it "should replace the ordering with the new parameters" do
-      person_a         = Person.create!(number: 1)
-      person_b         = Person.create!(number: 10)
-      initial_ordering = [person_b, person_a]
-      query            = Person.union(Person.where(id: person_a.id), Person.where(id: person_b.id))
-                               .order_union(id: :desc)
+      user_a           = User.create!(number: 1)
+      user_b           = User.create!(number: 10)
+      initial_ordering = [user_b, user_a]
+      query            = User.union(User.where(id: user_a.id), User.where(id: user_b.id)).order_union(id: :desc)
 
       expect(query).to eq(initial_ordering)
       expect(query.reorder_union(number: :asc)).to eq(initial_ordering.reverse)

data/spec/query_methods/window_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Window Function Query Methods" do
+  let!(:user_one)   { User.create! }
+  let!(:user_two)   { User.create! }
+
+  let!(:tag_one)    { Tag.create!(user: user_one, tag_number: 1) }
+  let!(:tag_two)    { Tag.create!(user: user_two, tag_number: 2) }
+
+  let!(:tag_three)  { Tag.create!(user: user_one, tag_number: 3) }
+  let!(:tag_four)   { Tag.create!(user: user_two, tag_number: 4) }
+
+  let(:tag_group1)  { [tag_one, tag_three] }
+  let(:tag_group2)  { [tag_two, tag_four] }
+
+  describe ".window_select" do
+    context "when using ROW_NUMBER() ordered in asc" do
+      let(:base_query) do
+        Tag.define_window(:w).partition_by(:user_id, order_by: :tag_number).select(:id)
+      end
+
+      it "should return tag_one with r_id 1 and tag_three with r_id 2" do
+        results = base_query.select_window(:row_number, over: :w, as: :r_id).group_by(&:id)
+        tag_group1.each.with_index { |tag, idx| expect(results[tag.id].first.r_id).to eq(idx + 1) }
+      end
+
+      it "should return tag_two with r_id 1 and tag_four with r_id 2" do
+        results = base_query.select_window(:row_number, over: :w, as: :r_id).group_by(&:id)
+        tag_group2.each.with_index { |tag, idx| expect(results[tag.id].first.r_id).to eq(idx + 1) }
+      end
+    end
+
+    context "when using ROW_NUMBER() ordered in desc" do
+      let(:base_query) do
+        Tag.define_window(:w).partition_by(:user_id, order_by: { tag_number: :desc }).select(:id)
+      end
+
+      it "should return tag_one with r_id 2 and tag_three with r_id 1" do
+        results = base_query.select_window(:row_number, over: :w, as: :r_id).group_by(&:id)
+        tag_group1.reverse_each.with_index { |tag, idx| expect(results[tag.id].first.r_id).to eq(idx + 1) }
+      end
+
+      it "should return tag_two with r_id 2 and tag_four with r_id 1" do
+        results = base_query.select_window(:row_number, over: :w, as: :r_id).group_by(&:id)
+        tag_group2.reverse_each.with_index { |tag, idx| expect(results[tag.id].first.r_id).to eq(idx + 1) }
+      end
+    end
+  end
+end

data/spec/query_methods/with_cte_spec.rb

@@ -3,25 +3,25 @@
 require "spec_helper"
 
 RSpec.describe "Active Record With CTE Query Methods" do
-  let!(:person_one)  { Person.create! }
-  let!(:person_two)  { Person.create! }
-  let!(:profile_one) { ProfileL.create!(person_id: person_one.id, likes: 200) }
-  let!(:profile_two) { ProfileL.create!(person_id: person_two.id, likes: 500) }
+  let!(:user_one)    { User.create! }
+  let!(:user_two)    { User.create! }
+  let!(:profile_one) { ProfileL.create!(user_id: user_one.id, likes: 200) }
+  let!(:profile_two) { ProfileL.create!(user_id: user_two.id, likes: 500) }
 
   describe ".with/1" do
     context "when using as a standalone query" do
       it "should only return a person with less than 300 likes" do
-        query = Person.with(profile: ProfileL.where("likes < 300"))
-                      .joins("JOIN profile ON profile.id = people.id")
+        query = User.with(profile: ProfileL.where("likes < 300"))
+                    .joins("JOIN profile ON profile.id = users.id")
 
-        expect(query).to match_array([person_one])
+        expect(query).to match_array([user_one])
       end
 
       it "should return anyone with likes greater than or equal to 200" do
-        query = Person.with(profile: ProfileL.where("likes >= 200"))
-                      .joins("JOIN profile ON profile.id = people.id")
+        query = User.with(profile: ProfileL.where("likes >= 200"))
+                    .joins("JOIN profile ON profile.id = users.id")
 
-        expect(query).to match_array([person_one, person_two])
+        expect(query).to match_array([user_one, user_two])
       end
     end
 
@@ -31,9 +31,19 @@ RSpec.describe "Active Record With CTE Query Methods" do
 
       it "will maintain the CTE table when merging into existing AR queries" do
         sub_query = ProfileL.with(version_controls: VersionControl.where.contains(source: { help: "me" }))
-        query     = Person.joins(profile_l: :version).merge(sub_query)
+        query     = User.joins(profile_l: :version).merge(sub_query)
 
-        expect(query).to match_array([person_one])
+        expect(query).to match_array([user_one])
+      end
+
+      it "should contain a unique list of ordered CTE keys when merging in multiple children" do
+        x     = User.with(profile: ProfileL.where("likes < 300"))
+        y     = User.with(profile: ProfileL.where("likes > 400"))
+        z     = y.merge(x).joins("JOIN profile ON profile.id = users.id") # Y should reject X's CTE (FIFO)
+        query = User.with(my_profile: z).joins("JOIN my_profile ON my_profile.id = users.id")
+
+        expect(query.cte.with_keys).to eq([:profile, :my_profile])
+        expect(query).to match_array([user_two])
       end
     end
   end

data/spec/spec_helper.rb

@@ -13,7 +13,7 @@ end
 ActiveRecord::Base.establish_connection(ENV["DATABASE_URL"])
 
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require File.expand_path(f) }
-Dir["#{File.dirname(__FILE__)}/**/*examples.rb"].each { |f| require f }
+Dir["#{File.dirname(__FILE__)}/**/*examples.rb"].sort.each { |f| require f }
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure

data/spec/sql_inspections/any_of_sql_spec.rb

@@ -3,30 +3,30 @@
 require "spec_helper"
 
 RSpec.describe "Any / None of SQL Queries" do
-  let(:equal_query) { '"people"."personal_id" = 1' }
-  let(:or_query)    { 'OR "people"."personal_id" = 2' }
-  let(:equal_or)    { equal_query + " " + or_query }
-  let(:join_query)  { /INNER JOIN \"tags\" ON \"tags\".\"person_id\" = \"people\".\"id/ }
+  let(:equal_query) { '"users"."personal_id" = 1' }
+  let(:or_query)    { 'OR "users"."personal_id" = 2' }
+  let(:equal_or)    { "#{equal_query} #{or_query}" }
+  let(:join_query)  { /INNER JOIN "tags" ON "tags"."user_id" = "users"."id/ }
 
   describe "where.any_of/1" do
     it "should group different column arguments into nested or conditions" do
-      query = Person.where.any_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
+      query = User.where.any_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
       expect(query).to match_regex(/WHERE \(\(.+ = 1 OR .+ = 2\) OR .+ = 2\)/)
     end
 
     it "Should assign where clause predicates for standard queries" do
-      query = Person.where.any_of({ personal_id: 1 }, { personal_id: 2 }).to_sql
+      query = User.where.any_of({ personal_id: 1 }, { personal_id: 2 }).to_sql
       expect(query).to include(equal_or)
 
-      personal_one = Person.where(personal_id: 1)
-      personal_two = Person.where(personal_id: 2)
-      query = Person.where.any_of(personal_one, personal_two).to_sql
+      personal_one = User.where(personal_id: 1)
+      personal_two = User.where(personal_id: 2)
+      query = User.where.any_of(personal_one, personal_two).to_sql
       expect(query).to include(equal_or)
     end
 
     it "Joining queries should be added to the select statement" do
-      person_two_tag = Person.where(personal_id: 1).joins(:hm_tags)
-      query = Person.where.any_of(person_two_tag).to_sql
+      user_two_tag = User.where(personal_id: 1).joins(:hm_tags)
+      query = User.where.any_of(user_two_tag).to_sql
       expect(query).to match_regex(join_query)
       expect(query).to include(equal_query)
     end
@@ -34,7 +34,7 @@ RSpec.describe "Any / None of SQL Queries" do
 
   describe "where.none_of/1" do
     it "Should surround the query in a WHERE NOT clause" do
-      query = Person.where.none_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
+      query = User.where.none_of({ personal_id: 1 }, { id: 2 }, { personal_id: 2 }).to_sql
       expect(query).to match_regex(/WHERE.+NOT \(\(.+ = 1 OR .+ = 2\) OR .+ = 2\)/)
     end
   end

data/spec/sql_inspections/arel/aggregate_function_name_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Arel::Nodes::AggregateFunctionName do
+  describe "Custom Aggregate function" do
+    it "constructs an aggregate function based on a given name" do
+      query = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me")])
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(id == me)")
+    end
+
+    it "can append multiple expressions" do
+      query = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me"), Arel.sql("id == you")])
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(id == me, id == you)")
+    end
+
+    it "can append a distinct clause inside the aggregate" do
+      query = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me")], true)
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(DISTINCT id == me)")
+    end
+
+    it "can append an order by clause when providing a ordering expression" do
+      order_expr = Arel.sql("id").desc
+      query      = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me")], true).order_by([order_expr])
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(DISTINCT id == me ORDER BY id DESC)")
+    end
+
+    it "can append multiple ordering clauses" do
+      expr       = Arel.sql("id").desc
+      other_expr = Arel.sql("name").asc
+      query      = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me")], true).order_by([expr, other_expr])
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(DISTINCT id == me ORDER BY id DESC, name ASC)")
+    end
+
+    it "can be aliased" do
+      alias_as = Arel.sql("new_name")
+      query    = described_class.new("MY_CUSTOM_AGG", [Arel.sql("id == me")], true).as(alias_as)
+      expect(query.to_sql).to eq("MY_CUSTOM_AGG(DISTINCT id == me) AS new_name")
+    end
+  end
+end

data/spec/sql_inspections/arel/array_spec.rb

@@ -3,7 +3,7 @@
 require "spec_helper"
 
 RSpec.describe "Array Column Predicates" do
-  let(:arel_table) { Person.arel_table }
+  let(:arel_table) { User.arel_table }
 
   describe "Array Overlap" do
     it "converts Arel overlap statement" do
@@ -17,7 +17,7 @@ RSpec.describe "Array Column Predicates" do
     end
 
     it "works with count (and other predicates)" do
-      expect(Person.where(arel_table[:tag_ids].overlap([1, 2])).count).to eq 0
+      expect(User.where(arel_table[:tag_ids].overlap([1, 2])).count).to eq 0
     end
   end
 
@@ -33,31 +33,31 @@ RSpec.describe "Array Column Predicates" do
     end
 
     it "works with count (and other predicates)" do
-      expect(Person.where(arel_table[:tag_ids].contains([1, 2])).count).to eq 0
+      expect(User.where(arel_table[:tag_ids].contains([1, 2])).count).to eq 0
     end
   end
 
   describe "Any Array Element" do
     it "creates any predicates that contain a string value" do
       query = arel_table.where(arel_table[:tags].any("tag")).to_sql
-      expect(query).to match_regex(/'tag' = ANY\("people"\."tags"\)/)
+      expect(query).to match_regex(/'tag' = ANY\("users"\."tags"\)/)
     end
 
     it "creates any predicates that contain a integer value" do
       query = arel_table.where(arel_table[:tags].any(2)).to_sql
-      expect(query).to match_regex(/2 = ANY\("people"\."tags"\)/)
+      expect(query).to match_regex(/2 = ANY\("users"\."tags"\)/)
     end
   end
 
   describe "All Array Elements" do
     it "create all predicates that contain a string value" do
       query = arel_table.where(arel_table[:tags].all("tag")).to_sql
-      expect(query).to match_regex(/'tag' = ALL\("people"\."tags"\)/)
+      expect(query).to match_regex(/'tag' = ALL\("users"\."tags"\)/)
     end
 
     it "create all predicates that contain a interger value" do
       query = arel_table.where(arel_table[:tags].all(2)).to_sql
-      expect(query).to match_regex(/2 = ALL\("people"\."tags"\)/)
+      expect(query).to match_regex(/2 = ALL\("users"\."tags"\)/)
     end
   end
 end