sequel 4.26.0 → 5.37.0

data/lib/sequel/adapters/mysql.rb

@@ -1,55 +1,44 @@
-begin
-  require "mysqlplus"
-rescue LoadError
-  require 'mysql'
-end
+# frozen-string-literal: true
+
+require 'mysql'
 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_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
 
@@ -116,13 +105,12 @@ module Sequel
         # that feature.
         sqls.unshift("SET NAMES #{literal(encoding.to_s)}") if encoding
 
-        sqls.each{|sql| log_yield(sql){conn.query(sql)}}
+        sqls.each{|sql| log_connection_yield(sql, conn){conn.query(sql)}}
 
         add_prepared_statements_cache(conn)
         conn
       end
       
-      # Closes given database connection.
       def disconnect_connection(c)
         c.close
       rescue Mysql::Error
@@ -146,21 +134,25 @@ 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 freeze
+        server_version
+        @conversion_procs.freeze
+        super
+      end
+
+      # Return the version of the MySQL server to which we are connecting.
       def server_version(server=nil)
         @server_version ||= (synchronize(server){|conn| conn.server_version if conn.respond_to?(:server_version)} || super)
       end
@@ -172,7 +164,7 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql)}
+          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?
@@ -216,8 +208,8 @@ module Sequel
       
       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
@@ -225,7 +217,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
@@ -255,7 +247,6 @@ module Sequel
         end
       end
     
-      # The MySQL adapter main error class is Mysql::Error
       def database_error_classes
         [Mysql::Error]
       end
@@ -264,31 +255,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.
@@ -298,12 +283,11 @@ 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
-          @columns = cols.map(&:first)
+          self.columns = cols.map(&:first)
           if opts[:split_multiple_result_sets]
             s = []
             yield_rows(r, cols){|h| s << h}
@@ -333,7 +317,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
       
@@ -346,7 +330,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
@@ -355,9 +338,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

data/lib/sequel/adapters/mysql2.rb

@@ -1,13 +1,21 @@
+# frozen-string-literal: true
+
 require 'mysql2'
-Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
+require_relative 'utils/mysql_mysql2'
 
 module Sequel
-  # Module for holding all Mysql2-related classes and modules for Sequel.
   module Mysql2
-    # Database class for MySQL databases used with Sequel.
+    NativePreparedStatements = if ::Mysql2::VERSION >= '0.4'
+      true
+    else
+      require_relative 'utils/mysql_prepared_statements'
+      false
+    end
+
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
-      include Sequel::MySQL::PreparedStatements::DatabaseMethods
+      include Sequel::MySQL::MysqlMysql2::DatabaseMethods
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods unless NativePreparedStatements
 
       set_adapter_scheme :mysql2
       
@@ -28,13 +36,16 @@ module Sequel
       # options such as :local_infile.
       def connect(server)
         opts = server_opts(server)
-        opts[:host] ||= 'localhost'
         opts[:username] ||= opts.delete(:user)
         opts[:flags] ||= 0
         opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         opts[:encoding] ||= opts[:charset]
         conn = ::Mysql2::Client.new(opts)
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
+          
+        if NativePreparedStatements
+          conn.instance_variable_set(:@sequel_default_query_options, conn.query_options.dup)
+        end
 
         sqls = mysql_connection_setting_sqls
 
@@ -46,36 +57,85 @@ module Sequel
           sqls.unshift("SET NAMES #{conn.escape(encoding.to_s)}")
         end
 
-        sqls.each{|sql| log_yield(sql){conn.query(sql)}}
+        sqls.each{|sql| log_connection_yield(sql, conn){conn.query(sql)}}
 
         add_prepared_statements_cache(conn)
         conn
       end
 
-      # Return the number of matched rows when executing a delete/update statement.
       def execute_dui(sql, opts=OPTS)
         execute(sql, opts){|c| return c.affected_rows}
       end
 
-      # Return the last inserted id when executing an insert statement.
       def execute_insert(sql, opts=OPTS)
         execute(sql, opts){|c| return c.last_id}
       end
 
+      def freeze
+        server_version
+        super
+      end
+
       # Return the version of the MySQL server to which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
+      def server_version(_server=nil)
+        @server_version ||= super()
       end
 
       private
 
+      if NativePreparedStatements
+        # Use a native mysql2 prepared statement to implement prepared statements.
+        def execute_prepared_statement(ps_name, opts, &block)
+          ps = prepared_statement(ps_name)
+          sql = ps.prepared_sql
+
+          synchronize(opts[:server]) do |conn|
+            stmt, ps_sql = conn.prepared_statements[ps_name]
+            unless ps_sql == sql
+              stmt.close if stmt
+              stmt = log_connection_yield(conn, "Preparing #{ps_name}: #{sql}"){conn.prepare(sql)}
+              conn.prepared_statements[ps_name] = [stmt, sql]
+            end
+
+            if ps.log_sql
+              opts = Hash[opts]
+              opts = opts[:log_sql] = " (#{sql})"
+            end
+
+            _execute(conn, stmt, opts, &block)
+          end
+        end
+      end
+
       # Execute the given SQL on the given connection.  If the :type
       # option is :select, yield the result of the query, otherwise
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
           stream = opts[:stream]
-          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)}
+          if NativePreparedStatements
+            if args = opts[:arguments]
+              args = args.map{|arg| bound_variable_value(arg)}
+            end
+
+            case sql
+            when ::Mysql2::Statement
+              stmt = sql
+            when Dataset
+              sql = sql.sql
+              close_stmt = true
+              stmt = conn.prepare(sql)
+            end
+          end
+
+          r = log_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn, args) do
+            if stmt
+              conn.query_options.merge!(:cache_rows=>true, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream, :cast_booleans=>convert_tinyint_to_bool)
+              stmt.execute(*args)
+            else
+              conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)
+            end
+          end
           if opts[:type] == :select
             if r
               if stream
@@ -96,26 +156,50 @@ module Sequel
           end
         rescue ::Mysql2::Error => e
           raise_error(e)
+        ensure
+          if stmt
+            conn.query_options.replace(conn.instance_variable_get(:@sequel_default_query_options))
+            stmt.close if close_stmt
+          end
         end
       end
 
       # Set the convert_tinyint_to_bool setting based on the default value.
       def adapter_initialize
-        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+        self.convert_tinyint_to_bool = true
+      end
+
+      if NativePreparedStatements
+        # Handle bound variable arguments that Mysql2 does not handle natively.
+        def bound_variable_value(arg)
+          case arg
+          when true
+            1
+          when false
+            0
+          when DateTime, Time
+            literal(arg)[1...-1]
+          else
+            arg
+          end
+        end
       end
 
-      # MySQL connections use the query method to execute SQL without a result
       def connection_execute_method
         :query
       end
 
-      # The MySQL adapter main error class is Mysql2::Error
       def database_error_classes
         [::Mysql2::Error]
       end
 
       def database_exception_sqlstate(exception, opts)
-        exception.sql_state
+        state = exception.sql_state
+        state unless state == 'HY000'
+      end
+
+      def dataset_class_default
+        Dataset
       end
 
       # If a connection object is available, try pinging it.  Otherwise, if the
@@ -129,42 +213,40 @@ module Sequel
              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::PreparedStatements::DatasetMethods
+      include Sequel::MySQL::MysqlMysql2::DatasetMethods
+      include Sequel::MySQL::PreparedStatements::DatasetMethods unless NativePreparedStatements
       STREAMING_SUPPORTED = ::Mysql2::VERSION >= '0.3.12'
 
-      Database::DatasetClass = self
+      if NativePreparedStatements
+        PreparedStatementMethods = prepared_statements_module(
+          "sql = self; opts = Hash[opts]; opts[:arguments] = bind_arguments",
+          Sequel::Dataset::UnnumberedArgumentMapper,
+          %w"execute execute_dui execute_insert")
+      end
 
-      # Yield all rows matching this dataset.
       def fetch_rows(sql)
         execute(sql) do |r|
-          @columns = if identifier_output_method
-            r.fields.map!{|c| output_identifier(c.to_s)}
-          else
-            r.fields
-          end
+          self.columns = r.fields.map!{|c| output_identifier(c.to_s)}
           r.each(:cast_booleans=>convert_tinyint_to_bool?){|h| yield h}
         end
         self
       end
 
-      # Use streaming to implement paging if Mysql2 supports it.
+      # Use streaming to implement paging if Mysql2 supports it and
+      # it hasn't been disabled.
       def paged_each(opts=OPTS, &block)
-        if STREAMING_SUPPORTED
+        if STREAMING_SUPPORTED && opts[:stream] != false
+          unless block_given?
+            return enum_for(:paged_each, opts)
+          end
           stream.each(&block)
         else
           super
@@ -181,13 +263,12 @@ module Sequel
       private
 
       # Whether to cast tinyint(1) columns to integer instead of boolean.
-      # By default, uses the opposite of the database's convert_tinyint_to_bool
+      # By default, uses the database's convert_tinyint_to_bool
       # setting.  Exists for compatibility with the mysql adapter.
       def convert_tinyint_to_bool?
         @db.convert_tinyint_to_bool
       end
 
-      # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts=OPTS)
         opts = Hash[opts]
         opts[:type] = :select
@@ -195,9 +276,19 @@ module Sequel
         super
       end
 
+      if NativePreparedStatements
+        def bound_variable_modules
+          [PreparedStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
+        end
+      end
+
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
       def literal_string_append(sql, v)
-        sql << APOS << db.synchronize(@opts[:server]){|c| c.escape(v)} << APOS
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(v)} << "'"
       end
     end
   end