alf-core 0.13.1 → 0.14.0

data/lib/alf-lang/alf/lang/oo/algebra_methods.rb

@@ -5,9 +5,25 @@ module Alf
 
         def self.def_operator_method(name, clazz)
           define_method(name) do |*args|
+            # add self operands at begining of args
             args.unshift(_self_operand)
+
+            # split operands vs. arguments
             operands, arguments = args[0...clazz.arity], args[clazz.arity..-1]
-            _operator_output clazz.new(operands, *arguments)
+
+            # build the new expression
+            expr = clazz.new(operands, *arguments)
+
+            # bind it if operands were bound
+            conns = operands.map(&:connection).uniq
+            if conns.size == 1
+              expr.connection = conns.first
+            elsif conns.size > 1
+              raise NotSupportedError, "Multiple connections unsupported"
+            end
+
+            # let the abstraction have a chance to of decorating it
+            _operator_output(expr)
           end
         end
 

data/lib/alf-optimizer/alf/optimizer/restrict.rb

@@ -45,6 +45,8 @@ module Alf
       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)
@@ -95,7 +97,11 @@ module Alf
       end
 
       def on_restrict(expr, predicate)
-        apply(expr.operand, predicate & expr.predicate)
+        if predicate.native? or expr.predicate.native?
+          restrict(expr, predicate)
+        else
+          apply(expr.operand, predicate & expr.predicate)
+        end
       end
 
       def on_summarize(expr, predicate)

data/lib/alf-predicate/alf/predicate.rb

@@ -37,6 +37,10 @@ module Alf
 
     end
 
+    def native?
+      Native===expr
+    end
+
     def tautology?
       expr.tautology?
     end
@@ -73,8 +77,13 @@ module Alf
       Predicate.new(expr.rename(renaming))
     end
 
-    def evaluate(scope)
-      scope.instance_exec(&to_proc)
+    def evaluate(scope, connection = nil)
+      proc = to_proc
+      if proc.arity == 1
+        proc.call(scope)
+      else
+        scope.instance_exec(&to_proc)
+      end
     end
 
     def and_split(attr_list)

data/lib/alf-relation/alf/relation.rb

@@ -47,6 +47,10 @@ module Alf
       end
     end
 
+    def self.empty
+      @empty ||= new([].to_set)
+    end
+
     def check_internal_representation!
       error = lambda{|msg| raise TypeError, msg }
       error["Set expected"]        unless reused_instance.is_a?(Set)
@@ -91,7 +95,23 @@ module Alf
 
     # Returns an engine Cog
     def to_cog
-      Engine::Leaf.new(self)
+      Engine::Leaf.new(self, self)
+    end
+
+    def to_hash(from, to=nil)
+      if from.is_a?(Hash) and to.nil?
+        raise ArgumentError "Hash of size 1 expected. " unless from.size==1
+        to_hash(from.keys.first, from.values.first)
+      else
+        each.each_with_object({}) do |tuple, hash|
+          key, value = tuple[from], tuple[to]
+          if hash.has_key?(key) and hash[key] != value
+            raise "Key expected for `#{from}`, divergence found on `#{key}`"
+          else
+            hash[key] = value
+          end
+        end
+      end
     end
 
     # Returns a textual representation of this relation

data/lib/alf-relvar/alf/relvar.rb

@@ -3,6 +3,26 @@ module Alf
     include Algebra::Operand
     include Lang::ObjectOriented
 
+    def connection
+      expr.connection
+    end
+
+    def connection=(conn)
+      expr.connection = conn
+    end
+
+    def connection!
+      expr.connection!
+    end
+
+    def bind(connection)
+      expr.bind(connection)
+    end
+
+    def bound?
+      expr.bound?
+    end
+
     def type
       @type ||= Relation[heading]
     end
@@ -76,7 +96,7 @@ module Alf
   private
 
     def _operator_output(expr)
-      Relvar::Virtual.new(expr, connection)
+      Relvar::Virtual.new(expr)
     end
 
   end # module Relvar

data/lib/alf-relvar/alf/relvar/base.rb

@@ -3,12 +3,17 @@ module Alf
     class Base
       include Relvar
 
-      def initialize(name, connection = nil)
-        raise unless name.is_a?(Symbol)
-        @name = name
-        @connection = connection
+      def initialize(expr)
+        raise "Named operand expected, got `#{expr}`" unless expr.is_a?(Algebra::Operand::Named)
+        @expr = expr
+      end
+      attr_reader :expr
+
+      ### Relvar contract
+
+      def name
+        expr.name
       end
-      attr_reader :name
 
       ### Static analysis & inference
 
@@ -42,7 +47,7 @@ module Alf
       ### to_xxx
 
       def to_cog
-        connection!.cog(name)
+        connection!.cog(name, self)
       end
 
       def to_lispy

data/lib/alf-relvar/alf/relvar/fake.rb

@@ -3,10 +3,11 @@ module Alf
     class Fake
       include Relvar
 
-      def initialize(heading)
+      def initialize(expr, heading)
+        @expr = expr
         @heading = Heading.coerce(heading)
       end
-      attr_reader :heading
+      attr_reader :expr, :heading
 
       def insert(tuples)
         @inserted_tuples = tuples.to_a

data/lib/alf-relvar/alf/relvar/virtual.rb

@@ -3,9 +3,8 @@ module Alf
     class Virtual
       include Relvar
 
-      def initialize(expr, connection = nil)
+      def initialize(expr)
         @expr = expr
-        @connection = connection
       end
       attr_reader :expr
 

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

@@ -17,7 +17,7 @@ module Alf
       end
 
       def connection!
-        raise UnboundError unless bound?
+        raise UnboundError, "Not bound `#{self}`" unless bound?
         @connection
       end
 

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

@@ -2,36 +2,88 @@ module Alf
   module Support
     class Config
 
-      def self.delegation_methods
-        public_instance_methods(false).reject{|m| m.to_s =~ /=$/ }
-      end
+      module ClassMethods
+
+        def options
+          @options ||= []
+        end
+
+        def each_option(&bl)
+          options.each(&bl)
+        end
+
+        def delegation_methods
+          public_instance_methods(false).reject{|m| m.to_s =~ /=$/ }
+        end
 
-      def self.helpers(to = :config)
-        meths = delegation_methods
-        Module.new do
-          meths.each do |m|
-            define_method(m){|*args, &bl| self.send(to).send(m, *args, &bl) }
+        def helpers(to = :config)
+          meths = delegation_methods
+          Module.new do
+            meths.each do |m|
+              define_method(m){|*args, &bl| self.send(to).send(m, *args, &bl) }
+            end
           end
         end
-      end
 
-      def self.option(name, domain, default_value)
-        getter_name = domain == Boolean ? :"#{name}?" : :"#{name}"
-        setter_name = :"#{name}="
-        ivar_name   = :"@#{name}"
-        define_method(getter_name) do
-          return instance_variable_get(ivar_name) if instance_variable_defined?(ivar_name)
-          default_value
+        def option(name, domain, default_value)
+          options << [name, domain, default_value]
+          getter_name = self.getter_name(name, domain)
+          setter_name = self.setter_name(name)
+          ivar_name   = self.ivar_name(name)
+          define_method(getter_name) do
+            value = instance_variable_defined?(ivar_name) \
+                  ? instance_variable_get(ivar_name)
+                  : default_value
+            value.is_a?(Proc) && domain != Proc ? instance_exec(&value) : value
+          end
+          define_method(setter_name) do |val|
+            val = val.is_a?(Proc) ? val : Support.coerce(val, domain)
+            instance_variable_set(ivar_name, val)
+          end
+        end
+
+        def getter_name(option, domain)
+          domain == Boolean ? :"#{option}?" : :"#{option}"
+        end
+
+        def setter_name(option)
+          :"#{option}="
+        end
+
+        def ivar_name(option)
+          :"@#{option}"
         end
-        define_method(setter_name) do |val|
-          instance_variable_set(ivar_name, Support.coerce(val, domain))
+
+        def option_get(conf, name)
+          option = options.find{|(n,_,_)| n == name }
+          raise ConfigError, "No such option `#{name}`" unless option
+          conf.send(getter_name(option[0], option[1]))
+        end
+
+        def option_set(conf, name, value)
+          option = options.find{|(n,_,_)| n == name }
+          raise ConfigError, "No such option `#{name}`" unless option
+          conf.send(setter_name(option[0]), value)
         end
+
       end
+      extend(ClassMethods)
       private_class_method :option
 
       # Creates a default options instance
       def initialize(h = {})
         install_options_from_hash(h)
+        yield(self) if block_given?
+      end
+
+      # Returns the value of an option
+      def [](option)
+        self.class.option_get(self, option)
+      end
+
+      # Sets the value of an option
+      def []=(option, value)
+        self.class.option_set(self, option, value)
       end
 
       # Merge with another options from a hash
@@ -39,6 +91,27 @@ module Alf
         dup.install_options_from_hash(h)
       end
 
+      # Duplicates this configuration as well as all option values
+      def dup
+        super.tap do |c|
+          self.class.each_option do |name,_,default|
+            ivar_name = self.class.ivar_name(name)
+            if instance_variable_defined?(ivar_name) || !default.is_a?(Proc)
+              c[name] = (self[name].dup rescue self[name])
+            end
+          end
+        end
+      end
+
+      # Freeze this configuration as well as all option values
+      def freeze
+        super
+        self.class.each_option do |name,_,_|
+          self[name].freeze
+        end
+        self
+      end
+
     protected
 
       def install_options_from_hash(h)

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

@@ -51,12 +51,16 @@ module Alf
           self
         end
 
-        def query
-          @parent.query(yield)
+        def [](what)
+          @tuple[what]
         end
 
-        def tuple_extract
-          @parent.tuple_extract(yield)
+        def to_s
+          @tuple.to_s
+        end
+
+        def inspect
+          @tuple.inspect
         end
 
       end # module OwnMethods

data/lib/alf-types/alf/types.rb

@@ -32,6 +32,8 @@ module Alf
     require_relative 'types/boolean'
     require_relative 'types/size'
     require_relative 'types/attr_name'
+    require_relative 'types/selector'
+    require_relative 'types/selection'
     require_relative 'types/attr_list'
     require_relative 'types/heading'
     require_relative 'types/ordering'

data/lib/alf-types/alf/types/attr_list.rb

@@ -83,7 +83,7 @@ module Alf
       # @return [Integer] 0 if same set of attribute names, -1 if self is a subset of
       # other, 1 if a superset, nil otherwise.
       def <=>(other)
-        return nil unless other.is_a?(AttrList)
+        return nil unless other.respond_to?(:to_set)
         s1, s2 = to_set, other.to_set
         if s1==s2              then 0
         elsif s1.subset?(s2)   then -1
@@ -105,12 +105,14 @@ module Alf
         c = set_compare(other)
         c and (c >= (proper ? 1 : 0))
       end
+      alias :supersetOf? :superset?
 
       # Returns true if self is a (proper) subset of `other`
       def subset?(other, proper = false)
         c = set_compare(other)
         c and (c <= (proper ? -1 : 0))
       end
+      alias :subsetOf? :subset?
 
       # Returns true if self intersects another attribute list
       def intersect?(other)

data/lib/alf-types/alf/types/heading.rb

@@ -136,7 +136,10 @@ module Alf
       #                  nil if not comparable.
       def <=>(other)
         return nil unless other.is_a?(Heading) && to_attr_list==other.to_attr_list
-        comparisons = attributes.keys.map{|k| self[k] <=> other[k] }.reject{|x| x == 0}.uniq
+        comparisons = attributes.keys
+                    .map{|k| self[k] <=> other[k] }
+                    .reject{|x| x == 0}
+                    .uniq
         case comparisons.size
         when 0 then 0
         when 1 then comparisons.first

data/lib/alf-types/alf/types/keys.rb

@@ -23,10 +23,6 @@ module Alf
         map{|k| renaming.rename_attr_list(k) }
       end
 
-      def compact
-        reject{|k| k.empty? }
-      end
-
       def to_ruby_literal
         "Alf::Keys[" << reused_instance.map{|k| Support.to_ruby_literal(k.to_a) }.join(',') << "]"
       end

data/lib/alf-types/alf/types/ordering.rb

@@ -6,20 +6,27 @@ module Alf
     class Ordering
       extend Domain::Reuse.new(Array)
 
+      def self.new(array)
+        super(array.map{|(x,y)| [Selector.coerce(x), y.to_sym] })
+      end
+
+      ArrayOfArray = ->(x){
+        x.is_a?(Array) && x.all?{|y| y.is_a?(Array)}
+      }
+      ArrayWithDirections = ->(x){
+        x.each_with_index.all?{|elm,i| (i%2==0) || elm.to_s =~ /^asc|desc$/ }
+      }
+
       coercions do |c|
         c.delegate :to_ordering
+        c.coercion(ArrayOfArray){|arg,_|
+          Ordering.new(arg)
+        }
+        c.coercion(ArrayWithDirections){|arg,_|
+          Ordering.new(arg.each_slice(2).to_a)
+        }
         c.coercion(Array){|arg,_|
-          if arg.all?{|a| a.is_a?(Array)}
-            Ordering.new(arg)
-          else
-            symbolized = arg.map{|s| AttrName.coerce(s) }
-            sliced = symbolized.each_slice(2)
-            if sliced.all?{|a,o| [:asc,:desc].include?(o)}
-              Ordering.new sliced.to_a
-            else
-              Ordering.new symbolized.map{|a| [a, :asc]}
-            end
-          end
+          Ordering.new(arg.map{|x| [x, :asc] })
         }
       end
 
@@ -37,6 +44,17 @@ module Alf
 
       reuse :to_a
 
+      # Returns the directions associated with an attribute name, nil
+      # if no such attribute.
+      #
+      # @param [Symbol] an attribute name.
+      # @return [Symbol] the associated direction or nil
+      def [](attribute)
+        attribute = Selector.coerce(attribute)
+        pair = reused_instance.find{|p| p.first == attribute }
+        pair && pair.last
+      end
+
       # Compares two tuples according to this ordering.
       #
       # Both t1 and t2 should have all attributes used by this ordering.
@@ -47,8 +65,9 @@ module Alf
       # @return [-1, 0 or 1] according to the classical ruby semantics of
       #         `(t1 <=> t2)`
       def compare(t1, t2)
+        extract = proc{|t,x| Array(x).inject(t){|m,a| m[a]} }
         reused_instance.each do |atr, dir|
-          x, y = t1[atr], t2[atr]
+          x, y = extract[t1,atr], extract[t2,atr]
           comp = x.respond_to?(:<=>) ? (x <=> y) : (x.to_s <=> y.to_s)
           comp *= -1 if dir == :desc
           return comp unless comp == 0
@@ -58,13 +77,77 @@ module Alf
 
       # Computes the union of this ordering with another one.
       #
-      # The union is simply defined by extension of self with other's attributes
-      # and directions.
+      # The union is simply defined by extension of self with other's
+      # attributes and directions. Duplicates are automatically removed.
+      #
+      # When a conflict arises (same attribute but not same direction),
+      # the block is yield with the attribute name, then `self`'s and `other`'s
+      # directions as arguments. The block is expected to return the direction
+      # to use to the attribute. A default block is provided that always favors
+      # the direction found in `other`.
       #
       # @param [Ordering] other another Ordering (coercions will apply)
       # @return [Ordering] the union ordering
-      def +(other)
-        Ordering.new(reused_instance + Ordering.coerce(other).reused_instance)
+      def merge(other, &bl)
+        bl ||= lambda{|attr,d1,d2| d2 }
+        other = Ordering.coerce(other)
+        attributes = self.selectors | other.selectors
+        directions = attributes.to_a.map{|a|
+          left, right = self[a], other[a]
+          direction = if left.nil? or right.nil?
+                        left || right
+                      elsif left == right
+                        left
+                      else
+                        bl.call(a, left, right)
+                      end
+          [a, direction]
+        }
+        Ordering.new(directions)
+      end
+      alias :+ :merge
+
+      # Reverse this ordering.
+      #
+      # @return [Ordering] another ordering where the direction of every
+      #         attribute has been flipped (asc <-> desc)
+      def reverse
+        Ordering.new(reused_instance.map{|attr,dir|
+          [ attr, dir == :asc ? :desc : :asc ]
+        })
+      end
+
+      # Returns a total ordering given some key definitions.
+      #
+      # @return [Ordering]
+      def total(keys, &bl)
+        list = to_attr_list
+        if k = keys.to_a.find{|k| k.to_attr_list.subsetOf?(list) }
+          self
+        elsif k = keys.first
+          merge(k.to_ordering){|k,d1,d2| d1 }
+        elsif bl && (key = bl.call.to_attr_list)
+          merge(key.to_ordering){|k,d1,d2| d1 }
+        else
+          raise NotSupportedError, "Unable to find a total order (no key available)"
+        end
+      end
+
+      # Dives into a relation/tuple valued attribute `attr`.
+      #
+      # @return [Ordering] the sub-ordering to use for `attr`
+      def dive(attr)
+        attrs = reused_instance
+              .map   {|(s,d)| [s.dive(attr), d] }
+              .reject{|(s,d)| s.nil? }
+        Ordering.new(attrs)
+      end
+
+      # Returns the list of selectors
+      #
+      # @return [Array[Selector]] the list of selectors
+      def selectors
+        reused_instance.map(&:first)
       end
 
       # Converts to an attribute list.
@@ -72,14 +155,14 @@ module Alf
       # @return [AttrList] a list of attribute names that participate to the
       #         ordering
       def to_attr_list
-        AttrList.new(reused_instance.map(&:first))
+        AttrList.new(selectors.map{|x| Array(x).first })
       end
 
       # Returns a lispy expression.
       #
       # @return [String] a lispy expression for this ordering
       def to_lispy
-        Support.to_ruby_literal(to_a)
+        Support.to_ruby_literal(to_a.map{|(x,d)| [x.outcoerce, d]})
       end
 
       # Returns a ruby literal for this ordering.
@@ -88,8 +171,11 @@ module Alf
       def to_ruby_literal
         "Alf::Ordering[#{Support.to_ruby_literal(reused_instance)}]"
       end
+
+      alias :to_s :to_ruby_literal
       alias :inspect :to_ruby_literal
 
+      EMPTY = Ordering.new([])
     end # class Ordering
   end # module Types
 end # module Alf