active_record_extended 1.1.0 → 1.2.0

data/lib/active_record_extended/query_methods/select.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Select
+      class SelectHelper
+        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
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def build_foster_select(*args)
+          flatten_safely(args).each do |select_arg|
+            case select_arg
+            when String, Symbol
+              select!(select_arg)
+            when Hash
+              select_arg.each_pair do |alias_name, options_or_column|
+                case options_or_column
+                when Array
+                  process_array!(options_or_column, alias_name)
+                when Hash
+                  process_hash!(options_or_column, alias_name)
+                else
+                  select!(options_or_column, alias_name)
+                end
+              end
+            end
+          end
+        end
+
+        private
+
+        # Assumes that the first element in the array is the source/target column.
+        # Example
+        # process_array_options!([:col_name], :my_alias_name)
+        #    #=> SELECT ([:col_name:]) AS "my_alias_name", ...
+        def process_array!(array_of_options, alias_name)
+          options = array_of_options.detect { |opts| opts.is_a?(Hash) }
+          query   = { __select_statement: array_of_options.first }
+          query.merge!(options) unless options.nil?
+          process_hash!(query, alias_name)
+        end
+
+        # Processes options that come in as Hash elements
+        # Examples:
+        # process_hash_options!({ memberships: :price, cast_with: :agg_array_distinct }, :past_purchases)
+        #  #=> 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)),
+          }
+          query_statement = hash_to_dot_notation(hash_of_options.delete(:__select_statement) || hash_of_options.first)
+          select!(query_statement, alias_name, enforced_options)
+        end
+
+        # Turn a hash chain into a query statement:
+        # Example: hash_to_dot_notation(table_name: :col_name) #=> "table_name.col_name"
+        def hash_to_dot_notation(column)
+          case column
+          when Hash, Array
+            column.to_a.flat_map(&method(:hash_to_dot_notation)).join(".")
+          when String, Symbol
+            /^([[:alpha:]]+)$/.match?(column.to_s) ? double_quote(column) : column
+          else
+            column
+          end
+        end
+
+        # 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))
+        end
+
+        # Wraps the query with the requested query method
+        # Example:
+        #   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
+
+          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))
+            casted_query = ::Arel::Nodes::AggregateFunctionName.new(cast_with, expr, distinct).order_by(order_expr)
+            nested_alias_escape(casted_query, alias_name)
+          else
+            alias_name.presence ? nested_alias_escape(query, alias_name) : query
+          end
+        end
+      end
+
+      def foster_select(*args)
+        raise ArgumentError, "Call `.forster_select' with at least one field" if args.empty?
+        spawn._foster_select!(*args)
+      end
+
+      def _foster_select!(*args)
+        SelectHelper.new(self).build_foster_select(*args)
+        self
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Select)

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
@@ -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
@@ -171,7 +140,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
@@ -246,11 +215,7 @@ 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

data/lib/active_record_extended/query_methods/with_cte.rb

@@ -54,12 +54,12 @@ module ActiveRecordExtended
           select =
             case expression
             when String
-              Arel::Nodes::SqlLiteral.new("(#{expression})")
+              Arel.sql("(#{expression})")
             when ActiveRecord::Relation, Arel::SelectManager
-              Arel::Nodes::SqlLiteral.new("(#{expression.to_sql})")
+              Arel.sql("(#{expression.to_sql})")
             end
           next if select.nil?
-          Arel::Nodes::As.new(Arel::Nodes::SqlLiteral.new(PG::Connection.quote_ident(name.to_s)), select)
+          Arel::Nodes::As.new(Arel.sql(PG::Connection.quote_ident(name.to_s)), select)
         end
       end
 

data/lib/active_record_extended/utilities/order_by.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "active_record"
+
+module ActiveRecordExtended
+  module Utilities
+    module OrderBy
+      def inline_order_by(arel_node, ordering_args)
+        return arel_node unless scope_preprocess_order_args(ordering_args)
+
+        Arel::Nodes::InfixOperation.new("ORDER BY", arel_node, ordering_args)
+      end
+
+      def scope_preprocess_order_args(ordering_args)
+        return false if ordering_args.blank? || !@scope.respond_to?(:preprocess_order_args, true)
+
+        # Sanitation check / resolver (ActiveRecord::Relation#preprocess_order_args)
+        @scope.send(:preprocess_order_args, ordering_args)
+        ordering_args
+      end
+
+      # Processes "ORDER BY" expressions for supported aggregate functions
+      def order_by_expression(order_by)
+        return false unless order_by && order_by.presence.present?
+
+        to_ordered_table_path(order_by)
+          .tap(&method(:process_ordering_arguments!))
+          .tap(&method(:scope_preprocess_order_args))
+      end
+
+      #
+      # Turns a hash into a dot notation path.
+      #
+      # Example:
+      # - Using pre-set directions:
+      #   [{ products: { position: :asc, id: :desc } }]
+      #     #=> [{ "products.position" => :asc, "products.id" => :desc }]
+      #
+      # - Using fallback directions:
+      #   [{products: :position}]
+      #     #=> [{"products.position" => :asc}]
+      #
+      def to_ordered_table_path(args)
+        flatten_safely(Array.wrap(args)) do |arg|
+          next arg unless arg.is_a?(Hash)
+
+          arg.each_with_object({}) do |(tbl_or_col, obj), new_hash|
+            if obj.is_a?(Hash)
+              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)
+              new_hash[tbl_or_col] = obj
+            elsif obj.nil?
+              new_hash[tbl_or_col.to_s] = :asc
+            else
+              new_hash["#{tbl_or_col}.#{obj}"] = :asc
+            end
+          end
+        end
+      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
+  end
+end

data/lib/active_record_extended/utilities/support.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module Utilities
+    module Support
+      A_TO_Z_KEYS = ("a".."z").to_a.freeze
+
+      # We need to ensure we can flatten nested ActiveRecord::Relations
+      # that might have been nested due to the (splat)*args parameters
+      #
+      # Note: calling `Array.flatten[!]/1` will actually remove all AR relations from the array.
+      #
+      def flatten_to_sql(*values)
+        flatten_safely(values) do |value|
+          value = yield value if block_given?
+          to_arel_sql(value)
+        end
+      end
+      alias to_sql_array flatten_to_sql
+
+      def flatten_safely(values, &block)
+        unless values.is_a?(Array)
+          values = yield values if block_given?
+          return [values]
+        end
+
+        values.map { |value| flatten_safely(value, &block) }.reduce(:+)
+      end
+
+      # Applies aliases to the given query
+      # Ex: `SELECT * FROM users` => `(SELECT * FROM users) AS "members"`
+      def nested_alias_escape(query, alias_name)
+        sql_query = Arel::Nodes::Grouping.new(to_arel_sql(query))
+        Arel::Nodes::As.new(sql_query, to_arel_sql(double_quote(alias_name)))
+      end
+
+      # Wraps subquery into an Aliased ARRAY
+      # Ex: `SELECT * FROM users` => (ARRAY(SELECT * FROM users)) AS "members"
+      def wrap_with_array(arel_or_rel_query, alias_name, order_by: false)
+        if order_by && arel_or_rel_query.is_a?(ActiveRecord::Relation)
+          arel_or_rel_query = arel_or_rel_query.order(order_by)
+        end
+
+        query = Arel::Nodes::Array.new(to_sql_array(arel_or_rel_query))
+        nested_alias_escape(query, alias_name)
+      end
+
+      # Wraps query into an aggregated array
+      # EX: `(ARRAY_AGG((SELECT * FROM users)) AS "members"`
+      #     `(ARRAY_AGG(DISTINCT (SELECT * FROM users)) AS "members"`
+      #     `SELECT ARRAY_AGG((id)) AS "ids" FROM users`
+      #     `SELECT ARRAY_AGG(DISTINCT (id)) AS "ids" FROM users`
+      def wrap_with_agg_array(arel_or_rel_query, alias_name, order_by: false, distinct: false)
+        distinct       = !(!distinct)
+        order_exp      = distinct ? nil : order_by # Can't order a distinct agg
+        query          = group_when_needed(arel_or_rel_query)
+        query          =
+          Arel::Nodes::AggregateFunctionName
+          .new("ARRAY_AGG", to_sql_array(query), distinct)
+          .order_by(order_exp)
+
+        nested_alias_escape(query, alias_name)
+      end
+
+      # Will attempt to digest and resolve the from clause
+      #
+      # If the from clause is a String, it will check to see if a table reference key has been assigned.
+      #   - If one cannot be detected, one will be appended.
+      #   - Rails does not allow assigning table references using the `.from/2` method, when its a string / sym type.
+      #
+      # If the from clause is an AR relation; it will duplicate the object.
+      #   - Ensures any memorizers are reset (ex: `.to_sql` sets a memorizer on the instance)
+      #   - Key's can be assigned using the `.from/2` method.
+      #
+      def from_clause_constructor(from, reference_key)
+        case from
+        when /\s.?#{reference_key}.?$/ # The from clause is a string and has the tbl reference key
+          @scope.unscoped.from(from)
+        when String, Symbol
+          @scope.unscoped.from("#{from} #{reference_key}")
+        else
+          replicate_klass = from.respond_to?(:unscoped) ? from.unscoped : @scope.unscoped
+          replicate_klass.from(from.dup, reference_key)
+        end
+      end
+
+      # Will carry defined CTE tables from the nested sub-query and gradually pushes it up to the parents query stack
+      # I.E: It pushes `WITH [:cte_name:] AS(...), ..` to the top of the query structure tree
+      #
+      # SPECIAL GOTCHA NOTE: (if duplicate keys are found) This will favor the parents query `with's` over nested ones!
+      def pipe_cte_with!(subquery)
+        return self unless subquery.try(:with_values?)
+
+        cte_ary              = flatten_safely(subquery.with_values)
+        subquery.with_values = nil # Remove nested queries with values
+
+        # Add subquery's CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+        if @scope.with_values?
+          # combine top-level and lower level queries `.with` values into 1 structure
+          with_hash = cte_ary.each_with_object(@scope.with_values.first) do |from_cte, hash|
+            hash.reverse_merge!(from_cte)
+          end
+
+          @scope.with_values = [with_hash]
+        else
+          # Top level has no with values
+          @scope.with!(*cte_ary)
+        end
+
+        self
+      end
+
+      # Ensures the given value is properly double quoted.
+      # This also ensures we don't have conflicts with reversed keywords.
+      #
+      # IE: `user` is a reserved keyword in PG. But `"user"` is allowed and works the same
+      #     when used as an column/tbl alias.
+      def double_quote(value)
+        return if value.nil?
+
+        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:]]+))/
+          value
+        else
+          PG::Connection.quote_ident(value.to_s)
+        end
+      end
+
+      # Ensures the key is properly single quoted and treated as a actual PG key reference.
+      def literal_key(key)
+        case key
+        when TrueClass  then "'t'"
+        when FalseClass then "'f'"
+        when Numeric    then key
+        else
+          key = key.to_s
+          key.start_with?("'") && key.end_with?("'") ? key : "'#{key}'"
+        end
+      end
+
+      # Converts a potential subquery into a compatible Arel SQL node.
+      #
+      # Note:
+      # We convert relations to SQL to maintain compatibility with Rails 5.[0/1].
+      # Only Rails 5.2+ maintains bound attributes in Arel, so its better to be safe then sorry.
+      # When we drop support for Rails 5.[0/1], we then can then drop the '.to_sql' conversation
+
+      def to_arel_sql(value)
+        case value
+        when Arel::Node, Arel::Nodes::SqlLiteral, nil
+          value
+        when ActiveRecord::Relation
+          Arel.sql(value.spawn.to_sql)
+        else
+          Arel.sql(value.respond_to?(:to_sql) ? value.to_sql : value.to_s)
+        end
+      end
+
+      def group_when_needed(arel_or_rel_query)
+        return arel_or_rel_query unless needs_to_be_grouped?(arel_or_rel_query)
+        Arel::Nodes::Grouping.new(to_arel_sql(arel_or_rel_query))
+      end
+
+      def needs_to_be_grouped?(query)
+        query.respond_to?(:to_sql) || (query.is_a?(String) && /^SELECT.+/i.match?(query))
+      end
+
+      def key_generator
+        A_TO_Z_KEYS.sample
+      end
+    end
+  end
+end