mondrian-rest 0.7.9-java → 1.0.0-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbd9d6692bb827f1b325d682e9df7872a83be6a5085b0af4ceb41cc4194b59d7
-  data.tar.gz: 8e1d250c08c9c88adec227560d816ee79afe1f6c236f0ab31fa5574e981d3d81
+  metadata.gz: 2cfb2bb9ca02faf64e851332d271430bed71fcda750ae4f0b46e71cacb8d4c72
+  data.tar.gz: 82aa47f20dabcfb4a8deff1e8636f9a8570b667956baf90db522351d6c84a0c7
 SHA512:
-  metadata.gz: cc64f9b2911c3e3e7b4142ec91a2796a83190e4abb00a0cb340b0a841d0f706ff43aade8dad0c833e54273b9a4672cf7f2a53223281e4febf9e92fd15bbdaadb
-  data.tar.gz: 55e965893aec267dd80d1acac550d0b9b85443e36485357468c1c27dcc3e7851205dfef6bc0afcc2b0025786b3a2f07f1448da254cb2c3c826f763724e5c32bb
+  metadata.gz: b340ebdde3e89747453ecbbdab83e8c112115a240799778f680cb575359c900ad22b43711ab2f93e402f42dacbd14d6883d612887b11fe103f40e9035b13b60d
+  data.tar.gz: a2f4252ee653683f7e39df31f270f052c944b264418c69902c4c7dffec662e6bf3e667936793501cbf6b6e65e64f9278f24e2c956fcf915e2d1c99532fb6df54

data/Rakefile

@@ -13,8 +13,8 @@ desc "API Routes"
 task :routes do
   require_relative './lib/mondrian_rest.rb'
   Mondrian::REST::Api.routes.each do |api|
-    method = api.route_method.ljust(10)
-    path = api.route_path
+    method = api.request_method.ljust(10)
+    path = api.path
     puts "     #{method} #{path}"
   end
 end

data/lib/mondrian_rest.rb

@@ -2,10 +2,10 @@ require 'json'
 
 Java::JavaLang::System.setProperty("jdbc.driver.autoload", "true")
 
-require_relative './jars/mondrian-rest_jars.rb'
-
 require 'mondrian-olap'
 require 'grape'
+require 'active_support'
+require 'active_support/core_ext/enumerable'
 
 require_relative './mondrian_rest/nest.rb'
 require_relative './mondrian_rest/api.rb'

data/lib/mondrian_rest/api.rb

@@ -6,7 +6,6 @@ require_relative './query_helper.rb'
 require_relative './api_formatters.rb'
 
 module Mondrian::REST
-
   class Api < Grape::API
     version '1', using: :header, vendor: 'mondrian_rest'
     default_format :json
@@ -20,26 +19,26 @@ module Mondrian::REST
     end
 
     resource :mdx do
-      content_type :xls, "application/vnd.ms-excel"
+      content_type :xls, 'application/vnd.ms-excel'
       formatter :xls, Mondrian::REST::Formatters::XLS
 
-      content_type :csv, "text/csv"
+      content_type :csv, 'text/csv'
       formatter :csv, Mondrian::REST::Formatters::CSV
 
-      content_type :json, "application/json"
+      content_type :json, 'application/json'
       formatter :json, Mondrian::REST::Formatters::AggregationJSON
 
-      content_type :jsonrecords, "application/x-jsonrecords"
+      content_type :jsonrecords, 'application/x-jsonrecords'
       formatter :jsonrecords, Mondrian::REST::Formatters::JSONRecords
 
-      desc "Execute an MDX query against a cube"
-      content_type :txt, "text/plain"
+      desc 'Execute an MDX query against a cube'
+      content_type :txt, 'text/plain'
 
       params do
         optional :parents, type: Boolean, desc: "Include members' ancestors"
-        optional :debug, type: Boolean, desc: "Include generated MDX", default: false
-        optional :properties, type: Array, desc: "Include member properties"
-        optional :caption, type: Array, desc: "Replace caption with property", default: []
+        optional :debug, type: Boolean, desc: 'Include generated MDX', default: false
+        optional :properties, type: Array, desc: 'Include member properties'
+        optional :caption, type: Array, desc: 'Replace caption with property', default: []
       end
 
       post do
@@ -52,17 +51,17 @@ module Mondrian::REST
 
     resource :flush do
       params do
-        requires :secret, type: String, desc: "Secret key"
+        requires :secret, type: String, desc: 'Secret key'
       end
-      content_type :json, "application/json"
-      desc "Flush the schema cache"
+      content_type :json, 'application/json'
+      desc 'Flush the schema cache'
 
       get do
         if ENV['MONDRIAN_REST_SECRET'].nil?
-          error!("Please set MONDRIAN_REST_SECRET to use this endpoint", 403)
+          error!('Please set MONDRIAN_REST_SECRET to use this endpoint', 403)
         end
         if params[:secret] != ENV['MONDRIAN_REST_SECRET']
-          error!("Invalid secret key.", 403)
+          error!('Invalid secret key.', 403)
         end
         {
           'status' => olap_flush
@@ -71,7 +70,7 @@ module Mondrian::REST
     end
 
     resource :cubes do
-      content_type :json, "application/json"
+      content_type :json, 'application/json'
       default_format :json
       desc "Returns the cubes defined in this server's schema"
       get do
@@ -81,9 +80,9 @@ module Mondrian::REST
       end
 
       route_param :cube_name do
-        desc "Return a cube"
+        desc 'Return a cube'
         params do
-          requires :cube_name, type: String, desc: "Cube name"
+          requires :cube_name, type: String, desc: 'Cube name'
         end
 
         get do
@@ -92,7 +91,7 @@ module Mondrian::REST
         end
 
         resource :members do
-          desc "return a member by its full name"
+          desc 'return a member by its full name'
           params do
             requires :full_name,
                      type: String,
@@ -106,46 +105,47 @@ module Mondrian::REST
             if m.nil?
               error!("Member `#{member_full_name}` not found in cube `#{params[:cube_name]}`", 404)
             end
-            m.to_h.merge({
-                           ancestors: m.ancestors.map(&:to_h),
-                           dimension: m.dimension_info
-                         })
+            m.to_h.merge(
+              ancestors: m.ancestors.map(&:to_h),
+              dimension: m.dimension_info
+            )
           end
         end
 
-
         resource :aggregate do
-          content_type :xls, "application/vnd.ms-excel"
+          content_type :xls, 'application/vnd.ms-excel'
           formatter :xls, Mondrian::REST::Formatters::XLS
 
-          content_type :csv, "text/csv"
+          content_type :csv, 'text/csv'
           formatter :csv, Mondrian::REST::Formatters::CSV
 
-          content_type :json, "application/json"
+          content_type :json, 'application/json'
           formatter :json, Mondrian::REST::Formatters::AggregationJSON
 
-          content_type :jsonrecords, "application/x-jsonrecords"
+          content_type :jsonrecords, 'application/x-jsonrecords'
           formatter :jsonrecords, Mondrian::REST::Formatters::JSONRecords
 
-          content_type :jsonstat, "application/x-jsonstat"
-          formatter :jsonstat, Mondrian::REST::Formatters::JSONStat
-
           rescue_from PropertyError do |e|
-            error!({error: e}, 400)
+            error!({ error: e }, 400)
           end
 
-          desc "aggregate from query parameters"
+          desc 'aggregate from query parameters'
           params do
             optional :measures, type: Array
-            optional :cut, type: Array, desc: "Specification of slicer axis"
-            optional :drilldown, type: Array, desc: "Dimension(s) to be drilled down"
-            optional :nonempty, type: Boolean, desc: "Only return non empty cells"
-            optional :sparse, type: Boolean, desc: "Skip rows where all measures are null (only applies to CSV, XLS and JSONRECORDS)", default: !java.lang.System.getProperty('mondrian-rest.sparseDefault').nil?
-            optional :distinct, type: Boolean, desc: "Apply DISTINCT() to every axis"
+            optional :cut, type: Array, desc: 'Specification of slicer axis'
+            optional :drilldown, type: Array, desc: 'Dimension(s) to be drilled down'
+            optional :nonempty, type: Boolean, desc: 'Only return non empty cells'
+            optional :sparse, type: Boolean, desc: 'Skip rows where all measures are null (only applies to CSV, XLS and JSONRECORDS)', default: !java.lang.System.getProperty('mondrian-rest.sparseDefault').nil?
+            optional :distinct, type: Boolean, desc: 'Apply DISTINCT() to every axis'
             optional :parents, type: Boolean, desc: "Include members' ancestors"
-            optional :debug, type: Boolean, desc: "Include generated MDX", default: false
-            optional :properties, type: Array, desc: "Include member properties"
-            optional :caption, type: Array, desc: "Replace caption with property", default: []
+            optional :debug, type: Boolean, desc: 'Include generated MDX', default: false
+            optional :properties, type: Array, desc: 'Include member properties'
+            optional :caption, type: Array, desc: 'Replace caption with property', default: []
+            optional :filter, type: Array, desc: "Filter by measure value. Accepts: #{Mondrian::REST::QueryHelper::VALID_FILTER_OPS.join(', ')}"
+            optional :order, type: String, desc: 'Sort by measure or property name'
+            optional :order_desc, type: Boolean, desc: 'Sort direction (true is descending)', default: false
+            optional :offset, type: Integer, desc: 'Offset this resultset'
+            optional :limit, type: Integer, desc: 'Limit number of results'
           end
 
           get do
@@ -161,8 +161,8 @@ module Mondrian::REST
           route_param :dimension_name do
             desc "Return a dimension's members"
             params do
-              requires :cube_name, type: String, desc: "Cube name"
-              requires :dimension_name, type: String, desc: "Dimension name"
+              requires :cube_name, type: String, desc: 'Cube name'
+              requires :dimension_name, type: String, desc: 'Dimension name'
             end
 
             get do
@@ -171,33 +171,37 @@ module Mondrian::REST
               dimension.to_h(get_members: true)
             end
 
+            resource :hierarchies do
+              route_param :hierarchy_name do
+                resource :levels do
+                  route_param :level_name do
+                    resource :members do
+                      params do
+                        optional :member_properties, type: Array, default: []
+                        optional :caption, type: String, desc: 'Replace caption with property', default: nil
+                        optional :children, type: Boolean, default: false
+                      end
+
+                      get do
+                        get_members(params)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+
             resource :levels do
               route_param :level_name do
                 resource :members do
-
                   params do
                     optional :member_properties, type: Array, default: []
-                    optional :caption, type: String, desc: "Replace caption with property", default: nil
+                    optional :caption, type: String, desc: 'Replace caption with property', default: nil
                     optional :children, type: Boolean, default: false
                   end
 
                   get do
-                    cube = get_cube_or_404(params[:cube_name])
-
-                    dimension = cube.dimension(params[:dimension_name])
-                    if dimension.nil?
-                      error!("dimension #{params[:dimension_name]} not found in cube #{params[:cube_name]}", 404)
-                    end
-
-                    level = dimension.hierarchies[0].level(params[:level_name])
-                    if level.nil?
-                      error!("level #{params[:level_name]} not found in dimension #{params[:dimension_name]}")
-                    end
-
-                    level.to_h(member_properties: params[:member_properties],
-                               get_children: params[:children],
-                               member_caption: params[:caption],
-                               get_members: true)
+                    get_members(params)
                   end
 
                   route_param :member_key,
@@ -205,7 +209,7 @@ module Mondrian::REST
                               requirements: { member_key: /[A-Za-z0-9\.\-\s%]+/i } do
 
                     params do
-                      optional :caption, type: String, desc: "Replace caption with property", default: nil
+                      optional :caption, type: String, desc: 'Replace caption with property', default: nil
                       optional :member_properties, type: Array, default: []
                       optional :children, type: Boolean, default: false
                     end
@@ -215,13 +219,13 @@ module Mondrian::REST
                       dimension = cube.dimension(params[:dimension_name])
                       level = dimension.hierarchies[0].level(params[:level_name])
 
-                      member = level.members.detect { |m|
+                      member = level.members.detect do |m|
                         m.property_value('MEMBER_KEY').to_s == params[:member_key]
-                      }
+                      end
                       error!('member not found', 404) if member.nil?
                       member
                         .to_h(params[:member_properties], params[:caption], params[:children])
-                        .merge({ancestors: member.ancestors.map(&:to_h)})
+                        .merge(ancestors: member.ancestors.map(&:to_h))
                     end
                   end
                 end

data/lib/mondrian_rest/api_formatters.rb

@@ -2,29 +2,27 @@ require_relative './formatters/aggregation_json'
 require_relative './formatters/csv'
 require_relative './formatters/excel'
 require_relative './formatters/jsonrecords'
-require_relative './formatters/jsonstat'
-
 
 module Mondrian::REST::Formatters
-
   ##
   # Generate 'tidy data' (http://vita.had.co.nz/papers/tidy-data.pdf)
   # from a result set.
   def self.tidy(result, options)
-
     cube = result.cube
 
     add_parents = options[:add_parents]
     properties = options[:properties]
-    sparse = options[:sparse]
     rs = result.to_h(add_parents, options[:debug])
 
-    if rs[:values].empty?
-      return []
-    end
+    return [] if rs[:values].empty?
 
     measures = rs[:axes].first[:members]
-    dimensions = rs[:axis_dimensions][1..-1]
+    dimensions = rs[:axes][1..-1]
+
+    indexed_members = rs[:axes].map do |ax|
+      ax[:members].index_by { |m| m[:key] }
+    end
+
     columns = []
     slices = []
     level_has_all = []
@@ -33,8 +31,7 @@ module Mondrian::REST::Formatters
       dimensions.each do |dd|
         if add_parents
           hier = cube.dimension(dd[:name])
-                   .hierarchies
-                   .first # TODO: Support other hierarchies
+                     .hierarchy(dd[:hierarchy])
 
           level_has_all << hier.has_all?
           slices << dd[:level_depth]
@@ -51,71 +48,54 @@ module Mondrian::REST::Formatters
       end
 
       props = Mondrian::REST::APIHelpers.parse_properties(properties, dimensions)
-      pnames = properties.map { |p|
+      pnames = properties.map do |p|
         org.olap4j.mdx.IdentifierNode.parseIdentifier(p).getSegmentList.last.name
-      }
+      end
 
       # append properties and measure columns and yield table header
       y.yield columns + pnames + pluck(measures, :name)
 
-      prod = rs[:axes][1..-1].map { |e|
-        e[:members].map.with_index { |e_, i| [e_,i] }
-      }
-      values = rs[:values]
-
-      prod.shift.product(*prod).each do |cell|
-        cidxs = cell.map { |c,i| i }.reverse
+      rs[:cell_keys].each_with_index do |row, i|
+        cm = row.each_with_index.map { |member_key, i| indexed_members[i + 1][member_key] }
+        msrs = rs[:values][i]
 
-        cm = cell.map(&:first)
-
-        msrs = measures.map.with_index { |m, mi|
-          (cidxs + [mi]).reduce(values) { |_, idx| _[idx] }
-        }
-
-        next if sparse && msrs.all?(&:nil?)
-
-        if add_parents
-          vdim = cm.each.with_index.reduce([]) { |cnames, (member, j)|
-            member[:ancestors][0...slices[j] - (level_has_all[j] ? 1 : 0)].reverse.each { |ancestor|
+        if !add_parents
+          y.yield pluck(cm, :key).zip(pluck(cm, :caption)).flatten \
+                  + get_props(cm, pnames, props, dimensions) \
+                  + msrs
+        else
+          vdim = cm.each.with_index.reduce([]) do |cnames, (member, j)|
+            member[:ancestors][0...slices[j] - (level_has_all[j] ? 1 : 0)].reverse.each do |ancestor|
               cnames += [ancestor[:key], ancestor[:caption]]
-            }
+            end
             cnames += [member[:key], member[:caption]]
-          }
+          end
 
           y.yield vdim + get_props(cm, pnames, props, dimensions) + msrs
-        else
-          row = pluck(cm, :key)
-                  .zip(pluck(cm, :caption))
-                  .flatten
-
-          y.yield row + get_props(cm, pnames, props, dimensions) + msrs
         end
       end
     end
   end
 
   def self.get_props(cm, pnames, props, dimensions)
-    pvalues = cm.each.with_index.reduce({}) do |h, (member, ax_i)|
+    pvalues = cm.each.with_index.each_with_object({}) do |(member, ax_i), h|
       dname = dimensions[ax_i][:name]
-      if props[dname] # are there properties requested for members of this dimension?
-        mmbr_lvl = dimensions[ax_i][:level]
-        (props[dname][mmbr_lvl] || []).each { |p|
-          h[p] = member[:properties][p]
-        }
-        if member[:ancestors]
-          props[dname]
-            .select { |k, _| k != mmbr_lvl } # levels other than member's own
-            .each { |l, p|
-            p.each # get all requested props for this level's ancestor
-              .with_object(member[:ancestors].find { |anc|
-                             anc[:level_name] == l
-                           }) { |prop, anc|
-              h[prop] = anc[:properties][prop]
-            }
-          }
+      next unless props[dname] # are there properties requested for members of this dimension?
+      mmbr_lvl = dimensions[ax_i][:level]
+      (props[dname][mmbr_lvl] || []).each do |p|
+        h[p] = member[:properties][p]
+      end
+      next unless member[:ancestors]
+      props[dname]
+        .reject { |k, _| k == mmbr_lvl } # levels other than member's own
+        .each do |l, p|
+        p.each # get all requested props for this level's ancestor
+         .with_object(member[:ancestors].find do |anc|
+                        anc[:level_name] == l
+                      end) do |prop, anc|
+          h[prop] = anc[:properties][prop]
         end
       end
-      h
     end # reduce
     pnames.map { |pn| pvalues[pn] }
   end

data/lib/mondrian_rest/api_helpers.rb

@@ -4,7 +4,6 @@ module Mondrian::REST
   end
 
   module APIHelpers
-
     @@olap = nil
     @@mdx_parser = nil
 
@@ -42,44 +41,66 @@ module Mondrian::REST
 
     def mdx(query)
       logger.info("Executing MDX query #{query}")
-      begin
-        result = olap.execute query
-        result.mdx = query if params[:debug]
-        result.properties = params[:properties]
-        result.caption_properties = params[:caption] 
-        result.cube = Mondrian::OLAP::Cube.new(olap,
-                                               olap.raw_connection.prepareOlapStatement(query).getCube)
-        return result
-      rescue Mondrian::OLAP::Error => st
-        error!({error: st.backtrace}, 400)
-      end
+
+      result = olap.execute query
+      result.mdx = query if params[:debug]
+      result.properties = params[:properties]
+      result.caption_properties = params[:caption]
+      result.cube = Mondrian::OLAP::Cube.new(olap,
+                                             olap.raw_connection.prepareOlapStatement(query).getCube)
+      result
+    rescue Mondrian::OLAP::Error => st
+      error!({ error: st.backtrace }, 400)
     end
 
     def run_from_params(params)
       cube = get_cube_or_404(params[:cube_name])
       query = build_query(cube, params)
-      mdx_query = query.to_mdx
 
       result = mdx(query.to_mdx)
       result.cube = cube
       result
     end
 
+    def get_members(params)
+      cube = get_cube_or_404(params[:cube_name])
+
+      dimension = cube.dimension(params[:dimension_name])
+      if dimension.nil?
+        error!("dimension #{params[:dimension_name]} not found in cube #{params[:cube_name]}", 404)
+      end
+
+      hier = unless params[:hierarchy_name].nil?
+               h = dimension.hierarchy(params[:hierarchy_name])
+               error!("Hierarchy #{params[:hierarchy_name]} does not exist in dimension #{params[:dimension_name]}", 404) if h.nil?
+               h
+             else
+               dimension.hierarchies.first
+             end
+
+      level = hier.level(params[:level_name])
+      if level.nil?
+        error!("level #{params[:level_name]} not found in dimension #{params[:dimension_name]}")
+      end
+
+      level.to_h(member_properties: params[:member_properties],
+                 get_children: params[:children],
+                 member_caption: params[:caption],
+                 get_members: true)
+    end
+
     NEST = Mondrian::REST::Nest.new
-             .key { |d| d[0] }
-             .key { |d| d[1] }
+                               .key { |d| d[0] }
+                               .key { |d| d[1] }.freeze
 
     def self.parse_caption_properties(cprops)
-      if cprops.nil? or cprops.size < 1
-        return {}
-      end
+      return {} if cprops.nil? || cprops.empty?
 
-      NEST.map(cprops.map { |cp|
+      NEST.map(cprops.map do |cp|
                  names = org.olap4j.mdx.IdentifierNode.parseIdentifier(cp).getSegmentList.to_a.map(&:name)
                  # IF prop in Dim.Hier.Lvl.Prop format, skip names[1]
                  names.size == 4 ? [names[0], names[2], names[3]] : names
-               })
-
+               end)
     end
 
     ##

data/lib/mondrian_rest/mondrian_ext.rb

@@ -9,6 +9,29 @@ module Mondrian
         raw_cube.getSets
       end
 
+      def measure(name)
+        self.dimension('Measures')
+          .hierarchy
+          .levels
+          .first
+          .members
+          .detect { |m| m.name == name }
+      end
+
+      def valid_measure?(name)
+        !self.measure(name).nil?
+      end
+
+      def level(*parts)
+        dim = self.dimension(parts[0])
+        hier = if parts.size > 2
+                 dim.hierarchy(parts[1])
+               else
+                 dim.hierarchies[0]
+               end
+        hier.level(parts.last)
+      end
+
       def to_h
         # gather named sets
         named_sets = self.named_sets
@@ -128,6 +151,10 @@ module Mondrian
         }
       end
 
+      def property(name)
+        self.raw_level.getProperties.asMap[name]
+      end
+
     end
 
     class Member
@@ -171,13 +198,15 @@ module Mondrian
       def dimension_info
         d = @raw_member.getDimension()
         l = @raw_member.getLevel()
+        h = l.getHierarchy()
 
         x = {
-          :name => d.getName,
-          :caption => d.getCaption,
-          :type => self.dimension_type,
-          :level => l.getCaption,
-          :level_depth => l.depth
+          name: d.getName,
+          caption: d.getCaption,
+          type: self.dimension_type,
+          level: l.getCaption,
+          level_depth: l.depth,
+          hierarchy: h.getName
         }
       end
 
@@ -201,49 +230,60 @@ module Mondrian
         # return the contents of the filter axis
         # puts self.raw_cell_set.getFilterAxis.inspect
 
-        dimensions = self.axis_members.map { |am| am.first ? am.first.dimension_info : nil }
+        drilldowns_num = if self.raw_cell_set.getMetaData.getAxesMetaData.size == 1
+                           0
+                         else
+                           self.raw_cell_set.getMetaData.getAxesMetaData[1].getHierarchies.size
+                         end
+        dimensions = self.axis_members
+                       .flatten
+                       .map(&:dimension_info)
+                       .uniq
+
+        pprops = {}
+        pprops = Mondrian::REST::APIHelpers.parse_properties(self.properties, dimensions[1..-1]) unless self.properties.nil?
+        cprops = Mondrian::REST::APIHelpers.parse_caption_properties(self.caption_properties)
+
+        measure_axis = { members: self.axis_members.first.flatten.map(&:to_h) }
+        measure_axis.merge!(dimensions[0]) if dimensions.size > 0
+
+        member_axes = if drilldowns_num > 1
+                        self.axis_members[1].transpose
+                      elsif drilldowns_num == 1
+                        [self.axis_members[1]]
+                      else
+                        []
+                      end
 
-        pprops = unless self.properties.nil?
-                   Mondrian::REST::APIHelpers.parse_properties(self.properties,
-                                                               dimensions[1..-1]) # exclude Measures dimension
-                 else
-                   {}
-                 end
-
-        cprops = Mondrian::REST::APIHelpers.parse_caption_properties(
-          self.caption_properties
-        )
-
-        rv = {
-          axes: self.axis_members.each_with_index.map { |a, i|
+        {
+          axes: [measure_axis] + member_axes.each_with_index.map { |a, axis_index|
             {
-              members: a.map { |m|
+              members: a.uniq(&:full_name).map { |m|
                 mh = m.to_h(
                   pprops.dig(m.raw_member.getDimension.name, m.raw_level.name) || [],
                   (cprops.dig(m.raw_member.getDimension.name, m.raw_level.name) || [[]])[0][-1]
                 )
                 if parents
-                  mh.merge!({
-                              ancestors: m.ancestors.map { |ma|
-                                ma.to_h(
-                                  pprops.dig(ma.raw_member.getDimension.name, ma.raw_level.name) || [],
-                                  (cprops.dig(ma.raw_member.getDimension.name, ma.raw_level.name) || [[]])[0][-1]
-                                )
-                              }
-                            })
+                  mh[:ancestors] = m.ancestors.map { |ma|
+                    ma.to_h(
+                      pprops.dig(ma.raw_member.getDimension.name, ma.raw_level.name) || [],
+                      (cprops.dig(ma.raw_member.getDimension.name, ma.raw_level.name) || [[]])[0][-1])
+                  }
                 end
                 mh
               }
-            }
+            }.merge(dimensions.size > 1 ? dimensions[axis_index+1] : {})
           },
-          axis_dimensions: dimensions,
-          values: self.values
+          cell_keys: if drilldowns_num > 1
+                       self.axis_members[1].map { |t| t.map { |m| m.property_value('MEMBER_KEY') } }
+                     elsif drilldowns_num == 1
+                       self.axis_members[1].map { |t| [ t.property_value('MEMBER_KEY') ] }
+                     else
+                       []
+                     end,
+          values: self.values,
+          mdx: debug ? self.mdx : nil
         }
-
-        rv[:mdx] = self.mdx if debug
-
-        rv
-
       end
     end
   end

data/lib/mondrian_rest/query_helper.rb

@@ -1,6 +1,11 @@
 # coding: utf-8
 module Mondrian::REST
   module QueryHelper
+    VALID_FILTER_OPS = [
+      '>', '<', '>=', '<=', '=', '<>'
+    ].freeze
+    VALID_FILTER_RE = /(?<measure>[a-zA-Z0-9\s]+)\s*(?<operand>#{VALID_FILTER_OPS.join("|")})\s*(?<value>-?\d+\.?\d*)/
+    MEMBER_METHODS = %w[Caption Key Name UniqueName].freeze
 
     def unparse_node(node)
       sw = java.io.StringWriter.new
@@ -11,18 +16,16 @@ module Mondrian::REST
 
     def get_dimension(cube, dname)
       cube_dimensions = cube.dimensions
-                        .find_all { |d| d.dimension_type != :measures }
+                            .find_all { |d| d.dimension_type != :measures }
       dim = cube_dimensions.find { |d| d.name == dname }
       error!("Dimension #{dname} does not exist", 400) if dim.nil?
       dim
     end
 
     def get_member(cube, member_exp)
-      begin
-        return cube.member(member_exp)
-      rescue Java::JavaLang::IllegalArgumentException
-        error!("Illegal expression: #{member_exp}", 400)
-      end
+      cube.member(member_exp)
+    rescue Java::JavaLang::IllegalArgumentException
+      error!("Illegal expression: #{member_exp}", 400)
     end
 
     def get_named_set(cube, named_set_exp)
@@ -39,48 +42,42 @@ module Mondrian::REST
       case p
       when org.olap4j.mdx.CallNode
         case p.getOperatorName
-        when "{}"
+        when '{}'
           # check that the set contains only Members of a single dimension level
-          set_members = p.getArgList.map { |id_node|
+          set_members = p.getArgList.map do |id_node|
             get_member(cube, unparse_node(id_node))
-          }
+          end
 
-          if set_members.any? { |m| m.nil? }
-            error!("Illegal cut. Unknown member in cut set", 400)
+          if set_members.any?(&:nil?)
+            error!('Illegal cut. Unknown member in cut set', 400)
           end
 
           ls = set_members.map(&:raw_level).uniq
-          unless ls.size == 1
-            error!("Illegal cut: " + cut_expr, 400)
-          end
+          error!('Illegal cut: ' + cut_expr, 400) unless ls.size == 1
           { level: ls.first, cut: unparse_node(p), type: :set, set_members: set_members }
-        when "()"
+        when '()'
           # check that the range contains a valid range
 
           unless p.getArgList.first.is_a?(org.olap4j.mdx.CallNode) \
-            and p.getArgList.first.getOperatorName == ':'
-            error!("Illegal cut: " + cut_expr, 400)
+            && (p.getArgList.first.getOperatorName == ':')
+            error!('Illegal cut: ' + cut_expr, 400)
           end
 
-          ls = p.getArgList.first.getArgList.map { |id_node|
+          ls = p.getArgList.first.getArgList.map do |id_node|
             get_member(cube, unparse_node(id_node)).raw_level
-          }.uniq
+          end.uniq
 
-          unless ls.size == 1
-            error!("Illegal cut: " + cut_expr, 400)
-          end
+          error!('Illegal cut: ' + cut_expr, 400) unless ls.size == 1
 
           { level: ls.first, cut: unparse_node(p), type: :range }
         else
-          error!("Illegal cut: " + cut_expr, 400)
+          error!('Illegal cut: ' + cut_expr, 400)
         end
       when org.olap4j.mdx.IdentifierNode
 
         # does cut_expr look like a NamedSet?
         s = get_named_set(cube, cut_expr)
-        if !s.nil?
-          return { level: nil, cut: cut_expr, type: :named_set }
-        end
+        return { level: nil, cut: cut_expr, type: :named_set } unless s.nil?
 
         # if `cut_expr` looks like a member, check that it's level is
         # equal to `level`
@@ -92,7 +89,7 @@ module Mondrian::REST
 
         { level: m.raw_level, cut: cut_expr, type: :member }
       else
-        error!("Illegal cut: " + cut_expr, 400)
+        error!('Illegal cut: ' + cut_expr, 400)
       end
     end
 
@@ -100,10 +97,9 @@ module Mondrian::REST
     # Parses a drilldown specification
     # XXX TODO write doc
     def parse_drilldown(cube, drilldown)
-
       # check if the drilldown is a named set
       named_sets = cube.named_sets
-      if ns = named_sets.find { |ns| ns.name == drilldown }
+      if (ns = named_sets.find { |ns| ns.name == drilldown })
         return ns
       end
 
@@ -138,46 +134,101 @@ module Mondrian::REST
       level
     end
 
-    def build_query(cube, options={})
+    def parse_measure_filter(cube, filter)
+      m = VALID_FILTER_RE.match(filter)
+      error!("Filter clause #{filter} is invalid", 400) if m.nil?
+
+      unless cube.valid_measure?(m['measure'].strip)
+        error!("Invalid filter: measure #{m['measure'].strip} does not exist", 400)
+      end
+
+      {
+        measure: m['measure'].strip,
+        operand: m['operand'].strip,
+        value: m['value'].strip
+      }
+    end
+
+    def parse_order(cube, order, order_desc)
+      begin
+        s = org.olap4j.mdx.IdentifierNode.parseIdentifier(order).getSegmentList.map(&:getName)
+      rescue Java::JavaLang::IllegalArgumentException
+        error!("Invalid order specification: #{order}", 400)
+      end
+
+      if s[0] == 'Measures'
+        error!("Invalid measure in order: #{s[1]}", 400) unless cube.valid_measure?(s[1])
+
+        return {
+          order: cube.measure(s[1]).full_name,
+          desc: order_desc
+        }
+      else # ordering by a property
+        # we need at least dim.level.property
+        error!('Invalid order: specify at least [Dimension].[Level].[Property]', 400) if s.size < 3
+
+        lvl = cube.level(*s[0..-2])
+        error!("Invalid order: level #{s[0..-2].join('.')} not found", 400) if lvl.nil?
+
+        last = if MEMBER_METHODS.include?(s.last)
+                 s.last
+               else
+                 prop = lvl.property(s[-1])
+                 error!("Invalid order: property #{order} not found", 400) if prop.nil?
+                 "Properties('#{s.last}')"
+               end
+
+        return {
+          order: s[0..-2].map do |n|
+            Java::MondrianOlap::Util.quoteMdxIdentifier(n)
+          end.join('.') + '.CurrentMember.' + last,
+          desc: order_desc
+        }
+      end
+    end
 
+    def build_query(cube, options = {})
       measure_members = cube.dimension('Measures').hierarchy.levels.first.members
       options = {
         'cut' => [],
         'drilldown' => [],
         'measures' => [measure_members.first.name],
         'nonempty' => false,
-        'distinct' => false
+        'distinct' => false,
+        'filter' => [],
+        'order' => nil,
+        'order_desc' => false,
+        'offset' => nil,
+        'limit' => nil
       }.merge(options)
 
       # validate measures exist
       cm_names = measure_members.map(&:name)
 
-      options['measures'].each { |m|
+      options['measures'].each do |m|
         error!("Measure #{m} does not exist in cube #{cube.name}", 400) unless cm_names.include?(m)
-      }
+      end
+
+      filters = options['filter'].map { |f| parse_measure_filter(cube, f) }
 
       # measures go in axis(0) of the resultset
       query = olap.from(cube.name)
-              .axis(0,
-                    *options['measures'].map { |m|
-                      measure_members.find { |cm| cm.name == m }.full_name
-                    })
-      if options['nonempty']
-        query = query.nonempty
-      end
-      axis_idx = 1
+                  .axis(0,
+                        *options['measures'].map do |m|
+                          measure_members.find { |cm| cm.name == m }.full_name
+                        end)
+      query = query.nonempty if options['nonempty']
 
       query_axes = options['drilldown'].map { |dd| parse_drilldown(cube, dd) }
 
-      slicer_axis = options['cut'].reduce({}) { |h, cut_expr|
+      slicer_axis = options['cut'].each_with_object({}) do |cut_expr, h|
         pc = parse_cut(cube, cut_expr)
         h[pc[:level]] = pc
-        h
-      }
+      end
 
       dd = query_axes.map do |qa|
         # if drilling down on a named set
-        if qa.kind_of?(Java::MondrianOlap4j::MondrianOlap4jNamedSet)
+        if qa.is_a?(Java::MondrianOlap4j::MondrianOlap4jNamedSet)
           "[#{qa.name}]"
         # there's a slice (cut) on this axis
         elsif slicer_axis[qa.raw_level]
@@ -188,10 +239,10 @@ module Mondrian::REST
           else
             cut[:cut]
           end
-        elsif cut = slicer_axis.find { |lvl, cut|
+        elsif cut = slicer_axis.find do |lvl, cut|
                 next if cut[:type] == :named_set
                 qa.raw_level.hierarchy == lvl.hierarchy && lvl.depth < qa.depth
-              }
+              end
           slicer_axis.delete(cut[0])
           cut = cut[1]
 
@@ -200,44 +251,58 @@ module Mondrian::REST
             "DESCENDANTS(#{cut[:cut]}, #{qa.unique_name})"
           when :set
             # TODO
-            "{" + cut[:set_members].map { |m|
+            '{' + cut[:set_members].map do |m|
               "DESCENDANTS(#{m.full_name}, #{qa.unique_name})"
-            }.join(",") + "}"
+            end.join(',') + '}'
           when :range
             # TODO
-            raise "Unsupported operation"
+            raise 'Unsupported operation'
           end
         else
           qa.unique_name + '.Members'
         end
       end
 
-      # query axes (drilldown)
-      dd.each do |ds|
-        query = query.axis(axis_idx,
-                           ds)
+      unless dd.empty?
+        # Cross join all the drilldowns
+        axis_exp = dd.join(' * ')
 
-        if options['distinct']
-          query = query.distinct
+        # Apply filters
+        unless filters.empty?
+          filter_exp = filters.map { |f| "[Measures].[#{org.olap4j.mdx.MdxUtil.mdxEncodeString(f[:measure])}] #{f[:operand]} #{f[:value]}" }.join(' AND ')
+          axis_exp = "FILTER(#{axis_exp}, #{filter_exp})"
         end
 
-        if options['nonempty']
-          query = query.nonempty
+        unless options['order'].nil?
+          order = parse_order(cube, options['order'], options['order_desc'])
+          axis_exp = "ORDER(#{axis_exp}, #{order[:order]}, #{order[:desc] ? 'BDESC' : 'BASC'})"
         end
 
-        axis_idx += 1
+        # TODO: Apply pagination
+        unless options['offset'].nil?
+          axis_exp = if options['limit'].nil?
+                       "SUBSET(#{axis_exp}, #{options['offset']})"
+                     else
+                       "SUBSET(#{axis_exp}, #{options['offset']}, #{options['limit']})"
+                     end
+        end
+
+        query = query.axis(1, axis_exp)
       end
 
+      query = query.distinct if options['distinct']
+
+      query = query.nonempty if options['nonempty']
+
       # slicer axes (cut)
       if slicer_axis.size >= 1
-        puts slicer_axis.inspect
-        query = query.where(slicer_axis.values.map { |v|
+        query = query.where(slicer_axis.values.map do |v|
                               if v[:type] == :named_set
                                 "[#{v[:cut]}]"
                               else
                                 v[:cut]
                               end
-                            }.join(' * '))
+                            end.join(' * '))
       end
       query
     end

data/lib/mondrian_rest/version.rb

@@ -1,5 +1,5 @@
 module Mondrian
   module REST
-    VERSION = "0.7.9"
+    VERSION = "1.0.0"
   end
 end

data/mondrian-rest.gemspec

@@ -16,11 +16,11 @@ Gem::Specification.new do |s|
   s.files         = `git ls-files`.split("\n").reject { |f| f =~ /^spec\// }
   s.require_paths = ["lib", "lib/jars"]
 
-  s.requirements << 'jar no.ssb.jsonstat:json-stat-java, 0.2.2'
 
   s.add_runtime_dependency 'mondrian-olap', ["~> 0.8.0"]
   s.add_runtime_dependency 'grape', '~> 1.0', '>= 1.0.0'
   s.add_runtime_dependency 'writeexcel', '~> 1.0', '>= 1.0.5'
+  s.add_runtime_dependency 'activesupport', '~> 5.1', '>= 5.1.5'
 
   s.add_development_dependency "jar-dependencies", "~> 0.3.2"
   s.add_development_dependency 'rake', '~> 12.1', '>= 12.1.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mondrian-rest
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 1.0.0
 platform: java
 authors:
 - Manuel Aristarán
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2017-11-28 00:00:00.000000000 Z
+date: 2018-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -64,6 +64,26 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.0.5
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.5
+  name: activesupport
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.5
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
     requirements:
@@ -205,17 +225,6 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- lib/jars/com/codepoetics/protonpack/1.9/protonpack-1.9.jar
-- lib/jars/com/fasterxml/jackson/core/jackson-annotations/2.8.0/jackson-annotations-2.8.0.jar
-- lib/jars/com/fasterxml/jackson/core/jackson-core/2.8.5/jackson-core-2.8.5.jar
-- lib/jars/com/fasterxml/jackson/core/jackson-databind/2.8.5/jackson-databind-2.8.5.jar
-- lib/jars/com/fasterxml/jackson/datatype/jackson-datatype-guava/2.8.5/jackson-datatype-guava-2.8.5.jar
-- lib/jars/com/fasterxml/jackson/datatype/jackson-datatype-jdk8/2.8.5/jackson-datatype-jdk8-2.8.5.jar
-- lib/jars/com/fasterxml/jackson/datatype/jackson-datatype-jsr310/2.8.5/jackson-datatype-jsr310-2.8.5.jar
-- lib/jars/com/google/guava/guava/19.0/guava-19.0.jar
-- lib/jars/me/yanaga/guava-stream/1.0/guava-stream-1.0.jar
-- lib/jars/mondrian-rest_jars.rb
-- lib/jars/no/ssb/jsonstat/json-stat-java/0.2.2/json-stat-java-0.2.2.jar
 - lib/mondrian_rest.rb
 - lib/mondrian_rest/api.rb
 - lib/mondrian_rest/api_formatters.rb
@@ -224,7 +233,6 @@ files:
 - lib/mondrian_rest/formatters/csv.rb
 - lib/mondrian_rest/formatters/excel.rb
 - lib/mondrian_rest/formatters/jsonrecords.rb
-- lib/mondrian_rest/formatters/jsonstat.rb
 - lib/mondrian_rest/mondrian_ext.rb
 - lib/mondrian_rest/nest.rb
 - lib/mondrian_rest/query_helper.rb
@@ -249,8 +257,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
-requirements:
-- jar no.ssb.jsonstat:json-stat-java, 0.2.2
+requirements: []
 rubyforge_project:
 rubygems_version: 2.6.13
 signing_key:

data/lib/jars/mondrian-rest_jars.rb

@@ -1,28 +0,0 @@
-# this is a generated file, to avoid over-writing it just delete this comment
-begin
-  require 'jar_dependencies'
-rescue LoadError
-  require 'com/fasterxml/jackson/datatype/jackson-datatype-jdk8/2.8.5/jackson-datatype-jdk8-2.8.5.jar'
-  require 'com/fasterxml/jackson/core/jackson-annotations/2.8.0/jackson-annotations-2.8.0.jar'
-  require 'me/yanaga/guava-stream/1.0/guava-stream-1.0.jar'
-  require 'com/fasterxml/jackson/core/jackson-databind/2.8.5/jackson-databind-2.8.5.jar'
-  require 'no/ssb/jsonstat/json-stat-java/0.2.2/json-stat-java-0.2.2.jar'
-  require 'com/fasterxml/jackson/core/jackson-core/2.8.5/jackson-core-2.8.5.jar'
-  require 'com/fasterxml/jackson/datatype/jackson-datatype-guava/2.8.5/jackson-datatype-guava-2.8.5.jar'
-  require 'com/google/guava/guava/19.0/guava-19.0.jar'
-  require 'com/fasterxml/jackson/datatype/jackson-datatype-jsr310/2.8.5/jackson-datatype-jsr310-2.8.5.jar'
-  require 'com/codepoetics/protonpack/1.9/protonpack-1.9.jar'
-end
-
-if defined? Jars
-  require_jar( 'com.fasterxml.jackson.datatype', 'jackson-datatype-jdk8', '2.8.5' )
-  require_jar( 'com.fasterxml.jackson.core', 'jackson-annotations', '2.8.0' )
-  require_jar( 'me.yanaga', 'guava-stream', '1.0' )
-  require_jar( 'com.fasterxml.jackson.core', 'jackson-databind', '2.8.5' )
-  require_jar( 'no.ssb.jsonstat', 'json-stat-java', '0.2.2' )
-  require_jar( 'com.fasterxml.jackson.core', 'jackson-core', '2.8.5' )
-  require_jar( 'com.fasterxml.jackson.datatype', 'jackson-datatype-guava', '2.8.5' )
-  require_jar( 'com.google.guava', 'guava', '19.0' )
-  require_jar( 'com.fasterxml.jackson.datatype', 'jackson-datatype-jsr310', '2.8.5' )
-  require_jar( 'com.codepoetics', 'protonpack', '1.9' )
-end

data/lib/mondrian_rest/formatters/jsonstat.rb

@@ -1,50 +0,0 @@
-require 'java'
-
-module Mondrian::REST::Formatters
-  module JSONStat
-
-    def self.call(result, env)
-
-      mapper = Java::ComFasterxmlJacksonDatabind::ObjectMapper.new
-      mapper.registerModule(Java::NoSsbJsonstat::JsonStatModule.new)
-      mapper.registerModule(Java::ComFasterxmlJacksonDatatypeJdk8::Jdk8Module.new.configureAbsentsAsNulls(true))
-      mapper.setSerializationInclusion(Java::ComFasterxmlJacksonAnnotation::JsonInclude::Include::NON_NULL)
-      mapper.registerModule(Java::ComFasterxmlJacksonDatatypeGuava::GuavaModule.new.configureAbsentsAsNulls(false))
-
-      rs = result.to_h
-      rdims = rs[:axis_dimensions].reverse
-
-      builder = Java::NoSsbJsonstatV2::Dataset
-                  .create
-                  .withLabel('Aggregation: ')
-                  .withSource(env['REQUEST_URI'] || '')
-
-      dimensions = rdims.map.with_index do |d, i|
-        dim = Java::NoSsbJsonstatV2::Dimension
-                .create(d[:name])
-
-        if d[:type] == :measures
-          dim = dim.withMetricRole
-        elsif d[:type] == :time
-          dim = dim.withTimeRole
-        end
-
-        dim.withLabel(d[:caption])
-          .withIndexedLabels(
-            Java::ComGoogleCommonCollect::ImmutableMap.copyOf(
-              Hash[*(rs[:axes][-1 - i][:members].map { |m| [ m[:key].to_s, m[:caption] ] }.flatten)].to_java
-            )
-          )
-      end
-
-      dataset = builder
-                  .withDimensions(dimensions)
-                  .withValues(rs[:values].flatten)
-                  .build
-
-      mapper.writeValueAsString(dataset)
-
-    end
-
-  end
-end