alf 0.10.1 → 0.11.0

data/lib/alf-engine/alf/engine/group/hash.rb

@@ -0,0 +1,40 @@
+module Alf
+  module Engine
+    #
+    # Provides hash-based grouping.
+    #
+    class Group::Hash < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Attributes to group
+      attr_reader :attributes
+
+      # @return [AttrName] Name of the new attribute
+      attr_reader :as
+
+      # @return [Boolean] Group all but specified attributes?
+      attr_reader :allbut
+
+      # Creates a Group::Hash instance
+      def initialize(operand, attributes, as, allbut)
+        @operand = operand
+        @attributes = attributes
+        @as = as
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        atr, alb = @attributes, @allbut
+        index = Materialize::Hash.new(operand, atr, !alb)
+        index.each_pair do |k,v|
+          grouped = Relation.new(Clip.new(v, atr, alb).to_set)
+          yield k.merge(@as => grouped)
+        end
+      end
+
+    end # class Group::Hash
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/group.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Group
+    end # module Group
+  end # module Engine
+end # module Alf
+require_relative 'group/hash'

data/lib/alf-engine/alf/engine/join/hash.rb

@@ -0,0 +1,35 @@
+module Alf
+  module Engine
+    #
+    # Provides hash-based join.
+    #
+    class Join::Hash < Cog
+
+      # @return [Enumerable] The left operand
+      attr_reader :left
+
+      # @return [Enumerable] The right operand
+      attr_reader :right
+
+      # Creates a Join::Hash instance
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        index = nil
+        left.each do |left_tuple|
+          index ||= Materialize::Hash.new(right, lambda{|t|
+            AttrList.new(left_tuple.keys & t.keys)
+          }).prepare
+          index[left_tuple, true].each do |right_tuple|
+            yield left_tuple.merge(right_tuple)
+          end
+        end
+      end
+
+    end # class Hash
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/join.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Join
+    end # module Join
+  end # module Engine
+end # module Alf
+require_relative 'join/hash'

data/lib/alf-engine/alf/engine/materialize/array.rb

@@ -0,0 +1,78 @@
+module Alf
+  module Engine
+    #
+    # Provides in-memory materialization through a ruby Array.
+    #
+    # This class acts as a Cog, that it, it is an enumerable of tuples. An 
+    # optional ordering can be passed at construction.
+    # 
+    # Materialization occurs at prepare time, with auto-prepare on first 
+    # access.
+    #
+    # Example:
+    #
+    #     rel = [
+    #       {:name => "Jones", :city => "London"},
+    #       {:name => "Smith", :city => "Paris"},
+    #       {:name => "Blake", :city => "London"}
+    #     ]
+    #     
+    #     Materialize::Array.new(rel).to_a
+    #     # => same as rel, in same order as the source
+    #     
+    #     Materialize::Array.new(rel, Ordering[[:name, :asc]]).to_a
+    #     # => [
+    #            {:name => "Blake", :city => "London"},
+    #            {:name => "Jones", :city => "London"},
+    #            {:name => "Smith", :city => "Paris"}
+    #          ]
+    #
+    class Materialize::Array < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Ordering] Ordering to ensure (optional)
+      attr_reader :ordering
+
+      # Creates a Materialize::Array instance
+      def initialize(operand, ordering = nil)
+        @operand = operand
+        @ordering = ordering
+        @materialized = nil
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        materialized.each(&block)
+      end
+
+      # (see Cog#prepare)
+      #
+      # Prepare through materialization of the operand as an ordered array
+      def prepare
+        @materialized ||= begin
+          arr = operand.to_a
+          arr.sort!(&ordering.sorter) if ordering
+          arr
+        end
+      end
+
+      # (see Cog#free)
+      #
+      # Frees the materizalied hash
+      def clean
+        @materialized = nil
+      end
+
+      private 
+
+      # @return [Array] the materialized array
+      def materialized
+        prepare
+        @materialized
+      end
+
+    end # class Materialize::Array
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/materialize/hash.rb

@@ -0,0 +1,122 @@
+module Alf
+  module Engine
+    #
+    # Provides in-memory materialization through a ruby Hash.
+    #
+    # This class acts as a Cog, that it, it is an enumerable of tuples. No 
+    # particular ordering is guaranteed. In addition, the class provides 
+    # indexed access through the `[]` method. 
+    # 
+    # Materialization occurs at prepare time, with auto-prepare on first 
+    # access.
+    #
+    # Example:
+    #
+    #     rel = [
+    #       {:name => "Jones", :city => "London"},
+    #       {:name => "Smith", :city => "Paris"},
+    #       {:name => "Blake", :city => "London"}
+    #     ]
+    #     op = Materialize::Hash.new(rel, AttrList[:city])
+    #
+    #     op.to_a 
+    #     # => same as rel, no ordering guaranteed
+    #
+    #     op[:city => "London"].to_a
+    #     # => [
+    #            {:name => "Jones", :city => "London"},
+    #            {:name => "Blake", :city => "London"}
+    #          ]
+    #
+    #     op[:city => "London"].to_a
+    #     # => [
+    #            {:name => "Jones", :city => "London"},
+    #            {:name => "Blake", :city => "London"}
+    #          ]
+    #
+    #     op[:city => "Athens"].to_a
+    #     # => []
+    #
+    class Materialize::Hash < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Attributes for the hash key
+      attr_reader :key
+
+      # @return [Boolean] Hash on all but specified attributes?
+      attr_reader :allbut
+
+      # Creates a Materialize::Hash instance
+      def initialize(operand, key, allbut = false)
+        @operand = operand
+        @key = key
+        @allbut = allbut
+        @materialized = nil
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        materialized.each_value do |rel|
+          rel.each(&block)
+        end
+      end
+
+      # Yields indexed (key, tuples) pairs in turn.
+      def each_pair(&block)
+        materialized.each_pair(&block)
+      end
+
+      # Returns tuples that match a given key.
+      #
+      # This method returns a Cog instance in all case. En empty Cog is 
+      # returned if no tuples match the key.
+      #
+      # @param [Tuple] key_tuple a key tuple
+      # @param [Boolean] project project `key_tuple` on key first?
+      # @return [Cog] the tuples from operand that match `key_tuple`
+      def [](key_tuple, project = false)
+        key_tuple = key_for(key_tuple) if project
+        m = materialized
+        m.has_key?(key_tuple) ? m[key_tuple] : []
+      end
+
+      # (see Cog#prepare)
+      #
+      # Prepare through materialization of the operand as a hash
+      def prepare
+        @materialized ||= begin
+          h = ::Hash.new{|h,k| h[k] = []}
+          operand.each do |tuple|
+            h[key_for(tuple)] << tuple
+          end
+          h
+        end
+        self
+      end
+
+      # (see Cog#free)
+      #
+      # Frees the materizalied hash
+      def clean
+        @materialized = nil
+      end
+
+      private
+
+      # Projects `tuple` to get the indexing key
+      def key_for(tuple)
+        @key = @key.call(tuple) unless @key.is_a?(AttrList)
+        @key.project_tuple(tuple, @allbut)
+      end
+
+      # @return [Hash] the materialized hash
+      def materialized
+        prepare
+        @materialized
+      end
+
+    end # class Materialize::Hash
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/materialize.rb

@@ -0,0 +1,8 @@
+module Alf
+  module Engine
+    module Materialize
+    end # module Materialize
+  end # module Engine
+end # module Alf
+require_relative 'materialize/hash'
+require_relative 'materialize/array'

data/lib/alf-engine/alf/engine/quota/cesure.rb

@@ -0,0 +1,46 @@
+module Alf
+  module Engine
+    class Quota::Cesure < Cog
+      include Engine::Cesure
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] List of attributes for 'quota by'
+      attr_reader :by
+
+      # @return [Summarization] Quota computations as a summarization
+      attr_reader :summarization
+
+      # Creates an Aggregate instance
+      def initialize(operand, by, summarization)
+        @operand = operand
+        @by = by.to_attr_list
+        @summarization = summarization
+      end
+
+      protected
+
+      # (see Operator::Cesure#project)
+      def project(tuple)
+        @by.project_tuple(tuple, false)
+      end
+
+      # (see Operator::Cesure#start_cesure)
+      def start_cesure(key, receiver)
+        @aggs = @summarization.least
+      end
+
+      # (see Operator::Cesure#accumulate_cesure)
+      def accumulate_cesure(tuple, receiver)
+        @aggs = @summarization.happens(@aggs, tuple)
+        receiver.call tuple.merge(@summarization.finalize(@aggs))
+      end
+
+      # (see Cesure#flush_cesure)
+      def flush_cesure(key, receiver)
+      end
+
+    end # class Quota::Cesure
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/quota.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Quota
+    end # module Quota
+  end # module Engine
+end # module Alf
+require_relative 'quota/cesure'

data/lib/alf-engine/alf/engine/rank/cesure.rb

@@ -0,0 +1,48 @@
+module Alf
+  module Engine
+    class Rank::Cesure < Cog
+      include Engine::Cesure
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] List of attributes that form the operand ordering
+      attr_reader :by
+
+      # @return [AttrName] Name of the introduced attribute
+      attr_reader :as
+
+      # Creates an Aggregate instance
+      def initialize(operand, by, as)
+        @operand = operand
+        @by = by.to_attr_list
+        @as = as
+      end
+
+      protected
+
+      # (see Cesure#project)
+      def project(tuple)
+        @by.project_tuple(tuple, false)
+      end
+
+      # (see Cesure#start_cesure)
+      def start_cesure(key, receiver)
+        @rank ||= 0
+        @last_block = 0
+      end
+
+      # (see Cesure#accumulate_cesure)
+      def accumulate_cesure(tuple, receiver)
+        receiver.call tuple.merge(@as => @rank)
+        @last_block += 1
+      end
+
+      # (see Cesure#flush_cesure)
+      def flush_cesure(key, receiver)
+        @rank += @last_block
+      end
+
+    end # class Rank::Cesure
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/rank.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Rank
+    end # module Rank
+  end # module Engine
+end # module Alf
+require_relative 'rank/cesure'

data/lib/alf-engine/alf/engine/rename.rb

@@ -0,0 +1,39 @@
+module Alf
+  module Engine
+    #
+    # Renames tuples from the operand according to a Renaming info.
+    # 
+    # Example:
+    #
+    #     rel = [
+    #       {:name => "Jones", :city => "London"}
+    #     ]
+    #     Rename.new(rel, Renaming[:name => :last_name]).to_a
+    #     # => [
+    #     #      {:last_name => "Jones", :city => "London"}
+    #     #    ]
+    #
+    class Rename < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Renaming] Renaming info
+      attr_reader :renaming
+
+      # Creates a Rename instance
+      def initialize(operand, renaming)
+        @operand = operand
+        @renaming = renaming
+      end
+
+      # (see Cog#each)
+      def each
+        operand.each do |tuple|
+          yield @renaming.rename_tuple(tuple)
+        end
+      end
+
+    end # class Rename
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/semi/hash.rb

@@ -0,0 +1,39 @@
+module Alf
+  module Engine
+    #
+    # Filters tuples from `left` that match or do not match tuples from `right`.
+    #
+    class Semi::Hash < Cog
+
+      # @return [Enumerable] The left operand
+      attr_reader :left
+
+      # @return [Enumerable] The right operand
+      attr_reader :right
+
+      # @return [Boolean] Match (true) or not match (false)?
+      attr_reader :predicate
+
+      # Creates a Semi::Hash instance
+      def initialize(left, right, predicate)
+        @left = left
+        @right = right
+        @predicate = predicate
+      end
+
+      # (see Cog#each)
+      def each
+        index = nil
+        left.each do |left_tuple|
+          index ||= Materialize::Hash.new(right, lambda{|t|
+            AttrList.new(left_tuple.keys & t.keys)
+          }).prepare
+          if index[left_tuple, true].empty? != predicate
+            yield left_tuple 
+          end
+        end
+      end
+
+    end # class Semi::Hash
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/semi.rb

@@ -0,0 +1,7 @@
+module Alf
+  module Engine
+    module Semi
+    end # module Semi
+  end # module Engine
+end # module Alf
+require_relative 'semi/hash'

data/lib/alf-engine/alf/engine/set_attr.rb

@@ -0,0 +1,46 @@
+module Alf
+  module Engine
+    #
+    # Set computed tuples attributes. This cog allows implementing both
+    # EXTEND and UPDATE relational operators.
+    # 
+    # Example:
+    #
+    #     rel = [
+    #       {:name => "Jones", :city => "London"}
+    #     ]
+    #     comp = TupleComputation[
+    #       :city   => lambda{ city.upcase },
+    #       :concat => lambda{ "#{name} #{city}" }
+    #     ]
+    #     SetAttr.new(rel, comp).to_a
+    #     # => [
+    #     #      {:name => "Jones", :city => "LONDON", :concat => "Jones LONDON"}
+    #     #    ]
+    #
+    class SetAttr < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [TupleComputation] Computed attributes as a computation
+      attr_reader :computation
+
+      # Creates a SetAttr instance
+      def initialize(operand, computation)
+        @operand = operand
+        @computation = computation
+      end
+
+      # (see Cog#each)
+      def each
+        handle = Tools::TupleHandle.new
+        operand.each do |tuple|
+          computed = @computation.evaluate(handle.set(tuple))
+          yield tuple.merge(computed){|k,v1,v2| v2}
+        end
+      end
+
+    end # class SetAttr
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/sort/in_memory.rb

@@ -0,0 +1,39 @@
+module Alf
+  module Engine
+    #
+    # Implement an in-memory sort, relying on `to_a.sort!`
+    #
+    # Example:
+    #
+    #     rel = [
+    #       {:name => "Smith"},
+    #       {:name => "Jones"}
+    #     ]
+    #     Sort.new(rel, Ordering[[:name, :asc]]).to_a
+    #     # => [
+    #     #      {:name => "Jones"}
+    #     #      {:name => "Smith"},
+    #     #    ]
+    #
+    class Sort::InMemory < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Ordering] The ordering info
+      attr_reader :ordering
+
+      # Creates an Autonum instance
+      def initialize(operand, ordering)
+        @operand = operand
+        @ordering = ordering
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        operand.to_a.sort!(&ordering.sorter).each(&block)
+      end
+
+    end # class Sort::InMemory
+  end # module Engine
+end # module Alf

data/lib/alf-engine/alf/engine/sort.rb

@@ -0,0 +1,28 @@
+module Alf
+  module Engine
+    #
+    # Sort its operand according to an ordering information.
+    #
+    class Sort < Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Ordering] The ordering info
+      attr_reader :ordering
+
+      # Creates an Autonum instance
+      def initialize(operand, ordering)
+        @operand = operand
+        @ordering = ordering
+      end
+
+      # (see Cog#each)
+      def each(&block)
+        Sort::InMemory.new(operand, ordering).each(&block)
+      end
+
+    end # class Sort
+  end # module Engine
+end # module Alf
+require_relative 'sort/in_memory'

data/lib/alf-engine/alf/engine/summarize/cesure.rb

@@ -0,0 +1,51 @@
+module Alf
+  module Engine
+    class Summarize::Cesure < Cog
+      include Engine::Cesure
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Summarization key
+      attr_reader :by
+
+      # @return [Summarization] The summarization to use
+      attr_reader :summarization
+
+      # @return [Boolean] Make an allbut summarization?
+      attr_reader :allbut
+
+      # Creates an Aggregate instance
+      def initialize(operand, by, summarization, allbut)
+        @operand = operand
+        @by = by
+        @summarization = summarization
+        @allbut = allbut
+      end
+
+      protected
+
+      # (see Cesure#project)
+      def project(tuple)
+        @by.project_tuple(tuple, @allbut)
+      end
+      
+      # (see Cesure#start_cesure)
+      def start_cesure(key, receiver)
+        @aggs = @summarization.least
+      end
+
+      # (see Cesure#accumulate_cesure)
+      def accumulate_cesure(tuple, receiver)
+        @aggs = @summarization.happens(@aggs, tuple)
+      end
+
+      # (see Cesure#flush_cesure)
+      def flush_cesure(key, receiver)
+        @aggs = @summarization.finalize(@aggs)
+        receiver.call key.merge(@aggs)
+      end
+
+    end # class Summarize::Cesure
+  end # module Engine
+end # module Alf