alf 0.9.3 → 0.10.0

data/lib/alf/lispy/instance_methods.rb

@@ -0,0 +1,157 @@
+module Alf
+  module Lispy
+    
+    alias :ruby_extend :extend
+    
+    # The environment
+    attr_accessor :environment
+    
+    #
+    # Compiles a query expression given by a String or a block and returns
+    # the result (typically a tuple iterator)
+    #
+    # Example
+    #
+    #   # with a string
+    #   op = compile "(restrict :suppliers, lambda{ city == 'London' })"
+    #
+    #   # or with a block
+    #   op = compile {
+    #     (restrict :suppliers, lambda{ city == 'London' })
+    #   }
+    #
+    # @param [String] expr a Lispy expression to compile
+    # @return [Iterator] the iterator resulting from compilation
+    #
+    def compile(expr = nil, path = nil, &block)
+      if expr.nil? 
+        instance_eval(&block)
+      else 
+        b = _clean_binding
+        (path ? Kernel.eval(expr, b, path) : Kernel.eval(expr, b))
+      end
+    end
+  
+    #
+    # Evaluates a query expression given by a String or a block and returns
+    # the result as an in-memory relation (Alf::Relation)
+    #
+    # Example:
+    #
+    #   # with a string
+    #   rel = evaluate "(restrict :suppliers, lambda{ city == 'London' })"
+    #
+    #   # or with a block
+    #   rel = evaluate {
+    #     (restrict :suppliers, lambda{ city == 'London' })
+    #   }
+    #
+    def evaluate(expr = nil, path = nil, &block)
+      compiled = compile(expr, path, &block)
+      case compiled
+      when Iterator
+        compiled.to_rel
+      else
+        compiled
+      end
+    end
+    
+    #
+    # Coerces `h` to a valid tuple.
+    #
+    # @param [Hash] h, a hash mapping symbols to values
+    #
+    def Tuple(h)
+      unless h.keys.all?{|k| k.is_a?(Symbol)} &&
+             h.values.all?{|v| !v.nil?}
+        raise ArgumentError, "Invalid tuple literal #{h.inspect}"
+      end
+      h
+    end
+    
+    #
+    # Coerces `args` to a valid relation.
+    #
+    def Relation(first, *args)
+      if args.empty?
+        if first.is_a?(Symbol)
+          environment.dataset(first).to_rel
+        elsif first.is_a?(Hash)
+          Alf::Relation[first]
+        else
+          raise ArgumentError, "Unable to coerce `#{first.inspect}` to a relation"
+        end
+      else
+        Alf::Relation[*args.unshift(first)] 
+      end
+    end
+
+    # 
+    # Install the DSL through iteration over defined operators
+    #
+    Operator.each do |op_class|
+      meth_name = Tools.ruby_case(Tools.class_name(op_class)).to_sym
+      if op_class.unary?
+        define_method(meth_name) do |child, *args|
+          child = Iterator.coerce(child, environment)
+          op_class.new(*args).pipe(child, environment)
+        end
+      elsif op_class.binary?
+        define_method(meth_name) do |left, right, *args|
+          operands = [left, right].collect{|x| Iterator.coerce(x, environment)}
+          op_class.new(*args).pipe(operands, environment)
+        end
+      elsif op_class.nullary?
+        define_method(meth_name) do |*args|
+          op_class.new(*args).pipe(nil, environment)
+        end
+      else
+        raise "Unexpected operator #{op_class}"
+      end
+    end # Operators::each
+
+    # 
+    # Install the DSL through iteration over defined aggregators
+    #
+    Aggregator.each do |agg_class|
+      agg_name = Tools.ruby_case(Tools.class_name(agg_class)).to_sym
+      if method_defined?(agg_name)
+        raise "Unexpected method clash on Lispy: #{agg_name}"
+      else
+        define_method(agg_name) do |*args, &block|
+          agg_class.new(*args, &block)
+        end
+      end
+    end
+
+    def allbut(child, attributes)
+      (project child, attributes, :allbut => true)
+    end
+  
+    # 
+    # Runs a command as in shell.
+    #
+    # Example:
+    #
+    #     lispy = Alf.lispy(Alf::Environment.examples)
+    #     op = lispy.run(['restrict', 'suppliers', '--', "city == 'Paris'"])
+    #
+    def run(argv, requester = nil)
+      argv = Quickl.parse_commandline_args(argv) if argv.is_a?(String)
+      argv = Quickl.split_commandline_args(argv, '|')
+      argv.inject(nil) do |cmd,arr|
+        arr.shift if arr.first == "alf"
+        main = Alf::Command::Main.new(environment)
+        main.stdin_reader = cmd unless cmd.nil?
+        main.run(arr, requester)
+      end
+    end
+
+    private 
+    
+    def _clean_binding
+      binding
+    end
+  
+  end # module Lispy
+end # module Alf

data/lib/alf/operator/base.rb

@@ -0,0 +1,74 @@
+module Alf
+  module Operator
+    #
+    # Contains all methods for operator instances
+    #
+    module Base
+
+      #
+      # Input datasets
+      #
+      attr_accessor :datasets
+      
+      #
+      # Optional environment
+      #
+      attr_accessor :environment
+      
+      #
+      # Create an operator instance
+      #
+      def initialize(*args)
+        signature.parse_args(args, self)
+      end
+  
+      # 
+      # Sets the operator input
+      #
+      def pipe(input, env = environment)
+        raise NotImplementedError, "Operator#pipe should be overriden"
+      end
+      
+      #
+      # Returns operator signature.
+      #
+      def signature
+        self.class.signature
+      end
+
+      #
+      # Yields each tuple in turn 
+      #
+      # This method is implemented in a way that ensures that all operators are 
+      # thread safe. It is not intended to be overriden, use _each instead.
+      # 
+      def each
+        op = self.dup
+        op._prepare
+        op._each(&Proc.new)
+      end
+      
+      protected
+  
+      #
+      # Prepares the iterator before subsequent call to _each.
+      #
+      # This method is intended to be overriden by suclasses to install what's 
+      # need for successful iteration. The default implementation does nothing.
+      #
+      def _prepare 
+      end
+  
+      # Internal implementation of the iterator.
+      #
+      # This method must be implemented by subclasses. It is safe to use instance
+      # variables (typically initialized in _prepare) here.
+      # 
+      def _each
+      end
+      
+      private :datasets=, :environment=
+    end # module Base
+    include Base
+  end # module Operator
+end # module Alf

data/lib/alf/operator/binary.rb

@@ -0,0 +1,32 @@
+module Alf
+  module Operator
+    # 
+    # Specialization of Operator for operators that work on a binary input
+    #
+    module Binary
+      include Operator 
+      
+      # 
+      # Sets the operator input
+      #
+      def pipe(input, env = environment)
+        self.environment = env
+        self.datasets = input
+        self
+      end
+
+      protected
+      
+      # Returns the left operand
+      def left
+        Iterator.coerce(datasets.first, environment)
+      end
+      
+      # Returns the right operand
+      def right
+        Iterator.coerce(datasets.last, environment)
+      end
+      
+    end # module Binary
+  end # module Operator
+end # module Alf

data/lib/alf/operator/cesure.rb

@@ -0,0 +1,45 @@
+module Alf
+  module Operator
+    #
+    # Specialization of Operator for implementing operators that rely on a 
+    # cesure algorithm.
+    #
+    module Cesure
+      include Unary
+      
+      protected
+
+      # (see Operator#_each)
+      def _each
+        receiver, prev_key = Proc.new, nil
+        each_input_tuple do |tuple|
+          cur_key = project(tuple)
+          if cur_key != prev_key
+            flush_cesure(prev_key, receiver) unless prev_key.nil?
+            start_cesure(cur_key, receiver)
+            prev_key = cur_key
+          end
+          accumulate_cesure(tuple, receiver)
+        end
+        flush_cesure(prev_key, receiver) unless prev_key.nil?
+      end
+
+      # Projects a given tuple and returns it's cesure projection
+      def project(tuple)
+      end
+      
+      # Callback fired every time a new block starts
+      def start_cesure(key, receiver)
+      end
+
+      # Callback fired on each tuple of the current block 
+      def accumulate_cesure(tuple, receiver)
+      end
+
+      # Callback fired at end of a block
+      def flush_cesure(key, receiver)
+      end
+
+    end # module Cesure
+  end # module Operator
+end # module Alf

data/lib/alf/operator/class_methods.rb

@@ -0,0 +1,132 @@
+module Alf
+  module Operator
+    # 
+    # Encapsulates method that allows making operator introspection, that is,
+    # knowing operator cardinality and similar stuff.
+    # 
+    module ClassMethods
+
+      #
+      # Returns false
+      #
+      def command?
+        false
+      end
+    
+      #
+      # Returns true
+      #
+      def operator?
+        true
+      end
+
+      #
+      # Returns true if this is a relational operator, false otherwise
+      #
+      def relational?
+        ancestors.include?(Relational)
+      end
+    
+      #
+      # Returns true if this is a non relational operator, false otherwise
+      #
+      def non_relational?
+        ancestors.include?(NonRelational)
+      end
+    
+      #
+      # Runs the command on commandline arguments
+      #
+      # @param [Array] argv an array of commandline arguments, typically ARGV
+      # @param [Object] req an optional requester, typically a super command
+      # @return [Iterator] an Iterator with query result
+      #
+      def run(argv, req = nil)
+        inst, operands = from_argv(argv)
+
+        # find standard input reader
+        stdin_reader = if req && req.respond_to?(:stdin_reader)
+          req.stdin_reader
+        else 
+          Reader.coerce($stdin)
+        end
+
+        # normalize operands
+        operands = [ stdin_reader ] + Array(operands)
+        operands = operands.collect{|op| 
+          Iterator.coerce(op, req && req.environment)
+        }
+        operands = if nullary?
+          []
+        elsif unary?
+          operands.last
+        elsif binary?
+          operands[-2..-1]
+        end
+
+        inst.pipe(operands, req && req.environment)
+        inst
+      end
+
+      #
+      # Returns true if this operator is a zero-ary operator, false otherwise
+      #
+      def nullary?
+        ancestors.include?(Operator::Nullary)
+      end
+
+      #
+      # Returns true if this operator is an unary operator, false otherwise
+      #
+      def unary?
+        ancestors.include?(Operator::Unary)
+      end
+
+      #
+      # Returns true if this operator is a binary operator, false otherwise
+      #
+      def binary?
+        ancestors.include?(Operator::Binary)
+      end
+
+      #
+      # Installs or set the operator signature
+      #
+      def signature
+        if block_given?
+          @signature = Signature.new(self, &Proc.new) 
+          @signature.install
+          options do |opt|
+            signature.fill_option_parser(opt, self)
+          end
+        else
+          @signature ||= Signature.new(self)
+        end
+      end
+      
+      private 
+
+      # Factors an operator instance from commandline arguments
+      def from_argv(argv)
+        inst = new
+        operands = inst.signature.parse_argv(argv, inst)
+        [inst, operands]
+      end
+
+    end # module ClassMethods
+
+    #
+    # Yields non-relational then relational operators, in turn.
+    #
+    def self.each
+      Operator::NonRelational.each{|x| yield(x)}
+      Operator::Relational.each{|x| yield(x)}
+    end
+    
+    # Ensures that the Introspection module is set on real operators
+    def self.included(mod)
+      mod.extend(ClassMethods) if mod.is_a?(Class)
+    end
+      
+  end # module Operator
+end # module Alf

data/lib/alf/operator/experimental.rb

@@ -0,0 +1,9 @@
+module Alf
+  module Operator
+    #
+    # Marker for experimental operators
+    #
+    module Experimental 
+    end # module Experimental
+  end # module Operator
+end # module Alf

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

@@ -0,0 +1,24 @@
+module Alf
+  module Operator::NonRelational
+    class Autonum < Alf::Operator()
+      include Operator::NonRelational, Operator::Transform
+    
+      signature do |s|
+        s.argument :as, AttrName, :autonum
+      end
+          
+      protected
+        
+      # (see Operator#_prepare)
+      def _prepare
+        @autonum = -1
+      end
+      
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        tuple.merge(@as => (@autonum += 1))
+      end
+    
+    end # class Autonum
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,20 @@
+module Alf
+  module Operator::NonRelational
+    class Clip < Alf::Operator()
+      include Operator::NonRelational, Operator::Transform
+  
+      signature do |s|
+        s.argument :attributes, AttrList, []
+        s.option   :allbut,     Boolean, false, "Apply an allbut clipping?"
+      end
+      
+      protected 
+  
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        @attributes.project(tuple, @allbut)
+      end
+  
+    end # class Clip
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,21 @@
+module Alf
+  module Operator::NonRelational
+    class Coerce < Alf::Operator()
+      include Operator::NonRelational, Operator::Transform
+    
+      signature do |s|
+        s.argument :heading, Heading, {}
+      end
+      
+      protected 
+      
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        tuple.merge tuple_collect(@heading.attributes){|k,d|
+          [k, coerce(tuple[k], d)]
+        }
+      end
+    
+    end # class Coerce
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,62 @@
+module Alf
+  module Operator::NonRelational
+    class Compact < Alf::Operator()
+      include Operator::NonRelational, Operator::Shortcut, Operator::Unary
+  
+      signature do |s|
+      end
+      
+      # Removes duplicates according to a complete order
+      class SortBased
+        include Operator, Operator::Cesure
+
+        def initialize
+          @cesure_key ||= AttrList.new([])
+        end
+          
+        protected
+        
+        # (see Operator::Cesure#project)
+        def project(tuple)
+          @cesure_key.project(tuple, true)
+        end
+  
+        # (see Operator::Cesure#accumulate_cesure)
+        def accumulate_cesure(tuple, receiver)
+          @tuple = tuple
+        end
+  
+        # (see Operator::Cesure#flush_cesure)
+        def flush_cesure(key, receiver)
+          receiver.call(@tuple)
+        end
+ 
+      end # class SortBased
+  
+      # Removes duplicates by loading all in memory and filtering 
+      # them there 
+      class BufferBased
+        include Operator, Operator::Unary
+  
+        protected
+        
+        def _prepare
+          @tuples = input.to_a.uniq
+        end
+  
+        def _each
+          @tuples.each(&Proc.new)
+        end
+  
+      end # class BufferBased
+  
+      protected 
+      
+      def longexpr
+        chain BufferBased.new,
+              datasets
+      end
+  
+    end # class Compact
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,25 @@
+module Alf
+  module Operator::NonRelational
+    class Defaults < Alf::Operator()
+      include Operator::NonRelational, Operator::Transform
+  
+      signature do |s|
+        s.argument :defaults, TupleComputation, {}
+        s.option   :strict,   Boolean, false, "Restrict to default attributes only?"
+      end
+      
+      protected 
+  
+      # (see Operator::Transform#_tuple2tuple)
+      def _tuple2tuple(tuple)
+        handle = TupleHandle.new.set(tuple)
+        defs = @defaults.evaluate(handle)
+        keys = @strict ? defs.keys : (tuple.keys | defs.keys)
+        tuple_collect(keys){|k|
+          [k, coalesce(tuple[k], defs[k])]
+        }
+      end
+      
+    end # class Defaults
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,38 @@
+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)
+        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)
+        end
+      end
+
+    end # class Generator
+  end # module Operator::NonRelational
+end # module Alf

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

@@ -0,0 +1,23 @@
+module Alf
+  module Operator::NonRelational
+    class Sort < Alf::Operator()
+      include Operator::NonRelational, Operator::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
+end # module Alf

data/lib/alf/operator/nullary.rb

@@ -0,0 +1,20 @@
+module Alf
+  module Operator
+    # 
+    # Specialization of Operator for operators without operands
+    #
+    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
+end # module Alf