mondrian-olap 0.3.0 → 0.5.0

data/.rspec

@@ -1,2 +0,0 @@
---color
---backtrace

data/Gemfile

@@ -1,18 +0,0 @@
-source 'http://rubygems.org'
-
-gem 'nokogiri', '~> 1.5.0'
-
-group :development do
-  gem 'jruby-openssl'
-  gem 'jeweler', '~> 1.5.2'
-  gem 'rdoc'
-  gem 'rspec', '~> 2.5'
-  gem 'autotest'
-  gem 'jdbc-mysql'
-  gem 'jdbc-postgres'
-  gem 'jdbc-luciddb'
-  gem 'jdbc-jtds'
-  gem 'activerecord', '= 3.0.10'
-  gem 'activerecord-jdbc-adapter', '= 1.1.1'
-  gem 'activerecord-oracle_enhanced-adapter', :require => false
-end

data/README.rdoc

@@ -1,221 +0,0 @@
-= 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.
-
-== 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 at 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:
-
-  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 => 'weak_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:
-
-  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 at 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":
-
-  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:
-
-  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:
-
-  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":
-
-  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:
-
-  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.
-
-== REQUIREMENTS
-
-mondrian-olap gem is compatible with JRuby versions 1.5 and 1.6 (have not been tested with earlier versions). 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 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
-
-== 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/RUNNING_TESTS.rdoc

@@ -1,66 +0,0 @@
-== 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 on Java 6.

data/Rakefile

@@ -1,46 +0,0 @@
-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 '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/mondrian-olap.gemspec

@@ -1,126 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{mondrian-olap}
-  s.version = "0.3.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = [%q{Raimonds Simanovskis}]
-  s.date = %q{2011-11-12}
-  s.description = %q{JRuby gem for performing multidimensional queries of relational database data using Mondrian OLAP Java library
-}
-  s.email = %q{raimonds.simanovskis@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE-Mondrian.html",
-    "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".rspec",
-    "Changelog.md",
-    "Gemfile",
-    "LICENSE-Mondrian.html",
-    "LICENSE.txt",
-    "README.rdoc",
-    "RUNNING_TESTS.rdoc",
-    "Rakefile",
-    "VERSION",
-    "lib/mondrian-olap.rb",
-    "lib/mondrian/jars/commons-collections-3.1.jar",
-    "lib/mondrian/jars/commons-dbcp-1.2.1.jar",
-    "lib/mondrian/jars/commons-logging-1.0.4.jar",
-    "lib/mondrian/jars/commons-math-1.0.jar",
-    "lib/mondrian/jars/commons-pool-1.2.jar",
-    "lib/mondrian/jars/commons-vfs-1.0.jar",
-    "lib/mondrian/jars/eigenbase-properties.jar",
-    "lib/mondrian/jars/eigenbase-resgen.jar",
-    "lib/mondrian/jars/eigenbase-xom.jar",
-    "lib/mondrian/jars/javacup.jar",
-    "lib/mondrian/jars/log4j-1.2.8.jar",
-    "lib/mondrian/jars/log4j.properties",
-    "lib/mondrian/jars/mondrian.jar",
-    "lib/mondrian/jars/olap4j.jar",
-    "lib/mondrian/olap.rb",
-    "lib/mondrian/olap/connection.rb",
-    "lib/mondrian/olap/cube.rb",
-    "lib/mondrian/olap/query.rb",
-    "lib/mondrian/olap/result.rb",
-    "lib/mondrian/olap/schema.rb",
-    "lib/mondrian/olap/schema_element.rb",
-    "mondrian-olap.gemspec",
-    "spec/connection_spec.rb",
-    "spec/cube_spec.rb",
-    "spec/fixtures/MondrianTest.xml",
-    "spec/fixtures/MondrianTestOracle.xml",
-    "spec/query_spec.rb",
-    "spec/rake_tasks.rb",
-    "spec/schema_definition_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/support/matchers/be_like.rb"
-  ]
-  s.homepage = %q{http://github.com/rsim/mondrian-olap}
-  s.require_paths = [%q{lib}]
-  s.rubygems_version = %q{1.8.9}
-  s.summary = %q{JRuby API for Mondrian OLAP Java library}
-  s.test_files = [
-    "spec/connection_spec.rb",
-    "spec/cube_spec.rb",
-    "spec/query_spec.rb",
-    "spec/rake_tasks.rb",
-    "spec/schema_definition_spec.rb",
-    "spec/spec_helper.rb",
-    "spec/support/matchers/be_like.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<nokogiri>, ["~> 1.5.0"])
-      s.add_development_dependency(%q<jruby-openssl>, [">= 0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_development_dependency(%q<rdoc>, [">= 0"])
-      s.add_development_dependency(%q<rspec>, ["~> 2.5"])
-      s.add_development_dependency(%q<autotest>, [">= 0"])
-      s.add_development_dependency(%q<jdbc-mysql>, [">= 0"])
-      s.add_development_dependency(%q<jdbc-postgres>, [">= 0"])
-      s.add_development_dependency(%q<jdbc-luciddb>, [">= 0"])
-      s.add_development_dependency(%q<jdbc-jtds>, [">= 0"])
-      s.add_development_dependency(%q<activerecord>, ["= 3.0.10"])
-      s.add_development_dependency(%q<activerecord-jdbc-adapter>, ["= 1.1.1"])
-      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
-    else
-      s.add_dependency(%q<nokogiri>, ["~> 1.5.0"])
-      s.add_dependency(%q<jruby-openssl>, [">= 0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-      s.add_dependency(%q<rdoc>, [">= 0"])
-      s.add_dependency(%q<rspec>, ["~> 2.5"])
-      s.add_dependency(%q<autotest>, [">= 0"])
-      s.add_dependency(%q<jdbc-mysql>, [">= 0"])
-      s.add_dependency(%q<jdbc-postgres>, [">= 0"])
-      s.add_dependency(%q<jdbc-luciddb>, [">= 0"])
-      s.add_dependency(%q<jdbc-jtds>, [">= 0"])
-      s.add_dependency(%q<activerecord>, ["= 3.0.10"])
-      s.add_dependency(%q<activerecord-jdbc-adapter>, ["= 1.1.1"])
-      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<nokogiri>, ["~> 1.5.0"])
-    s.add_dependency(%q<jruby-openssl>, [">= 0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
-    s.add_dependency(%q<rdoc>, [">= 0"])
-    s.add_dependency(%q<rspec>, ["~> 2.5"])
-    s.add_dependency(%q<autotest>, [">= 0"])
-    s.add_dependency(%q<jdbc-mysql>, [">= 0"])
-    s.add_dependency(%q<jdbc-postgres>, [">= 0"])
-    s.add_dependency(%q<jdbc-luciddb>, [">= 0"])
-    s.add_dependency(%q<jdbc-jtds>, [">= 0"])
-    s.add_dependency(%q<activerecord>, ["= 3.0.10"])
-    s.add_dependency(%q<activerecord-jdbc-adapter>, ["= 1.1.1"])
-    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
-  end
-end
-