active_record_extended_telescope 2.0.1

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

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ActiveRecordExtended
+  module QueryMethods
+    module WithCTE
+      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
+
+        # @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.recursive_value = true
+            scope.cte.pipe_cte_with!(args)
+          end
+        end
+      end
+
+      # @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?
+        !(cte.nil? || cte.empty?)
+      end
+
+      # @param [Hash, WithCTE] values
+      def with_values=(values)
+        cte.with_values = values
+      end
+
+      # @param [Boolean] value
+      def recursive_value=(value)
+        raise ImmutableRelation if @loaded
+
+        @values[:recursive] = value
+      end
+
+      # @return [Boolean]
+      def recursive_value?
+        !(!@values[:recursive])
+      end
+
+      # @param [Hash, WithCTE] opts
+      def with(opts = :chain, *rest)
+        return WithChain.new(spawn) if opts == :chain
+
+        opts.blank? ? self : spawn.with!(opts, *rest)
+      end
+
+      # @param [Hash, WithCTE] opts
+      def with!(opts = :chain, *_rest)
+        return WithChain.new(self) if opts == :chain
+
+        tap do |scope|
+          scope.cte ||= WithCTE.new(self)
+          scope.cte.pipe_cte_with!(opts)
+        end
+      end
+
+      def build_with(arel)
+        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
+
+        if recursive_value?
+          arel.with(:recursive, cte_statements)
+        else
+          arel.with(cte_statements)
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Relation.prepend(ActiveRecordExtended::QueryMethods::WithCTE)

data/lib/active_record_extended/utilities/order_by.rb

@@ -0,0 +1,77 @@
+# 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 { |order_args| process_ordering_arguments!(order_args) }
+          .tap { |order_args| scope_preprocess_order_args(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
+
+      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

data/lib/active_record_extended/utilities/support.rb

@@ -0,0 +1,178 @@
+# 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
+          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 = generate_grouping(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.unscope(:where)
+      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?)
+
+        # Add subquery CTE's to the parents query stack. (READ THE SPECIAL NOTE ABOVE!)
+        if @scope.with_values?
+          @scope.cte.pipe_cte_with!(subquery.cte)
+        else
+          # Top level has no with values
+          @scope.with!(subquery.cte)
+        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.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.1, we then can then drop the '.to_sql' conversation
+
+      def to_arel_sql(value)
+        case value
+        when Arel::Nodes::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)
+
+        generate_grouping(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 generate_grouping(expr)
+        ::Arel::Nodes::Grouping.new(to_arel_sql(expr))
+      end
+
+      def generate_named_function(function_name, *args)
+        args.map! { |arg| to_arel_sql(arg) }
+        function_name = function_name.to_s.upcase
+        ::Arel::Nodes::NamedFunction.new(to_arel_sql(function_name), args)
+      end
+
+      def key_generator
+        A_TO_Z_KEYS.sample
+      end
+    end
+  end
+end