mondrian-olap 0.3.0 → 0.5.0

data/lib/mondrian/olap/cube.rb

@@ -1,5 +1,20 @@
 module Mondrian
   module OLAP
+    module Annotated
+      private
+
+      def annotations_for(raw_element)
+        @annotations ||= begin
+          annotated = raw_element.unwrap(Java::MondrianOlap::Annotated.java_class)
+          annotations_hash = annotated.getAnnotationMap.to_hash
+          annotations_hash.each do |key, annotation|
+            annotations_hash[key] = annotation.getValue
+          end
+          annotations_hash
+        end
+      end
+    end
+
     class Cube
       def self.get(connection, name)
         if raw_cube = connection.raw_schema.getCubes.get(name)
@@ -12,10 +27,25 @@ module Mondrian
         @raw_cube = raw_cube
       end
 
+      attr_reader :raw_cube
+
       def name
         @name ||= @raw_cube.getName
       end
 
+      def description
+        @description ||= @raw_cube.getDescription
+      end
+
+      def caption
+        @caption ||= @raw_cube.getCaption
+      end
+
+      include Annotated
+      def annotations
+        annotations_for(@raw_cube)
+      end
+
       def dimensions
         @dimenstions ||= @raw_cube.getDimensions.map{|d| Dimension.new(self, d)}
       end
@@ -51,12 +81,20 @@ module Mondrian
         @raw_dimension = raw_dimension
       end
 
-      attr_reader :cube
+      attr_reader :cube, :raw_dimension
 
       def name
         @name ||= @raw_dimension.getName
       end
 
+      def description
+        @description ||= @raw_dimension.getDescription
+      end
+
+      def caption
+        @caption ||= @raw_dimension.getCaption
+      end
+
       def full_name
         @full_name ||= @raw_dimension.getUniqueName
       end
@@ -88,6 +126,12 @@ module Mondrian
           :standard
         end
       end
+
+      include Annotated
+      def annotations
+        annotations_for(@raw_dimension)
+      end
+
     end
 
     class Hierarchy
@@ -96,10 +140,20 @@ module Mondrian
         @raw_hierarchy = raw_hierarchy
       end
 
+      attr_reader :raw_hierarchy
+
       def name
         @name ||= @raw_hierarchy.getName
       end
 
+      def description
+        @description ||= @raw_hierarchy.getDescription
+      end
+
+      def caption
+        @caption ||= @raw_hierarchy.getCaption
+      end
+
       def levels
         @levels = @raw_hierarchy.getLevels.map{|l| Level.new(self, l)}
       end
@@ -137,14 +191,22 @@ module Mondrian
       end
 
       def child_names(*parent_member_segment_names)
-        parent_member = if parent_member_segment_names.empty?
-          return root_member_names unless has_all?
-          all_member
-        else
-          @dimension.cube.member_by_segments(*parent_member_segment_names)
+        Error.wrap_native_exception do
+          parent_member = if parent_member_segment_names.empty?
+            return root_member_names unless has_all?
+            all_member
+          else
+            @dimension.cube.member_by_segments(*parent_member_segment_names)
+          end
+          parent_member && parent_member.children.map{|m| m.name}
         end
-        parent_member && parent_member.children.map{|m| m.name}
       end
+
+      include Annotated
+      def annotations
+        annotations_for(@raw_hierarchy)
+      end
+
     end
 
     class Level
@@ -153,10 +215,20 @@ module Mondrian
         @raw_level = raw_level
       end
 
+      attr_reader :raw_level
+
       def name
         @name ||= @raw_level.getName
       end
 
+      def description
+        @description ||= @raw_level.getDescription
+      end
+
+      def caption
+        @caption ||= @raw_level.getCaption
+      end
+
       def depth
         @raw_level.getDepth
       end
@@ -170,14 +242,24 @@ module Mondrian
           if cardinality >= 0
             cardinality
           else
-            @raw_level.getMembers.size
+            Error.wrap_native_exception do
+              @raw_level.getMembers.size
+            end
           end
         end
       end
 
       def members
-        @raw_level.getMembers.map{|m| Member.new(m)}
+        Error.wrap_native_exception do
+          @raw_level.getMembers.map{|m| Member.new(m)}
+        end
       end
+
+      include Annotated
+      def annotations
+        annotations_for(@raw_level)
+      end
+
     end
 
     class Member
@@ -185,18 +267,32 @@ module Mondrian
         @raw_member = raw_member
       end
 
+      attr_reader :raw_member
+
       def name
-        @raw_member.getName
+        @name ||= @raw_member.getName
       end
 
       def full_name
-        @raw_member.getUniqueName
+        @full_name ||= @raw_member.getUniqueName
+      end
+
+      def caption
+        @caption ||= @raw_member.getCaption
       end
 
       def calculated?
         @raw_member.isCalculated
       end
 
+      def calculated_in_query?
+        @raw_member.isCalculatedInQuery
+      end
+
+      def visible?
+        @raw_member.isVisible
+      end
+
       def all_member?
         @raw_member.isAll
       end
@@ -226,26 +322,69 @@ module Mondrian
       end
 
       def children
-        @raw_member.getChildMembers.map{|m| Member.new(m)}
+        Error.wrap_native_exception do
+          @raw_member.getChildMembers.map{|m| Member.new(m)}
+        end
       end
 
       def descendants_at_level(level)
-        raw_level = @raw_member.getLevel
-        raw_levels = raw_level.getHierarchy.getLevels
-        current_level_index = raw_levels.indexOf(raw_level)
-        descendants_level_index = raw_levels.indexOfName(level)
+        Error.wrap_native_exception do
+          raw_level = @raw_member.getLevel
+          raw_levels = raw_level.getHierarchy.getLevels
+          current_level_index = raw_levels.indexOf(raw_level)
+          descendants_level_index = raw_levels.indexOfName(level)
+
+          return nil unless descendants_level_index > current_level_index
+
+          members = [self]
+          (descendants_level_index - current_level_index).times do
+            members = members.map do |member|
+              member.children
+            end.flatten
+          end
+          members
+        end
+      end
+
+      def property_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyValue(property)
+        end
+      end
+
+      def property_formatted_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyFormattedValue(property)
+        end
+      end
+
+      include Annotated
+      def annotations
+        annotations_for(@raw_member)
+      end
 
-        return nil unless descendants_level_index > current_level_index
+      def format_string
+        format_exp = property_value('FORMAT_EXP')
+        if format_exp && format_exp =~ /\A"(.*)"\z/
+          format_exp = $1
+        end
+        if format_exp && !format_exp.empty?
+          format_exp
+        end
+      end
 
-        members = [self]
-        (descendants_level_index - current_level_index).times do
-          members = members.map do |member|
-            member.children
-          end.flatten
+      def cell_formatter_name
+        if dimension_type == :measures
+          cube_measure = raw_member.unwrap(Java::MondrianOlap::Member.java_class)
+          if value_formatter = cube_measure.getFormatter
+            f = value_formatter.java_class.declared_field('cf')
+            f.accessible = true
+            cf = f.value(value_formatter)
+            cf.class.name.split('::').last.gsub(/Udf\z/, '')
+          end
         end
-        members
       end
 
     end
   end
-end
+end

data/lib/mondrian/olap/error.rb

@@ -0,0 +1,57 @@
+module Mondrian
+  module OLAP
+
+    NATIVE_ERROR_REGEXP = /^(org\.olap4j\.|mondrian\.|java\.lang\.reflect\.UndeclaredThrowableException\: Mondrian Error\:)/
+
+    class Error < StandardError
+      # root_cause will be nil if there is no cause for wrapped native error
+      # root_cause_message will have either root_cause message or wrapped native error message
+      attr_reader :native_error, :root_cause_message, :root_cause
+
+      def initialize(native_error)
+        @native_error = native_error
+        get_root_cause
+        super(native_error.message)
+        add_root_cause_to_backtrace
+      end
+
+      def self.wrap_native_exception
+        yield
+      rescue NativeException => e
+        if e.message =~ NATIVE_ERROR_REGEXP
+          raise Mondrian::OLAP::Error.new(e)
+        else
+          raise
+        end
+      end
+
+      private
+
+      def get_root_cause
+        @root_cause = nil
+        e = @native_error
+        while e.respond_to?(:cause) && (cause = e.cause)
+          @root_cause = e = cause
+        end
+        message = e.message
+        if message =~ /\AMondrian Error:(.*)\Z/m
+          message = $1
+        end
+        @root_cause_message = message
+      end
+
+      def add_root_cause_to_backtrace
+        bt = @native_error.backtrace
+        if @root_cause
+          root_cause_bt = Array(@root_cause.backtrace)
+          root_cause_bt[0,5].reverse.each do |bt_line|
+            bt.unshift "root cause:   #{bt_line}"
+          end
+          bt.unshift "root cause: #{@root_cause.java_class.name}: #{@root_cause.message.chomp}"
+        end
+        set_backtrace bt
+      end
+
+    end
+  end
+end

data/lib/mondrian/olap/query.rb

@@ -43,19 +43,23 @@ module Mondrian
         RUBY
       end
 
-      def crossjoin(*axis_members)
-        raise ArgumentError, "cannot use crossjoin method before axis or with_set method" unless @current_set
-        raise ArgumentError, "specify list of members for crossjoin method" if axis_members.empty?
-        members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
-        @current_set.replace [:crossjoin, @current_set.clone, members]
-        self
+      %w(crossjoin nonempty_crossjoin).each do |method|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{method}(*axis_members)
+            raise ArgumentError, "cannot use #{method} method before axis or with_set method" unless @current_set
+            raise ArgumentError, "specify list of members for #{method} method" if axis_members.empty?
+            members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
+            @current_set.replace [:#{method}, @current_set.clone, members]
+            self
+          end
+        RUBY
       end
 
       def except(*axis_members)
         raise ArgumentError, "cannot use except method before axis or with_set method" unless @current_set
         raise ArgumentError, "specify list of members for except method" if axis_members.empty?
         members = axis_members.length == 1 && axis_members[0].is_a?(Array) ? axis_members[0] : axis_members
-        if @current_set[0] == :crossjoin
+        if [:crossjoin, :nonempty_crossjoin].include? @current_set[0]
           @current_set[2] = [:except, @current_set[2], members]
         else
           @current_set.replace [:except, @current_set.clone, members]
@@ -119,7 +123,7 @@ module Mondrian
         raise ArgumentError, "cannot use hierarchize method before axis or with_set method" unless @current_set
         order = order && order.to_s.upcase
         raise ArgumentError, "invalid hierarchize order #{order.inspect}" unless order.nil? || order == 'POST'
-        if all.nil? && @current_set[0] == :crossjoin
+        if all.nil? && [:crossjoin, :nonempty_crossjoin].include?(@current_set[0])
           @current_set[2] = [:hierarchize, @current_set[2]]
           @current_set[2] << order if order
         else
@@ -185,7 +189,15 @@ module Mondrian
         # definition of calculated member
         else
           member_definition = @with.last
-          options = params.last.is_a?(Hash) ? params.pop : nil
+          if params.last.is_a?(Hash)
+            options = params.pop
+            # if formatter does not include . then it should be ruby formatter name
+            if (formatter = options[:cell_formatter]) && !formatter.include?('.')
+              options = options.merge(:cell_formatter => Mondrian::OLAP::Schema::CellFormatter.new(formatter).class_name)
+            end
+          else
+            options = nil
+          end
           raise ArgumentError, "cannot use 'as' method before with_member method" unless member_definition &&
             member_definition[0] == :member && member_definition.length == 2
           raise ArgumentError, "calculated member definition should be single expression" unless params.length == 1
@@ -205,7 +217,19 @@ module Mondrian
       end
 
       def execute
-        @connection.execute to_mdx
+        Error.wrap_native_exception do
+          @connection.execute to_mdx
+        end
+      end
+
+      def execute_drill_through(options = {})
+        Error.wrap_native_exception do
+          drill_through_mdx = "DRILLTHROUGH "
+          drill_through_mdx << "MAXROWS #{options[:max_rows]} " if options[:max_rows]
+          drill_through_mdx << to_mdx
+          drill_through_mdx << " RETURN #{Array(options[:return]).join(',')}" if options[:return]
+          @connection.execute_drill_through drill_through_mdx
+        end
       end
 
       private
@@ -220,7 +244,13 @@ module Mondrian
             options = definition[3]
             options_string = ''
             options && options.each do |option, value|
-              options_string << ", #{option.to_s.upcase} = #{quote_value(value)}"
+              option_name = case option
+              when :caption
+                '$caption'
+              else
+                option.to_s.upcase
+              end
+              options_string << ", #{option_name} = #{quote_value(value)}"
             end
             "MEMBER #{member_name} AS #{quote_value(expression)}#{options_string}"
           when :set
@@ -251,12 +281,17 @@ module Mondrian
       }
 
       def members_to_mdx(members)
-        if members.length == 1
+        # if only one member which does not end with ]
+        # then assume it is expression which returns set
+        # TODO: maybe always include also single expressions in {...} to avoid some edge cases?
+        if members.length == 1 && members[0][-1,1] != ']'
           members[0]
         elsif members[0].is_a?(Symbol)
           case members[0]
           when :crossjoin
             "CROSSJOIN(#{members_to_mdx(members[1])}, #{members_to_mdx(members[2])})"
+          when :nonempty_crossjoin
+            "NONEMPTYCROSSJOIN(#{members_to_mdx(members[1])}, #{members_to_mdx(members[2])})"
           when :except
             "EXCEPT(#{members_to_mdx(members[1])}, #{members_to_mdx(members[2])})"
           when :nonempty
@@ -294,13 +329,13 @@ module Mondrian
         if @where[0].is_a?(Symbol) ||
             @where.length > 1 && @where.map{|full_name| extract_dimension_name(full_name)}.uniq.length == 1
           members_to_mdx(@where)
-        # generate tupple MDX expression
+        # generate tuple MDX expression
         else
-          where_to_mdx_tupple
+          where_to_mdx_tuple
         end
       end
 
-      def where_to_mdx_tupple
+      def where_to_mdx_tuple
         mdx = '('
         mdx << @where.map do |condition|
           condition
@@ -322,10 +357,10 @@ module Mondrian
       end
 
       def extract_dimension_name(full_name)
-        if full_name =~ /\A\[([^\]]+)\]/
+        if full_name =~ /\A[^\[]*\[([^\]]+)\]/
           $1
         end
       end
     end
   end
-end
+end