alf-sequel 0.14.0 → 0.15.0

data/Gemfile

@@ -1,8 +1,15 @@
 source 'http://rubygems.org'
 
+group :development do
+  gem "rake", "~> 10.1"
+  gem "rspec", "~> 2.14"
+end
+
 group :runtime do
-  gem "alf-core", "~> 0.14.0"
-  gem "sequel", "~> 3.48"
+  gem "sequel", "~> 4.2"
+
+  gem "alf-core", path: "../alf-core"
+  gem "alf-sql",  path: "../alf-sql"
 end
 
 group :test do
@@ -10,9 +17,5 @@ group :test do
   gem "rspec", "~> 2.14"
   gem "sqlite3", "~> 1.3",      :platforms => ['mri', 'rbx']
   gem "jdbc-sqlite3", "~> 3.7", :platforms => ['jruby']
-end
-
-group :development do
-  gem "rake", "~> 10.1"
-  gem "rspec", "~> 2.14"
+  gem "pg"
 end

data/Gemfile.lock

@@ -1,38 +1,50 @@
-GEM
-  remote: http://rubygems.org/
+PATH
+  remote: ../alf-core
   specs:
-    alf-core (0.14.0)
+    alf-core (0.15.0)
       domain (~> 1.0)
       myrrha (~> 3.0)
       path (~> 1.3)
-      sexpr (~> 0.5.1)
+      sexpr (~> 0.6.0)
+
+PATH
+  remote: ../alf-sql
+  specs:
+    alf-sql (0.15.0)
+      alf-core (~> 0.15.0)
+      sexpr (~> 0.6.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
     diff-lcs (1.2.4)
     domain (1.0.0)
-    jdbc-sqlite3 (3.7.2.1)
     myrrha (3.0.0)
       domain (~> 1.0)
     path (1.3.3)
+    pg (0.17.0)
     rake (10.1.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
       rspec-expectations (~> 2.14.0)
       rspec-mocks (~> 2.14.0)
-    rspec-core (2.14.4)
-    rspec-expectations (2.14.0)
+    rspec-core (2.14.7)
+    rspec-expectations (2.14.3)
       diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.14.1)
-    sequel (3.48.0)
-    sexpr (0.5.1)
-    sqlite3 (1.3.7)
+    rspec-mocks (2.14.4)
+    sequel (4.3.0)
+    sexpr (0.6.0)
+    sqlite3 (1.3.8)
 
 PLATFORMS
-  java
   ruby
 
 DEPENDENCIES
-  alf-core (~> 0.14.0)
+  alf-core!
+  alf-sql!
   jdbc-sqlite3 (~> 3.7)
+  pg
   rake (~> 10.1)
   rspec (~> 2.14)
-  sequel (~> 3.48)
+  sequel (~> 4.2)
   sqlite3 (~> 1.3)

data/README.md

@@ -3,9 +3,51 @@
 [![Build Status](https://secure.travis-ci.org/alf-tool/alf-sequel.png)](http://travis-ci.org/alf-tool/alf-sequel)
 [![Dependency Status](https://gemnasium.com/alf-tool/alf-sequel.png)](https://gemnasium.com/alf-tool/alf-sequel)
 
-A sequel adapter for alf
+A DBMS adapter for Alf built atop [Sequel](http://sequel.rubyforge.org/).
 
 ## Links
 
-http://github.com/alf-tool/alf
-http://github.com/alf-tool/alf-sequel
+* http://github.com/alf-tool/alf
+* http://github.com/alf-tool/alf-sql
+* http://github.com/alf-tool/alf-sequel
+
+## Synopsis
+
+Extends [alf-sql](https://github.com/alf-tool/alf-sql#synopsis) in such a way
+that most existing SQL databases can be used with Alf thanks to the awesome
+[Sequel](http://sequel.rubyforge.org/) library.
+
+## Example
+
+```ruby
+require 'alf-sequel'
+
+Alf.connect("sap.db") do |conn|
+
+  # Send a query and puts the result
+  # (See Alf main docs for smarter ways of using query results)
+  relation = conn.query{
+    restrict(suppliers, city: 'London')
+  }
+
+  puts relation
+  # => +------+-------+---------+--------+
+  #    | :sid | :name | :status | :city  |
+  #    +------+-------+---------+--------+
+  #    | S1   | Smith |      20 | London |
+  #    | S4   | Clark |      20 | London |
+  #    +------+-------+---------+--------+
+
+  # alf-sequel overrides `Operand#to_sql` in such a way that the resulting
+  # SQL code is handled by Sequel itself and thus valid for the DBMS
+  # considered
+  sql = conn.parse{
+    restrict(suppliers, city: 'London')
+  }.to_sql
+
+  puts sql
+  # => SELECT `t1`.`sid`, `t1`.`name`, `t1`.`status`, `t1`.`city`
+  #      FROM `suppliers` AS 't1'
+  #     WHERE (`t1`.`city` = 'London')
+end
+```

data/lib/alf/sequel.rb

@@ -2,6 +2,7 @@ require_relative 'sequel/version'
 require_relative 'sequel/loader'
 require_relative 'sequel/adapter'
 require_relative 'sequel/connection'
+require_relative 'sequel/translator'
 require_relative 'sequel/compiler'
 require_relative 'sequel/cog'
 require_relative 'sequel/unit_of_work'

data/lib/alf/sequel/cog.rb

@@ -1,97 +1,45 @@
 module Alf
   module Sequel
     class Cog
-      include Engine::Cog
+      include Alf::Compiler::Cog
+      include Enumerable
 
-      def initialize(expr, connection, opts)
-        super(expr)
-        @connection = connection
-        @opts = opts
+      def initialize(expr, compiler, sexpr)
+        super(expr, compiler)
+        @sexpr = sexpr
       end
-      attr_reader :connection, :opts
+      attr_reader :sexpr
 
-      def as;         opts[:as];         end
-      def dataset;    opts[:dataset];    end
-
-    ### Cog
-
-      def to_relation
-        Relation.coerce(to_a)
-      end
-
-      def each
-        dataset.each(&Proc.new)
-      end
-
-    ### Delegation to Dataset, that is, facade over ::Sequel itself
-
-      def select(expr, attrs)
-        branch expr, dataset: dataset.select(*qualify(attrs))
-      end
-
-      def rename(expr, attrs, opts)
-        branch expr, dataset: dataset.select(*qualify(attrs)).from_self(opts),
-                          as: opts[:alias]
-      end
-
-      def distinct(expr, *args, &bl)
-        branch expr, dataset: dataset.distinct(*args, &bl)
+      def should_be_reused?
+        sexpr.should_be_reused?
       end
 
-      def order(expr, *args, &bl)
-        branch expr, dataset: dataset.order(*args, &bl)
+      def cog_orders
+        [ sexpr.ordering ].compact
       end
 
-      def filter(expr, *args, &bl)
-        branch expr, dataset: dataset.filter(*args, &bl)
+      def dataset
+        @dataset ||= Translator.new(compiler.connection).call(sexpr)
       end
 
-      def intersect(expr, other, opts={})
-        branch expr, dataset: dataset.intersect(other.dataset, opts),
-                          as: opts[:alias]
+      def to_sql(buffer = "")
+        buffer << dataset.sql
+        buffer
       end
 
-      def join(expr, other, cols, opts={})
-        join = dataset.from_self.inner_join(other.dataset, cols, :table_alias => opts[:alias])
-        branch expr, dataset: join.from_self(opts),
-                          as: opts[:alias]
-      end
-
-      def union(expr, other, opts={})
-        branch expr, dataset: dataset.union(other.dataset, opts),
-                          as: opts[:alias]
-      end
-
-      def limit(expr, *args, &bl)
-        branch expr, dataset: dataset.limit(*args, &bl)
-      end
-
-    ### compilation tools
-
-      def sql
-        dataset.sql
-      end
-
-      def qualify(attributes)
-        return attributes unless as
-        case attributes
-        when Symbol
-          ::Sequel.qualify(as, attributes)
-        when Hash
-          attributes.map{|k,v| ::Sequel.as(::Sequel.qualify(as, k), v) }
-        else
-          attributes.map{|a| ::Sequel.qualify(as, a)}
-        end
+      def to_s
+        to_sql
       end
 
-      def branch(expr, opts = {})
-        Cog.new expr, connection, self.opts.merge(opts)
+      def inspect
+        "Alf::Sequel::Cog(#{to_sql})"
       end
 
-      def to_s
-        "Alf::Sequel::Cog|#{sql}"
+      def each(&bl)
+        return to_enum unless block_given?
+        dataset.each(&bl)
       end
 
-    end # class Operand
+    end # class Cog
   end # module Sequel
 end # module Alf

data/lib/alf/sequel/compiler.rb

@@ -1,209 +1,19 @@
 module Alf
   module Sequel
-    class Compiler < Algebra::Compiler
+    class Compiler < Sql::Compiler
 
-      def pass(expr)
-        rewrite(expr)
+      def initialize(connection)
+        super()
+        @connection = connection
       end
-      alias :on_missing :pass
+      attr_reader :connection
 
-      def next_alias
-        @as ||= 0
-        :"t#{@as += 1}"
-      end
-
-      def on_leaf_operand(expr)
-        if Algebra::Operand::Named===expr
-          expr.connection.cog(expr.name, expr, :alias => next_alias)
-        else
-          expr.to_cog
-        end
-      end
-
-    ### non relational
-
-      alias :on_autonum   :pass
-      alias :on_coerce    :pass
-      alias :on_defaults  :pass
-      alias :on_generator :pass
-
-      def on_clip(expr)
-        rewrite(expr){|rw|
-          rw.operand.select(expr, expr.stay_attributes)
-        }
-      end
-
-      def on_compact(expr)
-        rewrite(expr){|rw|
-          rw.operand.distinct(expr)
-        }
-      end
-
-      def on_sort(expr)
-        rewrite(expr){|rw|
-          operand  = rw.operand
-          ordering = to_sequel_ordering(operand, expr.ordering)
-          operand.order(expr, *ordering)
-        }
-      end
-
-    ### relational
-
-      alias :on_extend :pass
-
-      def on_frame(expr)
-        rewrite(expr){|rw|
-          offset, limit, ordering  = expr.offset, expr.limit, expr.total_ordering
-          operand  = rw.operand
-          ordering = to_sequel_ordering(operand, ordering)
-          operand.order(expr, *ordering).limit(expr, limit, offset)
-        }
-      end
-
-      alias :on_group  :pass
-      alias :on_infer_heading :pass
-
-      def on_intersect(expr)
-        rewrite(expr){|rw|
-          rw.left.intersect(expr, rw.right, {:alias => next_alias})
-        }
-      end
-
-      def on_join(expr)
-        rewrite(expr){|rw|
-          rw.left.join(expr, rw.right, expr.common_attributes.to_a, {:alias => next_alias})
-        }
-      end
-
-      def on_matching(expr)
-        rewrite(expr) do |rw|
-          rw.left.filter(expr, matching2filter(expr, rw))
-        end
-      end
-
-      def on_not_matching(expr)
-        rewrite(expr) do |rw|
-          rw.left.filter(expr, ~matching2filter(expr, rw))
-        end
-      end
-
-      def matching2filter(expr, rw)
-        commons = expr.common_attributes.to_a
-        if commons.size==1
-          # (NOT) IN (SELECT ...)
-          pred = ::Alf::Predicate.in(commons.first, rw.right.select(expr, commons).dataset)
-          Predicate.new(:qualifier => rw.left.as).call(pred)
-        elsif commons.size==0
-          # (NOT) EXISTS (SELECT ... no join condition ...)
-          rw.right.dataset.exists
-        else
-          # (NOT) EXISTS (SELECT ...)
-          filter = Hash[rw.left.qualify(commons).zip(rw.right.qualify(commons))]
-          filter = ::Sequel.expr filter
-          filter = rw.right.filter(expr, filter)
-          filter.dataset.exists
-        end
-      end
-
-      alias :on_minus :pass
-
-      def on_page(expr)
-        rewrite(expr){|rw|
-          index, size, ordering  = expr.page_index, expr.page_size, expr.total_ordering
-          operand, offset, limit = rw.operand, (index.abs - 1) * size, size
-          ordering = to_sequel_ordering(operand, index >= 0 ? ordering : ordering.reverse)
-          operand.order(expr, *ordering).limit(expr, offset , limit)
-        }
-      end
-
-      def on_project(expr)
-        rewrite(expr){|rw|
-          compiled = rw.operand.select(expr, expr.stay_attributes)
-          compiled = compiled.distinct(expr) unless key_preserving?(expr){ false }
-          compiled
-        }
-      end
-
-      alias :on_quota :pass
-      alias :on_rank  :pass
-
-      def on_rename(expr)
-        rewrite(expr){|rw|
-          rw.operand.rename(expr, expr.complete_renaming.to_hash, :alias => next_alias)
-        }
-      end
-
-      def on_restrict(expr)
-        rewrite(expr){|rw|
-          filter = Predicate.new(:qualifier => rw.operand.as).call(rw.predicate)
-          rw.operand.filter(expr, filter)
-        }
-      end
-
-      alias :on_summarize :pass
-      alias :on_ungroup :pass
-
-      def on_union(expr)
-        rewrite(expr){|rw|
-          rw.left.union(expr, rw.right, :alias => next_alias)
-        }
-      end
-
-      alias :on_unwrap :pass
-      alias :on_wrap :pass
-
-    private
-
-      def to_sequel_ordering(operand, ordering)
-        ordering.to_a.map{|(sel,dir)|
-          raise NotSupportedError if sel.composite?
-          ::Sequel.send(dir, operand.qualify(sel.outcoerce))
-        }
-      end
-
-      def key_preserving?(expr)
-        expr.key_preserving?
-      rescue NotSupportedError
-        block_given? ? yield : raise
-      end
-
-    private
-
-      def rewrite(expr)
-        # copy and apply on expr. the result is the same expression, but
-        # with cogs instead of operands
-        rewritten = copy_and_apply(expr)
-
-        # Continue compilation process provided all operands are recognized.
-        if block_given? and rewritten.operands.all?{|op| recognized?(op) }
-          # Compilation of predicates may throw a pass
-          catch(:pass){
-            rewritten = yield(rewritten)
-          }
-        end
-
-        # If the result is itself recognized, proceed
-        # Otherwise, give a change to the upper-stage compiler with a proxy
-        if recognized?(rewritten)
-          rewritten
-        else
-          operands = rewritten.operands.map{|op|
-            Algebra::Operand::Proxy.new(op)
-          }
-          rewritten = rewritten.with_operands(*operands)
-          engine.call(rewritten)
-        end
-      end
-
-      def recognized?(op)
-        op.is_a?(Cog)
-      end
+    protected
 
-      def engine
-        @engine ||= Engine::Compiler.new
+      def cog_class
+        Cog
       end
 
     end # class Compiler
   end # module Sequel
 end # module Alf
-require_relative 'compiler/predicate'