alf-core 0.14.0 → 0.15.0

data/lib/alf/algebra/support/type_check.rb

@@ -0,0 +1,51 @@
+module Alf
+  module Algebra
+    module TypeCheck
+
+      def type_check_error!(msg)
+        raise TypeCheckError, msg
+      end
+
+      def no_unknown!(unknown)
+        unknown = unknown.to_a
+        unless unknown.empty?
+          msg = "#{to_s}: no such attribute"
+          msg << ((unknown.size > 1) ? "s " : " ")
+          msg << unknown.map{|a| "`#{a}`" }.join(',')
+          type_check_error!(msg)
+        end
+      end
+      private :no_unknown!
+
+      def no_name_clash!(left, right)
+        commons = (left & right).to_a
+        unless commons.empty?
+          msg = "#{to_s}: cannot override "
+          msg << commons.map{|a| "`#{a}`" }.join(',')
+          type_check_error!(msg)
+        end
+      end
+
+      def valid_ordering!(ordering, attr_list)
+        no_unknown!(ordering.to_attr_list - attr_list)
+      end
+
+      def same_heading!(left, right)
+        unless left == right
+          type_check_error!("heading mismatch `#{left}` vs. `#{right}`")
+        end
+      end
+
+      def joinable_headings!(left, right, options)
+        if options[:strict]
+          commons = left.to_attr_list & right.to_attr_list
+          left_h, right_h = left.project(commons), right.project(commons)
+          same_heading!(left_h, right_h)
+        else
+          left & right
+        end
+      end
+
+    end # module TypeCheck
+  end # module Algebra
+end # module Alf

data/lib/{alf-algebra/alf → alf}/algebra/support/visitor.rb

@@ -15,8 +15,9 @@ module Alf
       def to_method_name(expr, prefix = "on_")
         case expr
         when Algebra::Operator
-          name = Support.ruby_case(Support.class_name(expr.class))
+          name = expr.class.rubycase_name
           meth = :"#{prefix}#{name}"
+          meth = :"#{prefix}shortcut" if expr.is_a?(Algebra::Shortcut) and !respond_to?(meth)
           meth = :"#{prefix}missing" unless respond_to?(meth)
           meth
         when Algebra::Operand

data/lib/alf/compiler.rb

@@ -0,0 +1,57 @@
+module Alf
+  class Compiler
+
+    def supports_reuse?
+      false
+    end
+
+    def join(plan)
+      nil
+    end
+
+    def call(expr)
+      Plan.new(self).compile(expr)
+    end
+
+    def compile(plan, expr, compiled, usage_count)
+      send(to_method_name(expr), plan, expr, *compiled)
+    end
+
+    def on_leaf_operand(plan, expr)
+      expr.to_cog(plan)
+    end
+
+    def on_shortcut(plan, expr, *compiled)
+      plan.recompile(*compiled){|p| expr.expand }
+    end
+
+    def on_missing(plan, expr, *compiled)
+      raise NotSupportedError, "Unable to compile `#{expr}` (#{self})"
+    end
+
+    def on_unsupported(plan, expr, *args)
+      raise NotSupportedError, "Unsupported expression `#{expr}`"
+    end
+
+  private
+
+    def to_method_name(expr)
+      case expr
+      when Algebra::Operator
+        name = expr.class.rubycase_name
+        meth = :"on_#{name}"
+        meth = :"on_shortcut" if expr.is_a?(Algebra::Shortcut) and !respond_to?(meth)
+        meth = :"on_missing"  if !respond_to?(meth)
+        meth
+      when Algebra::Operand
+        :on_leaf_operand
+      else
+        :on_unsupported
+      end
+    end
+
+  end # class Compiler
+end # module Alf
+require_relative 'compiler/plan'
+require_relative 'compiler/cog'
+require_relative 'compiler/default'

data/lib/alf/compiler/cog.rb

@@ -0,0 +1,39 @@
+module Alf
+  class Compiler
+    module Cog
+      extend Forwardable
+
+      def initialize(expr, compiler)
+        @expr = expr
+        @compiler = compiler
+      end
+      attr_reader :expr
+      attr_reader :compiler
+
+      def_delegators :expr, :connection,
+                            :heading,
+                            :keys
+
+      def cog_orders
+        []
+      end
+
+      def orderedby?(order)
+        cog_orders.any?{|o| order <= o }
+      end
+
+      def to_cog
+        self
+      end
+
+      def to_ascii_tree
+        Support::Tree.new(self).to_text
+      end
+
+      def to_relation
+        Relation.coerce(each.to_set)
+      end
+
+    end # module Cog
+  end # class Compiler
+end # module Alf

data/lib/alf/compiler/default.rb

@@ -0,0 +1,168 @@
+module Alf
+  class Compiler
+    class Default < Compiler
+
+      def supports_reuse?
+        true
+      end
+
+      def reuse(plan, cog)
+        cog
+      end
+
+      ### non relational
+
+      def on_autonum(plan, expr, compiled)
+        factor(Engine::Autonum, expr, compiled, expr.as)
+      end
+
+      def on_clip(plan, expr, compiled)
+        factor(Engine::Clip, expr, compiled, expr.attributes, expr.allbut)
+      end
+
+      def on_coerce(plan, expr, compiled)
+        factor(Engine::Coerce, expr, compiled, expr.coercions)
+      end
+
+      def on_compact(plan, expr, compiled)
+        factor(Engine::Compact, expr, compiled)
+      end
+
+      def on_defaults(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.clip(expr.operand, expr.defaults.to_attr_list)
+        } if expr.strict
+        factor(Engine::Defaults, expr, compiled, expr.defaults)
+      end
+
+      def on_generator(plan, expr)
+        factor(Engine::Generator, expr, expr.as, 1, 1, expr.size)
+      end
+
+      def on_sort(plan, expr, compiled)
+        return compiled if compiled.orderedby?(expr.ordering)
+        factor(Engine::Sort, expr, compiled, expr.ordering)
+      end
+
+      ### relational
+
+      def on_extend(plan, expr, compiled)
+        factor(Engine::SetAttr, expr, compiled, expr.ext)
+      end
+
+      def on_frame(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          ordering = expr.total_ordering rescue expr.ordering
+          p.sort(expr.operand, ordering)
+        }
+        factor(Engine::Take, expr, compiled, expr.offset, expr.limit)
+      end
+
+      def on_group(plan, expr, compiled)
+        factor(Engine::Group::Hash, expr, compiled, expr.attributes, expr.as, expr.allbut)
+      end
+
+      def on_hierarchize(plan, expr, compiled)
+        factor(Engine::Hierarchize, expr, compiled, expr.id, expr.parent, expr.as)
+      end
+
+      def on_intersect(plan, expr, left, right)
+        factor(Engine::Join::Hash, expr, left, right)
+      end
+
+      def on_join(plan, expr, left, right)
+        factor(Engine::Join::Hash, expr, left, right)
+      end
+
+      def on_matching(plan, expr, left, right)
+        factor(Engine::Semi::Hash, expr, left, right, true)
+      end
+
+      def on_minus(plan, expr, left, right)
+        factor(Engine::Semi::Hash, expr, left, right, false)
+      end
+
+      def on_not_matching(plan, expr, left, right)
+        factor(Engine::Semi::Hash, expr, left, right, false)
+      end
+
+      def on_page(plan, expr, compiled)
+        index, size = expr.page_index, expr.page_size
+        compiled = plan.recompile(compiled){|p|
+          ordering = expr.total_ordering rescue expr.ordering
+          ordering = ordering.reverse if index < 0
+          p.sort(expr.operand, ordering)
+        }
+        factor(Engine::Take, expr, compiled, (index.abs - 1) * size, size)
+      end
+
+      def on_project(plan, expr, compiled)
+        preserving = expr.key_preserving? rescue false
+        compiled = plan.recompile(compiled){|p|
+          p.clip(expr.operand, expr.attributes, allbut: expr.allbut)
+        }
+        compiled = factor(Engine::Compact, expr, compiled) unless preserving
+        compiled
+      end
+
+      def on_quota(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.sort(expr.operand, expr.by.to_ordering + expr.order)
+        }
+        factor(Engine::Quota::Cesure, expr, compiled, expr.by, expr.summarization)
+      end
+
+      def on_rank(plan, expr, compiled)
+        compiled = plan.recompile(compiled){|p|
+          p.sort(expr.operand, expr.order)
+        }
+        factor(Engine::Rank::Cesure, expr, compiled, expr.order, expr.as)
+      end
+
+      def on_rename(plan, expr, compiled)
+        factor(Engine::Rename, expr, compiled, expr.renaming)
+      end
+
+      def on_restrict(plan, expr, compiled)
+        factor(Engine::Filter, expr, compiled, expr.predicate)
+      end
+
+      def on_summarize(plan, expr, compiled)
+        if expr.allbut
+          factor(Engine::Summarize::Hash, expr, compiled, expr.by, expr.summarization, expr.allbut)
+        else
+          compiled = plan.recompile(compiled){|p|
+            p.sort(expr.operand, expr.by.to_ordering)
+          }
+          factor(Engine::Summarize::Cesure, expr, compiled, expr.by, expr.summarization, expr.allbut)
+        end
+      end
+
+      def on_ungroup(plan, expr, compiled)
+        factor(Engine::Ungroup, expr, compiled, expr.attribute)
+      end
+
+      def on_union(plan, expr, left, right)
+        compiled = factor(Engine::Concat, expr, [left, right])
+        compiled = factor(Engine::Compact, expr, compiled)
+        #
+        compiled
+      end
+
+      def on_unwrap(plan, expr, compiled)
+        factor(Engine::Unwrap, expr, compiled, expr.attribute)
+      end
+
+      def on_wrap(plan, expr, compiled)
+        factor(Engine::Wrap, expr, compiled, expr.attributes, expr.as, expr.allbut)
+      end
+
+    private
+
+      def factor(clazz, expr, *args)
+        clazz.new(*args, expr, self)
+      end
+
+    end # class Default
+  end # class Compiler
+end # module Alf

data/lib/alf/compiler/plan.rb

@@ -0,0 +1,77 @@
+require 'tsort'
+module Alf
+  class Compiler
+    class Plan
+
+      def initialize(compiler = Compiler.new)
+        @parser        = Lang::Parser::Lispy.new
+        @compilers     = {}
+        @compiled      = {}
+        @usage_count   = Hash.new{|h,k| h[k] = 0 }
+        @main_compiler = compiler
+        join(compiler)
+      end
+      attr_reader :parser, :main_compiler
+
+      def join(compiler)
+        @compilers[compiler] ||= compiler.join(self)
+        compiler
+      end
+
+      def options(compiler)
+        @compilers[compiler]
+      end
+
+      # Pre-visit
+      def compile(sexpr)
+        visit(sexpr)
+        _compile(sexpr)
+      end
+
+      # Post-visit, pre-reuse
+      def _compile(expr)
+        compiled = @compiled[expr]
+        return @compiled[expr] = __compile(expr) unless compiled
+        return __compile(expr) unless compiler = compiled.compiler
+        return __compile(expr) unless compiler.supports_reuse?
+        compiler.reuse(self, compiled)
+      end
+
+      # Real compilation, post-reuse
+      def __compile(expr = nil, compiled = nil, &bl)
+        expr      ||= bl.call(parser)
+        compiled  ||= children(expr).map{|op| _compile(op) }
+        compiler    = compiler(compiled)
+        usage_count = @usage_count[expr]
+        compiler.compile(self, expr, compiled, usage_count)
+      rescue NotSupportedError
+        main_compiler.compile(self, expr, compiled, usage_count)
+      end
+
+      def recompile(*compiled, &bl)
+        __compile(nil, compiled, &bl)
+      end
+
+      def visit(expr)
+        @usage_count[expr] += 1
+        children(expr).each{|op| visit(op) }
+      end
+
+    private
+
+      EMPTY_CHILDREN = []
+
+      def children(expr)
+        return EMPTY_CHILDREN unless expr.is_a?(Algebra::Operator)
+        expr.operands
+      end
+
+      def compiler(compiled)
+        candidates = compiled.map(&:compiler).uniq
+        candidates.size > 1 ? main_compiler \
+                            : candidates.first || main_compiler
+      end
+
+    end # class Plan
+  end # class Compiler
+end # module Alf

data/lib/{alf-core → alf/core}/version.rb

@@ -3,7 +3,7 @@ module Alf
     module Version
 
       MAJOR = 0
-      MINOR = 14
+      MINOR = 15
       TINY  = 0
 
       def self.to_s

data/lib/{alf-database/alf → alf}/database/connection.rb

@@ -24,6 +24,7 @@ module Alf
       def reconnect(opts = {})
         close unless (opts.keys & [:schema_cache]).empty?
         @options = options.merge(opts)
+        @parser = nil
         open!
       end
 
@@ -34,6 +35,7 @@ module Alf
       def close
         adapter_connection.close unless closed?
         @adapter_connection = nil
+        @parser = nil
       end
 
       ### logical level
@@ -47,7 +49,7 @@ module Alf
       end
 
       def relvar(*args, &bl)
-        parse(*args, &bl).to_relvar
+        optimize(*args, &bl).to_relvar
       end
 
       def query(*args, &bl)
@@ -72,31 +74,14 @@ module Alf
         raise FactAssertionError, msg
       end
 
-      ### middleware level
-
-      def cog(expr, *args, &bl)
-        case expr
-        when Symbol           then adapter_connection.cog(*args.unshift(expr), &bl)
-        when Algebra::Operand then compile(expr)
-        else
-          raise ArgumentError, "Unable to compile `#{expr}` to a cog"
-        end
-      end
-
-      def lock(expr, mode = :exclusive, &bl)
-        case expr
-        when Symbol then adapter_connection.lock(expr, mode, &bl)
-        else
-          raise NotImplementedError, "Unable to lock virtual relvars"
-        end
-      end
-
       ### physical level
 
       def_delegators :adapter_connection, :in_transaction,
                                           :knows?,
                                           :heading,
                                           :keys,
+                                          :cog,
+                                          :lock,
                                           :insert,
                                           :delete,
                                           :update
@@ -111,44 +96,17 @@ module Alf
         "Alf::Database::Connection(#{adapter_connection})"
       end
 
-      def compile(expr)
-        if df = options.debug_folder
-          where, i = options.debug_naming.call(expr), 1
-          debug_dot(expr, df/"#{where}/#{i}-Algebra.dot")
-          compilation_chain.inject(expr){|e,c|
-            c.call(e).tap{|mid|
-              name = "#{i}-#{Alf::Support.class_name(c.class)}"
-              debug_dot(mid, df/"#{where}/#{name}.dot")
-              i += 1
-            }
-          }
-        else
-          compilation_chain.inject(expr){|e,c| c.call(e) }
-        end
-      end
-
     private
 
       def optimizer
-        Optimizer.new.register(Optimizer::Restrict.new, Algebra::Restrict)
-      end
-
-      def compilation_chain
-        [ optimizer, adapter_connection.compiler ]
+        Optimizer.new.tap{|op|
+          op.register(Optimizer::Restrict.new)
+          op.register(Optimizer::Project.new)
+        }
       end
 
       def parser
-        options.viewpoint.parser(self)
-      end
-
-      def debug_dot(e, where)
-        where.parent.mkdir_p
-        where.open('w') do |io|
-          e.to_dot(io)
-        end
-      rescue => ex
-        $stderr.puts ex.message
-        $stderr.puts ex.backtrace.join("\n")
+        @parser ||= options.parser.new([ options.viewpoint ], self)
       end
 
     end # class Connection