activewarehouse 0.1.0

data/lib/active_warehouse/model/dimension.rb

@@ -0,0 +1,3 @@
+require 'active_warehouse/model/dimension/dimension'
+require 'active_warehouse/model/dimension/hierarchical_dimension'
+require 'active_warehouse/model/dimension/bridge'

data/lib/active_warehouse/model/dimension/bridge.rb

@@ -0,0 +1,32 @@
+module ActiveWarehouse
+  class Bridge < ActiveRecord::Base
+    class << self
+      # Get the table name. By default the table name will be the name of the dimension in singular form.
+      #
+      # Example: DateDimension will have a table called date_dimension
+      def table_name
+        name = self.name.demodulize.underscore
+        set_table_name(name)
+        name
+      end
+    
+      def build_table(force=false)
+        connection.drop_table(table_name) if force and table_exists?
+        if !table_exists?
+          connection.create_table(table_name, :id => false) do |t|
+            t.column :parent_id, :integer
+            t.column :child_id, :integer
+            t.column :levels_from_parent, :integer
+            t.column :bottom_flag, :boolean
+            t.column :top_flag, :boolean
+          end
+          connection.add_index table_name, :parent_id
+          connection.add_index table_name, :child_id
+          connection.add_index table_name, :levels_from_parent
+          connection.add_index table_name, :bottom_flag
+          connection.add_index table_name, :top_flag
+        end
+      end
+    end
+  end
+end

data/lib/active_warehouse/model/dimension/dimension.rb

@@ -0,0 +1,152 @@
+module ActiveWarehouse
+  class Dimension < ActiveRecord::Base
+    class << self
+      
+      # Indicate that this dimension is a variable depth hierarchical dimension. Calling this method will
+      # mix-in the ActiveWarehouse::HierarchicalDimension module, adding methods to support the hierarchical
+      # representation of this dimension
+      def acts_as_hierarchy_dimension
+        # Mix in the hierarchy dimension support code
+        include ActiveWarehouse::HierarchicalDimension
+      end
+      
+      # Define a named attribute hierarchy in the dimension.
+      # 
+      # Example: define_hierarchy(:fiscal_calendar, [:fiscal_year, :fiscal_quarter, :fiscal_month])
+      # 
+      # This would indicate that one of the drill down paths for this dimension is:
+      # Fiscal Year -> Fiscal Quarter -> Fiscal Month
+      #
+      # Internally the hierarchies are stored in order. The first hierarchy defined will be used as the default
+      # if no hierarchy is specified when rendering a cube.
+      def define_hierarchy(name, levels)
+        hierarchies << name
+        hierarchy_levels[name] = levels
+      end
+      
+      # Get the named attribute hierarchy
+      # 
+      # Example: hierarchy(:fiscal_calendar) might return [:fiscal_year, :fiscal_quarter, :fiscal_month]
+      def hierarchy(name)
+        hierarchy_levels[name]
+      end
+      
+      # Get the ordered hierarchy names
+      def hierarchies
+        @hierarchies ||= []
+      end
+      
+      # Get the hierarchy levels hash
+      def hierarchy_levels
+        @hierarchy_levels ||= {}
+      end
+      
+      # Return a symbol used when referring to this dimension. The symbol is calculated by demodulizing and underscoring the
+      # dimension's class name and then removing the trailing _dimension.
+      # 
+      # Example: DateDimension will return a symbol :date
+      def sym
+        self.name.demodulize.underscore.gsub(/_dimension/, '').to_sym
+      end
+      
+      # Get the table name. By default the table name will be the name of the dimension in singular form.
+      #
+      # Example: DateDimension will have a table called date_dimension
+      def table_name
+        name = self.name.demodulize.underscore
+        set_table_name(name)
+        name
+      end
+      
+      # Convert the given name into a dimension class name
+      def class_name(name)
+        dimension_name = name.to_s
+        dimension_name = "#{dimension_name}_dimension" unless dimension_name =~ /_dimension$/
+        dimension_name.classify
+      end
+      
+      # Get a class for the specified named dimension
+      def class_for_name(name)
+        class_name(name).constantize
+      end
+      
+      # Return the time when the underlying dimension source file was last modified. This is used
+      # to determine if a cube structure rebuild is required
+      def last_modified
+        File.new(__FILE__).mtime
+      end
+      
+      # Get the dimension class for the specified dimension parameter. The dimension parameter may be a class,
+      # String or Symbol.
+      def to_dimension(dimension)
+        return dimension if dimension.is_a?(Class) and dimension.superclass == Dimension
+        return class_for_name(dimension)
+      end
+      
+      # Returns a hash of all of the values at the specified hierarchy level mapped to the count at that level.
+      # For example, given a date dimension with years from 2002 to 2004 and a hierarchy defined with:
+      # 
+      #  hierarchy :cy, [:calendar_year, :calendar_quarter, :calendar_month_name] 
+      #
+      # ...then...
+      #
+      #  DateDimension.denominator_count(:cy, :calendar_year, :calendar_quarter) returns {'2002' => 4, '2003' => 4, '2004' => 4}
+      # 
+      # If the denominator_level parameter is omitted or nil then:
+      #
+      #  DateDimension.denominator_count(:cy, :calendar_year) returns {'2003' => 365, '2003' => 365, '2004' => 366}
+      #
+      def denominator_count(hierarchy_name, level, denominator_level=nil)
+        if hierarchy_levels[hierarchy_name].nil?
+          raise ArgumentError, "The hierarchy '#{hierarchy_name}' does not exist in your dimension #{name}"
+        end
+        
+        q = nil
+        # If the denominator_level is specified and it is not the last element in the hierarchy then do a distinct count. If
+        # the denominator level is less than the current level then raise an ArgumentError. In other words, if the current level is
+        # calendar month then passing in calendar year as the denominator level would raise an ArgumentErro.
+        #
+        # If the denominator_level is not specified then assume the finest grain possible (in the context of a date dimension
+        # this would be each day) and use the id to count.
+        if denominator_level && hierarchy_levels[hierarchy_name].last != denominator_level
+          level_index = hierarchy_levels[hierarchy_name].index(level)
+          denominator_index = hierarchy_levels[hierarchy_name].index(denominator_level)
+
+          if level_index.nil?
+            raise ArgumentError, "The level '#{level}' does not appear to exist"
+          end
+          if denominator_index.nil?
+            raise ArgumentError, "The denominator level '#{denominator_level}' does not appear to exist"
+          end
+          if hierarchy_levels[hierarchy_name].index(denominator_level) < hierarchy_levels[hierarchy_name].index(level)
+            raise ArgumentError, "The index of the denominator level '#{denominator_level}' in the hierarchy '#{hierarchy_name}' must be greater than or equal to the level '#{level}'"
+          end
+
+          q = "select #{level}, count(distinct(#{denominator_level})) from #{table_name} group by #{level}"
+        else
+          q = "select #{level}, count(id) from #{table_name} group by #{level}"
+        end
+        denominators = {}
+        connection.execute(q).each do |row|
+          denominators[row[0]] = row[1].to_i
+        end
+        denominators
+      end
+      
+      # Get the foreign key for this dimension which is used in Fact tables.
+      # 
+      # Example: DateDimension would have a foreign key of date_id
+      def foreign_key
+        table_name.sub(/_dimension/,'') + '_id'
+      end
+      
+      # Get an array of the available values for a particular hierarchy level
+      # For example, given a DateDimension with data from 2002 to 2004:
+      #
+      #  available_values('calendar_year') returns ['2002','2003','2004']
+      def available_values(level)
+        find(:all, :group => level.to_s, :order => level.to_s).collect {|dim| dim.send(level.to_sym)}
+      end
+    end
+  end
+end

data/lib/active_warehouse/model/dimension/hierarchical_dimension.rb

@@ -0,0 +1,35 @@
+module ActiveWarehouse
+  module HierarchicalDimension
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods
+      # Get the bridge class for this hierarchical dimension
+      def bridge_class
+        unless @bridge_class
+          @bridge_class = Class.new(ActiveWarehouse::Bridge)
+          Object.const_set(bridge_class_name, @bridge_class)
+        end
+        @bridge_class
+      end
+      
+      # Get the bridge class name for this hierarchical dimension
+      def bridge_class_name
+        name.gsub(/Dimension$/, '') + 'HierarchyBridge'
+      end
+    end
+    
+    # Get the parent for this node
+    def parent
+      bridge = bridge_class.new
+      bridge.find(:first, :conditions => ['levels_from_parent = 1 and child_id = ?', self.id])
+    end
+    
+    # Get the children for this node
+    def children
+      bridge = bridge_class.new
+      bridge.find(:all, :conditions => ['levels_from_parent = 1 and parent_id = ?', self.id])
+    end
+  end
+end

data/lib/active_warehouse/model/fact.rb

@@ -0,0 +1,96 @@
+module ActiveWarehouse
+  class Fact < ActiveRecord::Base
+    
+    class << self
+      attr_accessor :aggregate_fields, :aggregate_field_options, :calculated_fields, :calculated_field_options
+      
+      # Return a list of dimensions for this fact. 
+      #
+      # Example:
+      #
+      # sales_fact
+      #  time_id
+      #  region_id
+      #  sales_amount
+      #  number_items_sold
+      # 
+      # Calling SalesFact.dimensions would return the list: ['time','region']
+      def dimensions
+        dims = []
+        columns.each do |column|
+          if column.name =~ /(.*)_id/
+            dims << $1.to_sym
+          end
+        end
+        dims
+      end
+      
+      # Get the time when the fact source file was last modified
+      def last_modified
+        File.new(__FILE__).mtime
+      end
+      
+      # Get the table name. The fact table name is pluralized
+      def table_name
+        name = self.name.demodulize.underscore.pluralize
+        set_table_name(name)
+        name
+      end
+      
+      # Get the class name for the specified fact name
+      def class_name(name)
+        fact_name = name.to_s
+        fact_name = "#{fact_name}_facts" unless fact_name =~ /_fact[s?]$/
+        fact_name.classify
+      end
+      
+      # Get the class for the specified fact name
+      def class_for_name(name)
+        class_name(name).constantize
+      end
+      
+      # Define an aggregate. Also aliased from aggregate()
+      # * <tt>field</tt>: The field name
+      # * <tt>options</tt>: A hash of options for the aggregate
+      def define_aggregate(field, options={})
+        aggregate_fields << field
+        options[:type] ||= :sum
+        aggregate_field_options[field] = options
+      end
+      alias :aggregate :define_aggregate
+      
+      # Define a calculated field
+      # * <tt>field</tt>: The field name
+      # * <tt>options</tt>: An options hash
+      # 
+      # This method takes a block which will be passed the current aggregate record.
+      #
+      # Example: calculated_field (:gross_margin) { |r| r.gross_profit_dollar_amount / r.sales_dollar_amount}
+      def calculated_field(field, options={}, &block)
+        calculated_fields << field
+        options[:block] = block
+        calculated_field_options[field] = options
+      end
+      
+      # Get a list of all calculated fields
+      def calculated_fields
+        @calculated_field ||= []
+      end
+      
+      # Get a hash of all calculated field options
+      def calculated_field_options
+        @calculated_field_options ||= {}
+      end
+      
+      # Get a list of all aggregate fields
+      def aggregate_fields
+        @aggregate_fields ||= []
+      end
+      
+      # Get a hash of all aggregate field options
+      def aggregate_field_options
+        @aggregate_field_options ||= {}
+      end
+    end
+  end
+end

data/lib/active_warehouse/model/report.rb

@@ -0,0 +1,3 @@
+require 'active_warehouse/model/report/abstract_report'
+require 'active_warehouse/model/report/table_report'
+require 'active_warehouse/model/report/chart_report'

data/lib/active_warehouse/model/report/abstract_report.rb

@@ -0,0 +1,121 @@
+module ActiveWarehouse
+  module Report
+    module AbstractReport
+      
+      attr_accessor :pass_params
+
+      # Set the cube name
+      def cube_name=(name)
+        self['cube_name'] = name
+        @cube = nil
+      end
+
+      # Get the current cube instance
+      def cube
+        if @cube.nil?
+          cube_class = ActiveWarehouse::Cube.class_name(self.cube_name).constantize
+          @cube = cube_class.new
+        end
+        @cube
+      end
+      
+      # Get the fact class
+      def fact_class
+        cube.class.fact_class
+      end
+
+      # Get the column dimension class
+      def column_dimension_class
+        @column_dimension_class ||= ActiveWarehouse::Dimension.class_name(self.column_dimension_name).constantize
+      end
+
+      def column_hierarchy
+        self['column_hierarchy'] || column_dimension_class.hierarchies.first
+      end
+      
+      def column_param_prefix
+        self['column_param_prefix'] || 'c'
+      end
+
+      # Get the row dimension class
+      def row_dimension_class
+        @row_dimension_class ||= ActiveWarehouse::Dimension.class_name(self.row_dimension_name).constantize
+      end
+      
+      def row_hierarchy
+        self['row_hierarchy'] || row_dimension_class.hierarchies.first
+      end
+      
+      def row_param_prefix
+        self['row_param_prefix'] || 'r'
+      end
+      
+      # Get the list of displayed fact attributes. If this value is not specified then all aggregate and calculated
+      # fields will be displayed
+      def fact_attributes
+        return self['fact_attributes'] if self['fact_attributes']
+        fa = []
+        fact_class.aggregate_fields.each do |name|
+          fa << name
+        end
+        fact_class.calculated_fields.each do |name|
+          fa << name
+        end
+        fa
+      end
+      
+      def pass_params
+        @pass_params ||= []
+      end
+      
+      protected
+      # Callback which is invoked on each object returned from a call to the object's find method.
+      def after_find
+        from_storage
+      end
+      
+      # Converts values for all columns which can store symbol values into strings. This is used to store 
+      # the data in the database as a string rather than a YAML representation
+      def to_storage
+        symbol_attributes.each do |name|
+          self[name] = self[name].to_s if self[name]
+        end
+        list_attributes.each do |name|
+          self[name] = self[name].join(',') if self[name]
+        end
+        symbolized_list_attributes.each do |name|
+          self[name] = self[name].join(',') if self[name]
+        end
+      end
+      
+      # Converts values for all columns which store strings in the database to symbols.
+      def from_storage
+        symbol_attributes.each do |name|
+          self[name] = self[name].to_sym if self[name]
+        end
+        list_attributes.each do |name|
+          self[name] = self[name].split(/,/) if self[name]
+        end
+        symbolized_list_attributes.each do |name|
+          self[name] = self[name].split(/,/).collect { |v| v.to_sym } if self[name]
+        end
+      end
+      
+      # Attributes which should contain a symbol
+      def symbol_attributes
+        %w(cube_name column_dimension_name column_hierarchy row_dimension_name row_hierarchy)
+      end
+      
+      # Attributes which should contain a list of strings
+      def list_attributes
+        %w(column_constraints row_constraints)
+      end
+      
+      # Attributes which should contain a list of symbols
+      def symbolized_list_attributes
+        %w(fact_attributes)
+      end
+      
+    end
+  end
+end