alf-sequel 0.13.0 → 0.14.0

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.14.0 / 2013-10-01
+
+* Added SQL implementation of `page` and `frame`
+* Fix SQL bug on compilation of joins
+
 # 0.13.0 / 2013-07-29
 
 The 0.13.0 version is a new birthday for alf. See `alf` main for CHANGELOG

data/Gemfile

@@ -1,8 +1,7 @@
 source 'http://rubygems.org'
 
 group :runtime do
-  #gem "alf-core", :git => "git://github.com/alf-tool/alf-core.git"
-  gem "alf-core", "~> 0.13.0"
+  gem "alf-core", "~> 0.14.0"
   gem "sequel", "~> 3.48"
 end
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 GEM
   remote: http://rubygems.org/
   specs:
-    alf-core (0.13.0)
+    alf-core (0.14.0)
       domain (~> 1.0)
       myrrha (~> 3.0)
       path (~> 1.3)
@@ -11,7 +11,7 @@ GEM
     jdbc-sqlite3 (3.7.2.1)
     myrrha (3.0.0)
       domain (~> 1.0)
-    path (1.3.1)
+    path (1.3.3)
     rake (10.1.0)
     rspec (2.14.1)
       rspec-core (~> 2.14.0)
@@ -30,7 +30,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
-  alf-core (~> 0.13.0)
+  alf-core (~> 0.14.0)
   jdbc-sqlite3 (~> 3.7)
   rake (~> 10.1)
   rspec (~> 2.14)

data/lib/alf/sequel/cog.rb

@@ -3,7 +3,8 @@ module Alf
     class Cog
       include Engine::Cog
 
-      def initialize(connection, opts)
+      def initialize(expr, connection, opts)
+        super(expr)
         @connection = connection
         @opts = opts
       end
@@ -24,41 +25,45 @@ module Alf
 
     ### Delegation to Dataset, that is, facade over ::Sequel itself
 
-      def select(attrs)
-        branch dataset: dataset.select(*qualify(attrs))
+      def select(expr, attrs)
+        branch expr, dataset: dataset.select(*qualify(attrs))
       end
 
-      def rename(attrs, opts)
-        branch dataset: dataset.select(*qualify(attrs)).from_self(opts),
-                    as: opts[:alias]
+      def rename(expr, attrs, opts)
+        branch expr, dataset: dataset.select(*qualify(attrs)).from_self(opts),
+                          as: opts[:alias]
       end
 
-      def distinct(*args, &bl)
-        branch dataset: dataset.distinct(*args, &bl)
+      def distinct(expr, *args, &bl)
+        branch expr, dataset: dataset.distinct(*args, &bl)
       end
 
-      def order(*args, &bl)
-        branch dataset: dataset.order(*args, &bl)
+      def order(expr, *args, &bl)
+        branch expr, dataset: dataset.order(*args, &bl)
       end
 
-      def filter(*args, &bl)
-        branch dataset: dataset.filter(*args, &bl)
+      def filter(expr, *args, &bl)
+        branch expr, dataset: dataset.filter(*args, &bl)
       end
 
-      def intersect(other, opts={})
-        branch dataset: dataset.intersect(other.dataset, opts),
-                    as: opts[:alias]
+      def intersect(expr, other, opts={})
+        branch expr, dataset: dataset.intersect(other.dataset, opts),
+                          as: opts[:alias]
       end
 
-      def join(other, cols, opts={})
-        join = dataset.inner_join(other.dataset, cols, :table_alias => opts[:alias])
-        branch dataset: join.from_self(opts),
-                    as: opts[:alias]
+      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(other, opts={})
-        branch dataset: dataset.union(other.dataset, opts),
-                    as: opts[:alias]
+      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
@@ -79,8 +84,8 @@ module Alf
         end
       end
 
-      def branch(opts = {})
-        Cog.new connection, self.opts.merge(opts)
+      def branch(expr, opts = {})
+        Cog.new expr, connection, self.opts.merge(opts)
       end
 
       def to_s

data/lib/alf/sequel/compiler.rb

@@ -14,7 +14,7 @@ module Alf
 
       def on_leaf_operand(expr)
         if Algebra::Operand::Named===expr
-          expr.connection.cog(expr.name, :alias => next_alias)
+          expr.connection.cog(expr.name, expr, :alias => next_alias)
         else
           expr.to_cog
         end
@@ -29,53 +29,61 @@ module Alf
 
       def on_clip(expr)
         rewrite(expr){|rw|
-          rw.operand.select(expr.stay_attributes)
+          rw.operand.select(expr, expr.stay_attributes)
         }
       end
 
       def on_compact(expr)
         rewrite(expr){|rw|
-          rw.operand.distinct
+          rw.operand.distinct(expr)
         }
       end
 
       def on_sort(expr)
         rewrite(expr){|rw|
-          operand = rw.operand
-          ordering = expr.ordering.to_a.map{|(col,dir)|
-            ::Sequel.send(dir, operand.qualify(col))
-          }
-          operand.order(*ordering)
+          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(rw.right, :alias => next_alias)
+          rw.left.intersect(expr, rw.right, {:alias => next_alias})
         }
       end
 
       def on_join(expr)
         rewrite(expr){|rw|
-          rw.left.join(rw.right, expr.common_attributes.to_a, :alias => next_alias)
+          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(matching2filter(expr, rw))
+          rw.left.filter(expr, matching2filter(expr, rw))
         end
       end
 
       def on_not_matching(expr)
         rewrite(expr) do |rw|
-          rw.left.filter(~matching2filter(expr, rw))
+          rw.left.filter(expr, ~matching2filter(expr, rw))
         end
       end
 
@@ -83,7 +91,7 @@ module Alf
         commons = expr.common_attributes.to_a
         if commons.size==1
           # (NOT) IN (SELECT ...)
-          pred = ::Alf::Predicate.in(commons.first, rw.right.select(commons).dataset)
+          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 ...)
@@ -92,17 +100,26 @@ module Alf
           # (NOT) EXISTS (SELECT ...)
           filter = Hash[rw.left.qualify(commons).zip(rw.right.qualify(commons))]
           filter = ::Sequel.expr filter
-          filter = rw.right.filter(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.stay_attributes)
-          compiled = compiled.distinct unless key_preserving?(expr){ false }
+          compiled = rw.operand.select(expr, expr.stay_attributes)
+          compiled = compiled.distinct(expr) unless key_preserving?(expr){ false }
           compiled
         }
       end
@@ -112,14 +129,14 @@ module Alf
 
       def on_rename(expr)
         rewrite(expr){|rw|
-          rw.operand.rename(expr.complete_renaming.to_hash, :alias => next_alias)
+          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(filter)
+          rw.operand.filter(expr, filter)
         }
       end
 
@@ -128,7 +145,7 @@ module Alf
 
       def on_union(expr)
         rewrite(expr){|rw|
-          rw.left.union(rw.right, :alias => next_alias)
+          rw.left.union(expr, rw.right, :alias => next_alias)
         }
       end
 
@@ -137,6 +154,13 @@ module Alf
 
     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
@@ -146,12 +170,29 @@ module Alf
     private
 
       def rewrite(expr)
-        rewrited = copy_and_apply(expr)
-        if block_given? and rewrited.operands.all?{|op| recognized?(op) }
-          catch(:pass){ rewrited = yield(rewrited) }
+        # 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
-        rewrited = engine.call(rewrited) unless recognized?(rewrited)
-        rewrited
       end
 
       def recognized?(op)

data/lib/alf/sequel/connection/schema_methods.rb

@@ -11,11 +11,11 @@ module Alf
           sequel_db[name]
         end
 
-        def cog(name, opts={})
+        def cog(name, expr = nil, opts = {})
           if as = opts[:alias]
-            Cog.new(self, dataset: dataset(:"#{name}___#{as}"), as: as)
+            Cog.new(expr, self, dataset: dataset(:"#{name}___#{as}"), as: as)
           else
-            Cog.new(self, dataset: dataset(name))
+            Cog.new(expr, self, dataset: dataset(name))
           end
         end
 

data/lib/alf/sequel/unit_of_work/update.rb

@@ -40,8 +40,8 @@ module Alf
           else
             filter = mr.tuple_extract.to_hash
             tuples = connection.cog(@relvar_name)
-                               .filter(filter)
-                               .select(pkey.to_a)
+                               .filter(nil, filter)
+                               .select(nil, pkey.to_a)
             Relation(tuples)
           end
         end

data/lib/alf/sequel/version.rb

@@ -3,7 +3,7 @@ module Alf
     module Version
 
       MAJOR = 0
-      MINOR = 13
+      MINOR = 14
       TINY  = 0
 
       def self.to_s

data/spec/compiler/test_frame.rb

@@ -0,0 +1,89 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "frame" do
+
+      subject{ compile(expr) }
+
+      let(:expr){
+        frame(operand, ordering, offset, limit)
+      }
+
+      context 'when fully compilable' do
+        let(:operand){ suppliers }
+
+        [
+          [ [[:name, :asc]],  0, 8, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` ASC LIMIT 8 OFFSET 0" ],
+          [ [[:name, :asc]],  2, 8, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` ASC LIMIT 8 OFFSET 2" ],
+          [ [[:city, :asc]],  0, 8, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` ASC, `t1`.`sid` ASC LIMIT 8 OFFSET 0" ],
+          [ [[:city, :desc]],  2, 8, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` DESC, `t1`.`sid` ASC LIMIT 8 OFFSET 2" ],
+        ].each do |(ordering,offset,limit,expected)|
+
+          context "frame(#{ordering}, #{offset}, #{limit})" do
+            let(:ordering){ ordering }
+            let(:offset)  { offset   }
+            let(:limit)   { limit    }
+
+            it 'should compile as expected' do
+              subject.sql.should eq(expected)
+            end
+          end
+
+        end
+      end # fully compilable
+
+      context 'when immediately uncompilable yet known keys' do
+        let(:operand){
+          Algebra::Operand::Fake.new.with_keys([:sid], [:name])
+        }
+
+        [
+          [ [[:name, :asc]], 2, 8, [[:name, :asc]] ],
+          [ [[:city, :asc]], 2, 8, [[:city, :asc], [:sid, :asc]] ]
+        ].each do |ordering, offset, limit, expected|
+
+          context "frame(#{ordering}, #{offset}, #{limit})" do
+            let(:ordering){ ordering }
+            let(:offset)  { offset   }
+            let(:limit)   { limit    }
+
+            it{ should be_a(Engine::Take) }
+
+            it 'should have sort with good ordering' do
+              subject.operand.should be_a(Engine::Sort)
+              subject.operand.ordering.should eq(Ordering.new(expected))
+            end
+          end
+
+        end
+      end
+
+      context 'when immediately uncompilable yet unknown keys' do
+        let(:operand){
+          Algebra::Operand::Fake.new
+        }
+
+        [
+          [ [[:name, :asc]], 2, 8, [[:name, :asc]] ],
+          [ [[:city, :asc]], 2, 8, [[:city, :asc]] ]
+        ].each do |ordering, offset, limit, expected|
+
+          context "frame(#{ordering}, #{offset}, #{limit})" do
+            let(:ordering){ ordering }
+            let(:offset)  { offset   }
+            let(:limit)   { limit    }
+
+            it{ should be_a(Engine::Take) }
+
+            it 'should have sort with good ordering' do
+              subject.operand.should be_a(Engine::Sort)
+              subject.operand.ordering.should eq(Ordering.new(expected))
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

data/spec/compiler/test_join.rb

@@ -9,7 +9,15 @@ module Alf
         let(:expr){ join(suppliers, supplies) }
 
         specify do
-          subject.sql.should eq("SELECT * FROM (SELECT * FROM `suppliers` AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
+          subject.sql.should eq("SELECT * FROM (SELECT * FROM (SELECT * FROM `suppliers` AS 't1') AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
+        end
+      end
+
+      context 'when the left operand is a projection' do
+        let(:expr){ join(project(suppliers, [:sid]), supplies) }
+
+        specify do
+          subject.sql.should eq("SELECT * FROM (SELECT * FROM (SELECT `t1`.`sid` FROM `suppliers` AS 't1') AS 't1' INNER JOIN (SELECT * FROM `supplies` AS 't2') AS 't3' USING (`sid`)) AS 't3'")
         end
       end
 

data/spec/compiler/test_matching.rb

@@ -9,7 +9,7 @@ module Alf
         let(:expr){ matching(suppliers, project(supplies, [:part_id])) }
 
         specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT `t2`.`part_id` FROM `supplies` AS 't2'))")
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE (EXISTS (SELECT DISTINCT `t2`.`part_id` FROM `supplies` AS 't2'))")
         end
       end
 

data/spec/compiler/test_not_matching.rb

@@ -9,7 +9,7 @@ module Alf
         let(:expr){ not_matching(suppliers, project(supplies, [:part_id])) }
 
         specify do
-          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT `t2`.`part_id` FROM `supplies` AS 't2'))")
+          subject.sql.should eq("SELECT * FROM `suppliers` AS 't1' WHERE NOT (EXISTS (SELECT DISTINCT `t2`.`part_id` FROM `supplies` AS 't2'))")
         end
       end
 

data/spec/compiler/test_page.rb

@@ -0,0 +1,86 @@
+require 'compiler_helper'
+module Alf
+  module Sequel
+    describe Compiler, "page" do
+
+      subject{ compile(expr) }
+
+      let(:expr){
+        page(operand, ordering, page_index, page_size: 8)
+      }
+
+      context 'when fully compilable' do
+        let(:operand){ suppliers }
+
+        [
+          [ [[:name, :asc]],  2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` ASC LIMIT 8 OFFSET 8" ],
+          [ [[:name, :asc]], -2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`name` DESC LIMIT 8 OFFSET 8" ],
+          [ [[:city, :asc]],  2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` ASC, `t1`.`sid` ASC LIMIT 8 OFFSET 8" ],
+          [ [[:city, :asc]], -2, "SELECT * FROM `suppliers` AS 't1' ORDER BY `t1`.`city` DESC, `t1`.`sid` DESC LIMIT 8 OFFSET 8" ],
+        ].each do |(ordering,page_index,expected)|
+
+          context "page(#{ordering}, #{page_index})" do
+            let(:ordering)  { ordering   }
+            let(:page_index){ page_index }
+
+            it 'should compile as expected' do
+              subject.sql.should eq(expected)
+            end
+          end
+
+        end
+      end # fully compilable
+
+      context 'when immediately uncompilable yet known keys' do
+        let(:operand){
+          Algebra::Operand::Fake.new.with_keys([:sid], [:name])
+        }
+
+        [
+          [ [[:name, :asc]], 2, [[:name, :asc]] ],
+          [ [[:city, :asc]], 2, [[:city, :asc], [:sid, :asc]] ]
+        ].each do |ordering, page_index, expected|
+
+          context "page(#{ordering}, #{page_index})" do
+            let(:ordering)  { ordering   }
+            let(:page_index){ page_index }
+
+            it{ should be_a(Engine::Take) }
+
+            it 'should have sort with good ordering' do
+              subject.operand.should be_a(Engine::Sort)
+              subject.operand.ordering.should eq(Ordering.new(expected))
+            end
+          end
+
+        end
+      end
+
+      context 'when immediately uncompilable yet unknown keys' do
+        let(:operand){
+          Algebra::Operand::Fake.new
+        }
+
+        [
+          [ [[:name, :asc]], 2, [[:name, :asc]] ],
+          [ [[:city, :asc]], 2, [[:city, :asc]] ]
+        ].each do |ordering, page_index, expected|
+
+          context "page(#{ordering}, #{page_index})" do
+            let(:ordering)  { ordering   }
+            let(:page_index){ page_index }
+
+            it{ should be_a(Engine::Take) }
+
+            it 'should have sort with good ordering' do
+              subject.operand.should be_a(Engine::Sort)
+              subject.operand.ordering.should eq(Ordering.new(expected))
+            end
+          end
+
+        end
+      end
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: alf-sequel
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-29 00:00:00.000000000 Z
+date: 2013-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.13.0
+        version: 0.14.0
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -111,11 +111,13 @@ files:
 - spec/compiler/test_clip.rb
 - spec/compiler/test_compact.rb
 - spec/compiler/test_extend.rb
+- spec/compiler/test_frame.rb
 - spec/compiler/test_intersect.rb
 - spec/compiler/test_join.rb
 - spec/compiler/test_leaf_operand.rb
 - spec/compiler/test_matching.rb
 - spec/compiler/test_not_matching.rb
+- spec/compiler/test_page.rb
 - spec/compiler/test_predicate.rb
 - spec/compiler/test_project.rb
 - spec/compiler/test_rename.rb
@@ -158,7 +160,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 2828513476823415639
+      hash: 3191817765128165623
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: