Class: Bmg::Summarizer

Inherits:
Object
  • Object
show all
Defined in:
lib/bmg/summarizer.rb,
lib/bmg/summarizer/avg.rb,
lib/bmg/summarizer/max.rb,
lib/bmg/summarizer/min.rb,
lib/bmg/summarizer/sum.rb,
lib/bmg/summarizer/count.rb,
lib/bmg/summarizer/concat.rb,
lib/bmg/summarizer/stddev.rb,
lib/bmg/summarizer/by_proc.rb,
lib/bmg/summarizer/collect.rb,
lib/bmg/summarizer/distinct.rb,
lib/bmg/summarizer/multiple.rb,
lib/bmg/summarizer/variance.rb,
lib/bmg/summarizer/percentile.rb

Overview

Summarizer.

This class provides a basis for implementing aggregation operators.

Aggregation operators are made available through factory methods on the Summarizer class itself:

Summarizer.count
Summarizer.sum(:qty)
Summarizer.sum{|t| t[:qty] * t[:price] }

Once built, summarizers can be used either in black-box or white-box modes.

relation = ...
agg = Summarizer.sum(:qty)

# Black box mode:
result = agg.summarize(relation)

# White box mode:
memo = agg.least
relation.each do |tuple|
  memo = agg.happens(memo, tuple)
end
result = agg.finalize(memo)

Direct Known Subclasses

Avg, ByProc, Collect, Concat, Count, Distinct, Max, Min, Multiple, Percentile, Sum, Variance

Defined Under Namespace

Classes: Avg, ByProc, Collect, Concat, Count, Distinct, Max, Min, Multiple, Percentile, Stddev, Sum, Variance

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(*args, &block) ⇒ Summarizer

Creates an Summarizer instance.

Private method, please use the factory methods



40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/bmg/summarizer.rb', line 40

def initialize(*args, &block)
  @options = default_options
  args.push(block) if block
  args.each do |arg|
    case arg
    when Symbol, Proc then @functor = arg
    when Hash         then @options = @options.merge(arg)
    else
      raise ArgumentError, "Unexpected `#{arg}`"
    end
  end
end

Instance Attribute Details

#functor ⇒ Object (readonly)

Returns the underlying functor, either a Symbol or a Proc.

Returns:

  • the underlying functor, either a Symbol or a Proc



35
36
37
 
# File 'lib/bmg/summarizer.rb', line 35

def functor
  @functor
end

#options ⇒ Object (readonly)

Returns Aggregation options as a Hash.

Returns:

  • Aggregation options as a Hash



32
33
34
 
# File 'lib/bmg/summarizer.rb', line 32

def options
  @options
end

Class Method Details

.avg(*args, &bl) ⇒ Object

Factors an average summarizer



31
32
33
 
# File 'lib/bmg/summarizer/avg.rb', line 31

def self.avg(*args, &bl)
  Avg.new(*args, &bl)
end

.by_proc(least = nil, proc = nil, &bl) ⇒ Object

Factors a distinct summarizer



35
36
37
38
 
# File 'lib/bmg/summarizer/by_proc.rb', line 35

def self.by_proc(least = nil, proc = nil, &bl)
  least, proc = nil, least if least.is_a?(Proc)
  ByProc.new(least, proc || bl)
end

.collect(*args, &bl) ⇒ Object

Factors a collect summarizer



26
27
28
 
# File 'lib/bmg/summarizer/collect.rb', line 26

def self.collect(*args, &bl)
  Collect.new(*args, &bl)
end

.concat(*args, &bl) ⇒ Object

Factors a concatenation summarizer



37
38
39
 
# File 'lib/bmg/summarizer/concat.rb', line 37

def self.concat(*args, &bl)
  Concat.new(*args, &bl)
end

.count(*args, &bl) ⇒ Object

Factors a count summarizer



26
27
28
 
# File 'lib/bmg/summarizer/count.rb', line 26

def self.count(*args, &bl)
  Count.new(*args, &bl)
end

.distinct(*args, &bl) ⇒ Object

Factors a distinct summarizer



31
32
33
 
# File 'lib/bmg/summarizer/distinct.rb', line 31

def self.distinct(*args, &bl)
  Distinct.new(*args, &bl)
end

.max(*args, &bl) ⇒ Object

Factors a max summarizer



26
27
28
 
# File 'lib/bmg/summarizer/max.rb', line 26

def self.max(*args, &bl)
  Max.new(*args, &bl)
end

.min(*args, &bl) ⇒ Object

Factors a min summarizer



26
27
28
 
# File 'lib/bmg/summarizer/min.rb', line 26

def self.min(*args, &bl)
  Min.new(*args, &bl)
end

.multiple(defs) ⇒ Object

Factors a distinct summarizer



41
42
43
 
# File 'lib/bmg/summarizer/multiple.rb', line 41

def self.multiple(defs)
  Multiple.new(defs)
end

.percentile(*args, &bl) ⇒ Object

Factors an average summarizer



42
43
44
 
# File 'lib/bmg/summarizer/percentile.rb', line 42

def self.percentile(*args, &bl)
  Percentile.new(*args, &bl)
end

.stddev(*args, &bl) ⇒ Object

Factors a standard deviation summarizer



21
22
23
 
# File 'lib/bmg/summarizer/stddev.rb', line 21

def self.stddev(*args, &bl)
  Stddev.new(*args, &bl)
end

.sum(*args, &bl) ⇒ Object

Factors a sum summarizer



26
27
28
 
# File 'lib/bmg/summarizer/sum.rb', line 26

def self.sum(*args, &bl)
  Sum.new(*args, &bl)
end

.summarization(defs) ⇒ Object

Converts some summarization definitions to a Hash of summarizers.



55
56
57
58
59
60
61
62
63
64
65
66
 
# File 'lib/bmg/summarizer.rb', line 55

def self.summarization(defs)
  Hash[defs.map{|k,v|
    summarizer = case v
    when Summarizer then v
    when Symbol     then Summarizer.send(v, k)
    when Proc       then Summarizer.by_proc(&v)
    else
      raise ArgumentError, "Unexpected summarizer #{k} => #{v}"
    end
    [ k, summarizer ]
  }]
end

.variance(*args, &bl) ⇒ Object

Factors a variance summarizer



37
38
39
 
# File 'lib/bmg/summarizer/variance.rb', line 37

def self.variance(*args, &bl)
  Variance.new(*args, &bl)
end

Instance Method Details

#finalize(memo) ⇒ Object

This method finalizes an aggregation.

Argument memo is either least or the result of aggregating through happens. The default implementation simply returns memo. The method is intended to be overriden for complex aggregations that need statefull information such as ‘avg`.

Parameters:

  • memo (Object) —

    the current aggregation value

Returns:

  • (Object) —

    the aggregation value, as finalized



129
130
131
 
# File 'lib/bmg/summarizer.rb', line 129

def finalize(memo)
  memo
end

#happens(memo, tuple) ⇒ Object

This method is called on each aggregated tuple and must return an updated memo value. It can be seen as the block typically given to Enumerable.inject.

The default implementation collects the pre-value on the tuple and delegates to _happens.

Parameters:

  • memo —

    the current aggregation value

  • the —

    current iterated tuple

Returns:

  • updated memo value



97
98
99
100
101
102
103
104
105
106
107
108
109
 
# File 'lib/bmg/summarizer.rb', line 97

def happens(memo, tuple)
  value = case @functor
  when Proc
    @functor.call(tuple)
  when NilClass
    tuple
  when Symbol
    tuple[@functor]
  else
    tuple[@functor]
  end
  _happens(memo, value)
end

#least ⇒ Object

Returns the least value, which is the one to use on an empty set.

This method is intended to be overriden by subclasses; default implementation returns nil.

Returns:

  • the least value for this summarizer



83
84
85
 
# File 'lib/bmg/summarizer.rb', line 83

def least
  nil
end

#summarize(enum) ⇒ Object

Summarizes an enumeration of tuples.

Parameters:

  • an —

    enumerable of tuples

Returns:

  • the computed summarization value



137
138
139
 
# File 'lib/bmg/summarizer.rb', line 137

def summarize(enum)
  finalize(enum.inject(least){|m,t| happens(m, t) })
end

#to_summarizer_name ⇒ Object

Returns the canonical summarizer name



142
143
144
 
# File 'lib/bmg/summarizer.rb', line 142

def to_summarizer_name
  self.class.name.downcase[/::([a-z]+)$/, 1].to_sym
end