alf 0.9.3 → 0.10.0

data/lib/alf/operator/relational/extend.rb

@@ -0,0 +1,24 @@
+module Alf
+  module Operator::Relational
+    class Extend < Alf::Operator()
+      include Operator::Relational, Operator::Transform
+  
+      signature do |s|
+        s.argument :ext, TupleComputation, {}
+      end
+      
+      protected 
+    
+      # (see Operator#_prepare)
+      def _prepare
+        @handle = TupleHandle.new
+      end
+  
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        tuple.merge @ext.evaluate(@handle.set(tuple))
+      end
+  
+    end # class Extend
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/group.rb

@@ -0,0 +1,32 @@
+module Alf
+  module Operator::Relational
+    class Group < Alf::Operator()
+      include Operator::Relational, Operator::Unary
+      
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.argument :as,         AttrName, :group
+        s.option   :allbut,     Boolean,  false, 'Group all but specified attributes?'
+      end
+      
+      protected 
+  
+      # See Operator#_prepare
+      def _prepare
+        @index = Hash.new{|h,k| h[k] = Set.new} 
+        each_input_tuple do |tuple|
+          key, rest = @attributes.split(tuple, !@allbut)
+          @index[key] << rest
+        end
+      end
+  
+      # See Operator#_each
+      def _each
+        @index.each_pair do |k,v|
+          yield(k.merge(@as => Relation.coerce(v)))
+        end
+      end
+  
+    end # class Group
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/intersect.rb

@@ -0,0 +1,37 @@
+module Alf
+  module Operator::Relational
+    class Intersect < Alf::Operator()
+      include Operator, Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      class HashBased
+        include Operator, Operator::Binary
+      
+        protected
+        
+        def _prepare
+          @index = Hash.new
+          right.each{|t| @index[t] = true}
+        end
+        
+        def _each
+          left.each do |left_tuple|
+            yield(left_tuple) if @index.has_key?(left_tuple)
+          end
+        end
+        
+      end
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain HashBased.new,
+              datasets 
+      end
+      
+    end # class Intersect
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/join.rb

@@ -0,0 +1,106 @@
+module Alf
+  module Operator::Relational
+    class Join < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      #
+      # Performs a Join of two relations through a Hash buffer on the right
+      # one.
+      #
+      class HashBased
+        include Operator, Operator::Binary
+      
+        #
+        # Implements a special Buffer for join-based relational operators.
+        #
+        # Example:
+        #
+        #   buffer = Buffer::Join.new(...) # pass the right part of the join
+        #   left.each do |left_tuple|
+        #     key, rest = buffer.split(tuple)
+        #     buffer.each(key) do |right_tuple|
+        #       #
+        #       # do whatever you want with left and right tuples
+        #       #
+        #     end
+        #   end 
+        #
+        class JoinBuffer
+          include Tools
+          
+          #
+          # Creates a buffer instance with the right part of the join.
+          #
+          # @param [Iterator] enum a tuple iterator, right part of the join. 
+          #
+          def initialize(enum)
+            @buffer = nil
+            @key = nil
+            @enum = enum
+          end
+          
+          #
+          # Splits a left tuple according to the common key.
+          #
+          # @param [Hash] tuple a left tuple of the join
+          # @return [Array] an array of two elements, the key and the rest
+          # @see AttrList#split
+          #
+          def split(tuple)
+            _init(tuple) unless @key
+            @key.split(tuple)
+          end
+          
+          #
+          # Yields each right tuple that matches a given key value.
+          #
+          # @param [Hash] key a tuple that matches elements of the common key
+          #        (typically the first element returned by #split) 
+          #
+          def each(key)
+            @buffer[key].each(&Proc.new) if @buffer.has_key?(key)
+          end
+          
+          private
+          
+          # Initialize the buffer with a right tuple
+          def _init(right)
+            @buffer = Hash.new{|h,k| h[k] = []}
+            @enum.each do |left|
+              @key ||= coerce(left.keys & right.keys, AttrList)
+              @buffer[@key.project(left)] << left
+            end
+            @key ||= coerce([], AttrList)
+          end
+          
+        end # class JoinBuffer
+        
+        protected
+        
+        # (see Operator#_each)
+        def _each
+          buffer = JoinBuffer.new(right)
+          left.each do |left_tuple|
+            key, rest = buffer.split(left_tuple)
+            buffer.each(key) do |right|
+              yield(left_tuple.merge(right))
+            end
+          end
+        end
+        
+      end
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain HashBased.new,
+              datasets 
+      end
+      
+    end # class Join
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/matching.rb

@@ -0,0 +1,45 @@
+module Alf
+  module Operator::Relational
+    class Matching < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      #
+      # Performs a Matching of two relations through a Hash buffer on the right
+      # one.
+      #
+      class HashBased
+        include Operator, Operator::Binary
+      
+        # (see Operator#_each)
+        def _each
+          seen, key = nil, nil
+          left.each do |left_tuple|
+            seen ||= begin
+              h = Hash.new
+              right.each do |right_tuple|
+                key ||= coerce(left_tuple.keys & right_tuple.keys, AttrList)
+                h[key.project(right_tuple)] = true
+              end
+              key ||= coerce([], AttrList)
+              h
+            end
+            yield(left_tuple) if seen.has_key?(key.project(left_tuple))
+          end
+        end
+        
+      end # class HashBased
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain HashBased.new,
+              datasets 
+      end
+      
+    end # class Matching
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/minus.rb

@@ -0,0 +1,37 @@
+module Alf
+  module Operator::Relational
+    class Minus < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      class HashBased
+        include Operator, Operator::Binary
+      
+        protected
+        
+        def _prepare
+          @index = Hash.new
+          right.each{|t| @index[t] = true}
+        end
+        
+        def _each
+          left.each do |left_tuple|
+            yield(left_tuple) unless @index.has_key?(left_tuple)
+          end
+        end
+        
+      end
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain HashBased.new,
+              datasets 
+      end
+      
+    end # class Minus
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/not_matching.rb

@@ -0,0 +1,45 @@
+module Alf
+  module Operator::Relational
+    class NotMatching < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      #
+      # Performs a NotMatching of two relations through a Hash buffer on the 
+      # right one.
+      #
+      class HashBased
+        include Operator, Operator::Binary
+      
+        # (see Operator#_each)
+        def _each
+          seen, key = nil, nil
+          left.each do |left_tuple|
+            seen ||= begin
+              h = Hash.new
+              right.each do |right_tuple|
+                key ||= coerce(left_tuple.keys & right_tuple.keys, AttrList)
+                h[key.project(right_tuple)] = true
+              end
+              key ||= coerce([], AttrList)
+              h
+            end
+            yield(left_tuple) unless seen.has_key?(key.project(left_tuple))
+          end
+        end
+        
+      end # class HashBased
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain HashBased.new,
+              datasets 
+      end
+      
+    end # class NotMatching
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/project.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Operator::Relational
+    class Project < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Unary
+    
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.option   :allbut,     Boolean,  false, 'Project all but specified attributes?'
+      end
+      
+      protected 
+    
+      # (see Operator::Shortcut#longexpr)
+      def longexpr
+        chain Operator::NonRelational::Compact.new,
+              Operator::NonRelational::Clip.new(@attributes, {:allbut => @allbut}),
+              datasets
+      end
+    
+    end # class Project
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/quota.rb

@@ -0,0 +1,51 @@
+module Alf
+  module Operator::Relational
+    class Quota < Alf::Operator()
+      include Operator::Relational, Operator::Experimental,
+              Operator::Shortcut, Operator::Unary
+  
+      signature do |s|
+        s.argument :by,            AttrList, []
+        s.argument :order,         Ordering, []
+        s.argument :summarization, Summarization, {}
+      end
+      
+      class SortBased
+        include Operator, Operator::Cesure
+        
+        def initialize(by, order, summarization)
+          @by, @order, @summarization  = by, order, summarization
+        end
+        
+        protected
+        
+        # (see Operator::Cesure#project)
+        def project(tuple)
+          @by.project(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
+  
+      end # class SortBased
+  
+      protected
+      
+      def longexpr
+        sort_key = @by.to_ordering + @order
+        chain SortBased.new(@by, @order, @summarization),
+              Operator::NonRelational::Sort.new(sort_key),
+              datasets
+      end 
+  
+    end # class Quota
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/rank.rb

@@ -0,0 +1,55 @@
+module Alf
+  module Operator::Relational
+    class Rank < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Unary
+  
+      signature do |s|
+        s.argument :order, Ordering, []
+        s.argument :as, AttrName, :rank
+      end
+      
+      class SortBased
+        include Operator, Operator::Cesure
+        
+        def initialize(order, as)
+          @by_key = AttrList.coerce(order)
+          @as = as
+        end
+        
+        protected
+        
+        # (see Operator::Cesure#project)
+        def project(tuple)
+          @by_key.project(tuple, false)
+        end
+    
+        # (see Operator::Cesure#start_cesure)
+        def start_cesure(key, receiver)
+          @rank ||= 0
+          @last_block = 0
+        end
+  
+        # (see Operator::Cesure#accumulate_cesure)
+        def accumulate_cesure(tuple, receiver)
+          receiver.call tuple.merge(@as => @rank)
+          @last_block += 1
+        end
+        
+        # (see Operator::Cesure#flush_cesure)
+        def flush_cesure(key, receiver)
+          @rank += @last_block
+        end
+  
+      end # class SortBased
+  
+      protected
+      
+      def longexpr
+        chain SortBased.new(@order, @as),
+              Operator::NonRelational::Sort.new(@order),
+              datasets
+      end 
+  
+    end # class Rank
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/rename.rb

@@ -0,0 +1,19 @@
+module Alf
+  module Operator::Relational
+    class Rename < Alf::Operator()
+      include Operator::Relational, Operator::Transform
+  
+      signature do |s|
+        s.argument :renaming, Renaming, {}
+      end
+      
+      protected 
+    
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        @renaming.apply(tuple)
+      end
+  
+    end # class Rename
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/restrict.rb

@@ -0,0 +1,20 @@
+module Alf
+  module Operator::Relational
+    class Restrict < Alf::Operator()
+      include Operator::Relational, Operator::Unary
+      
+      signature do |s|
+        s.argument :predicate, TuplePredicate, "true"
+      end
+      
+      protected 
+    
+      # (see Operator#_each)
+      def _each
+        handle = TupleHandle.new
+        each_input_tuple{|t| yield(t) if @predicate.evaluate(handle.set(t)) }
+      end
+  
+    end # class Restrict
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/summarize.rb

@@ -0,0 +1,83 @@
+module Alf
+  module Operator::Relational
+    class Summarize < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Unary
+      
+      signature do |s|
+        s.argument :by,            AttrList, []
+        s.argument :summarization, Summarization, {}
+        s.option   :allbut,        Boolean, false, "Summarize on all but specified attributes?"
+      end
+      
+      # Summarizes according to a complete order
+      class SortBased
+        include Operator, Operator::Cesure
+  
+        def initialize(by_key, allbut, summarization)
+          @by_key, @allbut, @summarization = by_key, allbut, summarization
+        end
+  
+        protected 
+  
+        # (see Operator::Cesure#project)
+        def project(tuple)
+          @by_key.project(tuple, @allbut)
+        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)
+        end
+  
+        # (see Operator::Cesure#flush_cesure)
+        def flush_cesure(key, receiver)
+          @aggs = @summarization.finalize(@aggs)
+          receiver.call key.merge(@aggs)
+        end
+  
+      end # class SortBased
+
+      # Summarizes in-memory with a hash
+      class HashBased
+        include Operator, Operator::Relational, Operator::Unary
+  
+        def initialize(by_key, allbut, summarization)
+          @by_key, @allbut, @summarization = by_key, allbut, summarization
+        end
+
+        protected
+        
+        def _each
+          index = Hash.new{|h,k| @summarization.least}
+          each_input_tuple do |tuple|
+            key, rest = @by_key.split(tuple, @allbut)
+            index[key] = @summarization.happens(index[key], tuple)
+          end
+          index.each_pair do |key,aggs|
+            yield key.merge(@summarization.finalize(aggs))
+          end
+        end
+      
+      end
+        
+      protected 
+      
+      def longexpr
+        if @allbut
+          chain HashBased.new(@by, @allbut, @summarization),
+                datasets
+        else
+          chain SortBased.new(@by, @allbut, @summarization),
+                Operator::NonRelational::Sort.new(@by.to_ordering),
+                datasets
+        end
+      end
+  
+    end # class Summarize
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/ungroup.rb

@@ -0,0 +1,25 @@
+module Alf
+  module Operator::Relational
+    class Ungroup < Alf::Operator()
+      include Operator::Relational, Operator::Unary
+      
+      signature do |s|
+        s.argument :attr, AttrName, :grouped
+      end
+      
+      protected 
+  
+      # See Operator#_each
+      def _each
+        each_input_tuple do |tuple|
+          tuple = tuple.dup
+          subrel = tuple.delete(@attr)
+          subrel.each do |subtuple|
+            yield(tuple.merge(subtuple))
+          end
+        end
+      end
+  
+    end # class Ungroup
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/union.rb

@@ -0,0 +1,32 @@
+module Alf
+  module Operator::Relational
+    class Union < Alf::Operator()
+      include Operator::Relational, Operator::Shortcut, Operator::Binary
+      
+      signature do |s|
+      end
+      
+      class DisjointBased
+        include Operator, Operator::Binary
+      
+        protected
+        
+        def _each
+          left.each(&Proc.new)
+          right.each(&Proc.new)
+        end
+        
+      end
+      
+      protected
+      
+      # (see Shortcut#longexpr)
+      def longexpr
+        chain Operator::NonRelational::Compact.new,
+              DisjointBased.new,
+              datasets 
+      end
+      
+    end # class Union
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/unwrap.rb

@@ -0,0 +1,21 @@
+module Alf
+  module Operator::Relational
+    class Unwrap < Alf::Operator()
+      include Operator::Relational, Operator::Transform
+  
+      signature do |s|
+        s.argument :attr, AttrName, :wrapped
+      end
+      
+      protected 
+  
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        tuple = tuple.dup
+        wrapped = tuple.delete(@attr) || {}
+        tuple.merge(wrapped)
+      end
+  
+    end # class Unwrap
+  end # module Operator::Relational
+end # module Alf

data/lib/alf/operator/relational/wrap.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Operator::Relational
+    class Wrap < Alf::Operator()
+      include Operator::Relational, Operator::Transform
+  
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.argument :as, AttrName, :wrapped
+      end
+      
+      protected 
+  
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        wrapped, others = @attributes.split(tuple)
+        others[@as] = wrapped
+        others
+      end
+  
+    end # class Wrap
+  end # module Operator::Relational
+end # module Alf