sequel 2.12.0 → 3.0.0

data/lib/sequel/adapters/db2.rb

@@ -4,7 +4,10 @@ module Sequel
   module DB2
     class Database < Sequel::Database
       set_adapter_scheme :db2
+
       include DB2CLI
+
+      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
       
       rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
       #check_error(rc, "Could not allocate DB2 environment")

data/lib/sequel/adapters/dbi.rb

@@ -19,6 +19,15 @@ module Sequel
         :sqlite => "SQLite",
         :sqlrelay => "SQLRelay"
       }
+      
+      def initialize(opts)
+        super(opts)
+        case opts[:db_type]
+        when 'mssql'
+          Sequel.require 'adapters/shared/mssql'
+          extend Sequel::MSSQL::DatabaseMethods
+        end
+      end
 
       # Converts a uri to an options hash. These options are then passed
       # to a newly created database object.

data/lib/sequel/adapters/do.rb

@@ -121,10 +121,6 @@ module Sequel
       # transactions and commits them immediately after.  It's wasteful,
       # but required by DataObject's API.
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         th = Thread.current
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(th)

data/lib/sequel/adapters/firebird.rb

@@ -9,6 +9,7 @@ module Sequel
       set_adapter_scheme :firebird
 
       AUTO_INCREMENT = ''.freeze
+      TEMPORARY = 'GLOBAL TEMPORARY '.freeze
 
       # Add the primary_keys and primary_key_sequences instance variables,
       # so we can get the correct return values for inserted rows.
@@ -44,13 +45,10 @@ module Sequel
       # generator for auto-incrementing primary keys.
       def create_table(name, options={}, &block)
         options = {:generator=>options} if options.is_a?(Schema::Generator)
-        statements = create_table_sql_list(name, *((options[:generator] ||= Schema::Generator.new(self, &block)).create_info << options))
-        begin
-          execute_ddl(statements[1])
-        rescue
-          nil
-        end if statements[1]
-        statements[0].flatten.each {|sql| execute_ddl(sql)}
+        generator = options[:generator] || Schema::Generator.new(self, &block)
+        drop_statement, create_statements = create_table_sql_list(name, generator, options)
+        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        (create_statements + index_sql_list(name, generator.indexes)).each{|sql| execute_ddl(sql)}
       end
 
       def create_trigger(*args)
@@ -106,10 +104,6 @@ module Sequel
       end
 
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           log_info("Transaction.begin")
@@ -157,10 +151,10 @@ module Sequel
         "CREATE SEQUENCE #{quote_identifier(name)}"
       end
 
-      def create_table_sql_list(name, columns, indexes = nil, options={})
-        statements = super
+      def create_table_sql_list(name, generator, options={})
+        statements = [create_table_sql(name, generator, options)]
         drop_seq_statement = nil
-        columns.each do |c|
+        generator.columns.each do |c|
           if c[:auto_increment]
             c[:sequence_name] ||= "seq_#{name}_#{c[:name]}"
             unless c[:create_sequence] == false
@@ -183,7 +177,7 @@ module Sequel
             end
           end
         end
-        [statements, drop_seq_statement]
+        [drop_seq_statement, statements]
       end
 
       def create_trigger_sql(table, name, definition, opts={})
@@ -211,6 +205,10 @@ module Sequel
         seq_name = quote_identifier(name)
         "ALTER SEQUENCE #{seq_name} RESTART WITH #{opts[:restart_position]}"
       end
+
+      def type_literal_generic_string(column)
+        column[:text] ? :"BLOB SUBTYPE TEXT" : super
+      end
     end
 
     # Dataset class for Firebird datasets
@@ -273,9 +271,9 @@ module Sequel
         SELECT_CLAUSE_ORDER
       end
       
-      def select_limit_sql(sql, opts)
-        sql << " FIRST #{opts[:limit]}" if opts[:limit]
-        sql << " SKIP #{opts[:offset]}" if opts[:offset]
+      def select_limit_sql(sql)
+        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
+        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
       end
 
       private

data/lib/sequel/adapters/informix.rb

@@ -6,6 +6,8 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :informix
       
+      TEMPORARY = 'TEMP '.freeze
+      
       def connect(server)
         opts = server_opts(server)
         ::Informix.connect(opts[:database], opts[:user], opts[:password])
@@ -66,9 +68,9 @@ module Sequel
         SELECT_CLAUSE_ORDER
       end
 
-      def select_limit_sql(sql, opts)
-        sql << " SKIP #{opts[:offset]}" if opts[:offset]
-        sql << " FIRST #{opts[:limit]}" if opts[:limit]
+      def select_limit_sql(sql)
+        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
       end
     end
   end

data/lib/sequel/adapters/jdbc.rb

@@ -185,11 +185,27 @@ module Sequel
         execute(sql, {:type=>:insert}.merge(opts))
       end
       
+      # Return a hash containing index information. Hash keys are index name symbols.
+      # Values are subhashes with two keys, :columns and :unique.  The value of :columns
+      # is an array of symbols of column names.  The value of :unique is true or false
+      # depending on if the index is unique.
+      def indexes(table)
+        indexes = {}
+        m = output_identifier_meth
+        metadata(:getIndexInfo, nil, nil, input_identifier_meth.call(table), false, true) do |r|
+          next unless name = r[:column_name]
+          next if respond_to?(:primary_key_index_re, true) and r[:index_name] =~ primary_key_index_re 
+          i = indexes[m.call(r[:index_name])] ||= {:columns=>[], :unique=>!r[:non_unique]}
+          i[:columns] << m.call(name)
+        end
+        indexes
+      end 
+
       # All tables in this database
       def tables
         ts = []
-        ds = dataset
-        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << ds.send(:output_identifier, h[:table_name])}
+        m = output_identifier_meth
+        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
         ts
       end
       
@@ -197,10 +213,6 @@ module Sequel
       # databases.  Does not use the JDBC transaction methods, uses
       # SQL BEGIN/ROLLBACK/COMMIT statements instead.
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           stmt = conn.createStatement
@@ -308,9 +320,7 @@ module Sequel
       
       # Yield the metadata for this database
       def metadata(*args, &block)
-        ds = dataset
-        ds.identifier_output_method = :downcase
-        synchronize{|c| ds.send(:process_result_set, c.getMetaData.send(*args), &block)}
+        synchronize{|c| metadata_dataset.send(:process_result_set, c.getMetaData.send(*args), &block)}
       end
       
       # Java being java, you need to specify the type of each argument
@@ -347,16 +357,18 @@ module Sequel
       
       # All tables in this database
       def schema_parse_table(table, opts={})
+        m = output_identifier_meth
+        im = input_identifier_meth
         ds = dataset
         schema, table = schema_and_table(table)
-        schema = ds.send(:input_identifier, schema) if schema
-        table = ds.send(:input_identifier, table)
+        schema = im.call(schema) if schema
+        table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
-          ts << [ds.send(:output_identifier, h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name])}]
+          ts << [m.call(h[:column_name]), {:type=>schema_column_type(h[:type_name]), :db_type=>h[:type_name], :default=>(h[:column_def] == '' ? nil : h[:column_def]), :allow_null=>(h[:nullable] != 0), :primary_key=>pks.include?(h[:column_name])}]
         end
         ts
       end
@@ -476,11 +488,3 @@ module Sequel
     end
   end
 end
-
-class Java::JavaSQL::Timestamp
-  # Add a usec method in order to emulate Time values.
-  def usec
-    Deprecation.deprecate('Java::JavaSQL::Timestamp#usec', 'Use timestamp.getNanos/1000')
-    getNanos/1000
-  end
-end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -6,6 +6,13 @@ module Sequel
     module H2
       # Instance methods for H2 Database objects accessed via JDBC.
       module DatabaseMethods
+        PRIMARY_KEY_INDEX_RE = /\Aprimary_key/i.freeze
+      
+        # H2 uses the :h2 database type.
+        def database_type
+          :h2
+        end
+
         # Return Sequel::JDBC::H2::Dataset object with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::H2::Dataset.new(self, opts)
@@ -32,6 +39,12 @@ module Sequel
             super(table, op)
           end
         end
+        
+        # Default to a single connection for a memory database.
+        def connection_pool_default_options
+          o = super
+          uri == 'jdbc:h2:mem:' ? o.merge(:max_connections=>1) : o
+        end
       
         # Use IDENTITY() to get the last inserted id.
         def last_insert_id(conn, opts={})
@@ -45,10 +58,8 @@ module Sequel
           end 
         end
         
-        # Default to a single connection for a memory database.
-        def connection_pool_default_options
-          o = super
-          uri == 'jdbc:h2:mem:' ? o.merge(:max_connections=>1) : o
+        def primary_key_index_re
+          PRIMARY_KEY_INDEX_RE
         end
       end
       

data/lib/sequel/adapters/mysql.rb

@@ -135,10 +135,6 @@ module Sequel
       
       # Support single level transactions on MySQL.
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           log_info(begin_transaction_sql)
@@ -297,8 +293,8 @@ module Sequel
       end
       
       # Delete rows matching this dataset
-      def delete(opts = (defarg=true;nil))
-        execute_dui(defarg ? delete_sql : delete_sql(opts)){|c| c.affected_rows}
+      def delete
+        execute_dui(delete_sql){|c| c.affected_rows}
       end
       
       # Yield all rows matching this dataset
@@ -338,8 +334,8 @@ module Sequel
       end
       
       # Update the matching rows.
-      def update(values={}, opts=(defarg=true;nil))
-        execute_dui(defarg ? update_sql(values) : update_sql(values, opts)){|c| c.affected_rows}
+      def update(values={})
+        execute_dui(update_sql(values)){|c| c.affected_rows}
       end
       
       private

data/lib/sequel/adapters/odbc.rb

@@ -65,10 +65,6 @@ module Sequel
 
       # Support single level transactions on ODBC
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           log_info(begin_transaction_sql)

data/lib/sequel/adapters/oracle.rb

@@ -78,10 +78,6 @@ module Sequel
       alias do execute
       
       def transaction(opts={})
-        unless opts.is_a?(Hash)
-          Deprecation.deprecate('Passing an argument other than a Hash to Database#transaction', "Use DB.transaction(:server=>#{opts.inspect})") 
-          opts = {:server=>opts}
-        end
         synchronize(opts[:server]) do |conn|
           return yield(conn) if @transactions.include?(Thread.current)
           conn.autocommit = false

data/lib/sequel/adapters/shared/mssql.rb

@@ -7,7 +7,13 @@ module Sequel
       SQL_BEGIN = "BEGIN TRANSACTION".freeze
       SQL_COMMIT = "COMMIT TRANSACTION".freeze
       SQL_ROLLBACK = "ROLLBACK TRANSACTION".freeze
+      TEMPORARY = "#".freeze
       
+      # Microsoft SQL Server uses the :mssql type.
+      def database_type
+        :mssql
+      end
+
       def dataset(opts = nil)
         ds = super
         ds.extend(DatasetMethods)
@@ -34,6 +40,11 @@ module Sequel
       def rollback_transaction_sql
         SQL_ROLLBACK
       end
+
+      # SQL fragment for marking a table as temporary
+      def temporary_table_sql
+        TEMPORARY
+      end
     end
   
     module DatasetMethods
@@ -79,14 +90,14 @@ module Sequel
       end
 
       # MSSQL uses TOP for limit, with no offset support
-      def select_limit_sql(sql, opts)
-        raise(Error, "OFFSET not supported") if opts[:offset]
-        sql << " TOP #{opts[:limit]}" if opts[:limit]
+      def select_limit_sql(sql)
+        raise(Error, "OFFSET not supported") if @opts[:offset]
+        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
       end
 
       # MSSQL uses the WITH statement to lock tables
-      def select_with_sql(sql, opts)
-        sql << " WITH #{opts[:with]}" if opts[:with]
+      def select_with_sql(sql)
+        sql << " WITH #{@opts[:with]}" if @opts[:with]
       end
     end
   end

data/lib/sequel/adapters/shared/mysql.rb

@@ -15,14 +15,37 @@ module Sequel
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
-      NOT_NULL = Sequel::Database::NOT_NULL
-      NULL = Sequel::Database::NULL
-      PRIMARY_KEY = Sequel::Database::PRIMARY_KEY
-      TYPES = Sequel::Database::TYPES.merge(DateTime=>'datetime', \
-        TrueClass=>'tinyint', FalseClass=>'tinyint')
-      UNIQUE = Sequel::Database::UNIQUE
-      UNSIGNED = Sequel::Database::UNSIGNED
+      CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
+      PRIMARY = 'PRIMARY'.freeze
       
+      # MySQL's cast rules are restrictive in that you can't just cast to any possible
+      # database type.
+      def cast_type_literal(type)
+        CAST_TYPES[type] || super
+      end
+
+      # MySQL uses the :mysql database type
+      def database_type
+        :mysql
+      end
+
+      # Return a hash containing index information. Hash keys are index name symbols.
+      # Values are subhashes with two keys, :columns and :unique.  The value of :columns
+      # is an array of symbols of column names.  The value of :unique is true or false
+      # depending on if the index is unique.
+      def indexes(table)
+        indexes = {}
+        m = output_identifier_meth
+        im = input_identifier_meth
+        metadata_dataset.with_sql("SHOW INDEX FROM ?", SQL::Identifier.new(im.call(table))).each do |r|
+          name = r[:Key_name]
+          next if name == PRIMARY
+          i = indexes[m.call(name)] ||= {:columns=>[], :unique=>r[:Non_unique] != 1}
+          i[:columns] << m.call(r[:Column_name])
+        end
+        indexes
+      end
+
       # Get version of MySQL server, used for determined capabilities.
       def server_version
         m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
@@ -34,10 +57,8 @@ module Sequel
       # Options:
       # * :server - Set the server to use
       def tables(opts={})
-        ds = self['SHOW TABLES'].server(opts[:server])
-        ds.identifier_output_method = nil
-        ds2 = dataset
-        ds.map{|r| ds2.send(:output_identifier, r.values.first)}
+        m = output_identifier_meth
+        metadata_dataset.with_sql('SHOW TABLES').server(opts[:server]).map{|r| m.call(r.values.first)}
       end
       
       # Changes the database in use by issuing a USE statement.  I would be
@@ -63,10 +84,15 @@ module Sequel
           else
             super(table, op)
           end
-        when :rename_column
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{quote_identifier(op[:new_name])} #{type_literal(op)}"
-        when :set_column_type
-          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{quote_identifier(op[:name])} #{type_literal(op)}"
+        when :rename_column, :set_column_type, :set_column_null, :set_column_default
+          o = op[:op]
+          opts = schema(table).find{|x| x.first == op[:name]}
+          old_opts = opts ? opts.last : {}
+          name = o == :rename_column ? op[:new_name] : op[:name]
+          type = o == :set_column_type ? op[:type] : old_opts[:db_type]
+          null = o == :set_column_null ? op[:null] : old_opts[:allow_null]
+          default = o == :set_column_default ? op[:default] : (old_opts[:default].lit if old_opts[:default])
+          "ALTER TABLE #{quote_schema_table(table)} CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(:name=>name, :type=>type, :null=>null, :default=>default)}"
         when :drop_index
           "#{drop_index_sql(table, op)} ON #{quote_schema_table(table)}"
         else
@@ -85,13 +111,11 @@ module Sequel
       end
       
       # Use MySQL specific syntax for engine type and character encoding
-      def create_table_sql_list(name, columns, indexes = nil, options = {})
-        options[:engine] = Sequel::MySQL.default_engine unless options.include?(:engine)
-        options[:charset] = Sequel::MySQL.default_charset unless options.include?(:charset)
-        options[:collate] = Sequel::MySQL.default_collate unless options.include?(:collate)
-        sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})#{" ENGINE=#{options[:engine]}" if options[:engine]}#{" DEFAULT CHARSET=#{options[:charset]}" if options[:charset]}#{" DEFAULT COLLATE=#{options[:collate]}" if options[:collate]}"]
-        sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
-        sql
+      def create_table_sql(name, generator, options = {})
+        engine = options.include?(:engine) ? options[:engine] : Sequel::MySQL.default_engine
+        charset = options.include?(:charset) ? options[:charset] : Sequel::MySQL.default_charset
+        collate = options.include?(:collate) ? options[:collate] : Sequel::MySQL.default_collate
+        "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 
       # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
@@ -116,15 +140,19 @@ module Sequel
           using = " USING #{index[:type]}" unless index[:type] == nil
           "UNIQUE " if index[:unique]
         end
-        "CREATE #{index_type}INDEX #{index_name} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}#{using}"
+        "CREATE #{index_type}INDEX #{index_name}#{using} ON #{quote_schema_table(table_name)} #{literal(index[:columns])}"
       end
       
+      # MySQL treats integer primary keys as autoincrementing.
+      def schema_autoincrementing_primary_key?(schema)
+        super and schema[:db_type] =~ /int/io
+      end
+
       # Use the MySQL specific DESCRIBE syntax to get a table description.
       def schema_parse_table(table_name, opts)
-        ds = self["DESCRIBE ?", SQL::Identifier.new(table_name)]
-        ds.identifier_output_method = nil
-        ds2 = dataset
-        ds.map do |row|
+        m = output_identifier_meth
+        im = input_identifier_meth
+        metadata_dataset.with_sql("DESCRIBE ?", SQL::Identifier.new(im.call(table_name))).map do |row|
           row.delete(:Extra)
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)
@@ -132,13 +160,26 @@ module Sequel
           row[:default] = nil if blank_object?(row[:default])
           row[:db_type] = row.delete(:Type)
           row[:type] = schema_column_type(row[:db_type])
-          [ds2.send(:output_identifier, row.delete(:Field)), row]
+          [m.call(row.delete(:Field)), row]
         end
       end
 
-      # Override the standard type conversions with MySQL specific ones
-      def type_literal_base(column)
-        TYPES[column[:type]]
+      # MySQL has both datetime and timestamp classes, most people are going
+      # to want datetime
+      def type_literal_generic_datetime(column)
+        :datetime
+      end
+
+      # MySQL has both datetime and timestamp classes, most people are going
+      # to want datetime
+      def type_literal_generic_time(column)
+        column[:only_time] ? :time : :datetime
+      end
+
+      # MySQL doesn't have a true boolean class, so it uses tinyint
+      # MySQL doesn't have a true boolean class, so it uses tinyint
+      def type_literal_generic_trueclass(column)
+        :tinyint
       end
     end
   
@@ -148,15 +189,9 @@ module Sequel
 
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
-      CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}
       TIMESTAMP_FORMAT = "'%Y-%m-%d %H:%M:%S'".freeze
       COMMA_SEPARATOR = ', '.freeze
       
-      # MySQL can't use the varchar type in a cast.
-      def cast_sql(expr, type)
-        "CAST(#{literal(expr)} AS #{CAST_TYPES[type] || db.send(:type_literal_base, :type=>type)})"
-      end
-
       # MySQL specific syntax for LIKE/REGEXP searches, as well as
       # string concatenation.
       def complex_expression_sql(op, args)
@@ -175,22 +210,10 @@ module Sequel
       end
       
       # MySQL supports ORDER and LIMIT clauses in DELETE statements.
-      def delete_sql(opts = (defarg=true;nil))
-        if defarg
-          sql = super()
-          opts = @opts
-        else
-          sql = super
-          opts = opts ? @opts.merge(opts) : @opts
-        end
-
-        if order = opts[:order]
-          sql << " ORDER BY #{expression_list(order)}"
-        end
-        if limit = opts[:limit]
-          sql << " LIMIT #{limit}"
-        end
-
+      def delete_sql
+        sql = super
+        sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
+        sql << " LIMIT #{opts[:limit]}" if opts[:limit]
         sql
       end
 
@@ -200,19 +223,14 @@ module Sequel
         super
       end
 
-      # MySQL specific full text search syntax.
+      # Adds full text filter
       def full_text_search(cols, terms, opts = {})
-        mode = opts[:boolean] ? " IN BOOLEAN MODE" : ""
-        s = if Array === terms
-          if mode.empty?
-            "MATCH #{literal(Array(cols))} AGAINST #{literal(terms)}"
-          else
-            "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)[1...-1]}#{mode})"
-          end
-        else
-          "MATCH #{literal(Array(cols))} AGAINST (#{literal(terms)}#{mode})"
-        end
-        filter(s)
+        filter(full_text_sql(cols, terms, opts))
+      end
+      
+      # MySQL specific full text search syntax.
+      def full_text_sql(cols, term, opts = {})
+        "MATCH #{literal(Array(cols))} AGAINST (#{literal(Array(term).join(' '))}#{" IN BOOLEAN MODE" if opts[:boolean]})"
       end
 
       # MySQL allows HAVING clause on ungrouped datasets.
@@ -311,11 +329,6 @@ module Sequel
         else
           values = values[0] if values.size == 1
           
-          # if hash or array with keys we need to transform the values
-          if @transform && (values.is_a?(Hash) || (values.is_a?(Array) && values.keys))
-            values = transform_save(values)
-          end
-
           case values
           when Array
             if values.empty?
@@ -344,22 +357,10 @@ module Sequel
       end
       
       # MySQL supports ORDER and LIMIT clauses in UPDATE statements.
-      def update_sql(values, opts = (defarg=true;nil))
-        if defarg
-          sql = super(values)
-          opts = @opts
-        else
-          sql = super
-          opts = opts ? @opts.merge(opts) : @opts
-        end
-
-        if order = opts[:order]
-          sql << " ORDER BY #{expression_list(order)}"
-        end
-        if limit = opts[:limit]
-          sql << " LIMIT #{limit}"
-        end
-
+      def update_sql(values)
+        sql = super
+        sql << " ORDER BY #{expression_list(opts[:order])}" if opts[:order]
+        sql << " LIMIT #{opts[:limit]}" if opts[:limit]
         sql
       end