active_record_extended 2.2.0 → 3.1.0

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -1,119 +1,121 @@
 # frozen_string_literal: true
 
 module ActiveRecordExtended
-  module WhereChain
-    # Finds Records that have an array column that contain any a set of values
-    # User.where.overlap(tags: [1,2])
-    #   # SELECT * FROM users WHERE tags && {1,2}
-    def overlaps(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::Overlaps, "overlap")
-    end
-    alias overlap overlaps
-
-    # Finds Records that contain an element in an array column
-    # User.where.any(tags: 3)
-    #   # SELECT user.* FROM user WHERE 3 = ANY(user.tags)
-    def any(opts, *rest)
-      equality_to_function("ANY", opts, rest)
-    end
+  module QueryMethods
+    module WhereChain
+      # Finds Records that have an array column that contain any a set of values
+      # User.where.overlap(tags: [1,2])
+      #   # SELECT * FROM users WHERE tags && {1,2}
+      def overlaps(opts, *rest)
+        substitute_comparisons(opts, rest, Arel::Nodes::Overlaps, "overlap")
+      end
+      alias overlap overlaps
 
-    # Finds Records that contain a single matchable array element
-    # User.where.all(tags: 3)
-    #   # SELECT user.* FROM user WHERE 3 = ALL(user.tags)
-    def all(opts, *rest)
-      equality_to_function("ALL", opts, rest)
-    end
+      # Finds Records that contain an element in an array column
+      # User.where.any(tags: 3)
+      #   # SELECT user.* FROM user WHERE 3 = ANY(user.tags)
+      def any(opts, *rest)
+        equality_to_function("ANY", opts, rest)
+      end
 
-    # Finds Records that contains a nested set elements
-    #
-    # Array Column Type:
-    #   User.where.contains(tags: [1, 3])
-    #   # SELECT user.* FROM user WHERE user.tags @> {1,3}
-    #
-    # HStore Column Type:
-    #   User.where.contains(data: { nickname: 'chainer' })
-    #   # SELECT user.* FROM user WHERE user.data @> 'nickname' => 'chainer'
-    #
-    # JSONB Column Type:
-    #   User.where.contains(data: { nickname: 'chainer' })
-    #   # SELECT user.* FROM user WHERE user.data @> {'nickname': 'chainer'}
-    #
-    # This can also be used along side joined tables
-    #
-    # JSONB Column Type Example:
-    #   Tag.joins(:user).where.contains(user: { data: { nickname: 'chainer' } })
-    #   # SELECT tags.* FROM tags INNER JOIN user on user.id = tags.user_id WHERE user.data @> { nickname: 'chainer' }
-    #
-    def contains(opts, *rest)
-      if ActiveRecordExtended::AR_VERSION_GTE_6_1
-        return substitute_comparisons(opts, rest, Arel::Nodes::Contains, "contains")
+      # Finds Records that contain a single matchable array element
+      # User.where.all(tags: 3)
+      #   # SELECT user.* FROM user WHERE 3 = ALL(user.tags)
+      def all(opts, *rest)
+        equality_to_function("ALL", opts, rest)
       end
 
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::In, Arel::Nodes::Equality
-          column = left_column(arel) || column_from_association(arel)
+      # Finds Records that contains a nested set elements
+      #
+      # Array Column Type:
+      #   User.where.contains(tags: [1, 3])
+      #   # SELECT user.* FROM user WHERE user.tags @> {1,3}
+      #
+      # HStore Column Type:
+      #   User.where.contains(data: { nickname: 'chainer' })
+      #   # SELECT user.* FROM user WHERE user.data @> 'nickname' => 'chainer'
+      #
+      # JSONB Column Type:
+      #   User.where.contains(data: { nickname: 'chainer' })
+      #   # SELECT user.* FROM user WHERE user.data @> {'nickname': 'chainer'}
+      #
+      # This can also be used along side joined tables
+      #
+      # JSONB Column Type Example:
+      #   Tag.joins(:user).where.contains(user: { data: { nickname: 'chainer' } })
+      #   # SELECT tags.* FROM tags INNER JOIN user on user.id = tags.user_id WHERE user.data @> { nickname: 'chainer' }
+      #
+      def contains(opts, *rest)
+        if ActiveRecordExtended::AR_VERSION_GTE_6_1
+          return substitute_comparisons(opts, rest, Arel::Nodes::Contains, "contains")
+        end
 
-          if [:hstore, :jsonb].include?(column.type)
-            Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
-          elsif column.try(:array)
-            Arel::Nodes::ContainsArray.new(arel.left, arel.right)
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            column = left_column(arel) || column_from_association(arel)
+
+            if [:hstore, :jsonb].include?(column.type)
+              Arel::Nodes::ContainsHStore.new(arel.left, arel.right)
+            elsif column.try(:array)
+              Arel::Nodes::ContainsArray.new(arel.left, arel.right)
+            else
+              raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
+            end
           else
             raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
           end
-        else
-          raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
         end
       end
-    end
 
-    private
+      private
 
-    def matchable_column?(col, arel)
-      col.name == arel.left.name.to_s || col.name == arel.left.relation.name.to_s
-    end
+      def matchable_column?(col, arel)
+        col.name == arel.left.name.to_s || col.name == arel.left.relation.name.to_s
+      end
 
-    def column_from_association(arel)
-      assoc = assoc_from_related_table(arel)
-      assoc.klass.columns.detect { |col| matchable_column?(col, arel) } if assoc
-    end
+      def column_from_association(arel)
+        assoc = assoc_from_related_table(arel)
+        assoc.klass.columns.detect { |col| matchable_column?(col, arel) } if assoc
+      end
 
-    def assoc_from_related_table(arel)
-      @scope.klass.reflect_on_association(arel.left.relation.name.to_sym) ||
-        @scope.klass.reflect_on_association(arel.left.relation.name.singularize.to_sym)
-    end
+      def assoc_from_related_table(arel)
+        @scope.klass.reflect_on_association(arel.left.relation.name.to_sym) ||
+          @scope.klass.reflect_on_association(arel.left.relation.name.singularize.to_sym)
+      end
 
-    def left_column(arel)
-      @scope.klass.columns_hash[arel.left.name] || @scope.klass.columns_hash[arel.left.relation.name]
-    end
+      def left_column(arel)
+        @scope.klass.columns_hash[arel.left.name] || @scope.klass.columns_hash[arel.left.relation.name]
+      end
 
-    def equality_to_function(function_name, opts, rest)
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::Equality
-          Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
-        else
-          raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
+      def equality_to_function(function_name, opts, rest)
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::Equality
+            Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
+          else
+            raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
+          end
         end
       end
-    end
 
-    def substitute_comparisons(opts, rest, arel_node_class, method)
-      build_where_chain(opts, rest) do |arel|
-        case arel
-        when Arel::Nodes::In, Arel::Nodes::Equality
-          arel_node_class.new(arel.left, arel.right)
-        else
-          raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
+      def substitute_comparisons(opts, rest, arel_node_class, method)
+        build_where_chain(opts, rest) do |arel|
+          case arel
+          when Arel::Nodes::In, Arel::Nodes::Equality
+            arel_node_class.new(arel.left, arel.right)
+          else
+            raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
+          end
         end
       end
-    end
 
-    def build_where_clause_for(scope, opts, rest)
-      if ActiveRecordExtended::AR_VERSION_GTE_6_1
-        scope.send(:build_where_clause, opts, rest)
-      else
-        scope.send(:where_clause_factory).build(opts, rest)
+      def build_where_clause_for(scope, opts, rest)
+        if ActiveRecordExtended::AR_VERSION_GTE_6_1
+          scope.send(:build_where_clause, opts, rest)
+        else
+          scope.send(:where_clause_factory).build(opts, rest)
+        end
       end
     end
   end
@@ -122,7 +124,7 @@ end
 module ActiveRecord
   module QueryMethods
     class WhereChain
-      prepend ActiveRecordExtended::WhereChain
+      prepend ActiveRecordExtended::QueryMethods::WhereChain
 
       def build_where_chain(opts, rest, &block)
         where_clause = build_where_clause_for(@scope, opts, rest)

data/lib/active_record_extended/query_methods/window.rb

@@ -4,8 +4,8 @@ module ActiveRecordExtended
   module QueryMethods
     module Window
       class DefineWindowChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         def initialize(scope, window_name)
           @scope        = scope
@@ -24,7 +24,7 @@ module ActiveRecordExtended
       end
 
       class WindowSelectBuilder
-        include ::ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::Support
 
         def initialize(window_function, args, window_name)
           @window_function = window_function

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -4,12 +4,12 @@ module ActiveRecordExtended
   module QueryMethods
     module WithCTE
       class WithCTE
-        include ::ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::Support
         include Enumerable
         extend  Forwardable
 
         def_delegators :@with_values, :empty?, :blank?, :present?
-        attr_reader :with_values, :with_keys
+        attr_reader :with_values, :with_keys, :materialized_keys, :not_materialized_keys
 
         # @param [ActiveRecord::Relation] scope
         def initialize(scope)
@@ -33,6 +33,16 @@ module ActiveRecordExtended
           pipe_cte_with!(value)
         end
 
+        # @return [Boolean]
+        def materialized_key?(key)
+          materialized_keys.include?(key.to_sym)
+        end
+
+        # @return [Boolean]
+        def not_materialized_key?(key)
+          not_materialized_keys.include?(key.to_sym)
+        end
+
         # @param [Hash, WithCTE] value
         def pipe_cte_with!(value)
           return if value.nil? || value.empty?
@@ -44,6 +54,10 @@ module ActiveRecordExtended
             # Ensure we follow FIFO pattern.
             # If the parent has similar CTE alias keys, we want to favor the parent's expressions over its children's.
             if expression.is_a?(ActiveRecord::Relation) && expression.with_values?
+              # Add child's materialized keys to the parent
+              @materialized_keys += expression.cte.materialized_keys
+              @not_materialized_keys += expression.cte.not_materialized_keys
+
               pipe_cte_with!(expression.cte)
               expression.cte.reset!
             end
@@ -58,6 +72,8 @@ module ActiveRecordExtended
         def reset!
           @with_keys   = []
           @with_values = {}
+          @materialized_keys = Set.new
+          @not_materialized_keys = Set.new
         end
       end
 
@@ -75,6 +91,32 @@ module ActiveRecordExtended
             scope.cte.pipe_cte_with!(args)
           end
         end
+
+        # @param [Hash, WithCTE] args
+        def materialized(args)
+          @scope.tap do |scope|
+            args.each_pair do |name, _expression|
+              sym_name = name.to_sym
+              raise ArgumentError.new("CTE already set as not_materialized") if scope.cte.not_materialized_key?(sym_name)
+
+              scope.cte.materialized_keys << sym_name
+            end
+            scope.cte.pipe_cte_with!(args)
+          end
+        end
+
+        # @param [Hash, WithCTE] args
+        def not_materialized(args)
+          @scope.tap do |scope|
+            args.each_pair do |name, _expression|
+              sym_name = name.to_sym
+              raise ArgumentError.new("CTE already set as materialized") if scope.cte.materialized_key?(sym_name)
+
+              scope.cte.not_materialized_keys << sym_name
+            end
+            scope.cte.pipe_cte_with!(args)
+          end
+        end
       end
 
       # @return [WithCTE]
@@ -134,6 +176,9 @@ module ActiveRecordExtended
         cte_statements = cte.map do |name, expression|
           grouped_expression = cte.generate_grouping(expression)
           cte_name           = cte.to_arel_sql(cte.double_quote(name.to_s))
+
+          grouped_expression = add_materialized_modifier(grouped_expression, cte, name)
+
           Arel::Nodes::As.new(cte_name, grouped_expression)
         end
 
@@ -143,6 +188,18 @@ module ActiveRecordExtended
           arel.with(cte_statements)
         end
       end
+
+      private
+
+      def add_materialized_modifier(expression, cte, name)
+        if cte.materialized_key?(name)
+          Arel::Nodes::SqlLiteral.new("MATERIALIZED #{expression.to_sql}")
+        elsif cte.not_materialized_key?(name)
+          Arel::Nodes::SqlLiteral.new("NOT MATERIALIZED #{expression.to_sql}")
+        else
+          expression
+        end
+      end
     end
   end
 end

data/lib/active_record_extended/utilities/order_by.rb

@@ -49,7 +49,7 @@ module ActiveRecordExtended
               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)
+            elsif ActiveRecord::QueryMethods::VALID_DIRECTIONS.include?(obj)
               new_hash[tbl_or_col] = obj
             elsif obj.nil?
               new_hash[tbl_or_col.to_s] = :asc

data/lib/active_record_extended/utilities/support.rb

@@ -113,7 +113,7 @@ module ActiveRecordExtended
         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:]]+))/
+        when "*", /((^".+"$)|(^[[:alpha:]]+\.[[:alnum:]]+)|\(.+\))/
           value
         else
           PG::Connection.quote_ident(value.to_s)

data/lib/active_record_extended/version.rb

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

data/lib/active_record_extended.rb

@@ -1,10 +1,61 @@
 # frozen_string_literal: true
 
 require "active_record_extended/version"
-require "active_record_extended/utilities/support"
-require "active_record_extended/utilities/order_by"
-require "active_record_extended/active_record"
-require "active_record_extended/arel"
+
+require "active_record"
+require "active_record/relation"
+require "active_record/relation/merger"
+require "active_record/relation/query_methods"
 
 module ActiveRecordExtended
+  extend ActiveSupport::Autoload
+
+  AR_VERSION_GTE_6_1 = Gem::Requirement.new(">= 6.1").satisfied_by?(ActiveRecord.gem_version)
+
+  module Utilities
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :OrderBy
+      autoload :Support
+    end
+  end
+
+  module Patch
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :ArrayHandlerPatch
+      autoload :RelationPatch
+      autoload :WhereClausePatch
+    end
+  end
+
+  module QueryMethods
+    extend ActiveSupport::Autoload
+
+    eager_autoload do
+      autoload :AnyOf
+      autoload :Either
+      autoload :FosterSelect
+      autoload :Inet
+      autoload :Json
+      autoload :Unionize
+      autoload :WhereChain
+      autoload :Window
+      autoload :WithCTE
+    end
+  end
+
+  def self.eager_load!
+    super
+    ActiveRecordExtended::Utilities.eager_load!
+    ActiveRecordExtended::Patch.eager_load!
+    ActiveRecordExtended::QueryMethods.eager_load!
+  end
+end
+
+ActiveSupport.on_load(:active_record) do
+  require "active_record_extended/arel"
+  ActiveRecordExtended.eager_load!
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record_extended
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.1.0
 platform: ruby
 authors:
 - George Protacio-Karaszi
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-07-28 00:00:00.000000000 Z
+date: 2022-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -32,20 +32,6 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: 7.1.0
-- !ruby/object:Gem::Dependency
-  name: ar_outer_joins
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.2'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -66,7 +52,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
@@ -76,7 +62,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.16'
+        version: '2.2'
     - - "<"
       - !ruby/object:Gem::Version
         version: '3.0'
@@ -86,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -147,21 +133,20 @@ extra_rdoc_files: []
 files:
 - README.md
 - lib/active_record_extended.rb
-- lib/active_record_extended/active_record.rb
-- lib/active_record_extended/active_record/relation_patch.rb
 - lib/active_record_extended/arel.rb
 - lib/active_record_extended/arel/aggregate_function_name.rb
 - lib/active_record_extended/arel/nodes.rb
 - lib/active_record_extended/arel/predications.rb
-- lib/active_record_extended/arel/sql_literal.rb
+- lib/active_record_extended/arel/sql_literal_patch.rb
 - lib/active_record_extended/arel/visitors/postgresql_decorator.rb
-- lib/active_record_extended/patch/5_2/where_clause.rb
-- lib/active_record_extended/predicate_builder/array_handler_decorator.rb
+- lib/active_record_extended/patch/array_handler_patch.rb
+- lib/active_record_extended/patch/relation_patch.rb
+- lib/active_record_extended/patch/where_clause_patch.rb
 - lib/active_record_extended/query_methods/any_of.rb
 - lib/active_record_extended/query_methods/either.rb
+- lib/active_record_extended/query_methods/foster_select.rb
 - lib/active_record_extended/query_methods/inet.rb
 - lib/active_record_extended/query_methods/json.rb
-- lib/active_record_extended/query_methods/select.rb
 - lib/active_record_extended/query_methods/unionize.rb
 - lib/active_record_extended/query_methods/where_chain.rb
 - lib/active_record_extended/query_methods/window.rb
@@ -189,7 +174,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.15
+rubygems_version: 3.3.19
 signing_key:
 specification_version: 4
 summary: Adds extended functionality to Activerecord Postgres implementation

data/lib/active_record_extended/active_record/relation_patch.rb

@@ -1,62 +0,0 @@
-# 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, :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 merge
-        merge_ctes!
-        merge_union!
-        merge_windows!
-        super
-      end
-
-      def merge_union!
-        return if other.unionize_storage.empty?
-
-        relation.union_values          += other.union_values
-        relation.union_operations      += other.union_operations
-        relation.union_ordering_values += other.union_ordering_values
-      end
-
-      def merge_windows!
-        return unless other.window_values?
-
-        relation.window_values |= other.window_values
-      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_windows(arel) if window_values?
-          build_unions(arel)  if union_values?
-          build_with(arel)    if with_values?
-        end
-      end
-    end
-  end
-end
-
-ActiveRecord::Relation.prepend(ActiveRecordExtended::RelationPatch::ArelBuildPatch)
-ActiveRecord::Relation::Merger.prepend(ActiveRecordExtended::RelationPatch::Merger)
-ActiveRecord::Querying.prepend(ActiveRecordExtended::RelationPatch::QueryDelegation)

data/lib/active_record_extended/active_record.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "active_record"
-require "active_record/relation"
-require "active_record/relation/merger"
-require "active_record/relation/query_methods"
-
-module ActiveRecordExtended
-  # TODO: Deprecate <= AR 6.0 methods & routines
-  AR_VERSION_GTE_6_1 = Gem::Requirement.new(">= 6.1").satisfied_by?(ActiveRecord.gem_version)
-end
-
-require "active_record_extended/predicate_builder/array_handler_decorator"
-
-require "active_record_extended/active_record/relation_patch"
-
-require "active_record_extended/query_methods/where_chain"
-require "active_record_extended/query_methods/with_cte"
-require "active_record_extended/query_methods/unionize"
-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"
-require "active_record_extended/patch/5_2/where_clause"

data/lib/active_record_extended/patch/5_2/where_clause.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module ActiveRecordExtended
-  module WhereClause
-    def modified_predicates(&block)
-      ::ActiveRecord::Relation::WhereClause.new(predicates.map(&block))
-    end
-  end
-end
-
-ActiveRecord::Relation::WhereClause.prepend(ActiveRecordExtended::WhereClause)