alf-core 0.14.0 → 0.15.0

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

@@ -1,36 +0,0 @@
-module Alf
-  module Algebra
-    module Operand
-      class Named
-        include Operand
-
-        def initialize(name, connection = nil)
-          @name = name
-          @connection = connection
-        end
-        attr_reader :name
-
-        def keys
-          connection!.keys(name)
-        end
-
-        def heading
-          connection!.heading(name)
-        end
-
-        def to_relvar
-          Relvar::Base.new(self)
-        end
-
-        def to_s
-          "Operand::Named(#{name.inspect})"
-        end
-
-        def to_lispy
-          name.to_s
-        end
-
-      end # Named
-    end # module Operand
-  end # module Algebra
-end # module Alf

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

@@ -1,19 +0,0 @@
-module Alf
-  module Algebra
-    class InferHeading
-      include Operator, Relational, Unary, Experimental
-
-      signature do |s|
-      end
-
-      def heading
-        raise NotSupportedError
-      end
-
-      def keys
-        @keys ||= Keys[ [] ]
-      end
-
-    end # class InferHeading
-  end # module Algebra
-end # module Alf

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

@@ -1,21 +0,0 @@
-module Alf
-  module Algebra
-    class TypeSafe
-      include Operator, NonRelational, Unary
-
-      signature do |s|
-        s.argument :type_safe_heading, Heading, nil
-        s.option   :strict, Boolean,  false, 'Be strict, not allowing tuple projections?'
-      end
-
-      def heading
-        type_safe_heading
-      end
-
-      def keys
-        operand.keys
-      end
-
-    end # class TypeSafe
-  end # module Algebra
-end # module Alf

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

@@ -1,196 +0,0 @@
-module Alf
-  module Algebra
-    class ToDot < Compiler
-      include Alf::Support::DotUtils
-
-      def call(expr, buf = "")
-        buf << "/* #{expr} */\n"
-        buf << "digraph \"Alf\" {\n"
-        buf << "node [width=0.375,height=0.25,shape=record];\n"
-        super
-        buf << "}\n"
-        buf
-      end
-
-      def on_unary_operator(expr, buf, label)
-        buf << "#{expr.object_id} [label=#{dot_label(label)}];\n"
-        apply(expr.operand, buf)
-        buf << "#{expr.object_id} -> #{expr.operand.object_id} [label=\"operand\"];\n"
-      end
-
-      def on_binary_operator(expr, buf, label)
-        buf << "#{expr.object_id} [label=#{dot_label(label)}];\n"
-        apply(expr.left, buf)
-        apply(expr.right, buf)
-        buf << "#{expr.object_id} -> #{expr.left.object_id} [label=\"left\"];\n"
-        buf << "#{expr.object_id} -> #{expr.right.object_id} [label=\"right\"];\n"
-      end
-
-      def on_leaf_operand(expr, buf = "")
-        case expr
-        when Operand::Named
-          buf << "#{expr.object_id} [label=#{dot_label(expr.name)}];\n"
-        when Operand::Proxy
-          buf << "#{expr.object_id} [label=#{dot_label(expr.subject)}];\n"
-        when Relvar::Virtual
-          buf << "#{expr.object_id} [label=\"Relvar::Virtual\"];\n"
-          apply(expr.expr, buf)
-          buf << "#{expr.object_id} -> #{expr.expr.object_id} [label=\"definition\"];\n"
-        when Relation
-          buf << "#{expr.object_id} [label=\"Relation\"];\n"
-        else
-          buf << "#{expr.object_id} [label=#{dot_label(expr)}];\n"
-        end
-      end
-
-      ###
-
-      def on_autonum(expr, buf = "")
-        on_unary_operator(expr, buf, "Autonum|#{as(expr)}")
-      end
-
-      def on_clip(expr, buf = "")
-        on_unary_operator(expr, buf, "Clip|#{allbut(expr)}#{attributes(expr)}")
-      end
-
-      def on_coerce(expr, buf = "")
-        on_unary_operator(expr, buf, "Coerce|#{expr.coercions}")
-      end
-
-      def on_compact(expr, buf = "")
-        on_unary_operator(expr, buf, "Compact")
-      end
-
-      def on_defaults(expr, buf = "")
-        on_unary_operator(expr, buf, "Defaults|#{strict}#{expr.defaults}")
-      end
-
-      def on_extend(expr, buf = "")
-        on_unary_operator(expr, buf, "Extend|#{expr.ext}")
-      end
-
-      def on_generator(expr, buf = "")
-        on_unary_operator(expr, buf, "Generator|#{expr.size}#{as(expr)}")
-      end
-
-      def on_group(expr, buf = "")
-        on_unary_operator(expr, buf, "Group|#{allbut(expr)}#{attributes(expr)}#{as(expr)}")
-      end
-
-      def on_infer_heading(expr, buf = "")
-        on_unary_operator(expr, buf, "InferHeading")
-      end
-
-      def on_intersect(expr, buf = "")
-        on_binary_operator(expr, buf, "Intersect")
-      end
-
-      def on_join(expr, buf = "")
-        on_binary_operator(expr, buf, "Join")
-      end
-
-      def on_matching(expr, buf = "")
-        on_binary_operator(expr, buf, "Matching")
-      end
-
-      def on_minus(expr, buf = "")
-        on_binary_operator(expr, buf, "Minus")
-      end
-
-      def on_not_matching(expr, buf = "")
-        on_binary_operator(expr, buf, "NotMatching")
-      end
-
-      def on_project(expr, buf = "")
-        on_unary_operator(expr, buf, "Project|#{allbut(expr)}#{attributes(expr)}")
-      end
-
-      def on_quota(expr, buf = "")
-        on_unary_operator(expr, buf, "Quota|#{by(expr)}")
-      end
-
-      def on_rank(expr, buf = "")
-        on_unary_operator(expr, buf, "Rank|#{order(expr)}#{as(expr)}")
-      end
-
-      def on_rename(expr, buf = "")
-        on_unary_operator(expr, buf, "Rename|#{renaming(expr)}")
-      end
-
-      def on_restrict(expr, buf = "")
-        on_unary_operator(expr, buf, "Restrict|#{predicate(expr)}")
-      end
-
-      def on_sort(expr, buf = "")
-        on_unary_operator(expr, buf, "Sort|#{ordering(expr)}")
-      end
-
-      def on_summarize(expr, buf = "")
-        on_unary_operator(expr, buf, "Sumarize|#{allbut(expr)}#{by(expr)}")
-      end
-
-      def on_type_safe(expr, buf = "")
-        on_unary_operator(expr, buf, "TypeSafe|#{strict(expr)}#{heading(expr)}")
-      end
-
-      def on_ungroup(expr, buf = "")
-        on_unary_operator(expr, buf, "Ungroup|#{expr.attribute}")
-      end
-
-      def on_union(expr, buf = "")
-        on_binary_operator(expr, buf, "Union")
-      end
-
-      def on_unwrap(expr, buf = "")
-        on_unary_operator(expr, buf, "Unwrap|#{expr.attribute}")
-      end
-
-      def on_wrap(expr, buf = "")
-        on_unary_operator(expr, buf, "Wrap|#{allbut(expr)}#{attributes(expr)}#{as(expr)}")
-      end
-
-    private
-
-      def allbut(expr)
-        expr.allbut ? 'allbut ' : ''
-      end
-
-      def as(expr)
-        "|#{expr.as}"
-      end
-
-      def attributes(expr)
-        "#{expr.attributes.to_a.join(',')}"
-      end
-
-      def by(expr)
-        "#{expr.by}"
-      end
-
-      def order(expr)
-        "#{expr.ordering}"
-      end
-
-      def renaming(expr)
-        "#{expr.renaming}"
-      end
-
-      def predicate(expr)
-        "#{expr.predicate}"
-      end
-
-      def heading(expr)
-        "#{expr.heading}"
-      end
-
-      def ordering(expr)
-        "#{expr.ordering}"
-      end
-
-      def strict(expr)
-        expr.strict ? "strict " : ''
-      end
-
-    end # class ToDot
-  end # module Algebra
-end # module Alf

data/lib/alf-core/facade.rb

@@ -1,39 +0,0 @@
-module Alf
-  module Facade
-
-    def database(*args, &bl)
-      Alf::Database.new(*args, &bl)
-    end
-
-    def connect(*args, &bl)
-      Alf::Database.connect(*args, &bl)
-    end
-
-    def examples_adapter
-      Path.backfind('examples/suppliers_and_parts')
-    end
-
-    def examples(&bl)
-      Alf::Database.connect examples_adapter, &bl
-    end
-
-    def reader(source, *args)
-      Alf::Reader.reader(source, *args)
-    end
-
-    def Relation(*args, &bl)
-      Alf::Relation.coerce(*args, &bl)
-    end
-
-    def Tuple(*args, &bl)
-      tuple = Alf::Tuple.coerce(*args)
-      tuple = tuple.remap(&bl) if bl
-      tuple
-    end
-
-    def Heading(*args, &bl)
-      Alf::Heading.coerce(*args, &bl)
-    end
-
-  end
-end

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

@@ -1,50 +0,0 @@
-module Alf
-  module Engine
-    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
-
-      def each(&bl)
-        return to_enum unless block_given?
-        _each(&bl)
-      end
-
-      def to_dot(buffer = "")
-        Engine::ToDot.new.call(self, buffer)
-      end
-
-    protected
-
-      def tuple_scope(tuple = nil)
-        Support::TupleScope.new tuple, []
-      end
-
-    end # module Cog
-  end # module Engine
-end # module Alf

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

@@ -1,171 +0,0 @@
-module Alf
-  module Engine
-    class Compiler < Algebra::Compiler
-
-      def not_supported(expr)
-        # sub-compilers (i.e. Alf::Sequel's one) cheat a bit by partly rewriting
-        # expressions so that their operands are actually Cogs...
-        expr.is_a?(Cog) ? expr : super
-      end
-
-      ### leaf
-
-      def on_leaf_operand(expr)
-        expr.to_cog
-      end
-
-      ### non relational
-
-      def on_autonum(expr)
-        Autonum.new(apply(expr.operand), expr.as, expr)
-      end
-
-      def on_clip(expr)
-        Clip.new(apply(expr.operand), expr.attributes, expr.allbut, expr)
-      end
-
-      def on_coerce(expr)
-        Coerce.new(apply(expr.operand), expr.coercions, expr)
-      end
-
-      def on_compact(expr)
-        Compact.new(apply(expr.operand), expr)
-      end
-
-      def on_defaults(expr)
-        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, expr)
-      end
-
-      def on_sort(expr)
-        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, expr)
-      end
-
-      ### relational
-
-      def on_extend(expr)
-        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, 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), expr)
-      end
-
-      def on_intersect(expr)
-        Join::Hash.new(apply(expr.left), apply(expr.right), expr)
-      end
-
-      def on_join(expr)
-        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, expr)
-      end
-
-      def on_minus(expr)
-        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, expr)
-      end
-
-      def on_project(expr)
-        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, 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, 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, expr)
-      end
-
-      def on_restrict(expr)
-        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, expr)
-        else
-          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, expr)
-      end
-
-      def on_union(expr)
-        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, expr)
-      end
-
-      def on_wrap(expr)
-        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
-  end # module Engine
-end # module Alf