sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/mysql.rb

@@ -1,57 +1,44 @@
 # frozen-string-literal: true
 
-begin
-  require "mysqlplus"
-rescue LoadError
-  require 'mysql'
-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)
+require 'mysql'
+raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!, so it not supported. Please install the mysql or ruby-mysql gem.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
-Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
+require_relative 'utils/mysql_mysql2'
+require_relative 'utils/mysql_prepared_statements'
 
 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 integer(s) s.to_i end
-      def float(s) s.to_f end
-    end.new
+    boolean = Object.new
+    def boolean.call(s) s.to_i != 0 end
+    TYPE_TRANSLATOR_BOOLEAN = boolean.freeze
+    integer = Object.new
+    def integer.call(s) s.to_i end
+    TYPE_TRANSLATOR_INTEGER = integer.freeze
+    float = Object.new
+    def float.call(s) s.to_f end
 
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
     {
-      [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)
+      [0, 246] => ::Kernel.method(:BigDecimal),
+      [2, 3, 8, 9, 13, 247, 248] => integer,
+      [4, 5] => float,
+      [249, 250, 251, 252] => ::Sequel::SQL::Blob
     }.each do |k,v|
       k.each{|n| MYSQL_TYPES[n] = v}
     end
+    MYSQL_TYPES.freeze
 
-    class << self
-      # 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
-
-    # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
+      include Sequel::MySQL::MysqlMysql2::DatabaseMethods
       include Sequel::MySQL::PreparedStatements::DatabaseMethods
       
-      # 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
 
@@ -84,21 +71,43 @@ module Sequel
       #             disconnect this connection (a.k.a @@wait_timeout).
       def connect(server)
         opts = server_opts(server)
-        conn = Mysql.init
-        conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
-        conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
-        conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]
-        if encoding = opts[:encoding] || opts[:charset]
-          # Set encoding before connecting so that the mysql driver knows what
-          # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
-          conn.options(Mysql::SET_CHARSET_NAME, encoding)
-        end
-        if read_timeout = opts[:read_timeout] and defined? Mysql::OPT_READ_TIMEOUT
-          conn.options(Mysql::OPT_READ_TIMEOUT, read_timeout)
-        end
-        if connect_timeout = opts[:connect_timeout] and defined? Mysql::OPT_CONNECT_TIMEOUT
-          conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
+
+        if Mysql.respond_to?(:init)
+          conn = Mysql.init
+          conn.options(Mysql::READ_DEFAULT_GROUP, opts[:config_default_group] || "client")
+          conn.options(Mysql::OPT_LOCAL_INFILE, opts[:config_local_infile]) if opts.has_key?(:config_local_infile)
+          if encoding = opts[:encoding] || opts[:charset]
+            # Set encoding before connecting so that the mysql driver knows what
+            # encoding we want to use, but this can be overridden by READ_DEFAULT_GROUP.
+            conn.options(Mysql::SET_CHARSET_NAME, encoding)
+          end
+          if read_timeout = opts[:read_timeout] and defined? Mysql::OPT_READ_TIMEOUT
+            conn.options(Mysql::OPT_READ_TIMEOUT, read_timeout)
+          end
+          if connect_timeout = opts[:connect_timeout] and defined? Mysql::OPT_CONNECT_TIMEOUT
+            conn.options(Mysql::OPT_CONNECT_TIMEOUT, connect_timeout)
+          end
+        else
+          # ruby-mysql 3 API
+          conn = Mysql.new
+          # no support for default group
+          conn.local_infile = opts[:config_local_infile] if opts.has_key?(:config_local_infile)
+          if encoding = opts[:encoding] || opts[:charset]
+            conn.charset = encoding
+          end
+          if read_timeout = opts[:read_timeout]
+            conn.read_timeout = read_timeout
+          end
+          if connect_timeout = opts[:connect_timeout]
+            conn.connect_timeout = connect_timeout
+          end
+          conn.singleton_class.class_eval do
+            alias real_connect connect
+            alias use_result store_result
+          end
         end
+
+        conn.ssl_set(opts[:sslkey], opts[:sslcert], opts[:sslca], opts[:sslcapath], opts[:sslcipher]) if opts[:sslca] || opts[:sslkey]
         conn.real_connect(
           opts[:host] || 'localhost',
           opts[:user],
@@ -124,7 +133,6 @@ module Sequel
         conn
       end
       
-      # Closes given database connection.
       def disconnect_connection(c)
         c.close
       rescue Mysql::Error
@@ -148,23 +156,22 @@ module Sequel
       # 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)
+        @conversion_procs[1] = v ? TYPE_TRANSLATOR_BOOLEAN : TYPE_TRANSLATOR_INTEGER
         @convert_tinyint_to_bool = v
       end
 
-      # Return the number of matched rows when executing a delete/update statement.
       def execute_dui(sql, opts=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=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)
+      def freeze
+        server_version
+        @conversion_procs.freeze
+        super
       end
 
       private
@@ -173,53 +180,51 @@ module Sequel
       # option is :select, yield the result of the query, otherwise
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
-        begin
-          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql)}
-          if opts[:type] == :select
-            yield r if r
-          elsif block_given?
-            yield conn
-          end
-          if conn.respond_to?(:more_results?)
-            while conn.more_results? do
-              if r
-                r.free
-                r = nil
-              end
-              begin
-                conn.next_result
-                r = conn.use_result
-              rescue Mysql::Error => e
-                raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
-                break
-              end
-              yield r if opts[:type] == :select
+        r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql)}
+        if opts[:type] == :select
+          yield r if r
+        elsif defined?(yield)
+          yield conn
+        end
+        if conn.respond_to?(:more_results?)
+          while conn.more_results? do
+            if r
+              r.free
+              r = nil
             end
+            begin
+              conn.next_result
+              r = conn.use_result
+            rescue Mysql::Error => e
+              raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
+              break
+            end
+            yield r if opts[:type] == :select
           end
-        rescue Mysql::Error => e
-          raise_error(e)
-        ensure
-          r.free if r
-          # Use up all results to avoid a commands out of sync message.
-          if conn.respond_to?(:more_results?)
-            while conn.more_results? do
-              begin
-                conn.next_result
-                r = conn.use_result
-              rescue Mysql::Error => e
-                raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
-                break
-              end
-              r.free if r
+        end
+      rescue Mysql::Error => e
+        raise_error(e)
+      ensure
+        r.free if r
+        # Use up all results to avoid a commands out of sync message.
+        if conn.respond_to?(:more_results?)
+          while conn.more_results? do
+            begin
+              conn.next_result
+              r = conn.use_result
+            rescue Mysql::Error => e
+              raise_error(e, :disconnect=>true) if MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message)
+              break
             end
+            r.free if r
           end
         end
       end
       
       def adapter_initialize
         @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
+        self.convert_tinyint_to_bool = true
+        self.convert_invalid_date_time = false
       end
 
       # Try to get an accurate number of rows matched using the query
@@ -227,7 +232,7 @@ module Sequel
       # that may be inaccurate.
       def affected_rows(conn)
         s = conn.info
-        if s && s =~ AFFECTED_ROWS_RE
+        if s && s =~ /Rows matched:\s+(\d+)\s+Changed:\s+\d+\s+Warnings:\s+\d+/
           $1.to_i
         else
           conn.affected_rows
@@ -243,21 +248,18 @@ module Sequel
       # 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
+        yield v
+      rescue InvalidValue
+        case @convert_invalid_date_time
+        when nil, :nil
+          nil
+        when :string
+          v
+        else 
+          raise
         end
       end
     
-      # The MySQL adapter main error class is Mysql::Error
       def database_error_classes
         [Mysql::Error]
       end
@@ -266,31 +268,25 @@ module Sequel
         exception.sqlstate
       end
 
-      # Raise a disconnect error if the exception message matches the list
-      # of recognized exceptions.
+      def dataset_class_default
+        Dataset
+      end
+
       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.
-      def database_name
-        @opts[:database]
-      end
-      
       # Convert tinyint(1) type to boolean if convert_tinyint_to_bool is true
       def schema_column_type(db_type)
         convert_tinyint_to_bool && db_type =~ /\Atinyint\(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::MysqlMysql2::DatasetMethods
       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.
@@ -300,8 +296,7 @@ module Sequel
           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.
+            # avoid casting to boolean if convert_tinyint_to_bool is set.
             type_proc = f.type == 1 && cast_tinyint_integer?(f) ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
@@ -335,7 +330,7 @@ module Sequel
       def split_multiple_result_sets
         raise(Error, "Can't split multiple statements on a graphed dataset") if opts[:graph]
         ds = clone(:split_multiple_result_sets=>true)
-        ds.row_proc = proc{|x| x.map{|h| row_proc.call(h)}} if row_proc
+        ds = ds.with_row_proc(proc{|x| x.map{|h| row_proc.call(h)}}) if row_proc
         ds
       end
       
@@ -348,7 +343,6 @@ module Sequel
         field.length != 1
       end
       
-      # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:type] = :select
@@ -357,9 +351,7 @@ module Sequel
       
       # Handle correct quoting of strings using ::MySQL.quote.
       def literal_string_append(sql, v)
-        sql << "'"
-        sql << ::Mysql.quote(v)
-        sql << "'"
+        sql << "'" << ::Mysql.quote(v) << "'"
       end
       
       # Yield each row of the given result set r with columns cols