alf-core 0.13.0

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

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

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

@@ -0,0 +1,48 @@
+module Alf
+  module Engine
+    class Quota::Cesure
+      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 Quota::Cesure instance
+      def initialize(operand, by, summarization)
+        @operand = operand
+        @by = by.to_attr_list
+        @summarization = summarization
+      end
+
+      protected
+
+      # (see Cesure#project)
+      def project(tuple)
+        @by.project_tuple(tuple, false)
+      end
+
+      # (see Cesure#start_cesure)
+      def start_cesure(key, receiver)
+        @scope = tuple_scope unless @scope
+        @aggs  = @summarization.least
+      end
+
+      # (see Cesure#accumulate_cesure)
+      def accumulate_cesure(tuple, receiver)
+        @aggs = @summarization.happens(@aggs, @scope.__set_tuple(tuple))
+        receiver.call tuple.merge(@summarization.finalize(@aggs))
+      end
+
+      # (see Cesure#flush_cesure)
+      def flush_cesure(key, receiver)
+        @scope = nil
+      end
+
+    end # class Quota::Cesure
+  end # module Engine
+end # module Alf

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

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

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

@@ -0,0 +1,48 @@
+module Alf
+  module Engine
+    class Rank::Cesure
+      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 Rank::Cesure 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/rename.rb

@@ -0,0 +1,40 @@
+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
+      include 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.rb

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

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

@@ -0,0 +1,40 @@
+module Alf
+  module Engine
+    #
+    # Filters tuples from `left` that match or do not match tuples from `right`.
+    #
+    class Semi::Hash
+      include 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)
+          }, false).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/set_attr.rb

@@ -0,0 +1,47 @@
+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
+      include 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
+        scope = tuple_scope
+        operand.each do |tuple|
+          computed = @computation.evaluate(scope.__set_tuple(tuple))
+          yield tuple.merge(computed)
+        end
+      end
+
+    end # class SetAttr
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,29 @@
+module Alf
+  module Engine
+    #
+    # Sort its operand according to an ordering information.
+    #
+    class Sort
+      include 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/sort/in_memory.rb

@@ -0,0 +1,40 @@
+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
+      include 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/summarize.rb

@@ -0,0 +1,4 @@
+module Alf::Engine::Summarize
+end
+require_relative 'summarize/cesure'
+require_relative 'summarize/hash'

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

@@ -0,0 +1,54 @@
+module Alf
+  module Engine
+    class Summarize::Cesure
+      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 Summarize::Cesure 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)
+        @scope = tuple_scope unless @scope
+        @aggs  = @summarization.least
+      end
+
+      # (see Cesure#accumulate_cesure)
+      def accumulate_cesure(tuple, receiver)
+        @aggs = @summarization.happens(@aggs, @scope.__set_tuple(tuple))
+      end
+
+      # (see Cesure#flush_cesure)
+      def flush_cesure(key, receiver)
+        @aggs = @summarization.finalize(@aggs)
+        result = receiver.call key.merge(@aggs)
+        @scope = nil
+        result
+      end
+
+    end # class Summarize::Cesure
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,36 @@
+module Alf
+  module Engine
+    class Summarize::Hash
+      include Cog
+
+      # @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 Summarize::Hash instance
+      def initialize(operand, by, summarization, allbut)
+        @operand = operand
+        @by = by
+        @summarization = summarization
+        @allbut = allbut
+      end
+
+      # (see Cog#each)
+      def _each
+        index = Materialize::Hash.new(operand, by, allbut)
+        index.each_pair do |k, v|
+          yield k.merge(summarization.summarize(v))
+        end
+      end
+
+    end # class Summarize::Cesure
+  end # module Engine
+end # module Alf

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

@@ -0,0 +1,62 @@
+module Alf
+  module Engine
+    #
+    # Ensures an order of tuples, recursing on relation value attributes, that are
+    # converted as arrays as well.
+    #
+    # Example:
+    #
+    #   res = [
+    #     {:price => 12.0, :rva => Relation(...)},
+    #     {:price => 10.0, :rva => Relation(...)}
+    #   ]
+    #   ToArray.new(res, [:price, :asc]).to_a
+    #   # => [
+    #   #      {:price => 10.0, :rva => [...] },
+    #   #      {:price => 12.0, :rva => [...] }
+    #   #    ]
+    #
+    class ToArray
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [Ordering] The ordering info
+      attr_reader :ordering
+
+      # Creates an ToArray instance
+      def initialize(operand, ordering)
+        @operand = operand
+        @ordering = ordering
+      end
+
+      # (see Cog#each)
+      def _each(&block)
+        Sort.new(operand, ordering).each do |tuple|
+          yield recurse(tuple)
+        end
+      end
+
+    private
+
+      def recurse(tuple)
+        case tuple
+        when Hash
+          Hash[tuple.map{|k,v| [k, reorder(v)] }]
+        when Tuple
+          tuple.remap{|k,v| reorder(v) }
+        end
+      end
+
+      def reorder(value)
+        if RelationLike===value
+          ToArray.new(value, ordering).to_a
+        else
+          value
+        end
+      end
+
+    end # class ToArray
+  end # module Engine
+end # module Alf