alf-core 0.14.0 → 0.15.0

data/lib/{alf-optimizer/alf → alf}/optimizer/restrict.rb

@@ -1,55 +1,57 @@
 module Alf
   class Optimizer
-    class Restrict < Algebra::Rewriter
-      include Lang::Functional
+    class Restrict < Optimizer::Base
 
     ### overridings
 
-      def call(restrict, search = nil)
-        apply(restrict.operand, restrict.predicate)
-      rescue NotSupportedError
-        restrict
+      def search_predicate
+        Algebra::Restrict
+      end
+
+      def _call(restrict, search)
+        apply(restrict.operand, restrict.predicate, search)
       end
 
       def restrict(operand, predicate)
         check_constant(operand, predicate){ super }
       end
 
-      def apply(operand, predicate)
+      def apply(operand, predicate, search)
         check_constant(operand, predicate){ super }
+      rescue NotSupportedError
+        restrict(operand, predicate)
       end
 
     # leaf Operand, recursion end :-)
 
-      def on_leaf_operand(expr, predicate)
+      def on_leaf_operand(expr, predicate, search)
         restrict(expr, predicate)
       end
       alias :on_missing :on_leaf_operand
 
     ### pass through, unoptimizable, binary optimizable
 
-      def on_pass_through(expr, predicate)
-        expr.with_operands(*expr.operands.map{|op| apply(op, predicate)})
+      def on_pass_through(expr, predicate, search)
+        expr.with_operands(*expr.operands.map{|op| apply(op, predicate, search) })
       end
+      alias :on_allbut      :on_pass_through
       alias :on_clip        :on_pass_through
       alias :on_compact     :on_pass_through
       alias :on_sort        :on_pass_through
-      alias :on_type_safe  :on_pass_through
       alias :on_project     :on_pass_through
       alias :on_intersect   :on_pass_through
       alias :on_minus       :on_pass_through
       alias :on_union       :on_pass_through
 
-      def on_unoptimizable(expr, predicate)
-        restrict(expr, predicate)
+      def on_unoptimizable(expr, predicate, search)
+        restrict(search.call(expr), predicate)
       end
       alias :on_generator     :on_unoptimizable
-      alias :on_infer_heading :on_unoptimizable
       alias :on_page          :on_unoptimizable
       alias :on_frame         :on_unoptimizable
 
-      def on_binary_optimizable(expr, predicate)
-        binary_split(expr, predicate)
+      def on_binary_optimizable(expr, predicate, search)
+        binary_split(expr, predicate, search)
       end
       alias :on_join         :on_binary_optimizable
       alias :on_matching     :on_binary_optimizable
@@ -57,69 +59,65 @@ module Alf
 
     ### non relational
 
-      def on_autonum(expr, predicate)
-        unary_split(expr, predicate, AttrList[expr.as])
+      def on_autonum(expr, predicate, search)
+        unary_split(expr, predicate, AttrList[expr.as], search)
       end
 
-      def on_coerce(expr, predicate)
-        unary_split(expr, predicate, expr.coercions.to_attr_list)
+      def on_coerce(expr, predicate, search)
+        unary_split(expr, predicate, expr.coercions.to_attr_list, search)
       end
 
-      def on_defaults(expr, predicate)
-        unary_split(expr, predicate, expr.defaults.to_attr_list)
+      def on_defaults(expr, predicate, search)
+        unary_split(expr, predicate, expr.defaults.to_attr_list, search)
       end
 
     ### relational
 
-      def on_extend(expr, predicate)
-        unary_split(expr, predicate, expr.ext.to_attr_list)
+      def on_extend(expr, predicate, search)
+        unary_split(expr, predicate, expr.ext.to_attr_list, search)
       end
 
-      def on_group(expr, predicate)
-        unary_split(expr, predicate, AttrList[expr.as])
+      def on_group(expr, predicate, search)
+        unary_split(expr, predicate, AttrList[expr.as], search)
       end
 
-      def on_quota(expr, predicate)
-        unary_split(expr, predicate, expr.summarization.to_attr_list)
+      def on_quota(expr, predicate, search)
+        unary_split(expr, predicate, expr.summarization.to_attr_list, search)
       end
 
-      def on_rank(expr, predicate)
-        unary_split(expr, predicate, AttrList[expr.as])
+      def on_rank(expr, predicate, search)
+        unary_split(expr, predicate, AttrList[expr.as], search)
       end
 
-      def on_rename(expr, predicate)
-        begin
-          predicate = predicate.rename(expr.renaming.invert)
-        rescue NotSupportedError
-          return restrict(expr, predicate)
-        end
-        on_pass_through(expr, predicate)
+      def on_rename(expr, predicate, search)
+        predicate = predicate.rename(expr.renaming.invert)
+        on_pass_through(expr, predicate, search)
       end
 
-      def on_restrict(expr, predicate)
+      def on_restrict(expr, predicate, search)
         if predicate.native? or expr.predicate.native?
           restrict(expr, predicate)
         else
-          apply(expr.operand, predicate & expr.predicate)
+          apply(expr.operand, predicate & expr.predicate, search)
         end
       end
 
-      def on_summarize(expr, predicate)
-        unary_split(expr, predicate, expr.summarization.to_attr_list)
+      def on_summarize(expr, predicate, search)
+        unary_split(expr, predicate, expr.summarization.to_attr_list, search)
       end
 
-      def on_ungroup(expr, predicate)
+      def on_ungroup(expr, predicate, search)
         # TODO:
         restrict(expr, predicate)
       end
 
-      def on_unwrap(expr, predicate)
+      def on_unwrap(expr, predicate, search)
         # TODO:
         restrict(expr, predicate)
       end
 
-      def on_wrap(expr, predicate)
-        unary_split(expr, predicate, AttrList[expr.as])
+      def on_wrap(expr, predicate, search)
+        unary_split(expr, predicate, AttrList[expr.as], search)
       end
 
     ### Splitting rules
@@ -135,12 +133,12 @@ module Alf
         end
       end
 
-      def unary_split(expr, predicate, attr_list)
+      def unary_split(expr, predicate, attr_list, search)
         top, down = predicate.and_split(attr_list)
-        restrict(expr.with_operand(apply(expr.operand, down)), top)
+        restrict(expr.with_operand(apply(expr.operand, down, search)), top)
       end
 
-      def binary_split(expr, predicate)
+      def binary_split(expr, predicate, search)
         left_attrs, right_attrs = expr.operands.map{|op| op.heading.to_attr_list }
         left_only,  right_only  = left_attrs - right_attrs, right_attrs - left_attrs
 
@@ -156,8 +154,8 @@ module Alf
 
         # basic join with restricted operands
         join = expr.with_operands(
-          apply(expr.left, left_pred),
-          apply(expr.right, right_pred))
+          apply(expr.left, left_pred, search),
+          apply(expr.right, right_pred, search))
 
         if left_top.tautology? || right_top.tautology?
           # everything is already covered by one restriction pushed

data/lib/{alf-predicate/alf → alf}/predicate.rb

@@ -1,14 +1,14 @@
-require_relative 'predicate/parser'
 require_relative 'predicate/factory'
 require_relative 'predicate/grammar'
 require_relative 'predicate/processors'
 module Alf
   class Predicate
 
-    def initialize(expr)
-      @expr = expr
+    def initialize(sexpr)
+      @sexpr = sexpr
     end
-    attr_reader :expr
+    attr_reader :sexpr
+    alias :expr :sexpr
 
     class << self
       include Factory
@@ -18,10 +18,9 @@ module Alf
         when Predicate   then arg
         when TrueClass   then tautology
         when FalseClass  then contradiction
-        when Symbol      then var_ref(arg)
+        when Symbol      then identifier(arg)
         when Proc        then native(arg)
         when Hash, Tuple then eq(arg)
-        when String      then Predicate.new(Grammar.parse(arg))
         when Relation    then relation(arg)
         else
           raise ArgumentError, "Unable to coerce `#{arg}` to a predicate"
@@ -73,11 +72,15 @@ module Alf
       Predicate.new(!expr)
     end
 
+    def qualify(qualifier)
+      Predicate.new(expr.qualify(qualifier))
+    end
+
     def rename(renaming)
       Predicate.new(expr.rename(renaming))
     end
 
-    def evaluate(scope, connection = nil)
+    def evaluate(scope)
       proc = to_proc
       if proc.arity == 1
         proc.call(scope)
@@ -93,26 +96,27 @@ module Alf
     def ==(other)
       other.is_a?(Predicate) && (other.expr==expr)
     end
+    alias :eql? :==
 
     def hash
       expr.hash
     end
 
-    def to_ruby_code
-      @ruby_code ||= expr.to_ruby_code(:scope => "self")
+    def to_ruby_code(scope = "t")
+      expr.to_ruby_code(scope)
     end
     alias :to_s :to_ruby_code
 
     def to_proc
-      @proc ||= expr.to_proc(:scope => "self")
+      @proc ||= expr.to_proc("t")
     end
 
     def to_lispy
-      "->{ #{to_ruby_code} }"
+      to_ruby_code
     end
 
     def to_ruby_literal
-      to_proc.to_ruby_literal
+      to_lispy
     end
 
   end # class Predicate

data/lib/{alf-predicate/alf → alf}/predicate/factory.rb

@@ -10,8 +10,12 @@ module Alf
         _factor_predicate([:contradiction, false])
       end
 
-      def var_ref(name)
-        _factor_predicate([:var_ref, name])
+      def identifier(name)
+        _factor_predicate([:identifier, name])
+      end
+
+      def qualified_identifier(qualifier, name)
+        _factor_predicate([:qualified_identifier, qualifier, name])
       end
 
       def and(left, right = nil)
@@ -41,10 +45,11 @@ module Alf
         end
       end
 
-      def in(var_ref, values)
-        var_ref = sexpr(var_ref) if var_ref.is_a?(Symbol)
-        _factor_predicate([:in, var_ref, values])
+      def in(identifier, values)
+        identifier = sexpr(identifier) if identifier.is_a?(Symbol)
+        _factor_predicate([:in, identifier, values])
       end
+      alias :among :in
 
       def comp(op, h)
         h = h.to_hash
@@ -76,8 +81,8 @@ module Alf
         _factor_predicate([:literal, literal])
       end
 
-      def native(proc)
-        _factor_predicate([:native, proc])
+      def native(arg)
+        _factor_predicate([:native, arg])
       end
 
       def sexpr(expr)
@@ -86,7 +91,7 @@ module Alf
         when Predicate  then expr.expr
         when TrueClass  then Grammar.sexpr([:tautology, true])
         when FalseClass then Grammar.sexpr([:contradiction, false])
-        when Symbol     then Grammar.sexpr([:var_ref, expr])
+        when Symbol     then Grammar.sexpr([:identifier, expr])
         when Proc       then Grammar.sexpr([:native, expr])
         when Array      then Grammar.sexpr(expr)
         else

data/lib/{alf-predicate/alf → alf}/predicate/grammar.rb

@@ -11,10 +11,6 @@ module Alf
         Expr
       end
 
-      def parser
-        Parser.new
-      end
-
     end
   end # class Predicate
 end # module Alf
@@ -23,7 +19,8 @@ require_relative 'nodes/dyadic_comp'
 require_relative 'nodes/nadic_bool'
 require_relative 'nodes/tautology'
 require_relative 'nodes/contradiction'
-require_relative 'nodes/var_ref'
+require_relative 'nodes/identifier'
+require_relative 'nodes/qualified_identifier'
 require_relative 'nodes/and'
 require_relative 'nodes/or'
 require_relative 'nodes/not'

data/lib/{alf-predicate/alf → alf}/predicate/grammar.sexp.yml

@@ -2,7 +2,7 @@ rules:
   predicate:
     - tautology
     - contradiction
-    - var_ref
+    - identifier
     - not
     - and
     - or
@@ -18,8 +18,10 @@ rules:
     - [ true ]
   contradiction:
     - [ false ]
-  var_ref:
-    - [ var_name ]
+  identifier:
+    - [ name ]
+  qualified_identifier:
+    - [ name, name ]
   not:
     - [ predicate ]
   and:
@@ -39,16 +41,18 @@ rules:
   gte:
     - [ term, term ]
   in:
-    - [ var_ref, values ]
+    - [ varref, values ]
   term:
-    - var_ref
+    - varref
     - literal
+  varref:
+    - qualified_identifier
+    - identifier
   native:
     - [ "::Proc" ]
   literal:
     - "::Object"
   values:
     - "::Object"
-  var_name:
+  name:
     !ruby/regexp /^[a-zA-Z0-9_]+[?!]?$/
-

data/lib/{alf-predicate/alf → alf}/predicate/nodes/expr.rb

@@ -41,19 +41,24 @@ module Alf
       end
 
       def rename(renaming)
-        Renamer.call(self, :renaming => renaming.to_hash)
+        Renamer.call(self, :renaming => renaming)
+      end
+
+      def qualify(qualifier)
+        Qualifier.new(qualifier).call(self)
       end
 
       def constant_variables
         AttrList::EMPTY
       end
 
-      def to_ruby_code(options = {})
-        ToRubyCode.call(self, options)
+      def to_ruby_code(scope = 't')
+        code = ToRubyCode.call(self, scope: scope)
+        "->(t){ #{code} }"
       end
 
-      def to_proc(options = {})
-        ToProc.call(self, options)
+      def to_proc(scope = 't')
+        Kernel.eval(to_ruby_code(scope))
       end
 
       def sexpr(arg)

data/lib/{alf-predicate/alf/predicate/nodes/var_ref.rb → alf/predicate/nodes/identifier.rb}

@@ -1,18 +1,18 @@
 module Alf
   class Predicate
-    module VarRef
+    module Identifier
       include Expr
 
       def priority
         100
       end
 
-      def var_name
+      def name
         self[1]
       end
 
       def free_variables
-        @free_variables ||= AttrList[ var_name ]
+        @free_variables ||= AttrList[ name ]
       end
 
     end