sequel 3.21.0 → 3.28.0

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

@@ -16,11 +16,6 @@ module Sequel
         
         include Sequel::MSSQL::DatabaseMethods
         
-        # Return instance of Sequel::JDBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::JDBC::MSSQL::Dataset.new(self, opts)
-        end
-        
         private
         
         # Get the last inserted id using SCOPE_IDENTITY().
@@ -43,33 +38,6 @@ module Sequel
         def primary_key_index_re
           PRIMARY_KEY_INDEX_RE
         end
-
-        def metadata_dataset
-          ds = super
-          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
-          # for the getColumns result set specifies an incorrect type for the
-          # IS_AUTOINCREMENT column. The column is a string, but the type is
-          # specified as a short. This causes getObject() to throw a
-          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
-          # from char to SMALLINT is unsupported." Using getString() rather
-          # than getObject() for this column avoids the problem.
-          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
-          def ds.result_set_object_getter
-            lambda do |result, n, i|
-              if n == :is_autoincrement
-                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
-              else
-                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
-              end
-            end
-          end
-          ds
-        end
-      end
-      
-      # Dataset class for MSSQL datasets accessed via JDBC.
-      class Dataset < JDBC::Dataset
-        include Sequel::MSSQL::DatasetMethods
       end
     end
   end

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

@@ -56,6 +56,15 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          statement(conn){|s| log_yield(sql){s.execute(sql)}} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via JDBC.

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

@@ -1,4 +1,5 @@
 Sequel.require 'adapters/shared/oracle'
+Sequel.require 'adapters/jdbc/transactions'
 
 module Sequel
   module JDBC
@@ -7,38 +8,12 @@ module Sequel
       # Instance methods for Oracle Database objects accessed via JDBC.
       module DatabaseMethods
         include Sequel::Oracle::DatabaseMethods
-        TRANSACTION_BEGIN = 'Transaction.begin'.freeze
-        TRANSACTION_COMMIT = 'Transaction.commit'.freeze
-        TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+        include Sequel::JDBC::Transactions
         
         # Return Sequel::JDBC::Oracle::Dataset object with the given opts.
         def dataset(opts=nil)
           Sequel::JDBC::Oracle::Dataset.new(self, opts)
         end
-        
-        private
-        
-        # Use JDBC connection's setAutoCommit to false to start transactions
-        def begin_transaction(conn, opts={})
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
-          conn
-        end
-        
-        # Use JDBC connection's commit method to commit transactions
-        def commit_transaction(conn, opts={})
-          log_yield(TRANSACTION_COMMIT){conn.commit}
-        end
-        
-        # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
-        def remove_transaction(conn)
-          conn.setAutoCommit(true) if conn
-          @transactions.delete(Thread.current)
-        end
-        
-        # Use JDBC connection's rollback method to rollback transactions
-        def rollback_transaction(conn, opts={})
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
-        end
       end
       
       # Dataset class for Oracle datasets accessed via JDBC.

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

@@ -60,6 +60,12 @@ module Sequel
         
         private
         
+        # Use setNull for nil arguments as the default behavior of setString
+        # with nil doesn't appear to work correctly on PostgreSQL.
+        def set_ps_arg(cps, arg, i)
+          arg.nil? ? cps.setNull(i, JavaSQL::Types::NULL) : super
+        end
+
         # Extend the adapter with the JDBC PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)

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

@@ -0,0 +1,46 @@
+Sequel.require 'adapters/jdbc/mssql'
+
+module Sequel
+  module JDBC
+    # Database and Dataset instance methods for SQLServer specific
+    # support via JDBC.
+    module SQLServer
+      # Database instance methods for SQLServer databases accessed via JDBC.
+      module DatabaseMethods
+        include Sequel::JDBC::MSSQL::DatabaseMethods
+        
+        # Return instance of Sequel::JDBC::SQLServer::Dataset with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::SQLServer::Dataset.new(self, opts)
+        end
+        
+        def metadata_dataset
+          ds = super
+          # Work around a bug in SQL Server JDBC Driver 3.0, where the metadata
+          # for the getColumns result set specifies an incorrect type for the
+          # IS_AUTOINCREMENT column. The column is a string, but the type is
+          # specified as a short. This causes getObject() to throw a
+          # com.microsoft.sqlserver.jdbc.SQLServerException: "The conversion
+          # from char to SMALLINT is unsupported." Using getString() rather
+          # than getObject() for this column avoids the problem.
+          # Reference: http://social.msdn.microsoft.com/Forums/en/sqldataaccess/thread/20df12f3-d1bf-4526-9daa-239a83a8e435
+          def ds.result_set_object_getter
+            lambda do |result, n, i|
+              if n == :is_autoincrement
+                @convert_types ? convert_type(result.getString(i)) : result.getString(i)
+              else
+                @convert_types ? convert_type(result.getObject(i)) : result.getObject(i)
+              end
+            end
+          end
+          ds
+        end
+      end
+      
+      # Dataset class for SQLServer datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        include Sequel::MSSQL::DatasetMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Sequel
+  module JDBC
+    module Transactions
+      TRANSACTION_BEGIN = 'Transaction.begin'.freeze
+      TRANSACTION_COMMIT = 'Transaction.commit'.freeze
+      TRANSACTION_ROLLBACK = 'Transaction.rollback'.freeze
+
+      private
+
+      # Use JDBC connection's setAutoCommit to false to start transactions
+      def begin_transaction(conn, opts={})
+        log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+        conn
+      end
+      
+      # Use JDBC connection's commit method to commit transactions
+      def commit_transaction(conn, opts={})
+        log_yield(TRANSACTION_COMMIT){conn.commit}
+      end
+      
+      # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
+      def remove_transaction(conn)
+        conn.setAutoCommit(true) if conn
+        @transactions.delete(Thread.current)
+      end
+      
+      # Use JDBC connection's rollback method to rollback transactions
+      def rollback_transaction(conn, opts={})
+        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+      end
+    end
+  end
+end
+

data/lib/sequel/adapters/jdbc.rb

@@ -53,13 +53,15 @@ module Sequel
         Java::oracle.jdbc.driver.OracleDriver
       end,
       :sqlserver=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/sqlserver'
+        db.extend(Sequel::JDBC::SQLServer::DatabaseMethods)
+        db.send(:set_mssql_unicode_strings)
         com.microsoft.sqlserver.jdbc.SQLServerDriver
       end,
       :jtds=>proc do |db|
-        Sequel.ts_require 'adapters/jdbc/mssql'
-        db.extend(Sequel::JDBC::MSSQL::DatabaseMethods)
+        Sequel.ts_require 'adapters/jdbc/jtds'
+        db.extend(Sequel::JDBC::JTDS::DatabaseMethods)
+        db.send(:set_mssql_unicode_strings)
         JDBC.load_gem('jtds')
         Java::net.sourceforge.jtds.jdbc.Driver
       end,
@@ -73,6 +75,21 @@ module Sequel
         Sequel.ts_require 'adapters/jdbc/as400'
         db.extend(Sequel::JDBC::AS400::DatabaseMethods)
         com.ibm.as400.access.AS400JDBCDriver
+      end,
+      :"informix-sqli"=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/informix'
+        db.extend(Sequel::JDBC::Informix::DatabaseMethods)
+        com.informix.jdbc.IfxDriver
+      end,
+      :db2=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/db2'
+        db.extend(Sequel::JDBC::DB2::DatabaseMethods)
+        com.ibm.db2.jcc.DB2Driver
+      end,
+      :firebirdsql=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/firebird'
+        db.extend(Sequel::JDBC::Firebird::DatabaseMethods)
+        org.firebirdsql.jdbc.FBDriver
       end
     }
     
@@ -101,7 +118,7 @@ module Sequel
       # True by default, can be set to false to roughly double performance when
       # fetching rows.
       attr_accessor :convert_types
-      
+
       # Call the DATABASE_SETUP proc directly after initialization,
       # so the object always uses sub adapter specific code.  Also,
       # raise an error immediately if the connection doesn't have a
@@ -246,12 +263,14 @@ module Sequel
         indexes
       end 
 
+      # Whether or not JNDI is being used for this connection.
+      def jndi?
+        !!(uri =~ JNDI_URI_REGEXP)
+      end
+      
       # All tables in this database
       def tables(opts={})
-        ts = []
-        m = output_identifier_meth
-        metadata(:getTables, nil, nil, nil, ['TABLE'].to_java(:string)){|h| ts << m.call(h[:table_name])}
-        ts
+        get_tables('TABLE', opts)
       end
       
       # The uri for this connection.  You can specify the uri
@@ -264,11 +283,11 @@ module Sequel
         ur =~ /^\Ajdbc:/ ? ur : "jdbc:#{ur}"
       end
 
-      # Whether or not JNDI is being used for this connection.
-      def jndi?
-        !!(uri =~ JNDI_URI_REGEXP)
+      # All views in this database
+      def views(opts={})
+        get_tables('VIEW', opts)
       end
-      
+
       private
          
       # Close given adapter connections
@@ -276,6 +295,12 @@ module Sequel
         c.close
       end
       
+      # Raise a disconnect error if the SQL state of the cause of the exception indicates so.
+      def disconnect_error?(exception, opts)
+        cause = exception.respond_to?(:cause) ? exception.cause : exception
+        super || (cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/)
+      end
+
       # Execute the prepared statement.  If the provided name is a
       # dataset, use that as the prepared statement, otherwise use
       # it as a key to look it up in the prepared_statements hash.
@@ -325,6 +350,12 @@ module Sequel
         end
       end
 
+      # Gets the connection from JNDI.
+      def get_connection_from_jndi
+        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
+        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      end
+            
       # Gets the JDBC connection uri from the JNDI resource.
       def get_uri_from_jndi
         conn = get_connection_from_jndi
@@ -333,12 +364,14 @@ module Sequel
         conn.close if conn
       end
       
-      # Gets the connection from JNDI.
-      def get_connection_from_jndi
-        jndi_name = JNDI_URI_REGEXP.match(uri)[1]
-        JavaxNaming::InitialContext.new.lookup(jndi_name).connection
+      # Backbone of the tables and views support.
+      def get_tables(type, opts)
+        ts = []
+        m = output_identifier_meth
+        metadata(:getTables, nil, nil, nil, [type].to_java(:string)){|h| ts << m.call(h[:table_name])}
+        ts
       end
-            
+
       # Support Date objects used in bound variables
       def java_sql_date(date)
         java.sql.Date.new(Time.local(date.year, date.month, date.day).to_i * 1000)
@@ -383,12 +416,6 @@ module Sequel
         end
       end
 
-      # Treat SQLExceptions with a "Connection Error" SQLState as disconnects
-      def raise_error(exception, opts={})
-        cause = exception.respond_to?(:cause) ? exception.cause : exception
-        super(exception, {:disconnect => cause.respond_to?(:getSQLState) && cause.getSQLState =~ /^08/}.merge(opts))
-      end
-
       # Java being java, you need to specify the type of each argument
       # for the prepared statement, and bind it individually.  This
       # guesses which JDBC method to use, and hopefully JRuby will convert
@@ -405,8 +432,8 @@ module Sequel
           cps.setDouble(i, arg)
         when TrueClass, FalseClass
           cps.setBoolean(i, arg)
-        when nil
-          cps.setNull(i, JavaSQL::Types::NULL)
+        when NilClass
+          cps.setString(i, nil)
         when DateTime
           cps.setTimestamp(i, java_sql_datetime(arg))
         when Date
@@ -444,9 +471,11 @@ module Sequel
         table = im.call(table)
         pks, ts = [], []
         metadata(:getPrimaryKeys, nil, schema, table) do |h|
+          next if h[:table_schem] == 'INFORMATION_SCHEMA'
           pks << h[:column_name]
         end
         metadata(:getColumns, nil, schema, table, nil) do |h|
+          next if h[:table_schem] == 'INFORMATION_SCHEMA'
           s = {: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]), :column_size=>h[:column_size], :scale=>h[:decimal_digits]}
           if s[:db_type] =~ DECIMAL_TYPE_RE && s[:scale] == 0
             s[:type] = :integer
@@ -530,8 +559,8 @@ module Sequel
       # Uses the database's setting by default, can be set to false to roughly
       # double performance when fetching rows.
       attr_accessor :convert_types
-      
-      # Use the convert_types default setting from the database
+
+      # Use the convert_types default setting from the database.
       def initialize(db, opts={})
         @convert_types = db.convert_types
         super
@@ -560,8 +589,10 @@ module Sequel
       # Convert the type.  Used for converting Java types to ruby types.
       def convert_type(v)
         case v
-        when Java::JavaSQL::Timestamp, Java::JavaSQL::Time
+        when Java::JavaSQL::Timestamp
           Sequel.database_to_application_timestamp(v.to_string)
+        when Java::JavaSQL::Time
+          Sequel.string_to_time(v.to_string)
         when Java::JavaSQL::Date
           Sequel.string_to_date(v.to_string)
         when Java::JavaIo::BufferedReader
@@ -574,6 +605,8 @@ module Sequel
           Sequel::SQL::Blob.new(String.from_java_bytes(v))
         when Java::JavaSQL::Blob
           convert_type(v.getBytes(1, v.length))
+        when Java::JavaSQL::Clob
+          Sequel::SQL::Blob.new(v.getSubString(1, v.length))
         else
           v
         end

data/lib/sequel/adapters/mysql.rb

@@ -5,32 +5,27 @@ 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
+      def date(s) ::Sequel::MySQL.convert_date_time(:string_to_date, s) end
+      def time(s) ::Sequel::MySQL.convert_date_time(:string_to_time, s) end
+      def timestamp(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
@@ -54,10 +49,10 @@ module Sequel
     # 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)
+      MYSQL_TYPES[11] = (v != false) ?  TYPE_TRANSLATOR.method(:time) : ::Sequel.method(:string_to_time)
+      m = (v != false) ? TYPE_TRANSLATOR.method(:date) : ::Sequel.method(:string_to_date)
       [10, 14].each{|i| MYSQL_TYPES[i] = m}
-      m = TYPE_TRANSLATOR.method(v == false ? :timestamp : :timestamp_conv)
+      m = (v != false) ? TYPE_TRANSLATOR.method(:timestamp) : ::Sequel.method(:database_to_application_timestamp)
       [7, 12].each{|i| MYSQL_TYPES[i] = m}
       @convert_invalid_date_time = v
     end
@@ -84,18 +79,13 @@ 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|Lost connection to MySQL server during query)/
       
       set_adapter_scheme :mysql
       
-      # 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)
-      end
-      
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
       #
@@ -139,7 +129,7 @@ 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 +
@@ -161,10 +151,7 @@ module Sequel
 
         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
       
@@ -173,18 +160,6 @@ module Sequel
         MySQL::Dataset.new(self, opts)
       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
-      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)
@@ -220,7 +195,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.
@@ -248,6 +223,12 @@ module Sequel
       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,27 +243,6 @@ 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
@@ -292,67 +252,7 @@ module Sequel
     # 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
+      include Sequel::MySQL::PreparedStatements::DatasetMethods
       
       # Delete rows matching this dataset
       def delete
@@ -395,18 +295,6 @@ module Sequel
         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}
@@ -450,11 +338,6 @@ module Sequel
         "'#{::Mysql.quote(v)}'"
       end
       
-      # Extend the dataset with the MySQL stored procedure methods.
-      def prepare_extend_sproc(ds)
-        ds.extend(StoredProcedureMethods)
-      end
-      
       # Yield each row of the given result set r with columns cols
       # as a hash with symbol keys
       def yield_rows(r, cols)