locomotive 0.0.1

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

@@ -0,0 +1,56 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Not < Unary
+      attr_accessor :res, :item
+      def_sig :res=, ConstAttribute
+      def_sig :item=, ConstAttribute
+      
+      def initialize(op, res, item)
+        self.res,
+        self.item = res, item
+        super(op)
+      end
+      
+      def child=(op)
+        unless op.schema.attributes?([item])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item1}."
+        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 => item.to_xml, :new => false)].join
+        end
+      end
+      
+      def xml_kind
+        self.class.to_s.split('::').last.downcase.to_sym
+      end
+      
+      def clone
+       Not.new(child.clone,
+               res.clone,
+               item.clone)
+      end
+      
+      def set(var, plan)
+        self.class.new(
+          child.set(var,plan),
+          res.clone,
+          item.clone)
+      end
+    end
+  
+  end
+
+end

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

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

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

@@ -0,0 +1,3 @@
+require 'locomotive/relational_algebra/operators/builtins/basic_builtin'
+require 'locomotive/relational_algebra/operators/builtins/arith_builtin'
+require 'locomotive/relational_algebra/operators/builtins/function'

data/lib/locomotive/relational_algebra/operators/builtins/arith_builtin.rb

@@ -0,0 +1,37 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Addition < Fun
+      def to_xml
+        :add
+      end
+    end
+
+    class Subtraction < Fun
+      def to_xml
+        :subtract
+      end
+    end
+
+    class Multiplication < Fun
+      def to_xml
+        :multiply
+      end
+    end
+
+    class Division < Fun
+      def to_xml
+        :divide
+      end
+    end
+
+    class Contains < Fun
+      def to_xml
+        :contains
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/builtins/basic_builtin.rb

@@ -0,0 +1,20 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Fun
+      include Singleton
+    
+      def to_xml
+        self.class.to_s.split("::").last.downcase
+      end
+    
+      def clone
+        #singleton
+        self
+      end
+    end
+    
+  end
+
+end 

data/lib/locomotive/relational_algebra/operators/builtins/function.rb

@@ -0,0 +1,69 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Function < Unary;
+      def_node :column, :kind
+    
+      attr_accessor :res,
+                    :operator,
+                    :items
+      def_sig :res=, ConstAttribute
+      def_sig :operator=, Fun
+      def_sig :items=, [ConstAttribute]
+    
+     
+      def initialize(op, operator, res, items)
+        self.operator,
+        self.res,
+        self.items = operator, res, items
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?(self.items)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{items}."
+        end
+    
+        self.schema = op.schema +
+                        Schema.new( { res => op.schema[items.first] } )
+        super(op)
+      end
+    
+      def xml_kind
+        :fun
+      end
+    
+      def xml_content
+        content do
+          [
+           kind(:name => operator.to_xml),
+           column(:name => res.to_xml, :new => true),
+           items.collect do |it|
+             column :name => it.to_xml, :new => false
+           end.join
+          ].join
+        end
+      end
+    
+      def clone
+        Function.new(child.clone,
+                     operator.clone,
+                     res.clone,
+                     items.clone)
+      end
+    
+      def set(var, plan)
+        Function.new(
+          child.set(var,plan),
+          operator.clone,
+          res.clone,
+          items.clone) 
+      end
+    end
+    
+  end
+
+end 

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

@@ -0,0 +1,6 @@
+require 'locomotive/relational_algebra/operators/comparisons/basic_comparison'
+require 'locomotive/relational_algebra/operators/comparisons/equal'
+require 'locomotive/relational_algebra/operators/comparisons/greater'
+require 'locomotive/relational_algebra/operators/comparisons/greater_equal'
+require 'locomotive/relational_algebra/operators/comparisons/less'
+require 'locomotive/relational_algebra/operators/comparisons/less_equal'

data/lib/locomotive/relational_algebra/operators/comparisons/basic_comparison.rb

@@ -0,0 +1,65 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Comparison < Unary
+      def_node 
+      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?([self.item1])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item1}."
+        end
+        unless op.schema.attributes?([self.item2])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item2}."
+        end
+    
+        self.schema = op.schema + Schema.new({ self.res => [RBool.instance]})
+        super(op)
+      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
+    
+      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
+    end
+    
+  end
+
+end 

data/lib/locomotive/relational_algebra/operators/comparisons/equal.rb

@@ -0,0 +1,13 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Equal < Comparison;
+      def xml_kind
+        :eq
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/comparisons/greater.rb

@@ -0,0 +1,13 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class GreaterThan < Comparison
+      def xml_kind
+        :gt
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/comparisons/greater_equal.rb

@@ -0,0 +1,14 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+
+    class GreaterEqualThan < Comparison
+      def xml_kind
+        :gteq
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/comparisons/less.rb

@@ -0,0 +1,21 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class LessThan < Comparison
+
+      def initialize(op, res, items)
+        super(op, res, items)
+        change = self.item2
+        self.item2 = self.item1
+        self.item1 = change
+      end
+
+      def xml_kind
+        :gt
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/comparisons/less_equal.rb

@@ -0,0 +1,13 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class LessEqualThan < Comparison
+      def xml_kind
+        :lteq
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1 @@
+require 'locomotive/relational_algebra/operators/error/error'

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

@@ -0,0 +1,52 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Error < Binary
+      attr_accessor :item
+      def_sig :item=, ConstAttribute
+
+      def initialize(op1, op2, item)
+        self.item = item
+        super(op1, op2)
+      end
+
+      def left_and_right=(op1, op2)
+        unless op.schema.attributes?([item])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item}."
+        end
+
+        # set the schema to its right child
+        self.schema = op2.schema
+      end
+
+      def xml_kind
+        :error
+      end
+
+      def xml_content
+        content do
+          column :name => item.to_xml, :new => false
+        end
+      end
+
+      def clone
+        Error.new(
+          left.clone, right.clone,
+          item.clone)
+      end
+
+      def set(var, plan)
+        Error.new(
+          left.set(var,plan),
+          right.set(var.plan),
+          item.clone)
+      end
+    end
+
+  end
+
+end
+

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

@@ -0,0 +1 @@
+require 'locomotive/relational_algebra/operators/filter/select'

data/lib/locomotive/relational_algebra/operators/filter/select.rb

@@ -0,0 +1,50 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Select < Unary
+      attr_accessor :item
+    
+      def initialize(op,  item)
+        self.item = item
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?([item])
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{item}."
+        end
+        
+        unless op.schema[item].member? RBool.instance
+          raise CorruptedSchema,
+                "#{item}(#{op.schema[item]}) doesn have the type Boolean."
+        end
+    
+        self.schema = op.schema.clone
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          column :name => item.to_xml, :new => false
+        end
+      end
+    
+      def clone
+        Select.new(
+          self.child.clone,
+          self.item.clone)
+      end
+    
+      def set(var,plan)
+        Select.new(
+          child.set(var,plan),
+          item.clone)
+      end
+    end
+
+  end
+
+end