mondrian-olap 0.8.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: ebf052cd103202ea4f2a37a914d13379776349bf
-  data.tar.gz: af98519e88cc3f8a98c8fdf9538847115b499f7a
+SHA256:
+  metadata.gz: 0df66cbf2bfa1f2a0a746568e7491398870121101d15b23d486e270877de3900
+  data.tar.gz: bfd14249c31c8f4b050c186cf5b355aaa6d91a8a042b89555d862868cfa52ee8
 SHA512:
-  metadata.gz: 801ab9633c7b0e4efeb83ddc12d7ffebfe1966c6e65065c02692b0aa662efb5552c4fda1acc83a407bb82eaacaf76223ed03d6a4c863a0c7f8673bf32413a55e
-  data.tar.gz: 0969711c0ffe2f39b4616b016718294b9b759333890e56f8ba3191f2b64472da645426ddc3e97e7b22b84afae7cb9e0599254f28be14db0875247f3968f37c4a
+  metadata.gz: 62219364cd64926f57429c4e6ff3373bc5fc19eaadd638544875407357ed11c5442716a6f5245078980762f31c170813bc8ed86e0c7dee6a54c1063c97827b03
+  data.tar.gz: c48f2a34b98c53955af10ccf093bcb73797e6f122282d70ffdf4a0cfeecded72a413bdf782ad68a58c9b44733bd9d4129bf865551fab894b98e1dcafeec717d8

data/Changelog.md

@@ -1,3 +1,39 @@
+### 1.1.0 / 2019-11-09
+
+* New features
+  * Upgrade to the latest Mondrian version 8.3.0.5
+  * Tested with JRuby 9.2.9.0
+  * Set query specific timeout
+  * Support for Vertica and Snowflake databases
+* Bug fixes
+  * Handle and wrap TokenMgrError exception
+  * Patch for MONDRIAN-2660
+  * Patch for MONDRIAN-2661
+
+### 1.0.0 / 2019-03-04
+
+* New features
+  * Upgrade to the latest Mondrian version 8.2.0.4
+  * Desupport Java 7, added support for Java 11, tested with JRuby 9.2.6.0
+  * Remove deprecated NativeException, Fixnum
+  * Added Mondrian query profiling option
+  * Added connection flush_schema method and flush_schema(schema_key) class method
+  * Added pin_schema_timeout connection parameter
+* Bug fixes
+  * Fixed parsing of drill through queries with newlines
+  * Do not log Mondrian errors on the console
+  * Fixed handling of dimension names with escaped ]
+  * Patch for MONDRIAN-2641
+
+### 0.9.0 / 2017-10-07
+
+* New features
+  * Upgraded to the latest Mondrian version 3.14.0.5
+  * Added an annotations_hash method for schema elements
+* Bug fixes
+  * Fixed drill through SQL query generation
+  * Set a single role as a union role - used as a workaround for a Mondrian bug
+
 ### 0.8.0 / 2016-10-26
 
 * New features

data/LICENSE.txt

@@ -1,6 +1,6 @@
 (The MIT License)
 
-Copyright (c) 2010-2016 Raimonds Simanovskis
+Copyright (c) 2010-2019 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

@@ -1,3 +1,6 @@
+[![Travis CI status](https://travis-ci.org/rsim/mondrian-olap.svg?branch=master)](https://travis-ci.org/rsim/mondrian-olap)
+[![AppVeyor status](https://ci.appveyor.com/api/projects/status/08xd4tyty2k3wxba/branch/master?svg=true)](https://ci.appveyor.com/project/rsim/mondrian-olap)
+
 mondrian-olap
 =============
 
@@ -270,9 +273,9 @@ See more examples of data access roles in `spec/connection_role_spec.rb`.
 REQUIREMENTS
 ------------
 
-mondrian-olap gem is compatible with JRuby versions 1.7 and 9.0 and Java 7 or 8 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 1.7 and 9.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 supports MySQL, PostgreSQL, Oracle, LucidDB and Microsoft SQL Server databases as well as other databases that are supported by Mondrian OLAP engine (using jdbc_driver and jdbc_url connection parameters). When using MySQL, PostgreSQL or LucidDB databases then install jdbc-mysql, jdbc-postgres or jdbc-luciddb gem and require "jdbc/mysql", "jdbc/postgres" or "jdbc/luciddb" to load the corresponding JDBC database driver. When using Oracle then include Oracle JDBC driver (`ojdbc7.jar` for Java 7) in `CLASSPATH` or copy to `JRUBY_HOME/lib` or require it in application manually. 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 include `sqljdbc.jar` or `sqljdbc4.jar` in `CLASSPATH` or copy to `JRUBY_HOME/lib` or require it in application manually.
+mondrian-olap supports MySQL, PostgreSQL, Oracle, LucidDB and Microsoft SQL Server databases as well as other databases that are supported by Mondrian OLAP engine (using jdbc_driver and jdbc_url connection parameters). When using MySQL, PostgreSQL or LucidDB databases then install jdbc-mysql, jdbc-postgres or jdbc-luciddb gem and require "jdbc/mysql", "jdbc/postgres" or "jdbc/luciddb" to load the corresponding JDBC database driver. When using Oracle then include Oracle JDBC driver (`ojdbc8.jar` for Java 8) in `CLASSPATH` or copy to `JRUBY_HOME/lib` or require it in application manually. 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 include the latest `mssql-jdbc-*.jar` in `CLASSPATH` or copy to `JRUBY_HOME/lib` or require it in application manually.
 
 INSTALL
 -------

data/VERSION

@@ -1 +1 @@
-0.8.0
+1.1.0

data/lib/mondrian/jars/log4j.properties

@@ -1,5 +1,3 @@
-# Logs errors on the console
+# By default do not log anything
 #
-log4j.rootLogger = ERROR, A1
-log4j.appender.A1 = org.apache.log4j.ConsoleAppender
-log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+log4j.rootLogger=OFF

data/lib/mondrian/olap/connection.rb

@@ -7,10 +7,10 @@ module Mondrian
         connection
       end
 
-      attr_reader :raw_connection, :raw_catalog, :raw_schema,
+      attr_reader :raw_connection, :raw_mondrian_connection, :raw_catalog, :raw_schema,
                   :raw_schema_reader, :raw_cache_control
 
-      def initialize(params={})
+      def initialize(params = {})
         @params = params
         @driver = params[:driver]
         @connected = false
@@ -55,8 +55,9 @@ module Mondrian
           @raw_catalog = @raw_connection.getOlapCatalog
           # 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)
+          @raw_mondrian_connection = @raw_connection.getMondrianConnection
+          @raw_schema_reader = @raw_mondrian_connection.getSchemaReader
+          @raw_cache_control = @raw_mondrian_connection.getCacheControl(nil)
           @connected = true
           true
         end
@@ -67,17 +68,24 @@ module Mondrian
       end
 
       def close
+        @raw_jdbc_connection = @raw_catalog = @raw_schema = @raw_mondrian_connection = nil
+        @raw_schema_reader = @raw_cache_control = nil
         @raw_connection.close
+        @raw_connection = nil
         @connected = false
-        @raw_connection = @raw_jdbc_connection = nil
         true
       end
 
       def execute(query_string, parameters = {})
-        Error.wrap_native_exception do
+        options = {}
+        Error.wrap_native_exception(options) do
+          start_time = Time.now
           statement = @raw_connection.prepareOlapStatement(query_string)
+          options[:profiling_statement] = statement if parameters[:profiling]
           set_statement_parameters(statement, parameters)
-          Result.new(self, statement.executeQuery())
+          raw_cell_set = statement.executeQuery()
+          total_duration = ((Time.now - start_time) * 1000).to_i
+          Result.new(self, raw_cell_set, profiling_handler: statement.getProfileHandler, total_duration: total_duration)
         end
       end
 
@@ -99,6 +107,36 @@ module Mondrian
         Query.from(self, cube_name)
       end
 
+      def raw_schema_key
+        @raw_mondrian_connection.getSchema.getKey
+      end
+
+      def schema_key
+        raw_schema_key.toString
+      end
+
+      def self.raw_schema_key(schema_key)
+        if schema_key =~ /\A<(.*), (.*)>\z/
+          schema_content_key = $1
+          connection_key = $2
+
+          cons = Java::mondrian.rolap.SchemaContentKey.java_class.declared_constructor(java.lang.String)
+          cons.accessible = true
+          raw_schema_content_key = cons.new_instance(schema_content_key)
+
+          cons = Java::mondrian.rolap.ConnectionKey.java_class.declared_constructor(java.lang.String)
+          cons.accessible = true
+          raw_connection_key = cons.new_instance(connection_key)
+
+          cons = Java::mondrian.rolap.SchemaKey.java_class.declared_constructor(
+            Java::mondrian.rolap.SchemaContentKey, Java::mondrian.rolap.ConnectionKey)
+          cons.accessible = true
+          cons.new_instance(raw_schema_content_key, raw_connection_key)
+        else
+          raise ArgumentError, "invalid schema key #{schema_key}"
+        end
+      end
+
       def cube_names
         @raw_schema.getCubes.map{|c| c.getName}
       end
@@ -109,12 +147,37 @@ module Mondrian
 
       # Will affect only the next created connection. If it is necessary to clear all schema cache then
       # flush_schema_cache should be called, then close and then new connection should be created.
+      # This method flushes schemas for all connections (clears the schema pool).
       def flush_schema_cache
-        unwrapped_connection = @raw_connection.unwrap(Java::MondrianOlap::Connection.java_class)
-        raw_cache_control = unwrapped_connection.getCacheControl(nil)
         raw_cache_control.flushSchemaCache
       end
 
+      def self.raw_schema_pool
+        method = Java::mondrian.rolap.RolapSchemaPool.java_class.declared_method('instance')
+        method.accessible = true
+        method.invoke_static
+      end
+
+      def self.flush_schema_cache
+        method = Java::mondrian.rolap.RolapSchemaPool.java_class.declared_method('clear')
+        method.accessible = true
+        method.invoke(raw_schema_pool)
+      end
+
+      # This method flushes the schema only for this connection (removes from the schema pool).
+      def flush_schema
+        if raw_mondrian_connection && (rolap_schema = raw_mondrian_connection.getSchema)
+          raw_cache_control.flushSchema(rolap_schema)
+        end
+      end
+
+      def self.flush_schema(schema_key)
+        method = Java::mondrian.rolap.RolapSchemaPool.java_class.declared_method('remove',
+          Java::mondrian.rolap.SchemaKey.java_class)
+        method.accessible = true
+        method.invoke(raw_schema_pool, raw_schema_key(schema_key))
+      end
+
       def available_role_names
         @raw_connection.getAvailableRoleNames.to_a
       end
@@ -139,7 +202,9 @@ module Mondrian
         Error.wrap_native_exception do
           # workaround to access non-public method (was not public when using inside Torquebox)
           # @raw_connection.setRoleNames(Array(names))
-          @raw_connection.java_method(:setRoleNames, [Java::JavaUtil::List.java_class]).call(Array(names))
+          names = Array(names)
+          @raw_connection.java_method(:setRoleNames, [Java::JavaUtil::List.java_class]).call(names)
+          names
         end
       end
 
@@ -149,7 +214,7 @@ module Mondrian
 
       def locale=(locale)
         locale_elements = locale.to_s.split('_')
-        raise ArgumentError, "invalid locale string #{locale.inspect}" unless [1,2,3].include?(locale_elements.length)
+        raise ArgumentError, "invalid locale string #{locale.inspect}" unless [1, 2, 3].include?(locale_elements.length)
         java_locale = Java::JavaUtil::Locale.new(*locale_elements)
         @raw_connection.setLocale(java_locale)
       end
@@ -230,6 +295,7 @@ module Mondrian
         string = "jdbc:mondrian:Jdbc=#{quote_string(jdbc_uri)};JdbcDrivers=#{jdbc_driver};"
         # by default use content checksum to reload schema when catalog has changed
         string << "UseContentChecksum=true;" unless @params[:use_content_checksum] == false
+        string << "PinSchemaTimeout=#{@params[:pin_schema_timeout]};" if @params[:pin_schema_timeout]
         if role = @params[:role] || @params[:roles]
           roles = Array(role).map{|r| r && r.to_s.gsub(',', ',,')}.compact
           string << "Role=#{quote_string(roles.join(','))};" unless roles.empty?
@@ -242,7 +308,7 @@ module Mondrian
 
       def jdbc_uri
         case @driver
-        when 'mysql', 'postgresql'
+        when 'mysql', 'postgresql', 'vertica'
           uri = "jdbc:#{@driver}://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/#{@params[:database]}"
           uri << "?useUnicode=yes&characterEncoding=UTF-8" if @driver == 'mysql'
           if (properties = @params[:properties]).is_a?(Hash) && !properties.empty?
@@ -281,6 +347,15 @@ module Mondrian
           uri << ";applicationName=#{@params[:application_name]}" if @params[:application_name]
           uri << ";instanceName=#{@params[:instance_name]}" if @params[:instance_name]
           uri
+        when 'snowflake'
+          uri = "jdbc:snowflake://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/?db=#{@params[:database]}"
+          uri << "&schema=#{@params[:database_schema]}" if @params[:database_schema]
+          uri << "&warehouse=#{@params[:warehouse]}" if @params[:warehouse]
+          if (properties = @params[:properties]).is_a?(Hash) && !properties.empty?
+            uri << '&'
+            uri << properties.map{|k, v| "#{k}=#{v}"}.join('&')
+          end
+          uri
         when 'jdbc'
           @params[:jdbc_url] or raise ArgumentError, 'missing jdbc_url parameter'
         else
@@ -302,6 +377,10 @@ module Mondrian
           'net.sourceforge.jtds.jdbc.Driver'
         when 'sqlserver'
           'com.microsoft.sqlserver.jdbc.SQLServerDriver'
+        when 'vertica'
+          'com.vertica.jdbc.Driver'
+        when 'snowflake'
+          'net.snowflake.client.jdbc.SnowflakeDriver'
         when 'jdbc'
           @params[:jdbc_driver] or raise ArgumentError, 'missing jdbc_driver parameter'
         else
@@ -328,15 +407,14 @@ module Mondrian
       end
 
       def quote_string(string)
-        "'#{string.gsub("'","''")}'"
+        "'#{string.gsub("'", "''")}'"
       end
 
       def set_statement_parameters(statement, parameters)
         if parameters && !parameters.empty?
+          parameters = parameters.dup
           # define addtional parameters which can be accessed from user defined functions
-          if parameters[:define_parameters]
-            parameters = parameters.dup
-            define_parameters = parameters.delete(:define_parameters)
+          if define_parameters = parameters.delete(:define_parameters)
             query_validator = statement.getQuery.createValidator
             define_parameters.each do |dp_name, dp_value|
               dp_type_class = dp_value.is_a?(Numeric) ? Java::MondrianOlapType::NumericType : Java::MondrianOlapType::StringType
@@ -344,12 +422,30 @@ module Mondrian
               parameters[dp_name] = dp_value
             end
           end
+          if parameters.delete(:profiling)
+            statement.enableProfiling(ProfilingHandler.new)
+          end
+          if timeout = parameters.delete(:timeout)
+            statement.getQuery.setQueryTimeoutMillis(timeout * 1000)
+          end
           parameters.each do |parameter_name, value|
             statement.getQuery.setParameter(parameter_name, value)
           end
         end
       end
 
+      class ProfilingHandler
+        java_implements Java::mondrian.spi.ProfileHandler
+        attr_reader :plan
+        attr_reader :timing
+
+        java_signature 'void explain(String plan, mondrian.olap.QueryTiming timing)'
+        def explain(plan, timing)
+          @plan = plan
+          @timing = timing
+        end
+      end
+
     end
   end
 end

data/lib/mondrian/olap/cube.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 module Mondrian
   module OLAP
     module Annotated
@@ -400,13 +402,18 @@ module Mondrian
       end
 
       def cell_formatter_name
+        if cf = cell_formatter
+          cf.class.name.split('::').last.gsub(/Udf\z/, '')
+        end
+      end
+
+      def cell_formatter
         if dimension_type == :measures
           cube_measure = raw_member.unwrap(Java::MondrianOlap::Member.java_class)
           if value_formatter = cube_measure.getFormatter
             f = value_formatter.java_class.declared_field('cf')
             f.accessible = true
-            cf = f.value(value_formatter)
-            cf.class.name.split('::').last.gsub(/Udf\z/, '')
+            f.value(value_formatter)
           end
         end
       end

data/lib/mondrian/olap/error.rb

@@ -6,25 +6,43 @@ module Mondrian
     class Error < StandardError
       # root_cause will be nil if there is no cause for wrapped native error
       # root_cause_message will have either root_cause message or wrapped native error message
-      attr_reader :native_error, :root_cause_message, :root_cause
+      attr_reader :native_error, :root_cause_message, :root_cause, :profiling_handler
 
-      def initialize(native_error)
+      def initialize(native_error, options = {})
         @native_error = native_error
         get_root_cause
-        super(native_error.message)
+        super(native_error.toString)
         add_root_cause_to_backtrace
+        get_profiling(options)
       end
 
-      def self.wrap_native_exception
+      def self.wrap_native_exception(options = {})
         yield
-      rescue NativeException => e
-        if e.message =~ NATIVE_ERROR_REGEXP
-          raise Mondrian::OLAP::Error.new(e)
+      # TokenMgrError for some unknown reason extends java.lang.Error which normally should not be rescued
+      rescue Java::JavaLang::Exception, Java::MondrianParser::TokenMgrError => e
+        if e.toString =~ NATIVE_ERROR_REGEXP
+          raise Mondrian::OLAP::Error.new(e, options)
         else
           raise
         end
       end
 
+      def profiling_plan
+        if profiling_handler && (plan = profiling_handler.plan)
+          plan.gsub("\r\n", "\n")
+        end
+      end
+
+      def profiling_timing
+        profiling_handler.timing if profiling_handler
+      end
+
+      def profiling_timing_string
+        if profiling_timing && (timing_string = profiling_timing.toString)
+          timing_string.gsub("\r\n", "\n")
+        end
+      end
+
       private
 
       def get_root_cause
@@ -44,7 +62,7 @@ module Mondrian
         bt = @native_error.backtrace
         if @root_cause
           root_cause_bt = Array(@root_cause.backtrace)
-          root_cause_bt[0,10].reverse.each do |bt_line|
+          root_cause_bt[0, 10].reverse.each do |bt_line|
             bt.unshift "root cause:   #{bt_line}"
           end
           bt.unshift "root cause: #{@root_cause.java_class.name}: #{@root_cause.message.chomp}"
@@ -52,6 +70,17 @@ module Mondrian
         set_backtrace bt
       end
 
+      def get_profiling(options)
+        if statement = options[:profiling_statement]
+          f = Java::mondrian.olap4j.MondrianOlap4jStatement.java_class.declared_field("openCellSet")
+          f.accessible = true
+          if cell_set = f.value(statement)
+            cell_set.close
+            @profiling_handler = statement.getProfileHandler
+          end
+        end
+      end
+
     end
   end
 end