sequel 4.10.0 → 4.11.0

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 10
+  MINOR = 11
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -117,8 +117,8 @@ end
 describe "PostgreSQL views" do
   before do
     @db = DB
-    @db.drop_view(:items_view, :cascade=>true, :if_exists=>true)
-    @db.create_table!(:items){Integer :number}
+    @db.drop_table?(:items, :cascade=>true)
+    @db.create_table(:items){Integer :number}
     @db[:items].insert(10)
     @db[:items].insert(20)
   end
@@ -152,6 +152,15 @@ describe "PostgreSQL views" do
     @db[:items_view].select_order_map(:number).should == [10, 15, 20]
   end if DB.server_version >= 90300
 
+  specify "should support refreshing materialized views concurrently" do
+    @opts = {:materialized=>true}
+    @db.create_view(:items_view, @db[:items].where{number >= 10}, @opts)
+    @db.refresh_view(:items_view)
+    proc{@db.refresh_view(:items_view, :concurrently=>true)}.should raise_error(Sequel::DatabaseError)
+    @db.add_index :items_view, :number, :unique=>true
+    proc{@db.refresh_view(:items_view, :concurrently=>true)}.should_not raise_error
+  end if DB.server_version >= 90400
+
   specify "should support :if_exists=>true for not raising an error if the view does not exist" do
     proc{@db.drop_view(:items_view, :if_exists=>true)}.should_not raise_error
   end
@@ -170,6 +179,14 @@ describe "A PostgreSQL database" do
     @db.server_version.should > 70000
   end
 
+  specify "should respect the :read_only option per-savepoint" do
+    proc{@db.transaction{@db.transaction(:savepoint=>true, :read_only=>true){@db[:public__testfk].insert}}}.should raise_error(Sequel::DatabaseError)
+    proc{@db.transaction(:auto_savepoint=>true, :read_only=>true){@db.transaction(:read_only=>false){@db[:public__testfk].insert}}}.should raise_error(Sequel::DatabaseError)
+    proc{@db.transaction{@db[:public__testfk].insert; @db.transaction(:savepoint=>true, :read_only=>true){@db[:public__testfk].all;}}}.should_not raise_error
+    proc{@db.transaction{@db.transaction(:savepoint=>true, :read_only=>true){}; @db[:public__testfk].insert}}.should_not raise_error
+    proc{@db.transaction{@db[:public__testfk].all; @db.transaction(:savepoint=>true, :read_only=>true){@db[:public__testfk].all;}}}.should_not raise_error
+  end
+
   specify "should support disable_insert_returning" do
     ds = @db[:public__testfk].disable_insert_returning
     ds.delete
@@ -326,6 +343,22 @@ describe "A PostgreSQL dataset" do
     @d.order(Sequel.asc(:value, :nulls=>:first), :name).reverse.select_map(:name).should == %w[bcd bcd abc]
   end
 
+  specify "should support selecting from LATERAL functions" do
+    @d.from{[generate_series(1,3,1).as(:a), pow(:a, 2).lateral.as(:b)]}.select_map([:a, :b])== [[1, 1], [2, 4], [3, 9]]
+  end if DB.server_version >= 90300
+
+  specify "should support ordered-set and hypothetical-set aggregate functions" do
+    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{mode{}.within_group(:a)}.should == 1
+  end if DB.server_version >= 90400
+
+  specify "should support filtered aggregate functions" do
+    @d.from{generate_series(1,3,1).as(:a)}.select{(a.sql_number % 2).as(:a)}.from_self.get{count(:a).filter(:a=>1)}.should == 2
+  end if DB.server_version >= 90400
+
+  specify "should support functions with ordinality" do
+    @d.from{generate_series(1,10,3).with_ordinality}.select_map([:generate_series, :ordinality]).should == [[1, 1], [4, 2], [7, 3], [10, 4]]
+  end if DB.server_version >= 90400
+
   specify "#lock should lock tables and yield if a block is given" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
   end
@@ -848,28 +881,14 @@ describe "A PostgreSQL database" do
 
   specify "should support fulltext indexes and searching" do
     @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french', :index_type=>:gist}
-    check_sqls do
-      @db.sqls.should == [
-        %{CREATE TABLE "posts" ("title" text, "body" text)},
-        %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
-        %{CREATE INDEX "posts_title_index" ON "posts" USING gist (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
-      ]
-    end
 
     @db[:posts].insert(:title=>'ruby rails', :body=>'yowsa')
     @db[:posts].insert(:title=>'sequel', :body=>'ruby')
     @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
-    @db.sqls.clear
 
     @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.should == [:title=>'ruby rails', :body=>'yowsa']
     @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.should == [{:title=>'ruby scooby', :body=>'x'}]
-    check_sqls do
-      @db.sqls.should == [
-        %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('simple'::regconfig, 'rails'))},
-        %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple'::regconfig, 'yowsa | rails'))},
-        %{SELECT * FROM "posts" WHERE (to_tsvector('french'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('french'::regconfig, 'scooby'))}]
-    end
 
     @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
@@ -880,6 +899,13 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search(:title, 'jruby maglev', :phrase=>true).select_order_map(:title).should == ['ruby jruby maglev mri rubinius iron']
     @db[:posts].full_text_search(:title, 'rubinius ruby', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
     @db[:posts].full_text_search(:title, 'jruby maglev', :plain=>true).select_order_map(:title).should == ['jruby rubinius ruby maglev mri iron', 'ruby jruby maglev mri rubinius iron']
+
+    @db[:posts].delete
+    t1 = "bork " * 1000 + "ruby sequel"
+    t2 = "ruby sequel " * 1000
+    @db[:posts].insert(:title=>t1)
+    @db[:posts].insert(:title=>t2)
+    @db[:posts].full_text_search(:title, 'ruby & sequel', :rank=>true).select_map(:title).should == [t1, t2]
   end
 
   specify "should support spatial indexes" do
@@ -2237,6 +2263,13 @@ describe 'PostgreSQL array handling' do
       @ds.get(Sequel.pg_array(:i5).replace(1, 4).contains([1])).should == false
       @ds.get(Sequel.pg_array(:i5).replace(1, 4).contains([4])).should == true
     end
+    if @db.server_version >= 90400
+      @ds.get(Sequel.pg_array(:i).cardinality).should == 3
+      @ds.get(Sequel.pg_array(:i4).cardinality).should == 4
+      @ds.get(Sequel.pg_array(:i5).cardinality).should == 3
+
+      @ds.from{Sequel.pg_array([1,2,3]).op.unnest([4,5,6], [7,8]).as(:t1, [:a, :b, :c])}.select_order_map([:a, :b, :c]).should == [[1, 4, 7], [2, 5, 8], [3, 6, nil]]
+    end
 
     if @native
       @ds.get(Sequel.pg_array(:i).push(4)).should == [1, 2, 3, 4]
@@ -2515,133 +2548,166 @@ describe 'PostgreSQL json type' do
     @db.drop_table?(:items)
   end
 
-  specify 'insert and retrieve json values' do
-    @db.create_table!(:items){json :j}
-    @ds.insert(Sequel.pg_json(@h))
-    @ds.count.should == 1
-    if @native
-      rs = @ds.all
-      v = rs.first[:j]
-      v.should_not be_a_kind_of(Hash)
-      v.to_hash.should be_a_kind_of(Hash)
-      v.should == @h
-      v.to_hash.should == @h
+  json_types = [:json]
+  json_types << :jsonb if DB.server_version >= 90400
+  json_types.each do |json_type|
+    json_array_type = "#{json_type}[]"
+    pg_json = lambda{|v| Sequel.send(:"pg_#{json_type}", v)}
+
+    specify 'insert and retrieve json values' do
+      @db.create_table!(:items){column :j, json_type}
+      @ds.insert(pg_json.call(@h))
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        v = rs.first[:j]
+        v.should_not be_a_kind_of(Hash)
+        v.to_hash.should be_a_kind_of(Hash)
+        v.should == @h
+        v.to_hash.should == @h
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
+
       @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.should == rs
+      @ds.insert(pg_json.call(@a))
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        v = rs.first[:j]
+        v.should_not be_a_kind_of(Array)
+        v.to_a.should be_a_kind_of(Array)
+        v.should == @a
+        v.to_a.should == @a
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
     end
 
-    @ds.delete
-    @ds.insert(Sequel.pg_json(@a))
-    @ds.count.should == 1
-    if @native
-      rs = @ds.all
-      v = rs.first[:j]
-      v.should_not be_a_kind_of(Array)
-      v.to_a.should be_a_kind_of(Array)
-      v.should == @a
-      v.to_a.should == @a
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.should == rs
+    specify 'insert and retrieve json[] values' do
+      @db.create_table!(:items){column :j, json_array_type}
+      j = Sequel.pg_array([pg_json.call('a'=>1), pg_json.call(['b', 2])])
+      @ds.insert(j)
+      @ds.count.should == 1
+      if @native
+        rs = @ds.all
+        v = rs.first[:j]
+        v.should_not be_a_kind_of(Array)
+        v.to_a.should be_a_kind_of(Array)
+        v.should == j
+        v.to_a.should == j
+        @ds.delete
+        @ds.insert(rs.first)
+        @ds.all.should == rs
+      end
     end
-  end
 
-  specify 'insert and retrieve json[] values' do
-    @db.create_table!(:items){column :j, 'json[]'}
-    j = Sequel.pg_array([Sequel.pg_json('a'=>1), Sequel.pg_json(['b', 2])])
-    @ds.insert(j)
-    @ds.count.should == 1
-    if @native
-      rs = @ds.all
-      v = rs.first[:j]
-      v.should_not be_a_kind_of(Array)
-      v.to_a.should be_a_kind_of(Array)
-      v.should == j
-      v.to_a.should == j
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.should == rs
+    specify 'with models' do
+      @db.create_table!(:items) do
+        primary_key :id
+        column :h, json_type
+      end
+      c = Class.new(Sequel::Model(@db[:items]))
+      c.plugin :pg_typecast_on_load, :h unless @native
+      c.create(:h=>pg_json.call(@h)).h.should == @h
+      c.create(:h=>pg_json.call(@a)).h.should == @a
     end
-  end
 
-  specify 'use json in bound variables' do
-    @db.create_table!(:items){json :i}
-    @ds.call(:insert, {:i=>Sequel.pg_json(@h)}, {:i=>:$i})
-    @ds.get(:i).should == @h
-    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json(@h)).should == {:i=>@h}
-    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json({})).should == nil
-    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:delete, :i=>Sequel.pg_json(@h)).should == 1
+    specify 'use json in bound variables' do
+      @db.create_table!(:items){column :i, json_type}
+      @ds.call(:insert, {:i=>pg_json.call(@h)}, {:i=>:$i})
+      @ds.get(:i).should == @h
 
-    @ds.call(:insert, {:i=>Sequel.pg_json(@a)}, {:i=>:$i})
-    @ds.get(:i).should == @a
-    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json(@a)).should == {:i=>@a}
-    @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json([])).should == nil
+      @ds.delete
+      @ds.call(:insert, {:i=>pg_json.call('a'=>nil)}, {:i=>:$i})
+      @ds.get(:i).should == pg_json.call('a'=>nil)
 
-    @ds.delete
-    @ds.call(:insert, {:i=>Sequel.pg_json('a'=>nil)}, {:i=>:$i})
-    @ds.get(:i).should == Sequel.pg_json('a'=>nil)
-
-    @db.create_table!(:items){column :i, 'json[]'}
-    j = Sequel.pg_array([Sequel.pg_json('a'=>1), Sequel.pg_json(['b', 2])], :text)
-    @ds.call(:insert, {:i=>j}, {:i=>:$i})
-    @ds.get(:i).should == j
-    @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>j).should == {:i=>j}
-    @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>Sequel.pg_array([])).should == nil
-  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+      @db.create_table!(:items){column :i, json_array_type}
+      j = Sequel.pg_array([pg_json.call('a'=>1), pg_json.call(['b', 2])], json_type)
+      @ds.call(:insert, {:i=>j}, {:i=>:$i})
+      @ds.get(:i).should == j
+    end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
-  specify 'with models' do
-    @db.create_table!(:items) do
-      primary_key :id
-      json :h
-    end
-    c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :h unless @native
-    c.create(:h=>Sequel.pg_json(@h)).h.should == @h
-    c.create(:h=>Sequel.pg_json(@a)).h.should == @a
-  end
-
-  specify 'operations/functions with pg_json_ops' do
-    Sequel.extension :pg_json_ops
-    jo = Sequel.pg_json('a'=>1, 'b'=>{'c'=>2, 'd'=>{'e'=>3}}).op
-    ja = Sequel.pg_json([2, 3, %w'a b']).op
-
-    @db.get(jo['a']).should == 1
-    @db.get(jo['b']['c']).should == 2
-    @db.get(jo[%w'b c']).should == 2
-    @db.get(jo['b'].get_text(%w'd e')).should == "3"
-    @db.get(jo[%w'b d'].get_text('e')).should == "3"
-    @db.get(ja[1]).should == 3
-    @db.get(ja[%w'2 1']).should == 'b'
-
-    @db.get(jo.extract('a')).should == 1
-    @db.get(jo.extract('b').extract('c')).should == 2
-    @db.get(jo.extract('b', 'c')).should == 2
-    @db.get(jo.extract('b', 'd', 'e')).should == 3
-    @db.get(jo.extract_text('b', 'd')).should == '{"e":3}'
-    @db.get(jo.extract_text('b', 'd', 'e')).should == '3'
-
-    @db.get(ja.array_length).should == 3
-    @db.from(ja.array_elements.as(:v)).select_map(:v).should == [2, 3, %w'a b']
-
-    @db.from(jo.keys.as(:k)).select_order_map(:k).should == %w'a b'
-    @db.from(jo.each).select_order_map(:key).should == %w'a b'
-    @db.from(jo.each).order(:key).select_map(:value).should == [1, {'c'=>2, 'd'=>{'e'=>3}}]
-    @db.from(jo.each_text).select_order_map(:key).should == %w'a b'
-    @db.from(jo.each_text).order(:key).where(:key=>'b').get(:value).should =~ /\{"d":\{"e":3\},"c":2\}|\{"c":2,"d":\{"e":3\}\}/
-
-    Sequel.extension :pg_row_ops
-    @db.create_table!(:items) do
-      Integer :a
-      String :b
-    end
-    j = Sequel.pg_json('a'=>1, 'b'=>'c').op
-    @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:a]).should == 1
-    @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:b]).should == 'c'
-    j = Sequel.pg_json([{'a'=>1, 'b'=>'c'}, {'a'=>2, 'b'=>'d'}]).op
-    @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:a).should == [1, 2]
-    @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:b).should == %w'c d'
-  end if DB.server_version >= 90300 && (DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc)
+    specify 'operations/functions with pg_json_ops' do
+      Sequel.extension :pg_json_ops
+      jo = pg_json.call('a'=>1, 'b'=>{'c'=>2, 'd'=>{'e'=>3}}).op
+      ja = pg_json.call([2, 3, %w'a b']).op
+
+      @db.get(jo['a']).should == 1
+      @db.get(jo['b']['c']).should == 2
+      @db.get(jo[%w'b c']).should == 2
+      @db.get(jo['b'].get_text(%w'd e')).should == "3"
+      @db.get(jo[%w'b d'].get_text('e')).should == "3"
+      @db.get(ja[1]).should == 3
+      @db.get(ja[%w'2 1']).should == 'b'
+
+      @db.get(jo.extract('a')).should == 1
+      @db.get(jo.extract('b').extract('c')).should == 2
+      @db.get(jo.extract('b', 'c')).should == 2
+      @db.get(jo.extract('b', 'd', 'e')).should == 3
+      @db.get(jo.extract_text('b', 'd')).gsub(' ', '').should == '{"e":3}'
+      @db.get(jo.extract_text('b', 'd', 'e')).should == '3'
+
+      @db.get(ja.array_length).should == 3
+      @db.from(ja.array_elements.as(:v)).select_map(:v).should == [2, 3, %w'a b']
+
+      if DB.server_version >= 90400 
+        @db.get(jo.typeof).should == 'object'
+        @db.get(ja.typeof).should == 'array'
+        @db.from(ja.array_elements_text.as(:v)).select_map(:v).map{|s| s.gsub(' ', '')}.should == ['2', '3', '["a","b"]']
+        @db.from(jo.to_record(true).as(:v, [Sequel.lit('a integer'), Sequel.lit('b text')])).select_map(:a).should == [1]
+        @db.from(pg_json.call([{'a'=>1, 'b'=>1}]).op.to_recordset.as(:v, [Sequel.lit('a integer'), Sequel.lit('b integer')])).select_map(:a).should == [1]
+
+        if json_type == :jsonb
+          @db.get(jo.has_key?('a')).should == true
+          @db.get(jo.has_key?('c')).should == false
+          @db.get(pg_json.call(['2', '3', %w'a b']).op.include?('2')).should == true
+          @db.get(pg_json.call(['2', '3', %w'a b']).op.include?('4')).should == false
+
+          @db.get(jo.contain_all(['a', 'b'])).should == true
+          @db.get(jo.contain_all(['a', 'c'])).should == false
+          @db.get(jo.contain_all(['d', 'c'])).should == false
+          @db.get(jo.contain_any(['a', 'b'])).should == true
+          @db.get(jo.contain_any(['a', 'c'])).should == true
+          @db.get(jo.contain_any(['d', 'c'])).should == false
+
+          @db.get(jo.contains(jo)).should == true
+          @db.get(jo.contained_by(jo)).should == true
+          @db.get(jo.contains('a'=>1)).should == true
+          @db.get(jo.contained_by('a'=>1)).should == false
+          @db.get(pg_json.call('a'=>1).op.contains(jo)).should == false
+          @db.get(pg_json.call('a'=>1).op.contained_by(jo)).should == true
+
+          @db.get(ja.contains(ja)).should == true
+          @db.get(ja.contained_by(ja)).should == true
+          @db.get(ja.contains([2,3])).should == true
+          @db.get(ja.contained_by([2,3])).should == false
+          @db.get(pg_json.call([2,3]).op.contains(ja)).should == false
+          @db.get(pg_json.call([2,3]).op.contained_by(ja)).should == true
+        end
+      end
+
+      @db.from(jo.keys.as(:k)).select_order_map(:k).should == %w'a b'
+      @db.from(jo.each).select_order_map(:key).should == %w'a b'
+      @db.from(jo.each).order(:key).select_map(:value).should == [1, {'c'=>2, 'd'=>{'e'=>3}}]
+      @db.from(jo.each_text).select_order_map(:key).should == %w'a b'
+      @db.from(jo.each_text).order(:key).where(:key=>'b').get(:value).gsub(' ', '').should =~ /\{"d":\{"e":3\},"c":2\}|\{"c":2,"d":\{"e":3\}\}/
+
+      Sequel.extension :pg_row_ops
+      @db.create_table!(:items) do
+        Integer :a
+        String :b
+      end
+      j = Sequel.pg_json('a'=>1, 'b'=>'c').op
+      @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:a]).should == 1
+      @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:b]).should == 'c'
+      j = Sequel.pg_json([{'a'=>1, 'b'=>'c'}, {'a'=>2, 'b'=>'d'}]).op
+      @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:a).should == [1, 2]
+      @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:b).should == %w'c d'
+    end if DB.server_version >= 90300 && (DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc)
+  end
 end if DB.server_version >= 90200
 
 describe 'PostgreSQL inet/cidr types' do

data/spec/core/connection_pool_spec.rb

@@ -911,6 +911,12 @@ shared_examples_for "All connection pools classes" do
     x = nil
     @class.new(mock_db.call{123}, :after_connect=>proc{|c| x = [c, c]}).hold{}
     x.should == [123, 123]
+    @class.new(mock_db.call{123}, :after_connect=>lambda{|c| x = [c, c]}).hold{}
+    x.should == [123, 123]
+    @class.new(mock_db.call{123}, :after_connect=>proc{|c, s| x = [c, s]}).hold{}
+    x.should == [123, :default]
+    @class.new(mock_db.call{123}, :after_connect=>lambda{|c, s| x = [c, s]}).hold{}
+    x.should == [123, :default]
   end
   
   specify "should raise a DatabaseConnectionError if the connection raises an exception" do

data/spec/core/database_spec.rb

@@ -2184,6 +2184,18 @@ describe "Database#supports_savepoints?" do
   end
 end
 
+describe "Database#supports_views_with_check_option?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_views_with_check_option?.should == false
+  end
+end
+
+describe "Database#supports_views_with_local_check_option?" do
+  specify "should be false by default" do
+    Sequel::Database.new.supports_views_with_local_check_option?.should == false
+  end
+end
+
 describe "Database#supports_savepoints_in_prepared_transactions?" do
   specify "should be false by default" do
     Sequel::Database.new.supports_savepoints_in_prepared_transactions?.should == false

data/spec/core/dataset_spec.rb

@@ -870,6 +870,7 @@ describe "Dataset#as" do
   specify "should set up an alias" do
     dataset = Sequel.mock.dataset.from(:test)
     dataset.select(dataset.limit(1).select(:name).as(:n)).sql.should == 'SELECT (SELECT name FROM test LIMIT 1) AS n FROM test'
+    dataset.select(dataset.limit(1).select(:name).as(:n, [:nm])).sql.should == 'SELECT (SELECT name FROM test LIMIT 1) AS n(nm) FROM test'
   end
 end
 
@@ -2046,6 +2047,10 @@ describe "Dataset#from_self" do
     @ds.from_self(:alias=>:some_name).sql.should == 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name'
   end
   
+  specify "should use the user-specified column aliases" do
+    @ds.from_self(:alias=>:some_name, :column_aliases=>[:c1, :c2]).sql.should == 'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name(c1, c2)'
+  end
+  
   specify "should use the user-specified alias for joins" do
     @ds.from_self(:alias=>:some_name).inner_join(:posts, :alias=>:name).sql.should == \
       'SELECT * FROM (SELECT name FROM test LIMIT 1) AS some_name INNER JOIN posts ON (posts.alias = some_name.name)'
@@ -2154,6 +2159,10 @@ describe "Dataset#join_table" do
     @d.from('stats').join(Sequel.expr(:players).as(:p), {:id => :player_id}).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" AS "p" ON ("p"."id" = "stats"."player_id")'
   end
   
+  specify "should support aliased tables with an implicit column aliases" do
+    @d.from('stats').join(Sequel.expr(:players).as(:p, [:c1, :c2]), {:id => :player_id}).sql.should == 'SELECT * FROM "stats" INNER JOIN "players" AS "p"("c1", "c2") ON ("p"."id" = "stats"."player_id")'
+  end
+  
   specify "should support using an alias for the FROM when doing the first join with unqualified condition columns" do
     @d.from(Sequel.as(:foo, :f)).join_table(:inner, :bar, :id => :bar_id).sql.should == 'SELECT * FROM "foo" AS "f" INNER JOIN "bar" ON ("bar"."id" = "f"."bar_id")'
   end
@@ -2894,11 +2903,32 @@ describe "Dataset#import" do
       'COMMIT']
   end
 
+  specify "should slice based on the default_import_slice option" do
+    def @ds.default_import_slice; 2 end
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]])
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT']
+
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice=>nil)
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2)",
+      "INSERT INTO items (x, y) VALUES (3, 4)",
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT']
+  end
+
   specify "should accept a columns array and a values array with :commit_every option" do
-    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :commit_every => 3)
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :commit_every => 2)
     @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2)",
       "INSERT INTO items (x, y) VALUES (3, 4)",
+      'COMMIT',
+      'BEGIN',
       "INSERT INTO items (x, y) VALUES (5, 6)",
       'COMMIT']
   end
@@ -2920,6 +2950,14 @@ describe "Dataset#import" do
     @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) VALUES (1, 2), (3, 4), (5, 6)",
       'COMMIT']
+
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice=>2)
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (x, y) VALUES (1, 2), (3, 4)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) VALUES (5, 6)",
+      'COMMIT']
   end
 
   specify "should use correct sql for :union strategy" do
@@ -2928,6 +2966,14 @@ describe "Dataset#import" do
     @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) SELECT 1, 2 UNION ALL SELECT 3, 4 UNION ALL SELECT 5, 6",
       'COMMIT']
+
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice=>2)
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (x, y) SELECT 1, 2 UNION ALL SELECT 3, 4",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) SELECT 5, 6",
+      'COMMIT']
   end
 
   specify "should use correct sql for :union strategy when FROM is required" do
@@ -2937,6 +2983,14 @@ describe "Dataset#import" do
     @db.sqls.should == ['BEGIN',
       "INSERT INTO items (x, y) SELECT 1, 2 FROM foo UNION ALL SELECT 3, 4 FROM foo UNION ALL SELECT 5, 6 FROM foo",
       'COMMIT']
+
+    @ds.import([:x, :y], [[1, 2], [3, 4], [5, 6]], :slice=>2)
+    @db.sqls.should == ['BEGIN',
+      "INSERT INTO items (x, y) SELECT 1, 2 FROM foo UNION ALL SELECT 3, 4 FROM foo",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (x, y) SELECT 5, 6 FROM foo",
+      'COMMIT']
   end
 end
 
@@ -3622,6 +3676,7 @@ describe "Sequel::Dataset#qualify" do
 
   specify "should handle SQL::AliasedExpressions" do
     @ds.select(Sequel.expr(:a).as(:b)).qualify.sql.should == 'SELECT t.a AS b FROM t'
+    @ds.select(Sequel.expr(:a).as(:b, [:c, :d])).qualify.sql.should == 'SELECT t.a AS b(c, d) FROM t'
   end
 
   specify "should handle SQL::CaseExpressions" do
@@ -3660,7 +3715,7 @@ describe "Sequel::Dataset#qualify" do
     @ds.filter(Sequel::SQL::Wrapper.new(:a)).qualify.sql.should == 'SELECT t.* FROM t WHERE t.a'
   end
 
-  specify "should handle SQL::WindowFunctions" do
+  specify "should handle SQL::Functions with windows" do
     meta_def(@ds, :supports_window_functions?){true}
     @ds.select{sum(:a).over(:partition=>:b, :order=>:c)}.qualify.sql.should == 'SELECT sum(t.a) OVER (PARTITION BY t.b ORDER BY t.c) FROM t'
   end
@@ -4345,7 +4400,7 @@ describe "Custom ASTTransformer" do
     end.new
     ds = Sequel.mock.dataset.from(:t).cross_join(:a___g).join(:b___h, [:c]).join(:d___i, :e=>:f)
     ds.sql.should == 'SELECT * FROM t CROSS JOIN a AS g INNER JOIN b AS h USING (c) INNER JOIN d AS i ON (i.e = h.f)'
-    ds.clone(:from=>c.transform(ds.opts[:from]), :join=>c.transform(ds.opts[:join])).sql.should == 'SELECT * FROM tt CROSS JOIN aa AS gg INNER JOIN bb AS hh USING (cc) INNER JOIN dd AS ii ON (ii.ee = hh.ff)'
+    ds.clone(:from=>c.transform(ds.opts[:from]), :join=>c.transform(ds.opts[:join])).sql.should == 'SELECT * FROM tt CROSS JOIN aa AS g INNER JOIN bb AS h USING (cc) INNER JOIN dd AS i ON (ii.ee = hh.ff)'
   end
 end