alf 0.10.1 → 0.11.0

data/lib/alf/operator/non_relational/generator.rb

@@ -1,38 +1,20 @@
 module Alf
-  module Operator::NonRelational
-    class Generator < Alf::Operator()
-      include Operator::NonRelational, Operator::Nullary
-
-      class Size < Integer
-        extend Myrrha::Domain
-
-        def self.coerce(args)
-          Tools.coerce(args, Integer)
-        end
-
-        def self.from_argv(argv, opts = {})
-          coerce(argv.first)
+  module Operator
+    module NonRelational
+      class Generator
+        include NonRelational, Nullary
+
+        signature do |s|
+          s.argument :size, Size, 10
+          s.argument :as,   AttrName, :num
         end
 
-        def self.predicate
-          @predicate ||= lambda{|i| i >= 0}
-        end
-
-      end # Size
-
-      signature do |s|
-        s.argument :size, Size, 10
-        s.argument :as,   AttrName, :num
-      end
-          
-      protected
-
-      def _each
-        size.times do |i|
-          yield(@as => i+1)
+        # (see Operator#compile)
+        def compile
+          Engine::Generator.new(as, 1, 1, size)
         end
-      end
 
-    end # class Generator
-  end # module Operator::NonRelational
+      end # class Generator
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/non_relational/sort.rb

@@ -1,23 +1,19 @@
 module Alf
-  module Operator::NonRelational
-    class Sort < Alf::Operator()
-      include Operator::NonRelational, Operator::Unary
+  module Operator
+    module NonRelational
+      class Sort
+        include NonRelational, Unary
 
-      signature do |s|
-        s.argument :ordering, Ordering, []
-      end
-          
-      protected 
-    
-      def _prepare
-        @buffer = Buffer::Sorted.new(ordering)
-        @buffer.add_all(input)
-      end
-    
-      def _each
-        @buffer.each(&Proc.new)
-      end
-    
-    end # class Sort
-  end # module Operator::NonRelational
+        signature do |s|
+          s.argument :ordering, Ordering, []
+        end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Sort.new(operand, ordering)
+        end
+
+      end # class Sort
+    end # module NonRelational
+  end # module Operator
 end # module Alf

data/lib/alf/operator/nullary.rb

@@ -5,15 +5,6 @@ module Alf
     #
     module Nullary
       include Operator 
-      
-      # 
-      # Sets the operator input
-      #
-      def pipe(input, env = environment)
-        self.environment = env
-        self.datasets = []
-        self
-      end
 
     end # module Nullary
   end # module Operator

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

@@ -1,24 +1,19 @@
 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
+  module Operator
+    module Relational
+      class Extend
+        include Relational, Unary
+
+        signature do |s|
+          s.argument :ext, TupleComputation, {}
+        end
+
+        # (see Operator#compile)
+        def compile
+          Engine::SetAttr.new(operand, ext)
+        end
+
+      end # class Extend
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,32 +1,21 @@
 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
+  module Operator
+    module Relational
+      class Group
+        include Relational, Unary
+
+        signature do |s|
+          s.argument :attributes, AttrList, []
+          s.argument :as,         AttrName, :group
+          s.option   :allbut,     Boolean,  false, 'Group all but specified attributes?'
         end
-      end
-  
-      # See Operator#_each
-      def _each
-        @index.each_pair do |k,v|
-          yield(k.merge(@as => Relation.coerce(v)))
+
+        # (see Operator#compile)
+        def compile
+          Engine::Group::Hash.new(operand, attributes, as, allbut)
         end
-      end
   
-    end # class Group
-  end # module Operator::Relational
+      end # class Group
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,30 +1,20 @@
 module Alf
-  module Operator::Relational
-    class Heading < Alf::Operator()
-      include Operator::Relational, 
-              Operator::Experimental,
-              Operator::Unary
-    
-      signature do |s|
-      end
+  module Operator
+    module Relational
+      class Heading
+        include Relational, Unary, Experimental
+
+        signature do |s|
+        end
       
-      protected 
-    
-      # See Operator#_prepare
-      def _prepare
-        @tuple_heading = nil
-        each_input_tuple do |tuple|
-          h = tuple_heading(tuple)
-          @tuple_heading ||= h
-          @tuple_heading += h
+        # (see Operator#each)
+        def each
+          yield(operand.inject(Alf::Heading::EMPTY){|h,t|
+            h + Tools.tuple_heading(t)
+          }.to_h)
         end
-      end
-
-      # See Operator#_each
-      def _each
-        yield(@tuple_heading.attributes)
-      end
 
-    end # class Project
-  end # module Operator::Relational
+      end # class Project
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,37 +1,18 @@
 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}
+  module Operator
+    module Relational
+      class Intersect
+        include Relational, Binary
+
+        signature do |s|
         end
-        
-        def _each
-          left.each do |left_tuple|
-            yield(left_tuple) if @index.has_key?(left_tuple)
-          end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Join::Hash.new(left, right)
         end
-        
-      end
-      
-      protected
-      
-      # (see Shortcut#longexpr)
-      def longexpr
-        chain HashBased.new,
-              datasets 
-      end
-      
-    end # class Intersect
-  end # module Operator::Relational
+
+      end # class Intersect
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,106 +1,18 @@
 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
+  module Operator
+    module Relational
+      class Join
+        include Relational, Binary
+
+        signature do |s|
         end
-        
-      end
-      
-      protected
-      
-      # (see Shortcut#longexpr)
-      def longexpr
-        chain HashBased.new,
-              datasets 
-      end
-      
-    end # class Join
-  end # module Operator::Relational
+
+        # (see Operator#compile)
+        def compile
+          Engine::Join::Hash.new(left, right)
+        end
+
+      end # class Join
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,45 +1,18 @@
 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
+  module Operator
+    module Relational
+      class Matching
+        include Relational, Binary
+
+        signature do |s|
         end
-        
-      end # class HashBased
-      
-      protected
-      
-      # (see Shortcut#longexpr)
-      def longexpr
-        chain HashBased.new,
-              datasets 
-      end
-      
-    end # class Matching
-  end # module Operator::Relational
+
+        # (see Operator#compile)
+        def compile
+          Engine::Semi::Hash.new(left, right, true)
+        end
+
+      end # class Matching
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,37 +1,18 @@
 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}
+  module Operator
+    module Relational
+      class Minus
+        include Relational, Binary
+
+        signature do |s|
         end
-        
-        def _each
-          left.each do |left_tuple|
-            yield(left_tuple) unless @index.has_key?(left_tuple)
-          end
+
+        # (see Operator#compile)
+        def compile
+          Engine::Semi::Hash.new(left, right, false)
         end
-        
-      end
-      
-      protected
-      
-      # (see Shortcut#longexpr)
-      def longexpr
-        chain HashBased.new,
-              datasets 
-      end
-      
-    end # class Minus
-  end # module Operator::Relational
+
+      end # class Minus
+    end # Relational
+  end # module Operator
 end # module Alf

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

@@ -1,45 +1,18 @@
 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
+  module Operator
+    module Relational
+      class NotMatching
+        include Relational, Binary
+
+        signature do |s|
         end
-        
-      end # class HashBased
-      
-      protected
-      
-      # (see Shortcut#longexpr)
-      def longexpr
-        chain HashBased.new,
-              datasets 
-      end
-      
-    end # class NotMatching
-  end # module Operator::Relational
+
+        # (see Operator#compile)
+        def compile
+          Engine::Semi::Hash.new(left, right, false)
+        end
+
+      end # class NotMatching
+    end # module Relational
+  end # module Operator
 end # module Alf

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

@@ -1,22 +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
+  module Operator
+    module Relational
+      class Project
+        include Relational, Unary
+
+        signature do |s|
+          s.argument :attributes, AttrList, []
+          s.option   :allbut,     Boolean,  false, 'Project all but specified attributes?'
+        end
+
+        # (see Operator#compile)
+        def compile
+          op = Engine::Clip.new(operand, attributes, allbut)
+          op = Engine::Compact.new(op)
+          op
+        end
+
+      end # class Project
+    end # module Relational
+  end # module Operator
 end # module Alf