mainej-activewarehouse 0.3.0

data/activewarehouse/lib/active_warehouse/aggregate/dwarf_printer.rb

@@ -0,0 +1,34 @@
+module ActiveWarehouse #:nodoc:
+  module Aggregate #:nodoc:
+    # Dwarf support class that prints a representation of the Dwarf
+    class DwarfPrinter
+      # Print the specified node at the given depth.
+      def self.print_node(node, depth=0, recurse=true)
+        #puts "printing node #{node.index}"
+        cells = node.cells.collect { |c| cell_to_string(c)}.join('|')
+
+        parent_node = node.parent ? "#{cell_to_string(node.parent)}:" : ''
+        puts "#{node.index}=#{' '*depth}#{parent_node}[#{cells}|#{all_cell_to_string(node.all_cell)}]"
+        if !node.leaf?
+          print_node(node.all_cell.child, depth + 1, false) if node.all_cell
+        end
+        if recurse
+          node.children.each { |child| print_node(child, depth+1) }
+        end
+      end
+      
+      def self.cell_to_string(cell)
+        # a new String object must be created here, otherwise to_s returns a reference
+        # to the same String object each time and thus the value will be appended each time
+        # which is not what I want
+        s = String.new(cell.key.to_s)
+        s << " #{cell.value.join(',')}" if cell.node.leaf?
+        s
+      end
+      
+      def self.all_cell_to_string(cell)
+        cell ? (cell.value ? cell.value.inspect : '') : ''
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/aggregate/no_aggregate.rb

@@ -0,0 +1,212 @@
+require 'set'
+
+module ActiveWarehouse #:nodoc:
+  module Aggregate #:nodoc:
+    # An aggregate which goes directly to the fact and dimensions to answer questions
+    class NoAggregate < Aggregate
+      # Populate the aggregate (in this case it is a no-op implementation)
+      def populate
+        # do nothing
+      end
+      
+      # Query the aggregate
+      # def query(column_dimension_name, column_hierarchy_name,
+#                 row_dimension_name, row_hierarchy_name, conditions=nil,
+#                 cstage=0, rstage=0, filters={})
+      
+      # Query the aggregate
+      def query(*args)
+        options = parse_query_args(*args)
+        
+        column_dimension_name = options[:column_dimension_name]
+        column_hierarchy_name = options[:column_hierarchy_name]
+        row_dimension_name = options[:row_dimension_name]
+        row_hierarchy_name = options[:row_hierarchy_name]
+        conditions = options[:conditions]
+        cstage = options[:cstage] || 0
+        rstage = options[:rstage] || 0
+        filters = options[:filters] || {}
+        
+        fact_class = cube_class.fact_class
+        column_dimension = fact_class.dimension_class(column_dimension_name)
+        column_hierarchy = column_dimension.hierarchy(column_hierarchy_name)
+        row_dimension = fact_class.dimension_class(row_dimension_name)
+        row_hierarchy = row_dimension.hierarchy(row_hierarchy_name)
+        
+        used_dimensions = Set.new
+        used_dimensions.merge([column_dimension_name, row_dimension_name])
+        row_dim_reflection = fact_class.dimension_relationships[row_dimension_name].dependent_dimension_reflections
+        used_dimensions.merge(row_dim_reflection.collect{|d| d.name})
+        col_dim_reflection = fact_class.dimension_relationships[column_dimension_name].dependent_dimension_reflections
+        used_dimensions.merge(col_dim_reflection.collect{|d| d.name})
+        filters.each do |k,v|
+          used_dimensions << k.split('.')[0]
+        end
+        if conditions
+          cube_class.dimensions.each do |dimension|
+            if conditions =~ /#{dimension}\./i
+              used_dimensions << dimension
+            end
+          end
+        end
+        
+        # This method assumes at most one dimension is hierarchical dimension
+        # in the query params. TODO: need to handle when both row and column
+        # are hierarchical dimensions.
+        hierarchical_dimension = nil
+        hierarchical_dimension_name = nil
+        hierarchical_stage = nil
+        
+        if !column_dimension.hierarchical_dimension?
+          current_column_name = column_hierarchy[cstage]
+        else
+          hierarchical_dimension = column_dimension
+          hierarchical_dimension_name = column_dimension_name
+          hierarchical_stage = cstage
+          current_column_name = column_hierarchy[0]
+        end
+        
+        if !row_dimension.hierarchical_dimension?
+          current_row_name = row_hierarchy[rstage]
+        else
+          hierarchical_dimension = row_dimension
+          hierarchical_dimension_name = row_dimension_name
+          hierarchical_stage = rstage
+          current_row_name = row_hierarchy[0]
+        end
+
+        fact_columns = cube_class.aggregate_fields(used_dimensions).collect { |c| 
+          agg_sql = ''
+          quoted_label = cube_class.connection.quote_column_name(c.label)
+          if hierarchical_dimension and !c.levels_from_parent.empty?
+            bridge = hierarchical_dimension.bridge_class
+            bridge_table_name = bridge.table_name
+            levels_from_parent = bridge.levels_from_parent
+            get_all = false
+            c.levels_from_parent.each do |level|
+              case level
+              when :all
+                agg_sql += "  #{c.strategy_name}(#{c.from_table_name}.#{c.name}) AS #{quoted_label})"
+                get_all = true
+              when :self
+                agg_sql += " #{c.strategy_name}(CASE " if agg_sql.length == 0
+                agg_sql += " WHEN #{bridge_table_name}.#{levels_from_parent} = 0 THEN #{c.from_table_name}.#{c.name} \n"
+              when Integer  
+                agg_sql += " #{c.strategy_name}(CASE " if agg_sql.length == 0              
+                agg_sql += " WHEN #{bridge_table_name}.#{levels_from_parent} = #{level} then #{c.from_table_name}.#{c.name} \n"
+              else
+                raise ArgumentError, "Each element to :levels_from_parent option must be :all, :self, or Integer"
+              end
+            end
+            agg_sql += " ELSE 0 END) AS #{quoted_label}" unless get_all
+          else
+            if c.is_distinct?
+              agg_sql = "  #{c.strategy_name}(distinct #{c.from_table_name}.#{c.name}) AS #{quoted_label}" 
+            else
+              agg_sql = "  #{c.strategy_name}(#{c.from_table_name}.#{c.name}) AS #{quoted_label}" 
+            end
+          end
+          agg_sql
+        }.join(",\n")
+
+        sql = ''
+        sql += "SELECT\n"
+        sql += "  #{column_dimension_name}.#{current_column_name} as #{column_dimension_name}_1_#{current_column_name},\n"
+        sql += "  #{row_dimension_name}.#{current_row_name} as #{row_dimension_name}_2_#{current_row_name},\n"
+        sql += fact_columns
+        sql += "\nFROM\n"
+
+        sql += "  #{fact_class.table_name}"
+        cube_class.dimensions_hierarchies.each do |dimension_name, hierarchy_names|
+          next if !used_dimensions.include?(dimension_name)
+          dimension = fact_class.dimension_class(dimension_name)
+          if !dimension.hierarchical_dimension? 
+            if fact_class.belongs_to_relationship?(dimension_name)
+              sql += "\nJOIN #{dimension.table_name} as #{dimension_name}"
+              sql += "\n  ON #{fact_class.table_name}.#{fact_class.foreign_key_for(dimension_name)} = "
+              sql += "#{dimension_name}.#{dimension.primary_key}"
+            elsif fact_class.has_and_belongs_to_many_relationship?(dimension_name)
+              relationship = fact_class.dimension_relationship(dimension_name)
+              sql += "\nJOIN #{relationship.options[:join_table]} as #{dimension_name}_bridge"
+              sql += "\n  ON #{fact_class.table_name}.#{fact_class.primary_key} = "
+              sql += "#{dimension_name}_bridge.#{relationship.options[:foreign_key]}"
+              sql += "\nJOIN #{dimension.table_name} as #{dimension_name}"
+              sql += "\n  ON #{dimension_name}_bridge.#{relationship.options[:association_foreign_key]} = "
+              sql += "#{dimension_name}.#{dimension.primary_key}"
+            end
+          else
+            dimension_bridge = dimension.bridge_class
+            sql += "\nJOIN #{dimension_bridge.table_name}"
+            sql += "\n  ON #{fact_class.table_name}.#{fact_class.foreign_key_for(dimension_name)} = "
+            sql += "#{dimension_bridge.table_name}.#{dimension.parent_foreign_key}"
+            if dimension.slowly_changing_dimension?
+              sql += " and (#{dimension_bridge.table_name}.#{dimension_bridge.effective_date} <= "
+              sql += "#{fact_class.slowly_changes_over_name(dimension_name)}."
+              sql += "#{fact_class.slowly_changes_over_class(dimension_name).sql_date_stamp} "
+              sql += "and #{dimension_bridge.table_name}.#{dimension_bridge.expiration_date} >= "
+              sql += "#{fact_class.slowly_changes_over_name(dimension_name)}."
+              sql += "#{fact_class.slowly_changes_over_class(dimension_name).sql_date_stamp}) "
+            end
+            sql += "\nJOIN #{dimension.table_name} as #{dimension_name}"
+            sql += "\n  ON #{dimension_bridge.table_name}.#{dimension.child_foreign_key} = "
+            sql += "#{dimension_name}.#{dimension.primary_key}"
+          end
+        end
+
+        # build the where clause
+        # first add conditions
+        where_clause = Array(conditions)
+        
+        # apply filters
+        filters.each do |key, value|
+          dimension_name, column = key.split('.')
+          where_clause << "#{dimension_name}.#{column} = #{cube_class.connection.quote(value)}"
+        end
+        sql += %Q(\nWHERE\n  #{where_clause.join(" AND\n  ")} ) if where_clause.length > 0
+
+        # for hierarchical dimension we need to add where clause in for drill downs
+        if !hierarchical_dimension.nil?
+          if where_clause.length == 0
+            sql += "\n WHERE "
+          else 
+            sql += " \n AND "
+          end
+          sql += "\n #{hierarchical_dimension_name}.#{hierarchical_dimension.primary_key} IN ( "
+          sql += "\n SELECT #{hierarchical_dimension.parent_foreign_key} FROM #{hierarchical_dimension.bridge_class.table_name} "
+          if hierarchical_stage == 0   
+            sql += "\n WHERE #{hierarchical_dimension.bridge_class.top_flag} = #{connection.send(:quote, hierarchical_dimension.bridge_class.top_flag_value)})"
+          else
+            sql += "\n WHERE #{hierarchical_dimension.child_foreign_key} = #{hierarchical_stage} AND #{hierarchical_dimension.levels_from_parent} = 1)"
+          end
+        end
+        
+        sql += "\nGROUP BY\n"
+        sql += "  #{column_dimension_name}.#{current_column_name},\n"
+        sql += "  #{row_dimension_name}.#{current_row_name}"
+        
+        if options[:order]
+          order_by = options[:order]
+          order_by = [order_by] if order_by.is_a?(String)
+          order_by.collect!{ |v| cube_class.connection.quote_column_name(order_by) }
+          sql += %Q(\nORDER BY\n  #{order_by.join(",\n")})
+        end
+        
+        if options[:return] == :sql
+          sql
+        else
+          result = ActiveWarehouse::CubeQueryResult.new(
+            cube_class.aggregate_fields(used_dimensions)
+          )
+        
+          cube_class.connection.select_all(sql).each do |row|
+            result.add_data(row.delete("#{row_dimension_name}_2_#{current_row_name}"),
+                            row.delete("#{column_dimension_name}_1_#{current_column_name}"),
+                            row) # the rest of the members of row are the fact columns
+          end
+        
+          result
+        end
+      end
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/aggregate/pid_aggregate.rb

@@ -0,0 +1,29 @@
+module ActiveWarehouse #:nodoc:
+  module Aggregate #:nodoc:
+    # Implementation of a Partitioning and Inserting Dwarf algorithm as defined
+    # in http://www.zju.edu.cn/jzus/2005/A0506/A050608.pdf
+    class PidAggregate < Aggregate
+      include DwarfCommon
+      
+      # Initialize the aggregate
+      def initialize(cube_class)
+        super
+      end
+      
+      # Populate the aggregate
+      def populate
+        create_dwarf_cube(sorted_facts)
+      end
+      
+      # Query the aggregate
+      def query(*args)
+        options = parse_query_args(*args)
+      end
+      
+      def create_dwarf_cube(sorted_facts)
+        
+      end
+
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/aggregate_field.rb

@@ -0,0 +1,59 @@
+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
+    
+    # Returns true if the field is semi-additive
+    def is_semiadditive?
+      !field_options[:semiadditive].nil?
+    end
+    
+    def is_distinct?
+      field_options[:distinct] and field_options[:distinct] == true
+    end
+    
+    def is_count_distinct?
+      @strategy_name == :count and is_distinct?
+    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
+    
+    # Typecast the specified value using the column definition
+    def type_cast(value)
+      @column_definition.type_cast(value)
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/bridge.rb

@@ -0,0 +1,19 @@
+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.
+      #
+      # Example: DepartmentHierarchyBridge will have a table called
+      # department_hierarchy_bridge
+      def table_name
+        name = self.name.demodulize.underscore
+        set_table_name(name)
+        name
+      end
+    end
+  end
+end
+
+require 'active_warehouse/bridge/hierarchy_bridge'

data/activewarehouse/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/activewarehouse/lib/active_warehouse/builder.rb

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

data/activewarehouse/lib/active_warehouse/builder/date_dimension_builder.rb

@@ -0,0 +1,91 @@
+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
+      # 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.to_date
+        @end_date = end_date.to_date
+        @holiday_indicators = []
+      end
+
+      # Returns an array of hashes representing records in the dimension.
+      def build(options={})
+        (start_date..end_date).map { |date| record_from_date(date) }
+      end
+
+      private
+
+      # Returns a hash representing a record in the dimension. The values for each record are 
+      # accessed by name.
+      def record_from_date(date)
+        time = date.to_time # need methods only available in Time
+        record = {}
+        record[:date] = time.strftime("%m/%d/%Y")
+        record[:full_date_description] = time.strftime("%B %d,%Y")
+        record[:day_of_week] = time.strftime("%A")
+        #record[:day_number_in_epoch] = time.to_i / 24
+        #record[:week_number_in_epoch] = time.to_i / (24 * 7)
+        #record[:month_number_in_epoch] = time.to_i / (24 * 7 * 30)
+        record[:day_number_in_calendar_month] = time.day
+        record[:day_number_in_calendar_year] = time.yday
+        record[:day_number_in_fiscal_month] = time.day # should this be different from CY?
+        record[:day_number_in_fiscal_year] = time.fiscal_year_yday
+        #record[:last_day_in_week_indicator] = 
+        #record[:last_day_in_month_indicator] =
+        #record[:calendar_week_ending_date] = 
+        record[:calendar_week] = "Week #{time.week}"
+        record[:calendar_week_number] = time.week
+        record[:calendar_week_number_in_year] = time.week
+        record[:calendar_month_name] = time.strftime("%B")
+        record[:calendar_month_number] = time.month
+        record[:calendar_month_number_in_year] = time.month
+        record[:calendar_year_month] = time.strftime("%Y-%m")
+        record[:calendar_quarter] = "Q#{time.quarter}"
+        record[:calendar_quarter_number] = time.quarter
+        record[:calendar_quarter_number_in_year] = time.quarter
+        record[:calendar_year_quarter] = "#{time.strftime('%Y')}-#{record[:calendar_quarter]}"
+        #record[:calendar_half_year] = 
+        record[:calendar_year] = "#{time.year}"
+        record[:fiscal_week] = "FY Week #{time.fiscal_year_week}"
+        record[:fiscal_week_number] = time.fiscal_year_week
+        record[:fiscal_week_number_in_year] = time.fiscal_year_week
+        record[:fiscal_month] = time.fiscal_year_month
+        record[:fiscal_month_number] = time.fiscal_year_month
+        record[:fiscal_month_number_in_year] = time.fiscal_year_month
+        record[:fiscal_year_month] = "FY#{time.fiscal_year}-" + time.fiscal_year_month.to_s.rjust(2, '0')
+        record[:fiscal_quarter] = "FY Q#{time.fiscal_year_quarter}"
+        record[:fiscal_year_quarter] = "FY#{time.fiscal_year}-Q#{time.fiscal_year_quarter}"
+        record[:fiscal_quarter_number] = time.fiscal_year_quarter
+        record[:fiscal_year_quarter_number] = time.fiscal_year_quarter
+        #record[:fiscal_half_year] = 
+        record[:fiscal_year] = "FY#{time.fiscal_year}"
+        record[:fiscal_year_number] = time.fiscal_year
+        record[:holiday_indicator] = holiday_indicators.include?(date) ? 'Holiday' : 'Nonholiday'
+        record[:weekday_indicator] = weekday_indicators[time.wday]
+        record[:selling_season] = 'None'
+        record[:major_event] = 'None'
+        record[:sql_date_stamp] = date
+
+        record
+      end
+    end
+  end
+end