sequel 2.12.0 → 3.0.0

data/lib/sequel/metaprogramming.rb

@@ -8,26 +8,6 @@ module Sequel
   
     private
   
-    # Make a singleton/class attribute accessor method(s).
-    # Replaces the construct:
-    #
-    #   class << self
-    #     attr_accessor *meths
-    #   end
-    def metaattr_accessor(*meths)
-      meta_eval{attr_accessor(*meths)}
-    end
-  
-    # Make a singleton/class attribute reader method(s).
-    # Replaces the construct:
-    #
-    #   class << self
-    #     attr_reader *meths
-    #   end
-    def metaattr_reader(*meths)
-      meta_eval{attr_reader(*meths)}
-    end
-  
     # Evaluate the block in the context of the object's metaclass
     def meta_eval(&block)
       metaclass.instance_eval(&block)

data/lib/sequel/model.rb

@@ -45,7 +45,7 @@ module Sequel
        last left_outer_join limit map multi_insert naked order order_by
        order_more paginate print query range reverse_order right_outer_join
        select select_all select_more server set set_graph_aliases 
-       single_value to_csv to_hash transform union unfiltered unordered 
+       single_value to_csv to_hash union unfiltered unordered 
        update where with_sql'.map{|x| x.to_sym}
   
     # Class instance variables to set to nil when a subclass is created, for -w compliance
@@ -106,5 +106,4 @@ module Sequel
     require 'associations', 'model'
     Model.plugin Model::Associations
   end
-  require 'deprecated', 'model'
 end

data/lib/sequel/model/base.rb

@@ -285,7 +285,6 @@ module Sequel
           raise(Error, "Model.set_dataset takes a Symbol or a Sequel::Dataset")
         end
         @dataset.row_proc = Proc.new{|r| load(r)}
-        @dataset.transform(@transform) if @transform
         if inherited
           @simple_table = superclass.simple_table
           @columns = @dataset.columns rescue nil
@@ -438,8 +437,6 @@ module Sequel
       def set_columns(new_columns)
         @columns = new_columns
         def_column_accessor(*new_columns) if new_columns
-        # Deprecation.deprecated
-        @str_columns = nil
         @columns
       end
 
@@ -656,12 +653,9 @@ module Sequel
       # cached association and changed_columns information.  Raises an Error if the record no longer
       # exists in the database.
       def refresh
-        @values = this.first || raise(Error, "Record not found")
-        changed_columns.clear
-        associations.clear
-        self
+        _refresh(this)
       end
-      
+
       # Alias of refresh, but not aliased directly to make overriding in a plugin easier.
       def reload
         refresh
@@ -677,7 +671,7 @@ module Sequel
       #
       # Takes the following options:
       #
-      # * :changed - save all changed columns, instead of all columns or the columns
+      # * :changed - save all changed columns, instead of all columns or the columns given
       # * :transaction - set to false not to use a transaction
       # * :validate - set to false not to validate the model before saving
       def save(*columns)
@@ -777,6 +771,15 @@ module Sequel
         self
       end
       
+      # Refresh using a particular dataset, used inside save to make sure the same server
+      # is used for reading newly inserted values from the database
+      def _refresh(dataset)
+        @values = dataset.first || raise(Error, "Record not found")
+        changed_columns.clear
+        associations.clear
+        self
+      end
+      
       # Internal version of save, split from save to allow running inside
       # it's own transaction.
       def _save(columns, opts)
@@ -801,7 +804,11 @@ module Sequel
           after_create
           after_save
           @was_new = nil
-          refresh if pk
+          if pk
+            ds = this
+            ds = ds.server(:default) unless ds.opts[:server]
+            _refresh(ds)
+          end
         else
           return save_failure(:update) if before_update == false
           if columns.empty?
@@ -837,16 +844,12 @@ module Sequel
   
       # Set the columns, filtered by the only and except arrays.
       def set_restricted(hash, only, except)
-        columns_not_set = [nil, false, "", [], {}].include?(model.instance_variable_get(:@columns))
         meths = setter_methods(only, except)
         strict = strict_param_setting
         hash.each do |k,v|
           m = "#{k}="
           if meths.include?(m)
             send(m, v)
-          elsif columns_not_set && (Symbol === k)
-            Deprecation.deprecate('Calling Model#set_restricted for a column without a setter method when the model class does not have any columns', 'Use Model#[] for these columns')
-            self[k] = v
           elsif strict
             raise Error, "method #{m} doesn't exist or access is restricted to it"
           end
@@ -887,8 +890,7 @@ module Sequel
       # typecast_value method, so database adapters can override/augment the handling
       # for database specific column types.
       def typecast_value(column, value)
-        # Deprecation.deprecate : Remove model.serialized call
-        return value unless typecast_on_assignment && db_schema && (col_schema = db_schema[column]) && !model.serialized?(column)
+        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(InvalidValue, "nil/NULL is not allowed for the #{column} column") if raise_on_typecast_failure && value.nil? && (col_schema[:allow_null] == false)
         begin

data/lib/sequel/model/inflections.rb

@@ -97,8 +97,6 @@ module Sequel
     end
 
     # Setup the default inflections
-    # Commented out until the deprecated inflector is removed
-=begin
     plural(/$/, 's')
     plural(/s$/i, 's')
     plural(/(ax|test)is$/i, '\1es')
@@ -149,14 +147,13 @@ module Sequel
     irregular('move', 'moves')
 
     uncountable(%w(equipment information rice money species series fish sheep))
-=end
 
     private
 
     # Convert the given string to CamelCase.  Will also convert '/' to '::' which is useful for converting paths to namespaces.
     def camelize(s)
       s = s.to_s
-      # return s.camelize if s.respond_to?(:camelize)
+      return s.camelize if s.respond_to?(:camelize)
       s = s.gsub(CAMELIZE_MODULE_REGEXP){|x| "::#{x[-1..-1].upcase unless x == SLASH}"}.gsub(CAMELIZE_CONVERT_REGEXP){|x| x[-1..-1].upcase}
       s
     end
@@ -166,7 +163,7 @@ module Sequel
     # or is not initialized.
     def constantize(s)
       s = s.to_s
-      # return s.constantize if s.respond_to?(:constantize)
+      return s.constantize if s.respond_to?(:constantize)
       raise(NameError, "#{inspect} is not a valid constant name!") unless m = VALID_CONSTANT_NAME_REGEXP.match(s.to_s)
       Object.module_eval("::#{m[1]}", __FILE__, __LINE__)
     end
@@ -174,14 +171,14 @@ module Sequel
     # Removes the module part from the expression in the string
     def demodulize(s)
       s = s.to_s
-      # return s.demodulize if s.respond_to?(:demodulize)
+      return s.demodulize if s.respond_to?(:demodulize)
       s.gsub(DEMODULIZE_CONVERT_REGEXP, EMPTY_STRING)
     end
   
     # Returns the plural form of the word in the string.
     def pluralize(s)
       s = s.to_s
-      # return s.pluralize if s.respond_to?(:pluralize)
+      return s.pluralize if s.respond_to?(:pluralize)
       result = s.dup
       Inflections.plurals.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -190,7 +187,7 @@ module Sequel
     # The reverse of pluralize, returns the singular form of a word in a string.
     def singularize(s)
       s = s.to_s
-      # return s.singularize if s.respond_to?(:singularize)
+      return s.singularize if s.respond_to?(:singularize)
       result = s.dup
       Inflections.singulars.each{|(rule, replacement)| break if result.gsub!(rule, replacement)} unless Inflections.uncountables.include?(s.downcase)
       result
@@ -200,7 +197,7 @@ module Sequel
     # Also changes '::' to '/' to convert namespaces to paths.
     def underscore(s)
       s = s.to_s
-      # return s.underscore if s.respond_to?(:underscore)
+      return s.underscore if s.respond_to?(:underscore)
       s.gsub(UNDERSCORE_MODULE_REGEXP, SLASH).gsub(UNDERSCORE_CONVERT_REGEXP1, UNDERSCORE_CONVERT_REPLACE).
         gsub(UNDERSCORE_CONVERT_REGEXP2, UNDERSCORE_CONVERT_REPLACE).tr(DASH, UNDERSCORE).downcase
     end

data/lib/sequel/plugins/caching.rb

@@ -104,12 +104,6 @@ module Sequel
           super
         end
 
-        # Remove the object from the cache when updating
-        def update_values(*args)
-          cache_delete
-          super
-        end
-
         private
     
         # Delete this object from the cache

data/lib/sequel/plugins/hook_class_methods.rb

@@ -107,7 +107,7 @@ module Sequel
       end
 
       module InstanceMethods
-        Model::HOOKS.each{|h| class_eval("def #{h}; run_hooks(:#{h}); end", __FILE__, __LINE__)}
+        Model::HOOKS.each{|h| class_eval("def #{h}; return false if super == false; run_hooks(:#{h}); end", __FILE__, __LINE__)}
 
         private
 

data/lib/sequel/sql.rb

@@ -657,6 +657,8 @@ module Sequel
 
     # Represents a qualified (column with table or table with schema) reference. 
     class QualifiedIdentifier < GenericExpression
+      include QualifyingMethods
+
       # The column to reference
       attr_reader :column
 

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
-  MAJOR = 2
-  MINOR = 12
+  MAJOR = 3
+  MINOR = 0
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/firebird_spec.rb

@@ -25,6 +25,14 @@ FIREBIRD_DB.create_table! :test5 do
   integer :val
 end
 
+FIREBIRD_DB.create_table! :test6 do
+  primary_key :xid
+  blob :val
+  String :val2
+  varchar :val3, :size=>200
+  text :val4
+end
+
 context "A Firebird database" do
   before do
     @db = FIREBIRD_DB
@@ -234,7 +242,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :sequence_name => "seq_test"
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_TEST",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_test;\n                end\n              end\n\n"
@@ -245,7 +253,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :sequence_start_position => 999
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
       "ALTER SEQUENCE SEQ_POSTS_ID RESTART WITH 999",
@@ -257,7 +265,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :sequence_name => "seq_test", :sequence_start_position => 999
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_TEST",
       "ALTER SEQUENCE SEQ_TEST RESTART WITH 999",
@@ -269,7 +277,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :trigger_name => "trig_test"
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
       "          CREATE TRIGGER TRIG_TEST for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
@@ -280,7 +288,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :create_sequence => false
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "          CREATE TRIGGER BI_POSTS_ID for POSTS\n          ACTIVE BEFORE INSERT position 0\n          as               begin\n                if ((new.ID is null) or (new.ID = 0)) then\n                begin\n                  new.ID = next value for seq_posts_id;\n                end\n              end\n\n"
     ], nil]
@@ -290,7 +298,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :create_trigger => false
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )",
       "CREATE SEQUENCE SEQ_POSTS_ID",
     ], "DROP SEQUENCE SEQ_POSTS_ID"]
@@ -300,7 +308,7 @@ context "A Firebird database" do
     g = Sequel::Schema::Generator.new(FIREBIRD_DB) do
       primary_key :id, :create_sequence => false, :create_trigger => false
     end
-    FIREBIRD_DB.create_table_sql_list(:posts, *g.create_info).should == [[
+    FIREBIRD_DB.send(:create_table_sql_list, :posts, *g.create_info).should == [[
       "CREATE TABLE POSTS (ID integer PRIMARY KEY )"
     ], nil]
   end
@@ -348,7 +356,8 @@ context "Postgres::Dataset#insert" do
   end
 
   specify "should using call insert_returning_sql" do
-    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID', :server=> :default)
+#    @ds.should_receive(:single_value).once.with(:sql=>'INSERT INTO TEST5 (VAL) VALUES (10) RETURNING XID', :server=> :default)
+    @ds.should_receive(:single_value).once
     @ds.insert(:val=>10)
   end
 
@@ -374,3 +383,21 @@ context "Postgres::Dataset#insert" do
   end
 end
 
+context "Postgres::Dataset#insert" do
+  before do
+    @ds = FIREBIRD_DB[:test6]
+    @ds.delete
+  end
+
+  specify "should insert and retrieve a blob successfully" do
+    value1 = "\1\2\2\2\2222\2\2\2"
+    value2 = "abcd"
+    value3 = "efgh"
+    value4 = "ijkl"
+    id1 = @ds.insert(:val=>value1, :val2=>value2, :val3=>value3, :val4=>value4)
+    @ds.first(:XID=>id1)[:val].should == value1
+    @ds.first(:XID=>id1)[:val2].should == value2
+    @ds.first(:XID=>id1)[:val3].should == value3
+    @ds.first(:XID=>id1)[:val4].should == value4
+  end
+end

data/spec/adapters/mysql_spec.rb

@@ -13,17 +13,10 @@ end
 
 MYSQL_URI = URI.parse(MYSQL_DB.uri)
 
-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
@@ -32,6 +25,9 @@ def logger.method_missing(m, msg)
   MYSQL_DB.sqls << msg
 end
 MYSQL_DB.logger = logger
+MYSQL_DB.drop_table(:items) rescue nil
+MYSQL_DB.drop_table(:dolls) rescue nil
+MYSQL_DB.drop_table(:booltest) rescue nil
 
 if MYSQL_DB.class.adapter_scheme == :do
   SQL_BEGIN = 'Transaction.begin'
@@ -46,111 +42,77 @@ end
 context "MySQL", '#create_table' do
   before do
     @db = MYSQL_DB
+    MYSQL_DB.sqls.clear
   end
-  after(:each) do
-    @db.drop_table :dolls
+  after do
+    @db.drop_table(:dolls) rescue nil
   end
+  
   specify "should allow to specify options for MySQL" do
-    @db.create_table(:dolls, :engine => 'MyISAM', :charset => 'latin2') { text :name }
+    @db.create_table(:dolls, :engine => 'MyISAM', :charset => 'latin2'){text :name}
     @db.sqls.should == ["CREATE TABLE dolls (name text) ENGINE=MyISAM DEFAULT CHARSET=latin2"]
   end
+  
+  specify "should create a temporary table" do
+    @db.create_table(:tmp_dolls, :temp => true, :engine => 'MyISAM', :charset => 'latin2'){text :name}
+    @db.sqls.should == ["CREATE TEMPORARY TABLE tmp_dolls (name text) ENGINE=MyISAM DEFAULT CHARSET=latin2"]
+  end
 end
 
 context "A MySQL database" do
   before do
     @db = MYSQL_DB
+    @db.create_table(:booltest){TrueClass :value}
   end
   after do
     Sequel.convert_tinyint_to_bool = true
+    @db.drop_table(:booltest)
   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 provide disconnect functionality" do
-    @db.pool.size.should == 1
-    @db.disconnect
-    @db.pool.size.should == 0
-  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, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
     
     Sequel.convert_tinyint_to_bool = false
     @db.schema(:booltest, :reload=>true).should == [[:value, {:type=>:integer, :allow_null=>true, :primary_key=>false, :default=>nil, :db_type=>"tinyint(4)"}]]
   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
 
 context "A MySQL dataset" do
   before do
+    MYSQL_DB.create_table(:items){String :name; Integer :value}
     @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
+  after do
+    MYSQL_DB.drop_table(:items)
   end
   
   specify "should quote columns and tables using back-ticks if quoting identifiers" do
@@ -223,37 +185,6 @@ context "A MySQL dataset" do
       '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 == [SQL_BEGIN, "INSERT INTO items (name) VALUES ('abc')", SQL_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 == [SQL_BEGIN, "INSERT INTO items (name) VALUES ('abc')", SQL_COMMIT]
-  end
-  
   specify "should support regexps" do
     @d << {:name => 'abc', :value => 1}
     @d << {:name => 'bcd', :value => 2}
@@ -273,9 +204,6 @@ context "MySQL datasets" do
   before do
     @d = MYSQL_DB[:orders]
   end
-  after do
-    Sequel.convert_tinyint_to_bool = true
-  end
   
   specify "should correctly quote column references" do
     @d.quote_identifiers = true
@@ -286,30 +214,6 @@ context "MySQL datasets" do
       group_by(:minute.sql_function(:from_unixtime.sql_function(:ack))).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
 
 context "MySQL join expressions" do
@@ -454,89 +358,109 @@ context "A MySQL database" do
   end
 end  
 
-context "A MySQL database", "with table options" do
-  before(:all) do
-    @options = {}
-    @options[:engine] = 'MyISAM'
-    @options[:charset] = 'latin2'
-    @options[:collate] = 'swedish'
+context "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'    
+    Sequel::MySQL.default_collate = 'utf8_general_ci'    
     
     @db = MYSQL_DB
-    @g = Sequel::Schema::Generator.new(@db) do
-      integer :size
-      text :name
-    end
+    @db.drop_table(:items) rescue nil
+    
+    MYSQL_DB.sqls.clear
   end
-  
-  after(:all) do
+  after do
+    @db.drop_table(:items) rescue nil
     Sequel::MySQL.default_engine = nil
     Sequel::MySQL.default_charset = nil
     Sequel::MySQL.default_collate = nil
   end
   
   specify "should allow to pass custom options (engine, charset, collate) for table creation" do
-    statements = @db.send(:create_table_sql_list, :items, *(@g.create_info << @options))
-    statements.should == [
-      "CREATE TABLE items (size integer, name text) ENGINE=MyISAM DEFAULT CHARSET=latin2 DEFAULT COLLATE=swedish"
-    ]
+    @db.create_table(:items, @options){Integer :size; text :name}
+    @db.sqls.should == ["CREATE TABLE items (size integer, name text) ENGINE=MyISAM DEFAULT CHARSET=latin1 DEFAULT COLLATE=latin1_swedish_ci"]
   end
   
   specify "should use default options if specified (engine, charset, collate) for table creation" do
-    statements = @db.send(:create_table_sql_list, :items, *(@g.create_info))
-    statements.should == [
-      "CREATE TABLE items (size integer, name text) ENGINE=InnoDB DEFAULT CHARSET=utf8 DEFAULT COLLATE=utf8"
-    ]
+    @db.create_table(:items){Integer :size; text :name}
+    @db.sqls.should == ["CREATE TABLE items (size integer, name text) ENGINE=InnoDB DEFAULT CHARSET=utf8 DEFAULT COLLATE=utf8_general_ci"]
   end
   
   specify "should not use default if option has a nil value" do
-    statements = @db.send(:create_table_sql_list, :items, *(@g.create_info << {:engine=>nil, :charset=>nil, :collate=>nil}))
-    statements.should == [
-      "CREATE TABLE items (size integer, name text)"
-    ]
+    @db.create_table(:items, :engine=>nil, :charset=>nil, :collate=>nil){Integer :size; text :name}
+    @db.sqls.should == ["CREATE TABLE items (size integer, name text)"]
   end
 end
 
 context "A MySQL database" do
   before do
     @db = MYSQL_DB
+    @db.drop_table(:items) rescue nil
+    MYSQL_DB.sqls.clear
+  end
+  after do
+    @db.drop_table(:items) rescue nil
   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.send(:create_table_sql_list, :items, *g.create_info)
-    statements.should == [
-      "CREATE TABLE items (active1 boolean DEFAULT 1, active2 boolean DEFAULT 0)"
-    ]
+    @db.create_table(:items){TrueClass :active1, :default=>true; FalseClass :active2, :default => false}
+    @db.sqls.should == ["CREATE TABLE items (active1 tinyint DEFAULT 1, active2 tinyint 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.send(: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)"
-    ]
+    @db.create_table(:items){Integer :id; foreign_key :p_id, :items, :key => :id, :null => false, :on_delete => :cascade}
+    @db.sqls.should == ["CREATE TABLE items (id integer, p_id integer NOT NULL, FOREIGN KEY (p_id) REFERENCES items(id) ON DELETE CASCADE)"]
   end
   
-specify "should correctly format ALTER TABLE statements with foreign keys" do
-  g = Sequel::Schema::AlterTableGenerator.new(@db) do
-    add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade
+  specify "should correctly format ALTER TABLE statements with foreign keys" do
+    @db.create_table(:items){Integer :id}
+    @db.alter_table(:items){add_foreign_key :p_id, :users, :key => :id, :null => false, :on_delete => :cascade}
+    @db.sqls.should == ["CREATE TABLE items (id integer)", "ALTER TABLE items ADD COLUMN p_id integer NOT NULL", "ALTER TABLE items ADD FOREIGN KEY (p_id) REFERENCES users(id) ON DELETE CASCADE"]
+  end
+  
+  specify "should have rename_column support keep existing options" do
+    @db.create_table(:items){Integer :id, :null=>false, :default=>5}
+    @db.alter_table(:items){rename_column :id, :nid}
+    @db.sqls.should == ["CREATE TABLE items (id integer NOT NULL DEFAULT 5)", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id nid int(11) NOT NULL DEFAULT 5"]
+    @db[:items].insert
+    @db[:items].all.should == [{:nid=>5}]
+    proc{@db[:items].insert(:nid=>nil)}.should raise_error(Sequel::DatabaseError)
+  end
+  
+  specify "should have set_column_type support keep existing options" do
+    @db.create_table(:items){Integer :id, :null=>false, :default=>5}
+    @db.alter_table(:items){set_column_type :id, Bignum}
+    @db.sqls.should == ["CREATE TABLE items (id integer NOT NULL DEFAULT 5)", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id id bigint NOT NULL DEFAULT 5"]
+    @db[:items].insert
+    @db[:items].all.should == [{:id=>5}]
+    proc{@db[:items].insert(:id=>nil)}.should raise_error(Sequel::DatabaseError)
+    @db[:items].delete
+    @db[:items].insert(2**40)
+    @db[:items].all.should == [{:id=>2**40}]
+  end
+  
+  specify "should have set_column_default support keep existing options" do
+    @db.create_table(:items){Integer :id, :null=>false, :default=>5}
+    @db.alter_table(:items){set_column_default :id, 6}
+    @db.sqls.should == ["CREATE TABLE items (id integer NOT NULL DEFAULT 5)", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id id int(11) NOT NULL DEFAULT 6"]
+    @db[:items].insert
+    @db[:items].all.should == [{:id=>6}]
+    proc{@db[:items].insert(:id=>nil)}.should raise_error(Sequel::DatabaseError)
+  end
+  
+  specify "should have set_column_allow_null support keep existing options" do
+    @db.create_table(:items){Integer :id, :null=>false, :default=>5}
+    @db.alter_table(:items){set_column_allow_null :id, true}
+    @db.sqls.should == ["CREATE TABLE items (id integer NOT NULL DEFAULT 5)", "DESCRIBE items", "ALTER TABLE items CHANGE COLUMN id id int(11) NULL DEFAULT 5"]
+    @db[:items].insert
+    @db[:items].all.should == [{:id=>5}]
+    proc{@db[:items].insert(:id=>nil)}.should_not
   end
-  @db.send(:alter_table_sql_list, :items, g.operations).should == [[
-    "ALTER TABLE items ADD COLUMN p_id integer NOT NULL",
-    "ALTER TABLE items ADD FOREIGN KEY (p_id) REFERENCES users(id) ON DELETE CASCADE"
-  ]]
-end
   
   specify "should accept repeated raw sql statements using Database#<<" do
+    @db.create_table(:items){String :name; Integer :value}
     @db << 'DELETE FROM items'
     @db[:items].count.should == 0
     
@@ -548,8 +472,7 @@ end
   end
   
   specify "should handle multiple select statements at once" do
-    @db << 'DELETE FROM items; '
-    
+    @db.create_table(:items){String :name; Integer :value}
     @db[:items].delete
     @db[:items].insert(:name => 'tutu', :value => 1234)
     @db["SELECT * FROM items; SELECT * FROM items"].all.should == \
@@ -600,71 +523,73 @@ context "A grouped MySQL dataset" do
 end
 
 context "A MySQL database" do
-  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.send(:create_table_sql_list, :posts, *g.create_info).should == [
+  before do
+    @db = MYSQL_DB
+    @db.drop_table(:posts) rescue nil
+    @db.sqls.clear
+  end
+  after do
+    @db.drop_table(:posts) rescue nil
+  end
+  
+  specify "should support fulltext indexes and full_text_search" do
+    @db.create_table(:posts){text :title; text :body; full_text_index :title; full_text_index [:title, :body]}
+    @db.sqls.should == [
       "CREATE TABLE posts (title text, body text)",
+      "CREATE FULLTEXT INDEX posts_title_index ON posts (title)",
       "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))"
+    @db[:posts].insert(:title=>'ruby rails', :body=>'y')
+    @db[:posts].insert(:title=>'sequel', :body=>'ruby')
+    @db[:posts].insert(:title=>'ruby scooby', :body=>'x')
+    @db.sqls.clear
+
+    @db[:posts].full_text_search(:title, 'rails').all.should == [{:title=>'ruby rails', :body=>'y'}]
+    @db[:posts].full_text_search([:title, :body], ['sequel', 'ruby']).all.should == [{:title=>'sequel', :body=>'ruby'}]
+    @db[:posts].full_text_search(:title, '+ruby -rails', :boolean => true).all.should == [{:title=>'ruby scooby', :body=>'x'}]
+    @db.sqls.should == [
+      "SELECT * FROM posts WHERE (MATCH (title) AGAINST ('rails'))",
+      "SELECT * FROM posts WHERE (MATCH (title, body) AGAINST ('sequel ruby'))",
+      "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.send(:create_table_sql_list, :posts, *g.create_info).should == [
-      "CREATE TABLE posts (geom point)",
+    @db.create_table(:posts){point :geom, :null=>false; spatial_index [:geom]}
+    @db.sqls.should == [
+      "CREATE TABLE posts (geom point NOT NULL)",
       "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.send(:create_table_sql_list, :posts, *g.create_info).should == [
-      "CREATE TABLE posts (title text)",
-      "CREATE INDEX posts_title_index ON posts (title) USING hash"
+    @db.create_table(:posts){Integer :id; index :id, :type => :btree}
+    @db.sqls.should == [
+      "CREATE TABLE posts (id integer)",
+      "CREATE INDEX posts_id_index USING btree ON posts (id)"
     ]
   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.send(: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"
+    @db.create_table(:posts){Integer :id; index :id, :type => :btree, :unique => true}
+    @db.sqls.should == [
+      "CREATE TABLE posts (id integer)",
+      "CREATE UNIQUE INDEX posts_id_index USING btree ON posts (id)"
     ]
   end
 end
 
-context "MySQL::Dataset#insert" do
+context "MySQL::Dataset#insert and related methods" do
   before do
+    MYSQL_DB.create_table(:items){String :name; Integer :value}
     @d = MYSQL_DB[:items]
-    @d.delete
     MYSQL_DB.sqls.clear
   end
+  after do
+    MYSQL_DB.drop_table(:items)
+  end
 
-  specify "should insert record with default values when no arguments given" do
+  specify "#insert should insert record with default values when no arguments given" do
     @d.insert
     
     MYSQL_DB.sqls.should == [
@@ -676,7 +601,7 @@ context "MySQL::Dataset#insert" do
     ]
   end
 
-  specify "should insert record with default values when empty hash given" do
+  specify "#insert  should insert record with default values when empty hash given" do
     @d.insert({})
     
     MYSQL_DB.sqls.should == [
@@ -688,7 +613,7 @@ context "MySQL::Dataset#insert" do
     ]
   end
 
-  specify "should insert record with default values when empty array given" do
+  specify "#insert should insert record with default values when empty array given" do
     @d.insert []
     
     MYSQL_DB.sqls.should == [
@@ -699,16 +624,8 @@ context "MySQL::Dataset#insert" do
       {:name => nil, :value => nil}
     ]
   end
-end
 
-context "MySQL::Dataset#multi_insert" do
-  before do
-    @d = MYSQL_DB[:items]
-    @d.delete
-    MYSQL_DB.sqls.clear
-  end
-  
-  specify "should insert multiple records in a single statement" do
+  specify "#multi_insert should insert multiple records in a single statement" do
     @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
     
     MYSQL_DB.sqls.should == [
@@ -722,7 +639,7 @@ context "MySQL::Dataset#multi_insert" do
     ]
   end
 
-  specify "should split the list of records into batches if :commit_every option is given" do
+  specify "#multi_insert 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)
 
@@ -743,7 +660,7 @@ context "MySQL::Dataset#multi_insert" do
     ]
   end
 
-  specify "should split the list of records into batches if :slice option is given" do
+  specify "#multi_insert 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)
 
@@ -764,7 +681,7 @@ context "MySQL::Dataset#multi_insert" do
     ]
   end
   
-  specify "should support inserting using columns and values arrays" do
+  specify "#import should support inserting using columns and values arrays" do
     @d.import([:name, :value], [['abc', 1], ['def', 2]])
 
     MYSQL_DB.sqls.should == [
@@ -778,16 +695,8 @@ context "MySQL::Dataset#multi_insert" do
       {:name => 'def', :value => 2}
     ]
   end
-end
-
-context "MySQL::Dataset#insert_ignore" do
-  before do
-    @d = MYSQL_DB[:items]
-    @d.delete
-    MYSQL_DB.sqls.clear
-  end
   
-  specify "should add the IGNORE keyword when inserting" do
+  specify "#insert_ignore should add the IGNORE keyword when inserting" do
     @d.insert_ignore.multi_insert([{:name => 'abc'}, {:name => 'def'}])
     
     MYSQL_DB.sqls.should == [
@@ -800,16 +709,8 @@ context "MySQL::Dataset#insert_ignore" do
       {:name => 'abc', :value => nil}, {:name => 'def', :value => nil}
     ]
   end
-end
-
-context "MySQL::Dataset#on_duplicate_key_update" do
-  before do
-    @d = MYSQL_DB[:items]
-    @d.delete
-    MYSQL_DB.sqls.clear
-  end
   
-  specify "should add the ON DUPLICATE KEY UPDATE and ALL columns when no args given" do
+  specify "#on_duplicate_key_update should add the ON DUPLICATE KEY UPDATE and ALL columns when no args given" do
     @d.on_duplicate_key_update.import([:name,:value], 
       [['abc', 1], ['def',2]]
     )
@@ -824,7 +725,8 @@ context "MySQL::Dataset#on_duplicate_key_update" do
       {:name => 'abc', :value => 1}, {:name => 'def', :value => 2}
     ]
   end
-  specify "should add the ON DUPLICATE KEY UPDATE and columns specified when args are given" do
+  
+  specify "#on_duplicate_key_update should add the ON DUPLICATE KEY UPDATE and columns specified when args are given" do
     @d.on_duplicate_key_update(:value).import([:name,:value], 
       [['abc', 1], ['def',2]]
     )
@@ -844,14 +746,13 @@ end
 
 context "MySQL::Dataset#replace" do
   before 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
+    MYSQL_DB.create_table(:items){Integer :id, :unique=>true; Integer :value}
     @d = MYSQL_DB[:items]
     MYSQL_DB.sqls.clear
   end
+  after do
+    MYSQL_DB.drop_table(:items)
+  end
   
   specify "should create a record if the condition is not met" do
     @d.replace(:id => 111, :value => 333)
@@ -896,7 +797,13 @@ end
 
 unless MYSQL_DB.class.adapter_scheme == :do
   context "MySQL Stored Procedures" do
+    before do
+      MYSQL_DB.create_table(:items){Integer :id; Integer :value}
+      @d = MYSQL_DB[:items]
+      MYSQL_DB.sqls.clear
+    end
     after do
+      MYSQL_DB.drop_table(:items)
       MYSQL_DB.execute('DROP PROCEDURE test_sproc')
     end