locomotive 0.0.1

data/lib/locomotive/relational_algebra/rel_alg_ast_node.rb

@@ -0,0 +1,51 @@
+module Locomotive
+
+  module RelationalAlgebra
+  
+    # Represents a Relational Algebra node
+    # Such a node has
+    #  * the behaviour of a composite pattern
+    #  * and node specific annotations
+    class RelAlgAstNode
+      include AstHelpers::AstNode
+      include AstHelpers::Annotations
+
+      [:project, :attach,
+       :or, :and, :not,
+       :aggr,
+       :select,
+       :difference, :union, :distinct,
+       :cross, :equi_join, :theta_join,
+       :equal, :greater_than,
+       :less_than, :less_equal_than,
+       :row_num, :row_id, :rank, :row_rank,
+       :cast,
+       :error,
+       :serialize_relation].each do |op|
+        define_method(op) do |*args|
+          ::Locomotive::RelationalAlgebra.const_get(op.classify).new(self, *args)
+        end
+      end
+
+      [:addition, :subtraction,
+       :multiplication, :division].each do |meth|
+        define_method(meth) do |*args|
+          Function.new(self,
+                       ::Locomotive::RelationalAlgebra.const_get(meth.classify).instance,
+                       *args)
+        end
+      end
+
+      [:max, :min, :count, :avg, :sum, :all].each do |meth|
+        define_method(meth) do |*args|
+          Aggr.new(self,
+                   ::Locomotive::RelationalAlgebra.const_get(meth.classify).instance,
+                   *args)
+        end
+      end
+    end
+  
+  end
+
+end
+

data/lib/locomotive/relational_algebra/rel_alg_exceptions.rb

@@ -0,0 +1,15 @@
+module Locomotive
+
+module RelationalAlgebra
+
+class IdError < StandardError; end
+class AbstractClassError < StandardError; end
+class Duplicates < StandardError; end
+class CorruptedSchema < StandardError; end
+class ITblsNotEqual < StandardError; end
+
+class ArgumentException < StandardError; end
+
+end
+
+end

data/lib/locomotive/relational_algebra/schema.rb

@@ -0,0 +1,87 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    #
+    # The Schema contains the attributes
+    # and its associated types.
+    # Each operator of the relational algebra
+    # contains a schema.
+    #
+    class Schema
+      include Locomotive::XML
+      def_node :_schema_, :col
+    
+      protected
+    
+      attr_accessor :schema
+      def_sig :schema=, { ConstAttribute => [RType] }
+      
+      # check if there are duplicates in the schemas
+      def duplicates?(schema)
+        (self.attributes + schema.attributes).length >
+        (self.attributes + schema.attributes).uniq.length
+      end
+      def_sig :duplicates?, Schema
+    
+      public
+
+      delegate :[],
+               :each,
+               :to => :schema
+    
+      def initialize(hash)
+        self.schema = hash
+      end
+    
+      def attributes
+        schema.keys
+      end
+    
+      def attributes?(attributes)
+        attributes.all? { |attr| self.attributes.member? attr }
+      end
+      def_sig :attributes?, [ConstAttribute]
+    
+      # merges two schemas, given that there are
+      # no duplicate keys
+      def +(schm)
+        if duplicates?(schm)
+          raise Duplicates,
+                "Found duplicates in #{self.attributes} " \
+                "and #{schm.attributes}."
+        end
+        # create a new schema
+        Schema.new(schema.merge(schm.schema))
+      end
+      def_sig :+, Schema
+    
+      def []=(attr,types)
+        raise Duplicates, 
+               "#{attr.inspect} results in duplicates " \
+               "in schema #{self.attributes}" unless self[attr].nil?
+        schema[attr] = types
+      end
+      def_sig :[]=, ConstAttribute, [RType]
+    
+      def to_xml
+        _schema_ do
+          self.schema.collect do |attr,types|
+            col :name => attr.to_xml,
+                :type => types.collect { |ty| ty.to_xml }.join(",")
+          end.join
+        end
+      end
+
+      def inspect
+        "<Schema [#{schema.map { |s| s.inspect }.join(", ")}]>"
+      end
+    
+      def clone
+        Schema.new( self.schema.clone )
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/types.rb

@@ -0,0 +1,86 @@
+module Locomotive
+
+module RelationalAlgebra
+
+class RType
+  include Singleton
+  include Locomotive::XML
+
+  class << self
+    alias :type :instance
+  end
+
+  def initialize()
+    if self.class == RType
+      raise AbstractClassError,
+            "#{self.class} is an abstract class" 
+    end
+  end
+
+  def clone
+    # since all types are singletons
+    # we can return the object itself
+    self
+  end
+
+  def to_xml
+    self.class.to_s.split("::").last.downcase[1..-1]
+  end
+
+  def inspect
+    "<#{self.class.to_s.split('::').last}>"
+  end
+end
+class RDbl < RType; end
+class RDec < RDbl; end
+class RInt < RDec; end
+class RNat < RInt; end
+
+class RStr < RType; end
+
+class RBool < RType; end
+
+#
+# An atomic value constists of a value an
+# its associated type
+#
+class RAtomic
+  extend Locomotive::TypeChecking::Signature
+  include Locomotive::XML
+
+  def_node :_value_
+
+  attr_accessor :value,
+                :type
+  def_sig :type=, RType
+
+  def initialize(val, ty)
+    self.value,
+    self.type = val, ty
+  end
+
+  def to_xml
+    _value_ :type => type.to_xml do
+      value
+    end
+  end
+
+  def clone
+    RAtomic.new(self.value,
+               self.type)
+  end
+end
+
+
+[:r_dbl, :r_dec, :r_int, :r_nat, :r_str, :r_bool].each do |meth|
+  meth_ = meth.classify.to_sym
+  define_method(meth_) do |val|
+    RAtomic.new(val, 
+                ::Locomotive::RelationalAlgebra.
+                const_get(meth_).type)
+  end
+end
+
+end
+
+end

data/lib/locomotive/tree_helpers.rb

@@ -0,0 +1,3 @@
+require 'locomotive/tree_helpers/annotations'
+require 'locomotive/tree_helpers/ast'
+require 'locomotive/tree_helpers/ast_traversal'

data/lib/locomotive/tree_helpers/annotations.rb

@@ -0,0 +1,58 @@
+require 'pp'
+module Locomotive
+
+module AstHelpers
+
+# The purpose of this module is to enhance
+# an instance with accessors on special labeled
+# methods.
+#
+# Each instance of a class (with this module included)
+# has methods 
+#   *. o.ann_\w+
+#   *. o.ann_\w+=
+# to set and read the annotations.
+module Annotations
+  public
+
+  # overwrite the respond_to method
+  # to pretend there are ann_-methods
+  def respond_to? sym
+    @annotations ||= {}
+    if @annotations.keys.member?( sym.to_s[-1,1] != "=" ? 
+                                    sym :
+                                    sym.to_s[0..-2].to_sym )
+      true
+    else
+      super.respond_to? sym
+    end
+  end
+
+  # set method_missing to overwrite
+  # the behaviour of ann_-prefixed
+  # methods
+  def method_missing(key, *args)
+    key_str = key.to_s
+
+    # labeled ANN_PATTERN is not applicable in
+    # this case due to ?<data>
+    if /^ann_(?<data>\w+)=?/ =~ key_str
+      @annotations ||= {}
+
+      data_sym = "ann_#{data}".to_sym
+      if key_str[-1,1] == "=" then
+        @annotations[data_sym] = args[0]
+      else
+        @annotations[data_sym]
+      end
+
+    else 
+      super.method_missing(key, *args)
+    end
+  end
+
+end
+
+end
+
+end

data/lib/locomotive/tree_helpers/ast.rb

@@ -0,0 +1,99 @@
+require "#{File.dirname(__FILE__)}/ast_traversal"
+
+
+module Locomotive
+
+module AstHelpers
+
+# Implements the composite behaviour, thus a node with
+# two children.
+module AstNode
+  private
+  
+  DEFAULT_TRAVERSE_STRATEGY = PreOrderTraverse
+
+  public
+
+  attr_accessor :kind,
+                :value,
+                :owner
+
+  attr_reader :left_child,
+              :right_child
+
+  # The owner denotes the parent
+  # of this node
+
+  # Initialize the node with values.</b>
+  # An <b>A</b>stract <b>S</b>yntax <b>T</b>ree-Node
+  # has a
+  #   1. kind
+  #   2. value
+  #   3. a left child
+  #   4. a right child
+  #   5. some node specific annotations
+  #
+  # The values 2. - 5. can be omitted because there can be
+  # some nodes with a kind only (e.g. separators).
+  # A node with neither left- nor right-child is a leaf-node.
+  def initialize(kind,
+                 value = nil,
+                 left = nil,
+                 right = nil)
+    self.owner = nil
+    self.kind, self.value = kind, value
+    self.left_child  = left  if left  != nil
+    self.right_child = right if right != nil
+    self.traverse_strategy = DEFAULT_TRAVERSE_STRATEGY
+  end
+
+  # Sets a new left child 
+  # and sets the owner which is the
+  # actual instance
+  def left_child=(child)
+    child.owner = self
+    @left_child = child
+  end
+
+  # Sets a new right child
+  # and sets the owner which is the
+  # actual instance 
+  def right_child=(child)
+    child.owner  = self
+    @right_child = child
+  end
+
+  def has_left_child?
+    self.left_child != nil
+  end
+
+  def has_right_child?
+    self.right_child != nil
+  end
+
+  # checks whether the node is a leaf
+  # or not
+  def is_leaf?
+    self.left_child == nil and
+    self.right_child == nil
+  end
+
+  def traverse_strategy=(strategy)
+    @strategy = strategy
+    self.left_child.traverse_strategy = strategy if self.has_left_child?
+    self.right_child.traverse_strategy = strategy if self.has_right_child?
+  end
+
+  # Traverses the ast with a given
+  # strategy. If nothing given simple
+  # prefix-traversal is used
+  def traverse(strategy=nil, &block)
+    @strategy ||= strategy || DEFAULT_TRAVERSE_STRATEGY
+    @strategy.traverse(self, &block)
+  end
+
+end
+
+end
+
+end

data/lib/locomotive/tree_helpers/ast_traversal.rb

@@ -0,0 +1,43 @@
+module Locomotive
+
+module AstHelpers
+
+class TraverseStrategy
+  def TraverseStrategy.traverse(ast, &block)
+    raise "Called abstract method traverse"
+  end
+end
+
+class PreOrderTraverse < TraverseStrategy
+  def PreOrderTraverse.traverse(ast, &block)
+    block.call(ast)
+    traverse(ast.left_child,  &block) if ast.has_left_child?
+    traverse(ast.right_child, &block) if ast.has_right_child?
+    # return nothing
+    return
+  end
+end
+
+class PostOrderTraverse < TraverseStrategy
+  def PostOrderTraverse.traverse(ast, &block)
+    traverse(ast.left_child,  &block) if ast.has_left_child?
+    traverse(ast.right_child, &block) if ast.has_right_child?
+    block.call(ast)
+    # return nothing
+    return
+  end
+end
+
+class InOrderTraverse < TraverseStrategy
+  def InOrderTraverse.traverse(ast, &block)
+    traverse(ast.left_child,  &block) if ast.has_left_child?
+    block.call(ast)
+    traverse(ast.right_child, &block) if ast.has_right_child?
+    # return nothing
+    return 
+  end
+end
+
+end
+
+end