active_record_extended 2.0.3 → 3.2.1

data/lib/active_record_extended/query_methods/any_of.rb

@@ -5,23 +5,15 @@ module ActiveRecordExtended
     module AnyOf
       def any_of(*queries)
         queries = hash_map_queries(queries)
-        build_query(queries) do |arel_query, binds|
-          if binds.any?
-            @scope.where(unprepared_query(arel_query.to_sql), *binds)
-          else
-            @scope.where(arel_query)
-          end
+        build_query(queries) do |arel_query|
+          @scope.where(arel_query)
         end
       end
 
       def none_of(*queries)
         queries = hash_map_queries(queries)
-        build_query(queries) do |arel_query, binds|
-          if binds.any?
-            @scope.where.not(unprepared_query(arel_query.to_sql), *binds)
-          else
-            @scope.where.not(arel_query)
-          end
+        build_query(queries) do |arel_query|
+          @scope.where.not(arel_query)
         end
       end
 
@@ -29,7 +21,7 @@ module ActiveRecordExtended
 
       def hash_map_queries(queries)
         if queries.size == 1 && queries.first.is_a?(Hash)
-          queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
+          queries.first.each_pair.map { |attr, predicate| { attr => predicate } }
         else
           queries
         end
@@ -37,7 +29,7 @@ module ActiveRecordExtended
 
       def build_query(queries)
         query_map = construct_query_mappings(queries)
-        query     = yield(query_map[:arel_query], query_map[:binds])
+        query     = yield(query_map[:arel_query])
         query
           .joins(query_map[:joins].to_a)
           .includes(query_map[:includes].to_a)
@@ -51,29 +43,13 @@ module ActiveRecordExtended
             query_map[:joins]      << translate_reference(query.joins_values)      if query.joins_values.any?
             query_map[:includes]   << translate_reference(query.includes_values)   if query.includes_values.any?
             query_map[:references] << translate_reference(query.references_values) if query.references_values.any?
-            query_map[:binds] += bind_attributes(query)
             query.arel.constraints.reduce(:and)
           end.reduce(:or)
         end
       end
 
-      # Rails 5.1 fix
-      # 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
-        end
-      end
-
       def translate_reference(reference)
-        reference.map { |ref| ref.try(:to_sql) || ref }.compact
+        reference.filter_map { |ref| ref.try(:to_sql) || ref }
       end
 
       def generate_where_clause(query)

data/lib/active_record_extended/query_methods/either.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ar_outer_joins"
-
 module ActiveRecordExtended
   module QueryMethods
     module Either
@@ -12,21 +10,21 @@ module ActiveRecordExtended
         associations        = [initial_association, fallback_association]
         association_options = xor_field_options_for_associations(associations)
         condition__query    = xor_field_sql(association_options) + "= #{table_name}.#{primary_key}"
-        outer_joins(associations).where(Arel.sql(condition__query))
+        left_outer_joins(associations).where(Arel.sql(condition__query))
       end
       alias either_joins either_join
 
       def either_order(direction, **associations_and_columns)
         reflected_columns = map_columns_to_tables(associations_and_columns)
         conditional_query = xor_field_sql(reflected_columns) + sort_order_sql(direction)
-        outer_joins(associations_and_columns.keys).order(Arel.sql(conditional_query))
+        left_outer_joins(associations_and_columns.keys).order(Arel.sql(conditional_query))
       end
       alias either_orders either_order
 
       private
 
       def xor_field_sql(options)
-        XOR_FIELD_SQL % Hash[xor_field_options(options)]
+        XOR_FIELD_SQL % xor_field_options(options).to_h
       end
 
       def sort_order_sql(dir)
@@ -35,7 +33,7 @@ module ActiveRecordExtended
 
       def xor_field_options(options)
         str_args = options.flatten.take(XOR_FIELD_KEYS.size).map(&:to_s)
-        Hash[XOR_FIELD_KEYS.zip(str_args)]
+        XOR_FIELD_KEYS.zip(str_args).to_h
       end
 
       def map_columns_to_tables(associations_and_columns)
@@ -60,4 +58,4 @@ module ActiveRecordExtended
   end
 end
 
-ActiveRecord::Base.extend(ActiveRecordExtended::QueryMethods::Either)
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Either)

data/lib/active_record_extended/query_methods/{select.rb → foster_select.rb}

@@ -2,10 +2,10 @@
 
 module ActiveRecordExtended
   module QueryMethods
-    module Select
+    module FosterSelect
       class SelectHelper
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         AGGREGATE_ONE_LINERS = /^(exists|sum|max|min|avg|count|jsonb?_agg|(bit|bool)_(and|or)|xmlagg|array_agg)$/.freeze
 
@@ -115,4 +115,4 @@ module ActiveRecordExtended
   end
 end
 
-ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Select)
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::FosterSelect)

data/lib/active_record_extended/query_methods/json.rb

@@ -12,8 +12,8 @@ module ActiveRecordExtended
       ].freeze
 
       class JsonChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         DEFAULT_ALIAS    = '"results"'
         TO_JSONB_OPTIONS = [:array_agg, :distinct, :to_jsonb].to_set.freeze

data/lib/active_record_extended/query_methods/unionize.rb

@@ -7,8 +7,8 @@ module ActiveRecordExtended
       UNIONIZE_METHODS       = [:union, :union_all, :union_except, :union_intersect].freeze
 
       class UnionChain
-        include ::ActiveRecordExtended::Utilities::Support
-        include ::ActiveRecordExtended::Utilities::OrderBy
+        include ActiveRecordExtended::Utilities::Support
+        include ActiveRecordExtended::Utilities::OrderBy
 
         def initialize(scope)
           @scope = scope
@@ -178,7 +178,7 @@ module ActiveRecordExtended
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
         union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
-          next resolve_relation_node(relation_node) if union_node.nil?
+          next resolve_relation_node(relation_node) if union_node.nil? # rubocop:disable Lint/UnmodifiedReduceAccumulator
 
           operation = union_operations.fetch(index - 1, :union)
           left      = union_node

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -1,115 +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
+  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 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 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 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 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 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)
-      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)
+      # 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
+
+        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 ActiveRecord::VERSION::MAJOR == 6 && ActiveRecord::VERSION::MINOR == 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
@@ -118,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]
@@ -113,18 +155,23 @@ module ActiveRecordExtended
 
       # @param [Hash, WithCTE] opts
       def with(opts = :chain, *rest)
-        return WithChain.new(spawn) if :chain == opts
+        return WithChain.new(spawn) if opts == :chain
 
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
       # @param [Hash, WithCTE] opts
-      def with!(opts = :chain, *_rest)
-        return WithChain.new(self) if :chain == opts
-
-        tap do |scope|
-          scope.cte ||= WithCTE.new(self)
-          scope.cte.pipe_cte_with!(opts)
+      def with!(opts = :chain, *rest)
+        case opts
+        when :chain
+          WithChain.new(self)
+        when :recursive
+          WithChain.new(self).recursive(*rest)
+        else
+          tap do |scope|
+            scope.cte ||= WithCTE.new(self)
+            scope.cte.pipe_cte_with!(opts)
+          end
         end
       end
 
@@ -134,6 +181,8 @@ 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 +192,18 @@ module ActiveRecordExtended
           arel.with(cte_statements)
         end
       end
+
+      private
+
+      def add_materialized_modifier(expression, cte, name)
+        if cte.materialized_key?(name)
+          Arel.sql("MATERIALIZED #{expression.to_sql}")
+        elsif cte.not_materialized_key?(name)
+          Arel.sql("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.0.3"
+  VERSION = "3.2.1"
 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