mondrian-olap 0.4.0-java

data/RUNNING_TESTS.rdoc

@@ -0,0 +1,66 @@
+== Creating test database
+
+By default unit tests use MySQL database but PostgreSQL, Oracle and SQL Server databases are supported as well. Set MONDRIAN_DRIVER environment variable to "mysql" (default), "postgresql", "oracle", "luciddb", "mssql" (jTDS) or "sqlserver" (Microsoft JDBC) to specify database driver that should be used.
+
+If using MySQL, PostgreSQL or SQL Server database then create database user mondrian_test with password mondrian_test, create database mondrian_test and grant full access to this database for mondrian_test user. By default it is assumed that database is located on localhost (can be overridden with DATABASE_HOST environment variable).
+
+If using Oracle database then create database user mondrian_test with password mondrian_test. By default it is assumed that database orcl is located on localhost (can be overridden with DATABASE_NAME and DATABASE_HOST environment variables).
+
+If using LucidDB database then create schema MONDRIAN_TEST and create user MONDRIAN_TEST with password mondrian_test and with default schema MONDRIAN_TEST. By default it is assumed that database is located on localhost (can be overridden with DATABASE_HOST environment variable).
+
+See spec/spec_helper.rb for details of default connection parameters and how to override them.
+
+== Creating test data
+
+Install necessary gems with
+
+  bundle install
+
+Create tables with test data using
+
+  rake db:create_data
+
+or specify which database driver to use
+
+  rake db:create_data MONDRIAN_DRIVER=mysql
+  rake db:create_data MONDRIAN_DRIVER=postgresql
+  rake db:create_data MONDRIAN_DRIVER=oracle
+  rake db:create_data MONDRIAN_DRIVER=mssql
+  rake db:create_data MONDRIAN_DRIVER=sqlserver
+
+In case of LucidDB data are not generated and inserted directly into database but are imported from MySQL mondrian_test database (because inserting individual records into LucidDB is very inefficient). Therefore at first generate test data with mysql (using default database settings) and then run data creation task for LucidDB.
+
+  rake db:create_data MONDRIAN_DRIVER=mysql
+  rake db:create_data MONDRIAN_DRIVER=luciddb
+
+== Running tests
+
+Run tests with
+
+  rake spec
+
+or specify which database driver to use
+
+  rake spec MONDRIAN_DRIVER=mysql
+  rake spec MONDRIAN_DRIVER=postgresql
+  rake spec MONDRIAN_DRIVER=oracle
+  rake spec MONDRIAN_DRIVER=luciddb
+  rake spec MONDRIAN_DRIVER=mssql
+  rake spec MONDRIAN_DRIVER=sqlserver
+
+or also alternatively with
+
+  rake spec:mysql
+  rake spec:postgresql
+  rake spec:oracle
+  rake spec:luciddb
+  rake spec:mssql
+  rake spec:sqlserver
+
+You can also run all tests on all databases with
+
+  rake spec:all
+
+== JRuby versions
+
+It is recommended to use RVM (http://rvm.beginrescueend.com) to run tests with different JRuby implementations. mondrian-olap is being tested with latest versions of JRuby 1.6 and 1.7 on Java 6 and 7.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "mondrian-olap"
+  gem.summary = "JRuby API for Mondrian OLAP Java library"
+  gem.description = <<-EOS
+JRuby gem for performing multidimensional queries of relational database data using Mondrian OLAP Java library
+EOS
+  gem.email = "raimonds.simanovskis@gmail.com"
+  gem.homepage = "http://github.com/rsim/mondrian-olap"
+  gem.authors = ["Raimonds Simanovskis"]
+  gem.platform = "java"
+  gem.extra_rdoc_files = ['README.md']
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rcov_opts =  ['--exclude', '/Library,spec/']
+end
+
+task :default => :spec
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title = "mondrian-olap #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'spec/rake_tasks'

data/VERSION

@@ -0,0 +1 @@
+0.4.0

data/lib/mondrian-olap.rb

@@ -0,0 +1 @@
+require 'mondrian/olap'

data/lib/mondrian/jars/log4j.properties

@@ -0,0 +1,5 @@
+# Logs errors on the console
+#
+log4j.rootLogger = ERROR, A1
+log4j.appender.A1 = org.apache.log4j.ConsoleAppender
+log4j.appender.A1.layout=org.apache.log4j.PatternLayout

data/lib/mondrian/olap.rb

@@ -0,0 +1,17 @@
+require 'java'
+
+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/lib/mondrian/olap/connection.rb

@@ -0,0 +1,201 @@
+module Mondrian
+  module OLAP
+    class Connection
+      def self.create(params)
+        connection = new(params)
+        connection.connect
+        connection
+      end
+
+      attr_reader :raw_connection, :raw_catalog, :raw_schema
+
+      def initialize(params={})
+        @params = params
+        @driver = params[:driver]
+        @connected = false
+        @raw_connection = nil
+      end
+
+      def connect
+        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
+
+          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
+
+          # TODO: removed workaround for Mondrian ServiceDiscovery
+          # need to check if database dialects are always loaded by ServiceDiscovery detected class loader
+          @raw_jdbc_connection = driver.connect(conn_string, props)
+
+          @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?
+        @connected
+      end
+
+      def close
+        @raw_connection.close
+        @connected = false
+        @raw_connection = @raw_jdbc_connection = nil
+        true
+      end
+
+      def execute(query_string)
+        Error.wrap_native_exception do
+          statement = @raw_connection.prepareOlapStatement(query_string)
+          Result.new(self, statement.executeQuery())
+        end
+      end
+
+      def from(cube_name)
+        Query.from(self, cube_name)
+      end
+
+      def cube_names
+        @raw_schema.getCubes.map{|c| c.getName}
+      end
+
+      def cube(name)
+        Cube.get(self, name)
+      end
+
+      # 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.
+      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 available_role_names
+        @raw_connection.getAvailableRoleNames.to_a
+      end
+
+      def role_name
+        @raw_connection.getRoleName
+      end
+
+      def role_names
+        @raw_connection.getRoleNames.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
+          @raw_connection.setRoleNames(Array(names))
+        end
+      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
+        string << (@params[:catalog] ? "Catalog=#{catalog_uri}" : "CatalogContent=#{quote_string(catalog_content)}")
+      end
+
+      def jdbc_uri
+        case @driver
+        when 'mysql', 'postgresql'
+          uri = "jdbc:#{@driver}://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/#{@params[:database]}"
+          uri << "?useUnicode=yes&characterEncoding=UTF-8" if @driver == 'mysql'
+          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]}"
+          end
+        when 'luciddb'
+          uri = "jdbc:luciddb:http://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}"
+          uri << ";schema=#{@params[:database_schema]}" if @params[:database_schema]
+          uri
+        when 'mssql'
+          uri = "jdbc:jtds:sqlserver://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/#{@params[:database]}"
+          uri << ";instance=#{@params[:instance]}" if @params[:instance]
+          uri << ";domain=#{@params[:domain]}" if @params[:domain]
+          uri << ";appname=#{@params[:appname]}" if @params[:appname]
+          uri
+        when 'sqlserver'
+          uri = "jdbc:sqlserver://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}"
+          uri << ";databaseName=#{@params[:database]}" if @params[:database]
+          uri << ";integratedSecurity=#{@params[:integrated_security]}" if @params[:integrated_security]
+          uri << ";applicationName=#{@params[:application_name]}" if @params[:application_name]
+          uri << ";instanceName=#{@params[:instance_name]}" if @params[:instance_name]
+          uri
+        else
+          raise ArgumentError, 'unknown JDBC driver'
+        end
+      end
+
+      def jdbc_driver
+        case @driver
+        when 'mysql'
+          'com.mysql.jdbc.Driver'
+        when 'postgresql'
+          'org.postgresql.Driver'
+        when 'oracle'
+          'oracle.jdbc.OracleDriver'
+        when 'luciddb'
+          'org.luciddb.jdbc.LucidDbClientDriver'
+        when 'mssql'
+          'net.sourceforge.jtds.jdbc.Driver'
+        when 'sqlserver'
+          'com.microsoft.sqlserver.jdbc.SQLServerDriver'
+        else
+          raise ArgumentError, 'unknown JDBC driver'
+        end
+      end
+
+      def catalog_uri
+        if @params[:catalog]
+          "file://#{File.expand_path(@params[:catalog])}"
+        else
+          raise ArgumentError, 'missing catalog source'
+        end
+      end
+
+      def catalog_content
+        if @params[:catalog_content]
+          @params[:catalog_content]
+        elsif @params[:schema]
+          @params[:schema].to_xml(:driver => @driver)
+        else
+          raise ArgumentError, "Specify catalog with :catalog, :catalog_content or :schema option"
+        end
+      end
+
+      def quote_string(string)
+        "'#{string.gsub("'","''")}'"
+      end
+
+    end
+  end
+end

data/lib/mondrian/olap/cube.rb

@@ -0,0 +1,297 @@
+module Mondrian
+  module OLAP
+    class Cube
+      def self.get(connection, name)
+        if raw_cube = connection.raw_schema.getCubes.get(name)
+          Cube.new(connection, raw_cube)
+        end
+      end
+
+      def initialize(connection, raw_cube)
+        @connection = connection
+        @raw_cube = raw_cube
+      end
+
+      def name
+        @name ||= @raw_cube.getName
+      end
+
+      def description
+        @description ||= @raw_cube.getDescription
+      end
+
+      def dimensions
+        @dimenstions ||= @raw_cube.getDimensions.map{|d| Dimension.new(self, d)}
+      end
+
+      def dimension_names
+        dimensions.map{|d| d.name}
+      end
+
+      def dimension(name)
+        dimensions.detect{|d| d.name == name}
+      end
+
+      def query
+        Query.from(@connection, name)
+      end
+
+      def member(full_name)
+        segment_list = Java::OrgOlap4jMdx::IdentifierNode.parseIdentifier(full_name).getSegmentList
+        raw_member = @raw_cube.lookupMember(segment_list)
+        raw_member && Member.new(raw_member)
+      end
+
+      def member_by_segments(*segment_names)
+        segment_list = Java::OrgOlap4jMdx::IdentifierNode.ofNames(*segment_names).getSegmentList
+        raw_member = @raw_cube.lookupMember(segment_list)
+        raw_member && Member.new(raw_member)
+      end
+    end
+
+    class Dimension
+      def initialize(cube, raw_dimension)
+        @cube = cube
+        @raw_dimension = raw_dimension
+      end
+
+      attr_reader :cube
+
+      def name
+        @name ||= @raw_dimension.getName
+      end
+
+      def description
+        @description ||= @raw_dimension.getDescription
+      end
+
+      def full_name
+        @full_name ||= @raw_dimension.getUniqueName
+      end
+
+      def hierarchies
+        @hierarchies ||= @raw_dimension.getHierarchies.map{|h| Hierarchy.new(self, h)}
+      end
+
+      def hierarchy_names
+        hierarchies.map{|h| h.name}
+      end
+
+      def hierarchy(name = nil)
+        name ||= self.name
+        hierarchies.detect{|h| h.name == name}
+      end
+
+      def measures?
+        @raw_dimension.getDimensionType == Java::OrgOlap4jMetadata::Dimension::Type::MEASURE
+      end
+
+      def dimension_type
+        case @raw_dimension.getDimensionType
+        when Java::OrgOlap4jMetadata::Dimension::Type::TIME
+          :time
+        when Java::OrgOlap4jMetadata::Dimension::Type::MEASURE
+          :measures
+        else
+          :standard
+        end
+      end
+    end
+
+    class Hierarchy
+      def initialize(dimension, raw_hierarchy)
+        @dimension = dimension
+        @raw_hierarchy = raw_hierarchy
+      end
+
+      def name
+        @name ||= @raw_hierarchy.getName
+      end
+
+      def description
+        @description ||= @raw_hierarchy.getDescription
+      end
+
+      def levels
+        @levels = @raw_hierarchy.getLevels.map{|l| Level.new(self, l)}
+      end
+
+      def level(name)
+        levels.detect{|l| l.name == name}
+      end
+
+      def level_names
+        levels.map{|l| l.name}
+      end
+
+      def has_all?
+        @raw_hierarchy.hasAll
+      end
+
+      def all_member_name
+        has_all? ? @raw_hierarchy.getRootMembers.first.getName : nil
+      end
+
+      def all_member
+        has_all? ? Member.new(@raw_hierarchy.getRootMembers.first) : nil
+      end
+
+      def root_members
+        @raw_hierarchy.getRootMembers.map{|m| Member.new(m)}
+      end
+
+      def root_member_names
+        @raw_hierarchy.getRootMembers.map{|m| m.getName}
+      end
+
+      def root_member_full_names
+        @raw_hierarchy.getRootMembers.map{|m| m.getUniqueName}
+      end
+
+      def child_names(*parent_member_segment_names)
+        Error.wrap_native_exception do
+          parent_member = if parent_member_segment_names.empty?
+            return root_member_names unless has_all?
+            all_member
+          else
+            @dimension.cube.member_by_segments(*parent_member_segment_names)
+          end
+          parent_member && parent_member.children.map{|m| m.name}
+        end
+      end
+    end
+
+    class Level
+      def initialize(hierarchy, raw_level)
+        @hierarchy = hierarchy
+        @raw_level = raw_level
+      end
+
+      def name
+        @name ||= @raw_level.getName
+      end
+
+      def description
+        @description ||= @raw_level.getDescription
+      end
+
+      def depth
+        @raw_level.getDepth
+      end
+
+      def cardinality
+        @cardinality = @raw_level.getCardinality
+      end
+
+      def members_count
+        @members_count ||= begin
+          if cardinality >= 0
+            cardinality
+          else
+            Error.wrap_native_exception do
+              @raw_level.getMembers.size
+            end
+          end
+        end
+      end
+
+      def members
+        Error.wrap_native_exception do
+          @raw_level.getMembers.map{|m| Member.new(m)}
+        end
+      end
+    end
+
+    class Member
+      def initialize(raw_member)
+        @raw_member = raw_member
+      end
+
+      def name
+        @raw_member.getName
+      end
+
+      def full_name
+        @raw_member.getUniqueName
+      end
+
+      def caption
+        @raw_member.getCaption
+      end
+
+      def calculated?
+        @raw_member.isCalculated
+      end
+
+      def visible?
+        @raw_member.isVisible
+      end
+
+      def all_member?
+        @raw_member.isAll
+      end
+
+      def drillable?
+        return false if calculated?
+        # @raw_member.getChildMemberCount > 0
+        # This hopefully is faster than counting actual child members
+        raw_level = @raw_member.getLevel
+        raw_levels = raw_level.getHierarchy.getLevels
+        raw_levels.indexOf(raw_level) < raw_levels.size - 1
+      end
+
+      def depth
+        @raw_member.getDepth
+      end
+
+      def dimension_type
+        case @raw_member.getDimension.getDimensionType
+        when Java::OrgOlap4jMetadata::Dimension::Type::TIME
+          :time
+        when Java::OrgOlap4jMetadata::Dimension::Type::MEASURE
+          :measures
+        else
+          :standard
+        end
+      end
+
+      def children
+        Error.wrap_native_exception do
+          @raw_member.getChildMembers.map{|m| Member.new(m)}
+        end
+      end
+
+      def descendants_at_level(level)
+        Error.wrap_native_exception do
+          raw_level = @raw_member.getLevel
+          raw_levels = raw_level.getHierarchy.getLevels
+          current_level_index = raw_levels.indexOf(raw_level)
+          descendants_level_index = raw_levels.indexOfName(level)
+
+          return nil unless descendants_level_index > current_level_index
+
+          members = [self]
+          (descendants_level_index - current_level_index).times do
+            members = members.map do |member|
+              member.children
+            end.flatten
+          end
+          members
+        end
+      end
+
+      def property_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyValue(property)
+        end
+      end
+
+      def property_formatted_value(name)
+        if property = @raw_member.getProperties.get(name)
+          @raw_member.getPropertyFormattedValue(property)
+        end
+      end
+
+    end
+  end
+end