Class: Activecube::Query::Slice

Inherits:
Item
  • Object
show all
Defined in:
lib/activecube/query/slice.rb

Instance Attribute Summary collapse

Attributes inherited from Item

#cube, #definition, #key

Instance Method Summary collapse

Methods inherited from Item

#append_with!

Constructor Details

#initialize(cube, key, definition, parent = nil, selectors = []) ⇒ Slice

Returns a new instance of Slice.



5
6
7
8
9
10
11
12
13
14
15
16
17
 
# File 'lib/activecube/query/slice.rb', line 5

def initialize cube, key, definition, parent = nil, selectors = []
  super cube, key, definition
  @dimension = parent ? parent.dimension : definition
  @parent = parent

  @selectors = selectors
  
  if parent
    raise "Unexpected class #{definition.class.name}" unless definition.kind_of?(Activecube::Field)
    field_methods! if definition.class < Activecube::Field
  end  
  
end

Instance Attribute Details

#dimension ⇒ Object (readonly)

Returns the value of attribute dimension.



4
5
6
 
# File 'lib/activecube/query/slice.rb', line 4

def dimension
  @dimension
end

#parent ⇒ Object (readonly)

Returns the value of attribute parent.



4
5
6
 
# File 'lib/activecube/query/slice.rb', line 4

def parent
  @parent
end

#selectors ⇒ Object (readonly)

Returns the value of attribute selectors.



4
5
6
 
# File 'lib/activecube/query/slice.rb', line 4

def selectors
  @selectors
end

Instance Method Details

#[](arg) ⇒ Object

Raises:



23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/activecube/query/slice.rb', line 23

def [] arg

  key = arg.to_sym

  child = if definition.kind_of?(Activecube::Dimension) && definition.class.fields && (fdef = definition.class.fields[key])
            Activecube::Field.build key, fdef
          elsif definition.kind_of?(Activecube::Field) && (hash = definition.definition).kind_of?(Hash)
            Activecube::Field.build key, hash[key]
          end

  raise Activecube::InputArgumentError, "Field #{key} is not defined for #{definition}" unless child

  if child.kind_of?(Class) && child <= Activecube::Field
    child = child.new key
  elsif !child.kind_of?(Activecube::Field)
    child = Activecube::Field.new(key, child)
  end

  Slice.new cube, key, child, self

end

#alias!(new_key) ⇒ Object 



45
46
47
 
# File 'lib/activecube/query/slice.rb', line 45

def alias! new_key
  self.class.new cube, new_key, definition,  parent, selectors
end

#append_query(model, cube_query, table, query) ⇒ Object 



61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
# File 'lib/activecube/query/slice.rb', line 61

def append_query model, cube_query, table, query

  query = append_with!(model, cube_query, table, query)

  attr_alias = "`#{key.to_s}`"
  expr = (parent || definition.respond_to?(:expression)) ?
             Arel.sql(definition.expression( model, table, self, cube_query) ) :
             table[dimension.class.column_name]

  query = query.project(expr.as(attr_alias))

  if dimension.class.identity
    expr = dimension.class.identity_expression
    group_by_columns.each do |column|

      node =  if column==dimension.class.identity && expr
                Arel.sql(expr).as(column)
              else
                table[column]
              end

      unless query.projections.include?(node)
        query = query.project(node)
      end

      query = query.group( expr ? column : table[column])
    end
  else
    query = query.group(attr_alias)
  end

  if cube_query.orderings.empty?
    query = query.order(attr_alias)
  end

  selectors.each do |selector|
    selector.append_query model, cube_query, table, query
  end

  query
end

#field_methods! ⇒ Object 



107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/activecube/query/slice.rb', line 107

def field_methods!
  excluded = [:expression] + self.class.instance_methods(false)
  definition.class.instance_methods(false).each do |name|
    unless excluded.include?(name)
      define_singleton_method name do |*args|
        definition.send name, *args
        self
      end
    end
  end
end

#group_by_columns ⇒ Object 



53
54
55
56
57
58
59
 
# File 'lib/activecube/query/slice.rb', line 53

def group_by_columns
  if dimension.class.identity
    ([dimension.class.identity] + dimension.class.column_names).uniq
  else
    [key]
  end
end

#required_column_names ⇒ Object 



19
20
21
 
# File 'lib/activecube/query/slice.rb', line 19

def required_column_names
  ((dimension.class.column_names || []) + selectors.map(&:required_column_names) ).flatten.uniq
end

#to_s ⇒ Object 



103
104
105
 
# File 'lib/activecube/query/slice.rb', line 103

def to_s
  parent ? "Dimension #{dimension}[#{super}]" : "Dimension #{super}"
end

#when(*args) ⇒ Object 



49
50
51
 
# File 'lib/activecube/query/slice.rb', line 49

def when *args
  append *args, @selectors, Selector, cube.selectors
end