active_record_extended 1.2.0 → 2.0.3

data/lib/active_record_extended/utilities/order_by.rb

@@ -24,8 +24,8 @@ module ActiveRecordExtended
         return false unless order_by && order_by.presence.present?
 
         to_ordered_table_path(order_by)
-          .tap(&method(:process_ordering_arguments!))
-          .tap(&method(:scope_preprocess_order_args))
+          .tap { |order_args| process_ordering_arguments!(order_args) }
+          .tap { |order_args| scope_preprocess_order_args(order_args) }
       end
 
       #
@@ -60,34 +60,15 @@ module ActiveRecordExtended
         end
       end
 
-      # We'll need to preprocess these arguments for allowing `ActiveRecord::Relation#preprocess_order_args`,
-      # to check for sanitization issues and convert over to `Arel::Nodes::[Ascending/Descending]`.
-      # Without reflecting / prepending the parent's table name.
-      #
-      if ActiveRecord.gem_version < Gem::Version.new("5.1")
-        # TODO: Rails 5.0.x order logic will *always* append the parents name to the column when its an HASH obj
-        #       We should really do this stuff better. Maybe even just ignore `preprocess_order_args` altogether?
-        #       Maybe I'm just stupidly over paranoid on just the 'ORDER BY' for some odd reason.
-        def process_ordering_arguments!(ordering_args)
-          ordering_args.flatten!
-          ordering_args.compact!
-          ordering_args.map! do |arg|
-            next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-            arg.each_with_object([]) do |(field, dir), ordering_object|
-              ordering_object << to_arel_sql(field).send(dir.to_s.downcase)
-            end
-          end.flatten!
-        end
-      else
-        def process_ordering_arguments!(ordering_args)
-          ordering_args.flatten!
-          ordering_args.compact!
-          ordering_args.map! do |arg|
-            next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-            arg.each_with_object({}) do |(field, dir), ordering_obj|
-              # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
-              ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
-            end
+      def process_ordering_arguments!(ordering_args)
+        ordering_args.flatten!
+        ordering_args.compact!
+        ordering_args.map! do |arg|
+          next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
+
+          arg.each_with_object({}) do |(field, dir), ordering_obj|
+            # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
+            ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
           end
         end
       end

data/lib/active_record_extended/utilities/support.rb

@@ -20,7 +20,7 @@ module ActiveRecordExtended
 
       def flatten_safely(values, &block)
         unless values.is_a?(Array)
-          values = yield values if block_given?
+          values = yield values if block
           return [values]
         end
 
@@ -30,7 +30,7 @@ module ActiveRecordExtended
       # Applies aliases to the given query
       # Ex: `SELECT * FROM users` => `(SELECT * FROM users) AS "members"`
       def nested_alias_escape(query, alias_name)
-        sql_query = Arel::Nodes::Grouping.new(to_arel_sql(query))
+        sql_query = generate_grouping(query)
         Arel::Nodes::As.new(sql_query, to_arel_sql(double_quote(alias_name)))
       end
 
@@ -81,7 +81,7 @@ module ActiveRecordExtended
         else
           replicate_klass = from.respond_to?(:unscoped) ? from.unscoped : @scope.unscoped
           replicate_klass.from(from.dup, reference_key)
-        end
+        end.unscope(:where)
       end
 
       # Will carry defined CTE tables from the nested sub-query and gradually pushes it up to the parents query stack
@@ -91,20 +91,12 @@ module ActiveRecordExtended
       def pipe_cte_with!(subquery)
         return self unless subquery.try(:with_values?)
 
-        cte_ary              = flatten_safely(subquery.with_values)
-        subquery.with_values = nil # Remove nested queries with values
-
-        # Add subquery's CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+        # Add subquery CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
         if @scope.with_values?
-          # combine top-level and lower level queries `.with` values into 1 structure
-          with_hash = cte_ary.each_with_object(@scope.with_values.first) do |from_cte, hash|
-            hash.reverse_merge!(from_cte)
-          end
-
-          @scope.with_values = [with_hash]
+          @scope.cte.pipe_cte_with!(subquery.cte)
         else
           # Top level has no with values
-          @scope.with!(*cte_ary)
+          @scope.with!(subquery.cte)
         end
 
         self
@@ -143,13 +135,13 @@ module ActiveRecordExtended
       # Converts a potential subquery into a compatible Arel SQL node.
       #
       # Note:
-      # We convert relations to SQL to maintain compatibility with Rails 5.[0/1].
+      # We convert relations to SQL to maintain compatibility with Rails 5.1.
       # Only Rails 5.2+ maintains bound attributes in Arel, so its better to be safe then sorry.
-      # When we drop support for Rails 5.[0/1], we then can then drop the '.to_sql' conversation
+      # When we drop support for Rails 5.1, we then can then drop the '.to_sql' conversation
 
       def to_arel_sql(value)
         case value
-        when Arel::Node, Arel::Nodes::SqlLiteral, nil
+        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, nil
           value
         when ActiveRecord::Relation
           Arel.sql(value.spawn.to_sql)
@@ -160,13 +152,24 @@ module ActiveRecordExtended
 
       def group_when_needed(arel_or_rel_query)
         return arel_or_rel_query unless needs_to_be_grouped?(arel_or_rel_query)
-        Arel::Nodes::Grouping.new(to_arel_sql(arel_or_rel_query))
+
+        generate_grouping(arel_or_rel_query)
       end
 
       def needs_to_be_grouped?(query)
         query.respond_to?(:to_sql) || (query.is_a?(String) && /^SELECT.+/i.match?(query))
       end
 
+      def generate_grouping(expr)
+        ::Arel::Nodes::Grouping.new(to_arel_sql(expr))
+      end
+
+      def generate_named_function(function_name, *args)
+        args.map! { |arg| to_arel_sql(arg) }
+        function_name = function_name.to_s.upcase
+        ::Arel::Nodes::NamedFunction.new(to_arel_sql(function_name), args)
+      end
+
       def key_generator
         A_TO_Z_KEYS.sample
       end

data/lib/active_record_extended/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  VERSION = "1.2.0"
+  VERSION = "2.0.3"
 end

data/spec/query_methods/any_of_spec.rb

@@ -61,7 +61,7 @@ RSpec.describe "Active Record Any / None of Methods" do
       it "Return matched records of a joined table on the parent level" do
         query = Tag.joins(:user).where.any_of(
           { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_one, tag_three)
@@ -120,7 +120,7 @@ RSpec.describe "Active Record Any / None of Methods" do
       it "Return matched records of a joined table on the parent level" do
         query = Tag.joins(:user).where.none_of(
           { users: { personal_id: 1 } },
-          { users: { personal_id: 3 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_two)

data/spec/query_methods/either_spec.rb

@@ -23,6 +23,17 @@ RSpec.describe "Active Record Either Methods" do
         expect(query).to_not include(three)
       end
     end
+
+    context "Through association .either_joins/2" do
+      let!(:four) { User.create! }
+      let!(:group) { Group.create!(users: [four]) }
+
+      it "Should only only return records that belong to profile L or has group" do
+        query = User.either_joins(:profile_l, :groups)
+        expect(query).to include(one, four)
+        expect(query).to_not include(three, two)
+      end
+    end
   end
 
   describe ".either_order/2" do

data/spec/query_methods/json_spec.rb

@@ -47,7 +47,7 @@ RSpec.describe "Active Record JSON methods" do
     end
 
     it "allows for casting results in an aggregate-able Array function" do
-      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_as_array: true)
+      query = User.select(:id).select_row_to_json(sub_query, key: :tag_row, as: :results, cast_with: :array)
       expect(query.take.results).to be_a(Array).and(be_present)
       expect(query.take.results.first).to be_a(Hash)
     end
@@ -61,14 +61,14 @@ RSpec.describe "Active Record JSON methods" do
 
   describe ".json_build_object" do
     let(:sub_query) do
-      User.select_row_to_json(from: User.select(:id), cast_as_array: true, as: :ids).where(id: user_one.id)
+      User.select_row_to_json(from: User.select(:id), cast_with: :array, as: :ids).where(id: user_one.id)
     end
 
     it "defaults the column alias if one is not provided" do
       query = User.json_build_object(:personal, sub_query)
       expect(query.size).to eq(1)
       expect(query.take.results).to match(
-        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }])),
+        "personal" => match("ids" => match_array([{ "id" => user_one.id }, { "id" => user_two.id }]))
       )
     end
 
@@ -98,7 +98,7 @@ RSpec.describe "Active Record JSON methods" do
         :personal,
         sub_query.where.not(id: user_one),
         value: "COALESCE(array_agg(\"personal\"), '{}')",
-        as:    :cool_dudes,
+        as:    :cool_dudes
       )
 
       expect(query.take.cool_dudes["personal"]).to be_a(Array).and(be_empty)
@@ -110,7 +110,7 @@ RSpec.describe "Active Record JSON methods" do
           :personal,
           sub_query.where.not(id: user_one),
           value: "COALESCE(array_agg(personal), '{}')",
-          as:    :cool_dudes,
+          as:    :cool_dudes
         )
       end.to output.to_stderr
     end

data/spec/query_methods/select_spec.rb

@@ -15,7 +15,7 @@ RSpec.describe "Active Record Select Methods" do
         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])
+            User.foster_select(tag_count: [subquery, { cast_with: :array_agg, distinct: true }])
                 .joins(:hm_tags)
                 .group(:ip)
                 .take
@@ -25,8 +25,8 @@ RSpec.describe "Active Record Select Methods" do
 
         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 }],
+            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)
@@ -50,10 +50,10 @@ RSpec.describe "Active Record Select Methods" do
 
         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],
+            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
@@ -67,19 +67,19 @@ RSpec.describe "Active Record Select Methods" 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
+          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
+          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],
+            num_sum:      [:number, { cast_with: :sum }],
+            distinct_sum: [:number, { cast_with: :sum, distinct: true }]
           ).take
 
           expect(query.num_sum).to eq(15)
@@ -88,8 +88,8 @@ RSpec.describe "Active Record Select Methods" do
 
         it "avg" do
           query = User.foster_select(
-            num_avg:      [:number, cast_with: :avg],
-            distinct_avg: [:number, cast_with: :avg, distinct: true],
+            num_avg:      [:number, { cast_with: :avg }],
+            distinct_avg: [:number, { cast_with: :avg, distinct: true }]
           ).take
 
           expect(query.num_avg).to eq(3.75)

data/spec/query_methods/unionize_spec.rb

@@ -17,13 +17,13 @@ RSpec.describe "Active Record Union Methods" do
 
     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
@@ -88,7 +88,7 @@ RSpec.describe "Active Record Union Methods" do
       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"),
+          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]))
@@ -129,7 +129,7 @@ RSpec.describe "Active Record Union Methods" do
       query =
         User.union.all(
           User.where(id: user_one.id),
-          User.where(id: user_three.id),
+          User.where(id: user_three.id)
         ).order_union(id: :desc)
 
       expect(query).to eq([user_three, user_one])
@@ -144,7 +144,7 @@ RSpec.describe "Active Record Union Methods" do
       query =
         User.union.intersect(
           User.where("id < ?", user_three.id),
-          User.where("id >= ?", user_one.id),
+          User.where("id >= ?", user_one.id)
         ).order_union(id: :desc)
 
       expect(query).to eq([user_two, user_one])

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,8 +3,8 @@
 require "spec_helper"
 
 RSpec.describe "Active Record With CTE Query Methods" do
-  let!(:user_one)  { User.create! }
-  let!(:user_two)  { User.create! }
+  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) }
 
@@ -35,6 +35,16 @@ RSpec.describe "Active Record With CTE Query Methods" do
 
         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

@@ -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

@@ -5,8 +5,8 @@ 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/ }
+  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