locomotive 0.0.1

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

@@ -0,0 +1,5 @@
+require 'locomotive/relational_algebra/operators/join/basic_join'
+require 'locomotive/relational_algebra/operators/join/cross'
+require 'locomotive/relational_algebra/operators/join/equi_join'
+require 'locomotive/relational_algebra/operators/join/predicates'
+require 'locomotive/relational_algebra/operators/join/theta_join'

data/lib/locomotive/relational_algebra/operators/join/basic_join.rb

@@ -0,0 +1,9 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Join < Binary; end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/join/cross.rb

@@ -0,0 +1,28 @@
+module Locomotive
+
+  module RelationalAlgebra
+    
+    class Cross < Join
+      def initialize(op1,op2)
+        super(op1,op2)
+      end
+    
+      def left_and_right(op1,op2)
+        self.schema = op1.schema + op2.schema
+        super(op1,op2)
+      end
+    
+      def clone
+        Cross.new(left.clone,right.clone)
+      end
+    
+      def set(var,plan)
+        Cross.new(
+          left.set(var,plan),
+          right.set(var,plan))
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/join/equi_join.rb

@@ -0,0 +1,61 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class EquiJoin < Join
+      attr_accessor :item1
+      def_sig :item1=, ConstAttribute
+      attr_accessor :item2
+      def_sig :item2=, ConstAttribute
+    
+    
+      def initialize(op1,op2,it1,it2)
+        self.item1,
+        self.item2 = it1, it2
+        super(op1,op2)
+      end
+    
+      def left_and_right(op1,op2)
+        unless op1.schema.attributes?([self.item1])
+          raise CorruptedSchema,
+                "Schema #{op1.schema.attributes} does not " \
+                "contain all attributes of #{item1}."
+        end
+        unless op2.schema.attributes?([self.item2])
+          raise CorruptedSchema,
+                "Schema #{op2.schema.attributes} does not " \
+                "contain all attributes of #{item2}."
+        end
+        self.schema = op1.schema + op2.schema
+        super(op1,op2)
+      end
+
+      def xml_kind
+        :eqjoin
+      end
+    
+      def xml_content
+        content do
+          [column(:name => item1.to_xml, :new => false, :position => 1),
+           column(:name => item2.to_xml, :new => false, :position => 2)
+          ].join
+        end
+      end
+    
+      def clone
+        EquiJoin.new(left.clone,right.clone,
+                   item1.clone, item2.clone)
+      end
+    
+      def set(var,plan)
+        EquiJoin.new(
+          left.set(var,plan),
+          right.set(var,plan),
+          item1.clone,
+          item2.clone)
+      end
+    end
+    
+  end 
+
+end

data/lib/locomotive/relational_algebra/operators/join/predicates.rb

@@ -0,0 +1,95 @@
+module Locomotive
+
+  module RelationalAlgebra
+  
+    class Predicate
+      include Locomotive::XML
+      def_node :column, :comparison
+    
+      private
+    
+      def first=(first)
+        @first = first
+      end
+      def_sig :first=, ConstAttribute
+    
+      def second=(snd)
+        @second = snd
+      end
+      def_sig :second=, ConstAttribute
+    
+      public
+    
+      attr_reader :first,
+                  :second
+    
+      def initialize(first_, second_)
+        self.first,
+        self.second = first_, second_
+      end
+    
+      def clone
+        self.class.new(first.clone,second.clone)
+      end
+    end
+    
+    
+    class Equivalence < Predicate
+      def to_xml
+        comparison :kind => :eq do
+          [column(:name => first.to_xml, :new => false, :position => 1),
+           column(:name => second.to_xml, :new => false, :position => 2)].join
+        end
+      end
+    end
+
+    class PredLessThan < Predicate
+      def to_xml
+         comparison :kind => :lt do
+          [column(:name => first.to_xml, :new => false, :position => 1),
+           column(:name => second.to_xml, :new => false, :position => 2)].join
+        end
+      end
+    end
+    
+    class PredGreaterThan < Predicate
+      def to_xml
+         comparison :kind => :gt do
+          [column(:name => first.to_xml, :new => false, :position => 1),
+           column(:name => second.to_xml, :new => false, :position => 2)].join
+        end
+      end
+    end
+    
+    class PredicateList
+      include Locomotive::XML
+      def_node :content
+    
+      private
+    
+      attr_accessor :pred_list
+      def_sig :pred_list=, [Predicate]
+    
+      public
+      delegate :[],
+               :to_a,
+               :to => :pred_list
+    
+      def initialize(*ary)
+        self.pred_list = ary
+      end
+    
+      def to_xml
+        pred_list.collect do |pred|
+          pred.to_xml
+        end.join
+      end
+    
+      def clone
+        PredicateList.new( *pred_list.clone )
+      end
+    end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/join/theta_join.rb

@@ -0,0 +1,53 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class ThetaJoin < Join
+      private
+
+      def to_predicate_list(predicates)
+        case
+          when Array === predicates then 
+            PredicateList.new(*predicates)
+          when PredicateList === predicates then
+            predicates
+        end
+      end
+
+      public
+      attr_accessor :predicate_list
+      def_sig :predicate_list=, PredicateList
+    
+      def initialize(op1, op2, pred_list)
+        self.predicate_list = to_predicate_list pred_list
+        super(op1,op2)
+      end
+    
+      def left_and_right(op1,op2)
+        self.schema = op1.schema + op2.schema
+        super(op1,op2)
+      end
+    
+      def xml_content
+        content do
+          predicate_list.to_xml
+        end
+      end
+    
+      def clone
+        ThetaJoin.new(left.clone,
+                      right.clone,
+                      predicate_list.clone)
+      end
+    
+      def set(var,plan)
+        ThetaJoin.new(
+          left.set(var,plan),
+          right.set(var,plan),
+          predicate_list.clone)
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,2 @@
+require 'locomotive/relational_algebra/operators/projections/attach'
+require 'locomotive/relational_algebra/operators/projections/projection'

data/lib/locomotive/relational_algebra/operators/projections/attach.rb

@@ -0,0 +1,67 @@
+module Locomotive
+
+  module RelationalAlgebra
+    
+    class AttachItem
+      include Locomotive::XML
+      def_node :column
+    
+      attr_accessor :attribute
+      def_sig :attribute=, ConstAttribute
+      attr_accessor :atom
+      def_sig :atom=, RAtomic
+    
+      def initialize(attr, atom)
+        self.attribute,
+        self.atom = attr, atom
+      end
+    
+      def to_xml
+        column :name => attribute.to_xml,
+               :new => true do
+          atom.to_xml
+        end 
+      end
+    
+      def clone
+        AttachItem.new(attribute, atom)
+      end
+    end
+    
+    
+    
+    class Attach < Unary
+      attr_accessor :item
+      def_sig :item=, AttachItem
+    
+      def initialize(op, item)
+        self.item = item
+        super(op)
+      end
+    
+      def child=(op)
+        self.schema = op.schema +
+                 Schema.new({ item.attribute => [item.atom.type] })
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          item.to_xml
+        end
+      end
+    
+      def clone
+        Attach.new(child.clone, item.clone)
+      end
+    
+      def set(var, plan)
+        Attach.new(
+          child.set(var,plan),
+          item.clone)
+      end
+    end
+   
+  end 
+
+end 

data/lib/locomotive/relational_algebra/operators/projections/projection.rb

@@ -0,0 +1,106 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class ProjectList
+      include Locomotive::XML
+      def_node :column
+    
+      private
+    
+      attr_accessor :project_list
+      def_sig :project_list=, { GenericAttribute => [ConstAttribute] }
+      
+      public
+      delegate :[],
+               :to_a,
+               :to => :project_list
+    
+      def initialize(hash)
+        self.project_list = hash
+      end
+    
+      def old_items
+        project_list.keys
+      end
+    
+      def new_items
+        project_list.values.flatten
+      end
+    
+      def to_xml
+        project_list.collect do |old,news|
+          news.collect do |new|
+            column :name => new.to_xml,
+                   :old_name => old.to_xml,
+                   :new => new != old
+          end.join
+        end.join
+      end
+    
+      def clone
+        ProjectList.new( project_list.clone )
+      end
+    end
+    
+    class Project < Unary
+      private
+    
+      attr_reader :proj_list
+
+      def to_project_list(list)
+        case
+          when Hash === list then
+            ProjectList.new(list)
+          when Array === list then
+            ProjectList.new(list.collect do |item|
+                              [item, [item]]
+                            end.to_hash)
+          when ProjectList === list then
+            list
+          else raise ArgumentError,
+                     "list does not seem to be a projectlist"
+        end
+      end
+    
+      public
+    
+      def initialize(op, proj_list)
+        @proj_list = to_project_list proj_list
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?(proj_list.old_items)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{proj_list.old_items}."
+        end
+        proj_list.old_items.each do |old|
+          proj_list[old].each do |new|
+            schema[new] = op.schema[old]
+          end
+        end
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          proj_list.to_xml
+        end
+      end
+    
+      def clone
+        Project.new(child.clone, proj_list.clone)
+      end
+    
+      def set(var,plan)
+        Project.new(
+          child.set(var,plan),
+          proj_list.clone)
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,6 @@
+require 'locomotive/relational_algebra/operators/ranking/rank_lists'
+require 'locomotive/relational_algebra/operators/ranking/basic_ranking'
+require 'locomotive/relational_algebra/operators/ranking/rank'
+require 'locomotive/relational_algebra/operators/ranking/row_id'
+require 'locomotive/relational_algebra/operators/ranking/row_number'
+require 'locomotive/relational_algebra/operators/ranking/row_rank'

data/lib/locomotive/relational_algebra/operators/ranking/basic_ranking.rb

@@ -0,0 +1,67 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Numbering < Unary
+      private 
+        def to_sort_by(sortby)
+          case
+            when SortList === sortby then
+              sortby
+            when Array === sortby then 
+              SortList.new( 
+                 sortby.map { |si|
+                   [si, Ascending.instance]
+                 }.to_hash )
+            when Hash === sortby then 
+              SortList.new(sortby)
+            when sortby.nil? then
+              SortList.new({})
+          end
+        end
+
+      public
+      attr_reader :res,
+                  :sort_by
+
+    
+      def initialize(op, res, sortby)
+        @res = res
+        @sort_by = to_sort_by sortby
+        super(op)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?(sort_by.attributes)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{sort_by.attributes}."
+        end
+        self.schema = op.schema + Schema.new({ @res => [RNat.instance] })
+        super(op)
+      end
+    
+      def xml_content
+        content do
+          [column( :name => res.to_xml, :new => true),
+           sort_by.to_xml].join
+        end
+      end
+    
+      def clone
+        self.class.new(child.clone,
+                       res.clone,
+                       sort_by.clone)
+      end
+    
+      def set(var, plan)
+        self.class.new(
+          child.set(var,plan),
+          res.clone,
+          sort_by.clone)
+      end
+    end
+
+  end
+
+end