mainej-activewarehouse 0.3.0

data/activewarehouse/lib/active_warehouse/field.rb

@@ -0,0 +1,74 @@
+module ActiveWarehouse #:nodoc:
+  # Encapsulates a field.
+  class Field
+    # The owning class which is either a Fact or Dimension
+    attr_reader :owning_class
+    
+    # The field name
+    attr_reader :name
+    
+    # The field type
+    attr_reader :type
+    
+    attr_accessor :limit
+    attr_accessor :scale
+    attr_accessor :precision
+    
+    # A Hash of options for the field
+    attr_reader :field_options
+    
+    # +owning_class+ is the class of the table, either Fact or Dimension, that
+    # this field is found in.  Must somehow subclass ActiveRecord::Base
+    # +name+ is the name of this field.
+    # +field_options+ is a hash of raw options from the original definition.
+    # Options can include :label => a column alias or label for this field,
+    # :table_alias for a table alias (useful for building queries)
+    def initialize(owning_class, name, type, field_options = {})
+      @owning_class = owning_class
+      @name = name
+      @type = type
+      @field_options = field_options
+      @label = field_options[:label]
+      @table_alias = field_options[:table_alias]
+    end
+    
+    # returns the :label set in field_options, or from_table_name+'_'+name.
+    # Unless you have table_alias specified, then label will return table_alias+'_'+name.
+    # The default label can exceed database limits, so use :label to override.
+    def label
+      @label ? @label : "#{table_alias || from_table_name}_#{name}"
+    end
+    
+    # returns name of this field, matches name of the column
+    def name
+      @name
+    end
+    
+    # returns rails specific column type, e.g. :float or :string
+    def column_type
+      @type
+    end
+    
+    # convert the label into something we can use in a table.
+    # i.e., 'Sum of Transactions' becomes 'sum_of_transactions'
+    def label_for_table
+      label.gsub(/ /, '_').downcase
+    end
+    
+    # returns the table name that has this fact column
+    def from_table_name
+      owning_class.table_name
+    end
+    
+    # returns a table alias or if none set just the table name
+    def table_alias
+      @table_alias || from_table_name
+    end
+    
+    # Get a display string for the field. Delegates to label.
+    def to_s
+      label
+    end
+    
+  end
+end

data/activewarehouse/lib/active_warehouse/migrations.rb

@@ -0,0 +1,64 @@
+module ActiveWarehouse #:nodoc:
+  # Responsible for migrating ActiveWarehouse tables which are automatically created.
+  class Migrator < ActiveRecord::Migrator
+    class << self
+      def schema_info_table_name #:nodoc:
+        ActiveRecord::Base.table_name_prefix + 'activewarehouse_schema_info' + ActiveRecord::Base.table_name_suffix
+      end
+      
+      def current_version #:nodoc:
+        result = ActiveRecord::Base.connection.select_one("SELECT version FROM #{schema_info_table_name}")
+        if result
+          result['version'].to_i
+        else
+          # There probably isn't an entry for this plugin in the migration info table.
+          # We need to create that entry, and set the version to 0
+          ActiveRecord::Base.connection.execute("INSERT INTO #{schema_info_table_name} (version) VALUES (0)")      
+          0
+        end
+      end    
+    end
+    
+    def set_schema_version(version)
+      ActiveRecord::Base.connection.update("UPDATE #{self.class.schema_info_table_name} SET version = #{down? ? version.to_i - 1 : version.to_i}")
+    end
+  end
+end
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module SchemaStatements #:nodoc:
+      def initialize_schema_information_with_activewarehouse
+        initialize_schema_information_without_activewarehouse
+        
+        begin
+          execute "CREATE TABLE #{ActiveWarehouse::Migrator.schema_info_table_name} (version #{type_to_sql(:integer)})"
+        rescue ActiveRecord::StatementInvalid
+          # Schema has been initialized
+        end
+      end
+      alias_method_chain :initialize_schema_information, :activewarehouse
+      
+      def dump_schema_information_with_activewarehouse
+        schema_information = []
+        
+        dump = dump_schema_information_without_activewarehouse
+        schema_information << dump if dump
+        
+        begin
+          plugins = ActiveRecord::Base.connection.select_all("SELECT * FROM #{ActiveWarehouse::Migrator.schema_info_table_name}")
+          plugins.each do |plugin|
+            if (version = plugin['version'].to_i) > 0
+              schema_information << "INSERT INTO #{ActiveWarehouse::Migrator.schema_info_table_name} (version) VALUES (#{version})"
+            end
+          end
+        rescue ActiveRecord::StatementInvalid 
+          # No Schema Info
+        end
+        
+        schema_information.join("\n")
+      end
+      alias_method_chain :dump_schema_information, :activewarehouse
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/ordered_hash.rb

@@ -0,0 +1,34 @@
+module ActiveWarehouse
+  # Simple ordered hash implementation
+  class OrderedHash < Hash
+    alias_method :store, :[]=
+    alias_method :each_pair, :each
+  
+    def initialize
+      @keys = []
+    end
+  
+    def []=(key, val)
+      @keys << key
+      super
+    end
+  
+    def delete(key)
+      @keys.delete(key)
+      super
+    end
+  
+    def each
+      @keys.each { |k| yield k, self[k] }
+    end
+  
+    def each_key
+      @keys.each { |k| yield k }
+    end
+  
+    def each_value
+      @keys.each { |k| yield self[k] }
+    end
+    
+  end
+end

data/activewarehouse/lib/active_warehouse/prejoin_fact.rb

@@ -0,0 +1,97 @@
+module ActiveWarehouse #:nodoc:
+  # Class that supports prejoining a fact table with dimensions. This is useful if you need
+  # to list facts along with some or all of their detail information.
+  class PrejoinFact
+    # The fact class that this engine instance is connected to
+    attr_accessor :fact_class
+    
+    delegate :prejoined_table_name, 
+      :connection, 
+      :prejoined_fields,
+      :dimension_relationships, 
+      :dimension_class, 
+      :table_name,
+      :columns, :to => :fact_class
+  
+    # Initialize the engine instance
+    def initialize(fact_class)
+      @fact_class = fact_class
+    end
+  
+    # Populate the prejoined fact table.
+    def populate(options={})
+      populate_prejoined_fact_table(options)
+    end
+    
+    protected
+    # Drop the storage table
+    def drop_prejoin_fact_table
+      connection.drop_table(prejoined_table_name) if connection.tables.include?(prejoined_table_name)
+    end
+    
+    # Get foreign key names that are excluded.
+    def excluded_foreign_key_names
+      excluded_dimension_relations = prejoined_fields.keys.collect {|k| dimension_relationships[k]}
+      excluded_dimension_relations.collect {|r| r.primary_key_name}
+    end
+    
+    # Construct the prejoined fact table.
+    def create_prejoined_fact_table(options={})
+      connection.transaction {
+        drop_prejoin_fact_table
+
+        connection.create_table(prejoined_table_name, :id => false) do |t|
+          # get all columns except the foreign_key columns for prejoined dimensions
+          columns.each do |c|
+            t.column(c.name, c.type) unless excluded_foreign_key_names.include?(c.name)
+          end
+          #prejoined_columns
+          prejoined_fields.each_pair do |key, value|
+            dclass = dimension_class(key)
+            dclass.columns.each do |c|
+              t.column(c.name, c.type) if value.include?(c.name.to_sym) 
+            end
+          end
+        end
+      }
+    end
+    
+    # Populate the prejoined fact table.
+    def populate_prejoined_fact_table(options={})
+      fact_columns_string = columns.collect {|c|
+        "#{table_name}." + c.name unless excluded_foreign_key_names.include?(c.name)
+      }.compact.join(",\n")  
+      
+      prejoined_columns = []
+      
+      tables_and_joins = "#{table_name}"
+      
+      prejoined_fields.each_pair do |key, value|
+        dimension = dimension_class(key)
+        tables_and_joins += "\nJOIN #{dimension.table_name} as #{key}"
+        tables_and_joins += "\n  ON #{table_name}.#{dimension_relationships[key].primary_key_name} = "
+        tables_and_joins += "#{key}.#{dimension.primary_key}"
+        prejoined_columns << value.collect {|v| "#{key}." + v.to_s}
+      end
+
+      if connection.support_select_into_table?
+        drop_prejoin_fact_table
+        sql = <<-SQL
+          SELECT #{fact_columns_string}, 
+            #{prejoined_columns.join(",\n")}
+          FROM #{tables_and_joins}
+        SQL
+        sql = connection.add_select_into_table(prejoined_table_name, sql)
+      else
+        create_prejoined_fact_table(options)
+        sql = <<-SQL
+          INSERT INTO #{prejoined_table_name}
+          SELECT #{fact_columns_string}, 
+            #{prejoined_columns.join(",\n")}
+          FROM #{tables_and_joins}
+        SQL
+      end
+      connection.transaction { connection.execute(sql) }                
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/report.rb

@@ -0,0 +1,7 @@
+require 'active_warehouse/report/abstract_report'
+require 'active_warehouse/report/table_report'
+require 'active_warehouse/report/chart_report'
+require 'active_warehouse/report/dimension'
+require 'active_warehouse/report/data_column'
+require 'active_warehouse/report/data_row'
+require 'active_warehouse/report/data_cell'

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

@@ -0,0 +1,149 @@
+module ActiveWarehouse #:nodoc:
+  module Report #:nodoc:
+    # Base module for reports.
+    module AbstractReport
+      
+      # Array of parameters which will be passed
+      attr_accessor :pass_params
+      
+      # A Hash of level names mapped to a method that is used to filter the 
+      # available column values
+      attr_accessor :column_filters
+      
+      # A Hash of level names mapped to a method that is used to filter the 
+      # available row values
+      attr_accessor :row_filters
+      
+      # An optional conditions String
+      attr_accessor :conditions
+
+      # Set the cube name
+      def cube_name=(name)
+        write_attribute(: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 ||= fact_class.dimension_class(self.column_dimension_name)
+      end
+
+      # Get the column hierarchy. Uses the first hierarchy in the column 
+      # dimension if not specified
+      def column_hierarchy
+        ch = read_attribute(:column_hierarchy)
+        if ch.nil? || ch == 'NULL'
+          column_dimension_class.hierarchies.first
+        else
+          ch
+        end
+      end
+      
+      # Get the column prefix. Returns 'c' if not specified.
+      def column_param_prefix
+        read_attribute(:column_param_prefix) || 'c'
+      end
+
+      # Get the row dimension class
+      def row_dimension_class
+        @row_dimension_class ||= fact_class.dimension_class(self.row_dimension_name)
+      end
+      
+      # Get the row hierarchy. Uses the first hierarchy in the row dimension if
+      # not specified
+      def row_hierarchy
+        read_attribute(:row_hierarchy) || row_dimension_class.hierarchies.first
+      end
+      
+      # Get the row parameter prefix. Returns 'r' if not specified.
+      def row_param_prefix
+        read_attribute(: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 read_attribute(:fact_attributes) if read_attribute(:fact_attributes)
+        fa = []
+        fact_class.aggregate_fields.each { |field| fa << field }
+        fact_class.calculated_fields.each { |field| fa << field }
+        fa
+      end
+      
+      def column_filters
+        @column_filters ||= {}
+      end
+      
+      def row_filters
+        @row_filters ||= {}
+      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

data/activewarehouse/lib/active_warehouse/report/chart_report.rb

@@ -0,0 +1,9 @@
+module ActiveWarehouse #:nodoc:
+  module Report #:nodoc:
+    class ChartReport < ActiveRecord::Base #:nodoc:
+      include AbstractReport
+      before_save :to_storage
+      after_save :from_storage
+    end
+  end
+end

data/activewarehouse/lib/active_warehouse/report/data_cell.rb

@@ -0,0 +1,21 @@
+module ActiveWarehouse
+	module Report
+
+		class DataCell
+			
+			attr_accessor :column_dimension_value, :row_dimension_value, :fact_attribute, :raw_value, :value
+			
+			def initialize(column_dimension_value, row_dimension_value, fact_attribute, raw_value, value)
+				@column_dimension_value = column_dimension_value 
+				@row_dimension_value = row_dimension_value
+				@fact_attribute = fact_attribute 
+				@raw_value = raw_value
+				@value = value
+			end
+			
+			def key
+				"#{column_dimension_value}_#{fact_attribute.label}".gsub(' ', '_').downcase
+			end			
+		end
+	end
+end