mondrian-olap 0.4.0-java

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

@@ -0,0 +1,342 @@
+module Mondrian
+  module OLAP
+    class Query
+      def self.from(connection, cube_name)
+        query = self.new(connection)
+        query.cube_name = cube_name
+        query
+      end
+
+      attr_accessor :cube_name
+
+      def initialize(connection)
+        @connection = connection
+        @cube = nil
+        @axes = []
+        @where = []
+        @with = []
+      end
+
+      # Add new axis(i) to query
+      # or return array of axis(i) members if no arguments specified
+      def axis(i, *axis_members)
+        if axis_members.empty?
+          @axes[i]
+        else
+          @axes[i] ||= []
+          @current_set = @axes[i]
+          if axis_members.length == 1 && axis_members[0].is_a?(Array)
+            @current_set.concat(axis_members[0])
+          else
+            @current_set.concat(axis_members)
+          end
+          self
+        end
+      end
+
+      AXIS_ALIASES = %w(columns rows pages sections chapters)
+      AXIS_ALIASES.each_with_index do |axis, i|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{axis}(*axis_members)
+            axis(#{i}, *axis_members)
+          end
+        RUBY
+      end
+
+      %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 [:crossjoin, :nonempty_crossjoin].include? @current_set[0]
+          @current_set[2] = [:except, @current_set[2], members]
+        else
+          @current_set.replace [:except, @current_set.clone, members]
+        end
+        self
+      end
+
+      def nonempty
+        raise ArgumentError, "cannot use nonempty method before axis method" unless @current_set
+        @current_set.replace [:nonempty, @current_set.clone]
+        self
+      end
+
+      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]
+        self
+      end
+
+      def filter_nonempty
+        raise ArgumentError, "cannot use filter_nonempty method before axis or with_set method" unless @current_set
+        condition = "NOT ISEMPTY(S.CURRENT)"
+        @current_set.replace [:filter, @current_set.clone, condition, 'S']
+        self
+      end
+
+      VALID_ORDERS = ['ASC', 'BASC', 'DESC', 'BDESC']
+
+      def order(expression, direction)
+        raise ArgumentError, "cannot use order method before axis or with_set method" unless @current_set
+        direction = direction.to_s.upcase
+        raise ArgumentError, "invalid order direction #{direction.inspect}," <<
+          " should be one of #{VALID_ORDERS.inspect[1..-2]}" unless VALID_ORDERS.include?(direction)
+        @current_set.replace [:order, @current_set.clone, expression, direction]
+        self
+      end
+
+      %w(top bottom).each do |extreme|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{extreme}_count(count, expression=nil)
+            raise ArgumentError, "cannot use #{extreme}_count method before axis or with_set method" unless @current_set
+            @current_set.replace [:#{extreme}_count, @current_set.clone, count]
+            @current_set << expression if expression
+            self
+          end
+        RUBY
+
+        %w(percent sum).each do |extreme_name|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{extreme}_#{extreme_name}(value, expression)
+              raise ArgumentError, "cannot use #{extreme}_#{extreme_name} method before axis or with_set method" unless @current_set
+              @current_set.replace [:#{extreme}_#{extreme_name}, @current_set.clone, value, expression]
+              self
+            end
+          RUBY
+        end
+      end
+
+      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'
+        if all.nil? && [:crossjoin, :nonempty_crossjoin].include?(@current_set[0])
+          @current_set[2] = [:hierarchize, @current_set[2]]
+          @current_set[2] << order if order
+        else
+          @current_set.replace [:hierarchize, @current_set.clone]
+          @current_set << order if order
+        end
+        self
+      end
+
+      def hierarchize_all(order=nil)
+        hierarchize(order, :all)
+      end
+
+      # Add new WHERE condition to query
+      # or return array of existing conditions if no arguments specified
+      def where(*members)
+        if members.empty?
+          @where
+        else
+          @current_set = @where
+          if members.length == 1 && members[0].is_a?(Array)
+            @where.concat(members[0])
+          else
+            @where.concat(members)
+          end
+          self
+        end
+      end
+
+      # Add definition of calculated member
+      def with_member(member_name)
+        @with << [:member, member_name]
+        @current_set = nil
+        self
+      end
+
+      # Add definition of named_set
+      def with_set(set_name)
+        @current_set = []
+        @with << [:set, set_name, @current_set]
+        self
+      end
+
+      # return array of member and set definitions
+      def with
+        @with
+      end
+
+      # Add definition to calculated member or to named set
+      def as(*params)
+        # definition of named set
+        if @current_set
+          if params.empty?
+            raise ArgumentError, "named set cannot be empty"
+          else
+            raise ArgumentError, "cannot use 'as' method before with_set method" unless @current_set.empty?
+            if params.length == 1 && params[0].is_a?(Array)
+              @current_set.concat(params[0])
+            else
+              @current_set.concat(params)
+            end
+          end
+        # definition of calculated member
+        else
+          member_definition = @with.last
+          options = params.last.is_a?(Hash) ? params.pop : nil
+          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
+          member_definition << params[0]
+          member_definition << options if options
+        end
+        self
+      end
+
+      def to_mdx
+        mdx = ""
+        mdx << "WITH #{with_to_mdx}\n" unless @with.empty?
+        mdx << "SELECT #{axis_to_mdx}\n"
+        mdx << "FROM #{from_to_mdx}"
+        mdx << "\nWHERE #{where_to_mdx}" unless @where.empty?
+        mdx
+      end
+
+      def execute
+        Error.wrap_native_exception do
+          @connection.execute to_mdx
+        end
+      end
+
+      private
+
+      # FIXME: keep original order of WITH MEMBER and WITH SET defitions
+      def with_to_mdx
+        @with.map do |definition|
+          case definition[0]
+          when :member
+            member_name = definition[1]
+            expression = definition[2]
+            options = definition[3]
+            options_string = ''
+            options && options.each do |option, value|
+              options_string << ", #{option.to_s.upcase} = #{quote_value(value)}"
+            end
+            "MEMBER #{member_name} AS #{quote_value(expression)}#{options_string}"
+          when :set
+            set_name = definition[1]
+            set_members = definition[2]
+            "SET #{set_name} AS #{quote_value(members_to_mdx(set_members))}"
+          end
+        end.join("\n")
+      end
+
+      def axis_to_mdx
+        mdx = ""
+        @axes.each_with_index do |axis_members, i|
+          axis_name = AXIS_ALIASES[i] ? AXIS_ALIASES[i].upcase : "AXIS(#{i})"
+          mdx << ",\n" if i > 0
+          mdx << members_to_mdx(axis_members) << " ON " << axis_name
+        end
+        mdx
+      end
+
+      MDX_FUNCTIONS = {
+        :top_count => 'TOPCOUNT',
+        :top_percent => 'TOPPERCENT',
+        :top_sum => 'TOPSUM',
+        :bottom_count => 'BOTTOMCOUNT',
+        :bottom_percent => 'BOTTOMPERCENT',
+        :bottom_sum => 'BOTTOMSUM'
+      }
+
+      def members_to_mdx(members)
+        # 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
+            "NON EMPTY #{members_to_mdx(members[1])}"
+          when :filter
+            as_alias = members[3] ? " AS #{members[3]}" : nil
+            "FILTER(#{members_to_mdx(members[1])}#{as_alias}, #{members[2]})"
+          when :order
+            "ORDER(#{members_to_mdx(members[1])}, #{expression_to_mdx(members[2])}, #{members[3]})"
+          when :top_count, :bottom_count
+            mdx = "#{MDX_FUNCTIONS[members[0]]}(#{members_to_mdx(members[1])}, #{members[2]}"
+            mdx << (members[3] ? ", #{expression_to_mdx(members[3])})" : ")")
+          when :top_percent, :top_sum, :bottom_percent, :bottom_sum
+            "#{MDX_FUNCTIONS[members[0]]}(#{members_to_mdx(members[1])}, #{members[2]}, #{expression_to_mdx(members[3])})"
+          when :hierarchize
+            "HIERARCHIZE(#{members_to_mdx(members[1])}#{members[2] && ", #{members[2]}"})"
+          else
+            raise ArgumentError, "Cannot generate MDX for invalid set operation #{members[0].inspect}"
+          end
+        else
+          "{#{members.join(', ')}}"
+        end
+      end
+
+      def expression_to_mdx(expression)
+        expression.is_a?(Array) ? "(#{expression.join(', ')})" : expression
+      end
+
+      def from_to_mdx
+        "[#{@cube_name}]"
+      end
+
+      def where_to_mdx
+        # generate set MDX expression
+        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 tuple MDX expression
+        else
+          where_to_mdx_tuple
+        end
+      end
+
+      def where_to_mdx_tuple
+        mdx = '('
+        mdx << @where.map do |condition|
+          condition
+        end.join(', ')
+        mdx << ')'
+      end
+
+      def quote_value(value)
+        case value
+        when String
+          "'#{value.gsub("'", "''")}'"
+        when TrueClass, FalseClass
+          value ? 'TRUE' : 'FALSE'
+        when NilClass
+          'NULL'
+        else
+          "#{value}"
+        end
+      end
+
+      def extract_dimension_name(full_name)
+        if full_name =~ /\A[^\[]*\[([^\]]+)\]/
+          $1
+        end
+      end
+    end
+  end
+end

data/lib/mondrian/olap/result.rb

@@ -0,0 +1,264 @@
+require 'nokogiri'
+require 'bigdecimal'
+
+module Mondrian
+  module OLAP
+    class Result
+      def initialize(connection, raw_cell_set)
+        @connection = connection
+        @raw_cell_set = raw_cell_set
+      end
+
+      def axes_count
+        axes.length
+      end
+
+      def axis_names
+        @axis_names ||= axis_positions(:getName)
+      end
+
+      def axis_full_names
+        @axis_full_names ||= axis_positions(:getUniqueName)
+      end
+
+      def axis_members
+        @axis_members ||= axis_positions(:to_member)
+      end
+
+      AXIS_SYMBOLS = [:column, :row, :page, :section, :chapter]
+      AXIS_SYMBOLS.each_with_index do |axis, i|
+        define_method :"#{axis}_names" do
+          axis_names[i]
+        end
+
+        define_method :"#{axis}_full_names" do
+          axis_full_names[i]
+        end
+
+        define_method :"#{axis}_members" do
+          axis_members[i]
+        end
+      end
+
+      def values(*axes_sequence)
+        values_using(:getValue, axes_sequence)
+      end
+
+      def formatted_values(*axes_sequence)
+        values_using(:getFormattedValue, axes_sequence)
+      end
+
+      def values_using(values_method, axes_sequence = [])
+        if axes_sequence.empty?
+          axes_sequence = (0...axes_count).to_a.reverse
+        elsif axes_sequence.size != axes_count
+          raise ArgumentError, "axes sequence size is not equal to result axes count"
+        end
+        recursive_values(values_method, axes_sequence, 0)
+      end
+
+      # format results in simple HTML table
+      def to_html(options = {})
+        case axes_count
+        when 1
+          builder = Nokogiri::XML::Builder.new do |doc|
+            doc.table do
+              doc.tr do
+                column_full_names.each do |column_full_name|
+                  column_full_name = column_full_name.join(',') if column_full_name.is_a?(Array)
+                  doc.th column_full_name, :align => 'right'
+                end
+              end
+              doc.tr do
+                (options[:formatted] ? formatted_values : values).each do |value|
+                  doc.td value, :align => 'right'
+                end
+              end
+            end
+          end
+          builder.doc.to_html
+        when 2
+          builder = Nokogiri::XML::Builder.new do |doc|
+            doc.table do
+              doc.tr do
+                doc.th
+                column_full_names.each do |column_full_name|
+                  column_full_name = column_full_name.join(',') if column_full_name.is_a?(Array)
+                  doc.th column_full_name, :align => 'right'
+                end
+              end
+              (options[:formatted] ? formatted_values : values).each_with_index do |row, i|
+                doc.tr do
+                  row_full_name = row_full_names[i].is_a?(Array) ? row_full_names[i].join(',') : row_full_names[i]
+                  doc.th row_full_name, :align => 'left'
+                  row.each do |cell|
+                    doc.td cell, :align => 'right'
+                  end
+                end
+              end
+            end
+          end
+          builder.doc.to_html
+        else
+          raise ArgumentError, "just columns and rows axes are supported"
+        end
+      end
+
+      # specify drill through cell position, for example, as
+      #   :row => 0, :cell => 1
+      # specify max returned rows with :max_rows parameter
+      def drill_through(position_params = {})
+        Error.wrap_native_exception do
+          cell_params = []
+          axes_count.times do |i|
+            axis_symbol = AXIS_SYMBOLS[i]
+            raise ArgumentError, "missing position #{axis_symbol.inspect}" unless axis_position = position_params[axis_symbol]
+            cell_params << Java::JavaLang::Integer.new(axis_position)
+          end
+          raw_cell = @raw_cell_set.getCell(cell_params)
+          DrillThrough.from_raw_cell(raw_cell, position_params)
+        end
+      end
+
+      class DrillThrough
+        def self.from_raw_cell(raw_cell, params = {})
+          max_rows = params[:max_rows] || -1
+          # workaround to avoid calling raw_cell.drillThroughInternal private method
+          # which fails when running inside TorqueBox
+          cell_field = raw_cell.java_class.declared_field('cell')
+          cell_field.accessible = true
+          rolap_cell = cell_field.value(raw_cell)
+          if rolap_cell.canDrillThrough
+            sql_statement = rolap_cell.drillThroughInternal(max_rows, -1, nil, true, nil)
+            raw_result_set = sql_statement.getWrappedResultSet
+            new(raw_result_set)
+          end
+        end
+
+        def initialize(raw_result_set)
+          @raw_result_set = raw_result_set
+        end
+
+        def column_types
+          @column_types ||= (1..metadata.getColumnCount).map{|i| metadata.getColumnTypeName(i).to_sym}
+        end
+
+        def column_names
+          @column_names ||= begin
+            # if PostgreSQL then use getBaseColumnName as getColumnName returns empty string
+            if metadata.respond_to?(:getBaseColumnName)
+              (1..metadata.getColumnCount).map{|i| metadata.getBaseColumnName(i)}
+            else
+              (1..metadata.getColumnCount).map{|i| metadata.getColumnName(i)}
+            end
+          end
+        end
+
+        def table_names
+          @table_names ||= begin
+            # if PostgreSQL then use getBaseTableName as getTableName returns empty string
+            if metadata.respond_to?(:getBaseTableName)
+              (1..metadata.getColumnCount).map{|i| metadata.getBaseTableName(i)}
+            else
+              (1..metadata.getColumnCount).map{|i| metadata.getTableName(i)}
+            end
+          end
+        end
+
+        def column_labels
+          @column_labels ||= (1..metadata.getColumnCount).map{|i| metadata.getColumnLabel(i)}
+        end
+
+        def fetch
+          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)
+            end
+            row_values
+          else
+            @raw_result_set.close
+            nil
+          end
+        end
+
+        def rows
+          @rows ||= begin
+            rows_values = []
+            while row_values = fetch
+              rows_values << row_values
+            end
+            rows_values
+          end
+        end
+
+        private
+
+        def metadata
+          @metadata ||= @raw_result_set.getMetaData
+        end
+
+      end
+
+      def self.java_to_ruby_value(value, column_type = nil)
+        case value
+        when Numeric, String
+          value
+        when Java::JavaMath::BigDecimal
+          BigDecimal(value.to_s)
+        else
+          value
+        end
+      end
+
+      private
+
+      def axes
+        @axes ||= @raw_cell_set.getAxes
+      end
+
+      def axis_positions(map_method, join_with=false)
+        axes.map do |axis|
+          axis.getPositions.map do |position|
+            names = position.getMembers.map do |member|
+              if map_method == :to_member
+                Member.new(member)
+              else
+                member.send(map_method)
+              end
+            end
+            if names.size == 1
+              names[0]
+            elsif join_with
+              names.join(join_with)
+            else
+              names
+            end
+          end
+        end
+      end
+
+      AXIS_SYMBOL_TO_NUMBER = {
+        :columns => 0,
+        :rows => 1,
+        :pages => 2,
+        :sections => 3,
+        :chapters => 4
+      }.freeze
+
+      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
+          (0...positions_size).map do |i|
+            cell_params[axis_number] = Java::JavaLang::Integer.new(i)
+            recursive_values(value_method, axes_sequence, current_index + 1, cell_params)
+          end
+        else
+          self.class.java_to_ruby_value(@raw_cell_set.getCell(cell_params).send(value_method))
+        end
+      end
+
+    end
+  end
+end