active_record_extended_telescope 2.0.1

data/spec/query_methods/select_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Select Methods" do
+  let(:numbers) { (1..10).to_a }
+
+  describe ".foster_select" do
+    context "with an aggregate function" do
+      context "agg_array" do
+        let(:number_set) { numbers.sample(6).to_enum }
+        let!(:users) { Array.new(6) { User.create!(number: number_set.next, ip: "127.0.0.1") } }
+        let!(:tags) { users.flat_map { |u| Array.new(2) { Tag.create!(user: u, tag_number: numbers.sample) } } }
+
+        it "can accept a subquery" do
+          subquery = Tag.select("count(*)").joins("JOIN users u ON tags.user_id = u.id").where("u.ip = users.ip")
+          query    =
+            User.foster_select(tag_count: [subquery, { cast_with: :array_agg, distinct: true }])
+                .joins(:hm_tags)
+                .group(:ip)
+                .take
+
+          expect(query.tag_count).to eq([tags.size])
+        end
+
+        it "can be ordered" do
+          query = User.foster_select(
+            asc_ordered_numbers:  [:number, { cast_with: :array_agg, order_by: { number: :asc } }],
+            desc_ordered_numbers: [:number, { cast_with: :array_agg, order_by: { number: :desc } }]
+          ).take
+
+          expect(query.asc_ordered_numbers).to eq(number_set.to_a.sort)
+          expect(query.desc_ordered_numbers).to eq(number_set.to_a.sort.reverse)
+        end
+
+        it "works with joined relations" do
+          query =
+            User.foster_select(tag_numbers: { tags: :tag_number, cast_with: :array_agg })
+                .joins(:hm_tags)
+                .take
+          expect(query.tag_numbers).to match_array(Tag.pluck(:tag_number))
+        end
+      end
+
+      context "bool_[and|or]" do
+        let!(:users) do
+          enum_numbers = numbers.to_enum
+          Array.new(6) { User.create!(number: enum_numbers.next, ip: "127.0.0.1") }
+        end
+
+        it "will return a boolean expression" do
+          query = User.foster_select(
+            truthly_expr:     ["users.number > 0",   { cast_with: :bool_and }],
+            falsey_expr:      ["users.number > 200", { cast_with: :bool_and }],
+            other_true_expr:  ["users.number > 4",   { cast_with: :bool_or }],
+            other_false_expr: ["users.number > 6",   { cast_with: :bool_or }]
+          ).take
+
+          expect(query.truthly_expr).to be_truthy
+          expect(query.falsey_expr).to be_falsey
+          expect(query.other_true_expr).to be_truthy
+          expect(query.other_false_expr).to be_falsey
+        end
+      end
+
+      context "with math functions: sum|max|min|avg" do
+        before { 2.times.flat_map { |i| Array.new(2) { |j| User.create!(number: (i + 1) * j + 3) } } }
+
+        it "max" do
+          query = User.foster_select(max_num: [:number, { cast_with: :max }]).take
+          expect(query.max_num).to eq(5)
+        end
+
+        it "min" do
+          query = User.foster_select(max_num: [:number, { cast_with: :min }]).take
+          expect(query.max_num).to eq(3)
+        end
+
+        it "sum" do
+          query = User.foster_select(
+            num_sum:      [:number, { cast_with: :sum }],
+            distinct_sum: [:number, { cast_with: :sum, distinct: true }]
+          ).take
+
+          expect(query.num_sum).to eq(15)
+          expect(query.distinct_sum).to eq(12)
+        end
+
+        it "avg" do
+          query = User.foster_select(
+            num_avg:      [:number, { cast_with: :avg }],
+            distinct_avg: [:number, { cast_with: :avg, distinct: true }]
+          ).take
+
+          expect(query.num_avg).to eq(3.75)
+          expect(query.distinct_avg).to eq(4.0)
+        end
+      end
+    end
+
+    context "with standard select items" do
+      let!(:user) { User.create!(name: "Test") }
+
+      it "works with no alias" do
+        query = User.foster_select(:name).take
+        expect(query.name).to eq(user.name)
+      end
+
+      it "works with alias" do
+        query = User.foster_select(my_name: :name).take
+        expect(query.my_name).to eq(user.name)
+      end
+    end
+  end
+end

data/spec/query_methods/unionize_spec.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record Union Methods" do
+  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(: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/)
+      )
+    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!")
+      )
+    end
+  end
+
+  describe ".union" do
+    it_behaves_like "standard set of errors" do
+      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 = 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 = 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 = 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)    { 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 = 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)    { 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 = 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)    { 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!(user: user_three, likes: 120)
+
+      query =
+        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([user_one_pl.id]))
+      expect(query.first.likes).to eq(user_one_pl.likes)
+    end
+  end
+
+  describe "union.as" do
+    let(:query) do
+      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 users" do
+      expect(query.size).to eq(2)
+    end
+
+    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
+      query.each do |happy_person|
+        expect(happy_person).to respond_to(:profile_l)
+      end
+    end
+  end
+
+  describe "union.order_union" do
+    it "should order the .union commands" do
+      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 =
+        User.union.all(
+          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.except commands" do
+      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 =
+        User.union.intersect(
+          User.where("id < ?", user_three.id),
+          User.where("id >= ?", user_one.id)
+        ).order_union(id: :desc)
+
+      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
+      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)
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Active Record With CTE Query Methods" do
+  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 = User.with(profile: ProfileL.where("likes < 300"))
+                    .joins("JOIN profile ON profile.id = users.id")
+
+        expect(query).to match_array([user_one])
+      end
+
+      it "should return anyone with likes greater than or equal to 200" do
+        query = User.with(profile: ProfileL.where("likes >= 200"))
+                    .joins("JOIN profile ON profile.id = users.id")
+
+        expect(query).to match_array([user_one, user_two])
+      end
+    end
+
+    context "when merging in query" do
+      let!(:version_one) { VersionControl.create!(versionable: profile_one, source: { help: "me" }) }
+      let!(:version_two) { VersionControl.create!(versionable: profile_two, source: { help: "no one" }) }
+
+      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     = User.joins(profile_l: :version).merge(sub_query)
+
+        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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "simplecov"
+SimpleCov.start
+
+require "active_record_extended"
+
+unless ENV["DATABASE_URL"]
+  require "dotenv"
+  Dotenv.load
+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"].sort.each { |f| require f }
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/sql_inspections/any_of_sql_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Any / None of SQL Queries" do
+  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 = 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 = User.where.any_of({ personal_id: 1 }, { personal_id: 2 }).to_sql
+      expect(query).to include(equal_or)
+
+      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
+      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
+  end
+
+  describe "where.none_of/1" do
+    it "Should surround the query in a WHERE NOT clause" do
+      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
+end