active_record_extended 1.1.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9600653726c77cad5b6e0a90c1f5a55213c95804a3b094c1595aa085127f2605
-  data.tar.gz: 0a7204abdd56e9d92c6b304d42d79b7270feb966aed55cc122e2c2ad68d91dab
+  metadata.gz: 9934d5a90324b46dc3faa7b496724ac219a2582d264db89e64e2b9be574adab6
+  data.tar.gz: c1359988f9a6b83148f36548e842a25cab68a191e7a839caef7e783b1415b346
 SHA512:
-  metadata.gz: '008286c5485c0e14d8fd113ac12c78f2079f572ad5d99bf4eee9c8c3fa16c58948c496aa79436718098a120d3481aa832a2d9509f89beb7ee7733e2d96754ae3'
-  data.tar.gz: e239092f0511f1c75f2eca0a0aed42f193d14a6f4c490dc6549c87c19c231b671d5a3316be6dcaea0641d6c633f33f93ae8618a43f7b5314d1d97ad2abda7fd3
+  metadata.gz: e7385b414ef4c8d8b0c5b29eaeb70e77ba79f07828255deef5db79e99cf33f18de7bab696501711dee1f8e056ca3bdf628cdd498b341a91b5ad5cd2c766bd61c
+  data.tar.gz: 10e8d4f65c570dba757b2cf47aaaff7f8a5538974e9c8aadb3c267e3e3fccb9508b05a8722eb5d6680937cb15827f6fa4f88d6dd219d8240c58323385fe44eb2

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
 
@@ -46,15 +49,27 @@ The only problem is that this has created a wild west of environments of sorts.
 
 Active Record Extended is essentially providing users with the other half of Postgreses querying abilities. Due to Rails/ActiveRecord/Arel being designed to be DB agnostic, there are a lot of left out features; Either by choice or the simple lack of supporting API's for other databases. However some features are not exactly PG explicit. Some are just helper methods to express an idea much more easily.
 
-
 ## 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
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'active_record_extended'
+```
+
+And then execute:
+
+    $ bundle
 
 ## Usage
 
@@ -416,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")   
@@ -426,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" => {
@@ -776,22 +791,79 @@ SELECT "people".*
   ) ) ORDER BY personal_id DESC, id DESC) people
 ```
 
+#### Window Functions
+[Postgres Window Functions](https://www.postgresql.org/docs/current/tutorial-window.html)
 
-## Installation
+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.
 
-Add this line to your application's Gemfile:
+#### 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
-gem 'active_record_extended'
+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)
 ```
 
-And then execute:
+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)
+```
 
-    $ bundle
+#### Select Window
 
-Or install it yourself as:
+Once you've define a window, the next step to to utilize it on one of the many provided postgres window functions.
 
-    $ gem install active_record_extended
+`.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
 

data/lib/active_record_extended.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
 require "active_record_extended/version"
-require "active_record_extended/utilities"
+require "active_record_extended/utilities/support"
+require "active_record_extended/utilities/order_by"
 require "active_record_extended/active_record"
 require "active_record_extended/arel"
 

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"
@@ -21,11 +16,9 @@ require "active_record_extended/query_methods/any_of"
 require "active_record_extended/query_methods/either"
 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/predicate_builder_decorator"
-  end
+if ActiveRecord::VERSION::MAJOR == 5 && ActiveRecord::VERSION::MINOR == 1
   require "active_record_extended/patch/5_1/where_clause"
 elsif ActiveRecord::VERSION::MAJOR >= 5
   require "active_record_extended/patch/5_2/where_clause"

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, 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,5 +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/aggregate_function_name.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Arel
+  module Nodes
+    class AggregateFunctionName < ::Arel::Nodes::Node
+      include Arel::Predications
+      include Arel::WindowPredications
+      attr_accessor :name, :expressions, :distinct, :alias, :orderings
+
+      def initialize(name, expr, distinct = false)
+        super()
+        @name        = name.to_s.upcase
+        @expressions = expr
+        @distinct    = distinct
+      end
+
+      def order_by(expr)
+        @orderings = expr
+        self
+      end
+
+      def as(aliaz)
+        self.alias = SqlLiteral.new(aliaz)
+        self
+      end
+
+      def hash
+        [@name, @expressions, @distinct, @alias, @orderings].hash
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          expressions == other.expressions &&
+          orderings == other.orderings &&
+          distinct == other.distinct
+      end
+      alias == eql?
+    end
+  end
+end

data/lib/active_record_extended/arel/nodes.rb

@@ -1,56 +1,47 @@
 # frozen_string_literal: true
 
 require "arel/nodes/binary"
+require "arel/nodes/function"
 
 module Arel
   module Nodes
-    class Overlap < Arel::Nodes::Binary
-    end
-
-    class Contains < Arel::Nodes::Binary
-    end
-
-    class ContainsHStore < Arel::Nodes::Binary
-    end
-
-    class ContainsArray < Arel::Nodes::Binary
-    end
-
-    class ContainedInArray < Arel::Nodes::Binary
-    end
-
-    class RowToJson < Arel::Nodes::Function
-      def initialize(*args)
-        super
-        unless @expressions.is_a?(Array)
-          @expressions = Arel.sql(@expressions) unless @expressions.is_a?(Arel::Nodes::SqlLiteral)
-          @expressions = [@expressions]
+    [
+      "Overlap",
+      "Contains",
+      "ContainsHStore",
+      "ContainsArray",
+      "ContainedInArray"
+    ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
+
+    [
+      "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::Nodes::Node) ? [@expressions] : [::Arel.sql(@expressions)]
         end
       end
-    end
 
-    class JsonBuildObject < Arel::Nodes::Function
-      def initialize(*args)
-        super
-        @expressions = Array(@expressions)
-      end
-    end
-
-    class JsonbBuildObject < JsonBuildObject
+      const_set(function_node_name, func_klass)
     end
 
     module Inet
-      class ContainsEquals < Arel::Nodes::Binary
-      end
-
-      class ContainedWithin < Arel::Nodes::Binary
-      end
-
-      class ContainedWithinEquals < Arel::Nodes::Binary
-      end
-
-      class ContainsOrContainedWithin < Arel::Nodes::Binary
-      end
+      [
+        "Contains",
+        "ContainsEquals",
+        "ContainedWithin",
+        "ContainedWithinEquals",
+        "ContainsOrContainedWithin"
+      ].each { |binary_node_name| const_set(binary_node_name, Class.new(::Arel::Nodes::Binary)) }
     end
   end
 end

data/lib/active_record_extended/arel/predications.rb

@@ -21,12 +21,15 @@ module Arel
     def contains(other)
       Nodes::Contains.new self, Nodes.build_quoted(other, self)
     end
-    alias inet_contains contains
 
     def contained_in_array(other)
       Nodes::ContainedInArray.new self, Nodes.build_quoted(other, self)
     end
 
+    def inet_contains(other)
+      Nodes::Inet::Contains.new self, Nodes.build_quoted(other, self)
+    end
+
     def inet_contains_or_is_contained_within(other)
       Nodes::Inet::ContainsOrContainedWithin.new self, Nodes.build_quoted(other, self)
     end

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

@@ -23,7 +23,7 @@ module ActiveRecordExtended
         elsif left_column.try(:array)
           visit_Arel_Nodes_ContainsArray(object, collector)
         else
-          infix_value object, collector, " >> "
+          visit_Arel_Nodes_Inet_Contains(object, collector)
         end
       end
 
@@ -59,6 +59,45 @@ module ActiveRecordExtended
         aggregate "JSONB_BUILD_OBJECT", object, collector
       end
 
+      def visit_Arel_Nodes_ToJson(object, collector)
+        aggregate "TO_JSON", object, collector
+      end
+
+      def visit_Arel_Nodes_ToJsonb(object, collector)
+        aggregate "TO_JSONB", object, collector
+      end
+
+      def visit_Arel_Nodes_Array(object, collector)
+        aggregate "ARRAY", object, collector
+      end
+
+      def visit_Arel_Nodes_ArrayAgg(object, collector)
+        aggregate "ARRAY_AGG", object, collector
+      end
+
+      def visit_Arel_Nodes_AggregateFunctionName(object, collector)
+        collector << "#{object.name}("
+        collector << "DISTINCT " if object.distinct
+        collector = inject_join(object.expressions, collector, ", ")
+
+        if object.orderings
+          collector << " ORDER BY "
+          collector = inject_join(object.orderings, collector, ", ")
+        end
+        collector << ")"
+
+        if object.alias
+          collector << " AS "
+          visit object.alias, collector
+        else
+          collector
+        end
+      end
+
+      def visit_Arel_Nodes_Inet_Contains(object, collector)
+        infix_value object, collector, " >> "
+      end
+
       def visit_Arel_Nodes_Inet_ContainedWithinEquals(object, collector)
         infix_value object, collector, " <<= "
       end