redi_search 6.3.0 → 6.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d005b7e0b289004277bf5526a4270aa7dd707df16520ae0e2b9df577b12601c2
-  data.tar.gz: 9b3954997aa84e9e25037c6b332c00139d7d112dad9fffbbe32281f9da0fdfe1
+  metadata.gz: 6fbc68e53dd39c963d1bb380482967016fb5a511021104e16ce1cc8741cb8023
+  data.tar.gz: 4899d79c5a505ebf6a306e23cf1c943e511aaaf59855705395b36d7264da7f6d
 SHA512:
-  metadata.gz: dfcbe3552fef2dcb9abda2ad3e51c2bf35a2d2a16a631f249d1f1a89e5ed3aab5f0815387ab5a472f13db9c1d8a430f114840e81147e2b44160b1890be0f6c94
-  data.tar.gz: 3e2c1b66bb0053f42d886ab765468a213ab576b31d7d95a08f8bd216dcb8a933abbd76670207b2c9b366e988622a0aa1ece981901bb368916087c85a75b0726f
+  metadata.gz: bd8bdd6ca738503cc4a8008d43f2225ad3c14c869bfed0c42f13de5b104bb9d4093d46c479008c24d6fbf988a13e9494cff4cc202a6fa6e44a1f8d8d3c70f40d
+  data.tar.gz: 5fad9402eb86bc138a4b98e239b31ad48a5b5f5cc0f9c5db019c037955482f26cda1a74bce4b816f78c13503bd2da168cf9dfceb20f2ea9c92e7770ce85b8979

data/.ruby-version

@@ -1 +1 @@
-3.2.0-preview3
+3.2.1

data/lib/redi_search/aggregate/clauses/apply.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class Apply < ApplicationClause
+        clause_term :expression, presence: true
+        clause_term :as, presence: true
+        clause_order 5
+
+        def initialize(expression:, as:)
+          @expression = expression
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          ["APPLY", expression, "AS", as]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/filter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class Filter < ApplicationClause
+        clause_term :expression, presence: true
+        clause_order 6
+
+        def initialize(expression:)
+          @expression = expression
+        end
+
+        def clause
+          validate!
+
+          ["FILTER", expression]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/group_by.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class GroupBy < ApplicationClause
+        clause_term :fields, presence: true
+        clause_order 3
+
+        def initialize(fields:)
+          @fields = fields.map(&:to_s).map do |field|
+            field.prepend("@") unless field.start_with?("@")
+          end
+          @reducer = nil
+        end
+
+        def clause
+          validate!
+
+          ["GROUPBY", fields.count, *fields, *reducer&.clause].compact
+        end
+
+        def count(as: nil)
+          self.reducer = Reducers::Count.new(as: as).tap(&:validate!)
+        end
+
+        def distinct_count(property:, as: nil)
+          self.reducer = Reducers::DistinctCount.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def distinctish_count(property:, as: nil)
+          self.reducer = Reducers::DistinctishCount.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def sum(property:, as: nil)
+          self.reducer = Reducers::Sum.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def min(property:, as: nil)
+          self.reducer = Reducers::Min.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def max(property:, as: nil)
+          self.reducer = Reducers::Max.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def average(property:, as: nil)
+          self.reducer = Reducers::Average.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def stdev(property:, as: nil)
+          self.reducer = Reducers::Stdev.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        def quantile(property:, quantile:, as: nil)
+          self.reducer = Reducers::Quantile.new(
+            property: property, quantile: quantile, as: as
+          ).tap(&:validate!)
+        end
+
+        def to_list(property:, as: nil)
+          self.reducer = Reducers::ToList.
+                         new(property: property, as: as).tap(&:validate!)
+        end
+
+        private
+
+        attr_accessor :reducer
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/limit.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class Limit < ApplicationClause
+        clause_term :total, presence: true, numericality: {
+          within: 0..Float::INFINITY, only_integer: true
+        }
+        clause_term :offset, presence: true, numericality: {
+          within: 0..Float::INFINITY, only_integer: true
+        }
+        clause_order 7
+
+        def initialize(total:, offset: 0)
+          @total = total
+          @offset = offset
+        end
+
+        def clause
+          validate!
+
+          ["LIMIT", offset, total]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/load.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class Load < ApplicationClause
+        clause_term :fields, presence: true
+        clause_order 2
+
+        def initialize(fields:)
+          @fields = fields
+        end
+
+        def clause
+          validate!
+
+          ["LOAD", fields.size, *fields]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/sort_by.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class SortBy < ApplicationClause
+        class Sortable < ApplicationClause
+          clause_term :field, presence: true
+          clause_term :order, presence: true,
+                              inclusion: { within: %i(asc desc) }
+
+          def initialize(field, order = :asc)
+            @field = field.to_s
+            @field.prepend("@") unless @field.start_with?("@")
+            @order = order.to_sym
+          end
+
+          def clause
+            [field, order.to_s.upcase]
+          end
+        end
+
+        clause_term :fields, presence: true
+        clause_order 4
+
+        def initialize(fields:)
+          @fields = fields.flat_map do |field|
+            if field.is_a?(Hash) then field.map { |k, v| Sortable.new(k, v) }
+            else
+              Sortable.new(field)
+            end
+          end
+        end
+
+        def clause
+          validate! && fields.each(&:validate!)
+
+          ["SORTBY", fields.count * 2, *fields.flat_map(&:clause)]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/clauses/verbatim.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Clauses
+      class Verbatim < ApplicationClause
+        clause_order 1
+
+        def clause
+          validate!
+
+          ["VERBATIM"]
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/average.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Average < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "AVG", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/count.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Count < ApplicationClause
+        clause_term :as
+
+        def initialize(as:)
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "COUNT", 0]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/distinct_count.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class DistinctCount < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "COUNT_DISTINCT", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/distinctish_count.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class DistinctishCount < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "COUNT_DISTINCTISH", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/max.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Max < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "MAX", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/min.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Min < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "MIN", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/quantile.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Quantile < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :quantile, presence: true, inclusion: {
+          within: 0.0..1.0
+        }
+        clause_term :as
+
+        def initialize(property:, quantile:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @quantile = quantile
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "QUANTILE", 2, property, quantile]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/stdev.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Stdev < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "STDEV", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/sum.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class Sum < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "SUM", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate/reducers/to_list.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    module Reducers
+      class ToList < ApplicationClause
+        clause_term :property, presence: true
+        clause_term :as
+
+        def initialize(property:, as:)
+          @property = property.to_s
+          @property.prepend("@") unless @property.start_with?("@")
+          @as = as
+        end
+
+        def clause
+          validate!
+
+          command =  ["REDUCE", "TOLIST", 1, property]
+          command += ["AS", as] if as
+          command
+        end
+      end
+    end
+  end
+end

data/lib/redi_search/aggregate.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class Aggregate
+    class MissingGroupByClause < StandardError
+    end
+
+    extend Forwardable
+    include LazilyLoad
+    include Search::Queries
+
+    attr_reader :query, :used_clauses, :index, :clauses
+
+    def_delegator :index, :model
+
+    def initialize(index, term = nil, **term_options)
+      @index = index
+      @clauses = []
+      @used_clauses = Set.new
+
+      @query = term && Search::Queries::And.new(self, term, nil, **term_options)
+    end
+
+    def verbatim
+      add_to_clauses(Clauses::Verbatim.new)
+    end
+
+    def load(*fields)
+      add_to_clauses(Clauses::Load.new(fields: fields))
+    end
+
+    def group_by(*fields)
+      add_to_clauses(Clauses::GroupBy.new(fields: fields))
+    end
+
+    def count(as: nil)
+      clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+        raise(MissingGroupByClause, "call group_by first")
+
+      clause.count(as: as)
+      self
+    end
+
+    def quantile(property: nil, quantile: nil, as: nil)
+      clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+        raise(MissingGroupByClause, "call group_by first")
+
+      clause.count(property: property, quantile: quantile, as: as)
+
+      self
+    end
+
+    %i(distinct_count distinctish_count sum min max average stdev to_list).
+      each do |reducer|
+      define_method(reducer) do |property, as: nil|
+        clause = clauses.reverse.find { |cl| cl.is_a?(Clauses::GroupBy) } ||
+          raise(MissingGroupByClause, "call group_by first")
+
+        clause.public_send(reducer, property: property, as: as)
+        self
+      end
+    end
+
+    def sort_by(*fields)
+      add_to_clauses(Clauses::SortBy.new(fields: fields))
+    end
+
+    def apply(expression, as:)
+      add_to_clauses(Clauses::Apply.new(expression: expression, as: as))
+    end
+
+    def filter(expression)
+      add_to_clauses(Clauses::Filter.new(expression: expression))
+    end
+
+    def limit(total, offset = 0)
+      add_to_clauses(Clauses::Limit.new(total: total, offset: offset))
+    end
+
+    private
+
+    attr_writer :index, :clauses
+
+    def command
+      ["AGGREGATE", index.name, query.to_s,
+       *clauses.sort_by(&:clause_order).flat_map(&:clause)]
+    end
+
+    def parse_response(response)
+      @documents = response
+    end
+
+    def valid?
+      !query.to_s.empty?
+    end
+
+    def add_to_clauses(clause)
+      clause.validate! && clauses.push(clause) if
+        used_clauses.add?(clause.class)
+
+      self
+    end
+  end
+end

data/lib/redi_search/application_clause.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RediSearch
+  class ApplicationClause
+    include Validatable
+
+    def clause_order
+      self.class.order
+    end
+
+    class << self
+      def clause_term(term, **validations)
+        attr_reader term
+
+        validations.each do |validation_type, options|
+          define_validation(term, validation_type, options)
+        end
+      end
+
+      attr_reader :order
+
+      def clause_order(number)
+        @order = number
+      end
+
+      private
+
+      def define_validation(term, type, options)
+        if options.is_a? Hash
+          public_send("validates_#{type}_of", term, **options)
+        else
+          public_send("validates_#{type}_of", term)
+        end
+      end
+    end
+  end
+end