active_record_extended 1.1.0 → 2.0.0

data/lib/active_record_extended/query_methods/unionize.rb

@@ -7,7 +7,8 @@ module ActiveRecordExtended
       UNIONIZE_METHODS       = [:union, :union_all, :union_except, :union_intersect].freeze
 
       class UnionChain
-        include ::ActiveRecordExtended::Utilities
+        include ::ActiveRecordExtended::Utilities::Support
+        include ::ActiveRecordExtended::Utilities::OrderBy
 
         def initialize(scope)
           @scope = scope
@@ -58,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)
@@ -69,38 +70,6 @@ module ActiveRecordExtended
           scope_count              = 1 if scope_count <= 0 && @scope.union_values.size <= 1
           @scope.union_operations += [union_type] * scope_count
         end
-
-        # We'll need to preprocess these arguments for allowing `ActiveRecord::Relation#preprocess_order_args`,
-        # to check for sanitization issues and convert over to `Arel::Nodes::[Ascending/Descending]`.
-        # Without reflecting / prepending the parent's table name.
-
-        if ActiveRecord.gem_version < Gem::Version.new("5.1")
-          # TODO: Rails 5.0.x order logic will *always* append the parents name to the column when its an HASH obj
-          #       We should really do this stuff better. Maybe even just ignore `preprocess_order_args` altogether?
-          #       Maybe I'm just stupidly over paranoid on just the 'ORDER BY' for some odd reason.
-          def process_ordering_arguments!(ordering_args)
-            ordering_args.flatten!
-            ordering_args.compact!
-            ordering_args.map! do |arg|
-              next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-              arg.each_with_object([]) do |(field, dir), ordering_object|
-                ordering_object << to_arel_sql(field).send(dir.to_s.downcase)
-              end
-            end.flatten!
-          end
-        else
-          def process_ordering_arguments!(ordering_args)
-            ordering_args.flatten!
-            ordering_args.compact!
-            ordering_args.map! do |arg|
-              next to_arel_sql(arg) unless arg.is_a?(Hash) # ActiveRecord will reflect if an argument is a symbol
-              arg.each_with_object({}) do |(field, dir), ordering_obj|
-                # ActiveRecord will not reflect if the Hash keys are a `Arel::Nodes::SqlLiteral` klass
-                ordering_obj[to_arel_sql(field)] = dir.to_s.downcase
-              end
-            end
-          end
-        end
       end
 
       def unionize_storage
@@ -112,7 +81,7 @@ module ActiveRecordExtended
           union_values:          [],
           union_operations:      [],
           union_ordering_values: [],
-          unionized_name:        nil,
+          unionized_name:        nil
         }
       end
 
@@ -120,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
 
@@ -138,11 +108,13 @@ module ActiveRecordExtended
 
       def union(opts = :chain, *args)
         return UnionChain.new(spawn) if opts == :chain
+
         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
 
@@ -157,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
 
@@ -171,7 +145,7 @@ module ActiveRecordExtended
         return unless union_values?
 
         union_nodes      = apply_union_ordering(build_union_nodes!)
-        table_name       = Arel::Nodes::SqlLiteral.new(unionized_name)
+        table_name       = Arel.sql(unionized_name)
         table_alias      = arel.create_table_alias(arel.grouping(union_nodes), table_name)
         arel.from(table_alias)
       end
@@ -203,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)
@@ -247,17 +221,14 @@ module ActiveRecordExtended
       def apply_union_ordering(union_nodes)
         return union_nodes unless union_ordering_values?
 
-        # Sanitation check / resolver (ActiveRecord::Relation#preprocess_order_args)
-        preprocess_order_args(union_ordering_values)
-        union_ordering_values.uniq!
-        Arel::Nodes::InfixOperation.new("ORDER BY", union_nodes, union_ordering_values)
+        UnionChain.new(self).inline_order_by(union_nodes, union_ordering_values)
       end
 
       private
 
       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

@@ -54,10 +54,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 +88,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 +99,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 +120,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
+
         opts.blank? ? self : spawn.with!(opts, *rest)
       end
 
-      def with!(opts = :chain, *rest)
+      # @param [Hash, WithCTE] opts
+      def with!(opts = :chain, *_rest)
         return WithChain.new(self) if opts == :chain
-        self.with_values += [opts] + rest
-        self
-      end
 
-      def build_with_hashed_value(with_value)
-        with_value.map do |name, expression|
-          select =
-            case expression
-            when String
-              Arel::Nodes::SqlLiteral.new("(#{expression})")
-            when ActiveRecord::Relation, Arel::SelectManager
-              Arel::Nodes::SqlLiteral.new("(#{expression.to_sql})")
-            end
-          next if select.nil?
-          Arel::Nodes::As.new(Arel::Nodes::SqlLiteral.new(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