mondrian-olap 1.1.0 → 1.3.0

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)
@@ -394,6 +426,17 @@ module Mondrian
                   end
               end
 
+              # 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 # 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]
                 begin
@@ -402,7 +445,7 @@ module Mondrian
                   raise ArgumentError, "invalid return field #{member_full_name}"
                 end
 
-                # if this is property field then the name is initilized already
+                # if this is property field then the name is initialized 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
@@ -413,42 +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(column_alias)
+                add_sql_attributes return_fields[i], sql_options
               end
             end
 
@@ -472,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
 

data/lib/mondrian/olap/schema_element.rb

@@ -140,8 +140,8 @@ module Mondrian
 
       def xmlized_attributes(options)
         # data dictionary values should be in uppercase if schema defined with :upcase_data_dictionary => true
-        # or by default when using Oracle or LucidDB driver (can be overridden by :upcase_data_dictionary => false)
-        upcase_attributes = if options[:upcase_data_dictionary].nil? && %w(oracle luciddb snowflake).include?(options[:driver]) ||
+        # or by default when using Oracle or Snowflake driver (can be overridden by :upcase_data_dictionary => false)
+        upcase_attributes = if options[:upcase_data_dictionary].nil? && %w(oracle snowflake).include?(options[:driver]) ||
                             options[:upcase_data_dictionary]
           self.class.data_dictionary_names
         else
@@ -149,7 +149,10 @@ module Mondrian
         end
         hash = {}
         @attributes.each do |attr, value|
-          value = value.upcase if upcase_attributes.include?(attr)
+          # Support value calculation in parallel threads.
+          # value could be either Thread or a future object from concurrent-ruby
+          value = value.value if value.respond_to?(:value)
+          value = value.upcase if upcase_attributes.include?(attr) && value.is_a?(String)
           hash[
             # camelcase attribute name
             attr.to_s.gsub(/_([^_]+)/){|m| $1.capitalize}

data/lib/mondrian/olap/schema_udf.rb

@@ -9,21 +9,8 @@ module Mondrian
       end
 
       module ScriptElements
-        def javascript(text)
-          script text, :language => 'JavaScript'
-        end
-
         private
 
-        def coffeescript_function(arguments_string, text)
-          # construct function to ensure that last expression is returned
-          coffee_text = "#{arguments_string} ->\n" << text.gsub(/^/, '  ')
-          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
-          # remove function definition first and last lines
-          javascript_text = javascript_text.strip.lines.to_a[1..-2].join
-          javascript javascript_text
-        end
-
         def ruby(*options, &block)
           udf_class_name = if options.include?(:shared)
             "#{name.capitalize}Udf"
@@ -74,64 +61,13 @@ module Mondrian
 
       class UserDefinedFunction < SchemaElement
         include ScriptElements
+
         attributes :name, # Name with which the user-defined function will be referenced in MDX expressions.
-          # Name of the class which implemenets this user-defined function.
-          # Must implement the mondrian.spi.UserDefinedFunction  interface.
+          # Name of the class which implements this user-defined function.
+          # Must implement the mondrian.spi.UserDefinedFunction interface.
           :class_name
         elements :script
 
-        def coffeescript(text)
-          coffee_text = "__udf__ = {\n" << text << "}\n"
-          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
-          javascript_text << <<-JS
-
-__udf__.parameters || (__udf__.parameters = []);
-__udf__.returns || (__udf__.returns = "Scalar");
-var __scalarTypes__ = {"Numeric":true,"String":true,"Boolean":true,"DateTime":true,"Decimal":true,"Scalar":true};
-function __getType__(type) {
-  if (__scalarTypes__[type]) {
-    return new mondrian.olap.type[type+"Type"];
-  } else if (type === "Member") {
-    return mondrian.olap.type.MemberType.Unknown;
-  } else {
-    return null;
-  }
-}
-function getParameterTypes() {
-  var parameters = __udf__.parameters || [],
-      types = [];
-  for (var i = 0, len = parameters.length; i < len; i++) {
-    types.push(__getType__(parameters[i]))
-  }
-  return types;
-}
-function getReturnType(parameterTypes) {
-  var returns = __udf__.returns || "Scalar";
-  return __getType__(returns);
-}
-if (__udf__.syntax) {
-  function getSyntax() {
-    return mondrian.olap.Syntax[__udf__.syntax];
-  }
-}
-function execute(evaluator, args) {
-  var parameters = __udf__.parameters || [],
-      values = [],
-      value;
-  for (var i = 0, len = parameters.length; i < len; i++) {
-    if (__scalarTypes__[parameters[i]]) {
-      value = args[i].evaluateScalar(evaluator);
-    } else {
-      value = args[i].evaluate(evaluator);
-    }
-    values.push(value);
-  }
-  return __udf__.execute.apply(__udf__, values);
-}
-JS
-          javascript javascript_text
-        end
-
         class RubyUdfBase
           include Java::mondrian.spi.UserDefinedFunction
           def self.function_name=(name); @function_name = name; end
@@ -225,7 +161,7 @@ JS
           arguments_array_class = java.lang.Class.forName "[Lmondrian.spi.UserDefinedFunction$Argument;", true, class_loader
           add_method_signature("execute", [java.lang.Object, Java::mondrian.olap.Evaluator, arguments_array_class])
 
-          # Override this metho if evaluator is needed
+          # Override this method if evaluator is needed
           def call_with_evaluator(evaluator, *values)
             call(*values)
           end
@@ -294,10 +230,6 @@ JS
           end
         end
 
-        def coffeescript(text)
-          coffeescript_function('(value)', text)
-        end
-
         def ruby(*options, &block)
           ruby_formatter(options, Java::mondrian.spi.CellFormatter, 'formatCell', [java.lang.String, java.lang.Object], &block)
         end
@@ -308,12 +240,9 @@ JS
         attributes :class_name
         elements :script
 
-        def coffeescript(text)
-          coffeescript_function('(member)', text)
-        end
-
         def ruby(*options, &block)
-          ruby_formatter(options, Java::mondrian.spi.MemberFormatter, 'formatMember', [java.lang.String, Java::mondrian.olap.Member], &block)
+          ruby_formatter(options, Java::mondrian.spi.MemberFormatter, 'formatMember',
+            [java.lang.String, Java::mondrian.olap.Member], &block)
         end
       end
 
@@ -322,12 +251,9 @@ JS
         attributes :class_name
         elements :script
 
-        def coffeescript(text)
-          coffeescript_function('(member,propertyName,propertyValue)', text)
-        end
-
         def ruby(*options, &block)
-          ruby_formatter(options, Java::mondrian.spi.PropertyFormatter, 'formatProperty', [java.lang.String, Java::mondrian.olap.Member, java.lang.String, java.lang.Object], &block)
+          ruby_formatter(options, Java::mondrian.spi.PropertyFormatter, 'formatProperty',
+            [java.lang.String, Java::mondrian.olap.Member, java.lang.String, java.lang.Object], &block)
         end
       end
 

data/lib/mondrian/olap.rb

@@ -1,18 +1,22 @@
 require 'java'
 require 'nokogiri'
 
+{
+  # Do not register MondrianOlap4jDriver
+  "mondrian.olap4j.registerDriver" => false,
+  # Do not register log3j2 MBean
+  "log4j2.disable.jmx" => true
+}.each do |key, value|
+  if java.lang.System.getProperty(key).nil?
+    java.lang.System.setProperty(key, value.to_s)
+  end
+end
+
 directory = File.expand_path("../jars", __FILE__)
 Dir["#{directory}/*.jar"].each do |file|
   require file
 end
 
-unless java.lang.System.getProperty("log4j.configuration")
-  file_uri = java.io.File.new("#{directory}/log4j.properties").toURI.to_s
-  java.lang.System.setProperty("log4j.configuration", file_uri)
-end
-# register Mondrian olap4j driver
-Java::mondrian.olap4j.MondrianOlap4jDriver
-
 %w(error connection query result schema schema_udf cube).each do |file|
   require "mondrian/olap/#{file}"
 end

data/spec/connection_role_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe "Connection role" do
 
   describe "create connection" do
-    before(:each) do
+    before(:all) do
       @all_roles = [
         @role_name = role_name = 'California manager',
         @role_name2 = role_name2 = 'Dummy, with comma',
@@ -86,6 +86,9 @@ describe "Connection role" do
           end
         end
       end
+    end
+
+    before(:each) do
       @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
     end
 

data/spec/connection_spec.rb

@@ -12,7 +12,7 @@ describe "Connection" do
     end
 
     it "should be successful" do
-      @olap.connect.should be_true
+      @olap.connect.should == true
     end
 
   end
@@ -25,7 +25,7 @@ describe "Connection" do
       @olap = Mondrian::OLAP::Connection.new(CONNECTION_PARAMS.merge(
         :catalog_content => @schema_xml
       ))
-      @olap.connect.should be_true
+      @olap.connect.should == true
     end
 
   end
@@ -49,11 +49,11 @@ describe "Connection" do
         when 'mysql' then 'mondrian.spi.impl.MySqlDialect'
         when 'postgresql' then 'mondrian.spi.impl.PostgreSqlDialect'
         when 'oracle' then 'mondrian.spi.impl.OracleDialect'
-        when 'luciddb' then 'mondrian.spi.impl.LucidDbDialect'
-        when 'mssql' then 'mondrian.spi.impl.MicrosoftSqlServerDialect'
         when 'sqlserver' then 'mondrian.spi.impl.MicrosoftSqlServerDialect'
         when 'vertica' then 'mondrian.spi.impl.VerticaDialect'
-        when 'snowflake' then 'mondrian.spi.impl.JdbcDialectImpl'
+        when 'snowflake' then 'mondrian.spi.impl.SnowflakeDialect'
+        when 'clickhouse' then 'mondrian.spi.impl.ClickHouseDialect'
+        when 'mariadb' then 'mondrian.spi.impl.MariaDBDialect'
         end
     end
 
@@ -90,4 +90,37 @@ describe "Connection" do
 
   end
 
+  describe "jdbc_uri" do
+    before(:all) { @olap_connection = Mondrian::OLAP::Connection }
+
+    describe "SQL Server" do
+      it "should return a valid JDBC URI" do
+        @olap_connection.new(
+          driver: 'sqlserver',
+          host: 'example.com',
+          port: 1234,
+          instance: 'MSSQLSERVER',
+          database: 'example_db'
+        ).jdbc_uri.should == 'jdbc:sqlserver://example.com:1234;databaseName=example_db;instanceName=MSSQLSERVER'
+      end
+
+      it "should return a valid JDBC URI with instance name as property" do
+        @olap_connection.new(
+          driver: 'sqlserver',
+          host: 'example.com',
+          properties: {
+            instanceName: "MSSQLSERVER"
+          }
+        ).jdbc_uri.should == 'jdbc:sqlserver://example.com;instanceName=MSSQLSERVER'
+      end
+
+      it "should return a valid JDBC URI with enabled integratedSecurity" do
+        @olap_connection.new(
+          driver: 'sqlserver',
+          host: 'example.com',
+          integrated_security: 'true'
+        ).jdbc_uri.should == 'jdbc:sqlserver://example.com;integratedSecurity=true'
+      end
+    end
+  end
 end

data/spec/cube_cache_control_spec.rb

@@ -72,7 +72,8 @@ describe "Cube" do
     @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
   end
 
-  describe 'cache', unless: MONDRIAN_DRIVER == 'luciddb' do
+  # Do not execute tests on analytical databases with slow individual inserts
+  describe 'cache', unless: %w(vertica snowflake clickhouse mariadb).include?(MONDRIAN_DRIVER) do
     def qt(name)
       @connection.quote_table_name(name.to_s)
     end
@@ -87,9 +88,9 @@ describe "Cube" do
       SQL
 
       case MONDRIAN_DRIVER
-      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle', 'vertica', 'snowflake'
+      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle'
         @connection.execute 'CREATE TABLE sales_copy AS SELECT * FROM sales'
-      when 'mssql', 'sqlserver'
+      when '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_update 'SELECT * INTO sales_copy FROM sales'
@@ -97,14 +98,8 @@ describe "Cube" do
     end
 
     after(:each) do
-      case MONDRIAN_DRIVER
-      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle', 'vertica', 'snowflake'
-        @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
+      @connection.execute 'TRUNCATE TABLE sales'
+      @connection.execute 'INSERT INTO sales SELECT * FROM sales_copy'
 
       @olap.flush_schema_cache
       @olap.close
@@ -112,12 +107,7 @@ describe "Cube" do
     end
 
     after(:all) do
-      case MONDRIAN_DRIVER
-      when 'mysql', 'jdbc_mysql', 'postgresql', 'oracle', 'vertica', 'snowflake'
-        @connection.execute 'DROP TABLE sales_copy'
-      when 'mssql', 'sqlserver'
-        @connection.execute 'DROP TABLE sales_copy'
-      end
+      @connection.execute 'DROP TABLE sales_copy'
     end
 
     it 'should clear cache for deleted data at lower level with segments' do