active_record_extended 1.2.0 → 2.0.3

data/lib/active_record_extended/query_methods/select.rb

@@ -52,12 +52,12 @@ module ActiveRecordExtended
         #  #=> SELECT (ARRAY_AGG(DISTINCT members.price)) AS past_purchases, ...
         def process_hash!(hash_of_options, alias_name)
           enforced_options = {
-            cast_with: hash_of_options.delete(:cast_with),
-            order_by:  hash_of_options.delete(:order_by),
-            distinct:  !(!hash_of_options.delete(:distinct)),
+            cast_with: hash_of_options[:cast_with],
+            order_by:  hash_of_options[:order_by],
+            distinct:  !(!hash_of_options[:distinct])
           }
-          query_statement = hash_to_dot_notation(hash_of_options.delete(:__select_statement) || hash_of_options.first)
-          select!(query_statement, alias_name, enforced_options)
+          query_statement = hash_to_dot_notation(hash_of_options[:__select_statement] || hash_of_options.first)
+          select!(query_statement, alias_name, **enforced_options)
         end
 
         # Turn a hash chain into a query statement:
@@ -65,7 +65,7 @@ module ActiveRecordExtended
         def hash_to_dot_notation(column)
           case column
           when Hash, Array
-            column.to_a.flat_map(&method(:hash_to_dot_notation)).join(".")
+            column.to_a.flat_map { |col| hash_to_dot_notation(col) }.join(".")
           when String, Symbol
             /^([[:alpha:]]+)$/.match?(column.to_s) ? double_quote(column) : column
           else
@@ -76,7 +76,7 @@ module ActiveRecordExtended
         # Add's select statement values to the current relation, select statement lists
         def select!(query, alias_name = nil, **options)
           pipe_cte_with!(query)
-          @scope._select!(to_casted_query(query, alias_name, options))
+          @scope._select!(to_casted_query(query, alias_name, **options))
         end
 
         # Wraps the query with the requested query method
@@ -84,15 +84,15 @@ module ActiveRecordExtended
         #   to_casted_query("memberships.cost", :total_revenue, :sum)
         #    #=> SELECT (SUM(memberships.cost)) AS total_revenue
         def to_casted_query(query, alias_name, **options)
-          cast_with  = options.delete(:cast_with).to_s.downcase
-          order_expr = order_by_expression(options.delete(:order_by))
-          distinct   = cast_with.chomp!("_distinct") || options.delete(:distinct) # account for [:agg_name:]_distinct
+          cast_with  = options[:cast_with].to_s.downcase
+          order_expr = order_by_expression(options[:order_by])
+          distinct   = cast_with.chomp!("_distinct") || options[:distinct] # account for [:agg_name:]_distinct
 
           case cast_with
           when "array", "true"
             wrap_with_array(query, alias_name)
           when AGGREGATE_ONE_LINERS
-            expr         = to_sql_array(query, &method(:group_when_needed))
+            expr         = to_sql_array(query) { |value| group_when_needed(value) }
             casted_query = ::Arel::Nodes::AggregateFunctionName.new(cast_with, expr, distinct).order_by(order_expr)
             nested_alias_escape(casted_query, alias_name)
           else
@@ -102,7 +102,8 @@ module ActiveRecordExtended
       end
 
       def foster_select(*args)
-        raise ArgumentError, "Call `.forster_select' with at least one field" if args.empty?
+        raise ArgumentError.new("Call `.forster_select' with at least one field") if args.empty?
+
         spawn._foster_select!(*args)
       end
 

data/lib/active_record_extended/query_methods/unionize.rb

@@ -59,7 +59,7 @@ module ActiveRecordExtended
         protected
 
         def append_union_order!(union_type, args)
-          args.each(&method(:pipe_cte_with!))
+          args.each { |arg| pipe_cte_with!(arg) }
           flatten_scopes       = flatten_to_sql(args)
           @scope.union_values += flatten_scopes
           calculate_union_operation!(union_type, flatten_scopes.size)
@@ -81,7 +81,7 @@ module ActiveRecordExtended
           union_values:          [],
           union_operations:      [],
           union_ordering_values: [],
-          unionized_name:        nil,
+          unionized_name:        nil
         }
       end
 
@@ -89,10 +89,11 @@ module ActiveRecordExtended
         union_values:          Array,
         union_operations:      Array,
         union_ordering_values: Array,
-        unionized_name:        lambda { |klass| klass.arel_table.name },
+        unionized_name:        lambda { |klass| klass.arel_table.name }
       }.each_pair do |method_name, default|
         define_method(method_name) do
           return unionize_storage[method_name] if send("#{method_name}?")
+
           (default.is_a?(Proc) ? default.call(@klass) : default.new)
         end
 
@@ -106,19 +107,21 @@ module ActiveRecordExtended
       end
 
       def union(opts = :chain, *args)
-        return UnionChain.new(spawn) if opts == :chain
+        return UnionChain.new(spawn) if :chain == opts
+
         opts.nil? ? self : spawn.union!(opts, *args, chain_method: __callee__)
       end
 
       (UNIONIZE_METHODS + UNION_RELATION_METHODS).each do |union_method|
         next if union_method == :union
+
         alias_method union_method, :union
       end
 
       def union!(opts = :chain, *args, chain_method: :union)
         union_chain    = UnionChain.new(self)
         chain_method ||= :union
-        return union_chain if opts == :chain
+        return union_chain if :chain == opts
 
         union_chain.public_send(chain_method, *([opts] + args))
       end
@@ -126,11 +129,13 @@ module ActiveRecordExtended
       # Will construct *Just* the union SQL statement that was been built thus far
       def to_union_sql
         return unless union_values?
+
         apply_union_ordering(build_union_nodes!(false)).to_sql
       end
 
       def to_nice_union_sql(color = true)
         return to_union_sql unless defined?(::Niceql)
+
         ::Niceql::Prettifier.prettify_sql(to_union_sql, color)
       end
 
@@ -172,7 +177,7 @@ module ActiveRecordExtended
 
       def build_union_nodes!(raise_error = true)
         unionize_error_or_warn!(raise_error)
-        union_values.each_with_index.inject(nil) do |union_node, (relation_node, index)|
+        union_values.each_with_index.reduce(nil) do |union_node, (relation_node, index)|
           next resolve_relation_node(relation_node) if union_node.nil?
 
           operation = union_operations.fetch(index - 1, :union)
@@ -215,6 +220,7 @@ module ActiveRecordExtended
       #
       def apply_union_ordering(union_nodes)
         return union_nodes unless union_ordering_values?
+
         UnionChain.new(self).inline_order_by(union_nodes, union_ordering_values)
       end
 
@@ -222,7 +228,7 @@ module ActiveRecordExtended
 
       def unionize_error_or_warn!(raise_error = true)
         if raise_error && union_values.size <= 1
-          raise ArgumentError, "You are required to provide 2 or more unions to join!"
+          raise ArgumentError.new("You are required to provide 2 or more unions to join!")
         elsif !raise_error && union_values.size <= 1
           warn("Warning: You are required to provide 2 or more unions to join.")
         end

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -5,9 +5,10 @@ module ActiveRecordExtended
     # 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 overlap(opts, *rest)
-      substitute_comparisons(opts, rest, Arel::Nodes::Overlap, "overlap")
+    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)
@@ -54,10 +55,10 @@ module ActiveRecordExtended
           elsif column.try(:array)
             Arel::Nodes::ContainsArray.new(arel.left, arel.right)
           else
-            raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+            raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
           end
         else
-          raise ArgumentError, "Invalid argument for .where.contains(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.contains(), got #{arel.class}")
         end
       end
     end
@@ -88,7 +89,7 @@ module ActiveRecordExtended
         when Arel::Nodes::Equality
           Arel::Nodes::Equality.new(arel.right, Arel::Nodes::NamedFunction.new(function_name, [arel.left]))
         else
-          raise ArgumentError, "Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{function_name.downcase}(), got #{arel.class}")
         end
       end
     end
@@ -99,10 +100,18 @@ module ActiveRecordExtended
         when Arel::Nodes::In, Arel::Nodes::Equality
           arel_node_class.new(arel.left, arel.right)
         else
-          raise ArgumentError, "Invalid argument for .where.#{method}(), got #{arel.class}"
+          raise ArgumentError.new("Invalid argument for .where.#{method}(), got #{arel.class}")
         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)
+      end
+    end
   end
 end
 
@@ -112,9 +121,9 @@ module ActiveRecord
       prepend ActiveRecordExtended::WhereChain
 
       def build_where_chain(opts, rest, &block)
-        where_clause = @scope.send(:where_clause_factory).build(opts, rest)
+        where_clause = build_where_clause_for(@scope, opts, rest)
         @scope.tap do |scope|
-          scope.references!(PredicateBuilder.references(opts)) if opts.is_a?(Hash)
+          scope.references!(PredicateBuilder.references(opts.stringify_keys)) if opts.is_a?(Hash)
           scope.where_clause += where_clause.modified_predicates(&block)
         end
       end

data/lib/active_record_extended/query_methods/window.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Window
+      class DefineWindowChain
+        include ::ActiveRecordExtended::Utilities::Support
+        include ::ActiveRecordExtended::Utilities::OrderBy
+
+        def initialize(scope, window_name)
+          @scope        = scope
+          @window_name  = window_name
+        end
+
+        def partition_by(*partitions, order_by: nil)
+          @scope.window_values! << {
+            window_name:  to_arel_sql(@window_name),
+            partition_by: flatten_to_sql(partitions),
+            order_by:     order_by_expression(order_by)
+          }
+
+          @scope
+        end
+      end
+
+      class WindowSelectBuilder
+        include ::ActiveRecordExtended::Utilities::Support
+
+        def initialize(window_function, args, window_name)
+          @window_function = window_function
+          @win_args        = to_sql_array(args)
+          @over            = to_arel_sql(window_name)
+        end
+
+        def build_select(alias_name = nil)
+          window_arel = generate_named_function(@window_function, *@win_args).over(@over)
+
+          if alias_name.nil?
+            window_arel
+          else
+            nested_alias_escape(window_arel, alias_name)
+          end
+        end
+      end
+
+      def window_values
+        @values.fetch(:window, [])
+      end
+
+      def window_values!
+        @values[:window] ||= []
+      end
+
+      def window_values?
+        !window_values.empty?
+      end
+
+      def window_values=(*values)
+        @values[:window] = values.flatten(1)
+      end
+
+      def define_window(name)
+        spawn.define_window!(name)
+      end
+
+      def define_window!(name)
+        DefineWindowChain.new(self, name)
+      end
+
+      def select_window(window_function, *args, over:, as: nil)
+        spawn.select_window!(window_function, args, over: over, as: as)
+      end
+
+      def select_window!(window_function, *args, over:, as: nil)
+        args.flatten!
+        args.compact!
+
+        select_statement = WindowSelectBuilder.new(window_function, args, over).build_select(as)
+        _select!(select_statement)
+      end
+
+      def build_windows(arel)
+        window_values.each do |window_value|
+          window = arel.window(window_value[:window_name])
+          window = window.partition(window_value[:partition_by]) if window_value[:partition_by].present?
+          window.order(window_value[:order_by])                  if window_value[:order_by]
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Window)

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -3,78 +3,145 @@
 module ActiveRecordExtended
   module QueryMethods
     module WithCTE
-      class WithChain
+      class WithCTE
+        include ::ActiveRecordExtended::Utilities::Support
+        include Enumerable
+        extend  Forwardable
+
+        def_delegators :@with_values, :empty?, :blank?, :present?
+        attr_reader :with_values, :with_keys
+
+        # @param [ActiveRecord::Relation] scope
         def initialize(scope)
           @scope = scope
+          reset!
+        end
+
+        # @return [Enumerable] Returns the order for which CTE's were imported as.
+        def each
+          return to_enum(:each) unless block_given?
+
+          with_keys.each do |key|
+            yield(key, with_values[key])
+          end
+        end
+        alias each_pair each
+
+        # @param [Hash, WithCTE] value
+        def with_values=(value)
+          reset!
+          pipe_cte_with!(value)
         end
 
-        def recursive(*args)
+        # @param [Hash, WithCTE] value
+        def pipe_cte_with!(value)
+          return if value.nil? || value.empty?
+
+          value.each_pair do |name, expression|
+            sym_name = name.to_sym
+            next if with_values.key?(sym_name)
+
+            # 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?
+              pipe_cte_with!(expression.cte)
+              expression.cte.reset!
+            end
+
+            @with_keys            |= [sym_name]
+            @with_values[sym_name] = expression
+          end
+
+          value.reset! if value.is_a?(WithCTE)
+        end
+
+        def reset!
+          @with_keys   = []
+          @with_values = {}
+        end
+      end
+
+      class WithChain
+        # @param [ActiveRecord::Relation] scope
+        def initialize(scope)
+          @scope       = scope
+          @scope.cte ||= WithCTE.new(scope)
+        end
+
+        # @param [Hash, WithCTE] args
+        def recursive(args)
           @scope.tap do |scope|
-            scope.with_values    += args
             scope.recursive_value = true
+            scope.cte.pipe_cte_with!(args)
           end
         end
       end
 
-      def with_values
-        @values[:with] || []
+      # @return [WithCTE]
+      def cte
+        @values[:cte]
+      end
+
+      # @param [WithCTE] cte
+      def cte=(cte)
+        raise TypeError.new("Must be a WithCTE class type") unless cte.is_a?(WithCTE)
+
+        @values[:cte] = cte
       end
 
+      # @return [Boolean]
       def with_values?
-        !(@values[:with].nil? || @values[:with].empty?)
+        !(cte.nil? || cte.empty?)
       end
 
+      # @param [Hash, WithCTE] values
       def with_values=(values)
-        @values[:with] = values
+        cte.with_values = values
       end
 
+      # @param [Boolean] value
       def recursive_value=(value)
         raise ImmutableRelation if @loaded
+
         @values[:recursive] = value
       end
 
-      def recursive_value
-        @values[:recursive]
+      # @return [Boolean]
+      def recursive_value?
+        !(!@values[:recursive])
       end
-      alias recursive_value? recursive_value
 
+      # @param [Hash, WithCTE] opts
       def with(opts = :chain, *rest)
-        return WithChain.new(spawn) if opts == :chain
+        return WithChain.new(spawn) if :chain == opts
+
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
-      def with!(opts = :chain, *rest)
-        return WithChain.new(self) if opts == :chain
-        self.with_values += [opts] + rest
-        self
-      end
+      # @param [Hash, WithCTE] opts
+      def with!(opts = :chain, *_rest)
+        return WithChain.new(self) if :chain == opts
 
-      def build_with_hashed_value(with_value)
-        with_value.map do |name, expression|
-          select =
-            case expression
-            when String
-              Arel.sql("(#{expression})")
-            when ActiveRecord::Relation, Arel::SelectManager
-              Arel.sql("(#{expression.to_sql})")
-            end
-          next if select.nil?
-          Arel::Nodes::As.new(Arel.sql(PG::Connection.quote_ident(name.to_s)), select)
+        tap do |scope|
+          scope.cte ||= WithCTE.new(self)
+          scope.cte.pipe_cte_with!(opts)
         end
       end
 
       def build_with(arel)
-        with_statements = with_values.flat_map do |with_value|
-          case with_value
-          when String, Arel::Nodes::As
-            with_value
-          when Hash
-            build_with_hashed_value(with_value)
-          end
-        end.compact
+        return unless with_values?
+
+        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))
+          Arel::Nodes::As.new(cte_name, grouped_expression)
+        end
 
-        return if with_statements.empty?
-        recursive_value? ? arel.with(:recursive, with_statements) : arel.with(with_statements)
+        if recursive_value?
+          arel.with(:recursive, cte_statements)
+        else
+          arel.with(cte_statements)
+        end
       end
     end
   end