Class: Olap::Xmla::Response

Inherits:
Object
  • Object
show all
Defined in:
lib/olap/xmla/response.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(response, mdx) ⇒ Response

Returns a new instance of Response.



5
6
7
8
 
# File 'lib/olap/xmla/response.rb', line 5

def initialize response, mdx
  @response = response
  @mdx = mdx
end

Instance Attribute Details

#mdx ⇒ Object (readonly)

Returns the value of attribute mdx.



3
4
5
 
# File 'lib/olap/xmla/response.rb', line 3

def mdx
  @mdx
end

#response ⇒ Object (readonly)

Returns the value of attribute response.



3
4
5
 
# File 'lib/olap/xmla/response.rb', line 3

def response
  @response
end

Instance Method Details

#column_values(column_num) ⇒ Object

query a colum of the result

Example:

>> response.column_values 1

=> [30.0, 1025.0, 884.0, 543.0,...



103
104
105
106
107
108
109
110
111
 
# File 'lib/olap/xmla/response.rb', line 103

def column_values column_num

  rows.collect{|row|
    row[:values].detect{|value|
      value[:colnum]==column_num
    }[:value].to_f
  }

end

#column_values_aggregate(dimension_aggr_index = 0) ⇒ Object

Aggregate result by one of the columns



114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
 
# File 'lib/olap/xmla/response.rb', line 114

def column_values_aggregate dimension_aggr_index = 0

  result = []
  index = {}

  rows.each{|row|
    label = row[:labels][dimension_aggr_index]

    if i = index[label]
      for j in 0..result[i][:values].count-1
        result[i][:values][j] += row[:values][j][:value].to_f
      end
    else
      index[label] = result.count
      result << {
          rownum: result.count + 1,
          label: label,
          values: row[:values].collect{|v| v[:value].to_f }
      }
    end
  }

  result
end

#dimensions ⇒ Object

Collection of dimensions in response

  • :name the name of dimension

  • :caption display name of dimension



34
35
36
37
38
39
40
41
 
# File 'lib/olap/xmla/response.rb', line 34

def dimensions
  [response[:olap_info][:axes_info][:axis_info][1][:hierarchy_info]].flatten.collect{|m|
    {
        name: m[:@name],
        caption: m[:@caption]
    }
  }
end

#has_data? ⇒ Boolean

Returns true if the response has any data

Returns:

  • (Boolean) 


11
12
13
 
# File 'lib/olap/xmla/response.rb', line 11

def has_data?
  not response[:cell_data][:cell].empty?
end

#measures ⇒ Object

Collection of measures in response

  • :name the name of measure

  • :caption display name of measure



20
21
22
23
24
25
26
27
 
# File 'lib/olap/xmla/response.rb', line 20

def measures
  [response[:axes][:axis][0][:tuples][:tuple]].flatten.collect{|m|
    {
        name: (m[:member].kind_of?(Array) ? m[:member].collect { |x| x[:u_name]}.join(', ') : m[:member][:u_name]),
        caption: (m[:member].kind_of?(Array) ? m[:member].collect { |x| x[:caption]}.join(', ') : m[:member][:caption]),
    }
  }
end

#rows ⇒ Object

Collection of result rows

  • rownum number of row ( 1… N)

  • labels - array of tuples per the row

    value - the value of tuple
name - the name of tuple

  • values - the values array

    measure - metric name
value - metric value
fmt_value - formatted metric value
colnum - column number ( 1..N)



54
55
56
57
58
59
60
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
 
# File 'lib/olap/xmla/response.rb', line 54

def rows

  return [] unless response[:cell_data]

  measures = [response[:axes][:axis][0][:tuples][:tuple]].flatten
  cells = [response[:cell_data][:cell]].flatten

  cell_ordinal = 0
  cell_index = 0
  rownum = 0

  [response[:axes][:axis][1][:tuples][:tuple]].flatten.collect{ |tuple|
    rownum += 1
    colnum = 0
    tuple_member = [tuple[:member]].flatten
    {  rownum: rownum,
       labels: tuple_member.collect{|member|
         value = member[:caption]
         value = nil if value=='#null'
         {value: value, name: member[:@hierarchy]}
       },
       values: measures.collect{|m|

         colnum += 1

         measure = m[:member].kind_of?(Array) ? m[:member].collect{|m| m[:u_name]} : m[:member][:u_name]
         if (cell=cells[cell_index]) && cell[:@cell_ordinal].to_i==cell_ordinal
           cell_index += 1
           cell_ordinal += 1
           { colnum: colnum, measure: measure, value: cell[:value], fmt_value: cell[:fmt_value]}
         else
           cell_ordinal += 1
           { colnum: colnum, measure: measure, value: nil, fmt_value: nil}
         end

       }

    }
  }

end

#to_hash ⇒ Object

Convert the response to hash keys of hash are values of tuples values of hash are values of metrics

Example:

response.to_hash
=> {["2014", "05/11/2014"]=>[30.0, 27.0, 0.0], ["2014", "06/11/2014"]=>[1025.0, 688.0, 73.0]



148
149
150
151
152
153
154
155
156
 
# File 'lib/olap/xmla/response.rb', line 148

def to_hash
  Hash[rows.collect{|row|
         [
             row[:labels].collect{|l| l[:value].nil? ? nil : l[:value] },
             row[:values].collect{|l| (l.nil? || l[:value].nil?) ? 0.0 : l[:value].to_f },
         ]

       }]
end