mondrian-olap 0.3.0 → 0.5.0

data/lib/mondrian/olap/result.rb

@@ -1,4 +1,4 @@
-require 'nokogiri'
+require 'bigdecimal'
 
 module Mondrian
   module OLAP
@@ -24,7 +24,8 @@ module Mondrian
         @axis_members ||= axis_positions(:to_member)
       end
 
-      %w(column row page section chapter).each_with_index do |axis, i|
+      AXIS_SYMBOLS = [:column, :row, :page, :section, :chapter]
+      AXIS_SYMBOLS.each_with_index do |axis, i|
         define_method :"#{axis}_names" do
           axis_names[i]
         end
@@ -59,7 +60,7 @@ module Mondrian
       def to_html(options = {})
         case axes_count
         when 1
-          builder = Nokogiri::XML::Builder.new do |doc|
+          builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |doc|
             doc.table do
               doc.tr do
                 column_full_names.each do |column_full_name|
@@ -76,7 +77,7 @@ module Mondrian
           end
           builder.doc.to_html
         when 2
-          builder = Nokogiri::XML::Builder.new do |doc|
+          builder = Nokogiri::XML::Builder.new(:encoding => 'UTF-8') do |doc|
             doc.table do
               doc.tr do
                 doc.th
@@ -102,6 +103,297 @@ module Mondrian
         end
       end
 
+      # Specify drill through cell position, for example, as
+      #   :row => 0, :cell => 1
+      # Specify max returned rows with :max_rows parameter
+      # Specify returned fields (as list of MDX levels and measures) with :return parameter
+      # Specify measures which at least one should not be empty (NULL) with :nonempty parameter
+      def drill_through(params = {})
+        Error.wrap_native_exception do
+          cell_params = []
+          axes_count.times do |i|
+            axis_symbol = AXIS_SYMBOLS[i]
+            raise ArgumentError, "missing position #{axis_symbol.inspect}" unless axis_position = params[axis_symbol]
+            cell_params << Java::JavaLang::Integer.new(axis_position)
+          end
+          raw_cell = @raw_cell_set.getCell(cell_params)
+          DrillThrough.from_raw_cell(raw_cell, params)
+        end
+      end
+
+      class DrillThrough
+        def self.from_raw_cell(raw_cell, params = {})
+          max_rows = params[:max_rows] || -1
+          # workaround to avoid calling raw_cell.drillThroughInternal private method
+          # which fails when running inside TorqueBox
+          cell_field = raw_cell.java_class.declared_field('cell')
+          cell_field.accessible = true
+          rolap_cell = cell_field.value(raw_cell)
+
+          if params[:return] || rolap_cell.canDrillThrough
+            sql_statement = drill_through_internal(rolap_cell, params)
+            raw_result_set = sql_statement.getWrappedResultSet
+            new(raw_result_set)
+          end
+        end
+
+        def initialize(raw_result_set)
+          @raw_result_set = raw_result_set
+        end
+
+        def column_types
+          @column_types ||= (1..metadata.getColumnCount).map{|i| metadata.getColumnTypeName(i).to_sym}
+        end
+
+        def column_names
+          @column_names ||= begin
+            # if PostgreSQL then use getBaseColumnName as getColumnName returns empty string
+            if metadata.respond_to?(:getBaseColumnName)
+              (1..metadata.getColumnCount).map{|i| metadata.getBaseColumnName(i)}
+            else
+              (1..metadata.getColumnCount).map{|i| metadata.getColumnName(i)}
+            end
+          end
+        end
+
+        def table_names
+          @table_names ||= begin
+            # if PostgreSQL then use getBaseTableName as getTableName returns empty string
+            if metadata.respond_to?(:getBaseTableName)
+              (1..metadata.getColumnCount).map{|i| metadata.getBaseTableName(i)}
+            else
+              (1..metadata.getColumnCount).map{|i| metadata.getTableName(i)}
+            end
+          end
+        end
+
+        def column_labels
+          @column_labels ||= (1..metadata.getColumnCount).map{|i| metadata.getColumnLabel(i)}
+        end
+
+        def fetch
+          if @raw_result_set.next
+            row_values = []
+            column_types.each_with_index do |column_type, i|
+              row_values << Result.java_to_ruby_value(@raw_result_set.getObject(i+1), column_type)
+            end
+            row_values
+          else
+            @raw_result_set.close
+            nil
+          end
+        end
+
+        def rows
+          @rows ||= begin
+            rows_values = []
+            while row_values = fetch
+              rows_values << row_values
+            end
+            rows_values
+          end
+        end
+
+        private
+
+        def metadata
+          @metadata ||= @raw_result_set.getMetaData
+        end
+
+        # modified RolapCell drillThroughInternal method
+        def self.drill_through_internal(rolap_cell, params)
+          max_rows = params[:max_rows] || -1
+
+          result_field = rolap_cell.java_class.declared_field('result')
+          result_field.accessible = true
+          result = result_field.value(rolap_cell)
+
+          sql = generate_drill_through_sql(rolap_cell, result, params)
+
+          # Choose the appropriate scrollability. If we need to start from an
+          # offset row, it is useful that the cursor is scrollable, but not
+          # essential.
+          statement = result.getExecution.getMondrianStatement
+          execution = Java::MondrianServer::Execution.new(statement, 0)
+          connection = statement.getMondrianConnection
+          result_set_type = Java::JavaSql::ResultSet::TYPE_FORWARD_ONLY
+          result_set_concurrency = Java::JavaSql::ResultSet::CONCUR_READ_ONLY
+          schema = statement.getSchema
+          dialect = schema.getDialect
+
+          Java::MondrianRolap::RolapUtil.executeQuery(
+            connection.getDataSource,
+            sql,
+            nil,
+            max_rows,
+            -1, # firstRowOrdinal
+            Java::MondrianRolap::SqlStatement::StatementLocus.new(
+              execution,
+              "RolapCell.drillThrough",
+              "Error in drill through",
+              Java::MondrianServerMonitor::SqlStatementEvent::Purpose::DRILL_THROUGH, 0
+            ),
+            result_set_type,
+            result_set_concurrency,
+            nil
+          )
+        end
+
+        def self.generate_drill_through_sql(rolap_cell, result, params)
+          return_field_names, return_expressions, nonempty_columns = parse_return_fields(result, params)
+
+          sql_non_extended = rolap_cell.getDrillThroughSQL(return_expressions, false)
+          sql_extended = rolap_cell.getDrillThroughSQL(return_expressions, true)
+
+          if sql_non_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+            non_extended_from = $2
+            non_extended_where = $3
+          else
+            raise ArgumentError, "cannot parse drill through SQL: #{sql_non_extended}"
+          end
+
+          if sql_extended =~ /\Aselect (.*) from (.*) where (.*) order by (.*)\Z/
+            extended_select = $1
+            extended_from = $2
+            extended_where = $3
+            extended_order_by = $4
+          # if only measures are selected then there will be no order by
+          elsif sql_extended =~ /\Aselect (.*) from (.*) where (.*)\Z/
+            extended_select = $1
+            extended_from = $2
+            extended_where = $3
+            extended_order_by = ''
+          else
+            raise ArgumentError, "cannot parse drill through SQL: #{sql_extended}"
+          end
+
+          return_column_positions = {}
+
+          if return_field_names && !return_field_names.empty?
+            new_select = extended_select.split(/,\s*/).map do |part|
+              column_name, column_alias = part.split(' as ')
+              field_name = column_alias[1..-2].gsub(' (Key)', '')
+              position = return_field_names.index(field_name) || 9999
+              return_column_positions[column_name] = position
+              [part, position]
+            end.sort_by(&:last).map(&:first).join(', ')
+
+            new_order_by = extended_order_by.split(/,\s*/).map do |part|
+              column_name, asc_desc = part.split(/\s+/)
+              position = return_column_positions[column_name] || 9999
+              [part, position]
+            end.sort_by(&:last).map(&:first).join(', ')
+          else
+            new_select = extended_select
+            new_order_by = extended_order_by
+          end
+
+          new_from_parts = non_extended_from.split(/,\s*/)
+          outer_join_from_parts = extended_from.split(/,\s*/) - new_from_parts
+          where_parts = extended_where.split(' and ')
+
+          # reverse outer_join_from_parts to support dimensions with several table joins
+          # where join with detailed level table should be constructed first
+          outer_join_from_parts.reverse.each do |part|
+            part_elements = part.split(/\s+/)
+            # first is original table, then optional 'as' and the last is alias
+            table_name = part_elements.first
+            table_alias = part_elements.last
+            join_conditions = where_parts.select do |where_part|
+              where_part.include?(" = #{table_alias}.")
+            end
+            outer_join = " left outer join #{part} on (#{join_conditions.join(' and ')})"
+            left_table_alias = join_conditions.first.split('.').first
+
+            if left_table_from_part = new_from_parts.detect{|from_part| from_part.include?(left_table_alias)}
+              left_table_from_part << outer_join
+            else
+              raise ArgumentError, "cannot extract outer join left table #{left_table_alias} in drill through SQL: #{sql_extended}"
+            end
+          end
+
+          new_from = new_from_parts.join(', ')
+
+          new_where = non_extended_where
+          if nonempty_columns && !nonempty_columns.empty?
+            not_null_condition = nonempty_columns.map{|c| "(#{c}) IS NOT NULL"}.join(' OR ')
+            new_where += " AND (#{not_null_condition})"
+          end
+
+          sql = "select #{new_select} from #{new_from} where #{new_where}"
+          sql << " order by #{new_order_by}" unless new_order_by.empty?
+          sql
+        end
+
+        def self.parse_return_fields(result, params)
+          return_field_names = []
+          return_expressions = nil
+          nonempty_columns = []
+
+          if params[:return] || params[:nonempty]
+            rolap_cube = result.getCube
+            schema_reader = rolap_cube.getSchemaReader
+
+            if return_fields = params[:return]
+              return_fields = return_fields.split(/,\s*/) if return_fields.is_a?(String)
+              return_expressions = return_fields.map do |return_field|
+                begin
+                  segment_list = Java::MondrianOlap::Util.parseIdentifier(return_field)
+                  return_field_names << segment_list.to_a.last.name
+                rescue Java::JavaLang::IllegalArgumentException
+                  raise ArgumentError, "invalid return field #{return_field}"
+                end
+
+                level_or_member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
+
+                case level_or_member
+                when Java::MondrianOlap::Level
+                  Java::MondrianMdx::LevelExpr.new level_or_member
+                when Java::MondrianOlap::Member
+                  raise ArgumentError, "cannot use calculated member #{return_field} as return field" if level_or_member.isCalculated
+                  Java::mondrian.mdx.MemberExpr.new level_or_member
+                else
+                  raise ArgumentError, "return field #{return_field} should be level or measure"
+                end
+              end
+            end
+
+            if nonempty_fields = params[:nonempty]
+              nonempty_fields = nonempty_fields.split(/,\s*/) if nonempty_fields.is_a?(String)
+              nonempty_columns = nonempty_fields.map do |nonempty_field|
+                begin
+                  segment_list = Java::MondrianOlap::Util.parseIdentifier(nonempty_field)
+                rescue Java::JavaLang::IllegalArgumentException
+                  raise ArgumentError, "invalid return field #{return_field}"
+                end
+                member = schema_reader.lookupCompound rolap_cube, segment_list, false, 0
+                if member.is_a? Java::MondrianOlap::Member
+                  raise ArgumentError, "cannot use calculated member #{return_field} as nonempty field" if member.isCalculated
+                  sql_query = member.getStarMeasure.getSqlQuery
+                  member.getStarMeasure.generateExprString(sql_query)
+                else
+                  raise ArgumentError, "nonempty field #{return_field} should be measure"
+                end
+              end
+            end
+          end
+
+          [return_field_names, return_expressions, nonempty_columns]
+        end
+
+      end
+
+      def self.java_to_ruby_value(value, column_type = nil)
+        case value
+        when Numeric, String
+          value
+        when Java::JavaMath::BigDecimal
+          BigDecimal(value.to_s)
+        else
+          value
+        end
+      end
+
       private
 
       def axes
@@ -146,10 +438,10 @@ module Mondrian
             recursive_values(value_method, axes_sequence, current_index + 1, cell_params)
           end
         else
-          @raw_cell_set.getCell(cell_params).send(value_method)
+          self.class.java_to_ruby_value(@raw_cell_set.getCell(cell_params).send(value_method))
         end
       end
 
     end
   end
-end
+end

data/lib/mondrian/olap/schema.rb

@@ -5,10 +5,10 @@ module Mondrian
     # See http://mondrian.pentaho.com/documentation/schema.php for more detailed description
     # of Mondrian Schema elements.
     class Schema < SchemaElement
-      def initialize(name = nil, attributes = {}, &block)
+      def initialize(name = nil, attributes = {}, parent = nil, &block)
         name, attributes = self.class.pre_process_arguments(name, attributes)
         pre_process_attributes(attributes)
-        super(name, attributes, &block)
+        super(name, attributes, parent, &block)
       end
 
       def self.define(name = nil, attributes = {}, &block)
@@ -20,10 +20,16 @@ module Mondrian
         name, attributes = self.class.pre_process_arguments(name, attributes)
         pre_process_attributes(attributes)
         @attributes[:name] = name || @attributes[:name] || 'default' # otherwise connection with empty name fails
-        instance_eval &block if block
+        instance_eval(&block) if block
         self
       end
 
+      def include_schema(shared_schema)
+        shared_schema.class.elements.each do |element|
+          instance_variable_get("@#{pluralize(element)}").concat shared_schema.send(pluralize(element))
+        end
+      end
+
       private
 
       def self.pre_process_arguments(name, attributes)
@@ -43,11 +49,11 @@ module Mondrian
 
       public
 
-      attributes :name, :description
-      elements :cube
+      attributes :name, :description, :measures_caption
+      elements :annotations, :dimension, :cube, :virtual_cube, :role, :user_defined_function
 
       class Cube < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # The name of the measure that would be taken as the default measure of the cube.
           :default_measure,
           # Should the Fact table data for this Cube be cached by Mondrian or not.
@@ -55,7 +61,8 @@ module Mondrian
           :cache,
           # Whether element is enabled - if true, then the Cube is realized otherwise it is ignored.
           :enabled
-        elements :table, :view, :dimension, :measure, :calculated_member
+        # always render xml fragment as the first element in XML output (by default it is added at the end)
+        elements :annotations, :xml, :table, :view, :dimension_usage, :dimension, :measure, :calculated_member
       end
 
       class Table < SchemaElement
@@ -70,12 +77,13 @@ module Mondrian
 
       class View < SchemaElement
         attributes :alias
+        data_dictionary_names :alias
         # Defines a "table" using SQL query which can have different variants for different underlying databases
         elements :sql
       end
 
       class Dimension < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # The dimension's type may be one of "Standard" or "Time".
           # A time dimension will allow the use of the MDX time functions (WTD, YTD, QTD, etc.).
           # Use a standard dimension if the dimension is not a time-related dimension.
@@ -85,16 +93,41 @@ module Mondrian
           # Required in a private Dimension or a DimensionUsage, but not in a public Dimension.
           :foreign_key
         data_dictionary_names :foreign_key # values in XML will be uppercased when using Oracle driver
-        elements :hierarchy
+        elements :annotations, :hierarchy
+      end
+
+      class DimensionUsage < SchemaElement
+        attributes :name,
+          # Name of the source dimension. Must be a dimension in this schema. Case-sensitive.
+          :source,
+          # Name of the level to join to. If not specified, joins to the lowest level of the dimension.
+          :level,
+          # If present, then this is prepended to the Dimension column names
+          # during the building of collapse dimension aggregates allowing
+          # 1) different dimension usages to be disambiguated during aggregate table recognition and
+          # 2) multiple shared dimensions that have common column names to be disambiguated.
+          :usage_prefix,
+          # The name of the column in the fact table which joins to the leaf level of this dimension.
+          # Required in a private Dimension or a DimensionUsage, but not in a public Dimension.
+          :foreign_key
+        data_dictionary_names :usage_prefix, :foreign_key # values in XML will be uppercased when using Oracle driver
+
+        def initialize(name = nil, attributes = {}, parent = nil)
+          super
+          # by default specify :source as name
+          @attributes[:source] ||= name
+        end
       end
 
       class Hierarchy < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # Whether this hierarchy has an 'all' member.
           :has_all,
           # Name of the 'all' member. If this attribute is not specified,
           # the all member is named 'All hierarchyName', for example, 'All Store'.
           :all_member_name,
+          # A string being displayed instead as the all member's name
+          :all_member_caption,
           # Name of the 'all' level. If this attribute is not specified,
           # the all member is named '(All)'.
           :all_level_name,
@@ -108,17 +141,25 @@ module Mondrian
           # that all members have entirely unique rows, allowing SQL GROUP BY clauses to be completely eliminated from the query.
           :unique_key_level_name
         data_dictionary_names :primary_key, :primary_key_table # values in XML will be uppercased when using Oracle driver
-        elements :table, :join, :property, :level
+        elements :annotations, :table, :join, :view, :property, :level
+
+        def initialize(name = nil, attributes = {}, parent = nil)
+          super
+          # set :has_all => true if :all_member_name is set
+          if @attributes[:has_all].nil? && @attributes[:all_member_name]
+            @attributes[:has_all] = true
+          end
+        end
       end
 
       class Join < SchemaElement
-        attributes :left_key, :right_key
-        data_dictionary_names :left_key, :right_key # values in XML will be uppercased when using Oracle driver
-        elements :table
+        attributes :left_key, :right_key, :left_alias, :right_alias
+        data_dictionary_names :left_key, :right_key, :left_alias, :right_alias # values in XML will be uppercased when using Oracle driver
+        elements :table, :join
       end
 
       class Level < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # The name of the table that the column comes from.
           # If this hierarchy is based upon just one table, defaults to the name of that table;
           # otherwise, it is required.
@@ -132,6 +173,8 @@ module Mondrian
           :ordinal_column,
           # The name of the column which references the parent member in a parent-child hierarchy.
           :parent_column,
+          # The name of the column which holds the caption for members
+          :caption_column,
           # Value which identifies null parents in a parent-child hierarchy.
           # Typical values are 'NULL' and '0'.
           :null_parent_value,
@@ -140,11 +183,11 @@ module Mondrian
           # When generating SQL statements, Mondrian encloses values for String columns in quotation marks,
           # but leaves values for Integer and Numeric columns un-quoted.
           # Date, Time, and Timestamp values are quoted according to the SQL dialect.
-          # For a SQL-compliant dialect, the values appear prefixed by their typename, 
+          # For a SQL-compliant dialect, the values appear prefixed by their typename,
           # for example, "DATE '2006-06-01'".
           # Default value: 'String'
           :type,
-          # Whether members are unique across all parents. 
+          # Whether members are unique across all parents.
           # For example, zipcodes are unique across all states.
           # The first level's members are always unique.
           # Default value: false
@@ -161,9 +204,20 @@ module Mondrian
           # IfBlankName (a member doesn't appear if its name is null, empty or all whitespace);
           # and IfParentsName (a member appears unless its name matches the parent's.
           # Default value: 'Never'
-          :hide_member_if
-        data_dictionary_names :table, :column, :name_column, :ordinal_column, :parent_column # values in XML will be uppercased when using Oracle driver
-        elements :key_expression, :name_expression, :ordinal_expression, :property
+          :hide_member_if,
+          # The estimated number of members in this level. Setting this property improves the performance of
+          # MDSCHEMA_LEVELS, MDSCHEMA_HIERARCHIES and MDSCHEMA_DIMENSIONS XMLA requests
+          :approx_row_count
+        data_dictionary_names :table, :column, :name_column, :ordinal_column, :parent_column, :caption_column # values in XML will be uppercased when using Oracle driver
+        elements :annotations, :key_expression, :name_expression, :ordinal_expression, :caption_expression, :member_formatter, :property
+
+        def initialize(name = nil, attributes = {}, parent = nil)
+          super
+          # set :unique_members by default to true for first level and false for next levels
+          if @attributes[:unique_members].nil?
+            @attributes[:unique_members] = parent.levels.empty?
+          end
+        end
       end
 
       class KeyExpression < SchemaElement
@@ -178,6 +232,10 @@ module Mondrian
         elements :sql
       end
 
+      class CaptionExpression < SchemaElement
+        elements :sql
+      end
+
       class Sql < SchemaElement
         def self.name
           'SQL'
@@ -187,7 +245,7 @@ module Mondrian
       end
 
       class Property < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           :column,
           # Data type of this property: String, Numeric, Integer, Boolean, Date, Time or Timestamp.
           :type,
@@ -196,10 +254,12 @@ module Mondrian
           # (if the database permits columns in the SELECT that are not in the GROUP BY).
           # This can be a significant performance enhancement on some databases, such as MySQL.
           :depends_on_level_value
+        data_dictionary_names :column
+        elements :property_formatter
       end
 
       class Measure < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # Column which is source of this measure's values.
           # If not specified, a measure expression must be specified.
           :column,
@@ -209,9 +269,17 @@ module Mondrian
           # Aggregation function. Allowed values are "sum", "count", "min", "max", "avg", and "distinct-count".
           :aggregator,
           # Format string with which to format cells of this measure. For more details, see the mondrian.util.Format class.
-          :format_string
+          :format_string,
+          # Whether this member is visible in the user-interface. Default true.
+          :visible
         data_dictionary_names :column # values in XML will be uppercased when using Oracle driver
-        elements :measure_expression
+        elements :annotations, :measure_expression, :cell_formatter
+
+        def initialize(name = nil, attributes = {}, parent = nil)
+          super
+          # by default set aggregator to sum
+          @attributes[:aggregator] ||= 'sum'
+        end
       end
 
       class MeasureExpression < SchemaElement
@@ -219,12 +287,14 @@ module Mondrian
       end
 
       class CalculatedMember < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # Name of the dimension which this member belongs to.
           :dimension,
           # Format string with which to format cells of this measure. For more details, see the mondrian.util.Format class.
-          :format_string
-        elements :formula, :calculated_member_property
+          :format_string,
+          # Whether this member is visible in the user-interface. Default true.
+          :visible
+        elements :annotations, :formula, :calculated_member_property, :cell_formatter
       end
 
       class Formula < SchemaElement
@@ -232,7 +302,7 @@ module Mondrian
       end
 
       class CalculatedMemberProperty < SchemaElement
-        attributes :name, :description,
+        attributes :name, :description, :caption,
           # MDX expression which defines the value of this property. If the expression is a constant string, you could enclose it in quotes,
           # or just specify the 'value' attribute instead.
           :expression,
@@ -240,6 +310,30 @@ module Mondrian
           :value
       end
 
+      class VirtualCube < SchemaElement
+        attributes :name, :description, :caption,
+          # The name of the measure that would be taken as the default measure of the cube.
+          :default_measure,
+          # Whether element is enabled - if true, then the VirtualCube is realized otherwise it is ignored.
+          :enabled
+        elements :annotations, :virtual_cube_dimension, :virtual_cube_measure, :calculated_member
+      end
+
+      class VirtualCubeDimension < SchemaElement
+        attributes :name,
+          # Name of the cube which the dimension belongs to, or unspecified if the dimension is shared
+          :cube_name
+      end
+
+      class VirtualCubeMeasure < SchemaElement
+        attributes :name,
+          # Name of the cube which the measure belongs to.
+          :cube_name,
+          # Whether this member is visible in the user-interface. Default true.
+          :visible
+        elements :annotations
+      end
+
       class AggName < SchemaElement
         attributes :name
         data_dictionary_names :name
@@ -282,6 +376,103 @@ module Mondrian
         data_dictionary_names :name, :pattern
       end
 
+      class Role < SchemaElement
+        attributes :name
+        elements :schema_grant, :union
+      end
+
+      class SchemaGrant < SchemaElement
+        # access may be "all", "all_dimensions", "custom" or "none".
+        # If access is "all_dimensions", the role has access to all dimensions but still needs explicit access to cubes.
+        # If access is "custom", no access will be inherited by cubes for which no explicit rule is set.
+        # If access is "all_dimensions", an implicut access is given to all dimensions of the schema's cubes,
+        # provided the cube's access attribute is either "custom" or "all"
+        attributes :access
+        elements :cube_grant
+      end
+
+      class CubeGrant < SchemaElement
+        # access may be "all", "custom", or "none".
+        # If access is "custom", no access will be inherited by the dimensions of this cube,
+        # unless the parent SchemaGrant is set to "all_dimensions"
+        attributes :access,
+          # The unique name of the cube
+          :cube
+        elements :dimension_grant, :hierarchy_grant
+      end
+
+      class DimensionGrant < SchemaElement
+        # access may be "all", "custom" or "none".
+        # Note that a role is implicitly given access to a dimension when it is given "all" acess to a cube.
+        # If access is "custom", no access will be inherited by the hierarchies of this dimension.
+        # If the parent schema access is "all_dimensions", this timension will inherit access "all".
+        # See also the "all_dimensions" option of the "SchemaGrant" element.
+        attributes :access,
+          # The unique name of the dimension
+          :dimension
+      end
+
+      class HierarchyGrant < SchemaElement
+        # access may be "all", "custom" or "none".
+        # If access is "custom", you may also specify the attributes :top_level, :bottom_level, and the member grants.
+        # If access is "custom", the child levels of this hierarchy will not inherit access rights from this hierarchy,
+        # should there be no explicit rules defined for the said child level.
+        attributes :access,
+          # The unique name of the hierarchy
+          :hierarchy,
+          # Unique name of the highest level of the hierarchy from which this role is allowed to see members.
+          # May only be specified if the HierarchyGrant.access is "custom".
+          # If not specified, role can see members up to the top level.
+          :top_level,
+          # Unique name of the lowest level of the hierarchy from which this role is allowed to see members.
+          # May only be specified if the HierarchyGrant.access is "custom".
+          # If not specified, role can see members down to the leaf level.
+          :bottom_level,
+          # Policy which determines how cell values are calculated if not all of the children of the current cell
+          # are visible to the current role.
+          # Allowable values are "full" (the default), "partial", and "hidden".
+          :rollup_policy
+        elements :member_grant
+      end
+
+      class MemberGrant < SchemaElement
+        # The children of this member inherit that access.
+        # You can implicitly see a member if you can see any of its children.
+        attributes :access,
+          # The unique name of the member
+          :member
+      end
+
+      class Union < SchemaElement
+        elements :role_usage
+      end
+
+      class RoleUsage < SchemaElement
+        attributes :role_name
+      end
+
+      class Annotations < SchemaElement
+        elements :annotation
+        def initialize(name = nil, attributes = {}, parent = nil, &block)
+          if name.is_a?(Hash)
+            attributes = name
+            name = nil
+          end
+          if block_given?
+            super(name, attributes, parent, &block)
+          else
+            super(nil, {}, parent) do
+              attributes.each do |key, value|
+                annotation key.to_s, value.to_s
+              end
+            end
+          end
+        end
+      end
+
+      class Annotation < SchemaElement
+        content :text
+      end
     end
   end
-end
+end