mondrian-olap 0.1.0

data/RUNNING_TESTS.rdoc

@@ -0,0 +1,41 @@
+== Creating test database
+
+By default unit tests use MySQL database but PostgreSQL and Oracle databases are supported as well. Set MONDRIAN_DRIVER environment variable to "mysql" (default), "postgresql" or "oracle" to specify database driver that should be used.
+
+If using MySQL or PostgreSQL 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).
+
+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
+
+== 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
+
+== JRuby versions
+
+It is recommended to use RVM (http://rvm.beginrescueend.com) to run tests with different JRuby implementations. mondrian-olap has been tested with JRuby 1.5 and 1.6 release candidate versions.

data/Rakefile

@@ -0,0 +1,46 @@
+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"]
+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 'rake/rdoctask'
+Rake::RDocTask.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.1.0

data/lib/mondrian-olap.rb

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

data/lib/mondrian/jars/log4j.properties

@@ -0,0 +1,18 @@
+#
+# Log4J Konfiguration
+#
+# - Logs errors on the console
+#
+
+log4j.rootLogger = ERROR, A1
+
+# Logging to console
+log4j.appender.A1 = org.apache.log4j.ConsoleAppender
+
+# Logging message format
+# %d{DATE} Datum im Format dd MMM YYYY HH:mm:ss,SSS
+# %-5p Priorität der Meldung 5stellig
+# %m Meldung
+# %n Zeilenumbruch
+log4j.appender.A1.layout=org.apache.log4j.PatternLayout
+# log4j.appender.A1.layout.ConversionPattern=[JPivot] %d{DATE} %-5p [Session %X{SessionID}] %C#%M: %m%n

data/lib/mondrian/olap.rb

@@ -0,0 +1,14 @@
+require 'java'
+
+directory = File.expand_path("../jars", __FILE__)
+Dir["#{directory}/*.jar"].each do |file|
+  require file
+end
+
+java.lang.System.setProperty("log4j.configuration", "file://#{directory}/log4j.properties")
+# register Mondrian olap4j driver
+Java::mondrian.olap4j.MondrianOlap4jDriver
+
+%w(connection query result schema cube).each do |file|
+  require "mondrian/olap/#{file}"
+end

data/lib/mondrian/olap/connection.rb

@@ -0,0 +1,122 @@
+module Mondrian
+  module OLAP
+    class Connection
+      def self.create(params)
+        connection = new(params)
+        connection.connect
+        connection
+      end
+
+      attr_reader :raw_connection, :raw_schema, :raw_schema_reader
+
+      def initialize(params={})
+        @params = params
+        @driver = params[:driver]
+        @connected = false
+        @raw_connection = nil
+      end
+
+      def connect
+        @raw_jdbc_connection = Java::JavaSql::DriverManager.getConnection(connection_string)
+        @raw_connection = @raw_jdbc_connection.unwrap(Java::OrgOlap4j::OlapConnection.java_class)
+        @raw_schema = @raw_connection.getSchema
+        @connected = true
+        true
+      end
+
+      def connected?
+        @connected
+      end
+
+      def close
+        @raw_connection.close
+        @connected = false
+        @raw_connection = @raw_jdbc_connection = nil
+        true
+      end
+
+      def execute(query_string)
+        statement = @raw_connection.prepareOlapStatement(query_string)
+        Result.new(self, statement.executeQuery())
+      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
+
+      private
+
+      def connection_string
+        "jdbc:mondrian:Jdbc=#{jdbc_uri};JdbcDrivers=#{jdbc_driver};" <<
+          (@params[:catalog] ? "Catalog=#{catalog_uri}" : "CatalogContent=#{catalog_content}")
+      end
+
+      def jdbc_uri
+        case @driver
+        when 'mysql', 'postgresql'
+          "jdbc:#{@driver}://#{@params[:host]}#{@params[:port] && ":#{@params[:port]}"}/#{@params[:database]}" <<
+          "?user=#{@params[:username]}&password=#{@params[:password]}"
+        when 'oracle'
+          # connection using TNS alias
+          if @params[:database] && !@params[:host] && !@params[:url] && ENV['TNS_ADMIN']
+            "jdbc:oracle:thin:#{@params[:username]}/#{@params[:password]}@#{@params[:database]}"
+          else
+            @params[:url] ||
+            "jdbc:oracle:thin:#{@params[:username]}/#{@params[:password]}" <<
+            "@#{@params[:host] || 'localhost'}:#{@params[:port] || 1521}:#{@params[:database]}"
+          end
+        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'
+        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
+
+    end
+  end
+end

data/lib/mondrian/olap/cube.rb

@@ -0,0 +1,236 @@
+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 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_names = Java::OrgOlap4jMdx::IdentifierNode.parseIdentifier(full_name).map do |segment|
+          segment.getName
+        end
+        member_by_segments(*segment_names)
+      end
+
+      def member_by_segments(*segment_names)
+        raw_member = @raw_cube.lookupMember(*segment_names)
+        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 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 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)
+        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
+
+    class Level
+      def initialize(hierarchy, raw_level)
+        @hierarchy = hierarchy
+        @raw_level = raw_level
+      end
+
+      def name
+        @name ||= @raw_level.getName
+      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
+            @raw_level.getMembers.size
+          end
+        end
+      end
+
+      def members
+        @raw_level.getMembers.map{|m| Member.new(m)}
+      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 calculated?
+        @raw_member.isCalculated
+      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 children
+        @raw_member.getChildMembers.map{|m| Member.new(m)}
+      end
+
+      def descendants_at_level(level)
+        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
+  end
+end