mondrian-olap 0.8.0 → 1.1.0

data/lib/mondrian/olap/query.rb

@@ -79,7 +79,7 @@ module Mondrian
         self
       end
 
-      def filter(condition, options={})
+      def filter(condition, options = {})
         raise ArgumentError, "cannot use filter method before axis or with_set method" unless @current_set
         @current_set.replace [:filter, @current_set.clone, condition]
         @current_set << options[:as] if options[:as]
@@ -138,7 +138,7 @@ module Mondrian
         end
       end
 
-      def hierarchize(order=nil, all=nil)
+      def hierarchize(order = nil, all = nil)
         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'
@@ -152,7 +152,7 @@ module Mondrian
         self
       end
 
-      def hierarchize_all(order=nil)
+      def hierarchize_all(order = nil)
         hierarchize(order, :all)
       end
 
@@ -236,19 +236,15 @@ module Mondrian
       end
 
       def execute(parameters = {})
-        Error.wrap_native_exception do
-          @connection.execute to_mdx, parameters
-        end
+        @connection.execute to_mdx, parameters
       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
+        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
 
       private
@@ -300,10 +296,10 @@ module Mondrian
       }
 
       def members_to_mdx(members)
-        # if only one member which does not end with ]
+        # if only one member which does not end with ] or .Item(...)
         # 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] != ']'
+        if members.length == 1 && members[0] !~ /(\]|\.Item\(\d+\))\z/i
           members[0]
         elsif members[0].is_a?(Symbol)
           case members[0]
@@ -380,8 +376,9 @@ module Mondrian
       end
 
       def extract_dimension_name(full_name)
-        if full_name =~ /\A[^\[]*\[([^\]]+)\]/
-          $1
+        # "[Foo [Bar]]].[Baz]" =>  "Foo [Bar]"
+        if full_name
+          full_name.gsub(/\A\[|\]\z/, '').split('].[').first.try(:gsub, ']]', ']')
         end
       end
     end

data/lib/mondrian/olap/result.rb

@@ -3,12 +3,14 @@ require 'bigdecimal'
 module Mondrian
   module OLAP
     class Result
-      def initialize(connection, raw_cell_set)
+      def initialize(connection, raw_cell_set, options = {})
         @connection = connection
         @raw_cell_set = raw_cell_set
+        @profiling_handler = options[:profiling_handler]
+        @total_duration = options[:total_duration]
       end
 
-      attr_reader :raw_cell_set
+      attr_reader :raw_cell_set, :profiling_handler, :total_duration
 
       def axes_count
         axes.length
@@ -105,6 +107,32 @@ module Mondrian
         end
       end
 
+      def profiling_plan
+        if profiling_handler
+          @raw_cell_set.close
+          if plan = profiling_handler.plan
+            plan.gsub("\r\n", "\n")
+          end
+        end
+      end
+
+      def profiling_timing
+        if profiling_handler
+          @raw_cell_set.close
+          profiling_handler.timing
+        end
+      end
+
+      def profiling_mark_full(name, duration)
+        profiling_timing && profiling_timing.markFull(name, duration)
+      end
+
+      def profiling_timing_string
+        if profiling_timing && (timing_string = profiling_timing.toString)
+          timing_string.gsub("\r\n", "\n")
+        end
+      end
+
       # Specify drill through cell position, for example, as
       #   :row => 0, :cell => 1
       # Specify max returned rows with :max_rows parameter
@@ -177,7 +205,7 @@ module Mondrian
           if @raw_result_set.next
             row_values = []
             column_types.each_with_index do |column_type, i|
-              row_values << Result.java_to_ruby_value(@raw_result_set.getObject(i+1), column_type)
+              row_values << Result.java_to_ruby_value(@raw_result_set.getObject(i + 1), column_type)
             end
             row_values
           else
@@ -248,24 +276,28 @@ module Mondrian
           sql_non_extended = rolap_cell.getDrillThroughSQL(return_expressions, false)
           sql_extended = rolap_cell.getDrillThroughSQL(return_expressions, true)
 
-          if sql_non_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+          if sql_non_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/m
+            non_extended_from = $2
+            non_extended_where = $3
+          # the latest Mondrian version sometimes returns sql_non_extended without order by
+          elsif sql_non_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/m
             non_extended_from = $2
             non_extended_where = $3
           # if drill through total measure with just all members selection
-          elsif sql_non_extended =~ /\Aselect (.*) from (.*)\Z/
+          elsif sql_non_extended =~ /\Aselect (.*) from (.*)\Z/m
             non_extended_from = $2
             non_extended_where = "1 = 1" # dummy true condition
           else
             raise ArgumentError, "cannot parse drill through SQL: #{sql_non_extended}"
           end
 
-          if sql_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+          if sql_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/m
             extended_select = $1
             extended_from = $2
             extended_where = $3
             extended_order_by = $4
           # if only measures are selected then there will be no order by
-          elsif sql_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/
+          elsif sql_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/m
             extended_select = $1
             extended_from = $2
             extended_where = $3
@@ -282,13 +314,14 @@ module Mondrian
 
             return_fields.size.times do |i|
               column_alias = return_fields[i][:column_alias]
-              new_select_columns << if column_expression = return_fields[i][:column_expression]
-                new_order_by_columns << column_expression
-                new_group_by_columns << column_expression if group_by && return_fields[i][:type] != :measure
-                "#{column_expression} AS #{column_alias}"
-              else
-                "'' AS #{column_alias}"
-              end
+              new_select_columns <<
+                if column_expression = return_fields[i][:column_expression]
+                  new_order_by_columns << column_expression
+                  new_group_by_columns << column_expression if group_by && return_fields[i][:type] != :measure
+                  "#{column_expression} AS #{column_alias}"
+                else
+                  "'' AS #{column_alias}"
+                end
             end
 
             new_select = new_select_columns.join(', ')
@@ -361,7 +394,7 @@ module Mondrian
                   end
               end
 
-              return_fields.size.times do | i |
+              return_fields.size.times do |i|
                 member_full_name = return_fields[i][:member_full_name]
                 begin
                   segment_list = Java::MondrianOlap::Util.parseIdentifier(member_full_name)
@@ -381,34 +414,34 @@ module Mondrian
                 end
 
                 return_fields[i][:column_expression] = case return_fields[i][:type]
-                  when :name
-                    if level_or_member.respond_to? :getNameExp
-                      level_or_member.getNameExp.getExpression sql_query
-                    end
-                  when :property
-                    if property = level_or_member.getProperties.to_a.detect{|p| p.getName == return_fields[i][:name]}
-                      # property.getExp is a protected method therefore
-                      # use a workaround to get the value from the field
-                      f = property.java_class.declared_field("exp")
-                      f.accessible = true
-                      if column = f.value(property)
-                        column.getExpression sql_query
-                      end
+                when :name
+                  if level_or_member.respond_to? :getNameExp
+                    level_or_member.getNameExp.getExpression sql_query
+                  end
+                when :property
+                  if property = level_or_member.getProperties.to_a.detect{|p| p.getName == return_fields[i][:name]}
+                    # property.getExp is a protected method therefore
+                    # use a workaround to get the value from the field
+                    f = property.java_class.declared_field("exp")
+                    f.accessible = true
+                    if column = f.value(property)
+                      column.getExpression sql_query
                     end
+                  end
+                else
+                  if level_or_member.respond_to? :getKeyExp
+                    return_fields[i][:type] = :key
+                    level_or_member.getKeyExp.getExpression sql_query
                   else
-                    if level_or_member.respond_to? :getKeyExp
-                      return_fields[i][:type] = :key
-                      level_or_member.getKeyExp.getExpression sql_query
+                    return_fields[i][:type] = :measure
+                    column_expression = level_or_member.getMondrianDefExpression.getExpression sql_query
+                    if params[:group_by]
+                      level_or_member.getAggregator.getExpression column_expression
                     else
-                      return_fields[i][:type] = :measure
-                      column_expression = level_or_member.getMondrianDefExpression.getExpression sql_query
-                      if params[:group_by]
-                        level_or_member.getAggregator.getExpression column_expression
-                      else
-                        column_expression
-                      end
+                      column_expression
                     end
                   end
+                end
 
                 column_alias = if return_fields[i][:type] == :key
                   "#{return_fields[i][:name]} (Key)"
@@ -479,7 +512,7 @@ module Mondrian
         @axes ||= @raw_cell_set.getAxes
       end
 
-      def axis_positions(map_method, join_with=false)
+      def axis_positions(map_method, join_with = false)
         axes.map do |axis|
           axis.getPositions.map do |position|
             names = position.getMembers.map do |member|
@@ -508,7 +541,7 @@ module Mondrian
         :chapters => 4
       }.freeze
 
-      def recursive_values(value_method, axes_sequence, current_index, cell_params=[])
+      def recursive_values(value_method, axes_sequence, current_index, cell_params = [])
         if axis_number = axes_sequence[current_index]
           axis_number = AXIS_SYMBOL_TO_NUMBER[axis_number] if axis_number.is_a?(Symbol)
           positions_size = axes[axis_number].getPositions.size

data/lib/mondrian/olap/schema.rb

@@ -497,6 +497,7 @@ module Mondrian
       end
 
       class Annotation < SchemaElement
+        attributes :name
         content :text
       end
 

data/lib/mondrian/olap/schema_element.rb

@@ -67,14 +67,30 @@ module Mondrian
           attr_reader pluralize(name).to_sym
           class_eval <<-RUBY, __FILE__, __LINE__ + 1
             def #{name}(name=nil, attributes = {}, &block)
-              @#{pluralize(name)} << Schema::#{camel_case(name)}.new(name, attributes, self, &block)
+              new_element = Schema::#{camel_case(name)}.new(name, attributes, self, &block)
+              @#{pluralize(name)} << new_element
+              new_element
             end
           RUBY
+          if name == :annotations
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def annotations_hash
+                hash = {}
+                @annotationss.each do |annotations|
+                  annotations.annotations.each do |annotation|
+                    hash[annotation.name] = annotation.content
+                  end
+                end
+                hash
+              end
+            RUBY
+          end
         end
       end
 
-      def self.content(type=nil)
+      def self.content(type = nil)
         return @content if type.nil?
+        attr_reader :content
         @content = type
       end
 
@@ -86,7 +102,7 @@ module Mondrian
         @xml_fragments << string
       end
 
-      def to_xml(options={})
+      def to_xml(options = {})
         options[:upcase_data_dictionary] = @upcase_data_dictionary unless @upcase_data_dictionary.nil?
         Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |xml|
           add_to_xml(xml, options)
@@ -125,7 +141,7 @@ module Mondrian
       def xmlized_attributes(options)
         # data dictionary values should be in uppercase if schema defined with :upcase_data_dictionary => true
         # or by default when using Oracle or LucidDB driver (can be overridden by :upcase_data_dictionary => false)
-        upcase_attributes = if options[:upcase_data_dictionary].nil? && %w(oracle luciddb).include?(options[:driver]) ||
+        upcase_attributes = if options[:upcase_data_dictionary].nil? && %w(oracle luciddb snowflake).include?(options[:driver]) ||
                             options[:upcase_data_dictionary]
           self.class.data_dictionary_names
         else

data/lib/mondrian/olap/schema_udf.rb

@@ -17,7 +17,7 @@ module Mondrian
 
         def coffeescript_function(arguments_string, text)
           # construct function to ensure that last expression is returned
-          coffee_text = "#{arguments_string} ->\n" << text.gsub(/^/,'  ')
+          coffee_text = "#{arguments_string} ->\n" << text.gsub(/^/, '  ')
           javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
           # remove function definition first and last lines
           javascript_text = javascript_text.strip.lines.to_a[1..-2].join
@@ -67,7 +67,7 @@ module Mondrian
         end
 
         def ruby_formatter_java_class_name(name)
-          "rubyobj.#{self.class.name.gsub('::','.')}.#{ruby_formatter_name_to_class_name(name)}"
+          "rubyobj.#{self.class.name.gsub('::', '.')}.#{ruby_formatter_name_to_class_name(name)}"
         end
 
       end
@@ -180,19 +180,21 @@ JS
           add_method_signature("getSyntax", [Java::mondrian.olap.Syntax])
 
           UDF_SCALAR_TYPES = {
-            "Numeric" => Java::mondrian.olap.type.NumericType,
-            "String" => Java::mondrian.olap.type.StringType,
-            "Boolean" => Java::mondrian.olap.type.BooleanType,
-            "DateTime" => Java::mondrian.olap.type.DateTimeType,
-            "Decimal" => Java::mondrian.olap.type.DecimalType,
-            "Scalar" => Java::mondrian.olap.type.ScalarType
+            'Numeric' => Java::mondrian.olap.type.NumericType,
+            'String' => Java::mondrian.olap.type.StringType,
+            'Boolean' => Java::mondrian.olap.type.BooleanType,
+            'DateTime' => Java::mondrian.olap.type.DateTimeType,
+            'Decimal' => Java::mondrian.olap.type.DecimalType,
+            'Scalar' => Java::mondrian.olap.type.ScalarType
           }
           UDF_OTHER_TYPES = {
-            "Member" => Java::mondrian.olap.type.MemberType::Unknown,
-            "Set" => Java::mondrian.olap.type.SetType.new(Java::mondrian.olap.type.MemberType::Unknown),
-            "Hierarchy" => Java::mondrian.olap.type.HierarchyType.new(nil, nil),
-            "Level" => Java::mondrian.olap.type.LevelType::Unknown
+            'Member' => Java::mondrian.olap.type.MemberType::Unknown,
+            'Tuple' => Java::mondrian.olap.type.TupleType.new([].to_java(Java::mondrian.olap.type.Type)),
+            'Hierarchy' => Java::mondrian.olap.type.HierarchyType.new(nil, nil),
+            'Level' => Java::mondrian.olap.type.LevelType::Unknown
           }
+          UDF_OTHER_TYPES['Set'] = UDF_OTHER_TYPES['MemberSet'] = Java::mondrian.olap.type.SetType.new(UDF_OTHER_TYPES['Member'])
+          UDF_OTHER_TYPES['TupleSet'] = Java::mondrian.olap.type.SetType.new(UDF_OTHER_TYPES['Tuple'])
 
           def getParameterTypes
             @parameterTypes ||= self.class.parameters.map{|p| get_java_type(p)}
@@ -214,7 +216,7 @@ JS
 
           def execute(evaluator, arguments)
             values = []
-            self.class.parameters.each_with_index do |p,i|
+            self.class.parameters.each_with_index do |p, i|
               value = UDF_SCALAR_TYPES[p] ? arguments[i].evaluateScalar(evaluator) : arguments[i].evaluate(evaluator)
               values << value
             end
@@ -239,9 +241,12 @@ JS
           end
 
           def self.stringified_type(type)
-            type = stringify(type)
-            raise ArgumentError, "invalid user defined function type #{type.inspect}" unless UDF_SCALAR_TYPES[type] || UDF_OTHER_TYPES[type]
-            type
+            type_as_string = stringify(type)
+            if UDF_SCALAR_TYPES[type_as_string] || UDF_OTHER_TYPES[type_as_string]
+              type_as_string
+            else
+              raise ArgumentError, "Invalid user defined function type #{type.inspect}"
+            end
           end
 
           def self.stringify(arg)

data/spec/connection_role_spec.rb

@@ -4,15 +4,21 @@ describe "Connection role" do
 
   describe "create connection" do
     before(:each) do
-      @role_name = role_name = 'California manager'
-      @role_name2 = role_name2 = 'Dummy, with comma'
+      @all_roles = [
+        @role_name = role_name = 'California manager',
+        @role_name2 = role_name2 = 'Dummy, with comma',
+        @simple_role_name = simple_role_name = 'USA manager',
+        @union_role_name = union_role_name = 'Union California manager',
+        @intermediate_union_role_name = intermediate_union_role_name = "Intermediate #{union_role_name}"
+      ]
+
       @schema = Mondrian::OLAP::Schema.define do
         cube 'Sales' do
           table 'sales'
           dimension 'Gender', :foreign_key => 'customer_id' do
             hierarchy :has_all => true, :primary_key => 'id' do
               table 'customers'
-              level 'Gender', :column => 'gender', :unique_members => true
+              level 'Gender', :column => 'gender', :unique_members => true, :hide_member_if => 'IfBlankName'
             end
           end
           dimension 'Customers', :foreign_key => 'customer_id' do
@@ -49,6 +55,26 @@ describe "Connection role" do
         end
         role role_name2
 
+        role simple_role_name do
+          schema_grant :access => 'none' do
+            cube_grant :cube => 'Sales', :access => 'all' do
+              hierarchy_grant :hierarchy => '[Customers]', :access => 'custom', :bottom_level => '[Customers].[State Province]' do
+                member_grant :member => '[Customers].[USA]', :access => 'all'
+              end
+            end
+          end
+        end
+        role intermediate_union_role_name do
+          union do
+            role_usage role_name: simple_role_name
+          end
+        end
+        role union_role_name do
+          union do
+            role_usage role_name: intermediate_union_role_name
+          end
+        end
+
         # to test that Role elements are generated before UserDefinedFunction
         user_defined_function 'Factorial' do
           ruby do
@@ -63,12 +89,16 @@ describe "Connection role" do
       @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
     end
 
+    after(:each) do
+      @olap.role_name = nil if @olap
+    end
+
     it "should connect" do
       @olap.should be_connected
     end
 
     it "should get available role names" do
-      @olap.available_role_names.should == [@role_name, @role_name2]
+      @olap.available_role_names.sort.should == @all_roles.sort
     end
 
     it "should not get role name if not set" do
@@ -113,17 +143,40 @@ describe "Connection role" do
     # end
 
     it "should not get non-visible member when role name set in connection parameters" do
-      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
-        :role => @role_name)
-      @cube = @olap.cube('Sales')
-      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+      olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge schema: @schema, role: @role_name)
+      cube = olap.cube('Sales')
+      cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
     end
 
     it "should not get non-visible member when several role names set in connection parameters" do
-      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
-        :roles => [@role_name, @role_name2])
-      @cube = @olap.cube('Sales')
-      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+      olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge schema: @schema, roles: [@role_name, @role_name2])
+      cube = olap.cube('Sales')
+      cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+    it "should see members from ragged dimensions when using single role" do
+      # Workaround for a Mondrian bug which does not allow access to ragged dimensions when using single role.
+      # This syntax will create a union role with one role.
+      @olap.role_names = [@role_name]
+      cube = @olap.cube('Sales')
+      cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+      cube.member('[Gender].[All Genders]').should_not be_nil
+    end
+
+    it "should see members from ragged dimensions when using multiple roles" do
+      @olap.role_names = [@role_name, @role_name2]
+      cube = @olap.cube('Sales')
+      cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+      cube.member('[Gender].[All Genders]').should_not be_nil
+    end
+
+    # Test patch for UnionRoleImpl getBottomLevelDepth method
+    it "should see member as drillable when using union of union role" do
+      @olap.role_names = [@union_role_name]
+      cube = @olap.cube('Sales')
+      cube.member('[Customers].[All Customers]').should be_drillable
+      cube.member('[Customers].[All Customers].[USA]').should be_drillable
+      cube.member('[Customers].[All Customers].[USA].[CA]').should_not be_drillable
     end
 
   end