active_record_extended 1.1.0 → 2.0.0

data/lib/active_record_extended/utilities/order_by.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module ActiveRecordExtended
+  module Utilities
+    module OrderBy
+      def inline_order_by(arel_node, ordering_args)
+        return arel_node unless scope_preprocess_order_args(ordering_args)
+
+        Arel::Nodes::InfixOperation.new("ORDER BY", arel_node, ordering_args)
+      end
+
+      def scope_preprocess_order_args(ordering_args)
+        return false if ordering_args.blank? || !@scope.respond_to?(:preprocess_order_args, true)
+
+        # Sanitation check / resolver (ActiveRecord::Relation#preprocess_order_args)
+        @scope.send(:preprocess_order_args, ordering_args)
+        ordering_args
+      end
+
+      # Processes "ORDER BY" expressions for supported aggregate functions
+      def order_by_expression(order_by)
+        return false unless order_by && order_by.presence.present?
+
+        to_ordered_table_path(order_by)
+          .tap { |order_args| process_ordering_arguments!(order_args) }
+          .tap { |order_args| scope_preprocess_order_args(order_args) }
+      end
+
+      #
+      # Turns a hash into a dot notation path.
+      #
+      # Example:
+      # - Using pre-set directions:
+      #   [{ products: { position: :asc, id: :desc } }]
+      #     #=> [{ "products.position" => :asc, "products.id" => :desc }]
+      #
+      # - Using fallback directions:
+      #   [{products: :position}]
+      #     #=> [{"products.position" => :asc}]
+      #
+      def to_ordered_table_path(args)
+        flatten_safely(Array.wrap(args)) do |arg|
+          next arg unless arg.is_a?(Hash)
+
+          arg.each_with_object({}) do |(tbl_or_col, obj), new_hash|
+            if obj.is_a?(Hash)
+              obj.each_pair do |o_key, o_value|
+                new_hash["#{tbl_or_col}.#{o_key}"] = o_value
+              end
+            elsif ::ActiveRecord::QueryMethods::VALID_DIRECTIONS.include?(obj)
+              new_hash[tbl_or_col] = obj
+            elsif obj.nil?
+              new_hash[tbl_or_col.to_s] = :asc
+            else
+              new_hash["#{tbl_or_col}.#{obj}"] = :asc
+            end
+          end
+        end
+      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
+    end
+  end
+end

data/lib/active_record_extended/utilities/support.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module Utilities
+    module Support
+      A_TO_Z_KEYS = ("a".."z").to_a.freeze
+
+      # We need to ensure we can flatten nested ActiveRecord::Relations
+      # that might have been nested due to the (splat)*args parameters
+      #
+      # Note: calling `Array.flatten[!]/1` will actually remove all AR relations from the array.
+      #
+      def flatten_to_sql(*values)
+        flatten_safely(values) do |value|
+          value = yield value if block_given?
+          to_arel_sql(value)
+        end
+      end
+      alias to_sql_array flatten_to_sql
+
+      def flatten_safely(values, &block)
+        unless values.is_a?(Array)
+          values = yield values if block
+          return [values]
+        end
+
+        values.map { |value| flatten_safely(value, &block) }.reduce(:+)
+      end
+
+      # Applies aliases to the given query
+      # Ex: `SELECT * FROM users` => `(SELECT * FROM users) AS "members"`
+      def nested_alias_escape(query, alias_name)
+        sql_query = generate_grouping(query)
+        Arel::Nodes::As.new(sql_query, to_arel_sql(double_quote(alias_name)))
+      end
+
+      # Wraps subquery into an Aliased ARRAY
+      # Ex: `SELECT * FROM users` => (ARRAY(SELECT * FROM users)) AS "members"
+      def wrap_with_array(arel_or_rel_query, alias_name, order_by: false)
+        if order_by && arel_or_rel_query.is_a?(ActiveRecord::Relation)
+          arel_or_rel_query = arel_or_rel_query.order(order_by)
+        end
+
+        query = Arel::Nodes::Array.new(to_sql_array(arel_or_rel_query))
+        nested_alias_escape(query, alias_name)
+      end
+
+      # Wraps query into an aggregated array
+      # EX: `(ARRAY_AGG((SELECT * FROM users)) AS "members"`
+      #     `(ARRAY_AGG(DISTINCT (SELECT * FROM users)) AS "members"`
+      #     `SELECT ARRAY_AGG((id)) AS "ids" FROM users`
+      #     `SELECT ARRAY_AGG(DISTINCT (id)) AS "ids" FROM users`
+      def wrap_with_agg_array(arel_or_rel_query, alias_name, order_by: false, distinct: false)
+        distinct       = !(!distinct)
+        order_exp      = distinct ? nil : order_by # Can't order a distinct agg
+        query          = group_when_needed(arel_or_rel_query)
+        query          =
+          Arel::Nodes::AggregateFunctionName
+          .new("ARRAY_AGG", to_sql_array(query), distinct)
+          .order_by(order_exp)
+
+        nested_alias_escape(query, alias_name)
+      end
+
+      # Will attempt to digest and resolve the from clause
+      #
+      # If the from clause is a String, it will check to see if a table reference key has been assigned.
+      #   - If one cannot be detected, one will be appended.
+      #   - Rails does not allow assigning table references using the `.from/2` method, when its a string / sym type.
+      #
+      # If the from clause is an AR relation; it will duplicate the object.
+      #   - Ensures any memorizers are reset (ex: `.to_sql` sets a memorizer on the instance)
+      #   - Key's can be assigned using the `.from/2` method.
+      #
+      def from_clause_constructor(from, reference_key)
+        case from
+        when /\s.?#{reference_key}.?$/ # The from clause is a string and has the tbl reference key
+          @scope.unscoped.from(from)
+        when String, Symbol
+          @scope.unscoped.from("#{from} #{reference_key}")
+        else
+          replicate_klass = from.respond_to?(:unscoped) ? from.unscoped : @scope.unscoped
+          replicate_klass.from(from.dup, reference_key)
+        end.unscope(:where)
+      end
+
+      # Will carry defined CTE tables from the nested sub-query and gradually pushes it up to the parents query stack
+      # I.E: It pushes `WITH [:cte_name:] AS(...), ..` to the top of the query structure tree
+      #
+      # SPECIAL GOTCHA NOTE: (if duplicate keys are found) This will favor the parents query `with's` over nested ones!
+      def pipe_cte_with!(subquery)
+        return self unless subquery.try(:with_values?)
+
+        # Add subquery CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+        if @scope.with_values?
+          @scope.cte.pipe_cte_with!(subquery.cte)
+        else
+          # Top level has no with values
+          @scope.with!(subquery.cte)
+        end
+
+        self
+      end
+
+      # Ensures the given value is properly double quoted.
+      # This also ensures we don't have conflicts with reversed keywords.
+      #
+      # IE: `user` is a reserved keyword in PG. But `"user"` is allowed and works the same
+      #     when used as an column/tbl alias.
+      def double_quote(value)
+        return if value.nil?
+
+        case value.to_s
+          # Ignore keys that contain double quotes or a Arel.star (*)[all columns]
+          # or if a table has already been explicitly declared (ex: users.id)
+        when "*", /((^".+"$)|(^[[:alpha:]]+\.[[:alnum:]]+))/
+          value
+        else
+          PG::Connection.quote_ident(value.to_s)
+        end
+      end
+
+      # Ensures the key is properly single quoted and treated as a actual PG key reference.
+      def literal_key(key)
+        case key
+        when TrueClass  then "'t'"
+        when FalseClass then "'f'"
+        when Numeric    then key
+        else
+          key = key.to_s
+          key.start_with?("'") && key.end_with?("'") ? key : "'#{key}'"
+        end
+      end
+
+      # Converts a potential subquery into a compatible Arel SQL node.
+      #
+      # Note:
+      # 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.1, we then can then drop the '.to_sql' conversation
+
+      def to_arel_sql(value)
+        case value
+        when Arel::Nodes::Node, Arel::Nodes::SqlLiteral, nil
+          value
+        when ActiveRecord::Relation
+          Arel.sql(value.spawn.to_sql)
+        else
+          Arel.sql(value.respond_to?(:to_sql) ? value.to_sql : value.to_s)
+        end
+      end
+
+      def group_when_needed(arel_or_rel_query)
+        return arel_or_rel_query unless needs_to_be_grouped?(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
+    end
+  end
+end

data/lib/active_record_extended/version.rb

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

data/spec/query_methods/any_of_spec.rb

@@ -3,65 +3,65 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Any / None of Methods" do
-  let!(:one)       { Person.create!(personal_id: 1) }
-  let!(:two)       { Person.create!(personal_id: 2) }
-  let!(:three)     { Person.create!(personal_id: 3) }
+  let!(:one)       { User.create!(personal_id: 1) }
+  let!(:two)       { User.create!(personal_id: 2) }
+  let!(:three)     { User.create!(personal_id: 3) }
 
-  let!(:tag_one)   { Tag.create!(person_id: one.id) }
-  let!(:tag_two)   { Tag.create!(person_id: two.id) }
-  let!(:tag_three) { Tag.create!(person_id: three.id) }
+  let!(:tag_one)   { Tag.create!(user_id: one.id) }
+  let!(:tag_two)   { Tag.create!(user_id: two.id) }
+  let!(:tag_three) { Tag.create!(user_id: three.id) }
 
   describe "where.any_of/1" do
     it "Should return queries that match any of the outlined queries" do
-      query = Person.where.any_of({ personal_id: 1 }, { personal_id: 2 })
+      query = User.where.any_of({ personal_id: 1 }, { personal_id: 2 })
       expect(query).to include(one, two)
       expect(query).to_not include(three)
     end
 
     it "Should accept where query predicates" do
-      personal_one = Person.where(personal_id: 1)
-      personal_two = Person.where(personal_id: 2)
-      query = Person.where.any_of(personal_one, personal_two)
+      personal_one = User.where(personal_id: 1)
+      personal_two = User.where(personal_id: 2)
+      query = User.where.any_of(personal_one, personal_two)
 
       expect(query).to include(one, two)
       expect(query).to_not include(three)
     end
 
     it "Should accept query strings" do
-      personal_one = Person.where(personal_id: 1)
+      personal_one = User.where(personal_id: 1)
 
-      query = Person.where.any_of(personal_one, "personal_id > 2")
+      query = User.where.any_of(personal_one, "personal_id > 2")
       expect(query).to include(one, three)
       expect(query).to_not include(two)
 
-      query = Person.where.any_of(["personal_id >= ?", 2])
+      query = User.where.any_of(["personal_id >= ?", 2])
       expect(query).to include(two, three)
       expect(query).to_not include(one)
     end
 
     context "Relationship queries" do
       it "Finds records that are queried from two or more has_many associations" do
-        person_one_tag = Tag.create!(person_id: one.id)
-        person_two_tag = Tag.create!(person_id: two.id)
-        query          = Tag.where.any_of(one.hm_tags, two.hm_tags)
+        user_one_tag = Tag.create!(user_id: one.id)
+        user_two_tag = Tag.create!(user_id: two.id)
+        query = Tag.where.any_of(one.hm_tags, two.hm_tags)
 
-        expect(query).to include(tag_one, tag_two, person_one_tag, person_two_tag)
+        expect(query).to include(tag_one, tag_two, user_one_tag, user_two_tag)
         expect(query).to_not include(tag_three)
       end
 
       it "Finds records that are dynamically joined" do
-        person_one_tag = Tag.where(people: { id: one.id }).includes(:person).references(:person)
-        person_two_tag = Tag.where(people: { id: two.id }).joins(:person)
-        query          = Tag.where.any_of(person_one_tag, person_two_tag)
+        user_one_tag = Tag.where(users: { id: one.id }).includes(:user).references(:user)
+        user_two_tag = Tag.where(users: { id: two.id }).joins(:user)
+        query = Tag.where.any_of(user_one_tag, user_two_tag)
 
         expect(query).to include(tag_one, tag_two)
         expect(query).to_not include(tag_three)
       end
 
       it "Return matched records of a joined table on the parent level" do
-        query = Tag.joins(:person).where.any_of(
-          { people: { personal_id: 1 } },
-          { people: { personal_id: 3 } },
+        query = Tag.joins(:user).where.any_of(
+          { users: { personal_id: 1 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_one, tag_three)
@@ -72,55 +72,55 @@ RSpec.describe "Active Record Any / None of Methods" do
 
   describe "where.none_of/1" do
     it "Should return queries that match none of the outlined queries" do
-      query = Person.where.none_of({ personal_id: 1 }, { personal_id: 2 })
+      query = User.where.none_of({ personal_id: 1 }, { personal_id: 2 })
       expect(query).to include(three)
       expect(query).to_not include(one, two)
     end
 
     it "Should accept where query predicates" do
-      personal_one = Person.where(personal_id: 1)
-      personal_two = Person.where(personal_id: 2)
-      query = Person.where.none_of(personal_one, personal_two)
+      personal_one = User.where(personal_id: 1)
+      personal_two = User.where(personal_id: 2)
+      query = User.where.none_of(personal_one, personal_two)
 
       expect(query).to include(three)
       expect(query).to_not include(one, two)
     end
 
     it "Should accept query strings" do
-      personal_one = Person.where(personal_id: 1)
+      personal_one = User.where(personal_id: 1)
 
-      query = Person.where.none_of(personal_one, "personal_id > 2")
+      query = User.where.none_of(personal_one, "personal_id > 2")
       expect(query).to include(two)
       expect(query).to_not include(one, three)
 
-      query = Person.where.none_of(["personal_id >= ?", 2])
+      query = User.where.none_of(["personal_id >= ?", 2])
       expect(query).to include(one)
       expect(query).to_not include(two, three)
     end
 
     context "Relationship queries" do
       it "Finds records that are queried from two or more has_many associations" do
-        person_one_tag = Tag.create!(person_id: one.id)
-        person_two_tag = Tag.create!(person_id: two.id)
-        query          = Tag.where.none_of(one.hm_tags, two.hm_tags)
+        user_one_tag = Tag.create!(user_id: one.id)
+        user_two_tag = Tag.create!(user_id: two.id)
+        query = Tag.where.none_of(one.hm_tags, two.hm_tags)
 
         expect(query).to include(tag_three)
-        expect(query).to_not include(tag_one, tag_two, person_one_tag, person_two_tag)
+        expect(query).to_not include(tag_one, tag_two, user_one_tag, user_two_tag)
       end
 
       it "Finds records that are dynamically joined" do
-        person_one_tag = Tag.where(people: { id: one.id }).includes(:person).references(:person)
-        person_two_tag = Tag.where(people: { id: two.id }).joins(:person)
-        query          = Tag.where.none_of(person_one_tag, person_two_tag)
+        user_one_tag = Tag.where(users: { id: one.id }).includes(:user).references(:user)
+        user_two_tag = Tag.where(users: { id: two.id }).joins(:user)
+        query = Tag.where.none_of(user_one_tag, user_two_tag)
 
         expect(query).to include(tag_three)
         expect(query).to_not include(tag_one, tag_two)
       end
 
       it "Return matched records of a joined table on the parent level" do
-        query = Tag.joins(:person).where.none_of(
-          { people: { personal_id: 1 } },
-          { people: { personal_id: 3 } },
+        query = Tag.joins(:user).where.none_of(
+          { users: { personal_id: 1 } },
+          { users: { personal_id: 3 } }
         )
 
         expect(query).to include(tag_two)

data/spec/query_methods/array_query_spec.rb

@@ -3,28 +3,28 @@
 require "spec_helper"
 
 RSpec.describe "Active Record Array Query Methods" do
-  let!(:one)   { Person.create!(tags: [1, 2, 3],  personal_id: 33) }
-  let!(:two)   { Person.create!(tags: [3, 1, 5],  personal_id: 88) }
-  let!(:three) { Person.create!(tags: [2, 8, 20], personal_id: 33) }
+  let!(:one)   { User.create!(tags: [1, 2, 3],  personal_id: 33) }
+  let!(:two)   { User.create!(tags: [3, 1, 5],  personal_id: 88) }
+  let!(:three) { User.create!(tags: [2, 8, 20], personal_id: 33) }
 
   describe "#overlap" do
     it "Should return matched records" do
-      query = Person.where.overlap(tags: [1])
+      query = User.where.overlap(tags: [1])
       expect(query).to include(one, two)
       expect(query).to_not include(three)
 
-      query = Person.where.overlap(tags: [2, 3])
+      query = User.where.overlap(tags: [2, 3])
       expect(query).to include(one, two, three)
     end
   end
 
   describe "#contains" do
     it "returns records that contain elements in an array" do
-      query = Person.where.contains(tags: [1, 3])
+      query = User.where.contains(tags: [1, 3])
       expect(query).to include(one, two)
       expect(query).to_not include(three)
 
-      query = Person.where.contains(tags: [8, 2])
+      query = User.where.contains(tags: [8, 2])
       expect(query).to include(three)
       expect(query).to_not include(one, two)
     end
@@ -32,31 +32,31 @@ RSpec.describe "Active Record Array Query Methods" do
 
   describe "#any" do
     it "should return any records that match" do
-      query = Person.where.any(tags: 3)
+      query = User.where.any(tags: 3)
       expect(query).to include(one, two)
       expect(query).to_not include(three)
     end
 
     it "allows chaining" do
-      query = Person.where.any(tags: 3).where(personal_id: 33)
+      query = User.where.any(tags: 3).where(personal_id: 33)
       expect(query).to include(one)
       expect(query).to_not include(two, three)
     end
   end
 
   describe "#all" do
-    let!(:contains_all)     { Person.create!(tags: [1], personal_id: 1) }
-    let!(:contains_all_two) { Person.create!(tags: [1], personal_id: 2) }
-    let!(:contains_some)    { Person.create!(tags: [1, 2], personal_id: 2) }
+    let!(:contains_all)     { User.create!(tags: [1], personal_id: 1) }
+    let!(:contains_all_two) { User.create!(tags: [1], personal_id: 2) }
+    let!(:contains_some)    { User.create!(tags: [1, 2], personal_id: 2) }
 
     it "should return any records that match" do
-      query = Person.where.all(tags: 1)
+      query = User.where.all(tags: 1)
       expect(query).to include(contains_all, contains_all_two)
       expect(query).to_not include(contains_some)
     end
 
     it "allows chaining" do
-      query = Person.where.all(tags: 1).where(personal_id: 1)
+      query = User.where.all(tags: 1).where(personal_id: 1)
       expect(query).to include(contains_all)
       expect(query).to_not include(contains_all_two, contains_some)
     end