piglet 0.2.5 → 0.3.0

data/lib/piglet/field/infix_expression.rb

@@ -15,24 +15,29 @@ module Piglet
         else
           @type = determine_type(@left_expression, @right_expression)
         end
+        @predecessors = [left_expression, right_expression]
       end
     
       def simple?
         false
       end
     
-      def to_s
-        left  = @left_expression
-        right = @right_expression
+      def to_s(inner=false)
+        if inner
+          left  = @left_expression.field_alias
+          right = @right_expression.field_alias
+        else
+          left  = @left_expression
+          right = @right_expression
 
-        if left.respond_to?(:operator) && left.operator != @operator
-          left = parenthesise(left)
-        end
+          if left.respond_to?(:operator) && left.operator != @operator
+            left = parenthesise(left)
+          end
         
-        if right.respond_to?(:operator) && right.operator != @operator
-          right = parenthesise(right)
+          if right.respond_to?(:operator) && right.operator != @operator
+            right = parenthesise(right)
+          end
         end
-        
         "#{left} #{@operator} #{right}"
       end
       

data/lib/piglet/field/map_value.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Piglet
+  module Field
+    class MapValue
+      include Field
+      
+      def initialize(key, parent)
+        @key, @predecessors = key, [parent]
+      end
+      
+      def to_s(inner=false)
+        expr = if inner then @predecessors.first.field_alias else @predecessors.first end
+        "#{expr}##{@key}"
+      end
+    end
+  end
+end

data/lib/piglet/field/prefix_expression.rb

@@ -11,17 +11,20 @@ module Piglet
         options ||= {}
         @operator, @expression, @space_between = operator, expression, space_between
         @type = options[:type] || expression.type
+        @predecessors = [expression]
       end
     
       def simple?
         false
       end
     
-      def to_s
+      def to_s(inner=false)
+        expr = if inner then @expression.field_alias else @expression end
+        
         if @space_between
-          "#{@operator} #{parenthesise(@expression)}"
+          "#{@operator} #{parenthesise(expr)}"
         else
-          "#{@operator}#{parenthesise(@expression)}"
+          "#{@operator}#{parenthesise(expr)}"
         end
       end
     end

data/lib/piglet/field/reference.rb

@@ -10,16 +10,13 @@ module Piglet
         @name, @parent = name, relation
         @explicit_ancestry = options[:explicit_ancestry] || false
         @type = options[:type]
+        @predecessors = [relation] unless relation.nil?
       end
     
       def simple?
         true
       end
-    
-      def field(name)
-        Reference.new(name, self, :explicit_ancestry => true)
-      end
-    
+
       def method_missing(name, *args)
         if name.to_s =~ /^\w+$/ && args.empty?
           field(name)
@@ -32,12 +29,13 @@ module Piglet
         field("\$#{n}")
       end
     
-      def to_s
+      def to_s(inner=false)
         if @explicit_ancestry
           if @parent.respond_to?(:alias)
             "#{@parent.alias}.#{@name.to_s}"
           else
-            "#{@parent}.#{@name.to_s}"
+            expr = if inner then @parent.field_alias else @parent end
+            "#{expr}.#{@name.to_s}"
           end
         else
           @name.to_s

data/lib/piglet/field/rename.rb

@@ -3,14 +3,16 @@
 module Piglet
   module Field
     class Rename # :nodoc:
-      attr_reader :name, :type
+      attr_reader :name, :type, :predecessors
       
-      def initialize(new_name, field_expression)
-        @name, @field_expression, @type = new_name, field_expression, field_expression.type
+      def initialize(name, field_expression)
+        @name, @field_expression, @type = name, field_expression, field_expression.type
+        @predecessors = [field_expression]
       end
       
-      def to_s
-        "#{@field_expression} AS #{@name}"
+      def to_s(inner=false)
+        expr = if inner then @field_expression.field_alias else @field_expression end
+        "#{expr} AS #{@name}"
       end
     end
   end

data/lib/piglet/field/suffix_expression.rb

@@ -9,14 +9,16 @@ module Piglet
         options ||= {}
         @operator, @expression = operator, expression
         @type = options[:type] || expression.type
+        @predecessors = [expression]
       end
     
       def simple?
         false
       end
     
-      def to_s
-        "#{parenthesise(@expression)} #{@operator}"
+      def to_s(inner=false)
+        expr = if inner then @expression.field_alias else @expression end
+        "#{parenthesise(expr)} #{@operator}"
       end
     end
   end

data/lib/piglet/field/udf_expression.rb

@@ -5,10 +5,15 @@ module Piglet
       
       def initialize(ali4s, *args)
         @alias, @args = ali4s, args
+        @predecessors = args.select { |arg| arg.respond_to? :field_alias }
       end
       
-      def to_s
-        "#{@alias}(#{args_to_s(@args)})"
+      def to_s(inner=false)
+        if inner
+          "#{@alias}(#{args_to_inner_s(@args)})"
+        else
+          "#{@alias}(#{args_to_s(@args)})"
+        end
       end
       
     private
@@ -23,6 +28,18 @@ module Piglet
           arg
         end
       end
+      
+      def args_to_inner_s(arg)
+        if arg.is_a? String
+          "'#{escape(arg)}'"
+        elsif arg.is_a? Enumerable
+          arg.map { |a| args_to_inner_s(a) }.join(", ")
+        elsif arg.respond_to? :field_alias
+          arg.field_alias
+        else
+          arg.to_s
+        end
+      end
     end
   end
 end

data/lib/piglet/inout/load.rb

@@ -6,9 +6,9 @@ module Piglet
       include Piglet::Relation::Relation
       include StorageTypes
     
-      def initialize(path, options={})
+      def initialize(path, interpreter, options={})
         options ||= {}
-        @path, @using, @schema = path, options[:using], options[:schema]
+        @path, @interpreter, @using, @schema = path, interpreter, options[:using], options[:schema]
       end
     
       def schema

data/lib/piglet/interpreter.rb

@@ -38,7 +38,13 @@ module Piglet
       
       statements.flatten.map { |s| s.to_s }.join(";\n") + ";\n"
     end
-  
+    
+    def next_relation_alias
+      @counter ||= 0
+      @counter += 1
+      "relation_#{@counter}"
+    end
+
   protected
 
     # LOAD
@@ -55,7 +61,7 @@ module Piglet
     # NOTE: the syntax load('path', :schema => {:a => :chararray, :b => :int})
     # would be nice, but the order of the keys can't be guaranteed in Ruby 1.8.
     def load(path, options={})
-      Inout::Load.new(path, options)
+      Inout::Load.new(path, self, options)
     end
   
     # STORE
@@ -151,22 +157,6 @@ module Piglet
       @top_level_statements << Param::Default.new(name, value, options)
     end
     
-    # Support for binary conditions, a.k.a. the ternary operator.
-    #
-    #   x.test(x.a > x.b, x.a, x.b) # => (a > b ? a : b)
-    # 
-    # Should only be used in the block given to #filter and #foreach
-    def test(test, if_true, if_false)
-      Field::BinaryConditional.new(test, if_true, if_false)
-    end
-    
-    # Support for literals in FOREACH … GENERATE blocks.
-    #
-    #   x.foreach { |r| [literal("hello").as(:hello)] } # => FOREACH x GENERATE 'hello' AS hello
-    def literal(obj)
-      Field::Literal.new(obj)
-    end
-  
   private
   
     def assignments(relation, ignore_set)

data/lib/piglet/relation/block_context.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module Piglet
+  module Relation
+    class BlockContext
+      def initialize(relation, interpreter)
+        @relation, @interpreter = relation, interpreter
+      end
+      
+      # Support for literals in FOREACH … GENERATE blocks.
+      #
+      #   x.foreach { |r| [literal("hello").as(:hello)] } # => FOREACH x GENERATE 'hello' AS hello
+      def literal(obj)
+        Field::Literal.new(obj)
+      end
+      
+      # Support for binary conditions, a.k.a. the ternary operator.
+      #
+      #   x.test(x.a > x.b, x.a, x.b) # => (a > b ? a : b)
+      # 
+      # Should only be used in the block given to #filter and #foreach
+      def test(test, if_true, if_false)
+        Field::BinaryConditional.new(test, if_true, if_false)
+      end
+      
+      def [](n)
+        @relation.field("\$#{n}")
+      end
+      
+      def method_missing(name, *args)
+        if args.size == 0
+          @relation.method_missing(name, *args)
+        elsif @interpreter.respond_to?(name)
+          @interpreter.send(name, *args)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/piglet/relation/cogroup.rb

@@ -5,7 +5,8 @@ module Piglet
     class Cogroup # :nodoc:
       include Relation
     
-      def initialize(relation, description)
+      def initialize(relation, interpreter, description)
+        @interpreter = interpreter
         @join_fields = description.reject { |k, v| ! (k.is_a?(Relation)) }
         @sources = @join_fields.keys
         @parallel = description[:parallel]

data/lib/piglet/relation/cross.rb

@@ -5,9 +5,9 @@ module Piglet
     class Cross # :nodoc:
       include Relation
     
-      def initialize(relations, options={})
+      def initialize(relations, interpreter, options={})
         options ||= {}
-        @sources, @parallel = relations, options[:parallel]
+        @sources, @interpreter, @parallel = relations, interpreter, options[:parallel]
       end
     
       def schema

data/lib/piglet/relation/distinct.rb

@@ -5,9 +5,9 @@ module Piglet
     class Distinct # :nodoc:
       include Relation
     
-      def initialize(relation, options={})
+      def initialize(relation, interpreter, options={})
         options ||= {}
-        @sources, @parallel = [relation], options[:parallel]
+        @sources, @interpreter, @parallel = [relation], interpreter, options[:parallel]
       end
     
       def to_s

data/lib/piglet/relation/filter.rb

@@ -5,8 +5,8 @@ module Piglet
     class Filter # :nodoc:
       include Relation
     
-      def initialize(relation, expression)
-        @sources, @expression = [relation], expression
+      def initialize(relation, interpreter, expression)
+        @sources, @interpreter, @expression = [relation], interpreter, expression
       end
     
       def to_s

data/lib/piglet/relation/foreach.rb

@@ -5,8 +5,8 @@ module Piglet
     class Foreach # :nodoc:
       include Relation
     
-      def initialize(relation, field_expressions)
-        @sources, @field_expressions = [relation], [field_expressions].flatten
+      def initialize(relation, interpreter, field_expressions)
+        @sources, @interpreter, @field_expressions = [relation], interpreter, [field_expressions].flatten
       end
       
       def schema

data/lib/piglet/relation/group.rb

@@ -5,9 +5,9 @@ module Piglet
     class Group # :nodoc:
       include Relation
     
-      def initialize(relation, grouping, options={})
+      def initialize(relation, interpreter, grouping, options={})
         options ||= {}
-        @sources, @grouping, @parallel = [relation], grouping, options[:parallel]
+        @sources, @interpreter, @grouping, @parallel = [relation], interpreter, grouping, options[:parallel]
       end
       
       def schema

data/lib/piglet/relation/join.rb

@@ -5,7 +5,8 @@ module Piglet
     class Join # :nodoc:
       include Relation
     
-      def initialize(relation, description)
+      def initialize(relation, interpreter, description)
+        @interpreter = interpreter
         @join_fields = Hash[*description.select { |k, v| k.is_a?(Relation) }.flatten]
         @sources = @join_fields.keys
         @using = description[:using]

data/lib/piglet/relation/limit.rb

@@ -5,8 +5,8 @@ module Piglet
     class Limit # :nodoc:
       include Relation
     
-      def initialize(relation, n)
-        @sources, @n = [relation], n
+      def initialize(relation, interpreter, n)
+        @sources, @interpreter, @n = [relation], interpreter, n
       end
     
       def to_s

data/lib/piglet/relation/nested_foreach.rb

@@ -0,0 +1,60 @@
+# encoding: utf-8
+
+module Piglet
+  module Relation
+    class NestedForeach
+      include Relation
+      
+      def initialize(relation, interpreter, expressions)
+        @sources, @interpreter, @expressions = [relation], interpreter, expressions
+      end
+      
+      def schema
+        description = @field_expressions.map { |expr| [expr.name, expr.type] }
+        Piglet::Schema::Tuple.parse(description)
+      end
+      
+      def to_s
+        block_assignments = block_expressions.map do |expression|
+          "\t#{expression.field_alias} = #{expression.to_s(true)};\n"
+        end
+        
+        generate_fields = @expressions.map do |expression| 
+          if expression.respond_to?(:field_alias)
+            expression.field_alias
+          else
+            expression.to_s(true)
+          end
+        end
+        
+        str = "FOREACH #{@sources.first.alias} {\n"
+        str << block_assignments.join
+        str << "\tGENERATE " + generate_fields.join(', ') + ";\n"
+        str << "}"
+      end
+      
+    private
+    
+      def block_expressions
+        handled = Set.new
+        handled.add(@relation)
+        intermediates = @expressions.map { |expression| intermediates(expression, handled) }.flatten
+      end
+      
+      def intermediates(expression, handled)
+        result = []
+        unless handled.member?(expression)
+          if expression.is_a? Field::Field or expression.is_a? Field::Rename
+            expression.predecessors.each { |predecessor| result += intermediates(predecessor, handled) }
+            handled.add(expression)
+          end
+
+          if expression.is_a?(Field::Field) && ! expression.is_a?(Field::Rename)
+            result << expression
+          end
+        end
+        result
+      end
+    end
+  end
+end