sequel 4.36.0 → 5.61.0

data/lib/sequel/adapters/mysql2.rb

@@ -1,15 +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
       
@@ -30,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
 
@@ -54,70 +63,148 @@ module Sequel
         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)
+          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("Preparing #{ps_name}: #{sql}", conn){conn.prepare(sql)}
+              conn.prepared_statements[ps_name] = [stmt, sql]
+            end
+
+            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)
+          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_connection_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql, conn){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone, :stream=>stream)}
-          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
+        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
+            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
+        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)
+        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
 
       # 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
@@ -131,42 +218,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|
-          self.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 defined?(yield)
+            return enum_for(:paged_each, opts)
+          end
           stream.each(&block)
         else
           super
@@ -183,13 +268,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
@@ -197,19 +281,19 @@ module Sequel
         super
       end
 
-      # Handle correct quoting of strings using ::Mysql2::Client#escape.
-      def literal_string_append(sql, v)
-        s = begin
-          db.synchronize(@opts[:server]) do |c| 
-            begin
-              c.escape(v)
-            rescue ::Mysql2::Error => e
-              db.send(:raise_error, e)
-            end
-          end
+      if NativePreparedStatements
+        def bound_variable_modules
+          [PreparedStatementMethods]
+        end
+
+        def prepared_statement_modules
+          [PreparedStatementMethods]
         end
+      end
 
-        sql << APOS << s << APOS
+      # Handle correct quoting of strings using ::Mysql2::Client#escape.
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize(@opts[:server]){|c| c.escape(v)} << "'"
       end
     end
   end

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

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/shared/db2'
+require_relative '../shared/db2'
 
 Sequel.synchronize do
   Sequel::ODBC::DATABASE_SETUP[:db2] = proc do |db|

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

@@ -1,6 +1,6 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/shared/mssql'
+require_relative '../shared/mssql'
 
 module Sequel
   module ODBC
@@ -12,21 +12,17 @@ module Sequel
       end
     end
 
-    # Database and Dataset instance methods for MSSQL specific
-    # support via ODBC.
     module MSSQL
       module DatabaseMethods
-        extend Sequel::Database::ResetIdentifierMangling
         include Sequel::MSSQL::DatabaseMethods
-        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
-        
-        # Return the last inserted identity value.
+
         def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
               log_connection_yield(sql, conn){conn.do(sql)}
               begin
-                s = log_connection_yield(LAST_INSERT_ID_SQL, conn){conn.run(LAST_INSERT_ID_SQL)}
+                last_insert_id_sql = 'SELECT SCOPE_IDENTITY()'
+                s = log_connection_yield(last_insert_id_sql, conn){conn.run(last_insert_id_sql)}
                 if (rows = s.fetch_all) and (row = rows.first) and (v = row.first)
                   Integer(v)
                 end
@@ -42,20 +38,18 @@ module Sequel
       class Dataset < ODBC::Dataset
         include Sequel::MSSQL::DatasetMethods
 
-        # Use ODBC format, not Microsoft format, as the ODBC layer does
-        # some translation.  MSSQL version is over-ridden to allow 3 millisecond decimal places        
-        TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S%N'}".freeze
-
         private
 
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation, but allow for millisecond precision.
         def default_timestamp_format
-          TIMESTAMP_FORMAT
+          "{ts '%Y-%m-%d %H:%M:%S%N'}"
         end
 
         # Use ODBC format, not Microsoft format, as the ODBC layer does
         # some translation.
         def literal_date(v)
-          v.strftime(ODBC_DATE_FORMAT)
+          v.strftime("{d '%Y-%m-%d'}")
         end
       end
     end

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

@@ -0,0 +1,11 @@
+# frozen-string-literal: true
+
+require_relative '../shared/oracle'
+
+Sequel.synchronize do
+  Sequel::ODBC::DATABASE_SETUP[:oracle] = proc do |db|
+    db.extend ::Sequel::Oracle::DatabaseMethods
+    db.extend_datasets ::Sequel::Oracle::DatasetMethods
+  end
+end
+

data/lib/sequel/adapters/odbc.rb

@@ -11,10 +11,6 @@ module Sequel
     class Database < Sequel::Database
       set_adapter_scheme :odbc
 
-      GUARDED_DRV_NAME = /^\{.+\}$/.freeze
-      DRV_NAME_GUARDS = '{%s}'.freeze
-      DISCONNECT_ERRORS = /\A08S01/.freeze 
-
       def connect(server)
         opts = server_opts(server)
         conn = if opts.include?(:drvconnect)
@@ -23,8 +19,8 @@ module Sequel
           drv = ::ODBC::Driver.new
           drv.name = 'Sequel ODBC Driver130'
           opts.each do |param, value|
-            if :driver == param and not (value =~ GUARDED_DRV_NAME)
-              value = DRV_NAME_GUARDS % value
+            if :driver == param && value !~ /\A\{.+\}\z/
+              value = "{#{value}}"
             end
             drv.attrs[param.to_s.upcase] = value.to_s
           end
@@ -44,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
@@ -80,31 +76,30 @@ module Sequel
         [::ODBC::Error]
       end
 
+      def dataset_class_default
+        Dataset
+      end
+
       def disconnect_error?(e, opts)
-        super || (e.is_a?(::ODBC::Error) && DISCONNECT_ERRORS.match(e.message))
+        super || (e.is_a?(::ODBC::Error) && /\A08S01/.match(e.message))
       end
     end
     
     class Dataset < Sequel::Dataset
-      BOOL_TRUE = '1'.freeze
-      BOOL_FALSE = '0'.freeze
-      ODBC_DATE_FORMAT = "{d '%Y-%m-%d'}".freeze
-      TIMESTAMP_FORMAT="{ts '%Y-%m-%d %H:%M:%S'}".freeze
-
-      Database::DatasetClass = self
-
       def fetch_rows(sql)
         execute(sql) do |s|
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
-          columns = cols.map{|c| c.at(0)}
+          columns = cols.map{|c| c[0]}
           self.columns = columns
-          if rows = s.fetch_all
-            rows.each do |row|
-              hash = {}
-              cols.each{|n,t,j| hash[n] = convert_odbc_value(row[j], t)}
-              yield hash
+          s.each do |row|
+            hash = {}
+            cols.each do |n,t,j|
+              v = row[j]
+              # We can assume v is not false, so this shouldn't convert false to nil.
+              hash[n] = (convert_odbc_value(v, t) if v)
             end
+            yield hash
           end
         end
         self
@@ -136,19 +131,19 @@ module Sequel
       end
       
       def default_timestamp_format
-        TIMESTAMP_FORMAT
+        "{ts '%Y-%m-%d %H:%M:%S'}"
       end
 
       def literal_date(v)
-        v.strftime(ODBC_DATE_FORMAT)
+        v.strftime("{d '%Y-%m-%d'}")
       end
       
       def literal_false
-        BOOL_FALSE
+        '0'
       end
       
       def literal_true
-        BOOL_TRUE
+        '1'
       end
     end
   end