sequel 4.46.0 → 4.49.0

data/spec/adapters/db2_spec.rb

@@ -28,9 +28,47 @@ describe Sequel::Database do
   end
 end
 
+# SEQUEL5: Remove
 describe "Simple Dataset operations" do
   before(:all) do
-    Sequel::DB2.use_clob_as_blob = true
+    deprecated do
+      Sequel::DB2.use_clob_as_blob = true
+    end
+    DB.send(:remove_instance_variable, :@use_clob_as_blob) if DB.send(:instance_variable_defined?, :@use_clob_as_blob)
+    DB.create_table!(:items) do
+      Integer :id, :primary_key => true
+      Integer :number
+      column  :bin_string, 'varchar(20) for bit data'
+      column  :bin_clob, 'clob'
+    end
+    @ds = DB[:items]
+  end
+  after(:each) do
+    @ds.delete
+  end
+  after(:all) do
+    deprecated do
+      Sequel::DB2.use_clob_as_blob = false
+    end
+    DB.send(:remove_instance_variable, :@use_clob_as_blob) if DB.send(:instance_variable_defined?, :@use_clob_as_blob)
+    DB.drop_table(:items)
+  end
+
+  it "should insert with a primary key specified" do
+    @ds.insert(:id => 1,   :number => 10)
+    @ds.insert(:id => 100, :number => 20)
+    @ds.select_hash(:id, :number).must_equal(1 => 10, 100 => 20)
+  end
+
+  it "should insert into binary columns" do
+    @ds.insert(:id => 1, :bin_string => Sequel.blob("\1"), :bin_clob => Sequel.blob("\2"))
+    @ds.select(:bin_string, :bin_clob).first.must_equal(:bin_string => "\1", :bin_clob => "\2")
+  end
+end
+
+describe "Simple Dataset operations" do
+  before(:all) do
+    DB.use_clob_as_blob = true
     DB.create_table!(:items) do
       Integer :id, :primary_key => true
       Integer :number
@@ -43,7 +81,7 @@ describe "Simple Dataset operations" do
     @ds.delete
   end
   after(:all) do
-    Sequel::DB2.use_clob_as_blob = false
+    DB.use_clob_as_blob = false
     DB.drop_table(:items)
   end
 
@@ -88,6 +126,7 @@ describe Sequel::Database do
   end
 end
 
+# SEQUEL5: remove
 describe "Sequel::IBMDB.convert_smallint_to_bool" do
   before do
     @db = DB
@@ -95,55 +134,117 @@ describe "Sequel::IBMDB.convert_smallint_to_bool" do
     @ds = @db[:booltest]
   end
   after do
+    deprecated do
+      Sequel::IBMDB.convert_smallint_to_bool = true
+    end
+    @db.drop_table(:booltest)
+  end
+  
+  deprecated "should consider smallint datatypes as boolean if set, but not larger smallints" do
+    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
+    @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
+  end
+  
+  deprecated "should return smallints as bools and integers as integers when set" do
     Sequel::IBMDB.convert_smallint_to_bool = true
+    @ds.delete
+    @ds.insert(:b=>true, :i=>10)
+    @ds.all.must_equal [{:b=>true, :i=>10}]
+    @ds.delete
+    @ds.insert(:b=>false, :i=>0)
+    @ds.all.must_equal [{:b=>false, :i=>0}]
+    @ds.delete
+    @ds.insert(:b=>true, :i=>1)
+    @ds.all.must_equal [{:b=>true, :i=>1}]
+
+    @ds = @ds.with_convert_smallint_to_bool(false)
+    @ds.delete
+    @ds.insert(:b=>true, :i=>10)
+    @ds.all.must_equal [{:b=>1, :i=>10}]
+  end
+
+  deprecated "should return all smallints as integers when unset" do
+    Sequel::IBMDB.convert_smallint_to_bool = false
+    @ds.delete
+    @ds.insert(:b=>true, :i=>10)
+    @ds.all.must_equal [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds.insert(:b=>false, :i=>0)
+    @ds.all.must_equal [{:b=>0, :i=>0}]
+    
+    @ds.delete
+    @ds.insert(:b=>1, :i=>10)
+    @ds.all.must_equal [{:b=>1, :i=>10}]
+    @ds.delete
+    @ds.insert(:b=>0, :i=>0)
+    @ds.all.must_equal [{:b=>0, :i=>0}]
+
+    @ds = @ds.with_convert_smallint_to_bool(true)
+    @ds.delete
+    @ds.insert(:b=>true, :i=>10)
+    @ds.all.must_equal [{:b=>true, :i=>10}]
+  end
+end if DB.adapter_scheme == :ibmdb
+
+describe "Sequel::IBMDB::Database#convert_smallint_to_bool" do
+  before do
+    @db = DB
+    @db.create_table!(:booltest){column :b, 'smallint'; column :i, 'integer'}
+    @ds = @db[:booltest]
+  end
+  after do
+    @db.convert_smallint_to_bool = nil # SEQUEL5: true
     @db.drop_table(:booltest)
   end
   
   it "should consider smallint datatypes as boolean if set, but not larger smallints" do
     @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :boolean
     @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
-    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.convert_smallint_to_bool = false
     @db.schema(:booltest, :reload=>true).first.last[:type].must_equal :integer
     @db.schema(:booltest, :reload=>true).first.last[:db_type].must_match /smallint/i
   end
   
   it "should return smallints as bools and integers as integers when set" do
-    Sequel::IBMDB.convert_smallint_to_bool = true
+    @db.convert_smallint_to_bool = true
     @ds.delete
-    @ds << {:b=>true, :i=>10}
+    @ds.insert(:b=>true, :i=>10)
     @ds.all.must_equal [{:b=>true, :i=>10}]
     @ds.delete
-    @ds << {:b=>false, :i=>0}
+    @ds.insert(:b=>false, :i=>0)
     @ds.all.must_equal [{:b=>false, :i=>0}]
     @ds.delete
-    @ds << {:b=>true, :i=>1}
+    @ds.insert(:b=>true, :i=>1)
     @ds.all.must_equal [{:b=>true, :i=>1}]
 
     @ds = @ds.with_convert_smallint_to_bool(false)
     @ds.delete
-    @ds << {:b=>true, :i=>10}
+    @ds.insert(:b=>true, :i=>10)
     @ds.all.must_equal [{:b=>1, :i=>10}]
   end
 
   it "should return all smallints as integers when unset" do
-    Sequel::IBMDB.convert_smallint_to_bool = false
+    @db.convert_smallint_to_bool = false
     @ds.delete
-    @ds << {:b=>true, :i=>10}
+    @ds.insert(:b=>true, :i=>10)
     @ds.all.must_equal [{:b=>1, :i=>10}]
     @ds.delete
-    @ds << {:b=>false, :i=>0}
+    @ds.insert(:b=>false, :i=>0)
     @ds.all.must_equal [{:b=>0, :i=>0}]
     
     @ds.delete
-    @ds << {:b=>1, :i=>10}
+    @ds.insert(:b=>1, :i=>10)
     @ds.all.must_equal [{:b=>1, :i=>10}]
     @ds.delete
-    @ds << {:b=>0, :i=>0}
+    @ds.insert(:b=>0, :i=>0)
     @ds.all.must_equal [{:b=>0, :i=>0}]
 
     @ds = @ds.with_convert_smallint_to_bool(true)
     @ds.delete
-    @ds << {:b=>true, :i=>10}
+    @ds.insert(:b=>true, :i=>10)
     @ds.all.must_equal [{:b=>true, :i=>10}]
   end
 end if DB.adapter_scheme == :ibmdb

data/spec/adapters/mssql_spec.rb

@@ -17,13 +17,13 @@ describe "A MSSQL database" do
   end
 
   it "should be able to read fractional part of timestamp" do
-    rs = @db["select getutcdate() as full_date, cast(datepart(millisecond, getutcdate()) as int) as milliseconds"].first
-    rs[:milliseconds].must_equal rs[:full_date].usec/1000
+    rs = @db["select getutcdate() as full_date, cast(round(datepart(millisecond, getutcdate()), 0) as int) as milliseconds"].first
+    rs[:milliseconds].must_be_close_to(rs[:full_date].usec/1000, 2)
   end
 
   it "should be able to write fractional part of timestamp" do
-    t = Time.utc(2001, 12, 31, 23, 59, 59, 997000)
-    (t.usec/1000).must_equal @db["select cast(datepart(millisecond, ?) as int) as milliseconds", t].get
+    t = Time.utc(2001, 12, 31, 23, 59, 59, 996000)
+    (t.usec/1000).must_equal @db["select cast(round(datepart(millisecond, ?), 0) as int) as milliseconds", t].get
   end
   
   it "should not raise an error when getting the server version" do

data/spec/adapters/mysql_spec.rb

@@ -121,30 +121,30 @@ if [:mysql, :mysql2].include?(DB.adapter_scheme)
     it "should return tinyint(1)s as bools and tinyint(4)s as integers when set" do
       @db.convert_tinyint_to_bool = true
       @ds.delete
-      @ds << {:b=>true, :i=>10}
+      @ds.insert(:b=>true, :i=>10)
       @ds.all.must_equal [{:b=>true, :i=>10}]
       @ds.delete
-      @ds << {:b=>false, :i=>0}
+      @ds.insert(:b=>false, :i=>0)
       @ds.all.must_equal [{:b=>false, :i=>0}]
       @ds.delete
-      @ds << {:b=>true, :i=>1}
+      @ds.insert(:b=>true, :i=>1)
       @ds.all.must_equal [{:b=>true, :i=>1}]
     end
 
     it "should return all tinyints as integers when unset" do
       @db.convert_tinyint_to_bool = false
       @ds.delete
-      @ds << {:b=>true, :i=>10}
+      @ds.insert(:b=>true, :i=>10)
       @ds.all.must_equal [{:b=>1, :i=>10}]
       @ds.delete
-      @ds << {:b=>false, :i=>0}
+      @ds.insert(:b=>false, :i=>0)
       @ds.all.must_equal [{:b=>0, :i=>0}]
 
       @ds.delete
-      @ds << {:b=>1, :i=>10}
+      @ds.insert(:b=>1, :i=>10)
       @ds.all.must_equal [{:b=>1, :i=>10}]
       @ds.delete
-      @ds << {:b=>0, :i=>0}
+      @ds.insert(:b=>0, :i=>0)
       @ds.all.must_equal [{:b=>0, :i=>0}]
     end
 
@@ -155,7 +155,7 @@ if [:mysql, :mysql2].include?(DB.adapter_scheme)
         def convert_tinyint_to_bool?() false end #mysql2
       end
       ds.delete
-      ds << {:b=>true, :i=>10}
+      ds.insert(:b=>true, :i=>10)
       ds.all.must_equal [{:b=>1, :i=>10}]
       @ds.all.must_equal [{:b=>true, :i=>10}]
     end
@@ -220,8 +220,8 @@ describe "A MySQL dataset" do
   end if false # SEQUEL5
 
   it "should support regexps" do
-    @d << {:name => 'abc', :value => 1}
-    @d << {:name => 'bcd', :value => 2}
+    @d.insert(:name => 'abc', :value => 1)
+    @d.insert(:name => 'bcd', :value => 2)
     @d.filter(:name => /bc/).count.must_equal 2
     @d.filter(:name => /^bc/).count.must_equal 1
   end
@@ -234,7 +234,7 @@ describe "A MySQL dataset" do
 
   it "should correctly literalize strings with comment backslashes in them" do
     @d.delete
-    @d << {:name => ':\\'}
+    @d.insert(:name => ':\\')
 
     @d.first[:name].must_equal ':\\'
   end
@@ -297,6 +297,9 @@ describe "MySQL join expressions" do
   it "should raise error for :full_outer join requests." do
     lambda{@ds.join_table(:full_outer, :nodes)}.must_raise(Sequel::Error)
   end
+  it "should raise error for :natural_full join requests." do
+    lambda{@ds.join_table(:natural_full, :nodes)}.must_raise(Sequel::Error)
+  end
   it "should support natural left joins" do
     @ds.join_table(:natural_left, :nodes).sql.must_equal 'SELECT * FROM `nodes` NATURAL LEFT JOIN `nodes`'
   end
@@ -309,13 +312,13 @@ describe "MySQL join expressions" do
   it "should support natural right outer joins" do
     @ds.join_table(:natural_right_outer, :nodes).sql.must_equal 'SELECT * FROM `nodes` NATURAL RIGHT OUTER JOIN `nodes`'
   end
-  it "should support natural inner joins" do
+  deprecated "should support natural inner joins" do
     @ds.join_table(:natural_inner, :nodes).sql.must_equal 'SELECT * FROM `nodes` NATURAL LEFT JOIN `nodes`'
   end
   it "should support cross joins" do
     @ds.join_table(:cross, :nodes).sql.must_equal 'SELECT * FROM `nodes` CROSS JOIN `nodes`'
   end
-  it "should support cross joins as inner joins if conditions are used" do
+  deprecated "should support cross joins as inner joins if conditions are used" do
     @ds.join_table(:cross, :nodes, :id=>:id).sql.must_equal 'SELECT * FROM `nodes` INNER JOIN `nodes` ON (`nodes`.`id` = `nodes`.`id`)'
   end
   it "should support straight joins (force left table to be read before right)" do
@@ -391,7 +394,7 @@ describe "A MySQL database" do
     @db.add_column :test2, :xyz, :text
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => '000'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => '000')
     @db[:test2].first[:xyz].must_equal '000'
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
@@ -401,7 +404,7 @@ describe "A MySQL database" do
 
     @db[:test2].delete
     @db.add_column :test2, :xyz, :text
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => 'qqqq')
 
     @db[:test2].columns.must_equal [:name, :value, :xyz]
     @db.rename_column :test2, :xyz, :zyx, :type => :text
@@ -410,7 +413,7 @@ describe "A MySQL database" do
 
     @db[:test2].delete
     @db.add_column :test2, :tre, :text
-    @db[:test2] << {:name => 'mmm', :value => 111, :tre => 'qqqq'}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :tre => 'qqqq')
 
     @db[:test2].columns.must_equal [:name, :value, :zyx, :tre]
     @db.rename_column :test2, :tre, :ert, :type => :varchar, :size=>255
@@ -419,7 +422,7 @@ describe "A MySQL database" do
 
     @db.add_column :test2, :xyz, :float
     @db[:test2].delete
-    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
+    @db[:test2].insert(:name => 'mmm', :value => 111, :xyz => 56.78)
     @db.set_column_type :test2, :xyz, :integer
 
     @db[:test2].first[:xyz].must_equal 57
@@ -437,15 +440,62 @@ describe "A MySQL database" do
   end
 end  
 
+# SEQUEL5: Remove
 describe "A MySQL database with table options" do
   before do
     @options = {:engine=>'MyISAM', :charset=>'latin1', :collate => 'latin1_swedish_ci'}
 
-    Sequel::MySQL.default_engine = 'InnoDB'
-    Sequel::MySQL.default_charset = 'utf8'
-    Sequel::MySQL.default_collate = 'utf8_general_ci'
+    deprecated do
+      Sequel::MySQL.default_engine = 'InnoDB'
+      Sequel::MySQL.default_charset = 'utf8'
+      Sequel::MySQL.default_collate = 'utf8_general_ci'
+    end
+
+    @db = DB
+    @db.drop_table?(:items)
+
+    DB.sqls.clear
+  end
+  after do
+    @db.drop_table?(:items)
+
+    deprecated do
+      Sequel::MySQL.default_engine = nil
+      Sequel::MySQL.default_charset = nil
+      Sequel::MySQL.default_collate = nil
+    end
+  end
+
+  it "should allow to pass custom options (engine, charset, collate) for table creation" do
+    @db.create_table(:items, @options){Integer :size; text :name}
+    check_sqls do
+      @db.sqls.must_equal ["CREATE TABLE `items` (`size` integer, `name` text) ENGINE=MyISAM DEFAULT CHARSET=latin1 DEFAULT COLLATE=latin1_swedish_ci"]
+    end
+  end
+
+  it "should use default options if specified (engine, charset, collate) for table creation" do
+    @db.create_table(:items){Integer :size; text :name}
+    check_sqls do
+      @db.sqls.must_equal ["CREATE TABLE `items` (`size` integer, `name` text) ENGINE=InnoDB DEFAULT CHARSET=utf8 DEFAULT COLLATE=utf8_general_ci"]
+    end
+  end
+
+  it "should not use default if option has a nil value" do
+    @db.create_table(:items, :engine=>nil, :charset=>nil, :collate=>nil){Integer :size; text :name}
+    check_sqls do
+      @db.sqls.must_equal ["CREATE TABLE `items` (`size` integer, `name` text)"]
+    end
+  end
+end
+
+describe "A MySQL database with table options" do
+  before do
+    @options = {:engine=>'MyISAM', :charset=>'latin1', :collate => 'latin1_swedish_ci'}
 
     @db = DB
+    @db.default_engine = 'InnoDB'
+    @db.default_charset = 'utf8'
+    @db.default_collate = 'utf8_general_ci'
     @db.drop_table?(:items)
 
     DB.sqls.clear
@@ -453,9 +503,9 @@ describe "A MySQL database with table options" do
   after do
     @db.drop_table?(:items)
 
-    Sequel::MySQL.default_engine = nil
-    Sequel::MySQL.default_charset = nil
-    Sequel::MySQL.default_collate = nil
+    @db.default_engine = nil
+    @db.default_charset = nil
+    @db.default_collate = nil
   end
 
   it "should allow to pass custom options (engine, charset, collate) for table creation" do
@@ -707,12 +757,12 @@ describe "A grouped MySQL dataset" do
       text :name
       integer :value
     end
-    DB[:test2] << {:name => '11', :value => 10}
-    DB[:test2] << {:name => '11', :value => 20}
-    DB[:test2] << {:name => '11', :value => 30}
-    DB[:test2] << {:name => '12', :value => 10}
-    DB[:test2] << {:name => '12', :value => 20}
-    DB[:test2] << {:name => '13', :value => 10}
+    DB[:test2].insert(:name => '11', :value => 10)
+    DB[:test2].insert(:name => '11', :value => 20)
+    DB[:test2].insert(:name => '11', :value => 30)
+    DB[:test2].insert(:name => '12', :value => 10)
+    DB[:test2].insert(:name => '12', :value => 20)
+    DB[:test2].insert(:name => '13', :value => 10)
   end
   after do
     DB.drop_table?(:test2)
@@ -1317,6 +1367,10 @@ if DB.adapter_scheme == :mysql2
     it "should correctly handle early returning when streaming results" do
       3.times{@ds.each{|r| break r[:a]}.must_equal 0}
     end
+
+    it "#paged_each should bypass streaming when :stream => false passed in" do
+      DB[:a].order(:a).paged_each(:stream => false){|x| DB[:a].first; break}
+    end
   end
 end
 

data/spec/adapters/oracle_spec.rb

@@ -2,6 +2,10 @@ SEQUEL_ADAPTER_TEST = :oracle
 
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
+unless DB.opts[:autosequence]
+  warn "Running oracle adapter specs without :autosequence Database option results in many errors, use the :autosequence Database option when testing"
+end
+
 describe "An Oracle database" do
   before(:all) do
     DB.create_table!(:items) do
@@ -117,17 +121,17 @@ describe "An Oracle database" do
 
   it "should return the correct record count" do
     @d.count.must_equal 0
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.count.must_equal 3
   end
   
   it "should return the correct records" do
     @d.to_a.must_equal []
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
 
     @d.order(:value).to_a.must_equal [
       {:date_created=>nil, :name => 'abc', :value => 123},
@@ -214,9 +218,9 @@ describe "An Oracle database" do
   end
   
   it "should update records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').update(:value => 530)
     
     @d[:name => 'def'][:value].must_equal 789
@@ -224,17 +228,17 @@ describe "An Oracle database" do
   end
 
   it "should translate values correctly" do
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter{value > 500}.update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
     
     @d[:name => 'def'][:date_created].strftime('%F').must_equal '2009-09-09'
   end
   
   it "should delete records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').delete
     
     @d.count.must_equal 1
@@ -248,7 +252,7 @@ describe "An Oracle database" do
   
   it "should support transactions" do
     DB.transaction do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
     end
 
     @d.count.must_equal 1
@@ -257,15 +261,15 @@ describe "An Oracle database" do
   it "should return correct result" do
     @d1 = DB[:books]
     @d1.delete
-    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
-    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
-    @d1 << {:id => 3, :title => 'ccc', :category_id => 101}
-    @d1 << {:id => 4, :title => 'ddd', :category_id => 102}
+    @d1.insert(:id => 1, :title => 'aaa', :category_id => 100)
+    @d1.insert(:id => 2, :title => 'bbb', :category_id => 100)
+    @d1.insert(:id => 3, :title => 'ccc', :category_id => 101)
+    @d1.insert(:id => 4, :title => 'ddd', :category_id => 102)
     
     @d2 = DB[:categories]
     @d2.delete
-    @d2 << {:id => 100, :cat_name => 'ruby'}
-    @d2 << {:id => 101, :cat_name => 'rails'}
+    @d2.insert(:id => 100, :cat_name => 'ruby')
+    @d2.insert(:id => 101, :cat_name => 'rails')
   
     @d1.join(:categories, :id => :category_id).select(Sequel[:books][:id], :title, :cat_name).order(Sequel[:books][:id]).to_a.must_equal [
       {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
@@ -294,9 +298,9 @@ describe "An Oracle database" do
   it "should allow columns to be renamed" do
     @d1 = DB[:books]
     @d1.delete
-    @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
-    @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
-    @d1 << {:id => 3, :title => 'bbb', :category_id => 100}
+    @d1.insert(:id => 1, :title => 'aaa', :category_id => 100)
+    @d1.insert(:id => 2, :title => 'bbb', :category_id => 100)
+    @d1.insert(:id => 3, :title => 'bbb', :category_id => 100)
 
     @d1.select(Sequel.as(:title, :name)).order_by(:id).to_a.must_equal [
       { :name => 'aaa' },