activewarehouse 0.1.0 → 0.2.0

data/lib/active_warehouse/builder/date_dimension_builder.rb

@@ -1,18 +1,33 @@
-module ActiveWarehouse
-  module Builder
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    # A builder which will build a data structure which can be used to populate a date dimension using 
+    # commonly used date dimension columns.
     class DateDimensionBuilder
-      attr_accessor :start_date, :end_date, :holiday_indicators
+      # Specify the start date for the first record
+      attr_accessor :start_date
+      
+      # Specify the end date for the last record
+      attr_accessor :end_date
+      
+      # Define any holiday indicators
+      attr_accessor :holiday_indicators
+      
+      # Define the weekday indicators. The default array begins on Sunday and goes to Saturday.
       cattr_accessor :weekday_indicators
       @@weekday_indicators = ['Weekend','Weekday','Weekday','Weekday','Weekday','Weekday','Weekend']
-        
+      
+      # Initialize the builder.
+      # 
+      # * <tt>start_date</tt>: The start date. Defaults to 5 years ago from today.
+      # * <tt>end_date</tt>: The end date. Defaults to now.
       def initialize(start_date=Time.now.years_ago(5), end_date=Time.now)
         @start_date = start_date
         @end_date = end_date
         @holiday_indicators = []
       end
       
-      # Returns an array of hashes representing records in the dimension
-      # The values for each record are accessed by name
+      # Returns an array of hashes representing records in the dimension. The values for each record are 
+      # accessed by name.
       def build(options={})
         records = []
         date = start_date

data/lib/active_warehouse/builder/random_data_builder.rb

@@ -1,12 +1,213 @@
-module ActiveWarehouse
-  module Builder
+module ActiveWarehouse #:nodoc:
+  module Builder #:nodoc:
+    # Build random data usable for testing.
     class RandomDataBuilder
+      # Hash of generators where the key is the class and the value is an implementation of AbstractGenerator
+      attr_reader :generators
+      
+      # Hash of names mapped to generators where the name is the column name
+      attr_reader :column_generators
+      
       def initialize
+        @generators = {
+          Fixnum => FixnumGenerator.new,
+          Float => FloatGenerator.new,
+          Date => DateGenerator.new,
+          Time => TimeGenerator.new,
+          String => StringGenerator.new,
+          Object => BooleanGenerator.new,
+        }
+        @column_generators = {}
+      end
+      
+      def build(name, options={})
+        case name
+        when Class
+          if name.respond_to?(:base_class)
+            return build_dimension(name, options) if name.base_class == ActiveWarehouse::Dimension
+            return build_fact(name, options) if name.base_class == ActiveWarehouse::Fact
+          end
+          raise "#{name} is a class but does not appear to descend from Fact or Dimension"
+        when String
+          begin
+            build(name.classify.constantize, options)
+          rescue NameError
+            raise "Cannot find a class named #{name.classify}"
+          end
+        when Symbol
+          build(name.to_s, options)
+        else
+          raise "Unable to determine what to build"
+        end
+      end
+      
+      # 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. 
+      def build_dimension(name, options={})
+        options[:rows] ||= 100
+        options[:generators] ||= {}
+        rows = []
+
+        dimension_class = Dimension.to_dimension(name)
+        options[:rows].times do
+          row = {}
+          dimension_class.content_columns.each do |column|
+            generator = (options[:generators][column.klass] || @column_generators[column.name] || @generators[column.klass])
+            row[column.name] = generator.generate(column, options)
+          end
+          rows << row
+        end
         
+        rows
       end
       
-      def build(options={})
+      # Build test fact data for the specified fact name
+      # 
+      # Options:
+      # * <tt>:rows</tt>: The number of rows to create (defaults to 100)
+      # * <tt>:generators</tt>: A Hash of generators where each key is Fixnum, Float, Date, Time, String, or Object and the
+      #   value is extends from AbstractGenerator.
+      # * <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.
+      def build_fact(name, options={})
+        options[:rows] ||= 100
+        options[:generators] ||= {}
+        options[:fk_limit] ||= {}
+        rows = []
+
+        fact_class = Fact.to_fact(name)
+        options[:rows].times do
+          row = {}
+          fact_class.content_columns.each do |column|
+            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
+          end
+          rows << row
+        end
         
+        rows
+      end
+    end
+    
+    # Implement this class to provide an generator implementation for a specific class.
+    class AbstractGenerator
+      # Generate the next value. The column parameter must be an ActiveRecord::Adapter::Column instance. 
+      # The options hash is implementation dependent.
+      def generate(column, options={})
+        raise "generate method must be implemented by a subclass"
+      end
+    end
+    
+    # Basic Date generator
+    class DateGenerator < AbstractGenerator
+      # 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)
+      def generate(column, options={})
+        end_date = (options[:end_date] || Time.now).to_date
+        start_date = (options[:start_date] || 1.year.ago).to_date
+        number_of_days = end_date - start_date
+        start_date + rand(number_of_days)
+      end
+    end
+    
+    # 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)
+    class TimeGenerator < DateGenerator #:nodoc:
+      # Generate a random Time value
+      def generate(column, options={})
+        super(column, options).to_time
+      end
+    end
+    
+    # Basic Fixnum generator
+    class FixnumGenerator
+      # 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)
+      def generate(column, options={})
+        options[:max] ||= 1000
+        options[:min] ||= 0
+        rand(options[:max] + (-options[:min])) - options[:min]
+      end
+    end
+    
+    # Basic Float generator
+    class FloatGenerator
+      # Generate a float from 0 to options[:max] inclusive (default 1000)
+      #
+      # Options:
+      # *<tt>:max</tt>: The maximum allowed value (default 1000)
+      def generate(column, options={})
+        options[:max] ||= 1000
+        rand * options[:max].to_f
+      end
+    end
+    
+    # Basic BigDecimal generator
+    class BigDecimalGenerator
+      # Generate a big decimal from 0 to options[:max] inclusive (default 1000)
+      #
+      # Options:
+      # *<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?
+      end
+    end
+    
+    # A basic String generator
+    class StringGenerator
+      # Initialize the StringGenerator.
+      #
+      # Options:
+      # * <tt>:values</tt>: List of possible values
+      # * <tt>:chars</tt>: List of chars to use to generate random values
+      def initialize(options={})
+        @options = options
+      end
+      # Generate a random string
+      #
+      # Options:
+      # * <tt>:values</tt>: An array of values to use. If not specified then random char values will be used.
+      # * <tt>:chars</tt>: An array of characters to use to generate random values (default [a..zA..Z])
+      def generate(column, options={})
+        options[:values] ||= @options[:values]
+        options[:chars] ||= @options[:chars]
+        if options[:values]
+          options[:values][rand(options[:values].length)]
+        else
+          s = ''
+          chars = (options[:chars] || ('a'..'z').to_a + ('A'..'Z').to_a)
+          0.upto(column.limit - 1) do |n|
+            s << chars[rand(chars.length)]
+          end
+          s
+        end
+      end
+    end
+    
+    # A basic Boolean generator
+    class BooleanGenerator
+      # Generate a random boolean
+      def generate(column, options={})
+        rand(1) == 1
       end
     end
   end

data/lib/active_warehouse/compat/compat.rb

@@ -0,0 +1,49 @@
+# Provides 1.1.6 compatibility
+module ActiveRecord
+  module Calculations
+    module ClassMethods
+      protected
+      def construct_count_options_from_legacy_args(*args)
+        options     = {}
+        column_name = :all
+
+        # We need to handle
+        #   count()
+        #   count(options={})
+        #   count(column_name=:all, options={})
+        #   count(conditions=nil, joins=nil)      # deprecated
+        if args.size > 2
+          raise ArgumentError, "Unexpected parameters passed to count(options={}): #{args.inspect}"
+        elsif args.size > 0
+          if args[0].is_a?(Hash)
+            options = args[0]
+          elsif args[1].is_a?(Hash)
+            column_name, options = args
+          else
+            # Deprecated count(conditions, joins=nil)
+            ActiveSupport::Deprecation.warn(
+              "You called count(#{args[0].inspect}, #{args[1].inspect}), which is a deprecated API call. " +
+              "Instead you should use count(column_name, options). Passing the conditions and joins as " +
+              "string parameters will be removed in Rails 2.0.", caller(2)
+            )
+            options.merge!(:conditions => args[0])
+            options.merge!(:joins      => args[1]) if args[1]
+          end
+        end
+
+        [column_name, options]
+      end
+    end
+  end
+end
+
+class Module
+  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.
+    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+    yield(aliased_target, punctuation) if block_given?
+    alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
+    alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
+  end
+end

data/lib/active_warehouse/{model/cube.rb → cube.rb}

@@ -20,12 +20,14 @@ module ActiveWarehouse
           dimensions << dimension
         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
       end
+      alias :report_on :reports_on
       
       # Rebuild all aggregate classes. Set :force => true to force the rebuild of aggregate classes.
       def rebuild(options={})
@@ -163,30 +165,56 @@ module ActiveWarehouse
     def aggregate_map(column_dimension, column_hierarchy, row_dimension, row_hierarchy, cstage=0, rstage=0)
       # Fill known cells
       agg_map = AggregateMap.new
-      agg_records = aggregate_records(column_dimension, column_hierarchy, row_dimension, row_hierarchy)
-      agg_records.each do |agg_record|
-        # agg_record is an instance of Aggregate
-        # collect the aggregate record data fields into an array
-        data_array = agg_record.data_fields.collect{ |data_field_name| agg_record.send(data_field_name.to_sym) }
+      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
+          # convert to an average where necessary
+          # TODO: implement
 
-        # add calculated fields to the data array
-        self.class.fact_class.calculated_fields.each do |calculated_field| 
-          options = self.class.fact_class.calculated_field_options[calculated_field]
-          data_array << options[:block].call(agg_record)
+          # 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
         
-        # add the data array to the aggregate map
-        agg_map.add_data(agg_record.dimension2_path, agg_record.dimension1_path, data_array)
-      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
     end
     
     protected
     # Return all of the Aggregate records for the specified dimensions and hierarchies
-    def aggregate_records(column_dimension, column_hierarchy, row_dimension, row_hierarchy)
+    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")
@@ -217,8 +245,10 @@ module ActiveWarehouse
           aggregate_class = self.class.aggregates[aggregate_meta_data.id]
           raise "Cannot find aggregate for id #{aggregate_meta_data.id}" if aggregate_class.nil?
         end
-        #puts "Loading aggregate #{aggregate_meta_data.id}"
-        aggregates[k] = aggregate_class.find(:all)
+        
+        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]
     end

data/lib/active_warehouse/dimension.rb

@@ -0,0 +1,296 @@
+# require all of the "acts_as" mixins first
+require 'active_warehouse/dimension/hierarchical_dimension'
+require 'active_warehouse/dimension/slowly_changing_dimension'
+
+module ActiveWarehouse #:nodoc
+  # Dimension tables contain the textual descriptors of the business. Dimensions provide the filters which 
+  # are applied to facts. Dimensions are the primary source of query constraints, groupings and report 
+  # labels.
+  # 
+  class Dimension < ActiveRecord::Base
+    include ActiveWarehouse::HierarchicalDimension
+    include ActiveWarehouse::SlowlyChangingDimension
+    
+    after_save :expire_value_tree_cache
+    
+    class << self
+      # Alternate order by, to be used rather than the current level being queried
+      attr_accessor :order
+      
+      # Map of level names to alternate order columns
+      attr_reader :level_orders
+      
+      # Define a column to order by. If this value is specified then it will be used rather than the actual
+      # level being queried in the following method calls:
+      # * available_values
+      # * available_child_values
+      # * available_values_tree
+      def set_order(name)
+        @order = name
+      end
+      
+      # Define a column to order by for a specific level.
+      def set_level_order(level, name)
+        level_orders[level] = name
+      end
+      
+      # Get the level orders map
+      def level_orders
+        @level_orders ||= {}
+      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. Returns an array of column names.
+      # 
+      # 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} as level, count(distinct(#{denominator_level})) as level_count from #{table_name} group by #{level}"
+        else
+          q = "select #{level} as level, count(id) as level_count from #{table_name} group by #{level}"
+        end
+        denominators = {}
+        # TODO: fix to use select_all instead of execute
+        connection.select_all(q).each do |row|
+          denominators[row['level']] = row['level_count'].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)
+        level_method = level.to_sym
+        level = connection.quote_column_name(level.to_s)
+        order = level_orders[level] || self.order || level
+        find(:all, :select => level, :group => level, :order => order).collect {|dim| dim.send(level_method)}
+      end
+      
+      # Get an array of child values for a particular parent in the hierachy
+      # For example, given a DateDimension with data from 2002 to 2004:
+      # 
+      # available_child_values(:cy, [2002, 'Q1']) returns ['January', 'Feburary', 'March', 'April']
+      def available_child_values(hierarchy_name, parent_values)
+        if hierarchy_levels[hierarchy_name].nil?
+          raise ArgumentError, "The hierarchy '#{hierarchy_name}' does not exist in your dimension #{name}"
+        end
+
+        levels = hierarchy_levels[hierarchy_name]
+        if levels.length <= parent_values.length
+          raise ArgumentError, "The parent_values '#{parent_values.to_yaml}' exceeds the hierarchy depth #{levels.to_yaml}"
+        end
+        
+        child_level = levels[parent_values.length].to_s
+        
+        # Create the conditions array. Will work with 1.1.6.
+        conditions_parts = []
+        conditions_values = []
+        parent_values.each_with_index do |value, index|
+          conditions_parts << "#{levels[index]} = ?"
+          conditions_values << value
+        end
+        conditions = [conditions_parts.join(' AND ')] + conditions_values unless conditions_parts.empty?
+        
+        child_level_method = child_level.to_sym
+        child_level = connection.quote_column_name(child_level)
+        order = level_orders[child_level] || self.order || child_level
+        
+        options = {:select => child_level, :group => child_level, :order => order}
+        options[:conditions] = conditions unless conditions.nil?
+        find(:all, options).collect {|dim| dim.send(child_level_method)}
+      end
+      alias :available_children_values :available_child_values
+      
+      # Get a tree of Node objects for all of the values in the specified hierarchy.
+      def available_values_tree(hierarchy_name)
+        root = value_tree_cache[hierarchy_name]
+        if root.nil?
+          root = Node.new('All', '__ROOT__')
+          levels = hierarchy(hierarchy_name)
+          nodes = {nil => root}
+          level_list = levels.collect{|level| connection.quote_column_name(level) }.join(',')
+          order = self.order || level_list
+          find(:all, :select => level_list, :group => level_list, :order => order).each do |dim|
+            parent_node = root
+            levels.each do |level|
+              node_value = dim.send(level)
+              child_node = parent_node.optionally_add_child(node_value, level)
+              parent_node = child_node
+            end
+          end
+          value_tree_cache[hierarchy_name] = root
+        end
+        root
+      end
+      
+      protected
+      # Get the value tree cache
+      def value_tree_cache
+        @value_tree_cache ||= {}
+      end
+      
+      class Node#:nodoc:
+        attr_reader :value, :children, :parent, :level
+
+        def initialize(value, level, parent = nil)
+          @children = []
+          @value = value
+          @parent = parent
+          @level = level
+        end
+
+        def has_child?(child_value)
+          !self.child(child_value).nil?
+        end
+
+        def child(child_value)
+          @children.each do |c|
+            return c if c.value == child_value
+          end
+          nil
+        end
+
+        def add_child(child_value, level)
+          child = Node.new(child_value, level, self)
+          @children << child
+          child
+        end
+        
+        def optionally_add_child(child_value, level)
+          c = child(child_value)
+          c = add_child(child_value, level) unless c
+          c
+        end
+      end
+      
+      public
+      # Expire the value tree cache. This should be called if the dimension
+      def expire_value_tree_cache
+        @value_tree_cache = nil
+      end
+    end
+    
+    public
+    def expire_value_tree_cache
+      self.class.expire_value_tree_cache
+    end
+    
+  end
+end
+
+require 'active_warehouse/dimension/bridge'