active_record_extended_telescope 2.0.1

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)

data/lib/active_record_extended/query_methods/unionize.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module Unionize
+      UNION_RELATION_METHODS = [:order_union, :reorder_union, :union_as].freeze
+      UNIONIZE_METHODS       = [:union, :union_all, :union_except, :union_intersect].freeze
+
+      class UnionChain
+        include ::ActiveRecordExtended::Utilities::Support
+        include ::ActiveRecordExtended::Utilities::OrderBy
+
+        def initialize(scope)
+          @scope = scope
+        end
+
+        def as(from_clause_name)
+          @scope.unionized_name = from_clause_name.to_s
+          @scope
+        end
+        alias union_as as
+
+        def order(*ordering_args)
+          process_ordering_arguments!(ordering_args)
+          @scope.union_ordering_values += ordering_args
+          @scope
+        end
+        alias order_union order
+
+        def reorder(*ordering_args)
+          @scope.union_ordering_values.clear
+          order(*ordering_args)
+        end
+        alias reorder_union reorder
+
+        def union(*args)
+          append_union_order!(:union, args)
+          @scope
+        end
+
+        def all(*args)
+          append_union_order!(:union_all, args)
+          @scope
+        end
+        alias union_all all
+
+        def except(*args)
+          append_union_order!(:except, args)
+          @scope
+        end
+        alias union_except except
+
+        def intersect(*args)
+          append_union_order!(:intersect, args)
+          @scope
+        end
+        alias union_intersect intersect
+
+        protected
+
+        def append_union_order!(union_type, args)
+          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)
+        end
+
+        def calculate_union_operation!(union_type, scope_count)
+          scope_count             -= 1 unless @scope.union_operations?
+          scope_count              = 1 if scope_count <= 0 && @scope.union_values.size <= 1
+          @scope.union_operations += [union_type] * scope_count
+        end
+      end
+
+      def unionize_storage
+        @values.fetch(:unionize, {})
+      end
+
+      def unionize_storage!
+        @values[:unionize] ||= {
+          union_values:          [],
+          union_operations:      [],
+          union_ordering_values: [],
+          unionized_name:        nil
+        }
+      end
+
+      {
+        union_values:          Array,
+        union_operations:      Array,
+        union_ordering_values: Array,
+        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
+
+        define_method("#{method_name}?") do
+          unionize_storage.key?(method_name) && !unionize_storage[method_name].presence.nil?
+        end
+
+        define_method("#{method_name}=") do |value|
+          unionize_storage![method_name] = value
+        end
+      end
+
+      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
+
+      def union!(opts = :chain, *args, chain_method: :union)
+        union_chain    = UnionChain.new(self)
+        chain_method ||= :union
+        return union_chain if opts == :chain
+
+        union_chain.public_send(chain_method, *([opts] + args))
+      end
+
+      # 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
+
+      protected
+
+      def build_unions(arel = @klass.arel_table)
+        return unless union_values?
+
+        union_nodes      = apply_union_ordering(build_union_nodes!)
+        table_name       = Arel.sql(unionized_name)
+        table_alias      = arel.create_table_alias(arel.grouping(union_nodes), table_name)
+        arel.from(table_alias)
+      end
+
+      # Builds a set of nested nodes that union each other's results
+      #
+      # Note: Order of chained unions *DOES* matter
+      #
+      # Example:
+      #
+      #   User.union(User.select(:id).where(id: 8))
+      #       .union(User.select(:id).where(id: 50))
+      #       .union.except(User.select(:id).where(id: 8))
+      #
+      #   #=> [<#User id: 50]]
+      #
+      #   ```sql
+      #   SELECT users.*
+      #   FROM(
+      #       (
+      #         (SELECT users.id FROM users WHERE id = 8)
+      #         UNION
+      #         (SELECT users.id FROM users WHERE id = 50)
+      #       )
+      #       EXCEPT
+      #       (SELECT users.id FROM users WHERE id = 8)
+      #    ) users;
+      #   ```
+
+      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?
+
+          operation = union_operations.fetch(index - 1, :union)
+          left      = union_node
+          right     = resolve_relation_node(relation_node)
+
+          case operation
+          when :union_all
+            Arel::Nodes::UnionAll.new(left, right)
+          when :except
+            Arel::Nodes::Except.new(left, right)
+          when :intersect
+            Arel::Nodes::Intersect.new(left, right)
+          else
+            Arel::Nodes::Union.new(left, right)
+          end
+        end
+      end
+
+      # Apply's the allowed ORDER BY to the end of the final union statement
+      #
+      # Note: This will only apply at the very end of the union statements. Not nested ones.
+      #       (I guess you could double nest a union and apply it, but that would be dumb)
+      #
+      # Example:
+      #   User.union(User.select(:id).where(id: 8))
+      #       .union(User.select(:id).where(id: 50))
+      #       .union.order(id: :desc)
+      #  #=> [<#User id: 50>, <#User id: 8>]
+      #
+      #   ```sql
+      #   SELECT users.*
+      #   FROM(
+      #       (SELECT users.id FROM users WHERE id = 8)
+      #       UNION
+      #       (SELECT users.id FROM users WHERE id = 50)
+      #       ORDER BY id DESC
+      #    ) users;
+      #   ```
+      #
+      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
+
+      private
+
+      def unionize_error_or_warn!(raise_error = true)
+        if raise_error && union_values.size <= 1
+          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
+      end
+
+      def resolve_relation_node(relation_node)
+        case relation_node
+        when String
+          Arel::Nodes::Grouping.new(Arel.sql(relation_node))
+        else
+          relation_node.arel
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::Unionize)

data/lib/active_record_extended/query_methods/where_chain.rb

@@ -0,0 +1,132 @@
+# 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
+
+    # 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 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)
+          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
+
+    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 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 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
+
+    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
+
+    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
+
+module ActiveRecord
+  module QueryMethods
+    class WhereChain
+      prepend ActiveRecordExtended::WhereChain
+
+      def build_where_chain(opts, rest, &block)
+        where_clause = build_where_clause_for(@scope, opts, rest)
+        @scope.tap do |scope|
+          scope.references!(PredicateBuilder.references(opts.stringify_keys)) if opts.is_a?(Hash)
+          scope.where_clause += where_clause.modified_predicates(&block)
+        end
+      end
+    end
+  end
+end