mondrian-olap 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b807f5866de6c32810049ddaa15cf62725bdd14db8c92be93828172cc4a0c6
-  data.tar.gz: 34eb04b5545e340509f8699ce499a447a32effee40749e1b580d6063b7d596cf
+  metadata.gz: f016aae4b1d6d9f4138ae3bded251944cf7fcfe8f1bd0579df7f962eb1a52d03
+  data.tar.gz: 8b5a4d5c4526f2fd7a239c3dccd57c7d08f5f1d842354fae5bd13f21920e7e73
 SHA512:
-  metadata.gz: 503b38add95142332eb40c8885075461b98bb2cbbb2f49446b213754a593b94fd2226a965e2d90383e96b163eeab180a5de999cc3631b347060e5c59323ef83b
-  data.tar.gz: 7a9e42bda5d2acc62ccda1da5ab63bb63ad51c49828ed08e89a83e5c4e1a2742118be320c925e7771e29e95166b2e73e26420ac5f7132c4ffb3a2e4221c8ce83
+  metadata.gz: 7a9b3633a62cef270a163c25c5f1511442938b6705b2385fb2b7e2c2a8f9a1a2041b3f041af0be995970fa86307c4fe1af3c0fb94488c86cc1ec617b93acfe3b
+  data.tar.gz: 82ee663a5017af81ed6089f6f162e6d8a98458c1a7afb50e5bf5c3b27ea7422b91e81cc38e099a0a23d7ae99368b8c425083c55b6a6d1f1b75a04566cc664b0a

data/Changelog.md

@@ -1,4 +1,24 @@
-### Master
+### 1.3.0 / 2023-06-02
+
+* New features
+  * Upgrade to the latest Mondrian version 9.3.0.0 with additional patches
+  * Additional Mondrian patches and improvements
+    * Support for ClickHouse database
+    * Support for MariaDB ColumnStore engine
+    * Improve Aggregate performance of large compound slicers when mondrian.rolap.EnableInMemoryRollup=false
+    * Improve performance of Mondrian member property value lookup
+    * Set dynamic Mondrian connection pool size based on mondrian.rolap.maxSqlThreads property
+    * Skip registration of MondrianOlap4jDriver if mondrian.olap4j.registerDriver=false
+    * Enable Mondrian supportsMultiValueInExpr for PostgreSQL and Oracle
+  * Upgrade to log4j2
+  * Support instance parameter for SQL Server connection
+  * Allow to specify high_cardinality for dimension
+  * Remove deprecated jTDS driver support, use MS JDBC driver instead
+  * Remove user defined functions and formatters in JavaScript and CoffeeScript as they are not supported since JVM 8
+  * Upgrade tests to use the later ActiveRecord and RSpec versions
+  * Tested with JRuby 9.4 and JVM 17
+* Bug fixes
+  * Patch for MONDRIAN-2714 (fixed support for MySQL JDBC driver version 8.0.23)
 
 ### 1.2.0 / 2021-03-06
 

data/README.md

@@ -215,8 +215,8 @@ See more examples of dimension and member queries in `spec/cube_spec.rb`.
 
 ### User defined MDX functions
 
-You can define new MDX functions using JavaScript, CoffeeScript or Ruby language that you can later use
-either in calculated member formulas or in MDX queries. Here are examples of user defined functions in Ruby:
+You can define new MDX functions using Ruby that you can later use either in calculated member formulas or in MDX queries.
+Here are examples of user defined functions in Ruby:
 
 ```ruby
 schema = Mondrian::OLAP::Schema.define do
@@ -273,9 +273,9 @@ See more examples of data access roles in `spec/connection_role_spec.rb`.
 REQUIREMENTS
 ------------
 
-mondrian-olap gem is compatible with JRuby version 9.2.x, and Java 8 and 11 VM. mondrian-olap works only with JRuby and not with other Ruby implementations as it includes Mondrian OLAP Java libraries.
+mondrian-olap gem is compatible with JRuby versions 9.3.x and 9.4.x, JVM 8, 11, and 17. mondrian-olap works only with JRuby and not with other Ruby implementations as it includes Mondrian OLAP Java libraries.
 
-mondrian-olap supports MySQL, PostgreSQL, Oracle, Microsoft SQL Server, Vertica and Snowflake databases as well as other databases that are supported by Mondrian OLAP engine (using jdbc_driver and jdbc_url connection parameters). When using MySQL or PostgreSQL databases then install jdbc-mysql or jdbc-postgres gem and require "jdbc/mysql" or "jdbc/postgres" to load the corresponding JDBC database driver. When using Oracle then require Oracle JDBC driver (`ojdbc8.jar` for Java 8). When using SQL Server you can choose between the jTDS or Microsoft JDBC drivers. If you use jTDS require "jdbc/jtds". If you use the Microsoft JDBC driver then require the latest `mssql-jdbc-*.jar`. When using Vertica or Snowflake then require corresponding JDBC drivers.
+mondrian-olap supports MySQL, PostgreSQL, Oracle, Microsoft SQL Server, Vertica, Snowflake, and ClickHouse databases as well as other databases that are supported by Mondrian OLAP engine (using jdbc_driver and jdbc_url connection parameters). When using MySQL or PostgreSQL databases then install jdbc-mysql or jdbc-postgres gem and require "jdbc/mysql" or "jdbc/postgres" to load the corresponding JDBC database driver. When using Oracle then require Oracle JDBC driver `ojdbc*.jar`. When using MS SQL Server you then use the Microsoft JDBC driver `mssql-jdbc-*.jar`. When using Vertica, Snowflake, or ClickHouse then require corresponding JDBC drivers.
 
 INSTALL
 -------

data/VERSION

@@ -1 +1 @@
-1.2.0
+1.3.0

data/lib/mondrian/olap/connection.rb

@@ -289,6 +289,14 @@ module Mondrian
         true
       end
 
+      def jdbc_uri
+        if respond_to?(method_name = "jdbc_uri_#{@driver}", true)
+          send method_name
+        else
+          raise ArgumentError, 'unknown JDBC driver'
+        end
+      end
+
       private
 
       def connection_string
@@ -306,17 +314,10 @@ module Mondrian
         string + (@params[:catalog] ? "Catalog=#{catalog_uri}" : "CatalogContent=#{quote_string(catalog_content)}")
       end
 
-      def jdbc_uri
-        if respond_to?(method_name = "jdbc_uri_#{@driver}", true)
-          send method_name
-        else
-          raise ArgumentError, 'unknown JDBC driver'
-        end
-      end
-
       def jdbc_uri_generic(options = {})
         uri_prefix = options[:uri_prefix] || "jdbc:#{@driver}://"
-        uri = "#{uri_prefix}#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}"
+        port = @params[:port] || options[:default_port]
+        uri = "#{uri_prefix}#{@params[:host]}#{port && ":#{port}"}"
         uri += "/#{@params[:database]}" if @params[:database] && options[:add_database] != false
         properties = new_empty_properties
         properties.merge!(options[:default_properties]) if options[:default_properties].is_a?(Hash)
@@ -343,6 +344,7 @@ module Mondrian
 
       alias_method :jdbc_uri_postgresql, :jdbc_uri_generic
       alias_method :jdbc_uri_vertica, :jdbc_uri_generic
+      alias_method :jdbc_uri_mariadb, :jdbc_uri_generic
 
       def jdbc_uri_oracle
         # connection using TNS alias
@@ -360,18 +362,12 @@ module Mondrian
         end
       end
 
-      def jdbc_uri_mssql
-        jdbc_uri_generic(
-          uri_prefix: 'jdbc:jtds:sqlserver://', separator: ';', first_separator: ';',
-          default_properties: @params.slice(:instance, :domain, :appname)
-        )
-      end
-
       JDBC_SQLSERVER_PARAM_PROPERTIES = {
         database: 'databaseName',
         integrated_security: 'integratedSecurity',
         application_name: 'applicationName',
-        instance_name: 'instanceName'
+        instance_name: 'instanceName',
+        instance: 'instanceName'
       }
 
       def jdbc_uri_sqlserver
@@ -404,6 +400,15 @@ module Mondrian
         )
       end
 
+      def jdbc_uri_clickhouse
+        protocol_prefix = if protocol = @params[:protocol]
+          raise ArgumentError, "invalid protocol #{protocol}" unless protocol =~ /\A\w+\z/
+          ":#{protocol}"
+        end
+        uri_prefix = "jdbc:ch#{protocol_prefix}://"
+        jdbc_uri_generic(uri_prefix: uri_prefix)
+      end
+
       def jdbc_uri_jdbc
         @params[:jdbc_url] or raise ArgumentError, 'missing jdbc_url parameter'
       end
@@ -411,10 +416,11 @@ module Mondrian
       JDBC_DRIVER_CLASS = {
         'postgresql' => 'org.postgresql.Driver',
         'oracle' => 'oracle.jdbc.OracleDriver',
-        'mssql' => 'net.sourceforge.jtds.jdbc.Driver',
         'sqlserver' => 'com.microsoft.sqlserver.jdbc.SQLServerDriver',
         'vertica' => 'com.vertica.jdbc.Driver',
-        'snowflake' => 'net.snowflake.client.jdbc.SnowflakeDriver'
+        'snowflake' => 'net.snowflake.client.jdbc.SnowflakeDriver',
+        'clickhouse' => 'com.clickhouse.jdbc.ClickHouseDriver',
+        'mariadb' => 'org.mariadb.jdbc.Driver'
       }
 
       def jdbc_driver
@@ -474,6 +480,9 @@ module Mondrian
         end
       end
 
+      # Starting from Mondrian 9.2 additional QueryBody plan string is added at the end which will be ignored.
+      QUERY_BODY_PLAN_REGEXP = /\AQueryBody:/
+
       class ProfilingHandler
         java_implements Java::mondrian.spi.ProfileHandler
         attr_reader :plan
@@ -481,7 +490,11 @@ module Mondrian
 
         java_signature 'void explain(String plan, mondrian.olap.QueryTiming timing)'
         def explain(plan, timing)
-          @plan = plan
+          if @plan
+            @plan += "\n" + plan unless plan =~ QUERY_BODY_PLAN_REGEXP
+          else
+            @plan = plan
+          end
           @timing = timing
         end
       end

data/lib/mondrian/olap/cube.rb

@@ -56,15 +56,35 @@ module Mondrian
       end
 
       def dimensions
-        @dimenstions ||= @raw_cube.getDimensions.map{|d| Dimension.new(self, d)}
+        @dimenstions ||= @raw_cube.getDimensions.map { |d| dimension_from_raw(d) }
       end
 
       def dimension_names
-        dimensions.map{|d| d.name}
+        dimensions.map(&:name)
       end
 
       def dimension(name)
-        dimensions.detect{|d| d.name == name}
+        if @dimensions
+          @dimensions.detect { |d| d.name == name }
+        elsif raw_dimension = @raw_cube.getDimensions.detect { |d| d.getName == name }
+          dimension_from_raw(raw_dimension)
+        end
+      end
+
+      def hierarchies
+        @hierarchies ||= @raw_cube.getHierarchies.map { |h| hierarchy_from_raw(h) }
+      end
+
+      def hierarchy_names
+        hierarchies.map(&:name)
+      end
+
+      def hierarchy(name)
+        if @hierarchies
+          @hierarchies.detect { |h| h.name == name }
+        elsif raw_hierarchy = @raw_cube.getHierarchies.detect { |h| h.getName == name }
+          hierarchy_from_raw(raw_hierarchy)
+        end
       end
 
       def query
@@ -85,6 +105,16 @@ module Mondrian
 
       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
+
+      private
+
+      def dimension_from_raw(raw_dimension)
+        Dimension.new(self, raw_dimension)
+      end
+
+      def hierarchy_from_raw(raw_hierarchy)
+        Hierarchy.new(dimension_from_raw(raw_hierarchy.getDimension), raw_hierarchy)
+      end
     end
 
     class Dimension
@@ -156,7 +186,7 @@ module Mondrian
         @raw_hierarchy = raw_hierarchy
       end
 
-      attr_reader :raw_hierarchy
+      attr_reader :raw_hierarchy, :dimension
 
       def name
         @name ||= @raw_hierarchy.getName
@@ -170,6 +200,10 @@ module Mondrian
         @caption ||= @raw_hierarchy.getCaption
       end
 
+      def dimension_name
+        @dimension.name
+      end
+
       def levels
         @levels = @raw_hierarchy.getLevels.map{|l| Level.new(self, l)}
       end
@@ -257,6 +291,10 @@ module Mondrian
         @cardinality = @raw_level.getCardinality
       end
 
+      def cardinality=(value)
+        mondrian_level.setApproxRowCount(value || Java::JavaLang::Integer::MIN_VALUE)
+      end
+
       def members_count
         @members_count ||= begin
           if cardinality >= 0
@@ -275,6 +313,10 @@ module Mondrian
         end
       end
 
+      def mondrian_level
+        @raw_level.unwrap(Java::MondrianOlap::Level.java_class)
+      end
+
       include Annotated
       def annotations
         annotations_for(@raw_level)

data/lib/mondrian/olap/error.rb

@@ -39,7 +39,7 @@ module Mondrian
 
       def profiling_timing_string
         if profiling_timing && (timing_string = profiling_timing.toString)
-          timing_string.gsub("\r\n", "\n")
+          timing_string.gsub("\r\n", "\n").sub(Mondrian::OLAP::Result::QUERY_TIMING_CUMULATIVE_REGEXP, '')
         end
       end
 
@@ -76,7 +76,15 @@ module Mondrian
           f.accessible = true
           if cell_set = f.value(statement)
             cell_set.close
-            @profiling_handler = statement.getProfileHandler
+            # Starting from Mondrian 9.2 query plan was not available in case of error, need to get it explicitly.
+            if (@profiling_handler = statement.getProfileHandler) && !@profiling_handler.timing
+              query = statement.getQuery
+              string_writer = Java::java.io.StringWriter.new
+              print_writer = Java::java.io.PrintWriter.new(string_writer)
+              query.explain(print_writer)
+              print_writer.close
+              @profiling_handler.explain(string_writer.toString, cell_set.getQueryTiming)
+            end
           end
         end
       end

data/lib/mondrian/olap/query.rb

@@ -296,6 +296,7 @@ module Mondrian
       }
 
       def members_to_mdx(members)
+        members ||= []
         # if only one member which does not end with ] or .Item(...)
         # then assume it is expression which returns set
         # TODO: maybe always include also single expressions in {...} to avoid some edge cases?

data/lib/mondrian/olap/result.rb

@@ -127,9 +127,11 @@ module Mondrian
         profiling_timing && profiling_timing.markFull(name, duration)
       end
 
+      QUERY_TIMING_CUMULATIVE_REGEXP = /\AQuery Timing \(Cumulative\):\n/
+
       def profiling_timing_string
         if profiling_timing && (timing_string = profiling_timing.toString)
-          timing_string.gsub("\r\n", "\n")
+          timing_string.gsub("\r\n", "\n").sub(QUERY_TIMING_CUMULATIVE_REGEXP, '')
         end
       end
 
@@ -147,13 +149,12 @@ module Mondrian
             cell_params << Java::JavaLang::Integer.new(axis_position)
           end
           raw_cell = @raw_cell_set.getCell(cell_params)
-          DrillThrough.from_raw_cell(raw_cell, params)
+          DrillThrough.from_raw_cell(raw_cell, params.merge(role_name: @connection.role_name))
         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')
@@ -161,14 +162,18 @@ module Mondrian
           rolap_cell = cell_field.value(raw_cell)
 
           if params[:return] || rolap_cell.canDrillThrough
-            sql_statement = drill_through_internal(rolap_cell, params)
+            sql_statement, return_fields = drill_through_internal(rolap_cell, params)
             raw_result_set = sql_statement.getWrappedResultSet
-            new(raw_result_set)
+            raw_cube = raw_cell.getCellSet.getMetaData.getCube
+            new(raw_result_set, return_fields: return_fields, raw_cube: raw_cube, role_name: params[:role_name])
           end
         end
 
-        def initialize(raw_result_set)
+        def initialize(raw_result_set, options = {})
           @raw_result_set = raw_result_set
+          @return_fields = options[:return_fields]
+          @raw_cube = options[:raw_cube]
+          @role_name = options[:role_name]
         end
 
         def column_types
@@ -207,7 +212,7 @@ module Mondrian
             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
+            can_access_row_values?(row_values) ? row_values : fetch
           else
             @raw_result_set.close
             nil
@@ -226,6 +231,35 @@ module Mondrian
 
         private
 
+        def can_access_row_values?(row_values)
+          return true unless @role_name
+
+          member_full_name_columns_indexes.each do |column_indexes|
+            segment_names = [@return_fields[column_indexes.first][:member].getHierarchy.getName]
+            column_indexes.each { |i| segment_names << row_values[i].to_s }
+            segment_list = Java::OrgOlap4jMdx::IdentifierNode.ofNames(*segment_names).getSegmentList
+            return false unless @raw_cube.lookupMember(segment_list)
+          end
+
+          true
+        end
+
+        def member_full_name_columns_indexes
+          @member_full_name_columns_indexes ||= begin
+            fieldset_columns = Hash.new { |h, k| h[k] = Array.new }
+            column_labels.each_with_index do |label, i|
+              # Find all role restriction columns with a label pattern "_level:<Fieldset ID>:<Level depth>"
+              if label =~ /\A_level:(\d+):(\d+)\z/
+                # Group by fieldset ID with a compound value of level depth and column index
+                fieldset_columns[$1] << [$2.to_i, i]
+              end
+            end
+            # For each fieldset create an array with columns indexes sorted by level depth
+            fieldset_columns.each { |k, v| fieldset_columns[k] = v.sort_by(&:first).map(&:last) }
+            fieldset_columns.values
+          end
+        end
+
         def metadata
           @metadata ||= @raw_result_set.getMetaData
         end
@@ -238,7 +272,7 @@ module Mondrian
           result_field.accessible = true
           result = result_field.value(rolap_cell)
 
-          sql = generate_drill_through_sql(rolap_cell, result, params)
+          sql, return_fields = generate_drill_through_sql(rolap_cell, result, params)
 
           # Choose the appropriate scrollability. If we need to start from an
           # offset row, it is useful that the cursor is scrollable, but not
@@ -248,10 +282,8 @@ module Mondrian
           connection = statement.getMondrianConnection
           result_set_type = Java::JavaSql::ResultSet::TYPE_FORWARD_ONLY
           result_set_concurrency = Java::JavaSql::ResultSet::CONCUR_READ_ONLY
-          schema = statement.getSchema
-          dialect = schema.getDialect
 
-          Java::MondrianRolap::RolapUtil.executeQuery(
+          sql_statement = Java::MondrianRolap::RolapUtil.executeQuery(
             connection.getDataSource,
             sql,
             nil,
@@ -267,11 +299,12 @@ module Mondrian
             result_set_concurrency,
             nil
           )
+          [sql_statement, return_fields]
         end
 
         def self.generate_drill_through_sql(rolap_cell, result, params)
           nonempty_columns, return_fields = parse_return_fields(result, params)
-          return_expressions = return_fields.map{|field| field[:member]}
+          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)
@@ -314,9 +347,11 @@ module Mondrian
 
             return_fields.size.times do |i|
               column_alias = return_fields[i][:column_alias]
+              column_expression = return_fields[i][:column_expression]
+              quoted_table_name = return_fields[i][:quoted_table_name]
               new_select_columns <<
-                if column_expression = return_fields[i][:column_expression]
-                  new_order_by_columns << column_expression
+                if column_expression && (!quoted_table_name || extended_from.include?(quoted_table_name))
+                  new_order_by_columns << column_expression unless return_fields[i][:name].start_with?('_level:')
                   new_group_by_columns << column_expression if group_by && return_fields[i][:type] != :measure
                   "#{column_expression} AS #{column_alias}"
                 else
@@ -337,12 +372,9 @@ module Mondrian
           outer_join_from_parts = extended_from.split(/,\s*/) - new_from_parts
           where_parts = extended_where.split(' and ')
 
-          # reverse outer_join_from_parts to support dimensions with several table joins
-          # where join with detailed level table should be constructed first
-          outer_join_from_parts.reverse.each do |part|
+          outer_join_from_parts.each do |part|
             part_elements = part.split(/\s+/)
             # first is original table, then optional 'as' and the last is alias
-            table_name = part_elements.first
             table_alias = part_elements.last
             join_conditions = where_parts.select do |where_part|
               where_part.include?(" = #{table_alias}.")
@@ -368,7 +400,7 @@ module Mondrian
           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
+          [sql, return_fields]
         end
 
         def self.parse_return_fields(result, params)
@@ -396,8 +428,14 @@ module Mondrian
 
               # Old versions of Oracle had a limit of 30 character identifiers.
               # Do not limit it for other databases (as e.g. in MySQL aliases can be longer than column names)
-              max_alias_length = dialect.getMaxColumnNameLength
-              max_alias_length = nil if max_alias_length && max_alias_length > 30
+              max_alias_length = dialect.getMaxColumnNameLength # 0 means that there is no limit
+              max_alias_length = nil if max_alias_length && (max_alias_length > 30 || max_alias_length == 0)
+              sql_options = {
+                dialect: dialect,
+                sql_query: sql_query,
+                max_alias_length: max_alias_length,
+                params: params
+              }
 
               return_fields.size.times do |i|
                 member_full_name = return_fields[i][:member_full_name]
@@ -418,44 +456,7 @@ module Mondrian
                   raise ArgumentError, "return field #{member_full_name} should be level or measure"
                 end
 
-                return_fields[i][:column_expression] = case return_fields[i][:type]
-                when :name
-                  if level_or_member.respond_to? :getNameExp
-                    level_or_member.getNameExp.getExpression sql_query
-                  end
-                when :property
-                  if property = level_or_member.getProperties.to_a.detect{|p| p.getName == return_fields[i][:name]}
-                    # property.getExp is a protected method therefore
-                    # use a workaround to get the value from the field
-                    f = property.java_class.declared_field("exp")
-                    f.accessible = true
-                    if column = f.value(property)
-                      column.getExpression sql_query
-                    end
-                  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
-                  return_fields[i][:name]
-                end
-                return_fields[i][:column_alias] = dialect.quoteIdentifier(
-                  max_alias_length ? column_alias[0, max_alias_length] : column_alias
-                )
+                add_sql_attributes return_fields[i], sql_options
               end
             end
 
@@ -479,8 +480,76 @@ module Mondrian
             end
           end
 
+          if params[:role_name].present?
+            add_role_restricition_fields return_fields, sql_options
+          end
+
           [nonempty_columns, return_fields]
         end
+
+        def self.add_sql_attributes(field, options = {})
+          member = field[:member]
+          dialect = options[:dialect]
+          sql_query = options[:sql_query]
+          max_alias_length = options[:max_alias_length]
+          params = options[:params]
+
+          if table_name = (member.try(:getTableName) || member.try(:getMondrianDefExpression).try(:table))
+            field[:quoted_table_name] = dialect.quoteIdentifier(table_name)
+          end
+
+          field[:column_expression] =
+            case field[:type]
+            when :name
+              if member.respond_to? :getNameExp
+                member.getNameExp.getExpression sql_query
+              end
+            when :property
+              if property = member.getProperties.to_a.detect { |p| p.getName == field[: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
+            when :name_or_key
+              member.getNameExp&.getExpression(sql_query) || member.getKeyExp&.getExpression(sql_query)
+            else
+              if member.respond_to? :getKeyExp
+                field[:type] = :key
+                member.getKeyExp.getExpression sql_query
+              else
+                field[:type] = :measure
+                column_expression = member.getMondrianDefExpression.getExpression sql_query
+                if params[:group_by]
+                  member.getAggregator.getExpression column_expression
+                else
+                  column_expression
+                end
+              end
+            end
+
+          column_alias = field[:type] == :key ? "#{field[:name]} (Key)" : field[:name]
+          field[:column_alias] = dialect.quoteIdentifier(
+            max_alias_length ? column_alias[0, max_alias_length] : column_alias
+          )
+        end
+
+        def self.add_role_restricition_fields(fields, options = {})
+          # For each unique level field add a set of fields to be able to build level member full name from database query results
+          fields.map { |f| f[:member] }.uniq.each_with_index do |level_or_member, i|
+            next if level_or_member.is_a?(Java::MondrianOlap::Member)
+            current_level = level_or_member
+            loop do
+              # Create an additional field name using a pattern "_level:<Fieldset ID>:<Level depth>"
+              fields << {member: current_level, type: :name_or_key, name: "_level:#{i}:#{current_level.getDepth}"}
+              add_sql_attributes fields.last, options
+              break unless (current_level = current_level.getParentLevel) and !current_level.isAll
+            end
+          end
+        end
       end
 
       def self.java_to_ruby_value(value, column_type = nil)

data/lib/mondrian/olap/schema.rb

@@ -95,7 +95,9 @@ module Mondrian
           :type,
           # The name of the column in the fact table which joins to the leaf level of this dimension.
           # Required in a private Dimension or a DimensionUsage, but not in a public Dimension.
-          :foreign_key
+          :foreign_key,
+          # Flag to mark this dimension as a high cardinality one and avoid caching.
+          :high_cardinality
         data_dictionary_names :foreign_key # values in XML will be uppercased when using Oracle driver
         elements :annotations, :hierarchy
       end
@@ -113,7 +115,9 @@ module Mondrian
           :usage_prefix,
           # The name of the column in the fact table which joins to the leaf level of this dimension.
           # Required in a private Dimension or a DimensionUsage, but not in a public Dimension.
-          :foreign_key
+          :foreign_key,
+          # Flag to mark this dimensions as a high cardinality one and avoid caching.
+          :high_cardinality
         data_dictionary_names :usage_prefix, :foreign_key # values in XML will be uppercased when using Oracle driver
         elements :annotations
 
@@ -347,7 +351,9 @@ module Mondrian
           # Name of the cube which the dimension belongs to, or unspecified if the dimension is shared
           :cube_name,
           # Whether this dimension is visible in the user-interface. Default true.
-          :visible
+          :visible,
+          # Flag to mark this dimensions as a high cardinality one and avoid caching.
+          :high_cardinality
         elements :annotations
       end