mondrian-olap 0.3.0 → 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a82185c2c1e818166ad00f6a79629772eda89fd6
+  data.tar.gz: 48189b91d855f7dc3df6842d91360068285be951
+SHA512:
+  metadata.gz: d11c3fb9718d6a81be7f534c1b96a6cf731b64019a947a01bbfb58e3a2d52453bd334c5f083ef05981093657f66b3b4572f64748ae0aa4382f4c6a03c445aa9f
+  data.tar.gz: 5f588afd736a0e8c62f05b5a9d56aa75fe181e46373d4025d85522532b8371a3fb439e3d000339ed70ad61d0f8c99ce37e17b9ddc693cfe44a4884ff557c375f

data/Changelog.md

@@ -1,3 +1,41 @@
+### 0.5.0 / 2013-11-29
+
+* New features
+  * upgraded to latest Mondrian 3.5 version (build from 2013-07-31)
+  * added shutdown_static_mondrian_server! method
+  * add schema element annotations in schema definition
+  * set connection locale
+  * added support for schema elements caption
+  * added shared dimension schema definition methods
+  * added virtual cube schema definition methods
+* Improvements
+  * connection execute_drill_through method
+  * define shared user defined cell formatters
+  * set default hierarchy :has_all and level :unique_members attributes
+  * by default use sum aggregator for measure in schema definition
+  * support Oracle connection using slash and service name as database name
+* Bug fixes
+  * render cube XML fragment before calculated members in generated XML schema
+  * generate XML with UTF-8 encoding
+
+### 0.4.0 / 2012-12-03
+
+* New features
+  * upgraded to latest Mondrian 3.5 version (build from 2012-11-29)
+    as well as corresponding olap4j 1.0.1 version
+  * support for JRuby 1.7 and Java 7 VM
+  * user defined functions and formatters in JavaScript, CoffeeScript and Ruby
+  * shared user defined functions in Ruby
+  * all exceptions are wrapped in Mondrian::OLAP::Error exception with root_cause_message method
+  * drill through from result cell to source measure and dimension table rows
+  * support for Mondrian schema roles to limit cube data access
+* Improvements
+  * get description of cube, dimension, hierarchy and level from schema definition
+  * visible? method for measures and calculated members
+  * nonempty_crossjoin query builder method
+  * schema definition with nested table joins
+  * added approx_row_count schema level attribute
+
 ### 0.3.0 / 2011-11-12
 
 * New features

data/LICENSE.txt

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

@@ -0,0 +1,302 @@
+mondrian-olap
+=============
+
+JRuby gem for performing multidimensional queries of relational database data using Mondrian OLAP Java library.
+
+DESCRIPTION
+-----------
+
+SQL language is good for doing ad-hoc queries from relational databases but it becomes very complicated when doing more complex analytical queries to get summary results. Alternative approach is OLAP (On-Line Analytical Processing) databases and engines that provide easier multidimensional analysis of data at different summary levels.
+
+One of the most popular open-source OLAP engines is [Mondrian](http://mondrian.pentaho.com). Mondrian OLAP engine can be put in front of relational SQL database and it provides MDX multidimensional query language which is much more suited for analytical purposes.
+
+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). [eazyBI remote setup](https://eazybi.com/help/remote-setup) 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).
+
+USAGE
+-----
+
+### Schema definition
+
+At first you need to define OLAP schema mapping to relational database schema tables and columns. OLAP schema consists of:
+
+* Cubes
+
+  Multidimensional cube is a collection of measures that can be accessed by dimensions. In relational database cubes are stored in fact tables with measure columns and dimension foreign key columns.
+
+* Dimensions
+
+  Dimension can be used in one cube (private) or in many cubes (shared). In relational database dimensions are stored in dimension tables.
+
+* Hierarchies and levels
+
+  Dimension has at least one primary hierarchy and optional additional hierarchies and each hierarchy has one or more levels. In relational database all levels can be stored in the same dimension table as different columns or can be stored also in several tables.
+
+* Members
+
+  Dimension hierarchy level values are called members.
+
+* Measures
+
+  Measures are values which can be accessed at detailed level or aggregated (e.g. as sum or average) at higher dimension hierarchy levels. In relational database measures are stored as columns in cube table.
+
+* Calculated measures
+
+  Calculated measures are not stored in database but calculated using specified formula from other measures.
+
+Read more about about [defining Mondrian OLAP schema](http://mondrian.pentaho.com/documentation/schema.php).
+
+Here is example how to define OLAP schema and its mapping to relational database tables and columns using mondrian-olap:
+
+```ruby
+require "rubygems"
+require "mondrian-olap"
+
+schema = Mondrian::OLAP::Schema.define do
+  cube 'Sales' do
+    table 'sales'
+    dimension 'Customers', :foreign_key => 'customer_id' do
+      hierarchy :has_all => true, :all_member_name => 'All Customers', :primary_key => 'id' do
+        table 'customers'
+        level 'Country', :column => 'country', :unique_members => true
+        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
+    dimension 'Products', :foreign_key => 'product_id' do
+      hierarchy :has_all => true, :all_member_name => 'All Products',
+                :primary_key => 'id', :primary_key_table => 'products' do
+        join :left_key => 'product_class_id', :right_key => 'id' do
+          table 'products'
+          table 'product_classes'
+        end
+        level 'Product Family', :table => 'product_classes', :column => 'product_family', :unique_members => true
+        level 'Brand Name', :table => 'products', :column => 'brand_name', :unique_members => false
+        level 'Product Name', :table => 'products', :column => 'product_name', :unique_members => true
+      end
+    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 => 'week_of_year', :type => 'Numeric', :unique_members => false, :level_type => 'TimeWeeks'
+      end
+    end
+    measure 'Unit Sales', :column => 'unit_sales', :aggregator => 'sum'
+    measure 'Store Sales', :column => 'store_sales', :aggregator => 'sum'
+  end
+end
+```
+
+### Connection creation
+
+When schema is defined it is necessary to establish OLAP connection to database. Here is example how to connect to MySQL database using the schema object that was defined previously:
+
+```ruby
+require "jdbc/mysql"
+
+olap = Mondrian::OLAP::Connection.create(
+  :driver => 'mysql',
+  :host => 'localhost,
+  :database => 'mondrian_test',
+  :username => 'mondrian_user',
+  :password => 'secret',
+  :schema => schema
+)
+```
+
+### MDX queries
+
+Mondrian OLAP provides MDX query language. [Read more about MDX](http://mondrian.pentaho.com/documentation/mdx.php).
+mondrian-olap allows executing of MDX queries, for example query for "Get sales amount and number of units (on columns) of all product families (on rows) sold in California during Q1 of 2010":
+
+```ruby
+result = olap.execute <<-MDX
+  SELECT  {[Measures].[Unit Sales], [Measures].[Store Sales]} ON COLUMNS,
+          {[Products].children} ON ROWS
+    FROM  [Sales]
+    WHERE ([Time].[2010].[Q1], [Customers].[USA].[CA])
+MDX
+```
+
+which would correspond to the following SQL query:
+
+    SELECT SUM(unit_sales) unit_sales_sum, SUM(store_sales) store_sales_sum
+    FROM sales
+      LEFT JOIN products ON sales.product_id = products.id
+      LEFT JOIN product_classes ON products.product_class_id = product_classes.id
+      LEFT JOIN time ON sales.time_id = time.id
+      LEFT JOIN customers ON sales.customer_id = customers.id
+    WHERE time.the_year = 2010 AND time.quarter = 'Q1'
+      AND customers.country = 'USA' AND customers.state_province = 'CA'
+    GROUP BY product_classes.product_family
+    ORDER BY product_classes.product_family
+
+and then get axis and cells of result object:
+
+```ruby
+result.axes_count         # => 2
+result.column_names       # => ["Unit Sales", "Store Sales"]
+result.column_full_names  # => ["[Measures].[Unit Sales]", "[Measures].[Store Sales]"]
+result.row_names          # => e.g. ["Drink", "Food", "Non-Consumable"]
+result.row_full_names     # => e.g. ["[Products].[Drink]", "[Products].[Food]", "[Products].[Non-Consumable]"]
+result.values             # => [[..., ...], [..., ...], [..., ...]]
+                          # (three rows, each row containing value for "unit sales" and "store sales")
+```
+
+### Query builder methods
+
+MDX queries could be built and executed also using Ruby methods in a similar way as ActiveRecord/Arel queries are made.
+Previous MDX query can be executed as:
+
+```ruby
+olap.from('Sales').
+columns('[Measures].[Unit Sales]', '[Measures].[Store Sales]').
+rows('[Products].children').
+where('[Time].[2010].[Q1]', '[Customers].[USA].[CA]').
+execute
+```
+
+Here is example of more complex query "Get sales amount and profit % of top 50 products cross-joined with USA and Canada country sales during Q1 of 2010":
+
+```ruby
+olap.from('Sales').
+with_member('[Measures].[ProfitPct]').
+  as('Val((Measures.[Store Sales] - Measures.[Store Cost]) / Measures.[Store Sales])',
+  :format_string => 'Percent').
+columns('[Measures].[Store Sales]', '[Measures].[ProfitPct]').
+rows('[Products].children').crossjoin('[Customers].[Canada]', '[Customers].[USA]').
+  top_count(50, '[Measures].[Store Sales]').
+where('[Time].[2010].[Q1]').
+execute
+```
+
+See more examples of queries in `spec/query_spec.rb`.
+
+Currently there are query builder methods just for most frequently used MDX functions, there will be new query builder methods in next releases of mondrian-olap gem.
+
+### Cube dimension and member queries
+
+mondrian-olap provides also methods for querying dimensions and members:
+
+```ruby
+cube = olap.cube('Sales')
+cube.dimension_names                    # => ['Measures', 'Customers', 'Products', 'Time']
+cube.dimensions                         # => array of dimension objects
+cube.dimension('Customers')             # => customers dimension object
+cube.dimension('Time').hierarchy_names  # => ['Time', 'Time.Weekly']
+cube.dimension('Time').hierarchies      # => array of hierarchy objects
+cube.dimension('Customers').hierarchy   # => default customers dimension hierarchy
+cube.dimension('Customers').hierarchy.level_names
+                                        # => ['(All)', 'Country', 'State Province', 'City', 'Name']
+cube.dimension('Customers').hierarchy.levels
+                                        # => array of hierarchy level objects
+cube.dimension('Customers').hierarchy.level('Country').members
+                                        # => array of all level members
+cube.member('[Customers].[USA].[CA]')   # => lookup member by full name
+cube.member('[Customers].[USA].[CA]').children
+                                        # => get all children of member in deeper hierarchy level
+cube.member('[Customers].[USA]').descendants_at_level('City')
+                                        # => get all descendants of member in specified hierarchy level
+```
+
+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:
+
+```ruby
+schema = Mondrian::OLAP::Schema.define do
+  # ... cube definitions ...
+  user_defined_function 'Factorial' do
+    ruby do
+      parameters :numeric
+      returns :numeric
+      def call(n)
+        n <= 1 ? 1 : n * call(n - 1)
+      end
+    end
+  end
+  user_defined_function 'UpperName' do
+    ruby do
+      parameters :member
+      returns :string
+      syntax :property
+      def call(member)
+        member.getName.upcase
+      end
+    end
+  end
+end
+```
+
+See more examples of user defined functions in `spec/schema_definition_spec.rb`.
+
+### Data access roles
+
+In schema you can define data access roles which can be selected for connection and which will limit access just to
+subset of measures and dimension members. Here is example of data access role definition:
+
+```ruby
+schema = Mondrian::OLAP::Schema.define do
+  # ... cube definitions ...
+  role 'California manager' do
+    schema_grant :access => 'none' do
+      cube_grant :cube => 'Sales', :access => 'all' do
+        dimension_grant :dimension => '[Measures]', :access => 'all'
+        hierarchy_grant :hierarchy => '[Customers]', :access => 'custom',
+                        :top_level => '[Customers].[State Province]', :bottom_level => '[Customers].[City]' do
+          member_grant :member => '[Customers].[USA].[CA]', :access => 'all'
+          member_grant :member => '[Customers].[USA].[CA].[Los Angeles]', :access => 'none'
+        end
+      end
+    end
+  end
+end
+```
+
+See more examples of data access roles in `spec/connection_role_spec.rb`.
+
+REQUIREMENTS
+------------
+
+mondrian-olap gem is compatible with JRuby versions 1.6 and 1.7 and Java 6 and 7 VM. mondrian-olap works only with JRuby and not with other Ruby implementations as it includes Mondrian OLAP Java libraries.
+
+mondrian-olap currently supports MySQL, PostgreSQL, Oracle, LucidDB and Microsoft SQL Server databases. 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 (`ojdbc6.jar` for Java 6) 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.
+
+INSTALL
+-------
+
+Install gem with:
+
+    gem install mondrian-olap
+
+or include in your project's Gemfile:
+
+    gem "mondrian-olap"
+
+LINKS
+-----
+
+* Source code: http://github.com/rsim/mondrian-olap
+* Bug reports / Feature requests: http://github.com/rsim/mondrian-olap/issues
+* General discussions and questions at: http://groups.google.com/group/mondrian-olap
+* mondrian-olap demo Rails application: https://github.com/rsim/mondrian_demo
+
+LICENSE
+-------
+
+mondrian-olap is released under the terms of MIT license; see LICENSE.txt.
+
+Mondrian OLAP Engine is released under the terms of the Eclipse Public
+License v1.0 (EPL); see LICENSE-Mondrian.html.

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.5.0

data/lib/mondrian/olap.rb

@@ -1,4 +1,5 @@
 require 'java'
+require 'nokogiri'
 
 directory = File.expand_path("../jars", __FILE__)
 Dir["#{directory}/*.jar"].each do |file|
@@ -12,6 +13,6 @@ end
 # register Mondrian olap4j driver
 Java::mondrian.olap4j.MondrianOlap4jDriver
 
-%w(connection query result schema cube).each do |file|
+%w(error connection query result schema schema_udf cube).each do |file|
   require "mondrian/olap/#{file}"
 end

data/lib/mondrian/olap/connection.rb

@@ -17,35 +17,39 @@ module Mondrian
       end
 
       def connect
-        # hack to call private constructor of MondrianOlap4jDriver
-        # to avoid using DriverManager which fails to load JDBC drivers
-        # because of not seeing JRuby required jar files
-        cons = Java::MondrianOlap4j::MondrianOlap4jDriver.java_class.declared_constructor
-        cons.accessible = true
-        driver = cons.new_instance.to_java
-
-        props = java.util.Properties.new
-        props.setProperty('JdbcUser', @params[:username]) if @params[:username]
-        props.setProperty('JdbcPassword', @params[:password]) if @params[:password]
-
-        conn_string = connection_string
-
-        # workaround for Mondrian ServiceDiscovery
-        current_thread = Java::JavaLang::Thread.currentThread
-        class_loader = current_thread.getContextClassLoader
-        begin
-          current_thread.setContextClassLoader(nil)
-          @raw_jdbc_connection = driver.connect(conn_string, props)
-        ensure
-          current_thread.setContextClassLoader(class_loader)
-        end
+        Error.wrap_native_exception do
+          # hack to call private constructor of MondrianOlap4jDriver
+          # to avoid using DriverManager which fails to load JDBC drivers
+          # because of not seeing JRuby required jar files
+          cons = Java::MondrianOlap4j::MondrianOlap4jDriver.java_class.declared_constructor
+          cons.accessible = true
+          driver = cons.new_instance.to_java
 
-        @raw_connection = @raw_jdbc_connection.unwrap(Java::OrgOlap4j::OlapConnection.java_class)
-        @raw_catalog = @raw_connection.getOlapCatalog
-        # currently it is assumed that there is just one schema per connection catalog
-        @raw_schema = @raw_catalog.getSchemas.first
-        @connected = true
-        true
+          props = java.util.Properties.new
+          props.setProperty('JdbcUser', @params[:username]) if @params[:username]
+          props.setProperty('JdbcPassword', @params[:password]) if @params[:password]
+
+          conn_string = connection_string
+
+          # latest Mondrian version added ClassResolver which uses current thread class loader to load some classes
+          # therefore need to set it to JRuby class loader to ensure that Mondrian classes are found
+          # (e.g. when running mondrian-olap inside OSGi container)
+          current_thread = Java::JavaLang::Thread.currentThread
+          class_loader = current_thread.getContextClassLoader
+          begin
+            current_thread.setContextClassLoader JRuby.runtime.jruby_class_loader
+            @raw_jdbc_connection = driver.connect(conn_string, props)
+          ensure
+            current_thread.setContextClassLoader(class_loader)
+          end
+
+          @raw_connection = @raw_jdbc_connection.unwrap(Java::OrgOlap4j::OlapConnection.java_class)
+          @raw_catalog = @raw_connection.getOlapCatalog
+          # currently it is assumed that there is just one schema per connection catalog
+          @raw_schema = @raw_catalog.getSchemas.first
+          @connected = true
+          true
+        end
       end
 
       def connected?
@@ -60,8 +64,17 @@ module Mondrian
       end
 
       def execute(query_string)
-        statement = @raw_connection.prepareOlapStatement(query_string)
-        Result.new(self, statement.executeQuery())
+        Error.wrap_native_exception do
+          statement = @raw_connection.prepareOlapStatement(query_string)
+          Result.new(self, statement.executeQuery())
+        end
+      end
+
+      def execute_drill_through(query_string)
+        Error.wrap_native_exception do
+          statement = @raw_connection.createStatement
+          Result::DrillThrough.new(statement.executeQuery(query_string))
+        end
       end
 
       def from(cube_name)
@@ -84,12 +97,120 @@ module Mondrian
         raw_cache_control.flushSchemaCache
       end
 
+      def available_role_names
+        @raw_connection.getAvailableRoleNames.to_a
+      end
+
+      def role_name
+        @raw_connection.getRoleName
+      end
+
+      def role_names
+        # workaround to access non-public method (was not public when using inside Torquebox)
+        # @raw_connection.getRoleNames.to_a
+        @raw_connection.java_method(:getRoleNames).call.to_a
+      end
+
+      def role_name=(name)
+        Error.wrap_native_exception do
+          @raw_connection.setRoleName(name)
+        end
+      end
+
+      def role_names=(names)
+        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))
+        end
+      end
+
+      def locale
+        @raw_connection.getLocale.toString
+      end
+
+      def locale=(locale)
+        locale_elements = locale.to_s.split('_')
+        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
+
+      # access MondrianServer instance
+      def mondrian_server
+        Error.wrap_native_exception do
+          @raw_connection.getMondrianConnection.getServer
+        end
+      end
+
+      # Force shutdown of static MondrianServer, should not normally be used.
+      # Can be used in at_exit block if JRuby based plugin is unloaded from other Java application.
+      # WARNING: Mondrian will be unusable after calling this method!
+      def self.shutdown_static_mondrian_server!
+        static_mondrian_server = Java::MondrianOlap::MondrianServer.forId(nil)
+
+        # force Mondrian to think that static_mondrian_server is not static MondrianServer
+        mondrian_server_registry = Java::MondrianServer::MondrianServerRegistry::INSTANCE
+        f = mondrian_server_registry.java_class.declared_field("staticServer")
+        f.accessible = true
+        f.set_value(mondrian_server_registry, nil)
+
+        static_mondrian_server.shutdown
+
+        # shut down expiring reference timer thread
+        f = Java::MondrianUtil::ExpiringReference.java_class.declared_field("timer")
+        f.accessible = true
+        expiring_reference_timer = f.static_value.to_java
+        expiring_reference_timer.cancel
+
+        # shut down Mondrian Monitor
+        cons = Java::MondrianServer.__send__(:"MonitorImpl$ShutdownCommand").java_class.declared_constructor
+        cons.accessible = true
+        shutdown_command = cons.new_instance.to_java
+
+        cons = Java::MondrianServer.__send__(:"MonitorImpl$Handler").java_class.declared_constructor
+        cons.accessible = true
+        handler = cons.new_instance.to_java
+
+        pair = Java::mondrian.util.Pair.new handler, shutdown_command
+
+        f = Java::MondrianServer::MonitorImpl.java_class.declared_field("ACTOR")
+        f.accessible = true
+        monitor_actor = f.static_value.to_java
+
+        f = monitor_actor.java_class.declared_field("eventQueue")
+        f.accessible = true
+        event_queue = f.value(monitor_actor)
+
+        event_queue.put pair
+
+        # shut down connection pool thread
+        f = Java::mondrian.rolap.RolapConnectionPool.java_class.declared_field("instance")
+        f.accessible = true
+        rolap_connection_pool = f.static_value.to_java
+        f = rolap_connection_pool.java_class.declared_field("mapConnectKeyToPool")
+        f.accessible = true
+        map_connect_key_to_pool = f.value(rolap_connection_pool)
+        map_connect_key_to_pool.values.each do |pool|
+          pool.close if pool && !pool.isClosed
+        end
+
+        true
+      end
+
       private
 
       def connection_string
         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
+        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?
+        end
+        if locale = @params[:locale]
+          string << "Locale=#{quote_string(locale.to_s)};"
+        end
         string << (@params[:catalog] ? "Catalog=#{catalog_uri}" : "CatalogContent=#{quote_string(catalog_content)}")
       end
 
@@ -98,14 +219,24 @@ module Mondrian
         when 'mysql', 'postgresql'
           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?
+            uri << (@driver == 'mysql' ? '&' : '?')
+            uri << properties.map{|k, v| "#{k}=#{v}"}.join('&')
+          end
           uri
         when 'oracle'
           # connection using TNS alias
           if @params[:database] && !@params[:host] && !@params[:url] && ENV['TNS_ADMIN']
             "jdbc:oracle:thin:@#{@params[:database]}"
           else
-            @params[:url] ||
-            "jdbc:oracle:thin:@#{@params[:host] || 'localhost'}:#{@params[:port] || 1521}:#{@params[:database]}"
+            @params[:url] || begin
+              database = @params[:database]
+              unless database =~ %r{^(:|/)}
+                # assume database is a SID if no colon or slash are supplied (backward-compatibility)
+                database = ":#{database}"
+              end
+              "jdbc:oracle:thin:@#{@params[:host] || 'localhost'}:#{@params[:port] || 1521}#{database}"
+            end
           end
         when 'luciddb'
           uri = "jdbc:luciddb:http://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}"