ruby-druid 0.1.9 → 0.9.0

data/lib/druid/query.rb

@@ -1,223 +1,489 @@
-require 'druid/serializable'
+require 'time'
+require 'iso8601'
+
+require 'active_support/all'
+require 'active_model'
+
+require 'druid/granularity'
+require 'druid/aggregation'
+require 'druid/post_aggregation'
 require 'druid/filter'
+require 'druid/context'
 require 'druid/having'
-require 'druid/post_aggregation'
-
-require 'time'
-require 'json'
 
 module Druid
   class Query
+    include ActiveModel::Model
 
-    attr_reader :properties
-
-    def initialize(source, client = nil)
-      @properties = {}
-      @client = client
+    attr_accessor :queryType
+    validates :queryType, inclusion: { in: %w(timeseries search timeBoundary groupBy segmentMetadata select topN dataSourceMetadata) }
 
-      # set some defaults
-      data_source(source)
-      granularity(:all)
+    attr_accessor :dataSource
+    validates :dataSource, presence: true
 
-      interval(today)
+    class IntervalsValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if !value.is_a?(Array) || value.blank?
+          record.errors.add(attribute, 'must be a list with at least one interval')
+          return
+        end
+        value.each do |interval|
+          parts = interval.to_s.split('/')
+          record.errors.add(attribute, 'must consist of two ISO8601 dates seperated by /') unless parts.length == 2
+          parts = parts.map do |ts|
+            ISO8601::DateTime.new(ts) rescue nil
+          end
+          record.errors.add(attribute, 'must consist of valid ISO8601 dates') unless parts.all?
+          record.errors.add(attribute, 'first date needs to be < second date') unless parts.first.to_time < parts.last.to_time
+        end
+      end
     end
 
-    def today
-      Time.now.to_date.to_time
+    attr_accessor :intervals
+    validates :intervals, intervals: true
+
+    class GranularityValidator < ActiveModel::EachValidator
+      TYPES = %w(timeseries search groupBy select topN)
+      SIMPLE = %w(all none minute fifteen_minute thirty_minute hour day)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.queryType)
+          if value.is_a?(String)
+            record.errors.add(attribute, "must be one of #{SIMPLE.inspect}") unless SIMPLE.include?(value)
+          elsif value.is_a?(Granularity)
+            value.valid? # trigger validation
+            value.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          else
+            record.errors.add(attribute, "invalid type or class: #{value.inspect}")
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
+      end
     end
 
-    def send
-      @client.send(self)
+    attr_accessor :granularity
+    validates :granularity, granularity: true
+
+    def granularity=(value)
+      if value.is_a?(String)
+        @granularity = value
+      elsif value.is_a?(Hash)
+        @granularity = Granularity.new(value)
+      else
+        @granularity = value
+      end
     end
 
-    def query_type(type)
-      @properties[:queryType] = type
-      self
+    class DimensionsValidator < ActiveModel::EachValidator
+      TYPES = %w(groupBy select)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.queryType)
+          record.errors.add(attribute, 'must be a list with at least one dimension') if !value.is_a?(Array) || value.blank?
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
+      end
     end
-    
-    def get_query_type()
-      @properties[:queryType] || :groupBy
+
+    attr_accessor :dimensions
+    validates :dimensions, dimensions: true
+
+    class AggregationsValidator < ActiveModel::EachValidator
+      TYPES = %w(timeseries groupBy topN)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.queryType)
+          value.each(&:valid?) # trigger validation
+          value.each do |avalue|
+            avalue.errors.messages.each do |k, v|
+              record.errors.add(attribute, { k => v })
+            end
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
+      end
     end
 
-    def data_source(source)
-      source = source.split('/')
-      @properties[:dataSource] = source.last
-      @service = source.first
-      self
+    attr_accessor :aggregations
+    validates :aggregations, aggregations: true
+
+    def aggregations
+      @aggregations ||= []
     end
 
-    def source
-      "#{@service}/#{@properties[:dataSource]}"
+    def aggregations=(value)
+      if value.is_a?(Array)
+        @aggregations = value.map do |x|
+          Aggregation.new(x)
+        end
+      else
+        @aggregations = [value]
+      end
     end
 
-    def group_by(*dimensions)
-      query_type(:groupBy)
-      @properties[:dimensions] = dimensions.flatten
-      self
+    def aggregation_types
+      Set.new(@aggregations.map do |aggregation|
+        aggregation.type
+      end.flatten.compact)
     end
 
-    def topn(dimension, metric, threshold)
-      query_type(:topN)
-      @properties[:dimension] = dimension
-      @properties[:metric] = metric
-      @properties[:threshold] = threshold
-      self
+    def aggregation_names
+      Set.new(@aggregations.map do |aggregation|
+        [aggregation.fieldName] + [aggregation.fieldNames]
+      end.flatten.compact)
     end
-    
-    def time_series(*aggregations)
-      query_type(:timeseries)
-      #@properties[:aggregations] = aggregations.flatten
-      self
+
+    class PostaggregationsValidator < ActiveModel::EachValidator
+      TYPES = %w(timeseries groupBy topN)
+      def validate_each(record, attribute, value)
+        if TYPES.include?(record.queryType)
+          value.each(&:valid?) # trigger validation
+          value.each do |avalue|
+            avalue.errors.messages.each do |msg|
+              record.errors.add(attribute, msg)
+            end
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
+      end
     end
 
-    [:long_sum, :double_sum, :count].each do |method_name|
-      agg_type = method_name.to_s.split('_')
-      agg_type[1].capitalize! if agg_type.length > 1
-      agg_type = agg_type.join
+    attr_accessor :postAggregations
+    validates :postAggregations, postaggregations: true
 
-      define_method method_name do |*metrics|
-        query_type(get_query_type())
-        @properties[:aggregations] = [] if @properties[:aggregations].nil?
+    def postAggregations
+      @postAggregations ||= []
+    end
 
-        metrics.flatten.each do |metric|
-          @properties[:aggregations] << {
-            :type => agg_type,
-            :name => metric.to_s,
-            :fieldName => metric.to_s
-          } unless contains_aggregation?(metric)
+    def postAggregations=(value)
+      if value.is_a?(Array)
+        @postAggregations = value.map do |x|
+          PostAggregation.new(x)
         end
+      else
+        @postAggregations = [value]
+      end
+    end
 
-        self
+    class FilterValidator < ActiveModel::EachValidator
+      TYPES = %w(timeseries search groupBy select topN)
+      def validate_each(record, attribute, value)
+        if value && TYPES.include?(record.queryType)
+          value.valid? # trigger validation
+          value.errors.messages.each do |k, v|
+            record.errors.add(attribute, { k => v })
+          end
+        else
+          record.errors.add(attribute, "is not supported by type=#{record.queryType}") if value
+        end
       end
     end
 
-    alias_method :sum, :long_sum
+    attr_accessor :filter
+    validates :filter, filter: true
 
-    def postagg(type=:long, &block)
-      post_agg = PostAggregation.new.instance_exec(&block)
-      @properties[:postAggregations] ||= []
-      @properties[:postAggregations] << post_agg
+    def filter=(value)
+      if value.is_a?(Hash)
+        @filter = Filter.new(value)
+      else
+        @filter = value
+      end
+    end
 
-      # make sure, the required fields are in the query
-      field_type = (type.to_s + '_sum').to_sym
-      # ugly workaround, because SOMEONE overwrote send
-      sum_method = self.method(field_type)
-      sum_method.call(post_agg.get_field_names)
+    # groupBy
+    attr_accessor :having
 
-      self
+    def having=(value)
+      if value.is_a?(Hash)
+        @having = Having.new(value)
+      else
+        @having = value
+      end
     end
 
-    def postagg_double(&block)
-      postagg(:double, &block)
-    end
+    # groupBy
+    attr_accessor :limitSpec
 
-    def filter(hash = nil, &block)
-      if hash
-        last = nil
-        hash.each do |k,values|
-          filter = FilterDimension.new(k).in(values)
-          last = last ? last.&(filter) : filter
-        end
-        @properties[:filter] = @properties[:filter] ? @properties[:filter].&(last) : last
-      end
-      if block
-        filter = Filter.new.instance_exec(&block)
-        raise "Not a valid filter" unless filter.is_a? FilterParameter
-        @properties[:filter] = @properties[:filter] ? @properties[:filter].&(filter) : filter
+    # search
+    attr_accessor :limit
+
+    # search
+    attr_accessor :searchDimensions
+
+    # search
+    attr_accessor :query
+
+    # search
+    attr_accessor :sort
+
+    # timeBoundary
+    attr_accessor :bound
+
+    # segementMetadata
+    attr_accessor :toInclude
+
+    # segementMetadata
+    attr_accessor :merge
+
+    # select
+    attr_accessor :metrics
+
+    # select
+    attr_accessor :pagingSpec
+
+    # topN
+    attr_accessor :dimension
+
+    # topN
+    attr_accessor :metric
+
+    # topN
+    attr_accessor :threshold
+
+    attr_accessor :context
+
+    def context=(value)
+      if value.is_a?(Hash)
+        @context = Context.new(value)
+      else
+        @context = value
       end
-      self
     end
 
-    def interval(from, to = Time.now)
-      intervals([[from, to]])
+    def initialize(attributes = {})
+      super
+      @context ||= Context.new
     end
 
-    def intervals(is)
-      @properties[:intervals] = is.map{ |ii| mk_interval(ii[0], ii[1]) }
-      self
+    def as_json(options = {})
+      super(options.merge(except: %w(errors validation_context)))
     end
 
-    def having(&block)
-      having = Having.new.instance_exec(&block)
+    def contains_aggregation?(metric)
+      aggregations.any? { |a| a.name.to_s == metric.to_s }
+    end
+
+    class Builder
+
+      attr_reader :query
+
+      def initialize
+        @query = Query.new
+        query_type(:timeseries)
+        interval(Time.now.utc.beginning_of_day)
+      end
+
+      def query_type(type)
+        @query.queryType = type.to_s
+        self
+      end
+
+      def data_source(source)
+        @query.dataSource = source.split('/').last
+        self
+      end
+
+      def interval(from, to = Time.now)
+        intervals([[from, to]])
+      end
+
+      def intervals(is)
+        @query.intervals = is.map do |from, to|
+          from = from.respond_to?(:iso8601) ? from.iso8601 : ISO8601::DateTime.new(from).to_s
+          to = to.respond_to?(:iso8601) ? to.iso8601 : ISO8601::DateTime.new(to).to_s
+          "#{from}/#{to}"
+        end
+        self
+      end
 
-      if old_having = @properties[:having]
-        if old_having.operator? && old_having.and?
-          new_having = old_having
+      def last(duration)
+        interval(Time.now - duration)
+      end
+
+      def granularity(gran, time_zone = "UTC")
+        gran = gran.to_s
+        if %w(all none minute fifteen_minute thirty_minute hour day).include?(gran)
+          @query.granularity = gran
         else
-          new_having = HavingOperator.new('and')
-          new_having.add(old_having)
+          @query.granularity = Granularity.new({
+            type: 'period',
+            period: gran,
+            timeZone: time_zone
+          })
         end
-        new_having.add(having)
-      else
-        new_having = having
+        self
       end
 
-      @properties[:having] = new_having
-      self
-    end
+      ## query types
 
-    alias_method :[], :interval
+      def metadata
+        query_type(:segmentMetadata)
+        @query.context.useCache = false
+        @query.context.populateCache = false
+        self
+      end
 
-    def granularity(gran, time_zone = nil)
-      gran = gran.to_s
-      case gran
-      when 'none', 'all', 'second', 'minute', 'fifteen_minute', 'thirty_minute', 'hour'
-        @properties[:granularity] = gran
-        return self
-      when 'day'
-        gran = 'P1D'
+      def timeseries
+        query_type(:timeseries)
+        self
       end
 
-      time_zone ||= Time.now.strftime('%Z')
-      # druid doesn't seem to understand 'CEST'
-      # this is a work around
-      time_zone = 'Europe/Berlin' if time_zone == 'CEST'
+      def group_by(*dimensions)
+        query_type(:groupBy)
+        @query.dimensions = dimensions.flatten
+        self
+      end
 
-      @properties[:granularity] = {
-        :type => 'period',
-        :period => gran,
-        :timeZone => time_zone
-      }
-      self
-    end
+      def topn(dimension, metric, threshold)
+        query_type(:topN)
+        @query.dimension = dimension
+        @query.metric = metric
+        @query.threshold = threshold
+        self
+      end
 
-    def to_json
-      @properties.to_json
-    end
+      def search(what = "", dimensions = [], limit = nil)
+        query_type(:search)
+        @query.searchDimensions = dimensions unless dimensions.empty?
+        @query.limit = limit if limit
+        # for now we always sort lexicographic
+        @query.sort = { type: 'lexicographic' }
+        @query.query = {
+          type: "insensitive_contains",
+          value: what
+        }
+        self
+      end
 
-   def limit_spec(limit, columns)
-      @properties[:limitSpec] = {
-        :type => :default,
-        :limit => limit,
-        :columns => order_by_column_spec(columns)
-      }
-      self
-    end 
+      ### aggregations
+      [:count, :long_sum, :double_sum, :min, :max, :hyper_unique].each do |method_name|
+        define_method method_name do |*metrics|
+          metrics.flatten.compact.each do |metric|
+            @query.aggregations << Aggregation.new({
+              type: method_name.to_s.camelize(:lower),
+              name: metric,
+              fieldName: metric,
+            }) unless @query.contains_aggregation?(metric)
+          end
+          self
+        end
+      end
 
-    private
+      def histograms(metrics)
+        metrics.each{|m| histogram(m) }
+        self
+      end
 
-    def order_by_column_spec(columns)
-      columns.map do |dimension, direction|
-        {
-          :dimension => dimension,
-          :direction => direction
-        }
+      def histogram(metric, type = "equalBuckets", args = {})
+        @query.aggregations << Aggregation.new({
+          type: "approxHistogramFold",
+          name: "raw_#{metric}",
+          fieldName: metric,
+        })
+        type = type.dup
+        type[0] = type[0].upcase
+        options = args.dup.merge({
+          name: metric,
+          fieldName: "raw_#{metric}"
+        })
+        @query.postAggregations << ::Druid.const_get("PostAggregationHistogram#{type}").new(options)
+        self
       end
-    end
 
-    def mk_interval(from, to)
-      from = today + from if from.is_a?(Fixnum)
-      to = today + to if to.is_a?(Fixnum)
+      alias_method :sum, :long_sum
 
-      from = DateTime.parse(from.to_s) unless from.respond_to? :iso8601
-      to = DateTime.parse(to.to_s) unless to.respond_to? :iso8601
-      "#{from.iso8601}/#{to.iso8601}"
-    end
+      def cardinality(metric, dimensions, by_row = false)
+        @query.aggregations << Aggregation.new({
+          type: 'cardinality',
+          name: metric,
+          fieldNames: dimensions,
+          byRow: by_row,
+        }) unless @query.contains_aggregation?(metric)
+        self
+      end
 
-    def contains_aggregation?(metric)
-      return false if @properties[:aggregations].nil?
-      @properties[:aggregations].index { |aggregation| aggregation[:fieldName] == metric.to_s }
+      def js_aggregation(metric, columns, functions)
+        @query.aggregations << Aggregation.new({
+          type: 'javascript',
+          name: metric,
+          fieldNames: columns,
+          fnAggregate: functions[:aggregate],
+          fnCombine: functions[:combine],
+          fnReset: functions[:reset],
+        }) unless @query.contains_aggregation?(metric)
+        self
+      end
+
+      ## post aggregations
+
+      def postagg(type = :long_sum, &block)
+        post_agg = PostAggregation.new.instance_exec(&block)
+        @query.postAggregations << post_agg
+        # make sure, the required fields are in the query
+        self.method(type).call(post_agg.field_names)
+        self
+      end
+
+      ## filters
+
+      def filter(hash = nil, type = :in, &block)
+        filter_from_hash(hash, type) if hash
+        filter_from_block(&block) if block
+        self
+      end
+
+      def filter_from_hash(hash, type = :in)
+        last = nil
+        hash.each do |k, values|
+          filter = DimensionFilter.new(dimension: k).__send__(type, values)
+          last = last ? last.&(filter) : filter
+        end
+        @query.filter = @query.filter ? @query.filter.&(last) : last
+      end
+
+      def filter_from_block(&block)
+        filter = Filter.new.instance_exec(&block)
+        @query.filter = @query.filter ? @query.filter.&(filter) : filter
+      end
+
+      ## having
+
+      def having(hash = nil, &block)
+        having_from_hash(hash) if hash
+        having_from_block(&block) if block
+        self
+      end
+
+      def having_from_block(&block)
+        chain_having(Having.new.instance_exec(&block))
+      end
+
+      def having_from_hash(h)
+        chain_having(Having.new(h))
+      end
+
+      def chain_having(having)
+        having = @query.having.chain(having) if @query.having
+        @query.having = having
+        self
+      end
+
+      ### limit/sort
+
+      def limit(limit, columns)
+        @query.limitSpec = {
+          type: :default,
+          limit: limit,
+          columns: columns.map do |dimension, direction|
+            { dimension: dimension, direction: direction }
+          end
+        }
+        self
+      end
     end
-  end
 
+  end
 end