sequel 5.45.0 → 5.77.0

data/lib/sequel/adapters/mysql.rb

@@ -1,7 +1,7 @@
 # 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)
+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)
 
 require_relative 'utils/mysql_mysql2'
 require_relative 'utils/mysql_prepared_statements'
@@ -29,6 +29,21 @@ module Sequel
     end
     MYSQL_TYPES.freeze
 
+    RUBY_MYSQL_3 = !Mysql.respond_to?(:init)
+    RUBY_MYSQL_4 = RUBY_MYSQL_3 && ::Mysql::VERSION.to_i >= 4
+
+    if RUBY_MYSQL_3
+      class Adapter < ::Mysql
+        alias real_connect connect
+        alias use_result store_result
+        if RUBY_MYSQL_4
+          def initialize(**opts)
+            super(**opts.merge(:cast=>false))
+          end
+        end
+      end
+    end
+
     class Database < Sequel::Database
       include Sequel::MySQL::DatabaseMethods
       include Sequel::MySQL::MysqlMysql2::DatabaseMethods
@@ -71,21 +86,40 @@ 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 !RUBY_MYSQL_3
+          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 = Adapter.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
+          opts[:compress] = false
         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],
@@ -152,56 +186,49 @@ module Sequel
         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
-
       private
       
       # 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
-          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
@@ -233,17 +260,15 @@ 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
     

data/lib/sequel/adapters/mysql2.rb

@@ -86,20 +86,26 @@ module Sequel
       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)
+          if ps_name.is_a?(Sequel::Dataset::ArgumentMapper)
+            ps = ps_name
+            ps_name = ps.prepared_statement_name
+          else
+            ps = prepared_statement(ps_name) 
+          end
           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)}
+              stmt = log_connection_yield("Preparing #{ps_name}: #{sql}", conn){conn.prepare(sql)}
               conn.prepared_statements[ps_name] = [stmt, sql]
             end
 
-            if ps.log_sql
-              opts = Hash[opts]
-              opts = opts[:log_sql] = " (#{sql})"
+            opts = Hash[opts]
+            opts[:sql] = "Executing #{ps_name || sql}"
+            if ps_name && ps.log_sql
+              opts[:log_sql] = " (#{sql})"
             end
 
             _execute(conn, stmt, opts, &block)
@@ -111,56 +117,55 @@ 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
-          stream = opts[:stream]
-          if NativePreparedStatements
-            if args = opts[:arguments]
-              args = args.map{|arg| bound_variable_value(arg)}
-            end
+        stream = opts[: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
+          case sql
+          when ::Mysql2::Statement
+            stmt = sql
+            sql = opts[: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
+        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
-          if opts[:type] == :select
-            if r
-              if stream
-                begin
-                  r2 = yield r
-                ensure
-                  # If r2 is nil, it means the block did not exit normally,
-                  # so the rest of the results must be drained to prevent
-                  # "commands out of sync" errors.
-                  r.each{} unless r2
-                end
-              else
-                yield r
+        end
+        if opts[:type] == :select
+          if r
+            if stream
+              begin
+                r2 = yield r
+              ensure
+                # If r2 is nil, it means the block did not exit normally,
+                # so the rest of the results must be drained to prevent
+                # "commands out of sync" errors.
+                r.each{} unless r2
               end
+            else
+              yield r
             end
-          elsif block_given?
-            yield conn
-          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
+        elsif defined?(yield)
+          yield conn
+        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
 
@@ -177,8 +182,8 @@ module Sequel
             1
           when false
             0
-          when DateTime, Time
-            literal(arg)[1...-1]
+          when Time, Date
+            @default_dataset.literal_date_or_time(arg, true)
           else
             arg
           end
@@ -244,7 +249,7 @@ module Sequel
       # it hasn't been disabled.
       def paged_each(opts=OPTS, &block)
         if STREAMING_SUPPORTED && opts[:stream] != false
-          unless block_given?
+          unless defined?(yield)
             return enum_for(:paged_each, opts)
           end
           stream.each(&block)

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

@@ -43,7 +43,7 @@ module Sequel
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation, but allow for millisecond precision.
         def default_timestamp_format
-          "{ts '%Y-%m-%d %H:%M:%S%N'}"
+          "{ts '%Y-%m-%d %H:%M:%S.%3N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does

data/lib/sequel/adapters/odbc.rb

@@ -40,7 +40,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             r = log_connection_yield(sql, conn){conn.run(sql)}
-            yield(r) if block_given?
+            yield(r) if defined?(yield)
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           ensure

data/lib/sequel/adapters/oracle.rb

@@ -88,11 +88,11 @@ module Sequel
               r = conn.parse(sql)
               args = cursor_bind_params(conn, r, args)
               nr = log_connection_yield(sql, conn, args){r.exec}
-              r = nr unless block_given?
+              r = nr unless defined?(yield)
             else
               r = log_connection_yield(sql, conn){conn.exec(sql)}
             end
-            if block_given?
+            if defined?(yield)
               yield(r)
             elsif type == :insert
               last_insert_id(conn, opts)
@@ -192,7 +192,7 @@ module Sequel
           log_sql << ")"
         end
         r = log_connection_yield(log_sql, conn, args){cursor.exec}
-        if block_given?
+        if defined?(yield)
           yield(cursor)
         elsif type == :insert
           last_insert_id(conn, opts)
@@ -312,6 +312,7 @@ module Sequel
               :char_used => column.char_used?,
               :char_size => column.char_size,
               :data_size => column.data_size,
+              :column_size => column.precision,
               :precision => column.precision,
               :scale => column.scale,
               :fsprecision => column.fsprecision,