sequel 3.1.0 → 3.2.0

data/spec/extensions/schema_dumper_spec.rb

@@ -228,41 +228,9 @@ END_MIG
     @d.dump_table_schema(:t3).should == "create_table(:t3) do\n  Date :c1\n  DateTime :c2, :null=>false\nend"
   end
   
-  it "should handle converting many default formats" do
-    m = @d.method(:column_schema_to_ruby_default)
-    m.call("adf", :string, :same_db=>true).inspect.should == '"adf".lit'
-    p = lambda{|d,t| m.call(d,t,{})}
-    p[nil, :integer].should == nil
-    p['1', :integer].should == 1
-    p['-1', :integer].should == -1
-    p['1.0', :float].should == 1.0
-    p['-1.0', :float].should == -1.0
-    p['1.0', :decimal].should == BigDecimal.new('1.0')
-    p['-1.0', :decimal].should == BigDecimal.new('-1.0')
-    p['1', :boolean].should == true
-    p['0', :boolean].should == false
-    p['true', :boolean].should == true
-    p['false', :boolean].should == false
-    p["'t'", :boolean].should == true
-    p["'f'", :boolean].should == false
-    p["'a'", :string].should == 'a'
-    p["'a'", :blob].should == 'a'.to_sequel_blob
-    p["'a'", :blob].should be_a_kind_of(Sequel::SQL::Blob)
-    p["''", :string].should == ''
-    p["'\\a''b'", :string].should == "\\a'b"
-    p["'NULL'", :string].should == "NULL"
-    p["'2009-10-29'", :date].should == Date.new(2009,10,29)
-    p["CURRENT_TIMESTAMP", :date].should == nil
-    p["today()", :date].should == nil
-    p["'2009-10-29T10:20:30-07:00'", :datetime].should == DateTime.parse('2009-10-29T10:20:30-07:00')
-    p["'2009-10-29 10:20:30'", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
-    p["'10:20:30'", :time].should == Time.parse('10:20:30')
-    p["NaN", :float].should == nil
-  end
-  
   it "should handle converting common defaults" do
     @d.meta_def(:schema) do |t, *os|
-      [[:c1, {:db_type=>'boolean', :default=>"false", :type=>:boolean, :allow_null=>true}],
+      s = [[:c1, {:db_type=>'boolean', :default=>"false", :type=>:boolean, :allow_null=>true}],
        [:c2, {:db_type=>'varchar', :default=>"'blah'", :type=>:string, :allow_null=>true}],
        [:c3, {:db_type=>'integer', :default=>"-1", :type=>:integer, :allow_null=>true}],
        [:c4, {:db_type=>'float', :default=>"1.0", :type=>:float, :allow_null=>true}],
@@ -272,46 +240,12 @@ END_MIG
        [:c8, {:db_type=>'datetime', :default=>"'2008-10-29 10:20:30'", :type=>:datetime, :allow_null=>true}],
        [:c9, {:db_type=>'time', :default=>"'10:20:30'", :type=>:time, :allow_null=>true}],
        [:c10, {:db_type=>'interval', :default=>"'6 weeks'", :type=>:interval, :allow_null=>true}]]
+      s.each{|_, c| c[:ruby_default] = column_schema_to_ruby_default(c[:default], c[:type])}
+      s
     end
     @d.dump_table_schema(:t4).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  TrueClass :c1, :default=>false\n  String :c2, :default=>\"blah\"\n  Integer :c3, :default=>-1\n  Float :c4, :default=>1.0\n  BigDecimal :c5, :default=>BigDecimal.new(\"0.1005E3\")\n  File :c6, :default=>Sequel::SQL::Blob.new(\"blah\")\n  Date :c7, :default=>Date.parse(\"2008-10-29\")\n  DateTime :c8, :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  Time :c9, :default=>Time.parse(\"10:20:30\"), :only_time=>true\n  String :c10\nend"
     @d.dump_table_schema(:t4, :same_db=>true).gsub(/[+-]\d\d:\d\d"\)/, '")').should == "create_table(:t4) do\n  column :c1, \"boolean\", :default=>false\n  column :c2, \"varchar\", :default=>\"blah\"\n  column :c3, \"integer\", :default=>-1\n  column :c4, \"float\", :default=>1.0\n  column :c5, \"decimal\", :default=>BigDecimal.new(\"0.1005E3\")\n  column :c6, \"blob\", :default=>Sequel::SQL::Blob.new(\"blah\")\n  column :c7, \"date\", :default=>Date.parse(\"2008-10-29\")\n  column :c8, \"datetime\", :default=>DateTime.parse(\"2008-10-29T10:20:30\")\n  column :c9, \"time\", :default=>Time.parse(\"10:20:30\")\n  column :c10, \"interval\", :default=>\"'6 weeks'\".lit\nend"
   end
-  
-  it "should handle converting PostgreSQL specific default formats" do
-    m = @d.method(:column_schema_to_ruby_default)
-    @d.meta_def(:database_type){:postgres}
-    p = lambda{|d,t| m.call(d,t,{})}
-    p["''::text", :string].should == ""
-    p["'\\a''b'::character varying", :string].should == "\\a'b"
-    p["'a'::bpchar", :string].should == "a"
-    p["(-1)", :integer].should == -1
-    p["(-1.0)", :float].should == -1.0
-    p['(-1.0)', :decimal].should == BigDecimal.new('-1.0')
-    p["'a'::bytea", :blob].should == 'a'.to_sequel_blob
-    p["'a'::bytea", :blob].should be_a_kind_of(Sequel::SQL::Blob)
-    p["'2009-10-29'::date", :date].should == Date.new(2009,10,29)
-    p["'2009-10-29 10:20:30.241343'::timestamp without time zone", :datetime].should == DateTime.parse('2009-10-29 10:20:30.241343')
-    p["'10:20:30'::time without time zone", :time].should == Time.parse('10:20:30')
-  end
-  
-  it "should handle converting MySQL specific default formats" do
-    m = @d.method(:column_schema_to_ruby_default)
-    @d.meta_def(:database_type){:mysql}
-    p = lambda{|d,t| m.call(d,t,{})}
-    s = lambda{|d,t| m.call(d,t,{:same_db=>true})}
-    p["\\a'b", :string].should == "\\a'b"
-    p["a", :string].should == "a"
-    p["NULL", :string].should == "NULL"
-    p["-1", :float].should == -1.0
-    p['-1', :decimal].should == BigDecimal.new('-1.0')
-    p["2009-10-29", :date].should == Date.new(2009,10,29)
-    p["2009-10-29 10:20:30", :datetime].should == DateTime.parse('2009-10-29 10:20:30')
-    p["10:20:30", :time].should == Time.parse('10:20:30')
-    p["CURRENT_DATE", :date].should == nil
-    p["CURRENT_TIMESTAMP", :datetime].should == nil
-    s["CURRENT_DATE", :date].inspect.should == "\"CURRENT_DATE\".lit"
-    s["CURRENT_TIMESTAMP", :datetime].inspect.should == "\"CURRENT_TIMESTAMP\".lit"
-  end
 
   it "should convert unknown database types to strings" do
     @d.dump_table_schema(:t5).should == "create_table(:t5) do\n  String :c1\nend"

data/spec/extensions/single_table_inheritance_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(__FILE__), "spec_helper")
 describe Sequel::Model, "#sti_key" do
   before do
     class ::StiTest < Sequel::Model
+      def kind; self[:kind]; end 
       def kind=(x); self[:kind] = x; end 
       def _refresh(x); end 
       plugin :single_table_inheritance, :kind
@@ -74,6 +75,11 @@ describe Sequel::Model, "#sti_key" do
     MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
   end
 
+  it "should have the before_create hook not override an existing value" do
+    StiTest.create(:kind=>'StiTestSub1')
+    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')"]
+  end
+
   it "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
     StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
     StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')"

data/spec/integration/dataset_test.rb

@@ -249,7 +249,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
   
   specify "should give the correct results for simple UNION, EXCEPT, and INTERSECT" do
     @ds1.union(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
-    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    if @ds1.supports_intersect_except?
       @ds1.except(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'20'
       @ds1.intersect(@ds2).order(:number).map{|x| x[:number].to_s}.should == %w'10'
     end
@@ -285,7 +285,7 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
 
     @ds1.union(@ds2).union(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
     @ds1.union(@ds2.union(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30 40'
-    unless defined?(Sequel::Dataset::UnsupportedIntersectExcept) and @ds1.class.ancestors.include?(Sequel::Dataset::UnsupportedIntersectExcept)
+    if @ds1.supports_intersect_except?
       @ds1.union(@ds2).except(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'20 30'
       @ds1.union(@ds2.except(@ds3)).order(:number).map{|x| x[:number].to_s}.should == %w'10 20 30'
       @ds1.union(@ds2).intersect(@ds3).order(:number).map{|x| x[:number].to_s}.should == %w'10 '
@@ -307,3 +307,85 @@ describe "Dataset UNION, EXCEPT, and INTERSECT" do
     end
   end
 end
+
+if INTEGRATION_DB.dataset.supports_cte?
+  describe "Common Table Expressions" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :parent_id}
+      @ds = @db[:i1]
+      @ds.insert(:id=>1)
+      @ds.insert(:id=>2)
+      @ds.insert(:id=>3, :parent_id=>1)
+      @ds.insert(:id=>4, :parent_id=>1)
+      @ds.insert(:id=>5, :parent_id=>3)
+      @ds.insert(:id=>6, :parent_id=>5)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results for WITH" do
+      @db[:t].with(:t, @ds.order(:id).filter(:parent_id=>nil).select(:id)).map(:id).should == [1, 2]
+    end
+    
+    specify "should give correct results for recursive WITH" do
+      ds = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>nil), @ds.join(:t, :i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi])
+      ds.all.should == [{:parent_id=>nil, :id=>1}, {:parent_id=>nil, :id=>2}, {:parent_id=>1, :id=>3}, {:parent_id=>1, :id=>4}, {:parent_id=>3, :id=>5}, {:parent_id=>5, :id=>6}]
+      ps = @db[:t].select(:i___id, :pi___parent_id).with_recursive(:t, @ds.filter(:parent_id=>:$n), @ds.join(:t, :i=>:parent_id).filter(:t__i=>:parent_id).select(:i1__id, :i1__parent_id), :args=>[:i, :pi]).prepare(:select, :cte_sel)
+      ps.call(:n=>1).should == [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>3}, {:id=>6, :parent_id=>5}]
+      ps.call(:n=>3).should == [{:id=>5, :parent_id=>3}, {:id=>6, :parent_id=>5}]
+      ps.call(:n=>5).should == [{:id=>6, :parent_id=>5}]
+    end
+  end
+end
+
+if INTEGRATION_DB.dataset.supports_window_functions?
+  describe "Window Functions" do
+    before do
+      @db = INTEGRATION_DB
+      @db.create_table!(:i1){Integer :id; Integer :group_id; Integer :amount}
+      @ds = @db[:i1].order(:id)
+      @ds.insert(:id=>1, :group_id=>1, :amount=>1)
+      @ds.insert(:id=>2, :group_id=>1, :amount=>10)
+      @ds.insert(:id=>3, :group_id=>1, :amount=>100)
+      @ds.insert(:id=>4, :group_id=>2, :amount=>1000)
+      @ds.insert(:id=>5, :group_id=>2, :amount=>10000)
+      @ds.insert(:id=>6, :group_id=>2, :amount=>100000)
+    end
+    after do
+      @db.drop_table(:i1)
+    end
+    
+    specify "should give correct results for window functions" do
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id){}}.all.should ==
+        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount){}}.all.should ==
+        [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
+    end
+    
+    specify "should give correct results for window functions with frames" do
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:all){}}.all.should ==
+        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:all){}}.all.should ==
+        [{:sum=>111, :id=>1}, {:sum=>111, :id=>2}, {:sum=>111, :id=>3}, {:sum=>111000, :id=>4}, {:sum=>111000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:all){}}.all.should ==
+        [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :frame=>:all){}}.all.should ==
+        [{:sum=>111111, :id=>1}, {:sum=>111111, :id=>2}, {:sum=>111111, :id=>3}, {:sum=>111111, :id=>4}, {:sum=>111111, :id=>5}, {:sum=>111111, :id=>6}]
+        
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :order=>id, :frame=>:rows){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :partition=>group_id, :frame=>:rows){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1000, :id=>4}, {:sum=>11000, :id=>5}, {:sum=>111000, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :order=>id, :frame=>:rows){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+      @ds.select(:id){sum(:over, :args=>amount, :frame=>:rows){}}.all.should ==
+        [{:sum=>1, :id=>1}, {:sum=>11, :id=>2}, {:sum=>111, :id=>3}, {:sum=>1111, :id=>4}, {:sum=>11111, :id=>5}, {:sum=>111111, :id=>6}]
+    end
+  end
+end

data/spec/integration/schema_test.rb

@@ -74,11 +74,11 @@ describe "Database schema parser" do
 
   specify "should parse defaults from the schema properly" do
     INTEGRATION_DB.create_table!(:items){Integer :number}
-    INTEGRATION_DB.schema(:items).first.last[:default].should == nil
+    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == nil
     INTEGRATION_DB.create_table!(:items){Integer :number, :default=>0}
-    INTEGRATION_DB.schema(:items).first.last[:default].to_s.should == "0"
+    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 0
     INTEGRATION_DB.create_table!(:items){String :a, :default=>"blah"}
-    INTEGRATION_DB.schema(:items).first.last[:default].should include('blah')
+    INTEGRATION_DB.schema(:items).first.last[:ruby_default].should == 'blah'
   end
 
   specify "should parse types from the schema properly" do
@@ -146,9 +146,7 @@ end
 
 describe "Database schema modifiers" do
   before do
-    INTEGRATION_DB.create_table!(:items){Integer :number}
     @ds = INTEGRATION_DB[:items]
-    @ds.insert([10])
     clear_sqls
   end
   after do
@@ -156,12 +154,27 @@ describe "Database schema modifiers" do
   end
 
   specify "should create tables correctly" do
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.table_exists?(:items).should == true
     INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
+    @ds.insert([10])
     @ds.columns!.should == [:number]
   end
 
+  specify "should handle foreign keys correctly when creating tables" do
+    INTEGRATION_DB.create_table!(:items) do 
+      primary_key :id
+      foreign_key :item_id, :items
+      unique [:item_id, :id]
+      foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
+    end
+    INTEGRATION_DB.table_exists?(:items).should == true
+    INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:id, :item_id]
+    @ds.columns!.should == [:id, :item_id]
+  end
+
   specify "should add columns to tables correctly" do
+    INTEGRATION_DB.create_table!(:items){Integer :number}
     INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number]
     @ds.columns!.should == [:number]
     INTEGRATION_DB.alter_table(:items){add_column :name, :text}
@@ -174,6 +187,12 @@ describe "Database schema modifiers" do
       INTEGRATION_DB.alter_table(:items){add_foreign_key :item_id, :items}
       INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
       @ds.columns!.should == [:number, :name, :id, :item_id]
+      INTEGRATION_DB.alter_table(:items) do
+        add_unique_constraint [:item_id, :id]
+        add_foreign_key [:id, :item_id], :items, :key=>[:item_id, :id]
+      end
+      INTEGRATION_DB.schema(:items, :reload=>true).map{|x| x.first}.should == [:number, :name, :id, :item_id]
+      @ds.columns!.should == [:number, :name, :id, :item_id]
     end
   end
 

data/spec/integration/spec_helper.rb

@@ -1,10 +1,11 @@
 require 'rubygems'
+require 'logger'
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(__FILE__), "../../lib/"))
   require 'sequel'
 end
 begin
-  require File.join(File.dirname(__FILE__), '../spec_config.rb')
+  require File.join(File.dirname(File.dirname(__FILE__)), 'spec_config.rb') unless defined?(INTEGRATION_DB)
 rescue LoadError
 end
 
@@ -16,12 +17,13 @@ def clear_sqls
 end 
 
 class Spec::Example::ExampleGroup
-  def start_logging
-    require 'logger'
-    INTEGRATION_DB.loggers << Logger.new(STDOUT)
-  end
-  def stop_logging
+  def log
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
      INTEGRATION_DB.loggers.clear
+    end
   end
 end
 

data/spec/model/eager_loading_spec.rb

@@ -628,6 +628,15 @@ describe Sequel::Model, "#eager_graph" do
     proc{GraphAlbum.eager_graph(Object.new)}.should raise_error(Sequel::Error)
   end
 
+  it "should not split results and assign associations if ungraphed is called" do
+    ds = GraphAlbum.eager_graph(:band).ungraphed
+    ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3})
+    end
+    ds.all.should == [GraphAlbum.load(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3)]
+  end
+
   it "should eagerly load a single many_to_one association" do
     ds = GraphAlbum.eager_graph(:band)
     ds.sql.should == 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'

data/spec/model/record_spec.rb

@@ -35,19 +35,19 @@ describe "Model#save server use" do
 end
 
 describe "Model#save" do
-  
-  before(:each) do
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x, :y
     end
+    @c.dataset.meta_def(:insert){|h| super(h); 1}
     MODEL_DB.reset
   end
   
   it "should insert a record for a new model instance" do
     o = @c.new(:x => 1)
     o.save
-    
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)",
+      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
 
   it "should use dataset's insert_select method if present" do
@@ -60,15 +60,42 @@ describe "Model#save" do
     o.save
     
     o.values.should == {:y=>2}
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (2)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (2)"]
+  end
+
+  it "should use value returned by insert as the primary key" do
+    @c.dataset.meta_def(:insert){|h| super(h); 13}
+    o = @c.new(:x => 11)
+    o.save
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (11)",
+      "SELECT * FROM items WHERE (id = 13) LIMIT 1"]
+  end
+
+  it "should work correctly for inserting a record without a primary key" do
+    @c.dataset.meta_def(:insert){|h| super(h); 13}
+    @c.no_primary_key
+    o = @c.new(:x => 11)
+    o.save
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (11)"]
+  end
+
+  it "should set the autoincrementing_primary_key value to the value returned by insert" do
+    @c.dataset.meta_def(:insert){|h| super(h); 13}
+    @c.unrestrict_primary_key
+    @c.set_primary_key [:x, :y]
+    o = @c.new(:x => 11)
+    o.meta_def(:autoincrementing_primary_key){:y}
+    o.save
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (11)"
+    MODEL_DB.sqls.last.should =~ %r{SELECT \* FROM items WHERE \(\([xy] = 1[13]\) AND \([xy] = 1[13]\)\) LIMIT 1}
   end
 
   it "should update a record for an existing model instance" do
     o = @c.load(:id => 3, :x => 1)
     o.save
-    
-    MODEL_DB.sqls.first.should =~ 
-      /UPDATE items SET (id = 3, x = 1|x = 1, id = 3) WHERE \(id = 3\)/
+    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.first.should =~ /UPDATE items SET (id = 3, x = 1|x = 1, id = 3) WHERE \(id = 3\)/
   end
   
   it "should update only the given columns if given" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 3.1.0
+  version: 3.2.0
 platform: ruby
 authors: 
 - Jeremy Evans
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-04 00:00:00 -07:00
+date: 2009-07-02 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,7 @@ extra_rdoc_files:
 - doc/sharding.rdoc
 - doc/virtual_rows.rdoc
 - doc/reflection.rdoc
+- doc/opening_databases.rdoc
 - doc/release_notes/2.10.0.txt
 - doc/release_notes/2.9.0.txt
 - doc/release_notes/2.8.0.txt
@@ -51,6 +52,7 @@ extra_rdoc_files:
 - doc/release_notes/2.12.0.txt
 - doc/release_notes/3.0.0.txt
 - doc/release_notes/3.1.0.txt
+- doc/release_notes/3.2.0.txt
 files: 
 - COPYING
 - CHANGELOG
@@ -84,8 +86,10 @@ files:
 - doc/release_notes/2.12.0.txt
 - doc/release_notes/3.0.0.txt
 - doc/release_notes/3.1.0.txt
+- doc/release_notes/3.2.0.txt
 - doc/virtual_rows.rdoc
 - doc/reflection.rdoc
+- doc/opening_databases.rdoc
 - spec/adapters
 - spec/adapters/ado_spec.rb
 - spec/adapters/informix_spec.rb
@@ -111,9 +115,9 @@ files:
 - spec/core/core_sql_spec.rb
 - spec/core/dataset_spec.rb
 - spec/core/expression_filters_spec.rb
+- spec/core/schema_spec.rb
 - spec/core/object_graph_spec.rb
 - spec/core/schema_generator_spec.rb
-- spec/core/schema_spec.rb
 - spec/core/spec_helper.rb
 - spec/core/version_spec.rb
 - spec/model
@@ -210,10 +214,7 @@ files:
 - lib/sequel/adapters/shared/sqlite.rb
 - lib/sequel/adapters/sqlite.rb
 - lib/sequel/adapters/utils
-- lib/sequel/adapters/utils/date_format.rb
 - lib/sequel/adapters/utils/stored_procedures.rb
-- lib/sequel/adapters/utils/unsupported.rb
-- lib/sequel/adapters/utils/savepoint_transactions.rb
 - lib/sequel/adapters/amalgalite.rb
 - lib/sequel/connection_pool.rb
 - lib/sequel/core.rb
@@ -232,6 +233,7 @@ files:
 - lib/sequel/model.rb
 - lib/sequel/exceptions.rb
 - lib/sequel/metaprogramming.rb
+- lib/sequel/sql.rb
 - lib/sequel/model
 - lib/sequel/model/associations.rb
 - lib/sequel/model/base.rb
@@ -239,7 +241,6 @@ files:
 - lib/sequel/model/errors.rb
 - lib/sequel/model/exceptions.rb
 - lib/sequel/model/inflections.rb
-- lib/sequel/sql.rb
 - lib/sequel/version.rb
 has_rdoc: true
 homepage: http://sequel.rubyforge.org