alf-core 0.13.1 → 0.14.0

data/CHANGELOG.md

@@ -1,3 +1,80 @@
+# 0.14.0 / 01-10-2013
+
+## Types
+
+* Introduced Selector as an ordered list of attribute names. An Ordering is now
+  a list of [Selector, (:asc|:desc)] pairs.
+* Introduced Selection as an ordered list of Selectors.
+* Accordingly, orderings may now include selections on tuple-valued attributes.
+* Added Ordering#[] that returns the direction associated to an attribute.
+* Added Ordering#reverse that reverse the direction of every attribute.
+* Fixed Ordering#+ to avoid duplicate attributes. This operator is now called
+  `merge` (with alias to `+`) and looks like Hash#merge, including an block to
+  arbitrate conflicts.
+* Removed Keys#compact which was seriously confusing.
+* TupleExpression now recognizes Procs of arity 1 and simply call them with the
+  tuple scope instead of `instance_exec`uting them on the scope. Predicate does
+  something similar when native predicates are used.
+* TupleExpression optionnaly accepts a connection argument. When the evaluated
+  expression ends-up being a relational expression, the latter is evaluated on
+  the connection and returns the resulting relation. TupleComputation delegates
+  accordingly.
+
+## Support
+
+* TupleScope now delegates to_s, inspect and [] to the underlying tuple. This
+  should fix the freezing bug that occured when an error was raised during
+  TupleScope-driven evaluations.
+* Removed TupleScope#query and TupleScoe#tuple_extract
+
+## Relation
+
+* Added Relation#to_hash for getting hashes from any attribute pair.
+
+## Viewpoint
+
+* Added `Viewpoint.(expects,depends)` for declaring expectations and dependencies
+* Added `Viewpoint.metadata` to query those expectations and dependencies
+* Added `Viewpoint.build` to build viewpoints (with particular contexts)
+* Removed `Viewpoint.namespace`, use `Viewpoint.depends` instead.
+
+## Algebra
+
+* Fixed Project#keys and Project#key_preserving? (same for Clip)
+* Added `page` operator (page-index, page-size) implemented through `sort+take`
+  where `take` is a new engine cog.
+* Added `frame` operator (offset, limit àla SQL) implemented through `sort+take`
+  as well.
+* Extend now recognizes Procs of arity 1. Instead of relying on instance_exec,
+  underlying expressions are evaluated by passing a TupleScope to the proc.
+* Extend automatically evaluates relational expressions returned by procs,
+  bounding them to the current connection if needed.
+
+## Engine & compilation
+
+* All engine-compiled cogs may optionally be tagged with the expression they
+  come from (as taken as last argument of initialize, and readable through
+  `expr`).
+* The default compiler uses this feature so that algebra expressions can be
+  tracked back from compilation results.
+
+## Adapter
+
+* Adapter::Connection#cog now takes an optional `expr` parameter for
+  traceability with algebra expressions. The resulting cog is expected to be
+  tagged accordingly.
+
+## I/O
+
+* Added a `Ruby` input reader mapping to '.rb' and '.ruby' files.
+* Reader no longer includes `Engine::Cog`. `Adapter::Folder::Connection`
+  correctly adapts its `cog` method to return an Engine::Leaf instance that
+  delegated to the reader itself.
+
+## Database
+
+* The `default_viewpoint` option has been renamed `viewpoint`
+
 # 0.13.1 / 2013-08-05
 
 * Empty lines are silently ignored by .rash reader

data/examples/operators/page.alf

@@ -0,0 +1,4 @@
+#!/usr/bin/env alf
+
+# second suppliers page, with page size of 50
+(page suppliers, [[:city, :asc]], 2, page_size: 50)

data/lib/alf-adapter-fs/alf/adapter/folder.rb

@@ -15,6 +15,10 @@ module Alf
         Folder::Connection.new(Path(conn_spec))
       end
 
+      def to_s
+        "Alf::Adapter::Folder(#{conn_spec})"
+      end
+
       Adapter.register(:folder, self)
     end # class Folder
   end # class Adapter

data/lib/alf-adapter-fs/alf/adapter/folder/connection.rb

@@ -11,9 +11,10 @@ module Alf
         end
 
         # Returns a cog for `name`
-        def cog(name)
+        def cog(name, expr = nil)
           if f = find_file(name)
-            Reader.reader(find_file(name))
+            reader = Reader.reader(find_file(name))
+            Alf::Engine::Leaf.new(reader, expr)
           else
             raise NoSuchRelvarError, "Unable to find a file for #{name}"
           end

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

@@ -49,7 +49,7 @@ module Alf
       ### read-only methods
 
       # Returns a cog for a given name
-      def cog(name)
+      def cog(name, expr = nil)
         raise NotSupportedError, "Unable to serve cog `#{name}` in `#{self}`"
       end
 

data/lib/alf-algebra/alf/algebra/operand.rb

@@ -21,7 +21,7 @@ module Alf
       ### Static analysis & inference
 
       def heading
-        raise NotSupportedError
+        raise NotSupportedError, "Heading inference unsupported on `#{self}`"
       end
 
       def attr_list
@@ -29,7 +29,7 @@ module Alf
       end
 
       def keys
-        raise NotSupportedError
+        raise NotSupportedError, "Key inference unsupported on `#{self}`"
       end
 
       ### to_xxx

data/lib/alf-algebra/alf/algebra/operand/fake.rb

@@ -29,7 +29,7 @@ module Alf
         end
 
         def heading
-          @attributes[:heading] || connection!.heading(name)
+          @attributes[:heading] || (connection && connection.heading(name)) || super
         end
 
         def keys
@@ -37,11 +37,11 @@ module Alf
         end
 
         def to_relvar
-          Relvar::Fake.new(heading)
+          Relvar::Fake.new(self, heading)
         end
 
         def to_cog
-          Engine::Leaf.new([])
+          Engine::Leaf.new([], self)
         end
 
         def to_lispy

data/lib/alf-algebra/alf/algebra/operand/named.rb

@@ -19,7 +19,7 @@ module Alf
         end
 
         def to_relvar
-          Relvar::Base.new(name, connection)
+          Relvar::Base.new(self)
         end
 
         def to_s

data/lib/alf-algebra/alf/algebra/operand/proxy.rb

@@ -9,6 +9,16 @@ module Alf
         end
         attr_reader :subject
 
+        def heading
+          return subject.heading if subject.respond_to?(:heading)
+          super
+        end
+
+        def keys
+          return subject.keys if subject.respond_to?(:keys)
+          super
+        end
+
         def to_cog
           return subject.to_cog if subject.respond_to?(:to_cog)
           Alf::Engine::Leaf.new(subject)
@@ -19,6 +29,10 @@ module Alf
           super
         end
 
+        def to_s
+          "Operand::Proxy(#{subject})"
+        end
+
       end # class Proxy
     end # module Operand
   end # module Algebra

data/lib/alf-algebra/alf/algebra/operator.rb

@@ -70,7 +70,7 @@ module Alf
       alias :to_s :to_lispy
 
       def to_relvar
-        Relvar::Virtual.new(self, connection)
+        Relvar::Virtual.new(self)
       end
 
     ### identity and pseudo-mutability
@@ -115,6 +115,8 @@ require_relative 'operator/type_safe'
 require_relative 'operator/generator'
 
 require_relative 'operator/extend'
+require_relative 'operator/frame'
+require_relative 'operator/hierarchize'
 require_relative 'operator/project'
 require_relative 'operator/restrict'
 require_relative 'operator/rename'
@@ -130,5 +132,6 @@ require_relative 'operator/group'
 require_relative 'operator/ungroup'
 require_relative 'operator/summarize'
 require_relative 'operator/rank'
+require_relative 'operator/page'
 require_relative 'operator/quota'
 require_relative 'operator/infer_heading'

data/lib/alf-algebra/alf/algebra/operator/clip.rb

@@ -13,10 +13,13 @@ module Alf
       end
 
       def keys
-        @keys ||= operand.keys.
-                          project(attributes, allbut).
-                          compact.
-                          if_empty{ Keys[ heading.to_attr_list ] }
+        @keys ||= operand.keys.select{|k|
+          k.project(attributes, allbut) == k
+        }.if_empty{ Keys[ heading.to_attr_list ] }
+      end
+
+      def key_preserving?
+        keys.any?{|k| operand.keys.include?(k) }
       end
 
       def stay_attributes

data/lib/alf-algebra/alf/algebra/operator/frame.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Algebra
+    class Frame
+      include Operator, Relational, Unary, WithOrdering
+
+      signature do |s|
+        s.argument :ordering, Ordering, []
+        s.argument :offset,   Integer, 0
+        s.argument :limit,    Integer, 25
+      end
+
+      def heading
+        operand.heading
+      end
+
+      def keys
+        operand.keys
+      end
+
+    end # class Frame
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/hierarchize.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Algebra
+    class Hierarchize
+      include Operator, Relational, Unary, Experimental
+
+      signature do |s|
+        s.argument :id,     AttrList, [:id]
+        s.argument :parent, AttrList, [:parent]
+        s.argument :as,     AttrName, [:children]
+      end
+
+      def heading
+        @heading ||= Relation.type(operand.heading){|r| {as => r}}.heading
+      end
+
+      def keys
+        operand.keys
+      end
+
+    end # class Hierarchize
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/page.rb

@@ -0,0 +1,22 @@
+module Alf
+  module Algebra
+    class Page
+      include Operator, Relational, Unary, WithOrdering
+
+      signature do |s|
+        s.argument :ordering, Ordering, []
+        s.argument :page_index, Integer, 1
+        s.option   :page_size,  Integer, 25, 'Size of the pages to compute'
+      end
+
+      def heading
+        operand.heading
+      end
+
+      def keys
+        operand.keys
+      end
+
+    end # class Page
+  end # module Algebra
+end # module Alf

data/lib/alf-algebra/alf/algebra/operator/project.rb

@@ -13,18 +13,13 @@ module Alf
       end
 
       def keys
-        @keys ||= begin
-          keys = operand.keys.project(attributes, allbut).compact
-          if keys.empty?
-            has_empty = operand.keys.include?(AttrList::EMPTY)
-            keys = Keys[ has_empty ? AttrList::EMPTY : heading.to_attr_list ]
-          end
-          keys
-        end
+        @keys ||= operand.keys.select{|k|
+          k.project(attributes, allbut) == k
+        }.if_empty{ Keys[ heading.to_attr_list ] }
       end
 
       def key_preserving?
-        keys.any?{|k| operand.keys.any?{|op_k| k.subset?(op_k) } }
+        keys.any?{|k| operand.keys.include?(k) }
       end
 
       def stay_attributes

data/lib/alf-algebra/alf/algebra/operator/rank.rb

@@ -14,8 +14,8 @@ module Alf
 
       def keys
         @keys ||= begin
-          keys, order_attrs = operand.keys, order.to_attr_list
-          if keys.any?{|k| order_attrs.superset?(k)}
+          keys, selectors = operand.keys, order.to_attr_list
+          if keys.any?{|k| k.subsetOf?(selectors) }
             keys + [ AttrList[as] ]
           else
             keys

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

@@ -9,6 +9,8 @@ require_relative 'support/experimental'
 require_relative 'support/classification'
 require_relative 'support/signature'
 
+require_relative 'support/with_ordering'
+
 require_relative 'support/visitor'
 require_relative 'support/compiler'
 require_relative 'support/rewriter'

data/lib/alf-algebra/alf/algebra/support/signature.rb

@@ -174,7 +174,8 @@ module Alf
       # @return the name to use in shell for `option`
       def option_name(option)
         name, domain, defa, = option
-        domain == Boolean ? "--#{name}" : "--#{name}=#{name.to_s.upcase}"
+        name = name.to_s.gsub(/_/, '-')
+        domain == Boolean ? "--#{name}" : "--#{name}=#{name.upcase}"
       end
 
       # Yields `(name,dom,value)` triples for each argument value

data/lib/alf-algebra/alf/algebra/support/with_ordering.rb

@@ -0,0 +1,11 @@
+module Alf
+  module Algebra
+    module WithOrdering
+
+      def total_ordering
+        ordering.total(keys){ heading }
+      end
+
+    end # module WithOrdering
+  end # module Algebra
+end # module Alf

data/lib/alf-core/ext/domain/heading_based.rb

@@ -6,13 +6,18 @@ module Domain
         raise "#{master_class}.new may not be called directly" if master_class==self
         super(*args)
       }
-      define_method(:type){|generating_type|
-        meths   = [
+      define_method(:type){|generating_type={},&bl|
+        clazz = Class.new(master_class)
+        if bl
+          generating_type = generating_type.to_heading.to_hash unless generating_type.is_a?(Hash)
+          generating_type = generating_type.merge(bl.call(clazz))
+        end
+        meths = [
           DomainMethods.new(master_class, generating_type),
           AlgebraMethods.new(master_class, generating_type),
           Domain::Comparisons,
         ]
-        Class.new(master_class).extend(*meths).heading_based_factored
+        clazz.extend(*meths).heading_based_factored
       }
       alias_method :[], :type
       define_method(:heading_based_factored) do
@@ -27,6 +32,7 @@ module Domain
           gt
         }
         define_method(:<=>){|other|
+          return 0 if self == other
           return nil unless other.ancestors.include?(master_class)
           return -1 if other == master_class
           to_heading <=> other.to_heading
@@ -48,8 +54,14 @@ module Domain
         define_method(:to_heading){
           @heading ||= Alf::Heading.coerce(generating_type)
         }
+        define_method(:recursive?){
+          h = to_heading
+          h.to_attr_list.any?{|a| h[a] == self}
+        }
         define_method(:to_ruby_literal){
-          "#{master_class.name}[#{Alf::Support.to_ruby_literal(to_heading.to_hash)}]"
+          recursive? ?
+            "#{master_class.name}[...]" :
+            "#{master_class.name}[#{Alf::Support.to_ruby_literal(to_heading.to_hash)}]"
         }
         alias_method :name, :to_ruby_literal
         alias_method :to_s, :to_ruby_literal

data/lib/alf-core/facade.rb

@@ -9,8 +9,12 @@ module Alf
       Alf::Database.connect(*args, &bl)
     end
 
+    def examples_adapter
+      Path.backfind('examples/suppliers_and_parts')
+    end
+
     def examples(&bl)
-      Alf::Database.connect Path.backfind('examples/suppliers_and_parts'), &bl
+      Alf::Database.connect examples_adapter, &bl
     end
 
     def reader(source, *args)

data/lib/alf-core/version.rb

@@ -3,8 +3,8 @@ module Alf
     module Version
 
       MAJOR = 0
-      MINOR = 13
-      TINY  = 1
+      MINOR = 14
+      TINY  = 0
 
       def self.to_s
         [ MAJOR, MINOR, TINY ].join('.')