alf-core 0.13.0

data/examples/operators/union.alf

@@ -0,0 +1,3 @@
+#!/usr/bin/env alf
+(union (project suppliers, [:city]), 
+       (project parts,     [:city]))

data/examples/operators/unwrap.alf

@@ -0,0 +1,4 @@
+#!/usr/bin/env alf 
+(unwrap \
+  (wrap suppliers, [:city, :status], :loc_and_status), 
+  :loc_and_status)

data/examples/operators/wrap.alf

@@ -0,0 +1,2 @@
+#!/usr/bin/env alf
+(wrap suppliers, [:city, :status], :loc_and_status)

data/examples/readme.rb

@@ -0,0 +1,23 @@
+require 'alf'
+
+db = Alf.examples
+
+grouped = db.query{
+  group(suppliers, [:sid, :name, :status], :in_that_city)
+}
+puts grouped
+
+grouped2 = db.query{
+  extend(grouped, how_many:   ->{ in_that_city.count }, 
+                  avg_status: ->{ in_that_city.avg{ status } })
+}
+puts grouped2
+
+summarized = db.query{
+  summary = summarize(suppliers, [:city], how_many: count{ sid }, avg_status: avg{ status })
+  join(grouped, summary)
+}
+puts summarized
+
+require 'json'
+puts summarized.to_json

data/examples/suppliers_and_parts/cities.rash

@@ -0,0 +1,4 @@
+{:city => 'London',   :country => 'England'}
+{:city => 'Paris',    :country => 'France'}
+{:city => 'Athens',   :country => 'Greece'}
+{:city => 'Brussels', :country => 'Belgium'} 

data/examples/suppliers_and_parts/parts.rash

@@ -0,0 +1,6 @@
+{:pid => 'P1', :name => 'Nut',   :color => 'Red',   :weight => 12.0, :city => 'London'}
+{:pid => 'P2', :name => 'Bolt',  :color => 'Green', :weight => 17.0, :city => 'Paris'}
+{:pid => 'P3', :name => 'Screw', :color => 'Blue',  :weight => 17.0, :city => 'Oslo'}
+{:pid => 'P4', :name => 'Screw', :color => 'Red',   :weight => 14.0, :city => 'London'}
+{:pid => 'P5', :name => 'Cam',   :color => 'Blue',  :weight => 12.0, :city => 'Paris'}
+{:pid => 'P6', :name => 'Cog',   :color => 'Red',   :weight => 19.0, :city => 'London'}

data/examples/suppliers_and_parts/suppliers.rash

@@ -0,0 +1,5 @@
+{:sid => 'S1', :name => 'Smith', :status => 20, :city => 'London'}
+{:sid => 'S2', :name => 'Jones', :status => 10, :city => 'Paris'}
+{:sid => 'S3', :name => 'Blake', :status => 30, :city => 'Paris'}
+{:sid => 'S4', :name => 'Clark', :status => 20, :city => 'London'}
+{:sid => 'S5', :name => 'Adams', :status => 30, :city => 'Athens'}

data/examples/suppliers_and_parts/supplies.rash

@@ -0,0 +1,12 @@
+{:sid => 'S1', :pid => 'P1', :qty => 300}
+{:sid => 'S1', :pid => 'P2', :qty => 200}
+{:sid => 'S1', :pid => 'P3', :qty => 400}
+{:sid => 'S1', :pid => 'P4', :qty => 200}
+{:sid => 'S1', :pid => 'P5', :qty => 100}
+{:sid => 'S1', :pid => 'P6', :qty => 100}
+{:sid => 'S2', :pid => 'P1', :qty => 300}
+{:sid => 'S2', :pid => 'P2', :qty => 400}
+{:sid => 'S3', :pid => 'P2', :qty => 200}
+{:sid => 'S4', :pid => 'P2', :qty => 200}
+{:sid => 'S4', :pid => 'P4', :qty => 300}
+{:sid => 'S4', :pid => 'P5', :qty => 400}

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

@@ -0,0 +1,22 @@
+module Alf
+  class Adapter
+    class Folder < Adapter
+
+      # (see Connection.recognizes?)
+      #
+      # @return [Boolean] true if args contains one String only, which denotes
+      #         an existing folder; false otherwise
+      def self.recognizes?(conn_spec)
+        Path.like?(conn_spec) && Path(conn_spec).directory?
+      end
+
+      # Returns a connection on the underlying folder
+      def connection
+        Folder::Connection.new(Path(conn_spec))
+      end
+
+      Adapter.register(:folder, self)
+    end # class Folder
+  end # class Adapter
+end # module Alf
+require_relative 'folder/connection'

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

@@ -0,0 +1,39 @@
+module Alf
+  class Adapter
+    class Folder
+      class Connection < Adapter::Connection
+
+        alias :folder :conn_spec
+
+        # Returns true if `name` is known, false otherwise.
+        def knows?(name)
+          !find_file(name).nil?
+        end
+
+        # Returns a cog for `name`
+        def cog(name)
+          if f = find_file(name)
+            Reader.reader(find_file(name))
+          else
+            raise NoSuchRelvarError, "Unable to find a file for #{name}"
+          end
+        end
+
+      protected
+
+        # Finds a specific file by name
+        #
+        # @param [String] name the name of a dataset
+        # @return [Path] path to an existing file if it exists, nil otherwise.
+        def find_file(name)
+          if (explicit = folder/name.to_s).file?
+            explicit
+          else
+            folder.glob("#{name}.*").find{|f| f.file?}
+          end
+        end
+
+      end # class Connection
+    end # class Folder
+  end # class Adapter
+end # module Alf

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

@@ -0,0 +1 @@
+require_relative 'folder'

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

@@ -0,0 +1,95 @@
+module Alf
+  class Adapter
+
+    class << self
+      include Support::Registry
+
+      # Register an adapter class under a specific name.
+      #
+      # Registered class must implement a recognizes? method that takes an array of
+      # arguments; it must returns true if an adapter instance can be built using those
+      # arguments, false otherwise.
+      #
+      # Example:
+      #
+      #     Adapter.register(:sqlite, MySQLiteAdapterClass)
+      #     Adapter.sqlite(...)        # MySQLiteAdapterClass.new(...)
+      #     Adapter.autodetect(...)    # => MySQLiteAdapterClass.new(...)
+      #
+      # @see also autodetect and recognizes?
+      # @param [Symbol] name name of the connection kind
+      # @param [Class] clazz class that implemented the connection
+      def register(name, clazz)
+        super([name, clazz], Adapter)
+      end
+
+      # Auto-detect the connection class to use for specific arguments.
+      #
+      # This method returns an instance of the first registered Connection class that returns
+      # true to an invocation of recognizes?(args). It raises an ArgumentError if no such
+      # class can be found.
+      #
+      # @param [Object] conn_spec a connection specification
+      # @return [Class] the first registered class that recognizes `conn_spec`
+      # @raise [ArgumentError] when no registered class recognizes the arguments
+      def autodetect(conn_spec)
+        name, clazz = registered.find{|nc| nc.last.recognizes?(conn_spec) }
+        unless clazz
+          raise ArgumentError, "No adapter for `#{conn_spec.inspect}`"
+        end
+        clazz
+      end
+
+      # Builds an adapter instance through the autodetection adapter mechanism.
+      #
+      # @param [Hash] conn_spec a connection specification
+      # @param [Module] schema a module for scope definition
+      # @return [Adapter] an adapter instance
+      def factor(conn_spec)
+        return conn_spec if conn_spec.is_a?(Adapter)
+        autodetect(conn_spec).new(conn_spec)
+      end
+
+      # Returns true if _args_ can be used for get an adapter instance, false otherwise.
+      #
+      # When returning true, an immediate invocation of new(*args) should succeed. While
+      # runtime exception are admitted (no such connection, for example), argument errors
+      # should not occur (missing argument, wrong typing, etc.).
+      #
+      # Please be specific in the implementation of this extension point, as registered
+      # adapters for a chain and each of them should have a chance of being selected.
+      #
+      # @param [Array] args arguments for the Adapter constructor
+      # @return [Boolean] true if an adapter may be built using `args`,
+      #         false otherwise.
+      def recognizes?(args)
+        false
+      end
+    end # class << self
+
+    # The connection specification
+    attr_reader :conn_spec
+
+    # Creates an adapter instance.
+    #
+    # @param [Object] conn_spec a connection specification.
+    def initialize(conn_spec)
+      @conn_spec = conn_spec
+    end
+
+    # Returns a low-level connection on this adapter
+    def connection
+      Connection.new(conn_spec)
+    end
+
+    # Yields the block with a connection and closes it afterwards
+    def connect
+      c = connection
+      yield(c)
+    ensure
+      c.close if c
+    end
+
+  end # class Adapter
+end # module Alf
+require_relative 'adapter/connection'

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

@@ -0,0 +1,88 @@
+module Alf
+  class Adapter
+    class Connection
+
+      def initialize(conn_spec)
+        @conn_spec = conn_spec
+      end
+      attr_reader :conn_spec
+
+      ### connection, transaction, locks
+
+      # Yields the block in a transaction
+      def in_transaction(opts = {})
+        yield
+      end
+
+      # Closes the connection
+      def close
+        @closed = true
+      end
+
+      # Checks whether the connection is closed
+      def closed?
+        defined?(@closed) && @closed
+      end
+
+      ### schema methods
+
+      # Returns true if `name` is known, false otherwise.
+      def knows?(name)
+        false
+      end
+
+      # Returns the heading of a given named variable
+      def heading(name)
+        raise NotSupportedError, "Unable to serve heading of `#{name}` in `#{self}`"
+      end
+
+      # Returns the keys of a given named variable
+      def keys(name)
+        raise NotSupportedError, "Unable to serve keys of `#{name}` in `#{self}`"
+      end
+
+      # Migrate the undelrying database according to adapter semantics.
+      def migrate!(opts)
+        raise NotSupportedError, "Unable to migrate using `#{self}`"
+      end
+
+      ### read-only methods
+
+      # Returns a cog for a given name
+      def cog(name)
+        raise NotSupportedError, "Unable to serve cog `#{name}` in `#{self}`"
+      end
+
+      ### update methods
+
+      # Locks the table with name `name`
+      def lock(name, mode)
+        yield
+      end
+
+      # Inserts `tuples` in the relvar called `name`
+      def insert(name, tuples)
+        raise NotSupportedError, "Unable to insert in `#{self}`"
+      end
+
+      # Delete from the relvar called `name`
+      def delete(name, predicate)
+        raise NotSupportedError, "Unable to delete in `#{self}`"
+      end
+
+      # Updates the relvar called `name`
+      def update(name, computation, predicate)
+        raise NotSupportedError, "Unable to update in `#{self}`"
+      end
+
+      ### compilation chain
+
+      # Returns a compiler instance
+      def compiler
+        Engine::Compiler.new
+      end
+
+    end # class Connection
+  end # class Adapter
+end # module Alf
+require_relative 'connection/schema_cached'

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

@@ -0,0 +1,34 @@
+module Alf
+  class Adapter
+    class Connection
+      class SchemaCached < Connection
+
+        def self.empty_cache
+          Hash.new{|h,k| h[k] = {}}
+        end
+
+        def initialize(connection, cache = nil)
+          @connection = connection
+          @cache      = cache || SchemaCached.empty_cache
+        end
+
+        Connection.instance_methods(false).each do |meth|
+          define_method(meth) do |*args, &bl|
+            @connection.send(meth, *args, &bl)
+          end
+        end
+
+        [ :knows?, :heading, :keys ].each do |meth|
+          define_method(meth) do |name|
+            @cache[meth][name] ||= @connection.send(meth, name)
+          end
+        end
+
+        def to_s
+          "#{@connection.to_s} (with cache)"
+        end
+
+      end # class SchemaCached
+    end # class Connection
+  end # class Database
+end # module Alf

data/lib/alf-aggregator/alf/aggregator.rb

@@ -0,0 +1,223 @@
+module Alf
+  #
+  # Aggregation operator.
+  #
+  # This class provides a basis for implementing aggregation operators. It should always
+  # be used as a superclass for such implementations.
+  #
+  # Aggregation operators are made available through factory methods on the
+  # Aggregator class itself:
+  #
+  #     Aggregator.count
+  #     Aggregator.sum{ qty }
+  #
+  # The coercion method should always be used for building aggregators from
+  # lispy source code:
+  #
+  #     Aggregator.coerce("count")
+  #     Aggregator.coerce("sum{ qty }")
+  #
+  # Once built, aggregators can be used either in black-box or white-box modes.
+  #
+  #     relation = ...
+  #     agg = Aggregator.sum{ qty }
+  #
+  #     # Black box mode:
+  #     result = agg.aggregate(relation)
+  #
+  #     # White box mode:
+  #     memo = agg.least
+  #     relation.each do |tuple|
+  #       memo = agg.happens(memo, tuple)
+  #     end
+  #     result = agg.finalize(memo)
+  #
+  class Aggregator
+
+    #
+    # Class-level utilities of Alf's aggregators.
+    #
+    # Subclasses of Aggregator are automatically tracked so as to add
+    # factory methods on the Aggregator class itself. Example:
+    #
+    #   class Sum < Aggregator   # will give a method Aggregator.sum
+    #     ...
+    #   end
+    #   Aggregator.sum{ size }
+    #
+    # All registered aggregators are available under `Aggregator.aggregators`
+    # Those aggregators may also be iterated as follows:
+    #
+    #   Alf::Aggregator.each do |agg_class|
+    #
+    #     # agg_class is a subclass of Aggregator
+    #
+    #   end
+    #
+    class << self
+      include Support::Registry
+
+      # Automatically installs factory methods for inherited classes.
+      #
+      # @param [Class] clazz a class that extends Aggregator
+      def inherited(clazz)
+        register(clazz, Aggregator)
+      end
+
+      # Coerces `arg` to an Aggregator
+      #
+      # Implemented coercions are:
+      # - Aggregator -> self
+      # - String     -> through factory methods on self
+      #
+      # @param [Object] arg a value to coerce to an aggregator
+      # @return [Aggregator] the coerced aggregator
+      # @raise [ArgumentError] if the coercion fails
+      def coerce(arg)
+        case arg
+        when Aggregator
+          arg
+        when String
+          agg = instance_eval(arg)
+          agg.source = arg
+          agg
+        else
+          raise ArgumentError, "Invalid arg `arg` for Aggregator()"
+        end
+      end
+    end # class << self
+
+    # @return [Hash] Aggregation options
+    attr_reader :options
+
+    # @return [TupleExpression] the underlying functor
+    attr_reader :functor
+
+    # @return [String] source code of the aggregator, if any
+    attr_accessor :source
+
+    # Creates an Aggregator instance.
+    #
+    # Example:
+    #
+    #   Aggregator.new{ size * price }
+    #
+    def initialize(options = {}, &block)
+      options, block = {}, options if options.is_a?(Symbol) && block.nil?
+      @options = default_options.merge(options)
+      @functor = Support.coerce(block, TupleExpression)
+    end
+
+    # Returns the default options to use
+    #
+    # @return [Hash] the default aggregation options
+    def default_options
+      {}
+    end
+
+    # Returns the least value, which is the one to use on an empty
+    # set.
+    #
+    # This method is intended to be overriden by subclasses; default
+    # implementation returns nil.
+    #
+    # @return [Object] the least value for this aggregator
+    def least
+      nil
+    end
+
+    # This method is called on each aggregated tuple and must return
+    # an updated _memo_ value. It can be seen as the block typically
+    # given to Enumerable.inject.
+    #
+    # The default implementation collects the pre-value on the tuple
+    # and delegates to _happens.
+    #
+    # @param [Object] memo the current aggregation value
+    # @param [Support::TupleScope] a tuple scope bound to the current tuple
+    # @return [Object] updated memo value
+    def happens(memo, scope)
+      raise unless Support::TupleScope===scope
+      _happens(memo, @functor.evaluate(scope))
+    end
+
+    # This method finalizes an aggregation.
+    #
+    # Argument _memo_ is either _least_ or the result of aggregating
+    # through _happens_. The default implementation simply returns
+    # _memo_. The method is intended to be overriden for complex
+    # aggregations that need statefull information such as `avg`.
+    #
+    # @param [Object] memo the current aggregation value
+    # @return [Object] the aggregation value, as finalized
+    def finalize(memo)
+      memo
+    end
+
+    # Aggregates over an enumeration of tuples.
+    #
+    # @param [Enumerable<Tuple>] an enumerable of tuples
+    # @return [Object] the computed aggregation value
+    def aggregate(enum)
+      scope = Support::TupleScope.new
+      finalize(enum.inject(least){|m,t| happens(m, scope.__set_tuple(t))})
+    end
+
+    # Infers the resulting type from expression source code
+    def infer_type
+      Object
+    end
+
+    # Asserts that this aggregator knows its source code or raises a
+    # NotImplementedError.
+    #
+    # @return [String] the source code when known
+    def has_source_code!
+      if source.nil?
+        raise NotImplementedError, "No known source code for this aggregator"
+      else
+        source
+      end
+    end
+
+    # Returns a lispy expression
+    #
+    # @return [String] a lispy expression for this aggregator
+    def to_lispy
+      has_source_code!
+    rescue NotImplementedError
+      "[lispy code unavailable]"
+    end
+
+    # Checks equality with another aggregator
+    #
+    # @param [Aggregator] other another aggregator
+    # @return [Boolean] true is self and other are equal, false otherwise
+    def ==(other)
+      return false unless other.is_a?(Aggregator)
+      has_source_code! == other.has_source_code!
+    rescue NotImplementedError
+      super
+    end
+
+    protected
+
+      # @see happens.
+      #
+      # This method is intended to be overriden and returns _value_
+      # by default, making this aggregator a "Last(...)" aggregator.
+      def _happens(memo, value)
+        value
+      end
+
+  end # class Aggregator
+end # module Alf
+require_relative 'aggregator/count'
+require_relative 'aggregator/sum'
+require_relative 'aggregator/min'
+require_relative 'aggregator/max'
+require_relative 'aggregator/avg'
+require_relative 'aggregator/variance'
+require_relative 'aggregator/stddev'
+require_relative 'aggregator/collect'
+require_relative 'aggregator/concat'