locomotive 0.0.1

data/lib/locomotive/utils.rb

@@ -0,0 +1,2 @@
+require 'locomotive/utils/relalg2xml'
+require 'locomotive/utils/xml'

data/lib/locomotive/utils/relalg2xml.rb

@@ -0,0 +1,239 @@
+module Locomotive
+
+module Utilities
+
+class RelAlg2XML
+
+  private
+
+  class << self
+    def define_content_ranks(*mtds)
+      mtds.each do |mtd|
+        name = "content_#{mtd}".to_sym
+        define_method(name) do |ast|
+          cols = []
+          cols << column(nil, :name => ast.ann_res, :new => true)
+          pos = -1
+          ast.ann_order.keys.each do |ord|
+            cols << column(nil, :name => ord, :function => "sort",
+                                   :pos => pos += 1,
+                                   :direction => ast.ann_order[ord],
+                                   :new => false)
+          end
+      
+          pos = -1
+          ast.ann_part.each do |part|
+            cols << column(nil, :name => part, :function => "part",
+                                   :pos => pos + 1,
+                                   :new => false)
+          end
+      
+          cols.join("\n")
+        end
+      end
+    end
+
+    def define_content_cmp(*mtds)
+      mtds.each do |mtd|
+        name = "content_#{mtd}".to_sym
+        define_method(name) do |ast|
+          cols = []
+          cols << "<kind name=\"#{ast.ann_fun_kind}\"/>"
+          cols << column(nil, :name => ast.ann_result, :new => true)
+          cols << column(nil, :name => ast.ann_operands.first, :new => false, :position => 1)
+          cols << column(nil, :name => ast.ann_operands.last, :new => false, :position => 2)
+          cols.join("\n")
+        end
+      end
+    end
+
+  end
+
+  def edge(attrs)
+    attrlist = []
+    attrs.keys.each do |attr|
+      attrlist << "#{attr}=\"#{attrs[attr]}\""
+    end
+
+    "<edge #{attrlist.join(" ")}/>"
+  end
+
+  def schema(schema)
+    cols = []
+    schema.keys.each do |col|
+      cols << "<col name=\"#{col.to_s}\"" \
+                 " types=\"#{schema[col].join(",")}\"/>"
+    end
+    cols.join("\n")
+  end
+
+  def value(inner_node, attrs)
+    attrlist = []
+    attrs.keys.each do |attr|
+      attrlist << "#{attr}=\"#{attrs[attr]}\""
+    end
+
+    "<value #{attrlist.join(" ")}#{inner_node ? ">" : "/>"}" \
+    "#{inner_node}#{inner_node ? "</value>" : ""}"
+  end
+
+  def column(inner_node, attrs)
+    attrlist = []
+    attrs.keys.each do |attr|
+      attrlist << "#{attr}=\"#{attrs[attr]}\""
+    end
+
+    "<column #{attrlist.join(" ")}#{inner_node ? ">\n" : "/>"}" \
+    "#{inner_node}#{inner_node ? "\n</column>" : ""}"
+  end
+
+  public
+
+  define_content_ranks :rowid, :rank, :rownum
+  define_content_cmp   :eq, :lt, :gt, :leq, :geq
+
+  def initialize(ast)
+    @ast = ast
+    # create an identifier for each node by a preorder-traversal
+    # and enhance it by an xmlid-annotation
+    id = 0
+    @ast.traverse do |ast|
+      ast.ann_xmlid = (id += 1)
+    end
+  end
+
+  def content_table(ast)
+    cols = []
+    ast.ann_values.keys.each do |col|
+      cols << column(value(ast.ann_values[col], :type => ast.ann_schema[col].first),
+                     :name => col, :new => true)
+    end
+    cols.join("\n")
+  end
+
+  def content_eqjoin(ast)
+    cols = []
+    cols << column(nil, :name => ast.ann_col1,  :new => false, :position => 1)
+    cols << column(nil, :name => ast.ann_col2,  :new => false, :position => 2)
+    cols.join("\n")
+  end
+
+  def content_project(ast)
+    cols = [] 
+    ast.ann_items.keys.each do |old|
+      ast.ann_items[old].each do |new|
+        cols << column(nil, :name => new, :old_name => old, :new => (new != old))
+      end
+    end
+    cols.join("\n")
+  end
+
+  def content_cross(ast)
+  end
+
+  def content_union(ast)
+  end
+
+  def content_serialize_relation(ast)
+    cols = []
+    cols << column(nil, :name => ast.ann_iter, :new => false, :function => :iter)
+    cols << column(nil, :name => ast.ann_pos, :new => false, :function => :pos)
+    pos = 0
+    ast.ann_items.each do |item|
+      cols << column(nil, :name => item, :new => false, :function => :item, :position => pos)
+      pos += 1
+    end
+    cols.join("\n")
+  end
+
+  def content_ref_tbl(ast)
+    cols = []
+    cols << "<table name=\"#{ast.value}\">"
+    ast.ann_items.keys.each do |col|
+      cols << column(nil, :name => col, :tname => ast.ann_items[col],
+                          :type => ast.ann_schema[col].join(","))
+    end
+    cols << "</table>"
+    cols.join("\n")
+  end
+
+  def content_attach(ast)
+    cols = []
+    col = ast.value.first.first
+    cols << column(value(ast.value[col].first, :type => ast.ann_schema[col].first),
+                   :name => col, :new => true)
+    cols.join("\n")
+  end
+
+  def content_nil(ast)
+  end
+
+  def content_fun(ast)
+    cols = []
+    cols << "<kind name=\"#{ast.ann_fun_kind}\"/>"
+    cols << column(nil, :name => ast.ann_result, :new => true)
+    cols << column(nil, :name => ast.ann_operands.first, :new => false, :position => 1)
+    cols << column(nil, :name => ast.ann_operands.last, :new => false, :position => 2)
+    cols.join("\n")
+  end
+
+  def to_xml_wrapper(ast)
+#<schema>
+#{schema ast.ann_schema}
+#</schema>
+<<XMLNODE
+<node id=\"#{ast.ann_xmlid.to_s}\" kind=\"#{ast.kind.to_s}\">
+<content>
+#{ content_method = "content_#{->(kind) {
+                               if kind == "serialize relation".to_sym then
+                                 :serialize_relation
+                               else
+                                 kind
+                               end }[ast.kind]}"
+  if !self.respond_to?(content_method) then
+    "<nocontent/>"
+  else
+    self.send(content_method, ast)
+  end}
+</content>
+#{edges = []
+  edges << edge(:to => ast.left_child.ann_xmlid) if ast.has_left_child?
+  edges << edge(:to => ast.right_child.ann_xmlid) if ast.has_right_child?
+  edges.join("\n")
+ }
+</node>
+XMLNODE
+  end
+
+  def to_xml
+  
+    node_list = []
+
+    node_list << <<PROLOG
+<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+<query_plan_bundle>
+<query_plan id=\"0\">
+<properties>
+<property name=\"overallResultType\" value=\"TUPLE\"/>
+</properties>
+<logical_query_plan unique_names=\"true\">
+PROLOG
+
+    @ast.traverse_strategy = Locomotive::AstHelpers::PostOrderTraverse
+    @ast.traverse do |ast|
+      node_list << to_xml_wrapper(ast)
+    end
+
+node_list << <<EPILOG
+</logical_query_plan>
+</query_plan>
+</query_plan_bundle>
+EPILOG
+
+    node_list.join("\n")
+  end
+end
+
+end
+
+end

data/lib/locomotive/utils/xml.rb

@@ -0,0 +1,47 @@
+module Locomotive
+
+module XML
+
+def self.included(klass)
+  klass.extend ClassMethods
+end
+
+module ClassMethods
+
+  def def_node(*mtds)
+    mtds.each do |mtd|
+      define_method(mtd) do |attrs={},&block|
+        attr_list = []
+        attrs.keys.each do |attr|
+          attr_list << "#{attr}=#{quote(attrs[attr])}"
+        end
+        mtd_name = mtd.to_s
+        if /^_?(?<name>[a-z]*)_?$/i =~ mtd_name.to_s
+          mtd_name = name
+        end
+        xml = "<#{mtd_name}"
+        xml += " " unless attr_list.empty?
+        if block.nil?
+          xml += "#{attr_list.join(" ")}/>\n"
+        else
+          content = block.call.to_s
+          xml += "#{attr_list.join(" ")}>#{content.length < 60 ? "" : "\n"}" \
+          "#{content}#{content.length < 60 ? "" : "\n"}" \
+          "</#{mtd_name}>\n"
+        end
+      end
+    end
+  end
+end
+
+def quote(val)
+  "\"#{val}\""
+end
+
+def to_xml
+  "#{self.class.to_s.split("::").last.downcase}".to_sym
+end
+
+end
+
+end

metadata

@@ -0,0 +1,157 @@
+--- !ruby/object:Gem::Specification 
+name: locomotive
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Manuel Mayr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-30 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Ruby representation of the Pathfinder-Algebra
+                       (http://www-db.informatik.uni-tuebingen.de/research/pathfinder).
+                       
+                       This gem provides a Ruby interface to the Pathfinder-Algebra.
+                       Taking an algebraic plan in XML, Pathfinder is able to generate
+                       code for various database systems (SQL-99 conformant, MonetDB,
+                       X100, ...). In order to generate efficient target code it also
+                       does heavy optimization on the input plans.
+email: mayr@informatik.uni-tuebingen.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/locomotive.rb
+- lib/locomotive/misc.rb
+- lib/locomotive/misc/type_check.rb
+- lib/locomotive/core_extensions.rb
+- lib/locomotive/core_extensions/class.rb
+- lib/locomotive/core_extensions/module.rb
+- lib/locomotive/core_extensions/array.rb
+- lib/locomotive/core_extensions/hash.rb
+- lib/locomotive/core_extensions/inflector.rb
+- lib/locomotive/core_extensions/symbol.rb
+- lib/locomotive/relational_algebra.rb
+- lib/locomotive/relational_algebra/attributes.rb
+- lib/locomotive/relational_algebra/operators.rb
+- lib/locomotive/relational_algebra/operators/abstraction.rb
+- lib/locomotive/relational_algebra/operators/abstraction/lambda.rb
+- lib/locomotive/relational_algebra/operators/abstraction/variable.rb
+- lib/locomotive/relational_algebra/operators/aggregation.rb
+- lib/locomotive/relational_algebra/operators/aggregation/aggr_builtin.rb
+- lib/locomotive/relational_algebra/operators/aggregation/aggregation.rb
+- lib/locomotive/relational_algebra/operators/basic_operators.rb
+- lib/locomotive/relational_algebra/operators/boolean.rb
+- lib/locomotive/relational_algebra/operators/boolean/and.rb
+- lib/locomotive/relational_algebra/operators/boolean/basic_boolean.rb
+- lib/locomotive/relational_algebra/operators/boolean/or.rb
+- lib/locomotive/relational_algebra/operators/boolean/not.rb
+- lib/locomotive/relational_algebra/operators/builtins.rb
+- lib/locomotive/relational_algebra/operators/builtins/arith_builtin.rb
+- lib/locomotive/relational_algebra/operators/builtins/basic_builtin.rb
+- lib/locomotive/relational_algebra/operators/builtins/function.rb
+- lib/locomotive/relational_algebra/operators/comparisons.rb
+- lib/locomotive/relational_algebra/operators/comparisons/basic_comparison.rb
+- lib/locomotive/relational_algebra/operators/comparisons/equal.rb
+- lib/locomotive/relational_algebra/operators/comparisons/greater.rb
+- lib/locomotive/relational_algebra/operators/comparisons/greater_equal.rb
+- lib/locomotive/relational_algebra/operators/comparisons/less.rb
+- lib/locomotive/relational_algebra/operators/comparisons/less_equal.rb
+- lib/locomotive/relational_algebra/operators/filter.rb
+- lib/locomotive/relational_algebra/operators/filter/select.rb
+- lib/locomotive/relational_algebra/operators/join.rb
+- lib/locomotive/relational_algebra/operators/join/basic_join.rb
+- lib/locomotive/relational_algebra/operators/join/cross.rb
+- lib/locomotive/relational_algebra/operators/join/equi_join.rb
+- lib/locomotive/relational_algebra/operators/join/predicates.rb
+- lib/locomotive/relational_algebra/operators/join/theta_join.rb
+- lib/locomotive/relational_algebra/operators/projections.rb
+- lib/locomotive/relational_algebra/operators/projections/attach.rb
+- lib/locomotive/relational_algebra/operators/projections/projection.rb
+- lib/locomotive/relational_algebra/operators/ranking.rb
+- lib/locomotive/relational_algebra/operators/ranking/basic_ranking.rb
+- lib/locomotive/relational_algebra/operators/ranking/rank.rb
+- lib/locomotive/relational_algebra/operators/ranking/rank_lists.rb
+- lib/locomotive/relational_algebra/operators/ranking/row_id.rb
+- lib/locomotive/relational_algebra/operators/ranking/row_number.rb
+- lib/locomotive/relational_algebra/operators/ranking/row_rank.rb
+- lib/locomotive/relational_algebra/operators/serialization.rb
+- lib/locomotive/relational_algebra/operators/serialization/basic_serialize.rb
+- lib/locomotive/relational_algebra/operators/serialization/serialize_relation.rb
+- lib/locomotive/relational_algebra/operators/set.rb
+- lib/locomotive/relational_algebra/operators/set/basic_set.rb
+- lib/locomotive/relational_algebra/operators/set/difference.rb
+- lib/locomotive/relational_algebra/operators/set/union.rb
+- lib/locomotive/relational_algebra/operators/set/distinct.rb
+- lib/locomotive/relational_algebra/operators/tables.rb
+- lib/locomotive/relational_algebra/operators/tables/literal_table.rb
+- lib/locomotive/relational_algebra/operators/tables/nil.rb
+- lib/locomotive/relational_algebra/operators/tables/ref_table.rb
+- lib/locomotive/relational_algebra/operators/typeing.rb
+- lib/locomotive/relational_algebra/operators/typeing/cast.rb
+- lib/locomotive/relational_algebra/operators/error.rb
+- lib/locomotive/relational_algebra/operators/error/error.rb
+- lib/locomotive/relational_algebra/ordering.rb
+- lib/locomotive/relational_algebra/query_information.rb
+- lib/locomotive/relational_algebra/rel_alg_ast_node.rb
+- lib/locomotive/relational_algebra/rel_alg_exceptions.rb
+- lib/locomotive/relational_algebra/schema.rb
+- lib/locomotive/relational_algebra/types.rb
+- lib/locomotive/tree_helpers.rb
+- lib/locomotive/tree_helpers/annotations.rb
+- lib/locomotive/tree_helpers/ast.rb
+- lib/locomotive/tree_helpers/ast_traversal.rb
+- lib/locomotive/utils.rb
+- lib/locomotive/utils/relalg2xml.rb
+- lib/locomotive/utils/xml.rb
+has_rdoc: true
+homepage: http://www-db.informatik.uni-tuebingen.de/research/pathfinder
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: ""
+test_files: []
+