active_record_extended 1.1.0 → 2.0.0

data/lib/active_record_extended/query_methods/any_of.rb

@@ -28,7 +28,7 @@ module ActiveRecordExtended
       private
 
       def hash_map_queries(queries)
-        if queries.count == 1 && queries.first.is_a?(Hash)
+        if queries.size == 1 && queries.first.is_a?(Hash)
           queries.first.each_pair.map { |attr, predicate| Hash[attr, predicate] }
         else
           queries
@@ -38,9 +38,10 @@ module ActiveRecordExtended
       def build_query(queries)
         query_map = construct_query_mappings(queries)
         query     = yield(query_map[:arel_query], query_map[:binds])
-        query.joins(query_map[:joins].to_a)
-             .includes(query_map[:includes].to_a)
-             .references(query_map[:references].to_a)
+        query
+          .joins(query_map[:joins].to_a)
+          .includes(query_map[:includes].to_a)
+          .references(query_map[:references].to_a)
       end
 
       def construct_query_mappings(queries) # rubocop:disable Metrics/AbcSize
@@ -60,13 +61,14 @@ module ActiveRecordExtended
       # 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
+        query.gsub(/((?<!\\)'.*?(?<!\\)'|(?<!\\)".*?(?<!\\)")|(=\ \$\d+)/) do |match|
+          Regexp.last_match(2)&.gsub(/=\ \$\d+/, "= ?") || match
         end
       end
 
@@ -77,9 +79,9 @@ module ActiveRecordExtended
       def generate_where_clause(query)
         case query
         when String, Hash
-          @scope.where(query)
+          @scope.unscoped.where(query)
         when Array
-          @scope.where(*query)
+          @scope.unscoped.where(*query)
         else
           query
         end

data/lib/active_record_extended/query_methods/either.rb

@@ -30,7 +30,7 @@ module ActiveRecordExtended
       end
 
       def sort_order_sql(dir)
-        %w[asc desc].include?(dir.to_s) ? dir.to_s : "asc"
+        ["asc", "desc"].include?(dir.to_s) ? dir.to_s : "asc"
       end
 
       def xor_field_options(options)

data/lib/active_record_extended/query_methods/inet.rb

@@ -57,7 +57,7 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" >> '127.0.0.255/32'"
       #
       def inet_contains(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Contains, "inet_contains")
+        substitute_comparisons(opts, rest, Arel::Nodes::Inet::Contains, "inet_contains")
       end
 
       # This method is a combination of `inet_contains` and `inet_contained_within`
@@ -74,8 +74,12 @@ module ActiveRecordExtended
       #  #=> "SELECT \"users\".* FROM \"users\" WHERE \"users\".\"ip\" && '127.0.0.255/32'"
       #
       def inet_contains_or_is_contained_within(opts, *rest)
-        substitute_comparisons(opts, rest, Arel::Nodes::Inet::ContainsOrContainedWithin,
-                               "inet_contains_or_is_contained_within")
+        substitute_comparisons(
+          opts,
+          rest,
+          Arel::Nodes::Inet::ContainsOrContainedWithin,
+          "inet_contains_or_is_contained_within"
+        )
       end
     end
   end

data/lib/active_record_extended/query_methods/json.rb

@@ -8,46 +8,50 @@ module ActiveRecordExtended
         :json_build_object,
         :jsonb_build_object,
         :json_build_literal,
-        :jsonb_build_literal,
+        :jsonb_build_literal
       ].freeze
 
       class JsonChain
-        include ::ActiveRecordExtended::Utilities
-        DEFAULT_ALIAS = '"results"'
+        include ::ActiveRecordExtended::Utilities::Support
+        include ::ActiveRecordExtended::Utilities::OrderBy
+
+        DEFAULT_ALIAS    = '"results"'
+        TO_JSONB_OPTIONS = [:array_agg, :distinct, :to_jsonb].to_set.freeze
+        ARRAY_OPTIONS    = [:array, true].freeze
 
         def initialize(scope)
           @scope = scope
         end
 
         def row_to_json!(**args, &block)
-          options = json_object_options(args).except(:values, :value)
+          options = json_object_options(args, except: [:values, :value])
           build_row_to_json(**options, &block)
         end
 
         def json_build_object!(*args)
-          options = json_object_options(args).except!(:values)
+          options = json_object_options(args, except: [:values, :cast_with, :order_by])
           build_json_object(Arel::Nodes::JsonBuildObject, **options)
         end
 
         def jsonb_build_object!(*args)
-          options = json_object_options(args).except!(:values)
+          options = json_object_options(args, except: [:values, :cast_with, :order_by])
           build_json_object(Arel::Nodes::JsonbBuildObject, **options)
         end
 
         def json_build_literal!(*args)
-          options = json_object_options(args).slice(:values, :col_alias)
+          options = json_object_options(args, only: [:values, :col_alias])
           build_json_literal(Arel::Nodes::JsonBuildObject, **options)
         end
 
         def jsonb_build_literal!(*args)
-          options = json_object_options(args).slice(:values, :col_alias)
+          options = json_object_options(args, only: [:values, :col_alias])
           build_json_literal(Arel::Nodes::JsonbBuildObject, **options)
         end
 
         private
 
         def build_json_literal(arel_klass, values:, col_alias: DEFAULT_ALIAS)
-          json_values    = flatten_to_sql(values.to_a, &method(:literal_key))
+          json_values    = flatten_to_sql(values.to_a) { |value| literal_key(value) }
           col_alias      = double_quote(col_alias)
           json_build_obj = arel_klass.new(json_values)
           @scope.select(nested_alias_escape(json_build_obj, col_alias))
@@ -60,42 +64,82 @@ module ActiveRecordExtended
           col_value         = to_arel_sql(value.presence || tbl_alias)
           json_build_object = arel_klass.new(to_sql_array(col_key, col_value))
 
-          # TODO: Change this to #match?(..) when we drop Rails 5.0 or Ruby 2.4 support
-          unless col_value.index(/".+"/)
+          unless /".+"/.match?(col_value)
             warn("`#{col_value}`: the `value` argument should contain a double quoted key reference for safety")
           end
 
           @scope.select(nested_alias_escape(json_build_object, col_alias)).from(nested_alias_escape(from, tbl_alias))
         end
 
-        def build_row_to_json(from:, key: key_generator, col_alias: nil, cast_to_array: false)
-          row_to_json = Arel::Nodes::RowToJson.new(double_quote(key))
+        def build_row_to_json(from:, **options, &block)
+          key         = options[:key]
+          row_to_json = ::Arel::Nodes::RowToJson.new(double_quote(key))
+          row_to_json = ::Arel::Nodes::ToJsonb.new(row_to_json) if options.dig(:cast_with, :to_jsonb)
+
           dummy_table = from_clause_constructor(from, key).select(row_to_json)
-          dummy_table = yield dummy_table if block_given?
+          dummy_table = dummy_table.instance_eval(&block) if block
+          return dummy_table if options[:col_alias].blank?
+
+          query = wrap_row_to_json(dummy_table, options)
+          @scope.select(query)
+        end
 
-          if col_alias.blank?
-            dummy_table
-          elsif cast_to_array
-            @scope.select(wrap_with_array(dummy_table, col_alias))
+        def wrap_row_to_json(dummy_table, options)
+          cast_opts = options[:cast_with]
+          col_alias = options[:col_alias]
+          order_by  = options[:order_by]
+
+          if cast_opts[:array_agg] || cast_opts[:distinct]
+            wrap_with_agg_array(dummy_table, col_alias, order_by: order_by, distinct: cast_opts[:distinct])
+          elsif cast_opts[:array]
+            wrap_with_array(dummy_table, col_alias, order_by: order_by)
           else
-            @scope.select(nested_alias_escape(dummy_table, col_alias))
+            nested_alias_escape(dummy_table, col_alias)
           end
         end
 
-        def json_object_options(*args) # rubocop:disable Metrics/AbcSize
-          flatten_safely(args).each_with_object(values: []) do |arg, options|
+        def json_object_options(args, except: [], only: []) # rubocop:disable Metrics/AbcSize, Metrics/PerceivedComplexity
+          options   = {}
+          lean_opts = lambda do |key, &block|
+            if only.present?
+              options[key] ||= block.call if only.include?(key)
+            elsif !except.include?(key)
+              options[key] ||= block.call
+            end
+          end
+
+          flatten_safely(args) do |arg|
             next if arg.nil?
 
             if arg.is_a?(Hash)
-              options[:key]           ||= arg.delete(:key)
-              options[:value]         ||= arg.delete(:value).presence
-              options[:col_alias]     ||= arg.delete(:as)
-              options[:cast_to_array] ||= arg.delete(:cast_as_array)
-              options[:from]          ||= arg.delete(:from).tap(&method(:pipe_cte_with!))
+              lean_opts.call(:key)       { arg.fetch(:key, key_generator) }
+              lean_opts.call(:value)     { arg[:value].presence }
+              lean_opts.call(:col_alias) { arg[:as] }
+              lean_opts.call(:order_by)  { order_by_expression(arg[:order_by]) }
+              lean_opts.call(:from)      { arg[:from].tap { |from_clause| pipe_cte_with!(from_clause) } }
+              lean_opts.call(:cast_with) { casting_options(arg[:cast_with]) }
+            end
+
+            unless except.include?(:values)
+              options[:values] ||= []
+              options[:values] << (arg.respond_to?(:to_a) ? arg.to_a : arg)
             end
+          end
+
+          options.tap(&:compact!)
+        end
+
+        def casting_options(cast_with)
+          return {} if cast_with.blank?
 
-            options[:values] << (arg.respond_to?(:to_a) ? arg.to_a : arg)
-          end.compact
+          skip_convert = [Symbol, TrueClass, FalseClass]
+          Array(cast_with).compact.each_with_object({}) do |arg, options|
+            arg                  = arg.to_sym unless skip_convert.include?(arg.class)
+            options[:to_jsonb]  |= TO_JSONB_OPTIONS.include?(arg)
+            options[:array]     |= ARRAY_OPTIONS.include?(arg)
+            options[:array_agg] |= arg == :array_agg
+            options[:distinct]  |= arg == :distinct
+          end
         end
       end
 
@@ -110,25 +154,102 @@ module ActiveRecordExtended
       #   - key: [Symbol or String] (default=[random letter]) What the row clause will be set as.
       #         - This is useful if you would like to add additional mid-level clauses (see mid-level scope example)
       #
-      #   - cast_as_array [boolean] (default=false): Determines if the query should be nested inside an Array() function
+      #   - cast_with [Symbol or Array of symbols]: Actions to transform your query
+      #     * :to_jsonb
+      #     * :array
+      #     * :array_agg (including just :array with this option will favor :array_agg)
+      #     * :distinct  (auto applies :array_agg & :to_jsonb)
       #
-      # Example:
+      #   - order_by [Symbol or hash]: Applies an ordering operation (similar to ActiveRecord #order)
+      #     - NOTE: this option will be ignored if you need to order a DISTINCT Aggregated Array,
+      #             since postgres will thrown an error.
+      #
+      #
+      #
+      # Examples:
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Adding mid-level scopes:
       #
       #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
+      #   User.select_row_to_json(subquery, key: :group, cast_with: :array) do |scope|
       #     scope.where(group: { name: "Nerd Core" })
       #   end
+      #    #=>  ```sql
+      #       SELECT ARRAY(
+      #             SELECT ROW_TO_JSON("group")
+      #             FROM(SELECT name, category_id FROM groups) AS group
+      #             WHERE group.name = 'Nerd Core'
+      #       )
+      #    ```
+      #
+      #
+      # - Array of JSONB objects
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_with: [:array, :to_jsonb]) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end
+      #   #=>  ```sql
+      #       SELECT ARRAY(
+      #             SELECT TO_JSONB(ROW_TO_JSON("group"))
+      #             FROM(SELECT name, category_id FROM groups) AS group
+      #             WHERE group.name = 'Nerd Core'
+      #       )
+      #   ```
+      #
+      # - Distinct Aggregated Array
+      #
+      #   subquery = Group.select(:name, :category_id)
+      #   User.select_row_to_json(subquery, key: :group, cast_with: [:array_agg, :distinct]) do |scope|
+      #     scope.where(group: { name: "Nerd Core" })
+      #   end
+      #   #=>  ```sql
+      #      SELECT ARRAY_AGG(DISTINCT (
+      #            SELECT TO_JSONB(ROW_TO_JSON("group"))
+      #            FROM(SELECT name, category_id FROM groups) AS group
+      #            WHERE group.name = 'Nerd Core'
+      #      ))
+      #   ```
+      #
+      # - Ordering a Non-aggregated Array
+      #
+      #  subquery = Group.select(:name, :category_id)
+      #  User.select_row_to_json(subquery, key: :group, cast_with: :array, order_by: { group: { name: :desc } })
+      #  #=>  ```sql
+      #     SELECT ARRAY(
+      #           SELECT ROW_TO_JSON("group")
+      #           FROM(SELECT name, category_id FROM groups) AS group
+      #           ORDER BY group.name DESC
+      #     )
+      #  ```
+      #
+      # - Ordering an Aggregated Array
+      #
+      #  Subquery = Group.select(:name, :category_id)
+      #  User
+      #   .joins(:people_groups)
+      #  .select_row_to_json(
+      #     subquery,
+      #     key: :group,
+      #     cast_with: :array_agg,
+      #     order_by: { people_groups: :category_id }
+      #   )
+      #   #=>  ```sql
+      #     SELECT ARRAY_AGG((
+      #           SELECT ROW_TO_JSON("group")
+      #           FROM(SELECT name, category_id FROM groups) AS group
+      #           ORDER BY group.name DESC
+      #     ) ORDER BY people_groups.category_id ASC)
+      #   ```
       #
-
       def select_row_to_json(from = nil, **options, &block)
         from.is_a?(Hash) ? options.merge!(from) : options.reverse_merge!(from: from)
         options.compact!
-        raise ArgumentError, "Required to provide a non-nilled from clause" unless options.key?(:from)
+        raise ArgumentError.new("Required to provide a non-nilled from clause") unless options.key?(:from)
+
         JsonChain.new(spawn).row_to_json!(**options, &block)
       end
 
@@ -149,7 +270,7 @@ module ActiveRecordExtended
       #   - Generic example:
       #
       #   subquery = Group.select(:name, :category_id).where("user_id = users.id")
-      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_as_array: true)
+      #   User.select(:name, email).select_row_to_json(subquery, as: :users_groups, cast_with: :array)
       #     #=> [<#User name:.., email:.., users_groups: [{ name: .., category_id: .. }, ..]]
       #
       #  - Setting a custom value:
@@ -163,21 +284,6 @@ module ActiveRecordExtended
       #        .take
       #        .results["gang_members"] #=> "BANG!"
       #
-      #
-      # - Adding mid-level scopes
-      #
-      #   subquery = Group.select(:name, :category_id)
-      #   User.select_row_to_json(subquery, key: :group, cast_as_array: true) do |scope|
-      #     scope.where(group: { name: "Nerd Core" })
-      #   end  #=>  ```sql
-      #       SELECT ARRAY(
-      #             SELECT ROW_TO_JSON("group")
-      #             FROM(SELECT name, category_id FROM groups) AS group
-      #             WHERE group.name = 'Nerd Core'
-      #       )
-      #     ```
-      #
-
       def json_build_object(key, from, **options)
         options[:key]  = key
         options[:from] = from

data/lib/active_record_extended/query_methods/select.rb

@@ -0,0 +1,118 @@
+# 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[:cast_with],
+            order_by:  hash_of_options[:order_by],
+            distinct:  !(!hash_of_options[:distinct])
+          }
+          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:
+        # 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 { |col| hash_to_dot_notation(col) }.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[: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) { |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
+            alias_name.presence ? nested_alias_escape(query, alias_name) : query
+          end
+        end
+      end
+
+      def foster_select(*args)
+        raise ArgumentError.new("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)