mondrian-olap 0.4.0-java

data/lib/mondrian/olap/schema_udf.rb

@@ -0,0 +1,282 @@
+require 'jruby/core_ext'
+
+module Mondrian
+  module OLAP
+    class Schema < SchemaElement
+
+      module ScriptElements
+        def javascript(text)
+          script text, :language => 'JavaScript'
+        end
+
+        private
+
+        def coffeescript_function(arguments_string, text)
+          # construct function to ensure that last expression is returned
+          coffee_text = "#{arguments_string} ->\n" << text.gsub(/^/,'  ')
+          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
+          # remove function definition first and last lines
+          javascript_text = javascript_text.strip.lines.to_a[1..-2].join
+          javascript javascript_text
+        end
+
+        def ruby_formatter(interface_class, method, signature, &block)
+          formatter_class = Class.new
+          formatter_class.class_eval do
+            include interface_class
+            define_method method, &block
+            add_method_signature(method, signature)
+          end
+          formatter_java_class = formatter_class.become_java!(false)
+          class_name formatter_java_class.getName
+        end
+      end
+
+      class UserDefinedFunction < SchemaElement
+        include ScriptElements
+        attributes :name, # Name with which the user-defined function will be referenced in MDX expressions.
+          # Name of the class which implemenets this user-defined function.
+          # Must implement the mondrian.spi.UserDefinedFunction  interface.
+          :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffee_text = "__udf__ = {\n" << text << "}\n"
+          javascript_text = CoffeeScript.compile(coffee_text, :bare => true)
+          javascript_text << <<-JS
+
+__udf__.parameters || (__udf__.parameters = []);
+__udf__.returns || (__udf__.returns = "Scalar");
+var __scalarTypes__ = {"Numeric":true,"String":true,"Boolean":true,"DateTime":true,"Decimal":true,"Scalar":true};
+function __getType__(type) {
+  if (__scalarTypes__[type]) {
+    return new mondrian.olap.type[type+"Type"];
+  } else if (type === "Member") {
+    return mondrian.olap.type.MemberType.Unknown;
+  } else {
+    return null;
+  }
+}
+function getParameterTypes() {
+  var parameters = __udf__.parameters || [],
+      types = [];
+  for (var i = 0, len = parameters.length; i < len; i++) {
+    types.push(__getType__(parameters[i]))
+  }
+  return types;
+}
+function getReturnType(parameterTypes) {
+  var returns = __udf__.returns || "Scalar";
+  return __getType__(returns);
+}
+if (__udf__.syntax) {
+  function getSyntax() {
+    return mondrian.olap.Syntax[__udf__.syntax];
+  }
+}
+function execute(evaluator, args) {
+  var parameters = __udf__.parameters || [],
+      values = [],
+      value;
+  for (var i = 0, len = parameters.length; i < len; i++) {
+    if (__scalarTypes__[parameters[i]]) {
+      value = args[i].evaluateScalar(evaluator);
+    } else {
+      value = args[i].evaluate(evaluator);
+    }
+    values.push(value);
+  }
+  return __udf__.execute.apply(__udf__, values);
+}
+JS
+          javascript javascript_text
+        end
+
+        class RubyUdfBase
+          include Java::mondrian.spi.UserDefinedFunction
+          def self.function_name=(name); @function_name = name; end
+          def self.function_name; @function_name; end
+
+          def getName
+            self.class.function_name
+          end
+          add_method_signature("getName", [java.lang.String])
+
+          def getDescription
+            getName
+          end
+          add_method_signature("getDescription", [java.lang.String])
+
+          def self.parameters(*types)
+            if types.empty?
+              @parameters || []
+            else
+              @parameters = types.map{|type| stringified_type(type)}
+            end
+          end
+
+          def self.returns(type = nil)
+            if type
+              @returns = stringified_type(type)
+            else
+              @returns || 'Scalar'
+            end
+          end
+
+          VALID_SYNTAX_TYPES = %w(Function Property Method)
+          def self.syntax(type = nil)
+            if type
+              type = stringify(type)
+              raise ArgumentError, "invalid user defined function type #{type.inspect}" unless VALID_SYNTAX_TYPES.include? type
+              @syntax = type
+            else
+              @syntax || 'Function'
+            end
+          end
+
+          def getSyntax
+            Java::mondrian.olap.Syntax.const_get self.class.syntax
+          end
+          add_method_signature("getSyntax", [Java::mondrian.olap.Syntax])
+
+          UDF_SCALAR_TYPES = {
+            "Numeric" => Java::mondrian.olap.type.NumericType,
+            "String" => Java::mondrian.olap.type.StringType,
+            "Boolean" => Java::mondrian.olap.type.BooleanType,
+            "DateTime" => Java::mondrian.olap.type.DateTimeType,
+            "Decimal" => Java::mondrian.olap.type.DecimalType,
+            "Scalar" => Java::mondrian.olap.type.ScalarType
+          }
+          UDF_OTHER_TYPES = {
+            "Member" => Java::mondrian.olap.type.MemberType::Unknown,
+            "Set" => Java::mondrian.olap.type.SetType.new(Java::mondrian.olap.type.MemberType::Unknown),
+            "Hierarchy" => Java::mondrian.olap.type.HierarchyType.new(nil, nil),
+            "Level" => Java::mondrian.olap.type.LevelType::Unknown
+          }
+
+          def getParameterTypes
+            @parameterTypes ||= self.class.parameters.map{|p| get_java_type(p)}
+          end
+          class_loader = JRuby.runtime.jruby_class_loader
+          type_array_class = java.lang.Class.forName "[Lmondrian.olap.type.Type;", true, class_loader
+          add_method_signature("getParameterTypes", [type_array_class])
+
+          def getReturnType(parameterTypes)
+            @returnType ||= get_java_type self.class.returns
+          end
+          add_method_signature("getReturnType", [Java::mondrian.olap.type.Type, type_array_class])
+
+          def getReservedWords
+            nil
+          end
+          string_array_class = java.lang.Class.forName "[Ljava.lang.String;", true, class_loader
+          add_method_signature("getReservedWords", [string_array_class])
+
+          def execute(evaluator, arguments)
+            values = []
+            self.class.parameters.each_with_index do |p,i|
+              value = UDF_SCALAR_TYPES[p] ? arguments[i].evaluateScalar(evaluator) : arguments[i].evaluate(evaluator)
+              values << value
+            end
+            call_with_evaluator(evaluator, *values)
+          end
+          arguments_array_class = java.lang.Class.forName "[Lmondrian.spi.UserDefinedFunction$Argument;", true, class_loader
+          add_method_signature("execute", [java.lang.Object, Java::mondrian.olap.Evaluator, arguments_array_class])
+
+          # Override this metho if evaluator is needed
+          def call_with_evaluator(evaluator, *values)
+            call(*values)
+          end
+
+          private
+
+          def get_java_type(type)
+            if type_class = UDF_SCALAR_TYPES[type]
+              type_class.new
+            else
+              UDF_OTHER_TYPES[type]
+            end
+          end
+
+          def self.stringified_type(type)
+            type = stringify(type)
+            raise ArgumentError, "invalid user defined function type #{type.inspect}" unless UDF_SCALAR_TYPES[type] || UDF_OTHER_TYPES[type]
+            type
+          end
+
+          def self.stringify(arg)
+            arg = arg.to_s.split('_').map{|s| s.capitalize}.join if arg.is_a? Symbol
+            arg
+          end
+        end
+
+        def ruby(*options, &block)
+          udf_class_name = if options.include?(:shared)
+            "#{name.capitalize}Udf"
+          end
+          if udf_class_name && self.class.const_defined?(udf_class_name)
+            udf_class = self.class.const_get(udf_class_name)
+          else
+            udf_class = Class.new(RubyUdfBase)
+            self.class.const_set(udf_class_name, udf_class) if udf_class_name
+          end
+          udf_class.function_name = name
+          udf_class.class_eval(&block)
+          udf_java_class = udf_class.become_java!(false)
+
+          class_name udf_java_class.getName
+        end
+      end
+
+      class Script < SchemaElement
+        attributes :language
+        content :text
+      end
+
+      class CellFormatter < SchemaElement
+        include ScriptElements
+        # Name of a formatter class for the appropriate cell being displayed.
+        # The class must implement the mondrian.olap.CellFormatter interface.
+        attributes :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffeescript_function('(value)', text)
+        end
+
+        def ruby(&block)
+          ruby_formatter(Java::mondrian.spi.CellFormatter, 'formatCell', [java.lang.String, java.lang.Object], &block)
+        end
+      end
+
+      class MemberFormatter < SchemaElement
+        include ScriptElements
+        attributes :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffeescript_function('(member)', text)
+        end
+
+        def ruby(&block)
+          ruby_formatter(Java::mondrian.spi.MemberFormatter, 'formatMember', [java.lang.String, Java::mondrian.olap.Member], &block)
+        end
+      end
+
+      class PropertyFormatter < SchemaElement
+        include ScriptElements
+        attributes :class_name
+        elements :script
+
+        def coffeescript(text)
+          coffeescript_function('(member,propertyName,propertyValue)', text)
+        end
+
+        def ruby(&block)
+          ruby_formatter(Java::mondrian.spi.PropertyFormatter, 'formatProperty', [java.lang.String, Java::mondrian.olap.Member, java.lang.String, java.lang.Object], &block)
+        end
+      end
+
+    end
+  end
+end

data/mondrian-olap.gemspec

@@ -0,0 +1,128 @@
+# 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 = "mondrian-olap"
+  s.version = "0.4.0"
+  s.platform = "java"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Raimonds Simanovskis"]
+  s.date = "2012-12-03"
+  s.description = "JRuby gem for performing multidimensional queries of relational database data using Mondrian OLAP Java library\n"
+  s.email = "raimonds.simanovskis@gmail.com"
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".rspec",
+    "Changelog.md",
+    "Gemfile",
+    "LICENSE-Mondrian.html",
+    "LICENSE.txt",
+    "README.md",
+    "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/error.rb",
+    "lib/mondrian/olap/query.rb",
+    "lib/mondrian/olap/result.rb",
+    "lib/mondrian/olap/schema.rb",
+    "lib/mondrian/olap/schema_element.rb",
+    "lib/mondrian/olap/schema_udf.rb",
+    "mondrian-olap.gemspec",
+    "spec/connection_role_spec.rb",
+    "spec/connection_spec.rb",
+    "spec/cube_spec.rb",
+    "spec/fixtures/MondrianTest.xml",
+    "spec/fixtures/MondrianTestOracle.xml",
+    "spec/mondrian_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"
+  ]
+  s.homepage = "http://github.com/rsim/mondrian-olap"
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.24"
+  s.summary = "JRuby API for Mondrian OLAP Java library"
+
+  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.8.3"])
+      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.10"])
+      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.2.8"])
+      s.add_development_dependency(%q<activerecord-jdbc-adapter>, ["= 1.2.2"])
+      s.add_development_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
+      s.add_development_dependency(%q<coffee-script>, ["~> 2.2.0"])
+      s.add_development_dependency(%q<therubyrhino>, ["~> 1.73.1"])
+      s.add_development_dependency(%q<pry>, [">= 0"])
+    else
+      s.add_dependency(%q<nokogiri>, ["~> 1.5.0"])
+      s.add_dependency(%q<jruby-openssl>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<rspec>, ["~> 2.10"])
+      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.2.8"])
+      s.add_dependency(%q<activerecord-jdbc-adapter>, ["= 1.2.2"])
+      s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
+      s.add_dependency(%q<coffee-script>, ["~> 2.2.0"])
+      s.add_dependency(%q<therubyrhino>, ["~> 1.73.1"])
+      s.add_dependency(%q<pry>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, ["~> 1.5.0"])
+    s.add_dependency(%q<jruby-openssl>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<rspec>, ["~> 2.10"])
+    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.2.8"])
+    s.add_dependency(%q<activerecord-jdbc-adapter>, ["= 1.2.2"])
+    s.add_dependency(%q<activerecord-oracle_enhanced-adapter>, [">= 0"])
+    s.add_dependency(%q<coffee-script>, ["~> 2.2.0"])
+    s.add_dependency(%q<therubyrhino>, ["~> 1.73.1"])
+    s.add_dependency(%q<pry>, [">= 0"])
+  end
+end
+

data/spec/connection_role_spec.rb

@@ -0,0 +1,130 @@
+require "spec_helper"
+
+describe "Connection role" do
+
+  describe "create connection" do
+    before(:each) do
+      @role_name = role_name = 'California manager'
+      @role_name2 = role_name2 = 'Dummy, with comma'
+      @schema = Mondrian::OLAP::Schema.define do
+        cube 'Sales' do
+          table 'sales'
+          dimension 'Gender', :foreign_key => 'customer_id' do
+            hierarchy :has_all => true, :primary_key => 'id' do
+              table 'customers'
+              level 'Gender', :column => 'gender', :unique_members => true
+            end
+          end
+          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 'Time', :foreign_key => 'time_id' do
+            hierarchy :has_all => false, :primary_key => 'id' do
+              table 'time'
+              level 'Year', :column => 'the_year', :type => 'Numeric', :unique_members => true
+              level 'Quarter', :column => 'quarter', :unique_members => false
+              level 'Month', :column => 'month_of_year', :type => 'Numeric', :unique_members => false
+            end
+          end
+          measure 'Unit Sales', :column => 'unit_sales', :aggregator => 'sum'
+          measure 'Store Sales', :column => 'store_sales', :aggregator => 'sum'
+        end
+        role role_name 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
+        role role_name2
+
+        # to test that Role elements are generated before UserDefinedFunction
+        user_defined_function 'Factorial' do
+          ruby do
+            parameters :numeric
+            returns :numeric
+            def call(n)
+              n <= 1 ? 1 : n * call(n - 1)
+            end
+          end
+        end
+      end
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema)
+    end
+
+    it "should connect" do
+      @olap.should be_connected
+    end
+
+    it "should get available role names" do
+      @olap.available_role_names.should == [@role_name, @role_name2]
+    end
+
+    it "should not get role name if not set" do
+      @olap.role_name.should be_nil
+      @olap.role_names.should be_empty
+    end
+
+    it "should set and get role name" do
+      @olap.role_name = @role_name
+      @olap.role_name.should == @role_name
+      @olap.role_names.should == [@role_name]
+    end
+
+    it "should raise error when invalid role name is set" do
+      expect {
+        @olap.role_name = 'invalid'
+      }.to raise_error {|e|
+        e.should be_kind_of(Mondrian::OLAP::Error)
+        e.message.should == "org.olap4j.OlapException: Unknown role 'invalid'"
+        e.root_cause_message.should == "Unknown role 'invalid'"
+      }
+    end
+
+    it "should set and get several role names" do
+      @olap.role_names = [@role_name, @role_name2]
+      @olap.role_name.should == "[#{@role_name}, #{@role_name2}]"
+      @olap.role_names.should == [@role_name, @role_name2]
+    end
+
+    it "should not get non-visible member" do
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should_not be_nil
+      @olap.role_name = @role_name
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+    # TODO: investigate why role name is not returned when set in connection string
+    # it "should set role name from connection parameters" do
+    #   @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+    #     :role => @role_name)
+    #   @olap.role_name.should == @role_name
+    # end
+
+    it "should not get non-visible member when role name set in connection parameters" do
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+        :role => @role_name)
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+    it "should not get non-visible member when several role names set in connection parameters" do
+      @olap = Mondrian::OLAP::Connection.create(CONNECTION_PARAMS.merge :schema => @schema,
+        :roles => [@role_name, @role_name2])
+      @cube = @olap.cube('Sales')
+      @cube.member('[Customers].[USA].[CA].[Los Angeles]').should be_nil
+    end
+
+  end
+end