sequel 3.21.0 → 3.36.0

data/lib/sequel/adapters/mysql.rb

@@ -5,97 +5,70 @@ rescue LoadError
 end
 raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
-Sequel.require %w'shared/mysql utils/stored_procedures', 'adapters'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all MySQL-related classes and modules for Sequel.
   module MySQL
     TYPE_TRANSLATOR = tt = Class.new do
       def boolean(s) s.to_i != 0 end
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
       def integer(s) s.to_i end
       def float(s) s.to_f end
-      def decimal(s) ::BigDecimal.new(s) end
-      def date(s) ::Sequel.string_to_date(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-      def timestamp(s) ::Sequel.database_to_application_timestamp(s) end
-      def date_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
-      def time_conv(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
-      def timestamp_conv(s) ::Sequel::MySQL.convert_date_time(:database_to_application_timestamp, s) end
     end.new
 
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
     {
-      [0, 246]  => tt.method(:decimal),
-      [2, 3, 8, 9, 13, 247, 248]  => tt.method(:integer),
-      [4, 5]  => tt.method(:float),
-      [249, 250, 251, 252]  => tt.method(:blob)
+      [0, 246] => ::BigDecimal.method(:new),
+      [2, 3, 8, 9, 13, 247, 248] => tt.method(:integer),
+      [4, 5] => tt.method(:float),
+      [249, 250, 251, 252] => ::Sequel::SQL::Blob.method(:new)
     }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
 
-    # Modify the type translator used for the tinyint type based
-    # on the value given.
-    def self.convert_tinyint_to_bool=(v)
-      MYSQL_TYPES[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
-      @convert_tinyint_to_bool = v
-    end
-    self.convert_tinyint_to_bool = convert_tinyint_to_bool
-
     class << self
-      # By default, Sequel raises an exception if in invalid date or time is used.
-      # However, if this is set to nil or :nil, the adapter treats dates
-      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
-      # it returns the strings as is.  
-      attr_reader :convert_invalid_date_time
-    end
-
-    # Modify the type translators for the date, time, and timestamp types
-    # depending on the value given.
-    def self.convert_invalid_date_time=(v)
-      MYSQL_TYPES[11] = TYPE_TRANSLATOR.method(v == false ? :time : :time_conv)
-      m = TYPE_TRANSLATOR.method(v == false ? :date : :date_conv)
-      [10, 14].each{|i| MYSQL_TYPES[i] = m}
-      m = TYPE_TRANSLATOR.method(v == false ? :timestamp : :timestamp_conv)
-      [7, 12].each{|i| MYSQL_TYPES[i] = m}
-      @convert_invalid_date_time = v
+      # Whether to convert invalid date time values by default.
+      #
+      # Only applies to Sequel::Database instances created after this
+      # has been set.
+      attr_accessor :convert_invalid_date_time
     end
     self.convert_invalid_date_time = false
 
-    # If convert_invalid_date_time is nil, :nil, or :string and
-    # the conversion raises an InvalidValue exception, return v
-    # if :string and nil otherwise.
-    def self.convert_date_time(meth, v)
-      begin
-        Sequel.send(meth, v)
-      rescue InvalidValue
-        case @convert_invalid_date_time
-        when nil, :nil
-          nil
-        when :string
-          v
-        else 
-          raise
-        end
-      end
-    end
-  
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods
       
       # Mysql::Error messages that indicate the current connection should be disconnected
       MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|Lost connection to MySQL server during query)/
+       
+      # Regular expression used for getting accurate number of rows
+      # matched by an update statement.
+      AFFECTED_ROWS_RE = /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/.freeze
       
       set_adapter_scheme :mysql
+
+      # Hash of conversion procs for the current database
+      attr_reader :conversion_procs
+      #
+      # Whether to convert tinyint columns to bool for the current database
+      attr_reader :convert_tinyint_to_bool
+
+      # By default, Sequel raises an exception if in invalid date or time is used.
+      # However, if this is set to nil or :nil, the adapter treats dates
+      # like 0000-00-00 and times like 838:00:00 as nil values.  If set to :string,
+      # it returns the strings as is.
+      attr_reader :convert_invalid_date_time
       
-      # Support stored procedures on MySQL
-      def call_sproc(name, opts={}, &block)
-        args = opts[:args] || [] 
-        execute("CALL #{name}#{args.empty? ? '()' : literal(args)}", opts.merge(:sproc=>false), &block)
+      def initialize(opts={})
+        super
+        @conversion_procs = MYSQL_TYPES.dup
+        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+        self.convert_invalid_date_time = Sequel::MySQL.convert_invalid_date_time
       end
-      
+
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
@@ -139,52 +112,57 @@ module Sequel
           opts[:user],
           opts[:password],
           opts[:database],
-          opts[:port],
+          (opts[:port].to_i if opts[:port]),
           opts[:socket],
           Mysql::CLIENT_MULTI_RESULTS +
           Mysql::CLIENT_MULTI_STATEMENTS +
           (opts[:compress] == false ? 0 : Mysql::CLIENT_COMPRESS)
         )
-        sqls = []
+        sqls = mysql_connection_setting_sqls
+
         # Set encoding a slightly different way after connecting,
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
-        sqls << "SET NAMES #{literal(encoding.to_s)}" if encoding
-
-        # Increase timeout so mysql server doesn't disconnect us
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
+        sqls.unshift("SET NAMES #{literal(encoding.to_s)}") if encoding
 
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
-        class << conn
-          attr_accessor :prepared_statements
-        end
-        conn.prepared_statements = {}
+        add_prepared_statements_cache(conn)
         conn
       end
       
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        MySQL::Dataset.new(self, opts)
+      # Modify the type translators for the date, time, and timestamp types
+      # depending on the value given.
+      def convert_invalid_date_time=(v)
+        m0 = ::Sequel.method(:string_to_time)
+        @conversion_procs[11] = (v != false) ?  lambda{|v| convert_date_time(v, &m0)} : m0
+        m1 = ::Sequel.method(:string_to_date) 
+        m = (v != false) ? lambda{|v| convert_date_time(v, &m1)} : m1
+        [10, 14].each{|i| @conversion_procs[i] = m}
+        m2 = method(:to_application_timestamp)
+        m = (v != false) ? lambda{|v| convert_date_time(v, &m2)} : m2
+        [7, 12].each{|i| @conversion_procs[i] = m}
+        @convert_invalid_date_time = v
       end
-      
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        elsif sql.is_a?(Symbol)
-          execute_prepared_statement(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
+
+      # Modify the type translator used for the tinyint type based
+      # on the value given.
+      def convert_tinyint_to_bool=(v)
+        @conversion_procs[1] = TYPE_TRANSLATOR.method(v ? :boolean : :integer)
+        @convert_tinyint_to_bool = v
       end
-      
+
+      # Return the number of matched rows when executing a delete/update statement.
+      def execute_dui(sql, opts={})
+        execute(sql, opts){|c| return affected_rows(c)}
+      end
+
+      # Return the last inserted id when executing an insert statement.
+      def execute_insert(sql, opts={})
+        execute(sql, opts){|c| return c.insert_id}
+      end
+
       # Return the version of the MySQL server two which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
@@ -197,7 +175,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
@@ -220,7 +198,7 @@ module Sequel
             end
           end
         rescue Mysql::Error => e
-          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+          raise_error(e)
         ensure
           r.free if r
           # Use up all results to avoid a commands out of sync message.
@@ -239,15 +217,51 @@ module Sequel
         end
       end
       
+      # Try to get an accurate number of rows matched using the query
+      # info.  Fall back to affected_rows if there was no match, but
+      # that may be inaccurate.
+      def affected_rows(conn)
+        s = conn.info
+        if s && s =~ AFFECTED_ROWS_RE
+          $1.to_i
+        else
+          conn.affected_rows
+        end
+      end
+
       # MySQL connections use the query method to execute SQL without a result
       def connection_execute_method
         :query
       end
       
+      # If convert_invalid_date_time is nil, :nil, or :string and
+      # the conversion raises an InvalidValue exception, return v
+      # if :string and nil otherwise.
+      def convert_date_time(v)
+        begin
+          yield v
+        rescue InvalidValue
+          case @convert_invalid_date_time
+          when nil, :nil
+            nil
+          when :string
+            v
+          else 
+            raise
+          end
+        end
+      end
+    
       # The MySQL adapter main error class is Mysql::Error
       def database_error_classes
         [Mysql::Error]
       end
+
+      # Raise a disconnect error if the exception message matches the list
+      # of recognized exceptions.
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::Mysql::Error) && MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+      end
       
       # The database name when using the native adapter is always stored in
       # the :database option.
@@ -262,114 +276,31 @@ module Sequel
         nil
       end
       
-      # Executes a prepared statement on an available connection.  If the
-      # prepared statement already exists for the connection and has the same
-      # SQL, reuse it, otherwise, prepare the new statement.  Because of the
-      # usual MySQL stupidity, we are forced to name arguments via separate
-      # SET queries.  Use @sequel_arg_N (for N starting at 1) for these
-      # arguments.
-      def execute_prepared_statement(ps_name, opts, &block)
-        args = opts[:arguments]
-        ps = prepared_statements[ps_name]
-        sql = ps.prepared_sql
-        synchronize(opts[:server]) do |conn|
-          unless conn.prepared_statements[ps_name] == sql
-            conn.prepared_statements[ps_name] = sql
-            _execute(conn, "PREPARE #{ps_name} FROM '#{::Mysql.quote(sql)}'", opts)
-          end
-          i = 0
-          _execute(conn, "SET " + args.map {|arg| "@sequel_arg_#{i+=1} = #{literal(arg)}"}.join(", "), opts) unless args.empty?
-          _execute(conn, "EXECUTE #{ps_name}#{" USING #{(1..i).map{|j| "@sequel_arg_#{j}"}.join(', ')}" unless i == 0}", opts, &block)
-        end
-      end
-      
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+        convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
       end
     end
     
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
-      include StoredProcedures
-      
-      # Methods to add to MySQL prepared statement calls without using a
-      # real database prepared statement and bound variables.
-      module CallableStatementMethods
-        # Extend given dataset with this module so subselects inside subselects in
-        # prepared statements work.
-        def subselect_sql(ds)
-          ps = ds.to_prepared_statement(:select)
-          ps.extend(CallableStatementMethods)
-          ps = ps.bind(@opts[:bind_vars]) if @opts[:bind_vars]
-          ps.prepared_args = prepared_args
-          ps.prepared_sql
-        end
-      end
-      
-      # Methods for MySQL prepared statements using the native driver.
-      module PreparedStatementMethods
-        include Sequel::Dataset::UnnumberedArgumentMapper
-        
-        private
-        
-        # Execute the prepared statement with the bind arguments instead of
-        # the given SQL.
-        def execute(sql, opts={}, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
-          super(prepared_statement_name, {:arguments=>bind_arguments}.merge(opts), &block)
-        end
-      end
-      
-      # Methods for MySQL stored procedures using the native driver.
-      module StoredProcedureMethods
-        include Sequel::Dataset::StoredProcedureMethods
-        
-        private
-        
-        # Execute the database stored procedure with the stored arguments.
-        def execute(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-        
-        # Same as execute, explicit due to intricacies of alias and super.
-        def execute_dui(sql, opts={}, &block)
-          super(@sproc_name, {:args=>@sproc_args, :sproc=>true}.merge(opts), &block)
-        end
-      end
-      
-      # MySQL is different in that it supports prepared statements but not bound
-      # variables outside of prepared statements.  The default implementation
-      # breaks the use of subselects in prepared statements, so extend the
-      # temporary prepared statement that this creates with a module that
-      # fixes it.
-      def call(type, bind_arguments={}, *values, &block)
-        ps = to_prepared_statement(type, values)
-        ps.extend(CallableStatementMethods)
-        ps.call(bind_arguments, &block)
-      end
-      
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
-      
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
+
+      Database::DatasetClass = self
+
       # Yield all rows matching this dataset.  If the dataset is set to
       # split multiple statements, yield arrays of hashes one per statement
       # instead of yielding results for all statements as hashes.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |r|
           i = -1
+          cps = db.conversion_procs
           cols = r.fetch_fields.map do |f| 
             # Pretend tinyint is another integer type if its length is not 1, to
             # avoid casting to boolean if Sequel::MySQL.convert_tinyint_to_bool
             # is set.
-            type_proc = f.type == 1 && f.length != 1 ? MYSQL_TYPES[2] : MYSQL_TYPES[f.type]
+            type_proc = f.type == 1 && f.length != 1 ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
           @columns = cols.map{|c| c.first}
@@ -378,7 +309,7 @@ module Sequel
             yield_rows(r, cols){|h| s << h}
             yield s
           else
-            yield_rows(r, cols, &block)
+            yield_rows(r, cols){|h| yield h}
           end
         end
         self
@@ -390,28 +321,6 @@ module Sequel
         super
       end
       
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.insert_id}
-      end
-      
-      # Store the given type of prepared statement in the associated database
-      # with the given name.
-      def prepare(type, name=nil, *values)
-        ps = to_prepared_statement(type, values)
-        ps.extend(PreparedStatementMethods)
-        if name
-          ps.prepared_statement_name = name
-          db.prepared_statements[name] = ps
-        end
-        ps
-      end
-      
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.insert_id}
-      end
-      
       # Makes each yield arrays of rows, with each array containing the rows
       # for a given result set.  Does not work with graphing.  So you can submit
       # SQL with multiple statements and easily determine which statement
@@ -428,11 +337,6 @@ module Sequel
         ds
       end
       
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
-      end
-      
       private
       
       # Set the :type option to :select if it hasn't been set.
@@ -440,19 +344,11 @@ module Sequel
         super(sql, {:type=>:select}.merge(opts), &block)
       end
       
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-      
       # Handle correct quoting of strings using ::MySQL.quote.
-      def literal_string(v)
-        "'#{::Mysql.quote(v)}'"
-      end
-      
-      # Extend the dataset with the MySQL stored procedure methods.
-      def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
+      def literal_string_append(sql, v)
+        sql << "'"
+        sql << ::Mysql.quote(v)
+        sql << "'"
       end
       
       # Yield each row of the given result set r with columns cols

data/lib/sequel/adapters/mysql2.rb

@@ -1,6 +1,5 @@
-require 'mysql2' unless defined? Mysql2
-
-Sequel.require %w'shared/mysql', 'adapters'
+require 'mysql2'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all Mysql2-related classes and modules for Sequel.
@@ -8,11 +7,21 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
       # Mysql::Error messages that indicate the current connection should be disconnected
-      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away)/
+      MYSQL_DATABASE_DISCONNECT_ERRORS = /\A(Commands out of sync; you can't run this command now|Can't connect to local MySQL server through socket|MySQL server has gone away|This connection is still waiting for a result, try again once you have the result|closed MySQL connection)/
 
       set_adapter_scheme :mysql2
+      
+      # Whether to convert tinyint columns to bool for this database
+      attr_accessor :convert_tinyint_to_bool
+
+      # Set the convert_tinyint_to_bool setting based on the default value.
+      def initialize(opts={})
+        super
+        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+      end
 
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
@@ -21,7 +30,6 @@ module Sequel
       #   a filter for an autoincrement column equals NULL to return the last
       #   inserted row.
       # * :charset - Same as :encoding (:encoding takes precendence)
-      # * :compress - Set to false to not compress results from the server
       # * :config_default_group - The default group to read from the in
       #   the MySQL config file.
       # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
@@ -37,42 +45,33 @@ module Sequel
         opts = server_opts(server)
         opts[:host] ||= 'localhost'
         opts[:username] ||= opts[:user]
+        opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
 
-        sqls = []
+        sqls = mysql_connection_setting_sqls
+
         # Set encoding a slightly different way after connecting,
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
         if encoding = opts[:encoding] || opts[:charset]
-          sqls << "SET NAMES #{conn.escape(encoding.to_s)}"
+          sqls.unshift("SET NAMES #{conn.escape(encoding.to_s)}")
         end
 
-        # Increase timeout so mysql server doesn't disconnect us.
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
-
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
+        add_prepared_statements_cache(conn)
         conn
       end
 
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        Mysql2::Dataset.new(self, opts)
+      # Return the number of matched rows when executing a delete/update statement.
+      def execute_dui(sql, opts={})
+        execute(sql, opts){|c| return c.affected_rows}
       end
 
-      # Executes the given SQL using an available connection, yielding the
-      # connection if the block is given.
-      def execute(sql, opts={}, &block)
-        if opts[:sproc]
-          call_sproc(sql, opts, &block)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
+      # Return the last inserted id when executing an insert statement.
+      def execute_insert(sql, opts={})
+        execute(sql, opts){|c| return c.last_id}
       end
 
       # Return the version of the MySQL server two which we are connecting.
@@ -87,14 +86,14 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => Sequel.database_timezone, :application_timezone => Sequel.application_timezone)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :symbolize_keys => true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
             yield conn
           end
         rescue ::Mysql2::Error => e
-          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+          raise_error(e)
         end
       end
 
@@ -108,6 +107,17 @@ module Sequel
         [::Mysql2::Error]
       end
 
+      # If a connection object is available, try pinging it.  Otherwise, if the
+      # error is a Mysql2::Error, check the SQL state and exception message for
+      # disconnects.
+      def disconnect_error?(e, opts)
+        super ||
+          ((conn = opts[:conn]) && !conn.ping) ||
+          (e.is_a?(::Mysql2::Error) &&
+            (e.sql_state =~ /\A08/ ||
+             MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)))
+      end
+
       # The database name when using the native adapter is always stored in
       # the :database option.
       def database_name
@@ -121,43 +131,39 @@ module Sequel
 
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
-        Sequel::MySQL.convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
+        convert_tinyint_to_bool && db_type == 'tinyint(1)' ? :boolean : super
       end
     end
 
     # Dataset class for MySQL datasets accessed via the native driver.
     class Dataset < Sequel::Dataset
       include Sequel::MySQL::DatasetMethods
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
 
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
+      Database::DatasetClass = self
 
       # Yield all rows matching this dataset.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |r|
-          @columns = r.fields
-          r.each(:cast_booleans => Sequel::MySQL.convert_tinyint_to_bool, &block)
+          if identifier_output_method
+            cols = r.fields
+            @columns = cols2 = cols.map{|c| output_identifier(c.to_s)}
+            cs = cols.zip(cols2)
+            r.each(:cast_booleans => db.convert_tinyint_to_bool) do |row|
+              h = {}
+              cs.each do |a, b|
+                h[b] = row[a]
+              end
+              yield h
+            end
+          else
+            @columns = r.fields
+            r.each(:cast_booleans => db.convert_tinyint_to_bool){|h| yield h}
+          end
         end
         self
       end
 
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.last_id}
-      end
-
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.last_id}
-      end
-
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
-      end
-
       private
 
       # Set the :type option to :select if it hasn't been set.
@@ -165,14 +171,9 @@ module Sequel
         super(sql, {:type=>:select}.merge(opts), &block)
       end
 
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape(v)}'"}
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
       end
     end
   end