activewarehouse 0.2.0 → 0.3.0

data/lib/active_warehouse/aggregate_field.rb

@@ -0,0 +1,49 @@
+module ActiveWarehouse
+  # Encapsulates a fact column in a fact table.  These fields
+  # represent columns that should be aggregated.
+  class AggregateField < Field
+  
+    attr_reader :strategy_name
+    
+    # +fact_class+ is the class of the fact table this field is found in.
+    # +column_definition+ is the ActiveRecord ColumnDefinition instance for this
+    # column.
+    # +strategy_name+ is the name of th aggregation strategy to be used, defaults to :sum
+    # +field_options+ is a hash of raw options from the original aggregate definition.
+    def initialize(fact_class, column_definition, strategy_name = :sum, field_options = {})
+      super(fact_class, column_definition.name, column_definition.type, field_options)
+      @column_definition = column_definition
+      @limit = column_definition.limit
+      @scale = column_definition.scale
+      @precision = column_definition.precision
+      @strategy_name = strategy_name
+    end
+    
+    # delegates to owning_class, returns the Fact that has this field
+    def fact_class
+      owning_class
+    end
+    
+    def is_semiadditive?
+      !field_options[:semiadditive].nil?
+    end
+    
+    # returns the Dimension that this semiadditive fact is over
+    def semiadditive_over
+      Dimension.to_dimension(field_options[:semiadditive])
+    end
+    
+    # overrides Field.label, prepending the aggregation strategy name to label
+    def label
+      @label ? @label : "#{super}_#{strategy_name}"
+    end
+    
+    def levels_from_parent
+      field_options[:levels_from_parent].nil? ? [] : field_options[:levels_from_parent]
+    end
+    
+    def type_cast(value)
+      @column_definition.type_cast(value)
+    end
+  end
+end

data/lib/active_warehouse/{dimension/bridge.rb → bridge.rb}

@@ -2,9 +2,11 @@ module ActiveWarehouse #:nodoc
   # Implements a bridge table.
   class Bridge < ActiveRecord::Base
     class << self
-      # Get the table name. By default the table name will be the name of the bridge in singular form.
+      # Get the table name. By default the table name will be the name of the
+      # bridge in singular form.
       #
-      # Example: DepartmentHierarchyBridge will have a table called department_hierarchy_bridge
+      # Example: DepartmentHierarchyBridge will have a table called
+      # department_hierarchy_bridge
       def table_name
         name = self.name.demodulize.underscore
         set_table_name(name)
@@ -12,4 +14,6 @@ module ActiveWarehouse #:nodoc
       end
     end
   end
-end
+end
+
+require 'active_warehouse/bridge/hierarchy_bridge'

data/lib/active_warehouse/bridge/hierarchy_bridge.rb

@@ -0,0 +1,46 @@
+module ActiveWarehouse #:nodoc:
+  # Bridge class that models ragged hierarchies.
+  class HierarchyBridge < Bridge
+    class << self
+      def set_levels_from_parent(name)
+        @levels_from_parent = name
+      end
+     
+      def levels_from_parent
+        @levels_from_parent ||= "levels_from_parent"
+      end
+     
+      def set_effective_date(name)
+        @effective_date = name
+      end
+     
+      def effective_date
+        @effective_date ||= "effective_date"
+      end
+     
+      def set_expiration_date(name)
+        @expiration_date = name
+      end
+     
+      def expiration_date
+        @expiration_date ||= "expiration_date"
+      end
+     
+      def set_top_flag(name)
+        @top_flag = name
+      end
+     
+      def top_flag
+        @top_flag ||= "top_flag"
+      end
+     
+      def set_top_flag_value(value)
+        @top_flag_value = value
+      end
+     
+      def top_flag_value
+        @top_flag_value ||= 'Y'
+      end 
+    end
+  end
+end

data/lib/active_warehouse/builder.rb

@@ -1,2 +1,3 @@
 require 'active_warehouse/builder/date_dimension_builder'
-require 'active_warehouse/builder/random_data_builder'
+require 'active_warehouse/builder/random_data_builder'
+require 'active_warehouse/builder/test_data_builder'

data/lib/active_warehouse/builder/date_dimension_builder.rb

@@ -30,8 +30,8 @@ module ActiveWarehouse #:nodoc:
       # accessed by name.
       def build(options={})
         records = []
-        date = start_date
-        while date <= end_date
+        date = start_date.to_time
+        while date <= end_date.to_time
           record = {}
           record[:date] = date.strftime("%m/%d/%Y")
           record[:full_date_description] = date.strftime("%B %d,%Y")
@@ -52,6 +52,7 @@ module ActiveWarehouse #:nodoc:
           record[:calendar_month_number_in_year] = date.month
           record[:calendar_year_month] = date.strftime("%Y-%m")
           record[:calendar_quarter] = "Q#{date.quarter}"
+          record[:calendar_quarter_number_in_year] = date.quarter
           record[:calendar_year_quarter] = "#{date.strftime('%Y')}-#{record[:calendar_quarter]}"
           #record[:calendar_half_year] = 
           record[:calendar_year] = "#{date.year}"
@@ -62,8 +63,10 @@ module ActiveWarehouse #:nodoc:
           record[:fiscal_year_month] = "FY#{date.fiscal_year}-" + date.fiscal_year_month.to_s.rjust(2, '0')
           record[:fiscal_quarter] = "FY Q#{date.fiscal_year_quarter}"
           record[:fiscal_year_quarter] = "FY#{date.fiscal_year}-Q#{date.fiscal_year_quarter}"
+          record[:fiscal_year_quarter_number] = date.fiscal_year_quarter
           #record[:fiscal_half_year] = 
           record[:fiscal_year] = "FY#{date.fiscal_year}"
+          record[:fiscal_year_number] = date.fiscal_year
           record[:holiday_indicator] = holiday_indicators.include?(date) ? 'Holiday' : 'Nonholiday'
           record[:weekday_indicator] = weekday_indicators[date.wday]
           record[:selling_season] = 'None'

data/lib/active_warehouse/builder/generator/generator.rb

@@ -0,0 +1,13 @@
+module ActiveWarehouse
+  module Builder
+    module Generator
+      # Base class for generators
+      class Generator
+        # Get the next value from the generator.
+        def next(options={})
+          raise "Abstract method"
+        end
+      end
+    end
+  end
+end

data/lib/active_warehouse/builder/generator/name_generator.rb

@@ -0,0 +1,20 @@
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    module Generator #:nodoc:
+      # Generate a name consisting of one or more words from word groups
+      class NameGenerator < ActiveWarehouse::Builder::Generator::Generator
+        def next(options={})
+          options[:separator] ||= ' '
+          parts = []
+          word_groups = options[:word_groups]
+          0.upto(word_groups.first.length) do |i|
+            word_groups.each do |word_group|
+              parts << word_group[i]
+            end
+          end
+          parts.join(options[:separator])
+        end
+      end
+    end
+  end
+end

data/lib/active_warehouse/builder/generator/paragraph_generator.rb

@@ -0,0 +1,11 @@
+module ActiveWarehouse
+  module Builder
+    module Generator
+      class ParagraphGenerator < ActiveWarehouse::Builder::Generator::Generator
+        def next(options={})
+          
+        end
+      end
+    end
+  end
+end

data/lib/active_warehouse/builder/random_data_builder.rb

@@ -8,6 +8,7 @@ module ActiveWarehouse #:nodoc:
       # Hash of names mapped to generators where the name is the column name
       attr_reader :column_generators
       
+      # Initialize the random data builder
       def initialize
         @generators = {
           Fixnum => FixnumGenerator.new,
@@ -20,6 +21,9 @@ module ActiveWarehouse #:nodoc:
         @column_generators = {}
       end
       
+      # Build the data for the specified class. Name may be a Class (which must descend from ActiveWarehouse::Dimension
+      # or ActiveWarehouse::Fact), a String or a Symbol. String or Symbol will be converted to a class name and then 
+      # passed back to this method.
       def build(name, options={})
         case name
         when Class
@@ -44,6 +48,7 @@ module ActiveWarehouse #:nodoc:
       # Build test dimension data for the specified dimension name.
       #
       # Options:
+      #
       # * <tt>:rows</tt>: The number of rows to create (defaults to 100)
       # * <tt>:generators</tt>: A map of generators where each key is Fixnum, Float, Date, Time, String, or Object and the
       #   value is extends from AbstractGenerator. 
@@ -57,6 +62,9 @@ module ActiveWarehouse #:nodoc:
           row = {}
           dimension_class.content_columns.each do |column|
             generator = (options[:generators][column.klass] || @column_generators[column.name] || @generators[column.klass])
+            if generator.nil?
+              raise ArgumentError, "No generator found, unknown column type?: #{column.klass}"
+            end
             row[column.name] = generator.generate(column, options)
           end
           rows << row
@@ -74,6 +82,7 @@ module ActiveWarehouse #:nodoc:
       # * <tt>:fk_limit</tt>: A Hash of foreign key limits, where each key is the name of column and the value is 
       #   a number. For example options[:fk_limit][:date_id] = 1000 would limit the foreign key values to something between
       #   1 and 1000, inclusive.
+      # * <tt>:dimensions</tt>: The number of available dimension FKs
       def build_fact(name, options={})
         options[:rows] ||= 100
         options[:generators] ||= {}
@@ -87,9 +96,10 @@ module ActiveWarehouse #:nodoc:
             generator = (options[:generators][column.klass] || @generators[column.klass])
             row[column.name] = generator.generate(column, options)
           end
-          fact_class.foreign_key_columns.each do |column|
-            fk_limit = (options[:fk_limit][column.name] || 100) - 1
-            row[column.name] = rand(fk_limit) + 1
+          fact_class.dimension_relationships.each do |name, reflection|
+            # it would be better to get a count of rows from the dimension tables
+            fk_limit = (options[:fk_limit][reflection.primary_key_name] || options[:dimensions] || 100) - 1
+            row[reflection.primary_key_name] = rand(fk_limit) + 1
           end
           rows << row
         end
@@ -112,8 +122,8 @@ module ActiveWarehouse #:nodoc:
       # Generate a random date value
       #
       # Options:
-      # *<tt>:start_date</tt>: The start date as a Date or Time object (default 1 year ago)
-      # *<tt>:end_date</tt>: The end date as a Date or Time object (default now)
+      # * <tt>:start_date</tt>: The start date as a Date or Time object (default 1 year ago)
+      # * <tt>:end_date</tt>: The end date as a Date or Time object (default now)
       def generate(column, options={})
         end_date = (options[:end_date] || Time.now).to_date
         start_date = (options[:start_date] || 1.year.ago).to_date
@@ -125,8 +135,8 @@ module ActiveWarehouse #:nodoc:
     # Basic Time generator
     #
     # Options:
-    # *<tt>:start_date</tt>: The start date as a Date or Time object (default 1 year ago)
-    # *<tt>:end_date</tt>: The end date as a Date or Time object (default now)
+    # * <tt>:start_date</tt>: The start date as a Date or Time object (default 1 year ago)
+    # * <tt>:end_date</tt>: The end date as a Date or Time object (default now)
     class TimeGenerator < DateGenerator #:nodoc:
       # Generate a random Time value
       def generate(column, options={})
@@ -139,8 +149,8 @@ module ActiveWarehouse #:nodoc:
       # Generate an integer from 0 to options[:max] inclusive
       #
       # Options:
-      # *<tt>:max</tt>: The maximum allowed value (default 1000)
-      # *<tt>:min</tt>: The minimum allowed value (default 0)
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
+      # * <tt>:min</tt>: The minimum allowed value (default 0)
       def generate(column, options={})
         options[:max] ||= 1000
         options[:min] ||= 0
@@ -153,7 +163,7 @@ module ActiveWarehouse #:nodoc:
       # Generate a float from 0 to options[:max] inclusive (default 1000)
       #
       # Options:
-      # *<tt>:max</tt>: The maximum allowed value (default 1000)
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
       def generate(column, options={})
         options[:max] ||= 1000
         rand * options[:max].to_f
@@ -165,7 +175,7 @@ module ActiveWarehouse #:nodoc:
       # Generate a big decimal from 0 to options[:max] inclusive (default 1000)
       #
       # Options:
-      # *<tt>:max</tt>: The maximum allowed value (default 1000)
+      # * <tt>:max</tt>: The maximum allowed value (default 1000)
       def generate(column, options={})
         options[:max] ||= 1000
         BigDecimal.new((rand * options[:max].to_f).to_s) # TODO: need BigDecimal type?

data/lib/active_warehouse/builder/test_data_builder.rb

@@ -0,0 +1,54 @@
+Dir[File.dirname(__FILE__) + "/generator/*.rb"].each { |file| require(file) }
+
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    # Unlike the RandomDataBuilder, which puts truly random data in the warehouse, this 
+    # generator uses collections of possible values to construct semi-understandable data
+    class TestDataBuilder
+      def initialize
+        
+      end
+      
+      # Usage: 
+      #
+      #   fields = [:id,:product_name,:product_description,:suggested_retail_price]
+      #   field_definitions = {
+      #     :id => :sequence,                                                  # symbol or string
+      #     :product_name => [['Foo','Bar']['Baz','Bing']],                    # array
+      #     :product_description => IpsumLorumGenerator                        # class
+      #     :suggested_retail_price => RandomNumberGenerator.new(0.00, 100.00) # generator instance
+      #   }
+      def build(fields, field_definitions, options={})
+        options[:number] ||= 100
+        rows = []
+        generators = {}
+        # set up all of the generators first
+        field_definitions.each do |name, fd|
+          case fd
+          when Class
+            generators[name] = fd.new
+          when String, Symbol
+            generators[name] = "#{fd}Generator".classify.constantize.new
+          when Array
+            generators[name] = NameGenerator.new(fd)
+          when Generator
+            generators[name] = fd
+          else
+            raise "Invalid generator specified: #{fd}"
+          end
+        end
+        
+        # generate all of the rows
+        0.upto(options[:number]) do
+          row = {}
+          fields.each do |field|
+            row[field] = generators[field].next(options)
+          end
+          rows << row
+        end
+        
+        rows
+      end
+    end
+  end
+end

data/lib/active_warehouse/calculated_field.rb

@@ -0,0 +1,27 @@
+module ActiveWarehouse #:nodoc:
+  # A field that uses a Proc to calculate the value 
+  class CalculatedField < Field
+    attr_reader :block
+    # Initialize the calculated field
+    #
+    # +fact_class+ is the fact class that the field is calculated in
+    # +name+ is the name of the calculated field
+    # +type+ is the type of the calculated field (defaults to :integer)
+    # +field_options+ is a Hash of options for the field
+    # 
+    # This method accepts a block which should take a single argument that is the record
+    # itself.
+    def initialize(fact_class, name, type = :integer, field_options = {}, &block)
+      unless block_given?
+        raise ArgumentError, "A block is required for the calculated field #{name} in #{fact_class}"
+      end
+      super(fact_class, name.to_s, type, field_options)
+      @block = block
+    end
+    
+    # Calculate the field value using the Hash of type-casted values
+    def calculate(values)
+      @block.call(values)
+    end
+  end
+end

data/lib/active_warehouse/compat/compat.rb

@@ -1,7 +1,7 @@
 # Provides 1.1.6 compatibility
-module ActiveRecord
-  module Calculations
-    module ClassMethods
+module ActiveRecord #:nodoc:
+  module Calculations #:nodoc:
+    module ClassMethods #:nodoc:
       protected
       def construct_count_options_from_legacy_args(*args)
         options     = {}
@@ -37,7 +37,7 @@ module ActiveRecord
   end
 end
 
-class Module
+class Module #:nodoc:
   def alias_method_chain(target, feature)
     # Strip out punctuation on predicates or bang methods since
     # e.g. target?_without_feature is not a valid method name.

data/lib/active_warehouse/cube.rb

@@ -1,8 +1,12 @@
 module ActiveWarehouse
-  # A Cube represents a collection of dimensions operating on a fact. The Cube provides a front-end for getting at the
-  # underlying data. The Cube manages the creation and population of all underlying aggregates.
+  # A Cube represents a collection of dimensions operating on a fact. The Cube
+  # provides a front-end for getting at the
+  # underlying data. Cubes support pluggable aggregation. The default aggregation
+  # is the NoAggregate which goes directly
+  # to the fact and dimensions to answer queries.
   class Cube
     class << self
+      
       # Callback which is invoked when subclasses are created
       def inherited(subclass)
         subclasses << subclass
@@ -13,54 +17,82 @@ module ActiveWarehouse
         @subclasses ||= []
       end
       
-      # Defines the dimensions that this cube pivots on.
+      # Defines the dimensions that this cube pivots on. If the fact name and
+      # cube name are different (for example, if a PurchaseCube does not report
+      # on a PurchaseFact) then you *must* declare the <code>reports_on</code>
+      # first.
       def pivots_on(*dimension_list)
-        # TODO: Validate if the fact is set
+        @dimensions_hierarchies = OrderedHash.new
+        @dimensions = []
         dimension_list.each do |dimension|
-          dimensions << dimension
+          case dimension
+          when Symbol, String
+            dimensions << dimension.to_sym
+            dimensions_hierarchies[dimension.to_sym] = fact_class.dimension_class(dimension).hierarchies
+          when Hash
+            dimension_name = dimension.keys.first.to_sym
+            dimensions << dimension_name
+            dimensions_hierarchies[dimension_name] = [dimension[dimension_name]].flatten
+          else
+            raise ArgumentError, "Each argument to pivot_on must be a symbol, string or Hash"
+          end
         end
       end
       alias :pivot_on :pivots_on
       
-      # Defines the fact that this cube reports on
-      def reports_on(fact)
-        # TODO: Validate if one or more dimension is set
-        @fact = fact
+      # Defines the fact name, without the 'Fact' suffix, that this cube
+      # reports on.  For instance, if you have PurchaseFact, you could then
+      # call <code>reports_on :purchase</code>.
+      # 
+      # The default value for reports_on is to take the name of the cube,
+      # i.e. PurchaseCube, and remove the Cube suffix.  The assumption is that
+      # your Cube name matches your Fact name.
+      def reports_on(fact_name)
+        @fact_name = fact_name
       end
       alias :report_on :reports_on
       
-      # Rebuild all aggregate classes. Set :force => true to force the rebuild of aggregate classes.
+      # Rebuild the data warehouse.
       def rebuild(options={})
-        logger.debug "Rebuilding aggregates for cube #{name}"
-        options[:force] ||= false
-        build_aggregate_classes(options)
+        populate(options)
       end
       
-      # Populate all aggregates. Set :force => true to force the population of the aggregate class.
+      # Populate the data warehouse.  Delegate to aggregate.populate
       def populate(options={})
-        options[:force] ||= false
-        aggregates.each do |agg_id, agg_clazz|
-          if agg_clazz.needs_rebuild? || options[:force]
-            logger.debug "Populating aggregate class #{agg_clazz.name}"
-            agg_clazz.populate
-          end
-        end
-      end
-      
-      # Get the fact that this cube reports on
-      def fact
-        @fact
+        aggregate.populate
       end
       
       # Get the dimensions that this cube pivots on
       def dimensions
-        @dimensions ||= []
+        @dimensions ||= fact_class.dimension_relationships.collect{|k,v| k}
       end
       
-      # Get the aggregate classes for this dimension
-      def aggregates
-        rebuild if @aggregates.nil?
-        @aggregates
+      # Get an OrderedHash of each dimension mapped to its hierarchies which 
+      # will be included in the cube
+      def dimensions_hierarchies
+        if @dimensions_hierarchies.nil?
+          @dimensions_hierarchies = OrderedHash.new
+          dimensions.each do |dimension|
+            @dimensions_hierarchies[dimension] = fact_class.dimension_class(dimension).hierarchies
+          end
+        end
+        @dimensions_hierarchies
+      end
+      
+      # returns true if this cube pivots on a hierarchical dimension.
+      def pivot_on_hierarchical_dimension?
+        dimension_classes.each do |dimension|
+          return true if dimension.hierarchical_dimension?
+        end
+        return false
+      end
+      
+      # returns the aggregate fields for this cube
+      # removing the aggregate fields that are defined in fact class that are
+      # related to hierarchical dimension, but the cube doesn't pivot on any
+      # hierarchical dimensions
+      def aggregate_fields
+        fact_class.aggregate_fields.reject {|field| !pivot_on_hierarchical_dimension? and !field.levels_from_parent.empty? } 
       end
       
       # Get the class name for the specified cube name
@@ -73,7 +105,7 @@ module ActiveWarehouse
       
       # Get the aggregated fact class name
       def fact_class_name
-        Fact.class_name(fact)
+        ActiveWarehouse::Fact.class_name(@fact_name || name.sub(/Cube$/,'').underscore.to_sym)
       end
       
       # Get the aggregated fact class instance
@@ -83,221 +115,90 @@ module ActiveWarehouse
       
       # Get a list of dimension class instances
       def dimension_classes
-        dimensions.collect {|dimension| Dimension.class_name(dimension).constantize} 
+        dimensions.collect do |dimension_name|
+          dimension_class(dimension_name)
+        end
+      end
+      
+      # Get the dimension class for the specified dimension name
+      def dimension_class(dimension_name)
+        fact_class.dimension_relationships[dimension_name.to_sym].class_name.constantize      
       end
       
+      # Get the cube logger
       def logger
         @logger ||= Logger.new('cube.log')
       end
       
+      # Get the time when the fact or any dimension referenced in this cube 
+      # was last modified
       def last_modified
-        lm = Fact.class_for_name(fact).last_modified
+        lm = fact_class.last_modified
         dimensions.each do |dimension|
-          dim = Dimension.class_for_name(dimension)
+          dim = ActiveWarehouse::Dimension.class_for_name(dimension)
           lm = dim.last_modified if dim.last_modified > lm
         end
         lm
       end
       
-      protected
-      def build_aggregate_classes(options={})
-        @aggregates = {}
-        existing_dimension_pairs = []
-        logger.debug "Building aggregate classes"
-        dimensions.each do |column_dimension|
-          dimensions.each do |row_dimension|
-            next if column_dimension == row_dimension
-            next if existing_dimension_pairs.include? [column_dimension,row_dimension]
-            next if existing_dimension_pairs.include? [row_dimension,column_dimension]
-            
-            existing_dimension_pairs << [column_dimension,row_dimension]
-            col_dim_class =  Dimension.class_for_name(column_dimension)
-            col_dim_class.hierarchy_levels.each_key do |column_hierarchy_name|
-              row_dim_class = Dimension.class_for_name(row_dimension)
-              row_dim_class.hierarchy_levels.each_key do |row_hierarchy_name|
-                # Construct the aggregate meta data instance
-                meta_data_attributes = {
-                  :cube_name => self.name,
-                  :dimension1 => column_dimension.to_s,
-                  :dimension1_hierarchy => column_hierarchy_name.to_s,
-                  :dimension2 => row_dimension.to_s,
-                  :dimension2_hierarchy => row_hierarchy_name.to_s
-                }
-                conditions = []
-                condition_args = []
-                meta_data_attributes.each do |key, value|
-                  conditions << "#{key} = ?"
-                  condition_args << value
-                end
-                conditions = [conditions.join(' and ')] + condition_args
-                meta_data = AggregateMetaData.find(:first, :conditions => conditions)
-                unless meta_data
-                  meta_data = AggregateMetaData.create(meta_data_attributes)
-                end
-                
-                # Construct the aggregate class instance
-                aggregate_class = Class.new(ActiveWarehouse::Aggregate)
-                aggregate_class.name = "Agg#{meta_data.id}"
-                logger.debug "Constructed aggregate #{aggregate_class.name}"
-                aggregate_class.cube = self
-                aggregate_class.dimension1 = column_dimension
-                aggregate_class.dimension1_hierarchy_name = column_hierarchy_name
-                aggregate_class.dimension2 = row_dimension
-                aggregate_class.dimension2_hierarchy_name = row_hierarchy_name
-            
-                # Create the underlying aggregate storage table
-                # TODO: fix the bug of data not being found when a storage table rebuild occurs
-                force_storage_table_rebuild = options[:force] || aggregate_class.needs_rebuild?(last_modified)
-                logger.debug "Force storage table rebuild? #{force_storage_table_rebuild}"
-                aggregate_class.create_storage_table(force_storage_table_rebuild)
-            
-                # Keep a reference to the aggregate class instance
-                @aggregates[meta_data.id] = aggregate_class
-              end
-            end
-          end
-        end
+      # The temp directory for storing files during warehouse rebuilds
+      attr_accessor :temp_dir
+      def temp_dir
+        @temp_dir ||= '/tmp'
+      end
+      
+      # Specify the ActiveRecord class to connect through
+      # Note: this is a potential directive in a Cube subclass
+      attr_accessor :connect_through
+      def connect_through
+        @connect_through ||= ActiveRecord::Base
+      end
+      
+      # Get an adapter connection
+      def connection
+        connect_through.connection
+      end
+      
+      # Defaults to NoAggregate strategy.
+      def aggregate
+        @aggregate ||= ActiveWarehouse::Aggregate::NoAggregate.new(self)
+      end
+      
+      def aggregate_class(agg_class)
+        @aggregate = agg_class.new(self)
       end
       
     end
     
     public
-    def aggregate_map(column_dimension, column_hierarchy, row_dimension, row_hierarchy, cstage=0, rstage=0)
-      # Fill known cells
-      agg_map = AggregateMap.new
-      agg_records = nil
-      # s = Benchmark.realtime do 
-        agg_records = aggregate_records(column_dimension, column_hierarchy, cstage, row_dimension, row_hierarchy, rstage)
-      #end
-#       cs = 0
-#       as = 0
-#       calc = 0
-#       x = 0
-      calculated_fields = self.class.fact_class.calculated_fields
-      calculated_field_options = self.class.fact_class.calculated_field_options
-      #puts "loading aggregate_records took #{s}s"
-      #s = Benchmark.realtime do
-        #puts "there are #{agg_records.length} agg_records"
-        #puts "there are #{self.class.fact_class.calculated_fields.length} calculated fields in class #{self.class.fact_class}"
-        agg_records.each do |agg_record|
-          # agg_record is an instance of Aggregate
-          # collect the aggregate record data fields into an array
-          data_array = nil
-          #cs += Benchmark.realtime do
-            data_array = agg_record.data_fields.collect{ |data_field_name| agg_record.send(data_field_name.to_sym) }
-          #end
-        
-          # convert to an average where necessary
-          # TODO: implement
-
-          # add calculated fields to the data array
-          #calc += Benchmark.realtime do
-            calculated_fields.each do |calculated_field|
-              options = calculated_field_options[calculated_field]
-              data_array << options[:block].call(agg_record)
-            end
-          #end
-        
-          # add the data array to the aggregate map
-          #as += Benchmark.realtime do
-            agg_map.add_data(agg_record.dimension2_path, agg_record.dimension1_path, data_array)
-          #end
-        end
-        
-      #end
-      #puts "creating the agg_map took #{s}s"
-      #puts "total time spent collecting the data: #{cs}s, avg:#{cs/agg_records.length}s (#{(cs/s) * 100}%)"
-      #puts "total time spent adding the data: #{as}s, avg:#{as/agg_records.length}s (#{(as/s) * 100}%)"
-      #puts "total time spent calculating fields: #{calc}s, avg:#{calc/agg_records.length}s (#{(calc/s) * 100}%)"
-      agg_map
+    # Query the cube. The column dimension, column hierarchy, row dimension and
+    # row hierarchy are all required.
+    #
+    # The conditions value is a String that represents a SQL condition appended
+    # to the where clause. TODO: this may eventually be converted to another
+    # query language.
+    #
+    # The cstage value represents the current  column drill down stage and 
+    # defaults to 0.
+    # 
+    # The rstage value represents the current row drill down stage and defaults 
+    # to 0. Filters contains key/value pairs where the key is a string of 
+    # 'dimension.column' and the value is the value to filter by. For example:
+    #
+    # filters = {'date.calendar_year' => 2007, 'product.category' => 'Food'}
+    # query(:date, :cy, :store, :region, 1, 0, filters)
+    #
+    # Note that product.category refers to a dimension which is not actually 
+    # visible but which is both part of the cube and is used for filtering.
+    def query(*args)
+      self.class.aggregate.query(*args)
     end
     
-    protected
-    # Return all of the Aggregate records for the specified dimensions and hierarchies
-    def aggregate_records(column_dimension, column_hierarchy, cstage, row_dimension, row_hierarchy, rstage)
-      k = Aggregate.key(column_dimension, column_hierarchy, row_dimension, row_hierarchy)
-      if aggregates[k].nil?
-        self.class.logger.debug("Aggregate #{k} not found in cache")
-        conditions = ['cube_name = ?', self.class.name]
-        conditions[0] << ' and dimension1 = ? and dimension1_hierarchy = ? and dimension2 = ? and dimension2_hierarchy = ?'
-        conditions << column_dimension.to_s
-        conditions << column_hierarchy.to_s
-        conditions << row_dimension.to_s
-        conditions << row_hierarchy.to_s
-        
-        conditions_reversed = ['cube_name = ?', self.class.name]
-        conditions_reversed[0] << ' and dimension1 = ? and dimension1_hierarchy = ? and dimension2 = ? and dimension2_hierarchy = ?'
-        conditions_reversed << row_dimension.to_s
-        conditions_reversed << row_hierarchy.to_s
-        conditions_reversed << column_dimension.to_s
-        conditions_reversed << column_hierarchy.to_s
-        
-        aggregate_meta_data = AggregateMetaData.find(:first, :conditions => conditions)
-        aggregate_meta_data ||= AggregateMetaData.find(:first, :conditions => conditions_reversed)
-        if aggregate_meta_data.nil?
-          self.class.rebuild
-          aggregate_meta_data = AggregateMetaData.find(:first, :conditions => conditions)
-          raise "Cannot find aggregate meta data for key #{k}" if aggregate_meta_data.nil?
-        end
-        aggregate_class = self.class.aggregates[aggregate_meta_data.id]
-        if aggregate_class.nil?
-          self.class.rebuild
-          aggregate_class = self.class.aggregates[aggregate_meta_data.id]
-          raise "Cannot find aggregate for id #{aggregate_meta_data.id}" if aggregate_class.nil?
-        end
-        
-        aggregates[k] = aggregate_class.find(:all, 
-          :conditions => ['(dimension1_stage = ? and dimension2_stage = ?) or (dimension1_stage = ? and dimension2_stage = ?)', 
-          cstage, rstage, rstage, cstage])
-      end
-      aggregates[k]
+    # Get the database connection (delegates to Cube.connection class method)
+    def connection
+      self.class.connection
     end
     
-    # Get a hash of all aggregate data
-    def aggregates
-      @aggregates ||= {}
-    end
   end
   
-  # In-memory map of aggregate values
-  class AggregateMap
-    attr_reader :length
-    
-    # Initialize the aggregate map
-    def initialize
-      @m = {}
-    end
-    
-    # Return true if the aggregate map includes the specified row path
-    def has_row_path?(row_path)
-      @m.has_key?(row_path)
-    end
-    
-    # Get the value for the specified row path, column path and field index
-    def value(row_path, col_path, field_index)
-      #puts "Getting value for #{row_path}, #{col_path} [field=#{field_index}]"
-      row = @m[row_path]
-      return 0 if row.nil?
-      col = row[col_path]
-      return 0 if col.nil?
-      return col[field_index] || 0
-    end
-    
-    # Get an array of the values for the specified row path and column path
-    def values(row_path, col_path)
-      row = @m[row_path]
-      return Array.new(length, 0) if row.nil?
-      col = row[col_path]
-      return Array.new(length, 0) if col.nil?
-      col
-    end
-    
-    # Add an array of data for the given row and column path
-    def add_data(row_path, col_path, data_array)
-      @length ||= data_array.length
-      #puts "Adding data for #{row_path}, #{col_path} [data=[#{data_array.join(',')}]]"
-      @m[row_path] ||= {}
-      @m[row_path][col_path] = data_array
-    end
-  end
 end