active_record_extended 1.2.0 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b524c24c37e0b6f7449d70e5030b893119b98dec6646b905c3a307c9a671c7f1
-  data.tar.gz: 18cb235fba334ebfaa752b92ad024117f686176b0e9107af6333e317a333c70f
+  metadata.gz: bbcdc3e208ac89fd2d55b8944ad7c0483e57f21a89941a4848beb548b56ce293
+  data.tar.gz: 10465bfe73686aae4fad33a7da0e533ed22401c68da5655654e1538a8bbb34c0
 SHA512:
-  metadata.gz: 78539255c169c26a1d6bab3968a2eed038d8391d532f97d55dabf7a7c071cddf4eee1424586021cd7b790db4abf042cf0617ac69ede670caeb9cde55a23125a4
-  data.tar.gz: 798ea355e5ebe213735db1552e7328d05c855c45800c941d4c5400a812b6d71f169ff52a48c0b9e6bf678d2dcf83ac1c7308a172b120caf9f83a240b0025e599
+  metadata.gz: 1ed8f4d6fe19c384bbb8add11443cc78b6f23cf4adc1808bdd0a1b6328a2dbeac22d4e0fa8fc6257dde505646d1c3613ed90711bbd36321cbb74231cf621958d
+  data.tar.gz: e139454fc996ad112d70332e39b002ba164d2172100f6b61f2494f090a0a3afe16c0e5e51998ab8f8cb8e839c6b0cb1104d152f821ae65d55bec4c83ec9c990a

data/README.md

@@ -36,6 +36,9 @@
     - [Union As](#union-as)
     - [Union Order](#union-order)
     - [Union Reorder](#union-reorder)
+  - [Window Functions](#window-functions)
+    - [Define Window](#define-window)
+    - [Select Window](#select-window)
 
 ## Description and History
 
@@ -49,11 +52,12 @@ Active Record Extended is essentially providing users with the other half of Pos
 ## Compatibility
 
 This package is designed align and work with any officially supported Ruby and Rails versions.
- - Minimum Ruby Version: 2.3.x **(EOL warning!)**
- - Minimum Rails Version: 5.0.x **(EOL warning!)**
- - Latest Ruby supported: 2.6.x
- - Latest Rails supported: 6.0.x
- - Postgres: 9.6-current(11) (probably works with most older versions to a certain point)
+ - Minimum Ruby Version: 2.4.x **(EOL warning!)**
+ - Minimum Rails Version: 5.1.x **(EOL warning!)**
+ - Minimum Postgres Version: 9.6.x **(EOL warning!)**
+ - Latest Ruby supported: 2.7.x
+ - Latest Rails supported: 6.1.x
+ - Postgres: 9.6-current(13) (probably works with most older versions to a certain point)
 
 ## Installation
 
@@ -427,7 +431,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
     product_query  = 
     Product.select(:id)
             .joins(:items)
-            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_as_array: true) do |item_scope|
+            .select_row_to_json(item_query, key: :outer_items, as: :items, cast_with: :array) do |item_scope|
               item_scope.where("outer_items.product_id = products.id")
                 # Results to: 
                 #  SELECT ..., ARRAY(SELECT ROW_TO_JSON("outer_items")   
@@ -437,7 +441,7 @@ While quite the mouthful of an explanation. The implementation of combining unre
             end
                    
     # Not defining a key will automatically generate a random key between a-z 
-    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_as_array: true)
+    category_query = Category.select(:name, :id).select_row_to_json(product_query, as: :products, cast_with: :array)
     Category.json_build_object(:physical_category, category_query.where(id: physical_cat.id)).results
     #=> {
     #        "physical_category" => {
@@ -787,6 +791,80 @@ SELECT "people".*
   ) ) ORDER BY personal_id DESC, id DESC) people
 ```
 
+#### Window Functions
+[Postgres Window Functions](https://www.postgresql.org/docs/current/tutorial-window.html)
+
+Let's address the elephant in the room. Arel has had, for a long time now, window function capabilities; 
+However they've never seen the lime light in ActiveRecord's query logic. 
+The following brings the dormant Arel methods up to the ActiveRecord Querying level.
+
+#### Define Window
+
+To set up a window function, we first must establish the window and we do this by using the `.define_window/1` method.
+This method also requires you to call chain `.partition_by/2`
+
+`.define_window/1` - Establishes the name of the window you'll reference later on in [.select_window](#select-window) 
+   - Aliased name of window
+    
+`.partition_by/2`  - Establishes the windows operations a [pre-defined window function](https://www.postgresql.org/docs/current/functions-window.html) will leverage.
+   - column name being partitioned against
+   - (**optional**) `order_by`: Processes how the window should be ordered
+
+```ruby
+User
+.define_window(:number_window).partition_by(:number, order_by: { id: :desc })
+.define_window(:name_window).partition_by(:name, order_by: :id)
+.define_window(:no_order_name).partition_by(:name)
+```
+
+Query Output
+```sql
+SELECT *
+FROM users
+WINDOW number_window AS (PARTITION BY number ORDER BY id DESC),
+       name_window   AS (PARTITION BY name ORDER BY id),
+       no_order_name AS (PARTITION BY name)
+```
+
+#### Select Window
+
+Once you've define a window, the next step to to utilize it on one of the many provided postgres window functions.
+
+`.select_window/3`
+  - [window function name](https://www.postgresql.org/docs/current/functions-window.html)
+  - (**optional**) Window function arguments (treated as a splatted array)
+  - (**optional**) `as:` : Alias name of the final result
+  - `over:` : name of [defined window](#define-window)
+
+```ruby
+User.create!(name: "Alice", number: 100) #=> id: 1
+User.create!(name: "Randy", number: 100) #=> id: 2
+User.create!(name: "Bob", number: 300)   #=> id: 3
+
+User
+.define_window(:number_window).partition_by(:number, order_by: { id: :desc })
+.select(:id, :name)
+.select_window(:row_number, over: :number_window, as: :row_id)
+.select_window(:first_value, :name, over: :number_window, as: :first_value_name)
+#=> [
+ #  { id: 1, name: "Alice", row_id: 2, first_value_name: "Randy" }
+ #  { id: 2, name: "Randy", row_id: 1, first_value_name: "Randy" }
+ #  { id: 3, name: "Bob",   row_id: 1, first_value_name: "Bob" }
+ # ]
+ # 
+
+```
+
+Query Output
+```sql
+SELECT "users"."id", 
+        "users"."name", 
+        (ROW_NUMBER() OVER number_window)      AS "row_id", 
+        (FIRST_VALUE(name) OVER number_window) AS "first_value_name"
+FROM "users" 
+WINDOW number_window AS (PARTITION BY number ORDER BY id DESC)
+```
+
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/active_record_extended/active_record.rb

@@ -1,10 +1,5 @@
 # frozen_string_literal: true
 
-# TODO: Remove this when ruby 2.3 support is dropped
-unless Hash.instance_methods(false).include?(:compact!)
-  require "active_support/all"
-end
-
 require "active_record"
 require "active_record/relation"
 require "active_record/relation/merger"
@@ -23,12 +18,8 @@ require "active_record_extended/query_methods/inet"
 require "active_record_extended/query_methods/json"
 require "active_record_extended/query_methods/select"
 
-if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR <= 1
-  if ActiveRecord::VERSION::MINOR.zero?
-    require "active_record_extended/patch/5_0/regex_match"
-    require "active_record_extended/patch/5_0/predicate_builder_decorator"
-  end
+if Gem::Requirement.new("~> 5.1.0").satisfied_by?(ActiveRecord.gem_version)
   require "active_record_extended/patch/5_1/where_clause"
-elsif ActiveRecord::VERSION::MAJOR >= 5
+else
   require "active_record_extended/patch/5_2/where_clause"
 end

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -1,27 +1,44 @@
 # frozen_string_literal: true
 
+require "active_record_extended/query_methods/window"
 require "active_record_extended/query_methods/unionize"
 require "active_record_extended/query_methods/json"
 
 module ActiveRecordExtended
   module RelationPatch
     module QueryDelegation
-      delegate :with, :foster_select, to: :all
+      delegate :with, :define_window, :select_window, :foster_select, to: :all
       delegate(*::ActiveRecordExtended::QueryMethods::Unionize::UNIONIZE_METHODS, to: :all)
       delegate(*::ActiveRecordExtended::QueryMethods::Json::JSON_QUERY_METHODS, to: :all)
     end
 
     module Merger
       def normal_values
-        super + [:with, :union]
+        super + [:union, :define_window]
+      end
+
+      def merge
+        merge_ctes!
+        super
+      end
+
+      def merge_ctes!
+        return unless other.with_values?
+
+        if other.recursive_value? && !relation.recursive_value?
+          relation.with!(:chain).recursive(other.cte)
+        else
+          relation.with!(other.cte)
+        end
       end
     end
 
     module ArelBuildPatch
       def build_arel(*aliases)
         super.tap do |arel|
-          build_unions(arel) if union_values?
-          build_with(arel)   if with_values?
+          build_windows(arel) if window_values?
+          build_unions(arel)  if union_values?
+          build_with(arel)    if with_values?
         end
       end
     end

data/lib/active_record_extended/arel.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record_extended/arel/nodes"
+require "active_record_extended/arel/sql_literal"
 require "active_record_extended/arel/aggregate_function_name"
 require "active_record_extended/arel/predications"
 require "active_record_extended/arel/visitors/postgresql_decorator"

data/lib/active_record_extended/arel/nodes.rb

@@ -5,28 +5,31 @@ require "arel/nodes/function"
 
 module Arel
   module Nodes
-    %w[
-      Overlap
-      Contains
-      ContainsHStore
-      ContainsArray
-      ContainedInArray
+    if Gem::Requirement.new("< 6.1").satisfied_by?(ActiveRecord.gem_version)
+      ["Contains", "Overlaps"].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+    end
+
+    [
+      "ContainsHStore",
+      "ContainsArray",
+      "ContainedInArray"
     ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
 
-    %w[
-      RowToJson
-      JsonBuildObject
-      JsonbBuildObject
-      ToJson
-      ToJsonb
-      Array
-      ArrayAgg
+    [
+      "RowToJson",
+      "JsonBuildObject",
+      "JsonbBuildObject",
+      "ToJson",
+      "ToJsonb",
+      "Array",
+      "ArrayAgg"
     ].each do |function_node_name|
       func_klass = Class.new(::Arel::Nodes::Function) do
         def initialize(*args)
           super
           return if @expressions.is_a?(::Array)
-          @expressions = @expressions.is_a?(::Arel::Node) ? [@expressions] : [::Arel.sql(@expressions)]
+
+          @expressions = @expressions.is_a?(::Arel::Nodes::Node) ? [@expressions] : [::Arel.sql(@expressions)]
         end
       end
 
@@ -34,12 +37,12 @@ module Arel
     end
 
     module Inet
-      %w[
-        Contains
-        ContainsEquals
-        ContainedWithin
-        ContainedWithinEquals
-        ContainsOrContainedWithin
+      [
+        "Contains",
+        "ContainsEquals",
+        "ContainedWithin",
+        "ContainedWithinEquals",
+        "ContainsOrContainedWithin"
       ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
   end

data/lib/active_record_extended/arel/predications.rb

@@ -14,9 +14,10 @@ module Arel
       Arel::Nodes::Equality.new(Nodes.build_quoted(other, self), all_tags_function)
     end
 
-    def overlap(other)
-      Nodes::Overlap.new(self, Nodes.build_quoted(other, self))
+    def overlaps(other)
+      Nodes::Overlaps.new(self, Nodes.build_quoted(other, self))
     end
+    alias overlap overlaps
 
     def contains(other)
       Nodes::Contains.new self, Nodes.build_quoted(other, self)

data/lib/active_record_extended/arel/sql_literal.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "arel/nodes/sql_literal"
+
+# CTE alias fix for Rails 6.1
+module Arel
+  module Nodes
+    module SqlLiteralDecorator
+      def name
+        self
+      end
+    end
+  end
+end
+
+Arel::Nodes::SqlLiteral.prepend(Arel::Nodes::SqlLiteralDecorator)

data/lib/active_record_extended/arel/visitors/postgresql_decorator.rb

@@ -9,7 +9,7 @@ module ActiveRecordExtended
 
       # rubocop:disable Naming/MethodName
 
-      def visit_Arel_Nodes_Overlap(object, collector)
+      def visit_Arel_Nodes_Overlaps(object, collector)
         infix_value object, collector, " && "
       end
 

data/lib/active_record_extended/query_methods/any_of.rb

@@ -61,13 +61,14 @@ module ActiveRecordExtended
       # In Rails 5.2 the arel table maintains attribute binds
       def bind_attributes(query)
         return [] unless query.respond_to?(:bound_attributes)
+
         query.bound_attributes.map(&:value)
       end
 
       # Rails 5.1 fix
       def unprepared_query(query)
-        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(\=\ \$\d+)/) do |match|
-          Regexp.last_match(2)&.gsub(/\=\ \$\d+/, "= ?") || match
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/=\ \$\d+/, "= ?") || match
         end
       end
 
@@ -78,9 +79,9 @@ module ActiveRecordExtended
       def generate_where_clause(query)
         case query
         when String, Hash
-          @scope.where(query)
+          @scope.unscoped.where(query)
         when Array
-          @scope.where(*query)
+          @scope.unscoped.where(*query)
         else
           query
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -30,7 +30,7 @@ module ActiveRecordExtended
       end
 
       def sort_order_sql(dir)
-        %w[asc desc].include?(dir.to_s) ? dir.to_s : "asc"
+        ["asc", "desc"].include?(dir.to_s) ? dir.to_s : "asc"
       end
 
       def xor_field_options(options)
@@ -52,6 +52,7 @@ module ActiveRecordExtended
       def xor_field_options_for_associations(associations)
         associations.each_with_object({}) do |association_name, options|
           reflection = reflect_on_association(association_name)
+          reflection = reflection.through_reflection if reflection.through_reflection?
           options[reflection.table_name] = reflection.foreign_key
         end
       end

data/lib/active_record_extended/query_methods/inet.rb

@@ -74,8 +74,12 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.0.255/32'"
       #
       def inet_contains_or_is_contained_within(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsOrContainedWithin,
-                               "inet_contains_or_is_contained_within")
+        substitute_comparisons(
+          opts,
+          rest,
+          Arel::Nodes::Inet::ContainsOrContainedWithin,
+          "inet_contains_or_is_contained_within"
+        )
       end
     end
   end

data/lib/active_record_extended/query_methods/json.rb

@@ -8,7 +8,7 @@ module ActiveRecordExtended
         :json_build_object,
         :jsonb_build_object,
         :json_build_literal,
-        :jsonb_build_literal,
+        :jsonb_build_literal
       ].freeze
 
       class JsonChain
@@ -51,7 +51,7 @@ module ActiveRecordExtended
         private
 
         def build_json_literal(arel_klass, values:, col_alias: DEFAULT_ALIAS)
-          json_values    = flatten_to_sql(values.to_a, &method(:literal_key))
+          json_values    = flatten_to_sql(values.to_a) { |value| literal_key(value) }
           col_alias      = double_quote(col_alias)
           json_build_obj = arel_klass.new(json_values)
           @scope.select(nested_alias_escape(json_build_obj, col_alias))
@@ -77,7 +77,7 @@ module ActiveRecordExtended
           row_to_json = ::Arel::Nodes::ToJsonb.new(row_to_json) if options.dig(:cast_with, :to_jsonb)
 
           dummy_table = from_clause_constructor(from, key).select(row_to_json)
-          dummy_table = dummy_table.instance_eval(&block) if block_given?
+          dummy_table = dummy_table.instance_eval(&block) if block
           return dummy_table if options[:col_alias].blank?
 
           query = wrap_row_to_json(dummy_table, options)
@@ -98,7 +98,6 @@ module ActiveRecordExtended
           end
         end
 
-        # TODO: [V2 release] Drop support for option :cast_as_array in favor of a more versatile :cast_with option
         def json_object_options(args, except: [], only: []) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
           options   = {}
           lean_opts = lambda do |key, &block|
@@ -113,12 +112,12 @@ module ActiveRecordExtended
             next if arg.nil?
 
             if arg.is_a?(Hash)
-              lean_opts.call(:key)       { arg.delete(:key) || key_generator }
-              lean_opts.call(:value)     { arg.delete(:value).presence }
-              lean_opts.call(:col_alias) { arg.delete(:as) }
-              lean_opts.call(:order_by)  { order_by_expression(arg.delete(:order_by)) }
-              lean_opts.call(:from)      { arg.delete(:from).tap(&method(:pipe_cte_with!)) }
-              lean_opts.call(:cast_with) { casting_options(arg.delete(:cast_with) || arg.delete(:cast_as_array)) }
+              lean_opts.call(:key)       { arg.fetch(:key, key_generator) }
+              lean_opts.call(:value)     { arg[:value].presence }
+              lean_opts.call(:col_alias) { arg[:as] }
+              lean_opts.call(:order_by)  { order_by_expression(arg[:order_by]) }
+              lean_opts.call(:from)      { arg[:from].tap { |from_clause| pipe_cte_with!(from_clause) } }
+              lean_opts.call(:cast_with) { casting_options(arg[:cast_with]) }
             end
 
             unless except.include?(:values)
@@ -155,9 +154,6 @@ module ActiveRecordExtended
       #   - key: [Symbol or String] (default=[random letter]) What the row clause will be set as.
       #         - This is useful if you would like to add additional mid-level clauses (see mid-level scope example)
       #
-      #   - cast_as_array [boolean] (default=false): Determines if the query should be nested inside an Array() function
-      #     * Will be deprecated in V2.0 in favor of `cast_with` argument
-      #
       #   - cast_with [Symbol or Array of symbols]: Actions to transform your query
       #     * :to_jsonb
       #     * :array
@@ -172,13 +168,13 @@ module ActiveRecordExtended
       #
       # Examples:
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Adding mid-level scopes:
       #
       #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #   User.select_row_to_json(subquery, key: :group, cast_with: :array) do |scope|
       #     scope.where(group: { name: "Nerd Core" })
       #   end
       #    #=>  ```sql
@@ -252,7 +248,8 @@ module ActiveRecordExtended
       def select_row_to_json(from = nil, **options, &block)
         from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
         options.compact!
-        raise ArgumentError, "Required to provide a non-nilled from clause" unless options.key?(:from)
+        raise ArgumentError.new("Required to provide a non-nilled from clause") unless options.key?(:from)
+
         JsonChain.new(spawn).row_to_json!(**options, &block)
       end
 
@@ -273,7 +270,7 @@ module ActiveRecordExtended
       #   - Generic example:
       #
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Setting a custom value: