alf-core 0.13.1 → 0.14.0

data/lib/alf-database/alf/database/connection.rb

@@ -111,8 +111,6 @@ module Alf
         "Alf::Database::Connection(#{adapter_connection})"
       end
 
-    private
-
       def compile(expr)
         if df = options.debug_folder
           where, i = options.debug_naming.call(expr), 1
@@ -129,6 +127,8 @@ module Alf
         end
       end
 
+    private
+
       def optimizer
         Optimizer.new.register(Optimizer::Restrict.new, Algebra::Restrict)
       end

data/lib/alf-database/alf/database/options.rb

@@ -8,9 +8,6 @@ module Alf
       # What viewpoint to use by default?
       option :viewpoint, Module, Viewpoint::NATIVE
 
-      alias :default_viewpoint  :viewpoint
-      alias :default_viewpoint= :viewpoint=
-
       # Path to a folder where debugging graphs can be found
       option :debug_folder, Path, nil
 

data/lib/alf-engine/alf/engine.rb

@@ -6,8 +6,9 @@ module Alf
   end # module Engine
 end # module Alf
 require_relative 'engine/cog'
+require_relative 'engine/support/cesure'
+
 require_relative 'engine/leaf'
-require_relative 'engine/cesure'
 require_relative 'engine/autonum'
 require_relative 'engine/clip'
 require_relative 'engine/coerce'
@@ -17,6 +18,7 @@ require_relative 'engine/defaults'
 require_relative 'engine/sort'
 require_relative 'engine/set_attr'
 require_relative 'engine/filter'
+require_relative 'engine/hierarchize'
 require_relative 'engine/concat'
 require_relative 'engine/aggregate'
 require_relative 'engine/rename'
@@ -29,6 +31,7 @@ require_relative 'engine/unwrap'
 require_relative 'engine/summarize'
 require_relative 'engine/rank'
 require_relative 'engine/quota'
+require_relative 'engine/take'
 require_relative 'engine/ungroup'
 require_relative 'engine/infer_heading'
 require_relative 'engine/type_safe'

data/lib/alf-engine/alf/engine/aggregate.rb

@@ -27,7 +27,8 @@ module Alf
       attr_reader :summarization
 
       # Creates an Aggregate instance
-      def initialize(operand, summarization)
+      def initialize(operand, summarization, expr = nil)
+        super(expr)
         @operand = operand
         @summarization = summarization
       end

data/lib/alf-engine/alf/engine/autonum.rb

@@ -26,7 +26,8 @@ module Alf
       attr_reader :as
 
       # Creates an Autonum instance
-      def initialize(operand, as)
+      def initialize(operand, as, expr = nil)
+        super(expr)
         @operand = operand
         @as = as
       end

data/lib/alf-engine/alf/engine/clip.rb

@@ -35,7 +35,8 @@ module Alf
       attr_reader :allbut
 
       # Creates an Clip instance
-      def initialize(operand, attributes, allbut)
+      def initialize(operand, attributes, allbut, expr = nil)
+        super(expr)
         @operand = operand
         @attributes = attributes
         @allbut = allbut

data/lib/alf-engine/alf/engine/coerce.rb

@@ -27,7 +27,8 @@ module Alf
       attr_reader :coercions
 
       # Creates an Coerce instance
-      def initialize(operand, coercions)
+      def initialize(operand, coercions, expr = nil)
+        super(expr)
         @operand = operand
         @coercions = coercions
       end

data/lib/alf-engine/alf/engine/cog.rb

@@ -3,6 +3,29 @@ module Alf
     module Cog
       include Enumerable
 
+      attr_reader :expr
+
+      def initialize(expr)
+        if expr && !expr.is_a?(Algebra::Operand)
+          raise "Operand expected as first cog argument"
+        end
+        @expr = expr
+      end
+
+      def heading
+        return expr.heading if expr
+        raise NotSupportedError, "Cog#heading without expr traceability"
+      end
+
+      def keys
+        return expr.keys if expr
+        raise NotSupportedError, "Cog#keys without expr traceability"
+      end
+
+      def to_cog
+        self
+      end
+
       def to_relation
         Relation.coerce(to_a)
       end

data/lib/alf-engine/alf/engine/compact.rb

@@ -10,13 +10,14 @@ module Alf
       attr_reader :operand
 
       # Creates a Compact instance
-      def initialize(operand)
+      def initialize(operand, expr = nil)
+        super(expr)
         @operand = operand
       end
 
       # (see Cog#each)
       def _each(&block)
-        Compact::Uniq.new(operand).each(&block)
+        Compact::Uniq.new(operand, expr).each(&block)
       end
 
     end # class Compact

data/lib/alf-engine/alf/engine/compact/set.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :operand
 
       # Creates a Compact::Set instance
-      def initialize(operand)
+      def initialize(operand, expr = nil)
+        super(expr)
         @operand = operand
       end
 

data/lib/alf-engine/alf/engine/compact/uniq.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :operand
 
       # Creates a Compact::Uniq instance
-      def initialize(operand)
+      def initialize(operand, expr = nil)
+        super(expr)
         @operand = operand
       end
 

data/lib/alf-engine/alf/engine/compiler.rb

@@ -17,126 +17,153 @@ module Alf
       ### non relational
 
       def on_autonum(expr)
-        Autonum.new(apply(expr.operand), expr.as)
+        Autonum.new(apply(expr.operand), expr.as, expr)
       end
 
       def on_clip(expr)
-        Clip.new(apply(expr.operand), expr.attributes, expr.allbut)
+        Clip.new(apply(expr.operand), expr.attributes, expr.allbut, expr)
       end
 
       def on_coerce(expr)
-        Coerce.new(apply(expr.operand), expr.coercions)
+        Coerce.new(apply(expr.operand), expr.coercions, expr)
       end
 
       def on_compact(expr)
-        Compact.new(apply(expr.operand))
+        Compact.new(apply(expr.operand), expr)
       end
 
       def on_defaults(expr)
-        op = Defaults.new(apply(expr.operand), expr.defaults)
-        op = Clip.new(op, expr.defaults.to_attr_list, false) if expr.strict
+        op = Defaults.new(apply(expr.operand), expr.defaults, expr)
+        op = Clip.new(op, expr.defaults.to_attr_list, false, expr) if expr.strict
         op
       end
 
       def on_generator(expr)
-        Generator.new(expr.as, 1, 1, expr.size)
+        Generator.new(expr.as, 1, 1, expr.size, expr)
       end
 
       def on_sort(expr)
-        Sort.new(apply(expr.operand), expr.ordering)
+        Sort.new(apply(expr.operand), expr.ordering, expr)
       end
 
       def on_type_safe(expr)
         checker = TypeCheck.new(expr.heading, expr.strict)
-        TypeSafe.new(apply(expr.operand), checker)
+        TypeSafe.new(apply(expr.operand), checker, expr)
       end
 
       ### relational
 
       def on_extend(expr)
-        SetAttr.new(apply(expr.operand), expr.ext)
+        SetAttr.new(apply(expr.operand), expr.ext, expr)
+      end
+
+      def on_frame(expr)
+        offset, limit = expr.offset, expr.limit
+        ordering = unsupported(expr.ordering){ expr.total_ordering }
+        op = Sort.new(apply(expr.operand), ordering, expr)
+        op = Take.new(op, offset, limit, expr)
+      end
+
+      def on_page(expr)
+        index, size = expr.page_index, expr.page_size
+        ordering = unsupported(expr.ordering){ expr.total_ordering }
+        ordering = ordering.reverse if index < 0
+        op = Sort.new(apply(expr.operand), ordering, expr)
+        op = Take.new(op, (index.abs - 1) * size, size, expr)
       end
 
       def on_group(expr)
-        Group::Hash.new(apply(expr.operand), expr.attributes, expr.as, expr.allbut)
+        Group::Hash.new(apply(expr.operand), expr.attributes, expr.as, expr.allbut, expr)
+      end
+
+      def on_hierarchize(expr)
+        Hierarchize.new(apply(expr.operand), expr.id, expr.parent, expr.as)
       end
 
       def on_infer_heading(expr)
-        InferHeading.new(apply(expr.operand))
+        InferHeading.new(apply(expr.operand), expr)
       end
 
       def on_intersect(expr)
-        Join::Hash.new(apply(expr.left), apply(expr.right))
+        Join::Hash.new(apply(expr.left), apply(expr.right), expr)
       end
 
       def on_join(expr)
-        Join::Hash.new(apply(expr.left), apply(expr.right))
+        Join::Hash.new(apply(expr.left), apply(expr.right), expr)
       end
 
       def on_matching(expr)
-        Semi::Hash.new(apply(expr.left), apply(expr.right), true)
+        Semi::Hash.new(apply(expr.left), apply(expr.right), true, expr)
       end
 
       def on_minus(expr)
-        Semi::Hash.new(apply(expr.left), apply(expr.right), false)
+        Semi::Hash.new(apply(expr.left), apply(expr.right), false, expr)
       end
 
       def on_not_matching(expr)
-        Semi::Hash.new(apply(expr.left), apply(expr.right), false)
+        Semi::Hash.new(apply(expr.left), apply(expr.right), false, expr)
       end
 
       def on_project(expr)
-        op = Clip.new(apply(expr.operand), expr.attributes, expr.allbut)
-        op = Compact.new(op)
+        op = Clip.new(apply(expr.operand), expr.attributes, expr.allbut, expr)
+        op = Compact.new(op, expr)
         op
       end
 
       def on_quota(expr)
-        op = Sort.new(apply(expr.operand), expr.by.to_ordering + expr.order)
-        op = Quota::Cesure.new(op, expr.by, expr.summarization)
+        op = Sort.new(apply(expr.operand), expr.by.to_ordering + expr.order, expr)
+        op = Quota::Cesure.new(op, expr.by, expr.summarization, expr)
         op
       end
 
       def on_rank(expr)
-        op = Sort.new(apply(expr.operand), expr.order)
-        op = Rank::Cesure.new(op, expr.order, expr.as)
+        op = Sort.new(apply(expr.operand), expr.order, expr)
+        op = Rank::Cesure.new(op, expr.order.to_attr_list, expr.as, expr)
         op
       end
 
       def on_rename(expr)
-        Rename.new(apply(expr.operand), expr.renaming)
+        Rename.new(apply(expr.operand), expr.renaming, expr)
       end
 
       def on_restrict(expr)
-        Filter.new(apply(expr.operand), expr.predicate)
+        Filter.new(apply(expr.operand), expr.predicate, expr)
       end
 
       def on_summarize(expr)
         if expr.allbut
-          Summarize::Hash.new(apply(expr.operand), expr.by, expr.summarization, expr.allbut)
+          Summarize::Hash.new(apply(expr.operand), expr.by, expr.summarization, expr.allbut, expr)
         else
-          op = Sort.new(apply(expr.operand), expr.by.to_ordering)
-          op = Summarize::Cesure.new(op, expr.by, expr.summarization, expr.allbut)
+          op = Sort.new(apply(expr.operand), expr.by.to_ordering, expr)
+          op = Summarize::Cesure.new(op, expr.by, expr.summarization, expr.allbut, expr)
           op
         end
       end
 
       def on_ungroup(expr)
-        Ungroup.new(apply(expr.operand), expr.attribute)
+        Ungroup.new(apply(expr.operand), expr.attribute, expr)
       end
 
       def on_union(expr)
-        op = Concat.new([apply(expr.left), apply(expr.right)])
-        op = Compact.new(op)
+        op = Concat.new([apply(expr.left), apply(expr.right)], expr)
+        op = Compact.new(op, expr)
         op
       end
 
       def on_unwrap(expr)
-        Unwrap.new(apply(expr.operand), expr.attribute)
+        Unwrap.new(apply(expr.operand), expr.attribute, expr)
       end
 
       def on_wrap(expr)
-        Wrap.new(apply(expr.operand), expr.attributes, expr.as, expr.allbut)
+        Wrap.new(apply(expr.operand), expr.attributes, expr.as, expr.allbut, expr)
+      end
+
+    protected
+
+      def unsupported(fallback, &bl)
+        bl.call
+      rescue NotSupportedError
+        fallback
       end
 
     end # class Compiler

data/lib/alf-engine/alf/engine/concat.rb

@@ -10,7 +10,8 @@ module Alf
       attr_reader :operands
 
       # Creates a Concat instance
-      def initialize(operands)
+      def initialize(operands, expr = nil)
+        super(expr)
         @operands = operands
       end
 

data/lib/alf-engine/alf/engine/defaults.rb

@@ -25,7 +25,8 @@ module Alf
       attr_reader :defaults
 
       # Creates a Defaults instance
-      def initialize(operand, defaults)
+      def initialize(operand, defaults, expr = nil)
+        super(expr)
         @operand = operand
         @defaults = defaults
       end

data/lib/alf-engine/alf/engine/filter.rb

@@ -24,7 +24,8 @@ module Alf
       attr_reader :predicate
 
       # Creates a Filter instance
-      def initialize(operand, predicate)
+      def initialize(operand, predicate, expr = nil)
+        super(expr)
         @operand = operand
         @predicate = predicate
       end
@@ -33,7 +34,8 @@ module Alf
       def _each
         scope = tuple_scope
         operand.each do |tuple|
-          yield(tuple) if @predicate.evaluate(scope.__set_tuple(tuple))
+          t, c = scope.__set_tuple(tuple), expr && expr.connection
+          yield(tuple) if @predicate.evaluate(t, c)
         end
       end
 

data/lib/alf-engine/alf/engine/generator.rb

@@ -29,7 +29,8 @@ module Alf
       attr_reader :count
 
       # Creates an Generator instance
-      def initialize(as, offset, step, count)
+      def initialize(as, offset, step, count, expr = nil)
+        super(expr)
         @as = as
         @offset = offset
         @step = step

data/lib/alf-engine/alf/engine/group/hash.rb

@@ -19,7 +19,8 @@ module Alf
       attr_reader :allbut
 
       # Creates a Group::Hash instance
-      def initialize(operand, attributes, as, allbut)
+      def initialize(operand, attributes, as, allbut, expr = nil)
+        super(expr)
         @operand = operand
         @attributes = attributes
         @as = as
@@ -29,9 +30,9 @@ module Alf
       # (see Cog#each)
       def _each(&block)
         atr, alb = @attributes, @allbut
-        index = Materialize::Hash.new(operand, atr, !alb)
+        index = Materialize::Hash.new(operand, atr, !alb, expr)
         index.each_pair do |k,v|
-          grouped = Clip.new(v, atr, alb).to_relation
+          grouped = Clip.new(v, atr, alb, expr).to_relation
           yield k.merge(@as => grouped)
         end
       end

data/lib/alf-engine/alf/engine/hierarchize.rb

@@ -0,0 +1,87 @@
+module Alf
+  module Engine
+    class Hierarchize
+      include Cog
+
+      # @return [Enumerable] The operand
+      attr_reader :operand
+
+      # @return [AttrList] Attribute list of the id
+      attr_reader :id
+
+      # @return [AttrList] Attribute list for the parent
+      attr_reader :parent
+
+      # @return [AttrName] Attribute name for children
+      attr_reader :children
+
+      # @return [Class] the type of the children relation
+      attr_reader :relation_type
+
+      # @return [Class] the type of the children tuples
+      attr_reader :tuple_type
+
+      # Creates a Hierarchize instance
+      def initialize(operand, id, parent, children, expr = nil)
+        super(expr)
+        @operand = operand
+        @id = id
+        @parent = parent
+        @children = children
+      end
+
+      # (see Cog#each)
+      def _each(&block)
+        by_id = Hash.new{|h,k| h[k] = {children => nil} }
+        operand.each do |tuple|
+          tuple = tuple.to_hash
+          infer_types(tuple) unless @relation_type
+
+          # extract my key and my parent's key
+          tuple_key, parent_key = keys_of(tuple)
+
+          # this will be my tuple
+          by_id[tuple_key] = tuple.merge(by_id[tuple_key])
+
+          # add me to my parent unless same tuple
+          unless tuple_key==parent_key
+            my_tuple = tuple_type.new(by_id[tuple_key])
+            by_id[parent_key][children] ||= relation_type.new(Set.new)
+            by_id[parent_key][children].send(:reused_instance) << my_tuple
+          end
+        end
+
+        # Now output tuples that are their own parent
+        by_id.each_pair do |k,tuple|
+          tuple_key, parent_key = keys_of(tuple)
+          tuple[children] ||= relation_type.empty
+          yield(tuple) if tuple_key==parent_key
+        end
+      end
+
+      def to_relation
+        tuples = to_set
+        relation_type.new(tuples)
+      end
+
+    private
+
+      def infer_types(tuple)
+        heading = Tuple(tuple).heading
+        @relation_type = Relation.type(heading){|r| { children => r } }
+        @tuple_type    = Tuple.type(heading){|r| { children => @relation_type } }
+      end
+
+      def renamer
+        @renamer ||= Renaming.new(Hash[parent.to_a.zip(id.to_a)])
+      end
+
+      def keys_of(tuple)
+        tuple_key  = id.project_tuple(tuple)
+        parent_key = renamer.rename_tuple(parent.project_tuple(tuple))
+        [ tuple_key, parent_key ]
+      end
+
+    end # class Hierarchize
+  end # module Engine
+end # module Alf