locomotive 0.0.1

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

@@ -0,0 +1,9 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Rank < Numbering; end
+
+  end
+
+end

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

@@ -0,0 +1,45 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class SortList
+      include Locomotive::XML
+      def_node :column
+    
+      private
+    
+      attr_accessor :sort_list
+      def_sig :sort_list=, { ConstAttribute => SortDirection }
+      
+      public
+      delegate :[],
+               :to_a,
+               :to => :sort_list
+    
+      def initialize(hash)
+        self.sort_list = hash
+      end
+    
+      def attributes
+        sort_list.keys
+      end
+    
+      def to_xml
+        pos = -1
+        sort_list.collect do |attr, dir|
+          column :name => attr.to_xml,
+                 :function => :sort,
+                 :position => pos += 1,
+                 :direction => dir.to_xml,
+                 :new => false
+        end.join
+      end
+    
+      def clone
+         SortList.new( sort_list.clone )
+      end
+    end
+    
+  end
+
+end 

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

@@ -0,0 +1,24 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class RowId < Numbering
+      def initialize(op, res)
+        super(op,res,{})
+      end
+    
+      def clone
+        RowId.new(child.clone,
+                    res.clone)
+      end
+    
+      def set(var,plan)
+        RowId.new(
+          child.set(var,plan),
+          res.clone)
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,55 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class RowNum < Numbering
+      def_node :column
+      
+      attr_accessor :part
+      def_sig :part=, [ConstAttribute]
+    
+      def initialize(op, res, part, sortby)
+        self.part = part
+        super(op,res,sortby)
+      end
+    
+      def child=(op)
+        unless op.schema.attributes?(part)
+          raise CorruptedSchema,
+                "Schema #{op.schema.attributes} does not " \
+                "contain all attributes of #{part}."
+        end
+        super(op)
+      end
+    
+      def xml_content
+        pos = -1
+        content do
+          [column(:name => res.to_xml, :new => true),
+           sort_by.to_xml,
+           part.collect do |p|
+             column :name => p.to_xml,
+                    :function => :partition,
+                    :position => pos += 1,
+                    :new => false
+           end.join].join
+        end
+      end
+    
+      def clone
+        RowNum.new(child.clone,
+                   res.clone,
+                   part.clone,
+                   sort_by.clone)
+      end
+    
+      def set(var,plan)
+        RowNum.new(
+          child.set(var,plan),
+          res.clone, part.clone, sort_by.clone)
+      end
+    end
+
+  end
+
+end

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

@@ -0,0 +1,9 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class RowRank < Numbering; end
+
+  end
+
+end

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

@@ -0,0 +1,2 @@
+require 'locomotive/relational_algebra/operators/serialization/basic_serialize'
+require 'locomotive/relational_algebra/operators/serialization/serialize_relation'

data/lib/locomotive/relational_algebra/operators/serialization/basic_serialize.rb

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

data/lib/locomotive/relational_algebra/operators/serialization/serialize_relation.rb

@@ -0,0 +1,105 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    # serialize operator
+    class SerializeRelation < Serialize
+      include Locomotive::XML
+      def_node :logical_query_plan
+    
+      attr_accessor :iter,
+                    :pos,
+                    :items
+      def_sig :iter=, ConstAttribute
+      def_sig :pos=, ConstAttribute
+      def_sig :items=, [ConstAttribute]
+    
+      def initialize(side,alg,iter,pos,items)
+        self.iter,
+        self.pos,
+        self.items = iter, pos, items
+        super(side,alg)
+      end
+    
+      def left_and_right(side,alg)
+        unless alg.schema.attributes?([self.iter])
+          raise CorruptedSchema,
+                "Schema #{alg.schema.attributes} does not " \
+                "contain all attributes of #{iter}."
+        end
+        unless alg.schema.attributes?([self.pos])
+          raise CorruptedSchema,
+                "Schema #{alg.schema.attributes} does not " \
+                "contain all attributes of #{pos}."
+        end
+        unless alg.schema.attributes?(self.items)
+          raise CorruptedSchema,
+                "Schema #{alg.schema.attributes} does not " \
+                "contain all attributes of #{items}."
+        end
+        self.schema = alg.schema.clone
+        super(side,alg)
+      end
+    
+      def xml_kind
+        "serialize relation".to_sym
+      end
+    
+      def xml_content
+        pos_ = -1
+        content do
+          [
+            column(:name => iter.to_xml, :new => false, :function => :iter),
+            column(:name => pos.to_xml, :new => false, :function => :pos),
+            items.collect do |it|
+              column :name => it.to_xml,
+                     :new => false,
+                     :function => :item,
+                     :position => pos_ += 1
+            end.join
+          ].join
+        end
+      end
+    
+      def serialize
+        xml_id = 0
+        xml_list = []
+    
+        self.traverse_strategy = Locomotive::AstHelpers::PostOrderTraverse
+        self.traverse do |op|
+          next if op.ann_vis
+          op.ann_xml_id = xml_id += 1
+          xml_list << op.to_xml
+          op.ann_vis = true
+        end
+
+        self.traverse do |op|
+          op.ann_vis = false
+        end
+    
+        logical_query_plan :unique_names => true do
+          xml_list.join
+        end
+      end
+    
+      def clone
+        Serialization.new(left.clone,
+                          right.clone,
+                          iter.clone,
+                          pos.clone,
+                          items.clone)
+      end
+    
+      def set(var,plan)
+        Serialization.new(
+          left.set(var,plan),
+          right.set(var,plan),
+          iter.clone,
+          pos.clone,
+          items.clone)
+      end
+    end
+ 
+  end
+
+end

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

@@ -0,0 +1,4 @@
+require 'locomotive/relational_algebra/operators/set/basic_set'
+require 'locomotive/relational_algebra/operators/set/difference'
+require 'locomotive/relational_algebra/operators/set/union'
+require 'locomotive/relational_algebra/operators/set/distinct'

data/lib/locomotive/relational_algebra/operators/set/basic_set.rb

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

data/lib/locomotive/relational_algebra/operators/set/difference.rb

@@ -0,0 +1,11 @@
+module Locomotive
+
+  module RelationalAlgebra
+   
+    # set operators 
+    # FIXME: sanity checks (schemas have to be equal)
+    class Difference < Set; end
+
+  end
+
+end

data/lib/locomotive/relational_algebra/operators/set/distinct.rb

@@ -0,0 +1,35 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class Distinct < Unary
+      
+      def initialize(op)
+        super(op)
+      end
+
+      def child=(op)
+        self.schema = op.schema.clone
+        super(op)
+      end
+
+      def clone
+        Distinct.new(
+          child.clone)
+      end
+
+      def set(var,plan)
+        Distinct.new(
+          child.set(var,plan))
+      end
+
+      def xml_content
+        content do
+        end
+      end
+    end
+
+  end
+
+end
+

data/lib/locomotive/relational_algebra/operators/set/union.rb

@@ -0,0 +1,11 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    # set operators 
+    # FIXME: sanity checks (schemas have to be equal)
+    class Union < Set; end
+
+  end
+
+end

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

@@ -0,0 +1,3 @@
+require 'locomotive/relational_algebra/operators/tables/literal_table'
+require 'locomotive/relational_algebra/operators/tables/nil'
+require 'locomotive/relational_algebra/operators/tables/ref_table'

data/lib/locomotive/relational_algebra/operators/tables/literal_table.rb

@@ -0,0 +1,95 @@
+module Locomotive
+
+  module RelationalAlgebra
+
+    class LiteralList
+      include Locomotive::XML
+      def_node :column
+    
+      protected
+    
+      attr_accessor :literal_list
+      def_sig :literal_list=, { ConstAttribute => [RAtomic] }
+      
+    
+      public
+      delegate :[],
+               :collect,
+               :to_a,
+               :to => :literal_list
+    
+      def initialize(hash)
+        self.literal_list = hash
+      end
+    
+      def attributes
+        literal_list.keys
+      end
+    
+      def to_xml
+        literal_list.collect do |attr,atomary|
+          column :name => attr.to_xml, :new => true do 
+            atomary.collect do |atom|
+              atom.to_xml
+            end.join
+          end
+        end.join
+      end
+    
+      def clone
+        LiteralList.new( literal_list.clone )
+      end
+    end
+    
+    class LiteralTable < Leaf
+      attr_reader :lit_list
+    
+      def lit_list=(llist)
+        s = Hash[ *llist.collect do |attr, types|
+                           [attr,types.collect { |a| a.type }.uniq]
+                         end.flatten_once ]
+        self.schema = Schema.new(s)
+        @lit_list = llist
+      end
+
+      def to_literal_list(llist)
+        case
+          when Hash === llist then
+            LiteralList.new(llist)
+          when LiteralList === llist then
+            llist
+        end
+      end
+      private :to_literal_list
+
+
+      def_sig :lit_list=, LiteralList
+      private :lit_list
+
+    
+      def initialize(llist)
+        self.lit_list = to_literal_list llist
+      end
+    
+      def xml_kind
+        :table
+      end
+    
+      def xml_content
+        content do
+          lit_list.to_xml
+        end
+      end
+    
+      def clone
+        LiteralTable.new( lit_list.clone )
+      end
+    end
+
+    def LiteralTable(values)
+      LiteralTable.new(values)
+    end
+     
+  end
+
+end