sequel 2.2.0 → 2.3.0

data/lib/sequel_model.rb

@@ -54,7 +54,7 @@ module Sequel
   #   sti_dataset, and sti_key.  You should not usually need to
   #   access these directly.
   # * The following class level attr_accessors are created: raise_on_save_failure,
-  #   strict_param_setting, and typecast_on_assignment:
+  #   strict_param_setting, typecast_empty_string_to_nil, and typecast_on_assignment:
   #
   #     # Don't raise an error if a validation attempt fails in
   #     # save/create/save_changes/etc.
@@ -71,6 +71,10 @@ module Sequel
   #     m = Model.new
   #     m.number = '10'
   #     m.number # => '10' instead of 10
+  #     # Don't typecast empty string to nil for non-string, non-blob columns.
+  #     Model.typecast_empty_string_to_nil = false
+  #     m.number = ''
+  #     m.number # => '' instead of nil
   #
   # * The following class level method aliases are defined:
   #   * Model.dataset= => set_dataset

data/lib/sequel_model/association_reflection.rb

@@ -70,14 +70,14 @@ module Sequel
 
         # Name symbol for default join table
         def default_join_table
-          ([self[:class_name].demodulize, self[:model].name.demodulize]. \
+          ([self[:class_name].demodulize, self[:model].name.to_s.demodulize]. \
             map{|i| i.pluralize.underscore}.sort.join('_')).to_sym
         end
       
         # Default foreign key name symbol for key in associated table that points to
         # current table's primary key.
         def default_left_key
-          :"#{self[:model].name.demodulize.underscore}_id"
+          :"#{self[:model].name.to_s.demodulize.underscore}_id"
         end
 
         # Default foreign key name symbol for foreign key in current model's table that points to
@@ -86,14 +86,9 @@ module Sequel
           :"#{self[:type] == :many_to_one ? self[:name] : self[:name].to_s.singularize}_id"
         end
       
-        # Name symbol for _dataset association method
-        def eager_dataset_method
-          :"#{self[:name]}_eager_dataset"
-        end
-      
         # Whether to eagerly graph a lazy dataset
         def eager_graph_lazy_dataset?
-          self[:type] != :many_to_one or opts[:key]
+          self[:type] != :many_to_one or self[:key].nil?
         end
 
         # Whether the associated object needs a primary key to be added/removed

data/lib/sequel_model/base.rb

@@ -14,6 +14,7 @@ module Sequel
     @sti_dataset = nil
     @sti_key = nil
     @strict_param_setting = true
+    @typecast_empty_string_to_nil = true
     @typecast_on_assignment = true
 
     # Which columns should be the only columns allowed in a call to set
@@ -47,12 +48,16 @@ module Sequel
     # access is restricted to it).
     metaattr_accessor :strict_param_setting
 
+    # Whether to typecast the empty string ('') to nil for columns that
+    # are not string or blob.
+    metaattr_accessor :typecast_empty_string_to_nil
+
     # Whether to typecast attribute values on assignment (default: true)
     metaattr_accessor :typecast_on_assignment
 
     # Dataset methods to proxy via metaprogramming
     DATASET_METHODS = %w'<< all avg count delete distinct eager eager_graph each each_page 
-       empty? except exclude filter first from_self full_outer_join get graph 
+       empty? except exclude filter first from from_self full_outer_join get graph 
        group group_and_count group_by having import inner_join insert 
        insert_multiple intersect interval invert_order join join_table last 
        left_outer_join limit map multi_insert naked order order_by order_more 
@@ -65,7 +70,7 @@ module Sequel
       :@cache_ttl=>nil, :@dataset_methods=>:dup, :@primary_key=>nil, 
       :@raise_on_save_failure=>nil, :@restricted_columns=>:dup, :@restrict_primary_key=>nil,
       :@sti_dataset=>nil, :@sti_key=>nil, :@strict_param_setting=>nil,
-      :@typecast_on_assignment=>nil}
+      :@typecast_empty_string_to_nil=>nil, :@typecast_on_assignment=>nil}
 
     # Returns the first record from the database matching the conditions.
     # If a hash is given, it is used as the conditions.  If another
@@ -190,7 +195,7 @@ module Sequel
     # from the parent class.
     def self.inherited(subclass)
       sup_class = subclass.superclass
-      ivs = subclass.instance_variables
+      ivs = subclass.instance_variables.collect{|x| x.to_s}
       INHERITED_INSTANCE_VARIABLES.each do |iv, dup|
         next if ivs.include?(iv.to_s)
         sup_class_value = sup_class.instance_variable_get(iv)
@@ -200,11 +205,12 @@ module Sequel
       unless ivs.include?("@dataset")
         begin
           if sup_class == Model
-            subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.empty?
+            subclass.set_dataset(Model.db[subclass.implicit_table_name]) unless subclass.name.blank?
           elsif ds = sup_class.instance_variable_get(:@dataset)
-            subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name) : ds.clone)
+            subclass.set_dataset(sup_class.sti_key ? sup_class.sti_dataset.filter(sup_class.sti_key=>subclass.name.to_s) : ds.clone)
           end
         rescue
+          nil
         end
       end
     end
@@ -318,9 +324,8 @@ module Sequel
       @dataset.extend(Associations::EagerLoading)
       @dataset.transform(@transform) if @transform
       @dataset_methods.each{|meth, block| @dataset.meta_def(meth, &block)} if @dataset_methods
-      begin
-        (@db_schema = get_db_schema) unless @@lazy_load_schema
-      rescue
+      unless @@lazy_load_schema
+        (@db_schema = get_db_schema) rescue nil
       end
       self
     end
@@ -375,7 +380,7 @@ module Sequel
       @sti_key = key
       @sti_dataset = dataset
       dataset.set_model(key, Hash.new{|h,k| h[k] = (k.constantize rescue m)})
-      before_create(:set_sti_key){send("#{key}=", model.name)}
+      before_create(:set_sti_key){send("#{key}=", model.name.to_s)}
     end
 
     # Returns the columns as a list of frozen strings instead
@@ -422,7 +427,7 @@ module Sequel
     # Create the column accessors
     def self.def_column_accessor(*columns) # :nodoc:
       columns.each do |column|
-        im = instance_methods
+        im = instance_methods.collect{|x| x.to_s}
         meth = "#{column}="
          define_method(column){self[column]} unless im.include?(column.to_s)
         unless im.include?(meth)

data/lib/sequel_model/inflector.rb

@@ -148,11 +148,9 @@ class String
   #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
   #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
   def camelize(first_letter_in_uppercase = :upper)
-    if first_letter_in_uppercase == :upper
-      gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
-    else
-      "#{first}#{camelize[1..-1]}"
-    end
+    s = gsub(/\/(.?)/){|x| "::#{x[-1..-1].upcase unless x == '/'}"}.gsub(/(^|_)(.)/){|x| x[-1..-1].upcase}
+    s[0...1] = s[0...1].downcase unless first_letter_in_uppercase == :upper
+    s
   end
   alias_method :camelcase, :camelize
 

data/lib/sequel_model/plugins.rb

@@ -34,7 +34,7 @@ module Sequel
       end
       if m.const_defined?("DatasetMethods")
         dataset.meta_def(:"#{plugin}_opts") {args.first}
-        dataset.metaclass.send(:include, m::DatasetMethods)
+        dataset.extend(m::DatasetMethods)
         def_dataset_method(*m::DatasetMethods.instance_methods)
       end
     end

data/lib/sequel_model/record.rb

@@ -2,7 +2,7 @@ module Sequel
   class Model
     # The setter methods (methods ending with =) that are never allowed
     # to be called automatically via set.
-    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_on_assignment= strict_param_setting= raise_on_save_failure="
+    RESTRICTED_SETTER_METHODS = %w"== === []= taguri= typecast_empty_string_to_nil= typecast_on_assignment= strict_param_setting= raise_on_save_failure="
 
     # The current cached associations.  A hash with the keys being the
     # association name symbols and the values being the associated object
@@ -22,6 +22,10 @@ module Sequel
     # doesn't exist or access to it is denied.
     attr_writer :strict_param_setting
 
+    # Whether this model instance should typecast the empty string ('') to
+    # nil for columns that are non string or blob.
+    attr_writer :typecast_empty_string_to_nil
+
     # Whether this model instance should typecast on attribute assignment
     attr_writer :typecast_on_assignment
 
@@ -49,6 +53,7 @@ module Sequel
       @raise_on_save_failure = model.raise_on_save_failure
       @strict_param_setting = model.strict_param_setting
       @typecast_on_assignment = model.typecast_on_assignment
+      @typecast_empty_string_to_nil = model.typecast_empty_string_to_nil
       if from_db
         @new = false
         @values = values
@@ -247,7 +252,8 @@ module Sequel
     end
 
     # Updates the instance with the supplied values with support for virtual
-    # attributes, ignoring any values for which no setter method is available.
+    # attributes, raising an exception if a value is used that doesn't have
+    # a setter method (or ignoring it if strict_param_setting = false).
     # Does not save the record.
     #
     # If no columns have been set for this model (very unlikely), assume symbol
@@ -479,6 +485,7 @@ module Sequel
           raise Error, "method #{m} doesn't exist or access is restricted to it"
         end
       end
+      self
     end
 
     # Returns all methods that can be used for attribute
@@ -503,7 +510,7 @@ module Sequel
       if only
         only.map{|x| "#{x}="}
       else
-        meths = methods.grep(/=\z/) - RESTRICTED_SETTER_METHODS
+        meths = methods.collect{|x| x.to_s}.grep(/=\z/) - RESTRICTED_SETTER_METHODS
         meths -= Array(primary_key).map{|x| "#{x}="} if primary_key && model.restrict_primary_key?
         meths -= except.map{|x| "#{x}="} if except
         meths
@@ -515,6 +522,7 @@ module Sequel
     # for database specific column types.
     def typecast_value(column, value)
       return value unless @typecast_on_assignment && @db_schema && (col_schema = @db_schema[column])
+      value = nil if value == '' and @typecast_empty_string_to_nil and col_schema[:type] and ![:string, :blob].include?(col_schema[:type])
       raise(Error, "nil/NULL is not allowed for the #{column} column") if value.nil? && (col_schema[:allow_null] == false)
       model.db.typecast_value(col_schema[:type], value)
     end

data/lib/sequel_model/schema.rb

@@ -2,27 +2,27 @@ module Sequel
   class Model
     # Creates table.
     def self.create_table
-      db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
+      db.create_table(table_name, @schema)
       @db_schema = get_db_schema(true) unless @@lazy_load_schema
       columns
     end
     
     # Drops the table if it exists and then runs create_table.
     def self.create_table!
-      drop_table if table_exists?
+      drop_table rescue nil
       create_table
     end
     
     # Drops table.
     def self.drop_table
-      db.execute db.drop_table_sql(table_name)
+      db.drop_table(table_name)
     end
 
     # Returns table schema created with set_schema for direct descendant of Model.
     # Does not retreive schema information from the database, see db_schema if you
     # want that.
     def self.schema
-      @schema || ((superclass != Model) && (superclass.schema))
+      @schema || (superclass.schema unless superclass == Model)
     end
 
     # Defines a table schema (see Schema::Generator for more information).

data/lib/sequel_model/validations.rb

@@ -223,7 +223,12 @@ module Sequel
         :wrong_length => 'is the wrong length'
       }.merge!(atts.extract_options!)
       
-      atts << {:if=>opts[:if], :tag=>opts[:tag]||:length}
+      tag = if opts[:tag]
+        opts[:tag]
+      else
+       ([:length] + [:maximum, :minimum, :is, :within].reject{|x| !opts.include?(x)}).join('-').to_sym
+      end
+      atts << {:if=>opts[:if], :tag=>tag}
       validates_each(*atts) do |o, a, v|
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         if m = opts[:maximum]

data/spec/adapters/ado_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+unless defined?(ADO_DB)
+  ADO_DB = Sequel.connect(:adapter => 'ado', :driver => "{Microsoft Access Driver (*.mdb)}; DBQ=c:\\Nwind.mdb")
+end
+
+context "An ADO dataset" do
+  setup do
+    ADO_DB.create_table!(:items) { text :name }
+  end
+
+  specify "should not raise exceptions when working with empty datasets" do
+    lambda {
+      ADO_DB[:items].all
+    }.should_not raise_error
+  end
+end

data/spec/adapters/informix_spec.rb

@@ -0,0 +1,96 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+unless defined?(INFORMIX_DB)
+  INFORMIX_DB = Sequel.connect('informix://localhost/mydb')
+end
+
+if INFORMIX_DB.table_exists?(:test)
+  INFORMIX_DB.drop_table :test
+end
+INFORMIX_DB.create_table :test do
+  text :name
+  integer :value
+  
+  index :value
+end
+
+context "A Informix database" do
+  specify "should provide disconnect functionality" do
+    INFORMIX_DB.execute("select user from dual")
+    INFORMIX_DB.pool.size.should == 1
+    INFORMIX_DB.disconnect
+    INFORMIX_DB.pool.size.should == 0
+  end
+end
+
+context "A Informix dataset" do
+  setup do
+    @d = INFORMIX_DB[:test]
+    @d.delete # remove all records
+  end
+  
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+  end
+  
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').update(:value => 530)
+    
+    # the third record should stay the same
+    # floating-point precision bullshit
+    @d[:name => 'def'][:value].should == 789
+    @d.filter(:value => 530).count.should == 2
+  end
+  
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').delete
+    
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+  
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  end
+  
+  specify "should support transactions" do
+    INFORMIX_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+  
+  specify "should support #first and #last" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    
+    @d.order(:value).first.should == {:name => 'abc', :value => 123}
+    @d.order(:value).last.should == {:name => 'def', :value => 789}
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -0,0 +1,764 @@
+require File.join(File.dirname(__FILE__), 'spec_helper.rb')
+
+unless defined?(MYSQL_USER)
+  MYSQL_USER = 'root'
+end
+unless defined?(MYSQL_DB)
+  MYSQL_URL = (ENV['SEQUEL_MY_SPEC_DB']||"mysql://#{MYSQL_USER}@localhost/sandbox") unless defined? MYSQL_URL
+  MYSQL_DB = Sequel.connect(MYSQL_URL)
+end
+unless defined?(MYSQL_SOCKET_FILE)
+  MYSQL_SOCKET_FILE = '/tmp/mysql.sock'
+end
+
+MYSQL_URI = URI.parse(MYSQL_DB.uri)
+MYSQL_DB_NAME = (m = /\/(.*)/.match(MYSQL_URI.path)) && m[1]
+
+MYSQL_DB.create_table! :items do
+  text :name
+  integer :value, :index => true
+end
+MYSQL_DB.create_table! :test2 do
+  text :name
+  integer :value
+end
+MYSQL_DB.create_table! :booltest do
+  tinyint :value
+end
+def MYSQL_DB.sqls
+  (@sqls ||= [])
+end
+logger = Object.new
+def logger.method_missing(m, msg)
+  MYSQL_DB.sqls << msg
+end
+MYSQL_DB.logger = logger
+
+context "A MySQL database" do
+  setup do
+    @db = MYSQL_DB
+  end
+  teardown do
+    Sequel.convert_tinyint_to_bool = true
+  end
+  
+  specify "should provide disconnect functionality" do
+    @db.tables
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+
+  specify "should provide the server version" do
+    @db.server_version.should >= 40000
+  end
+
+  specify "should support sequential primary keys" do
+    @db.create_table!(:with_pk) {primary_key :id; text :name}
+    @db[:with_pk] << {:name => 'abc'}
+    @db[:with_pk] << {:name => 'def'}
+    @db[:with_pk] << {:name => 'ghi'}
+    @db[:with_pk].order(:name).all.should == [
+      {:id => 1, :name => 'abc'},
+      {:id => 2, :name => 'def'},
+      {:id => 3, :name => 'ghi'}
+    ]
+  end
+
+  specify "should convert Mysql::Errors to Sequel::Errors" do
+   proc{@db << "SELECT 1 + blah;"}.should raise_error(Sequel::Error)
+  end
+
+  specify "should correctly parse the schema" do
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:boolean, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
+    
+    Sequel.convert_tinyint_to_bool = false
+    @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :max_chars=>nil, :default=>nil, :db_type=>"tinyint", :numeric_precision=>3}]]
+  end
+
+  specify "should get the schema all database tables if no table name is used" do
+    @db.schema(:booltest, :reload=>true).should == @db.schema(nil, :reload=>true)[:booltest]
+  end
+end
+
+context "A MySQL dataset" do
+  setup do
+    @d = MYSQL_DB[:items]
+    @d.delete # remove all records
+    MYSQL_DB.sqls.clear
+  end
+  
+  specify "should return the correct record count" do
+    @d.count.should == 0
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.count.should == 3
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).to_a.should == [
+      {:name => 'abc', :value => 123},
+      {:name => 'abc', :value => 456},
+      {:name => 'def', :value => 789}
+    ]
+  end
+  
+  specify "should update records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').update(:value => 530)
+    
+    # the third record should stay the same
+    # floating-point precision bullshit
+    @d[:name => 'def'][:value].should == 789
+    @d.filter(:value => 530).count.should == 2
+  end
+  
+  specify "should delete records correctly" do
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+    @d.filter(:name => 'abc').delete
+    
+    @d.count.should == 1
+    @d.first[:name].should == 'def'
+  end
+  
+  specify "should be able to literalize booleans" do
+    proc {@d.literal(true)}.should_not raise_error
+    proc {@d.literal(false)}.should_not raise_error
+  end
+  
+  specify "should quote columns and tables using back-ticks if quoting identifiers" do
+    @d.quote_identifiers = true
+    @d.select(:name).sql.should == \
+      'SELECT `name` FROM `items`'
+      
+    @d.select('COUNT(*)'.lit).sql.should == \
+      'SELECT COUNT(*) FROM `items`'
+
+    @d.select(:max[:value]).sql.should == \
+      'SELECT max(`value`) FROM `items`'
+      
+    @d.select(:NOW[]).sql.should == \
+    'SELECT NOW() FROM `items`'
+
+    @d.select(:max[:items__value]).sql.should == \
+      'SELECT max(`items`.`value`) FROM `items`'
+
+    @d.order(:name.desc).sql.should == \
+      'SELECT * FROM `items` ORDER BY `name` DESC'
+
+    @d.select('items.name AS item_name'.lit).sql.should == \
+      'SELECT items.name AS item_name FROM `items`'
+      
+    @d.select('`name`'.lit).sql.should == \
+      'SELECT `name` FROM `items`'
+
+    @d.select('max(items.`name`) AS `max_name`'.lit).sql.should == \
+      'SELECT max(items.`name`) AS `max_name` FROM `items`'
+      
+    @d.select(:test[:abc, 'hello']).sql.should == \
+      "SELECT test(`abc`, 'hello') FROM `items`"
+
+    @d.select(:test[:abc__def, 'hello']).sql.should == \
+      "SELECT test(`abc`.`def`, 'hello') FROM `items`"
+
+    @d.select(:test[:abc__def, 'hello'].as(:x2)).sql.should == \
+      "SELECT test(`abc`.`def`, 'hello') AS `x2` FROM `items`"
+
+    @d.insert_sql(:value => 333).should == \
+      'INSERT INTO `items` (`value`) VALUES (333)'
+
+    @d.insert_sql(:x => :y).should == \
+      'INSERT INTO `items` (`x`) VALUES (`y`)'
+  end
+  
+  specify "should quote fields correctly when reversing the order" do
+    @d.quote_identifiers = true
+    @d.reverse_order(:name).sql.should == \
+      'SELECT * FROM `items` ORDER BY `name` DESC'
+
+    @d.reverse_order(:name.desc).sql.should == \
+      'SELECT * FROM `items` ORDER BY `name` ASC'
+
+    @d.reverse_order(:name, :test.desc).sql.should == \
+      'SELECT * FROM `items` ORDER BY `name` DESC, `test` ASC'
+
+    @d.reverse_order(:name.desc, :test).sql.should == \
+      'SELECT * FROM `items` ORDER BY `name` ASC, `test` DESC'
+  end
+  
+  specify "should support ORDER clause in UPDATE statements" do
+    @d.order(:name).update_sql(:value => 1).should == \
+      'UPDATE items SET value = 1 ORDER BY name'
+  end
+  
+  specify "should support LIMIT clause in UPDATE statements" do
+    @d.limit(10).update_sql(:value => 1).should == \
+      'UPDATE items SET value = 1 LIMIT 10'
+  end
+  
+  specify "should support transactions" do
+    MYSQL_DB.transaction do
+      @d << {:name => 'abc', :value => 1}
+    end
+
+    @d.count.should == 1
+  end
+  
+  specify "should correctly rollback transactions" do
+    proc do
+      MYSQL_DB.transaction do
+        @d << {:name => 'abc'}
+        raise Interrupt, 'asdf'
+      end
+    end.should raise_error(Interrupt)
+
+    MYSQL_DB.sqls.should == ['BEGIN', "INSERT INTO items (name) VALUES ('abc')", 'ROLLBACK']
+  end
+
+  specify "should handle returning inside of the block by committing" do
+    def MYSQL_DB.ret_commit
+      transaction do
+        self[:items] << {:name => 'abc'}
+        return
+        self[:items] << {:name => 'd'}
+      end
+    end
+    MYSQL_DB.ret_commit
+    MYSQL_DB.sqls.should == ['BEGIN', "INSERT INTO items (name) VALUES ('abc')", 'COMMIT']
+  end
+  
+  specify "should support regexps" do
+    @d << {:name => 'abc', :value => 1}
+    @d << {:name => 'bcd', :value => 2}
+    @d.filter(:name => /bc/).count.should == 2
+    @d.filter(:name => /^bc/).count.should == 1
+  end
+  
+  specify "should correctly literalize strings with comment backslashes in them" do
+    @d.delete
+    proc {@d << {:name => ':\\'}}.should_not raise_error
+    
+    @d.first[:name].should == ':\\'
+  end
+end
+
+context "MySQL datasets" do
+  setup do
+    @d = MYSQL_DB[:orders]
+  end
+  teardown do
+    Sequel.convert_tinyint_to_bool = true
+  end
+  
+  specify "should correctly quote column references" do
+    @d.quote_identifiers = true
+    market = 'ICE'
+    ack_stamp = Time.now - 15 * 60 # 15 minutes ago
+    @d.query do
+      select :market, :minute[:from_unixtime[:ack]].as(:minute)
+      where {(:ack > ack_stamp) & {:market => market}}
+      group_by :minute[:from_unixtime[:ack]]
+    end.sql.should == \
+      "SELECT `market`, minute(from_unixtime(`ack`)) AS `minute` FROM `orders` WHERE ((`ack` > #{@d.literal(ack_stamp)}) AND (`market` = 'ICE')) GROUP BY minute(from_unixtime(`ack`))"
+  end
+
+  specify "should accept and return tinyints as bools or integers when configured to do so" do
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>true}
+    MYSQL_DB[:booltest].all.should == [{:value=>true}]
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>false}
+    MYSQL_DB[:booltest].all.should == [{:value=>false}]
+    
+    Sequel.convert_tinyint_to_bool = false
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>true}
+    MYSQL_DB[:booltest].all.should == [{:value=>1}]
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>false}
+    MYSQL_DB[:booltest].all.should == [{:value=>0}]
+    
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>1}
+    MYSQL_DB[:booltest].all.should == [{:value=>1}]
+    MYSQL_DB[:booltest].delete
+    MYSQL_DB[:booltest] << {:value=>0}
+    MYSQL_DB[:booltest].all.should == [{:value=>0}]
+  end
+end
+
+# # Commented out because it was causing subsequent examples to fail for some reason
+# context "Simple stored procedure test" do
+#   setup do
+#     # Create a simple stored procedure but drop it first if there
+#     MYSQL_DB.execute("DROP PROCEDURE IF EXISTS sp_get_server_id;")
+#     MYSQL_DB.execute("CREATE PROCEDURE sp_get_server_id() SQL SECURITY DEFINER SELECT @@SERVER_ID as server_id;")
+#   end
+# 
+#   specify "should return the server-id via a stored procedure call" do
+#     @server_id = MYSQL_DB["SELECT @@SERVER_ID as server_id;"].first[:server_id] # grab the server_id via a simple query
+#     @server_id_by_sp = MYSQL_DB["CALL sp_get_server_id();"].first[:server_id]
+#     @server_id_by_sp.should == @server_id  # compare it to output from stored procedure
+#   end
+# end
+# 
+context "MySQL join expressions" do
+  setup do
+    @ds = MYSQL_DB[:nodes]
+    @ds.db.meta_def(:server_version) {50014}
+  end
+
+  specify "should raise error for :full_outer join requests." do
+    lambda{@ds.join_table(:full_outer, :nodes)}.should raise_error(Sequel::Error::InvalidJoinType)
+  end
+  specify "should support natural left joins" do
+    @ds.join_table(:natural_left, :nodes).sql.should == \
+      'SELECT * FROM nodes NATURAL LEFT JOIN nodes'
+  end
+  specify "should support natural right joins" do
+    @ds.join_table(:natural_right, :nodes).sql.should == \
+      'SELECT * FROM nodes NATURAL RIGHT JOIN nodes'
+  end
+  specify "should support natural left outer joins" do
+    @ds.join_table(:natural_left_outer, :nodes).sql.should == \
+      'SELECT * FROM nodes NATURAL LEFT OUTER JOIN nodes'
+  end
+  specify "should support natural right outer joins" do
+    @ds.join_table(:natural_right_outer, :nodes).sql.should == \
+      'SELECT * FROM nodes NATURAL RIGHT OUTER JOIN nodes'
+  end
+  specify "should support natural inner joins" do
+    @ds.join_table(:natural_inner, :nodes).sql.should == \
+      'SELECT * FROM nodes NATURAL LEFT JOIN nodes'
+  end
+  specify "should support cross joins" do
+    @ds.join_table(:cross, :nodes).sql.should == \
+      'SELECT * FROM nodes CROSS JOIN nodes'
+  end
+  specify "should support cross joins as inner joins if conditions are used" do
+    @ds.join_table(:cross, :nodes, :id=>:id).sql.should == \
+      'SELECT * FROM nodes INNER JOIN nodes ON (nodes.id = nodes.id)'
+  end
+  specify "should support straight joins (force left table to be read before right)" do
+    @ds.join_table(:straight, :nodes).sql.should == \
+      'SELECT * FROM nodes STRAIGHT_JOIN nodes'
+  end
+  specify "should support natural joins on multiple tables." do
+    @ds.join_table(:natural_left_outer, [:nodes, :branches]).sql.should == \
+      'SELECT * FROM nodes NATURAL LEFT OUTER JOIN (nodes, branches)'
+  end
+  specify "should support straight joins on multiple tables." do
+    @ds.join_table(:straight, [:nodes,:branches]).sql.should == \
+      'SELECT * FROM nodes STRAIGHT_JOIN (nodes, branches)'
+  end
+end
+
+context "Joined MySQL dataset" do
+  setup do
+    @ds = MYSQL_DB[:nodes]
+  end
+  
+  specify "should quote fields correctly" do
+    @ds.quote_identifiers = true
+    @ds.join(:attributes, :node_id => :id).sql.should == \
+      "SELECT * FROM `nodes` INNER JOIN `attributes` ON (`attributes`.`node_id` = `nodes`.`id`)"
+  end
+  
+  specify "should allow a having clause on ungrouped datasets" do
+    proc {@ds.having('blah')}.should_not raise_error
+
+    @ds.having('blah').sql.should == \
+      "SELECT * FROM nodes HAVING (blah)"
+  end
+  
+  specify "should put a having clause before an order by clause" do
+    @ds.order(:aaa).having(:bbb => :ccc).sql.should == \
+      "SELECT * FROM nodes HAVING (bbb = ccc) ORDER BY aaa"
+  end
+end
+
+context "A MySQL database" do
+  setup do
+    @db = MYSQL_DB
+  end
+
+  specify "should support add_column operations" do
+    @db.add_column :test2, :xyz, :text
+    
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => '000'}
+    @db[:test2].first[:xyz].should == '000'
+  end
+  
+  specify "should support drop_column operations" do
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    @db.drop_column :test2, :xyz
+    
+    @db[:test2].columns.should == [:name, :value]
+  end
+  
+  specify "should support rename_column operations" do
+    @db[:test2].delete
+    @db.add_column :test2, :xyz, :text
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    @db.rename_column :test2, :xyz, :zyx, :type => :text
+    @db[:test2].columns.should == [:name, :value, :zyx]
+    @db[:test2].first[:zyx].should == 'qqqq'
+  end
+  
+  specify "should support rename_column operations with types like varchar(255)" do
+    @db[:test2].delete
+    @db.add_column :test2, :tre, :text
+    @db[:test2] << {:name => 'mmm', :value => 111, :tre => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :value, :zyx, :tre]
+    @db.rename_column :test2, :tre, :ert, :type => :varchar[255]
+    @db[:test2].columns.should == [:name, :value, :zyx, :ert]
+    @db[:test2].first[:ert].should == 'qqqq'
+  end
+  
+  specify "should support set_column_type operations" do
+    @db.add_column :test2, :xyz, :float
+    @db[:test2].delete
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
+    @db.set_column_type :test2, :xyz, :integer
+    
+    @db[:test2].first[:xyz].should == 57
+  end
+  
+  specify "should support add_index" do
+    @db.add_index :test2, :value
+  end
+  
+  specify "should support drop_index" do
+    @db.drop_index :test2, :value
+  end
+end  
+
+context "A MySQL database" do
+  setup do
+    @db = MYSQL_DB
+  end
+  
+  specify "should support defaults for boolean columns" do
+    g = Sequel::Schema::Generator.new(@db) do
+      boolean :active1, :default => true
+      boolean :active2, :default => false
+    end
+    statements = @db.create_table_sql_list(:items, *g.create_info)
+    statements.should == [
+      "CREATE TABLE items (active1 boolean DEFAULT 1, active2 boolean DEFAULT 0)"
+    ]
+  end
+  
+  specify "should correctly format CREATE TABLE statements with foreign keys" do
+    g = Sequel::Schema::Generator.new(@db) do
+      foreign_key :p_id, :table => :users, :key => :id, 
+        :null => false, :on_delete => :cascade
+    end
+    @db.create_table_sql_list(:items, *g.create_info).should == [
+      "CREATE TABLE items (p_id integer NOT NULL, FOREIGN KEY (p_id) REFERENCES users(id) ON DELETE CASCADE)"
+    ]
+  end
+  
+  specify "should accept repeated raw sql statements using Database#<<" do
+    @db << 'DELETE FROM items'
+    @db[:items].count.should == 0
+    
+    @db << "INSERT INTO items (name, value) VALUES ('tutu', 1234)"
+    @db[:items].first.should == {:name => 'tutu', :value => 1234}
+    
+    @db << 'DELETE FROM items'
+    @db[:items].first.should == nil
+  end
+end  
+
+# Socket tests should only be run if the MySQL server is on localhost
+if %w'localhost 127.0.0.1 ::1'.include? MYSQL_URI.host
+  context "A MySQL database" do
+    specify "should accept a socket option" do
+      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
+      proc {db.test_connection}.should_not raise_error
+    end
+    
+    specify "should accept a socket option without host option" do
+      db = Sequel.mysql(MYSQL_DB_NAME, :user => MYSQL_USER, :socket => MYSQL_SOCKET_FILE)
+      proc {db.test_connection}.should_not raise_error
+    end
+    
+    specify "should fail to connect with invalid socket" do
+      db = Sequel.mysql(MYSQL_DB_NAME, :host => 'localhost', :user => MYSQL_USER, :socket => 'blah')
+      proc {db.test_connection}.should raise_error
+    end
+  end
+end
+
+context "A grouped MySQL dataset" do
+  setup do
+    MYSQL_DB[:test2].delete
+    MYSQL_DB[:test2] << {:name => '11', :value => 10}
+    MYSQL_DB[:test2] << {:name => '11', :value => 20}
+    MYSQL_DB[:test2] << {:name => '11', :value => 30}
+    MYSQL_DB[:test2] << {:name => '12', :value => 10}
+    MYSQL_DB[:test2] << {:name => '12', :value => 20}
+    MYSQL_DB[:test2] << {:name => '13', :value => 10}
+  end
+  
+  specify "should return the correct count for raw sql query" do
+    ds = MYSQL_DB["select name FROM test2 WHERE name = '11' GROUP BY name"]
+    ds.count.should == 1
+  end
+  
+  specify "should return the correct count for a normal dataset" do
+    ds = MYSQL_DB[:test2].select(:name).where(:name => '11').group(:name)
+    ds.count.should == 1
+  end
+end
+
+context "A MySQL database" do
+  setup do
+  end
+  
+  specify "should support fulltext indexes" do
+    g = Sequel::Schema::Generator.new(MYSQL_DB) do
+      text :title
+      text :body
+      full_text_index [:title, :body]
+    end
+    MYSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (title text, body text)",
+      "CREATE FULLTEXT INDEX posts_title_body_index ON posts (title, body)"
+    ]
+  end
+  
+  specify "should support full_text_search" do
+    MYSQL_DB[:posts].full_text_search(:title, 'ruby').sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (title) AGAINST ('ruby'))"
+    
+    MYSQL_DB[:posts].full_text_search([:title, :body], ['ruby', 'sequel']).sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (title, body) AGAINST ('ruby', 'sequel'))"
+      
+    MYSQL_DB[:posts].full_text_search(:title, '+ruby -rails', :boolean => true).sql.should ==
+      "SELECT * FROM posts WHERE (MATCH (title) AGAINST ('+ruby -rails' IN BOOLEAN MODE))"
+  end
+
+  specify "should support spatial indexes" do
+    g = Sequel::Schema::Generator.new(MYSQL_DB) do
+      point :geom
+      spatial_index [:geom]
+    end
+    MYSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (geom point)",
+      "CREATE SPATIAL INDEX posts_geom_index ON posts (geom)"
+    ]
+  end
+
+  specify "should support indexes with index type" do
+    g = Sequel::Schema::Generator.new(MYSQL_DB) do
+      text :title
+      index :title, :type => :hash
+    end
+    MYSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (title text)",
+      "CREATE INDEX posts_title_index ON posts (title) USING hash"
+    ]
+  end
+
+  specify "should support unique indexes with index type" do
+    g = Sequel::Schema::Generator.new(MYSQL_DB) do
+      text :title
+      index :title, :type => :hash, :unique => true
+    end
+    MYSQL_DB.create_table_sql_list(:posts, *g.create_info).should == [
+      "CREATE TABLE posts (title text)",
+      "CREATE UNIQUE INDEX posts_title_index ON posts (title) USING hash"
+    ]
+  end
+end
+
+context "MySQL::Dataset#insert" do
+  setup do
+    @d = MYSQL_DB[:items]
+    @d.delete # remove all records
+    MYSQL_DB.sqls.clear
+  end
+
+  specify "should insert record with default values when no arguments given" do
+    @d.insert
+    
+    MYSQL_DB.sqls.should == [
+      "INSERT INTO items () VALUES ()"
+    ]
+    
+    @d.all.should == [
+      {:name => nil, :value => nil}
+    ]
+  end
+
+  specify "should insert record with default values when empty hash given" do
+    @d.insert({})
+    
+    MYSQL_DB.sqls.should == [
+      "INSERT INTO items () VALUES ()"
+    ]
+    
+    @d.all.should == [
+      {:name => nil, :value => nil}
+    ]
+  end
+
+  specify "should insert record with default values when empty array given" do
+    @d.insert []
+    
+    MYSQL_DB.sqls.should == [
+      "INSERT INTO items () VALUES ()"
+    ]
+    
+    @d.all.should == [
+      {:name => nil, :value => nil}
+    ]
+  end
+end
+
+context "MySQL::Dataset#multi_insert" do
+  setup do
+    @d = MYSQL_DB[:items]
+    @d.delete # remove all records
+    MYSQL_DB.sqls.clear
+  end
+  
+  specify "should insert multiple records in a single statement" do
+    @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
+    
+    MYSQL_DB.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (name) VALUES ('abc'), ('def')",
+      'COMMIT'
+    ]
+
+    @d.all.should == [
+      {:name => 'abc', :value => nil}, {:name => 'def', :value => nil}
+    ]
+  end
+
+  specify "should split the list of records into batches if :commit_every option is given" do
+    @d.multi_insert([{:value => 1}, {:value => 2}, {:value => 3}, {:value => 4}],
+      :commit_every => 2)
+
+    MYSQL_DB.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (value) VALUES (1), (2)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (value) VALUES (3), (4)",
+      'COMMIT'
+    ]
+    
+    @d.all.should == [
+      {:name => nil, :value => 1}, 
+      {:name => nil, :value => 2},
+      {:name => nil, :value => 3}, 
+      {:name => nil, :value => 4}
+    ]
+  end
+
+  specify "should split the list of records into batches if :slice option is given" do
+    @d.multi_insert([{:value => 1}, {:value => 2}, {:value => 3}, {:value => 4}],
+      :slice => 2)
+
+    MYSQL_DB.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (value) VALUES (1), (2)",
+      'COMMIT',
+      'BEGIN',
+      "INSERT INTO items (value) VALUES (3), (4)",
+      'COMMIT'
+    ]
+    
+    @d.all.should == [
+      {:name => nil, :value => 1}, 
+      {:name => nil, :value => 2},
+      {:name => nil, :value => 3}, 
+      {:name => nil, :value => 4}
+    ]
+  end
+  
+  specify "should support inserting using columns and values arrays" do
+    @d.multi_insert([:name, :value], [['abc', 1], ['def', 2]])
+
+    MYSQL_DB.sqls.should == [
+      'BEGIN',
+      "INSERT INTO items (name, value) VALUES ('abc', 1), ('def', 2)",
+      'COMMIT'
+    ]
+    
+    @d.all.should == [
+      {:name => 'abc', :value => 1}, 
+      {:name => 'def', :value => 2}
+    ]
+  end
+end
+
+context "MySQL::Dataset#replace" do
+  setup do
+    MYSQL_DB.drop_table(:items) if MYSQL_DB.table_exists?(:items)
+    MYSQL_DB.create_table :items do
+      integer :id, :unique => true
+      integer :value, :index => true
+    end
+    @d = MYSQL_DB[:items]
+    MYSQL_DB.sqls.clear
+  end
+  
+  specify "should create a record if the condition is not met" do
+    @d.replace(:id => 111, :value => 333)
+    @d.all.should == [{:id => 111, :value => 333}]
+  end
+  
+  specify "should update a record if the condition is met" do
+    @d << {:id => 111}
+    @d.all.should == [{:id => 111, :value => nil}]
+    @d.replace(:id => 111, :value => 333)
+    @d.all.should == [{:id => 111, :value => 333}]
+  end
+end
+
+context "MySQL::Dataset#complex_expression_sql" do
+  setup do
+    @d = MYSQL_DB.dataset
+  end
+
+  specify "should handle pattern matches correctly" do
+    @d.literal(:x.like('a')).should == "(x LIKE BINARY 'a')"
+    @d.literal(~:x.like('a')).should == "(x NOT LIKE BINARY 'a')"
+    @d.literal(:x.ilike('a')).should == "(x LIKE 'a')"
+    @d.literal(~:x.ilike('a')).should == "(x NOT LIKE 'a')"
+    @d.literal(:x.like(/a/)).should == "(x REGEXP BINARY 'a')"
+    @d.literal(~:x.like(/a/)).should == "(x NOT REGEXP BINARY 'a')"
+    @d.literal(:x.like(/a/i)).should == "(x REGEXP 'a')"
+    @d.literal(~:x.like(/a/i)).should == "(x NOT REGEXP 'a')"
+  end
+
+  specify "should handle string concatenation with CONCAT if more than one record" do
+    @d.literal([:x, :y].sql_string_join).should == "CONCAT(x, y)"
+    @d.literal([:x, :y].sql_string_join(' ')).should == "CONCAT(x, ' ', y)"
+    @d.literal([:x[:y], 1, 'z'.lit].sql_string_join(:y|1)).should == "CONCAT(x(y), y[1], '1', y[1], z)"
+  end
+
+  specify "should handle string concatenation as simple string if just one record" do
+    @d.literal([:x].sql_string_join).should == "x"
+    @d.literal([:x].sql_string_join(' ')).should == "x"
+  end
+end