sequel 4.47.0 → 4.48.0

data/lib/sequel/plugins/static_cache.rb

@@ -26,6 +26,7 @@ module Sequel
     # * Model.each
     # * Model.count (without an argument or block)
     # * Model.map
+    # * Model.as_hash
     # * Model.to_hash
     # * Model.to_hash_groups
     #
@@ -127,41 +128,46 @@ module Sequel
         Plugins.inherited_instance_variables(self, :@static_cache_frozen=>nil)
 
         # Use the cache instead of a query to get the results.
-        def to_hash(key_column = nil, value_column = nil)
-        if key_column.nil? && value_column.nil?
-          if @static_cache_frozen
-            return Hash[cache]
-          else
-            key_column = primary_key
+        def as_hash(key_column = nil, value_column = nil, opts = OPTS)
+          if key_column.nil? && value_column.nil?
+            if @static_cache_frozen && !opts[:hash]
+              return Hash[cache]
+            else
+              key_column = primary_key
+            end
           end
-        end
 
-        h = {}
-        if value_column
-          if value_column.is_a?(Array)
-            if key_column.is_a?(Array)
-              @all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+          h = opts[:hash] || {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+              else
+                @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              end
             else
-              @all.each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+              if key_column.is_a?(Array)
+                @all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+              else
+                @all.each{|r| h[r[key_column]] = r[value_column]}
+              end
             end
+          elsif key_column.is_a?(Array)
+            @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
           else
-            if key_column.is_a?(Array)
-              @all.each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
-            else
-              @all.each{|r| h[r[key_column]] = r[value_column]}
-            end
+            @all.each{|r| h[r[key_column]] = static_cache_object(r)}
           end
-        elsif key_column.is_a?(Array)
-          @all.each{|r| h[r.values.values_at(*key_column)] = static_cache_object(r)}
-        else
-          @all.each{|r| h[r[key_column]] = static_cache_object(r)}
+          h
         end
-        h
+
+        # Alias of as_hash for backwards compatibility.
+        def to_hash(*a)
+          as_hash(*a)
         end
 
         # Use the cache instead of a query to get the results
-        def to_hash_groups(key_column, value_column = nil)
-          h = {}
+        def to_hash_groups(key_column, value_column = nil, opts = OPTS)
+          h = opts[:hash] || {}
           if value_column
             if value_column.is_a?(Array)
               if key_column.is_a?(Array)

data/lib/sequel/plugins/subset_conditions.rb

@@ -13,7 +13,9 @@ module Sequel
     #   Album.plugin :subset_conditions
     #
     #   # This will now create a published_conditions method
-    #   Album.subset :published, :published => true
+    #   Album.dataset_module do
+    #     subset :published, :published => true
+    #   end
     #
     #   Album.where(Album.published_conditions).sql
     #   # SELECT * FROM albums WHERE (published IS TRUE)

data/lib/sequel/plugins/table_select.rb

@@ -32,7 +32,7 @@ module Sequel
         # has no explicit selection, select table.* from that table.
         def convert_input_dataset(ds)
           ds = super
-          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join]
+          if !ds.opts[:select] && (from = ds.opts[:from]) && from.length == 1 && !ds.opts[:join] # SEQUEL5: Only !ds.opts[:select]
             ds = ds.select_all(ds.first_source)
           end
           ds

data/lib/sequel/plugins/touch.rb

@@ -136,10 +136,11 @@ module Sequel
               # Can't update all values at once, so update each instance individually.
               # Instead if doing a simple save, update via the instance's dataset,
               # to avoid going into an infinite loop in some cases.
-              send(r[:name]).each{|x| x.this.update(column=>touch_association_value)}
+              send(assoc).each{|x| x.this.update(column=>touch_association_value)}
             else
               # Update all values at once for performance reasons.
               ds.update(column=>touch_association_value)
+              associations.delete(assoc)
             end
           end
         end

data/lib/sequel/plugins/validation_class_methods.rb

@@ -1,8 +1,6 @@
 # frozen-string-literal: true
 
 module Sequel
-  extension :blank
-
   module Plugins
     # Sequel's built-in validation_class_methods plugin adds backwards compatibility
     # for the legacy class-level validation methods (e.g. validates_presence_of :column).
@@ -11,7 +9,7 @@ module Sequel
     # as it is less complex and more flexible.  However, this plugin provides reflection
     # support, since it is class-level, while the instance-level validation_helpers
     # plugin does not.
-    # 
+    #
     # Usage:
     #
     #   # Add the validation class methods to all model subclasses (called before loading subclasses)
@@ -118,7 +116,7 @@ module Sequel
           validations.each do |att, procs|
             v = case att
             when Array
-              att.collect{|a| o.get_column_value(a)}
+              att.map{|a| o.get_column_value(a)}
             else
               o.get_column_value(att)
             end
@@ -194,11 +192,12 @@ module Sequel
         # :tag :: The tag to use for this validation.
         def validates_each(*atts, &block)
           opts = extract_options!(atts)
+          blank_meth = db.method(:blank_object?).to_proc
           blk = if (i = opts[:if]) || (am = opts[:allow_missing]) || (an = opts[:allow_nil]) || (ab = opts[:allow_blank])
             proc do |o,a,v|
               next if i && !validation_if_proc(o, i)
               next if an && Array(v).all?(&:nil?)
-              next if ab && Array(v).all?(&:blank?)
+              next if ab && Array(v).all?(&blank_meth)
               next if am && Array(a).all?{|x| !o.values.has_key?(x)}
               block.call(o,a,v)
             end
@@ -317,7 +316,7 @@ module Sequel
           reflect_validation(:presence, opts, atts)
           atts << opts
           validates_each(*atts) do |o, a, v|
-            o.errors.add(a, opts[:message]) if v.blank? && v != false
+            o.errors.add(a, opts[:message]) if db.send(:blank_object?, v) && v != false
           end
         end
         

data/lib/sequel/plugins/validation_helpers.rb

@@ -19,9 +19,7 @@ module Sequel
     # atts :: Single attribute symbol or an array of attribute symbols specifying the
     #         attribute(s) to validate.
     # Options:
-    # :allow_blank :: Whether to skip the validation if the value is blank.  You should
-    #                 make sure all objects respond to blank if you use this option, which you can do by:
-    #                     Sequel.extension :blank
+    # :allow_blank :: Whether to skip the validation if the value is blank.
     # :allow_missing :: Whether to skip the validation if the attribute isn't a key in the
     #                   values hash.  This is different from allow_nil, because Sequel only sends the attributes
     #                   in the values when doing an insert or update.  If the attribute is not present, Sequel
@@ -284,7 +282,7 @@ module Sequel
             next if am && !values.has_key?(a)
             v = from_values ? values[a] : get_column_value(a)
             next if an && v.nil?
-            next if ab && v.respond_to?(:blank?) && v.blank?
+            next if ab && model.db.send(:blank_object?, v)
             if message = yield(a, v, m)
               errors.add(a, message)
             end

data/lib/sequel/plugins/xml_serializer.rb

@@ -158,7 +158,7 @@ module Sequel
             opts[:builder]
           else
             builder_opts = if opts[:builder_opts]
-              opts[:builder_opts]
+              Hash[opts[:builder_opts]]
             else
               {}
             end
@@ -234,10 +234,10 @@ module Sequel
           if assocs = opts[:associations]
             assocs = case assocs
             when Symbol
-              {assocs=>{}}
+              {assocs=>OPTS}
             when Array
               assocs_tmp = {}
-              assocs.each{|v| assocs_tmp[v] = {}}
+              assocs.each{|v| assocs_tmp[v] = OPTS}
               assocs_tmp
             when Hash
               assocs
@@ -347,7 +347,7 @@ module Sequel
             cols.each do |c|
               attrs = {}
               if types
-                attrs[:type] = db_schema.fetch(c, {})[:type]
+                attrs[:type] = db_schema.fetch(c, OPTS)[:type]
               end
               v = vals[c]
               if v.nil?

data/lib/sequel/sql.rb

@@ -1150,7 +1150,7 @@ module Sequel
         when BooleanExpression
           case op = ce.op
           when :AND, :OR
-            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.collect{|a| BooleanExpression.invert(a)})
+            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
           else
             BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
           end
@@ -1764,7 +1764,7 @@ module Sequel
       def self.like(l, *ces)
         l, lre, lci = like_element(l)
         lci = (ces.last.is_a?(Hash) ? ces.pop : {})[:case_insensitive] ? true : lci
-        ces.collect! do |ce|
+        ces.map! do |ce|
           r, rre, rci = like_element(ce)
           BooleanExpression.new(LIKE_MAP[[lre||rre, lci||rci]], l, r)
         end

data/lib/sequel/version.rb

@@ -5,7 +5,7 @@ module Sequel
   MAJOR = 4
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 47
+  MINOR = 48
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 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/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,7 +312,7 @@ 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
@@ -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)