locomotive 0.0.1

data/lib/locomotive/relational_algebra/operators.rb

@@ -0,0 +1,15 @@
+require 'locomotive/relational_algebra/operators/basic_operators.rb'
+require 'locomotive/relational_algebra/operators/abstraction'
+require 'locomotive/relational_algebra/operators/aggregation'
+require 'locomotive/relational_algebra/operators/boolean'
+require 'locomotive/relational_algebra/operators/builtins'
+require 'locomotive/relational_algebra/operators/comparisons'
+require 'locomotive/relational_algebra/operators/filter'
+require 'locomotive/relational_algebra/operators/join'
+require 'locomotive/relational_algebra/operators/projections'
+require 'locomotive/relational_algebra/operators/ranking'
+require 'locomotive/relational_algebra/operators/serialization'
+require 'locomotive/relational_algebra/operators/set'
+require 'locomotive/relational_algebra/operators/tables'
+require 'locomotive/relational_algebra/operators/typeing'
+require 'locomotive/relational_algebra/operators/error'

data/lib/locomotive/relational_algebra/operators/abstraction.rb

@@ -0,0 +1,2 @@
+require 'locomotive/relational_algebra/operators/abstraction/variable'
+require 'locomotive/relational_algebra/operators/abstraction/lambda'

data/lib/locomotive/relational_algebra/operators/abstraction/lambda.rb

@@ -0,0 +1,83 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class RelLambda < Binary
+      def_node :parametrized_plan
+      def initialize(op1, op2)
+        super(op1,op2)
+      end
+    
+      def left_and_right(op1,op2)
+        self.schema = Schema.new( { Iter.new(1) => [RNat.type],
+                                    Pos.new(1) => [RNat.type],
+                                    # this is a dummy node
+                                    Item.new(1) => [RNat.type] } )
+        super(op1,op2)
+      end
+      def_sig :left_and_right, Variable, Operator
+    
+      def serialize
+        xml_id = 0
+        self.traverse do |op|
+          op.ann_xml_id = xml_id += 1
+        end
+    
+        xml_list = []
+    
+        self.traverse_strategy = Locomotive::AstHelpers::PostOrderTraverse
+        self.traverse do |op|
+          xml_list << op.to_xml
+        end
+    
+        parametrized_plan :comment => "not mentioned for execution" do
+          xml_list.join
+        end
+      end
+    
+      # performs a beta reduction on the right
+      # plan side
+      def apply(arg)
+        right.set(left, arg)
+      end
+    
+      def clone
+        RelLambda.new(op1.clone,
+                      op2.clone)
+      end
+    
+      def set(var,plan)
+        if var == self.left
+          right.clone
+        else
+          if !right.free.member?(var) or
+             !plan.free.member?(left)
+             RelLambda.new(
+               left.clone,
+               right.set(var, plan))
+          else
+             # alpha reduction
+             new_var = Variable.new_variable
+             RelLambda.new(
+               new_var,
+               right.set(left,new_var)).set(var,plan)
+          end
+        end
+      end
+    
+      def free
+        # the variable in the left branch
+        # is not a free variable anymore
+        right.free - [left]
+      end
+    
+      def bound
+        # the variable in the right branch
+        # is now a bound variable
+        [left.clone] + right.bound
+      end
+    end
+    
+  end
+
+end 

data/lib/locomotive/relational_algebra/operators/abstraction/variable.rb

@@ -0,0 +1,65 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Variable < Leaf
+    
+      class << self
+        attr_accessor :id_pool
+        
+        def new_variable(*items)
+          Variable.id_pool ||= [0]
+          new_id = Variable.id_pool.max + 1
+          Variable.id_pool << new_id
+          Variable.new(new_id, *items)
+        end
+      end
+    
+      attr_accessor :id, :items
+      def_sig :id=, Integer
+      def_sig :items=, [GenericAttribute]
+      def_node :variable
+    
+    
+      def initialize(id, *items)
+        self.id,
+        self.items = id, items
+        Variable.id_pool << self.id
+        self.schema = Schema.new({ Iter.new(1) => [RNat.type],
+                                   Pos.new(1) => [RNat.type] }.merge(
+                                     Hash[*items.collect do |it|
+                                             [it, [RNat.instance]]
+                                           end.flatten_once]) )
+      end
+    
+      def clone
+        Variable.new(id, *items.clone)
+      end
+    
+      def xml_content
+        content do
+          variable :name => id
+        end
+      end
+    
+      def ==(other)
+        other.class == Variable and
+        other.id == self.id
+      end
+    
+      def set(var,plan)
+        if var == self
+          plan.clone
+        else
+          self.clone
+        end
+      end
+    
+      def free
+        [ self.clone ]
+      end
+    end
+    
+  end
+
+end 

data/lib/locomotive/relational_algebra/operators/aggregation.rb

@@ -0,0 +1,2 @@
+require 'locomotive/relational_algebra/operators/aggregation/aggr_builtin'
+require 'locomotive/relational_algebra/operators/aggregation/aggregation'

data/lib/locomotive/relational_algebra/operators/aggregation/aggr_builtin.rb

@@ -0,0 +1,26 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class AggrFun
+      include Singleton
+    
+      def to_xml
+        self.class.to_s.split("::").last.downcase.to_sym
+      end
+    
+      def clone
+        self
+      end
+    end
+    
+    class Count < AggrFun; end
+    class Max < AggrFun; end
+    class Min < AggrFun; end
+    class Sum < AggrFun; end
+    class Avg < AggrFun; end
+    class All < AggrFun; end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/aggregation/aggregation.rb

@@ -0,0 +1,76 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Aggr < Unary
+      def_node :column, :aggregate
+    
+      attr_accessor :item, :over, :part_list, :aggr_kind
+      def_sig :aggr_kind=, AggrFun
+      def_sig :part_list=, [ConstAttribute]
+      def_sig :item=, ConstAttribute
+      def_sig :over=, [ConstAttribute]
+    
+      def initialize(op, aggr_kind, item, over, part)
+        self.item = item
+        self.aggr_kind = aggr_kind
+        self.over = over
+        self.part_list = part
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?(part_list)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{part_list}."
+        end
+        unless op.schema.attributes?(over)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item}."
+        end
+        self.schema = Schema.new( { self.item => [RNat.instance] }.merge(
+                                 Hash[*part_list.collect do |p|
+                                         [p, op.schema[p]]
+                                       end.flatten_once]))
+                              
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          part_list.collect do |part|
+            column :name => part.to_xml, :function => :partition, :new => false
+          end.join + 
+          (aggregate :kind => aggr_kind.to_xml do
+            ([column(:name => item.to_xml, :new => true)] + 
+             over.map do |c|
+               column(:name => c.to_xml, :new => false, :function => :item)
+             end).join
+          end)
+        end
+      end
+    
+      def clone
+        Aggr.new(
+          child.clone,
+          aggr_kind.clone,
+          over.clone,
+          item.clone,
+          part_list.clone)
+      end
+    
+      def set(var,plan)
+        Aggr.new(
+          child.set(var,plan),
+          aggr_kind.clone,
+          item.clone,
+          over.clone,
+          part_list.clone)
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/basic_operators.rb

@@ -0,0 +1,144 @@
+module Locomotive
+
+  module RelationalAlgebra
+    
+    # represents a variant operator of the
+    # relational algebra
+    class Operator < RelAlgAstNode
+      include Locomotive::XML
+      def_node :node, :content, :column, :edge
+    
+      attr_accessor :schema
+      def_sig :schema=, Schema
+    
+      def initialize
+        raise AbstractClassError,
+              "#{self.class} is an abstract class" if self.class == Operator
+        self.schema = Schema.new({})
+      end
+    
+      def xml_schema
+        self.schema.to_xml
+      end
+    
+      def xml_content
+        content()
+      end
+    
+      def xml_kind
+        self.class.to_s.split("::").last.downcase.to_sym
+      end
+    
+      def to_xml
+        cont_list = [ xml_schema,
+                      xml_content ]
+        cont_list << edge(:to => left_child.ann_xml_id) if has_left_child? and 
+                                                           left_child.respond_to? :ann_xml_id
+        cont_list << edge(:to => right_child.ann_xml_id) if has_right_child? and
+                                                            right_child.respond_to? :ann_xml_id
+        node :id => ann_xml_id,
+             :kind => xml_kind do
+          cont_list.join
+        end
+      end
+    
+      # returns all free variables in this plan
+      def free
+        # attention: for convenience we use
+        # the underlying ast framework
+        fv = []
+        fv += left_child.free if has_left_child?
+        fv += right_child.free if has_right_child?
+        fv
+      end
+    
+      # returns all bound variables in this plan
+      def bound
+        # attention: for convenience we use
+        #  the underlying ast framework
+        bv = []
+        bv += left_child.bound if has_left_child?
+        bv += right_child.bound if has_right_child?
+        bv
+      end
+    end
+
+    #
+    # A leaf doesn't have any child
+    #
+    class Leaf < Operator
+    #  undef left_child=
+    #  undef left_child
+    #  undef has_left_child?
+    #  undef right_child=
+    #  undef right_child
+    #  undef has_right_child?
+      def initialize()
+        raise AbstractClassError,
+              "#{self.class} is an abstract class" if self.class == Leaf
+        super()
+      end
+    
+      def set(var,plan)
+        self.clone
+      end
+    end
+  
+    #
+    # An unary Operator has exactly one child
+    #
+    class Unary < Operator
+      # undefine all methods to access
+      # the right child
+    #  undef right_child=
+    #  undef right_child
+    #  undef has_right_child?
+    
+      # since we have only one child for this
+      # type of operators, we define a shortcut
+      alias :child :left_child
+      alias :child= :left_child=
+      def_sig :child=, Operator
+    
+      alias :child? :has_left_child?
+    
+      def initialize(op)
+        raise AbstractClassError,
+              "#{self.class} is an abstract class" if self.class == Unary
+        super()
+        self.child = op
+      end
+    end
+    
+    #
+    # A binary operator has exactly two children
+    # 
+    class Binary < Operator
+      # getter and setters for left and
+      # right children by defining shortcuts
+      alias :left :left_child
+      alias :right :right_child
+      alias :left? :has_left_child?
+      alias :right? :has_right_child?
+    
+      #alias :left= :left_child=
+      #def_sig :left=, Operator
+      #alias :right= :right_child=
+      #def_sig :right=, Operator
+    
+      def left_and_right(op1, op2)
+        self.left_child = op1
+        self.right_child = op2 
+      end
+    
+      def initialize(op1, op2)
+        raise AbstractClassError,
+              "#{self.class} is an abstract class" if self.class == Binary
+        super()
+        left_and_right(op1,op2)
+      end
+    end
+     
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/boolean.rb

@@ -0,0 +1,4 @@
+require 'locomotive/relational_algebra/operators/boolean/basic_boolean'
+require 'locomotive/relational_algebra/operators/boolean/and'
+require 'locomotive/relational_algebra/operators/boolean/or'
+require 'locomotive/relational_algebra/operators/boolean/not'

data/lib/locomotive/relational_algebra/operators/boolean/and.rb

@@ -0,0 +1,9 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class And < BinOp; end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/boolean/basic_boolean.rb

@@ -0,0 +1,66 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class BinOp < Unary
+      attr_accessor :res, :item1, :item2
+      def_sig :res=, ConstAttribute
+      def_sig :item1=, ConstAttribute
+      def_sig :item2=, ConstAttribute
+    
+      def initialize(op, res, items)
+        self.res,
+        self.item1,
+        self.item2 = res, items[0], items[1]
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?([item1])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item1}."
+        end
+        unless op.schema.attributes?([item2])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item2}."
+        end
+    
+        self.schema = op.schema +
+                 Schema.new({ res => [RBool.instance] })
+    
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          [column(:name => res.to_xml, :new => true),
+           column(:name => item1.to_xml, :new => false, :position => 1),
+           column(:name => item2.to_xml, :new => false, :position => 2)].join
+        end
+      end
+    
+      def xml_kind
+        self.class.to_s.split('::').last.downcase.to_sym
+      end
+    
+      def clone
+        self.class.new(child.clone,
+                       res.clone,
+                       item1.clone,
+                       item2.clone)
+      end
+    
+      def set(var, plan)
+        self.class.new(
+          child.set(var,plan),
+          res.clone,
+          item1.clone,
+          item2.clone)
+      end
+    end
+
+  end
+
+end