orchestrate 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f7d5c6bc09a49e08d464387e25b98ae9777bbf93
-  data.tar.gz: 72a68c6e456c4920c9875e7e3f7108b29bd59d12
+  metadata.gz: 052b46ffb077d9256c3626b2d2fe1d6618c0f3c9
+  data.tar.gz: 34375247e7fc3ce08d2f836df6e0df7f778273f7
 SHA512:
-  metadata.gz: a8a2a5f7124cd557dc4a3ed3a4fc9d71064494e8241ae87409c8fcfd2fe40236eaebd0171e54c5c2ab22bcba03a1e33bb8a81171681a205edb4c153f747ef2a9
-  data.tar.gz: 753527cab83aac5537fd178ac976cf704f6c173c63b0b64a2f9c9fdd859c30d18e6d8cd34cb92bcc4b6bb2aa3643e66f47918193d561c65e88b2f591b82f802e
+  metadata.gz: 99d0edff2baf770cf3c2173c9245bb42957dee1a92c1d4abca2c24bc8b510569bf6bda09159c2761bbd64d9631cdfd1d2273166597dccb11a12f85c1a110fb3d
+  data.tar.gz: 6afa7091564272f7f22d0b4d173b03cd76815a63992876aaccadd3b1c08ab11a38a6c20e884e2feafcf8e339651f0bf0b623339927de6a7e6b1e8c5fd27f39a3

data/README.md

@@ -65,20 +65,20 @@ jill.add('favorite_food', 'Pizza').remove('years_to_live').update()
 
 #### Searching, Sorting for KeyValues
 ```ruby
-users.search("name:Jill")                    # returns users with name "Jill"
-users.search("name:Jill").order(:created_at) # returns users with name "Jill" in ascending order
+users.search("name:Jill").find                      # returns users with name "Jill"
+users.search("name:Jill").order(:created_at).find   # returns users with name "Jill" in ascending order
 ```
 
 The `order` method accepts multiple arguments, allowing you to sort search results based multiple parameters. When providing multiple field names to sort by each even-numbered argument must be either `:asc` or `:desc`.
 
 ```ruby
-users.search("location: Portland").order(:name, :asc, :rank, :desc)
+users.search("location: Portland").order(:name, :asc, :rank, :desc).find
 ```
 
 By default, odd-numbered arguments will be sorted in ascending order.
 ```ruby
-users.search("location: Portland").order(:name) # returns users in ascending order by name
-users.search("location: Portland").order(:name, :asc, :rank, :desc, :created_at) # :created_at argument defaults to :asc
+users.search("location: Portland").order(:name).find  # returns users in ascending order by name
+users.search("location: Portland").order(:name, :asc, :rank, :desc, :created_at).find   # :created_at argument defaults to :asc
 ```
 
 ### Geo Queries
@@ -87,13 +87,56 @@ users.search("location: Portland").order(:name, :asc, :rank, :desc, :created_at)
 cafes = app[:cafes]
 
 # Find cafes near a given geographic point
-cafes.near(:location, 12.56, 19.443, 4, 'mi')   # returns cafes in a 4 mile radius of given latitude, longitude
+cafes.near(:location, 12.56, 19.443, 4, 'mi').find   # returns cafes in a 4 mile radius of given latitude, longitude
 
 # Sort nearby cafes by distance
-cafes.near(:location, 12.56, 19.443, 4, 'mi').order(:distance)  # returns nearby cafes in ascending order (closest to farthest)
+cafes.near(:location, 12.56, 19.443, 4, 'mi').order(:distance).find  # returns nearby cafes in ascending order (closest to farthest)
 
 # Find cafes in a given area using a bounding box
-cafes.in(:location, {north:12.5, east:57, south:12, west:56})   # returns all cafes within specified bounding box
+cafes.in(:location, {north:12.5, east:57, south:12, west:56}).find   # returns all cafes within specified bounding box
+```
+
+### Aggregate Functions
+
+```ruby
+# Statistical Aggregate
+products.search("*").aggregate  # Start the search query and aggregate param builder
+  .stats("price")               # statistics on the price field for products matching the query
+  .find                         # return SearchResults object to execute our query
+  .each_aggregate               # return enumerator for iterating over each aggregate result
+
+# Range Aggregate
+products.search("*").aggregate  # Start the search query and aggregate param builder
+  .range("num_sold")            # set field for range function
+  .below(99)                    # count items with num_sold value below 99
+  .between(1, 10)               # count items with num_sold value between 1 & 10
+  .above(5)                     # count items with num_sold value above 5
+  .find                         # return SearchResults object to execute our query
+  .each_aggregate               # return enumerator for iterating over each aggregate result
+
+# Distance Aggregate
+cafes.near(:location, 12, 19, 4, 'mi').aggregate  # Start the near search query and aggregate param builder
+  .distance("location")         # set field for distance function
+  .below(3)                     # count cafes within 3 miles of given geographic point
+  .between(3, 4)                # count cafes between 3 and 4 miles of given geographic point
+  .above(1)                     # count cafes beyond 1 mile of given geographic point
+  .find                         # return SearchResults object to execute our query
+  .each_aggregate               # return enumerator for iterating over each aggregate result
+
+# Time-Series Aggregate
+# Accepted intervals are: year, quarter, month, week, day, and hour
+comments.search("*").aggregate  # Start the near search query and aggregate param builder
+  .time_series("posted", "day") # get count of comments posted by day
+  .find                         # return SearchResults object to execute our query
+  .each_aggregate               # return enumerator for iterating over each aggregate result
+
+# Multiple Aggregate Functions
+products.search("*").aggregate  # Start the search query and aggregate param builder
+  .stats("price")               # statistics on the price field for products matching the query
+  .range("num_sold")            # set field for range function
+  .below(99)                    # count items with num_sold value below 99
+  .find                         # return SearchResults object to execute our query
+  .each_aggregate               # return enumerator for iterating over each aggregate result
 ```
 
 ### Method Client use
@@ -173,6 +216,82 @@ query = "value:IN:{ north:12.5 east:57 south:12 west:56 }"
 client.search(:cafes, query)
 ```
 
+### Aggregate Functions
+
+```ruby
+# Statistical Aggregate
+query = "*"
+
+options = {
+  aggregate: "value.price:stats"    # get statistics for price across all items in the collection
+}
+
+response = client.search(:products, query, options)
+
+response.aggregates     # return aggregate results
+
+
+# Range Aggregate
+query = "*"
+
+options = {
+  # count items with num_sold below 99, in between 1 & 10, and above 5
+  aggregate: "value.num_sold:range:*~99:1~10:5~*"
+}
+
+response = client.search(:products, query, options)
+
+response.aggregates     # return aggregate results
+
+
+# Distance Aggregate
+coords = {
+  lat: 12.56,
+  lon: 19.443,
+  dist: '4mi' # Define size of search radius for NEAR query
+}
+
+options = {
+  # count cafes near give geographic point within 3 miles, between 3 and 4 miles, and beyond 1 mile
+  aggregate: "value.location:distance:*~3:3~4:1~*"
+}
+
+# Distance Aggregates require a near clause in the search query
+query = "value.location:NEAR:{lat:#{coords.lat} lon:#{coords.lon} dist:#{coords.dist}}"
+
+response = client.search(:cafes, query, options)
+
+response.aggregates     # return aggregate results
+
+
+# Time-Series Aggregate
+# Accepted intervals are: year, quarter, month, week, day, and hour
+
+options = {
+  # get count of comments posted by day
+  aggregate: "value.posted:time_series:day"
+}
+
+query = "*"
+
+response = client.search(:comments, query, options)
+
+response.aggregates     # return aggregate results
+
+
+# Multiple Aggregate Functions
+options = {
+  # multiple aggregate params are separated by commas
+  aggregate: "value.price:stats,value.num_sold:stats,value.num_sold:range:*~99:1~10:5~*"
+}
+
+query = "*"
+
+response = client.search(:products, query, options)
+
+response.aggregates     # return aggregate results
+```
+
 ### Examples and Documentation
 
 There are more examples at [Orchestrate's API Documentation][apidoc] and documentation in the [rdoc][].
@@ -277,10 +396,19 @@ end
 
 ## Release Notes
 
+### January 7, 2014: release 0.11.0
+  - **BACKWARDS-INCOMPATIBLE** `Orchestrate::Collection` searches require `#find` method at the end of the method call/chain. Example: `users.search('foo').find`.
+  - Implement `Orchestrate::Search` module, refactor functionality of prior `Orchestrate::Collection::SearchResults`.
+  - Implement results enumeration & request firing functionality in prior `Orchestrate::Collection::SearchResults` to `Orchestrate::Search::Results`
+  - Implement `Search::QueryBuilder` to construct `Collection` search queries. 
+  - Implement `Search::AggregateBuilder` to construct aggregate params on `Collection` search queries.
+  - Implement `Search::StatsBuilder`, `Search::RangeBuilder`, `Search::DistanceBuilder`, & `Search::TimeSeriesBuilder` to construct aggregate function clauses for aggregate params.
+  - Implement `Search::AggregateResult` objects to repesent aggregate results returned from `Collection` search.
+
 ### December 11, 2014: release 0.10.0
   - **BACKWARDS-INCOMPATIBLE** Prior `KeyValue#update` & `KeyValue#update!` renamed to `KeyValue#set` & `KeyValue#set!`. `KeyValue#update` now used after `PATCH` operations to fire the request.
   - Implement `Collection#near` & `Collection#in`, allowing `Collection` to perform geo queries.
-  - Implement `Client#patch`, `Client#patch_merge`, allowing `Client` to perform subdocument updates through `PATCH` requests.
+  - Implement `Client#patch`, `Client#patch_merge`, allowing `Client` to perform partial updates through `PATCH` requests.
   - Implement `KeyValue::OperationSet`, allowing a set of `PATCH` operations to be built by `KeyValue` through `KeyValue#add`, `KeyValue#remove`, `KeyValue#replace`, `KeyValue#move`, `KeyValue#copy`, `KeyValue#increment`, `KeyValue#decrement`, & `KeyValue#test`. The `KeyValue::OperationSet` is fired by ending the chain with `KeyValue#update`.
   - Implement `KeyValue#merge`, allowing `KeyValue` to merge partial values into existing keys through `PATCH` requests.
 
@@ -346,4 +474,4 @@ end
 ### May 21, 2014: release 0.5.0
   Initial Port from @jimcar
   - Uses Faraday HTTP Library as backend, with examples of alternate adapters
-  - Cleanup client method signatures
+  - Cleanup client method signatures

data/lib/orchestrate/api/response.rb

@@ -109,6 +109,9 @@ module Orchestrate::API
     # @return [Array] The items in the response.
     attr_reader :results
 
+    # @return [Array] The aggregate items in the response.
+    attr_reader :aggregates
+
     # @return [String] The location for the next page of results
     attr_reader :next_link
 
@@ -122,6 +125,7 @@ module Orchestrate::API
         @count = body['count']
         @total_count = body['total_count']
         @results = body['results']
+        @aggregates = body['aggregates']
         @next_link = body['next']
         @prev_link = body['prev']
       end

data/lib/orchestrate/collection.rb

@@ -345,17 +345,13 @@ module Orchestrate
       end
     end
 
-    # @!group Searching
-    # [Search the items in a collection](http://orchestrate.io/docs/api/#search) using a Lucene
-    # Query Syntax.
     # @param query [#to_s] The [Lucene Query
     #   String](http://lucene.apache.org/core/4_3_0/queryparser/org/apache/lucene/queryparser/classic/package-summary.html#Overview)
     #   to query the collection with.
-    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    # @return [Orchestrate::Search::QueryBuilder] A builder object to construct the query.
     def search(query)
-      SearchResults.new(self, query)
+      Search::QueryBuilder.new(self, query)
     end
-    # @!endgroup
 
     # @!group Geo Queries
     # Performs a search for items near a specified geographic point in a collection.
@@ -366,11 +362,11 @@ module Orchestrate
     # @param distance [Integer] The number of distance units.
     # @param units [#to_s] Unit of measurement for distance, default to kilometers (km),
     # supported units: km, m, cm, mm, mi, yd, ft, in, nmi
-    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    # @return [Orchestrate::Search::QueryBuilder] A builder object to construct the query.
     def near(field, latitude, longitude, distance, units=nil)
-        units ||= 'km'
-        query = "#{field}:NEAR:{lat:#{latitude} lon:#{longitude} dist:#{distance}#{units}}"
-        SearchResults.new(self, query)
+      units ||= 'km'
+      query = "#{field}:NEAR:{lat:#{latitude} lon:#{longitude} dist:#{distance}#{units}}"
+      Search::QueryBuilder.new(self, query)
     end
 
     # Performs a search for items within a particular area, 
@@ -380,112 +376,14 @@ module Orchestrate
     # @param box [#to_json] The values to create the bounding box,
     # @example
     #   collection.in(:field, {north: 12.5, south: 15, east: 14, west: 3})
-    # @return [SearchResults] A loaded SearchResults object ready to enumerate over.
+    # @return [Orchestrate::Search::QueryBuilder] A builder object to construct the query.
     def in(field, box={})
       box = box.flatten.each_slice(2).map {|dir, val| "#{dir}:#{val}" }.join(" ")
       query = "#{field}:IN:{#{box}}"
-      SearchResults.new(self, query)
+      Search::QueryBuilder.new(self, query)
     end
     # @!endgroup
 
-    # An enumerator with a query for searching an Orchestrate::Collection
-    class SearchResults
-      # @return [Collection] The collection this object will search.
-      attr_reader :collection
-
-      # @return [#to_s] The Lucene Query String given as the search query.
-      attr_reader :query
-      
-      # @return [#to_s] The sorting parameters.
-      attr_reader :sort
-
-      # @return [Integer] The number of results to fetch per request.
-      attr_reader :limit
-
-      # Initialize a new SearchResults object
-      # @param collection [Orchestrate::Collection] The collection to search.
-      # @param query [#to_s] The Lucene Query to perform.
-      def initialize(collection, query, sort=nil)
-        @collection = collection
-        @query = query
-        @sort = sort
-        @limit = 100
-        @offset= nil
-      end
-      
-      # Sets the sorting parameters for enumeration over the SearchResults items in the collection.
-      # #order takes multiple arguments, but each even numbered argument must be either :asc or :desc
-      # When given a single argument #order defaults to :asc
-      # @example
-      #  @app[:items].search("location: Portland").order(:name, :asc, :rank, :desc, :created_at)
-      # the :created_at parameter will default to :asc
-      def order(*args)
-        sort = args.each_slice(2).map {|field, dir| dir ||= :asc; "#{field}:#{dir}" }.join(",")
-        self.class.new(collection, query, sort)
-      end
-
-      include Enumerable
-
-      # Iterates over each result from the Search.  Used as the basis for Enumerable methods.  Items are
-      # provided on the basis of score, with most relevant first.
-      # @overload each
-      #   @return Enumerator
-      # @overload each(&block)
-      #   @yieldparam [Array<(Float, Orchestrate::KeyValue)>] score,key_value  The item's score and the item.
-      # @example
-      #   collection.search("trendy").take(5).each do |score, item|
-      #     puts "#{item.key} has a trend score of #{score}"
-      #   end
-      def each
-        params = {limit:limit}
-        params[:offset] = offset if offset
-        params[:sort] = sort if sort
-        @response ||= collection.perform(:search, query, params)
-        return enum_for(:each) unless block_given?
-        raise ResultsNotReady.new if collection.app.inside_parallel?
-        loop do
-          @response.results.each do |listing|
-            yield [ listing['score'], KeyValue.from_listing(collection, listing, @response) ]
-          end
-          break unless @response.next_link
-          @response = @response.next_results
-        end
-        @response = nil
-      end
-
-      # Creates a Lazy Enumerator for the Search Results.  If called inside its
-      # app's `in_parallel` block, will pre-fetch results.
-      def lazy
-        return each.lazy if collection.app.inside_parallel?
-        super
-      end
-
-      # Returns the first n items.  Equivalent to Enumerable#take.  Sets the
-      # `limit` parameter on the query to Orchestrate, so we don't ask for more than is needed.
-      # @param count [Integer] The number of items to limit to.
-      # @return [Array]
-      def take(count)
-        @limit = count > 100 ? 100 : count
-        super(count)
-      end
-
-      # Sets the offset for the query to Orchestrate, so you can skip items.  Does not fire a request.
-      # Impelemented as separate method from drop, unlike #take, because take is a more common use case.
-      # @overload offset
-      #   @return [Integer, nil] The number of items to skip.  Nil is equivalent to zero.
-      # @overload offset(conunt)
-      #   @param count [Integer] The number of items to skip.
-      #   @return [SearchResults] self.
-      def offset(count=nil)
-        if count
-          @offset = count
-          self
-        else
-          @offset
-        end
-      end
-    end
-
     # Tells the Applicaiton to perform a request on its client, automatically
     # providing the collection name.
     # @param api_method [Symbol] The method on the client to call.

data/lib/orchestrate/search/aggregate_builder.rb

@@ -0,0 +1,290 @@
+module Orchestrate::Search
+  # Aggregate Builder object for constructing aggregate params included in a search
+  class AggregateBuilder
+
+    # @return [QueryBuilder] 
+    attr_reader :builder
+
+    # @return [Array] Aggregate param arguments
+    attr_reader :aggregates
+
+    extend Forwardable
+
+    # Initialize a new AggregateBuilder object
+    # @param builder [Orchestrate::Search::SearchBuilder] The Search Builder object
+    def initialize(builder)
+      @builder = builder
+      @aggregates = []
+    end
+
+    def_delegator :@builder, :options
+    def_delegator :@builder, :order
+    def_delegator :@builder, :limit
+    def_delegator :@builder, :offset
+    def_delegator :@builder, :aggregate
+    def_delegator :@builder, :find
+    def_delegator :@builder, :collection
+
+    # @return Pretty-Printed string representation of the AggregateBuilder object
+    def to_s
+      "#<Orchestrate::Search::AggregateBuilder collection=#{collection.name} query=#{builder.query} aggregate=#{to_param}>"
+    end
+    alias :inspect :to_s
+
+    # @return constructed aggregate string parameter for search query
+    def to_param
+      aggregates.map {|agg| agg.to_param }.join(',')
+    end
+
+    # @!group Aggregate Functions
+
+    # @param field_name [#to_s]
+    # @return [AggregateBuilder]
+    def stats(field_name)
+      stat = StatsBuilder.new(self, "#{field_name}")
+      aggregates << stat
+      stat
+    end
+
+    # @param field_name [#to_s]
+    # @return [RangeBuilder]
+    def range(field_name)
+      rng = RangeBuilder.new(self, "#{field_name}")
+      aggregates << rng
+      rng
+    end
+
+    # @param field_name [#to_s]
+    # @return [DistanceBuilder]
+    def distance(field_name)
+      dist = DistanceBuilder.new(self, "#{field_name}")
+      aggregates << dist
+      dist
+    end
+
+    # @param field_name [#to_s]
+    # @return [TimeSeriesBuilder]
+    def time_series(field_name)
+      time = TimeSeriesBuilder.new(self, "#{field_name}")
+      aggregates << time
+      time
+    end
+    # @!endgroup
+  end
+
+  # Stats Builder object for constructing stats functions to be included in the aggregate param
+  class StatsBuilder
+    
+    # @return [AggregateBuilder]
+    attr_reader :builder
+
+    # @return [#to_s] The field to operate over
+    attr_reader :field_name
+
+    extend Forwardable
+
+    # Initialize a new RangeBuilder object
+    # @param builder [AggregateBuilder] The Aggregate Builder object
+    # @param field_name [#to_s]
+    def initialize(builder, field_name)
+      @builder = builder
+      @field_name = field_name
+    end
+
+    def_delegator :@builder, :options
+    def_delegator :@builder, :order
+    def_delegator :@builder, :limit
+    def_delegator :@builder, :offset
+    def_delegator :@builder, :aggregate
+    def_delegator :@builder, :find
+    def_delegator :@builder, :stats
+    def_delegator :@builder, :range
+    def_delegator :@builder, :distance
+    def_delegator :@builder, :time_series
+    def_delegator :@builder, :collection
+
+    # @return Pretty-Printed string representation of the StatsBuilder object
+    def to_s
+      "#<Orchestrate::Search::StatsBuilder collection=#{collection.name} field_name=#{field_name}>"
+    end
+    alias :inspect :to_s
+
+    # @return [#to_s] constructed aggregate string clause
+    def to_param
+      "#{field_name}:stats"
+    end
+  end
+
+  # Range Builder object for constructing range functions to be included in the aggregate param
+  class RangeBuilder
+
+    # @return [AggregateBuilder]
+    attr_reader :builder
+
+    # @return [#to_s] The field to operate over
+    attr_reader :field_name
+
+    # @return [#to_s] The range sets
+    attr_reader :ranges 
+
+    extend Forwardable
+
+    # Initialize a new RangeBuilder object
+    # @param builder [AggregateBuilder] The Aggregate Builder object
+    # @param field_name [#to_s]
+    def initialize(builder, field_name)
+      @builder = builder
+      @field_name = field_name
+      @ranges = ''
+    end
+
+    def_delegator :@builder, :options
+    def_delegator :@builder, :order
+    def_delegator :@builder, :limit
+    def_delegator :@builder, :offset
+    def_delegator :@builder, :aggregate
+    def_delegator :@builder, :find
+    def_delegator :@builder, :stats
+    def_delegator :@builder, :range
+    def_delegator :@builder, :distance
+    def_delegator :@builder, :time_series
+    def_delegator :@builder, :collection
+
+    # @return Pretty-Printed string representation of the RangeBuilder object
+    def to_s
+      "#<Orchestrate::Search::RangeBuilder collection=#{collection.name} field_name=#{field_name} ranges=#{ranges}>"
+    end
+    alias :inspect :to_s
+
+    # @return [#to_s] constructed aggregate string clause
+    def to_param
+      "#{field_name}:range:#{ranges}"
+    end
+
+    # @param x [Integer]
+    # @return [RangeBuilder]
+    def below(x)
+      @ranges << "*~#{x}:"
+      self
+    end
+
+    # @param x [Integer]
+    # @return [RangeBuilder]
+    def above(x)
+      @ranges << "#{x}~*:"
+      self
+    end
+
+    # @param x [Integer]
+    # @param y [Integer]
+    # @return [RangeBuilder]
+    def between(x, y)
+      @ranges << "#{x}~#{y}:"
+      self
+    end
+  end
+
+  # Distance Builder object for constructing distance functions for the aggregate param
+  class DistanceBuilder < RangeBuilder
+
+    # @return Pretty-Printed string representation of the DistanceBuilder object
+    def to_s
+      "#<Orchestrate::Search::DistanceBuilder collection=#{collection.name} field_name=#{field_name} ranges=#{ranges}>"
+    end
+    alias :inspect :to_s
+
+    # @return [#to_s] constructed aggregate string clause
+    def to_param
+      "#{field_name}:distance:#{ranges}"
+    end
+  end
+
+  # Time Series Builder object for constructing time series functions for the aggregate param
+  class TimeSeriesBuilder
+
+    # @return [AggregateBuilder]
+    attr_reader :builder
+
+    # @return [#to_s] The field to operate over
+    attr_reader :field_name
+
+    # @return [#to_s] The interval of time for the TimeSeries function
+    attr_reader :interval
+
+    extend Forwardable
+
+    # Initialize a new TimeSeriesBuilder object
+    # @param builder [AggregateBuilder] The Aggregate Builder object
+    # @param field_name [#to_s] The field to operate over
+    def initialize(builder, field_name)
+      @builder = builder
+      @field_name = field_name
+      @interval = nil
+    end
+
+    def_delegator :@builder, :options
+    def_delegator :@builder, :order
+    def_delegator :@builder, :limit
+    def_delegator :@builder, :offset
+    def_delegator :@builder, :aggregate
+    def_delegator :@builder, :find
+    def_delegator :@builder, :stats
+    def_delegator :@builder, :range
+    def_delegator :@builder, :distance
+    def_delegator :@builder, :time_series
+    def_delegator :@builder, :collection
+
+    # @return Pretty-Printed string representation of the TimeSeriesBuilder object
+    def to_s
+      "#<Orchestrate::Search::TimeSeriesBuilder collection=#{collection.name} field_name=#{field_name} interval=#{interval}>"
+    end
+    alias :inspect :to_s
+
+    # @return [#to_s] constructed aggregate string clause
+    def to_param
+      "#{field_name}:time_series:#{interval}"
+    end
+
+    # Set time series interval to year
+    # @return [AggregateBuilder]
+    def year
+      @interval = 'year'
+      self
+    end
+
+    # Set time series interval to quarter
+    # @return [AggregateBuilder]
+    def quarter
+      @interval = 'quarter'
+      self
+    end
+
+    # Set time series interval to month
+    # @return [AggregateBuilder]
+    def month
+      @interval = 'month'
+      self
+    end
+
+    # Set time series interval to week
+    # @return [AggregateBuilder]
+    def week
+      @interval = 'week'
+      self
+    end
+
+    # Set time series interval to day
+    # @return [AggregateBuilder]
+    def day
+      @interval = 'day'
+      self
+    end
+
+    # Set time series interval to hour
+    # @return [AggregateBuilder]
+    def hour
+      @interval = 'hour'
+      self
+    end
+  end
+end