mondrian-olap 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 62331aaa1c73a54c6adde925d5ee226ed05e73c6
-  data.tar.gz: 9c1f2557b90a4b1f9cb26da6358eaa36a1d33d79
+  metadata.gz: ebf052cd103202ea4f2a37a914d13379776349bf
+  data.tar.gz: af98519e88cc3f8a98c8fdf9538847115b499f7a
 SHA512:
-  metadata.gz: dedc6bee9ea5e9fb01f00a6de70c6d35edaa5ff6c30b80e7553db2cf30099b153056ac1979286bc4114c866c3d6e71d63723d7ce17026ee8d92e86ecf36d24cd
-  data.tar.gz: 8b39386fd21332b74baf56c47cabba12667f0d8231f99f24d8a3fd690de9a556d4e65048549ca59e53f26340b49a212b3e365d9e516ef4b90935fd42ab409015
+  metadata.gz: 801ab9633c7b0e4efeb83ddc12d7ffebfe1966c6e65065c02692b0aa662efb5552c4fda1acc83a407bb82eaacaf76223ed03d6a4c863a0c7f8673bf32413a55e
+  data.tar.gz: 0969711c0ffe2f39b4616b016718294b9b759333890e56f8ba3191f2b64472da645426ddc3e97e7b22b84afae7cb9e0599254f28be14db0875247f3968f37c4a

data/Changelog.md

@@ -1,3 +1,12 @@
+### 0.8.0 / 2016-10-26
+
+* New features
+  * upgraded to the latest Mondrian version 3.12.0.6
+  * added flush_region_cache_with_segments and flush_region_cache_with_full_names methods for partial clearing of the cache
+  * added Name() and Property() extensions for drill_through return fields
+* Bug fixes
+  * fixed retrieving of drill through results with Clob values
+
 ### 0.7.0 / 2015-12-12
 
 * New features

data/LICENSE.txt

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2010-2015 Raimonds Simanovskis
+Copyright (c) 2010-2016 Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -12,7 +12,7 @@ One of the most popular open-source OLAP engines is [Mondrian](http://mondrian.p
 
 mondrian-olap is JRuby gem which includes Mondrian OLAP engine and provides Ruby DSL for creating OLAP schemas on top of relational database schemas and provides MDX query language and query builder Ruby methods for making analytical queries.
 
-mondrian-olap is used in [eazyBI data analysis and reporting web application](https://eazybi.com). [Private eazyBI](https://eazybi.com/help/private-eazybi) can be used to create easy-to-use web based reports and dashboards on top of mondrian-olap based backend database. There is also [mondrian-olap demo Rails application for trying MDX queries](https://github.com/rsim/mondrian_demo).
+mondrian-olap is used in [eazyBI data analysis and reporting web application](https://eazybi.com). [Private eazyBI](https://eazybi.com/help/private-eazybi) can be used to create easy-to-use web based reports and dashboards on top of mondrian-olap based backend database. There is also [mondrian-olap demo Rails application for trying MDX queries](https://github.com/rsim/mondrian_demo). The [mondrian-rest](https://github.com/jazzido/mondrian-rest) uses mondrian-olap to implement a REST API interface for a Mondrian schema.
 
 USAGE
 -----

data/VERSION

@@ -1 +1 @@
-0.7.0
+0.8.0

data/lib/mondrian/olap/connection.rb

@@ -7,7 +7,8 @@ module Mondrian
         connection
       end
 
-      attr_reader :raw_connection, :raw_catalog, :raw_schema, :raw_schema_reader
+      attr_reader :raw_connection, :raw_catalog, :raw_schema,
+                  :raw_schema_reader, :raw_cache_control
 
       def initialize(params={})
         @params = params
@@ -55,6 +56,7 @@ module Mondrian
           # currently it is assumed that there is just one schema per connection catalog
           @raw_schema = @raw_catalog.getSchemas.first
           @raw_schema_reader = @raw_connection.getMondrianConnection.getSchemaReader
+          @raw_cache_control = @raw_connection.getMondrianConnection.getCacheControl(nil)
           @connected = true
           true
         end

data/lib/mondrian/olap/cube.rb

@@ -16,6 +16,8 @@ module Mondrian
     end
 
     class Cube
+      extend Forwardable
+
       def self.get(connection, name)
         if raw_cube = connection.raw_schema.getCubes.get(name)
           Cube.new(connection, raw_cube)
@@ -25,6 +27,7 @@ module Mondrian
       def initialize(connection, raw_cube)
         @connection = connection
         @raw_cube = raw_cube
+        @cache_control = CacheControl.new(@connection, self)
       end
 
       attr_reader :raw_cube
@@ -77,6 +80,9 @@ module Mondrian
         raw_member = @raw_cube.lookupMember(segment_list)
         raw_member && Member.new(raw_member)
       end
+
+      def_delegators :@cache_control, :flush_region_cache_with_segments, :flush_region_cache_with_segments
+      def_delegators :@cache_control, :flush_region_cache_with_full_names, :flush_region_cache_with_full_names
     end
 
     class Dimension
@@ -374,6 +380,10 @@ module Mondrian
         end
       end
 
+      def mondrian_member
+        @raw_member.unwrap(Java::MondrianOlap::Member.java_class)
+      end
+
       include Annotated
       def annotations
         annotations_for(@raw_member)
@@ -400,7 +410,35 @@ module Mondrian
           end
         end
       end
+    end
+
+    class CacheControl
+      def initialize(connection, cube)
+        @connection = connection
+        @cube = cube
+        @mondrian_cube = @cube.raw_cube.unwrap(Java::MondrianOlap::Cube.java_class)
+        @cache_control = @connection.raw_cache_control
+      end
 
+      def flush_region_cache_with_segments(*segment_names)
+        members = segment_names.map { |name| @cube.member_by_segments(*name).mondrian_member }
+        flush(members)
+      end
+
+      def flush_region_cache_with_full_names(*full_names)
+        members = full_names.map { |name| @cube.member(*name).mondrian_member }
+        flush(members)
+      end
+
+      private
+
+      def flush(members)
+        regions = members.map do |member|
+          @cache_control.create_member_region(member, true)
+        end
+        regions << @cache_control.create_measures_region(@mondrian_cube)
+        @cache_control.flush(@cache_control.create_crossjoin_region(*regions))
+      end
     end
   end
 end

data/lib/mondrian/olap/result.rb

@@ -242,7 +242,8 @@ module Mondrian
         end
 
         def self.generate_drill_through_sql(rolap_cell, result, params)
-          return_field_names, return_expressions, nonempty_columns = parse_return_fields(result, params)
+          nonempty_columns, return_fields = parse_return_fields(result, params)
+          return_expressions = return_fields.map{|field| field[:member]}
 
           sql_non_extended = rolap_cell.getDrillThroughSQL(return_expressions, false)
           sql_extended = rolap_cell.getDrillThroughSQL(return_expressions, true)
@@ -273,25 +274,30 @@ module Mondrian
             raise ArgumentError, "cannot parse drill through SQL: #{sql_extended}"
           end
 
-          return_column_positions = {}
-
-          if return_field_names && !return_field_names.empty?
-            new_select = extended_select.split(/,\s*/).map do |part|
-              column_name, column_alias = part.split(' as ')
-              field_name = column_alias[1..-2].gsub(' (Key)', '')
-              position = return_field_names.index(field_name) || 9999
-              return_column_positions[column_name] = position
-              [part, position]
-            end.sort_by(&:last).map(&:first).join(', ')
-
-            new_order_by = extended_order_by.split(/,\s*/).map do |part|
-              column_name, asc_desc = part.split(/\s+/)
-              position = return_column_positions[column_name] || 9999
-              [part, position]
-            end.sort_by(&:last).map(&:first).join(', ')
+          if return_fields.present?
+            new_select_columns = []
+            new_order_by_columns = []
+            new_group_by_columns = []
+            group_by = params[:group_by]
+
+            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
+            end
+
+            new_select = new_select_columns.join(', ')
+            new_order_by = new_order_by_columns.join(', ')
+            new_group_by = new_group_by_columns.join(', ')
           else
             new_select = extended_select
             new_order_by = extended_order_by
+            new_group_by = ''
           end
 
           new_from_parts = non_extended_from.split(/,\s*/)
@@ -327,40 +333,89 @@ module Mondrian
           end
 
           sql = "select #{new_select} from #{new_from} where #{new_where}"
+          sql << " group by #{new_group_by}" unless new_group_by.empty?
           sql << " order by #{new_order_by}" unless new_order_by.empty?
           sql
         end
 
         def self.parse_return_fields(result, params)
-          return_field_names = []
-          return_expressions = []
           nonempty_columns = []
+          return_fields = []
 
           if params[:return] || params[:nonempty]
             rolap_cube = result.getCube
             schema_reader = rolap_cube.getSchemaReader
+            dialect = result.getCube.getSchema.getDialect
+            sql_query = Java::mondrian.rolap.sql.SqlQuery.new(dialect)
+
+            if fields = params[:return]
+              fields = fields.split(/,\s*/) if fields.is_a? String
+              fields.each do |field|
+                return_fields << case field
+                  when /\AName\((.*)\)\z/i then
+                    { member_full_name: $1, type: :name }
+                  when /\AProperty\((.*)\s*,\s*'(.*)'\)\z/i then
+                    { member_full_name: $1, type: :property, name: $2 }
+                  else
+                    { member_full_name: field }
+                  end
+              end
 
-            if return_fields = params[:return]
-              return_fields = return_fields.split(/,\s*/) if return_fields.is_a?(String)
-              return_expressions = return_fields.map do |return_field|
+              return_fields.size.times do | i |
+                member_full_name = return_fields[i][:member_full_name]
                 begin
-                  segment_list = Java::MondrianOlap::Util.parseIdentifier(return_field)
-                  return_field_names << segment_list.to_a.last.name
+                  segment_list = Java::MondrianOlap::Util.parseIdentifier(member_full_name)
                 rescue Java::JavaLang::IllegalArgumentException
-                  raise ArgumentError, "invalid return field #{return_field}"
+                  raise ArgumentError, "invalid return field #{member_full_name}"
                 end
 
+                # if this is property field then the name is initilized already
+                return_fields[i][:name] ||= segment_list.to_a.last.name
                 level_or_member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
+                return_fields[i][:member] = level_or_member
+
+                if level_or_member.is_a? Java::MondrianOlap::Member
+                  raise ArgumentError, "cannot use calculated member #{member_full_name} as return field" if level_or_member.isCalculated
+                elsif !level_or_member.is_a? Java::MondrianOlap::Level
+                  raise ArgumentError, "return field #{member_full_name} should be level or measure"
+                end
 
-                case level_or_member
-                when Java::MondrianOlap::Level
-                  level_or_member
-                when Java::MondrianOlap::Member
-                  raise ArgumentError, "cannot use calculated member #{return_field} as return field" if level_or_member.isCalculated
-                  level_or_member
+                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
+                    end
+                  else
+                    if level_or_member.respond_to? :getKeyExp
+                      return_fields[i][:type] = :key
+                      level_or_member.getKeyExp.getExpression sql_query
+                    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
+                    end
+                  end
+
+                column_alias = if return_fields[i][:type] == :key
+                  "#{return_fields[i][:name]} (Key)"
                 else
-                  raise ArgumentError, "return field #{return_field} should be level or measure"
+                  return_fields[i][:name]
                 end
+                return_fields[i][:column_alias] = dialect.quoteIdentifier(column_alias)
               end
             end
 
@@ -370,23 +425,22 @@ module Mondrian
                 begin
                   segment_list = Java::MondrianOlap::Util.parseIdentifier(nonempty_field)
                 rescue Java::JavaLang::IllegalArgumentException
-                  raise ArgumentError, "invalid return field #{return_field}"
+                  raise ArgumentError, "invalid return field #{nonempty_field}"
                 end
                 member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
                 if member.is_a? Java::MondrianOlap::Member
-                  raise ArgumentError, "cannot use calculated member #{return_field} as nonempty field" if member.isCalculated
+                  raise ArgumentError, "cannot use calculated member #{nonempty_field} as nonempty field" if member.isCalculated
                   sql_query = member.getStarMeasure.getSqlQuery
                   member.getStarMeasure.generateExprString(sql_query)
                 else
-                  raise ArgumentError, "nonempty field #{return_field} should be measure"
+                  raise ArgumentError, "nonempty field #{nonempty_field} should be measure"
                 end
               end
             end
           end
 
-          [return_field_names, return_expressions, nonempty_columns]
+          [nonempty_columns, return_fields]
         end
-
       end
 
       def self.java_to_ruby_value(value, column_type = nil)
@@ -395,6 +449,8 @@ module Mondrian
           value
         when Java::JavaMath::BigDecimal
           BigDecimal(value.to_s)
+        when Java::JavaSql::Clob
+          clob_to_string(value)
         else
           value
         end
@@ -402,6 +458,23 @@ module Mondrian
 
       private
 
+      def self.clob_to_string(value)
+        if reader = value.getCharacterStream
+          buffered_reader = Java::JavaIo::BufferedReader.new(reader)
+          result = []
+          while str = buffered_reader.readLine
+            result << str
+          end
+          result.join("\n")
+        end
+      ensure
+        if buffered_reader
+          buffered_reader.close
+        elsif reader
+          reader.close
+        end
+      end
+
       def axes
         @axes ||= @raw_cell_set.getAxes
       end

data/spec/cube_cache_control_spec.rb

@@ -0,0 +1,267 @@
+require "spec_helper"
+
+describe "Cube" do
+  before(:all) do
+    @schema = Mondrian::OLAP::Schema.define do
+      measures_caption 'Measures caption'
+
+      cube 'Sales' do
+        description 'Sales description'
+        caption 'Sales caption'
+        annotations :foo => 'bar'
+        table 'sales'
+        visible true
+        dimension 'Gender', :foreign_key => 'customer_id' do
+          description 'Gender description'
+          caption 'Gender caption'
+          visible true
+          hierarchy :has_all => true, :primary_key => 'id' do
+            description 'Gender hierarchy description'
+            caption 'Gender hierarchy caption'
+            all_member_name 'All Genders'
+            all_member_caption 'All Genders caption'
+            table 'customers'
+            visible true
+            level 'Gender', :column => 'gender', :unique_members => true,
+                            :description => 'Gender level description', :caption => 'Gender level caption' do
+              visible true
+              # Dimension values SQL generated by caption_expression fails on PostgreSQL and MS SQL
+              if %w(mysql oracle).include?(MONDRIAN_DRIVER)
+                caption_expression do
+                  sql "'dummy'"
+                end
+              end
+            end
+          end
+        end
+        dimension 'Customers', :foreign_key => 'customer_id', :annotations => {:foo => 'bar'} do
+          hierarchy :has_all => true, :all_member_name => 'All Customers', :primary_key => 'id', :annotations => {:foo => 'bar'} do
+            table 'customers'
+            level 'Country', :column => 'country', :unique_members => true, :annotations => {:foo => 'bar'}
+            level 'State Province', :column => 'state_province', :unique_members => true
+            level 'City', :column => 'city', :unique_members => false
+            level 'Name', :column => 'fullname', :unique_members => true
+          end
+        end
+        calculated_member 'Non-USA', :annotations => {:foo => 'bar'} do
+          dimension 'Customers'
+          formula '[Customers].[All Customers] - [Customers].[USA]'
+        end
+        dimension 'Time', :foreign_key => 'time_id', :type => 'TimeDimension' do
+          hierarchy :has_all => false, :primary_key => 'id' do
+            table 'time'
+            level 'Year', :column => 'the_year', :type => 'Numeric', :unique_members => true, :level_type => 'TimeYears'
+            level 'Quarter', :column => 'quarter', :unique_members => false, :level_type => 'TimeQuarters'
+            level 'Month', :column => 'month_of_year', :type => 'Numeric', :unique_members => false, :level_type => 'TimeMonths'
+          end
+          hierarchy 'Weekly', :has_all => false, :primary_key => 'id' do
+            table 'time'
+            level 'Year', :column => 'the_year', :type => 'Numeric', :unique_members => true, :level_type => 'TimeYears'
+            level 'Week', :column => 'weak_of_year', :type => 'Numeric', :unique_members => false, :level_type => 'TimeWeeks'
+          end
+        end
+        calculated_member 'Last week' do
+          hierarchy '[Time.Weekly]'
+          formula 'Tail([Time.Weekly].[Week].Members).Item(0)'
+        end
+        measure 'Unit Sales', :column => 'unit_sales', :aggregator => 'sum', :annotations => {:foo => 'bar'}
+        measure 'Store Sales', :column => 'store_sales', :aggregator => 'sum'
+        measure 'Store Cost', :column => 'store_cost', :aggregator => 'sum', :visible => false
+      end
+    end
+    @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
+  end
+
+  describe 'cache', unless: MONDRIAN_DRIVER == 'luciddb' do
+    before(:all) do
+      @connection = ActiveRecord::Base.connection
+      @cube = @olap.cube('Sales')
+      @query = <<-SQL
+        SELECT {[Measures].[Store Cost], [Measures].[Store Sales]} ON COLUMNS
+        FROM  [Sales]
+        WHERE ([Time].[2010].[Q1], [Customers].[USA].[CA])
+      SQL
+
+      case MONDRIAN_DRIVER
+      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle'
+        @connection.execute 'CREATE TABLE sales_copy AS SELECT * FROM sales'
+      when 'mssql', 'sqlserver'
+        # Use raw_connection.execute to avoid detecting this query as a SELECT query
+        # for which executeQuery JDBC method will fail
+        @connection.raw_connection.execute 'SELECT * INTO sales_copy FROM sales'
+      end
+    end
+
+    after(:each) do
+      case MONDRIAN_DRIVER
+      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle'
+        @connection.execute 'TRUNCATE TABLE sales'
+        @connection.execute 'INSERT INTO sales SELECT * FROM sales_copy'
+      when 'mssql', 'sqlserver'
+        @connection.execute 'TRUNCATE TABLE sales'
+        @connection.execute 'INSERT INTO sales SELECT * FROM sales_copy'
+      end
+
+      @olap.flush_schema_cache
+      @olap.close
+      @olap.connect
+    end
+
+    after(:all) do
+      case MONDRIAN_DRIVER
+      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle'
+        @connection.execute 'DROP TABLE sales_copy'
+      when 'mssql', 'sqlserver'
+        @connection.execute 'DROP TABLE sales_copy'
+      end
+    end
+
+    it 'should clear cache for deleted data at lower level with segments' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        DELETE FROM sales
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA'
+                                          AND city = 'Berkeley')
+      SQL
+      @cube.flush_region_cache_with_segments(%w(Time 2010 Q1), %w(Customers USA CA))
+      @olap.execute(@query).values.should == [6756.4296, 11156.28]
+    end
+
+    it 'should clear cache for deleted data at same level with segments' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        DELETE FROM sales
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA')
+      SQL
+      @cube.flush_region_cache_with_segments(%w(Time 2010 Q1), %w(Customers USA CA))
+      @olap.execute(@query).values.should == [nil, nil]
+    end
+
+    it 'should clear cache for update data at lower level with segments' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        UPDATE sales SET
+            store_sales = store_sales + 1,
+            store_cost = store_cost + 1
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA'
+                                          AND city = 'Berkeley')
+      SQL
+      @cube.flush_region_cache_with_segments(%w(Time 2010 Q1), %w(Customers USA CA))
+      @olap.execute(@query).values.should == [6891.553, 11391.4]
+    end
+
+    it 'should clear cache for update data at same level with segments' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        UPDATE sales SET
+            store_sales = store_sales + 1,
+            store_cost = store_cost + 1
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA')
+      SQL
+      @cube.flush_region_cache_with_segments(%w(Time 2010 Q1), %w(Customers USA CA))
+      @olap.execute(@query).values.should == [6935.553, 11435.4]
+    end
+
+    it 'should clear cache for deleted data at lower level with members' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        DELETE FROM sales
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA'
+                                          AND city = 'Berkeley')
+      SQL
+      @cube.flush_region_cache_with_full_names('[Time].[2010].[Q1]', '[Customers].[USA].[CA]')
+      @olap.execute(@query).values.should == [6756.4296, 11156.28]
+    end
+
+    it 'should clear cache for deleted data at same level with members' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        DELETE FROM sales
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA')
+      SQL
+      @cube.flush_region_cache_with_full_names('[Time].[2010].[Q1]', '[Customers].[USA].[CA]')
+      @olap.execute(@query).values.should == [nil, nil]
+    end
+
+    it 'should clear cache for update data at lower level with members' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        UPDATE sales SET
+            store_sales = store_sales + 1,
+            store_cost = store_cost + 1
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA'
+                                          AND city = 'Berkeley')
+      SQL
+      @cube.flush_region_cache_with_full_names('[Time].[2010].[Q1]', '[Customers].[USA].[CA]')
+      @olap.execute(@query).values.should == [6891.553, 11391.4]
+    end
+
+    it 'should clear cache for update data at same level with members' do
+      @olap.execute(@query).values.should == [6890.553, 11390.4]
+      @connection.execute <<-SQL
+        UPDATE sales SET
+            store_sales = store_sales + 1,
+            store_cost = store_cost + 1
+        WHERE  time_id IN (SELECT id
+                           FROM   TIME
+                           WHERE  the_year = 2010
+                                  AND quarter = 'Q1')
+               AND customer_id IN (SELECT id
+                                   FROM   customers
+                                   WHERE  country = 'USA'
+                                          AND state_province = 'CA')
+      SQL
+      @cube.flush_region_cache_with_full_names('[Time].[2010].[Q1]', '[Customers].[USA].[CA]')
+      @olap.execute(@query).values.should == [6935.553, 11435.4]
+    end
+  end
+end

data/spec/cube_spec.rb

@@ -433,7 +433,5 @@ describe "Cube" do
     it "should get member empty annotations" do
       @cube.member('[Customers].[USA]').annotations.should == {}
     end
-
   end
-
 end

data/spec/fixtures/MondrianTest.xml

@@ -87,6 +87,7 @@ fullname
           </SQL>
         </OrdinalExpression>
         <Property name="Gender" column="gender"/>
+        <Property name="Description" column="description"/>
       </Level>
     </Hierarchy>
   </Dimension>

data/spec/fixtures/MondrianTestOracle.xml

@@ -87,6 +87,7 @@ FULLNAME
           </SQL>
         </OrdinalExpression>
         <Property name="Gender" column="GENDER"/>
+        <Property name="Description" column="DESCRIPTION"/>
       </Level>
     </Hierarchy>
   </Dimension>

data/spec/query_spec.rb

@@ -817,8 +817,7 @@ describe "Query" do
     end
 
     it "should return correct row value types" do
-      @drill_through.rows.first.map(&:class).should ==
-        case MONDRIAN_DRIVER
+      expected_value_types = case MONDRIAN_DRIVER
         when "oracle"
           [
             BigDecimal, String, BigDecimal, BigDecimal, BigDecimal,
@@ -831,7 +830,8 @@ describe "Query" do
           [
             Fixnum, String, Fixnum, Fixnum, Fixnum,
             String, String, String, String, String, String,
-            String, String, String, BigDecimal,
+            # last one can be BigDecimal or Fixnum, probably depends on MS SQL version
+            String, String, String, Numeric,
             String,
             BigDecimal
           ]
@@ -844,6 +844,10 @@ describe "Query" do
             BigDecimal
           ]
         end
+
+      @drill_through.rows.first.each_with_index do |value, i|
+        value.should be_a expected_value_types[i]
+      end
     end
 
     it "should return only specified max rows" do
@@ -857,8 +861,7 @@ describe "Query" do
       @query = @olap.from('Sales')
       @result = @query.columns('[Measures].[Unit Sales]', '[Measures].[Store Sales]').
         rows('[Product].children').
-        # where('[Time].[2010].[Q1]', '[Customers].[USA].[CA]').
-        where('[Time].[2010].[Q1]').
+        where('[Time].[2010].[Q1]', '[Time].[2010].[Q2]').
         execute
     end
 
@@ -870,9 +873,9 @@ describe "Query" do
         '[Measures].[Unit Sales]', '[Measures].[Store Sales]'
       ])
       @drill_through.column_labels.should == [
-        "Month",
-        "City",
-        "Product Family",
+        "Month (Key)",
+        "City (Key)",
+        "Product Family (Key)",
         "Unit Sales", "Store Sales"
       ]
     end
@@ -888,6 +891,74 @@ describe "Query" do
       @drill_through.rows.all?{|r| r.any?{|c| c}}.should be_true
     end
 
+    it "should return member name and property values" do
+      @drill_through = @result.drill_through(row: 0, column: 0,
+        return: [
+          "Name([Customers].[Name])",
+          "Property([Customers].[Name], 'Gender')",
+          "Property([Customers].[Name], 'Description')"
+        ]
+      )
+      @drill_through.column_labels.should == [ "Name", "Gender", "Description" ]
+      @drill_through.rows.should == @sql.select_rows(<<-SQL
+        SELECT
+          customers.fullname,
+          customers.gender,
+          customers.description
+        FROM
+          sales,
+          customers,
+          time,
+          products,
+          product_classes
+        WHERE
+          (time.quarter = 'Q1' OR time.quarter = 'Q2') AND
+          time.the_year = 2010 AND
+          product_classes.product_family = 'Drink' AND
+          products.product_class_id = product_classes.id AND
+          sales.product_id = products.id AND
+          sales.time_id = time.id AND
+          customers.id = sales.customer_id
+        ORDER BY
+          customers.fullname,
+          customers.gender,
+          customers.description
+      SQL
+      )
+    end
+
+    it "should group by" do
+      @drill_through = @result.drill_through(row: 0, column: 0,
+        return: [
+          "[Product].[Product Family]",
+          "[Measures].[Unit Sales]",
+          "[Measures].[Store Cost]"
+        ],
+        group_by: true
+      )
+      @drill_through.column_labels.should == [ "Product Family (Key)", "Unit Sales", "Store Cost" ]
+      @drill_through.rows.should == @sql.select_rows(<<-SQL
+        SELECT
+          product_classes.product_family,
+          SUM(sales.unit_sales) AS unit_sales,
+          SUM(sales.store_cost) AS store_cost
+        FROM
+          sales,
+          time,
+          products,
+          product_classes
+        WHERE
+          (time.quarter = 'Q1' OR time.quarter = 'Q2') AND
+          time.the_year = 2010 AND
+          product_classes.product_family = 'Drink' AND
+          products.product_class_id = product_classes.id AND
+          sales.product_id = products.id AND
+          sales.time_id = time.id
+        GROUP BY
+          product_classes.product_family
+      SQL
+      )
+    end
   end
 
   describe "drill through statement" do

data/spec/rake_tasks.rb

@@ -40,6 +40,14 @@ namespace :db do
         t.string      :lname, :limit => 30
         t.string      :fullname, :limit => 60
         t.string      :gender, :limit => 30
+        # Mondrian does not support properties with Oracle CLOB type
+        # as it tries to GROUP BY all columns when loading a dimension table
+        if MONDRIAN_DRIVER == 'oracle'
+          t.string      :description, :limit => 4000
+        else
+          t.text        :description
+        end
+
       end
 
       create_table :sales, :force => true, :id => false do |t|
@@ -207,7 +215,8 @@ namespace :db do
           :fname => "First#{i}",
           :lname => "Last#{i}",
           :fullname => "First#{i} Last#{i}",
-          :gender => i % 2 == 0 ? "M" : "F"
+          :gender => i % 2 == 0 ? "M" : "F",
+          :description => 100.times.map{"1234567890"}.join("\n")
         )
       end
     end

data/spec/spec_helper.rb

@@ -119,6 +119,7 @@ when 'mssql'
   url << ";instance=#{DATABASE_INSTANCE}" if DATABASE_INSTANCE
   AR_CONNECTION_PARAMS = {
     :adapter  => 'jdbc',
+    :dialect  => 'Microsoft SQL Server',
     :driver   => JDBC_DRIVER,
     :url      => url,
     :username => CONNECTION_PARAMS[:username],

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mondrian-olap
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Raimonds Simanovskis
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-12-12 00:00:00.000000000 Z
+date: 2016-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -56,14 +56,14 @@ dependencies:
   name: rspec
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.14'
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
@@ -168,14 +168,14 @@ dependencies:
   name: activerecord-oracle_enhanced-adapter
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.6
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.5.6
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
@@ -250,7 +250,7 @@ files:
 - lib/mondrian/jars/javacup-10k.jar
 - lib/mondrian/jars/log4j-1.2.17.jar
 - lib/mondrian/jars/log4j.properties
-- lib/mondrian/jars/mondrian-3.11.0.0-353.jar
+- lib/mondrian/jars/mondrian-3.12.0.6-237.jar
 - lib/mondrian/jars/olap4j-1.2.0.jar
 - lib/mondrian/olap.rb
 - lib/mondrian/olap/connection.rb
@@ -264,6 +264,7 @@ files:
 - lib/mondrian/olap/version.rb
 - spec/connection_role_spec.rb
 - spec/connection_spec.rb
+- spec/cube_cache_control_spec.rb
 - spec/cube_spec.rb
 - spec/fixtures/MondrianTest.xml
 - spec/fixtures/MondrianTestOracle.xml
@@ -300,6 +301,7 @@ summary: JRuby API for Mondrian OLAP Java library
 test_files:
 - spec/connection_role_spec.rb
 - spec/connection_spec.rb
+- spec/cube_cache_control_spec.rb
 - spec/cube_spec.rb
 - spec/fixtures/MondrianTest.xml
 - spec/fixtures/MondrianTestOracle.xml