sequel 3.21.0 → 3.41.0

data/lib/sequel/adapters/mysql2.rb

@@ -1,6 +1,5 @@
-require 'mysql2' unless defined? Mysql2
-
-Sequel.require %w'shared/mysql', 'adapters'
+require 'mysql2'
+Sequel.require %w'shared/mysql_prepared_statements', 'adapters'
 
 module Sequel
   # Module for holding all Mysql2-related classes and modules for Sequel.
@@ -8,11 +7,18 @@ module Sequel
     # Database class for MySQL databases used with Sequel.
     class Database < Sequel::Database
       include Sequel::MySQL::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)/
+      include Sequel::MySQL::PreparedStatements::DatabaseMethods
 
       set_adapter_scheme :mysql2
+      
+      # Whether to convert tinyint columns to bool for this database
+      attr_accessor :convert_tinyint_to_bool
+
+      # Set the convert_tinyint_to_bool setting based on the default value.
+      def initialize(opts={})
+        super
+        self.convert_tinyint_to_bool = Sequel::MySQL.convert_tinyint_to_bool
+      end
 
       # Connect to the database.  In addition to the usual database options,
       # the following options have effect:
@@ -21,7 +27,6 @@ module Sequel
       #   a filter for an autoincrement column equals NULL to return the last
       #   inserted row.
       # * :charset - Same as :encoding (:encoding takes precendence)
-      # * :compress - Set to false to not compress results from the server
       # * :config_default_group - The default group to read from the in
       #   the MySQL config file.
       # * :config_local_infile - If provided, sets the Mysql::OPT_LOCAL_INFILE
@@ -37,42 +42,34 @@ module Sequel
         opts = server_opts(server)
         opts[:host] ||= 'localhost'
         opts[:username] ||= opts[:user]
+        opts[:flags] = ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         conn = ::Mysql2::Client.new(opts)
+        conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
+
+        sqls = mysql_connection_setting_sqls
 
-        sqls = []
         # Set encoding a slightly different way after connecting,
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
         if encoding = opts[:encoding] || opts[:charset]
-          sqls << "SET NAMES #{conn.escape(encoding.to_s)}"
+          sqls.unshift("SET NAMES #{conn.escape(encoding.to_s)}")
         end
 
-        # Increase timeout so mysql server doesn't disconnect us.
-        # Value used by default is maximum allowed value on Windows.
-        sqls << "SET @@wait_timeout = #{opts[:timeout] || 2147483}"
-
-        # By default, MySQL 'where id is null' selects the last inserted id
-        sqls << "SET SQL_AUTO_IS_NULL=0" unless opts[:auto_is_null]
-
         sqls.each{|sql| log_yield(sql){conn.query(sql)}}
 
+        add_prepared_statements_cache(conn)
         conn
       end
 
-      # Returns instance of Sequel::MySQL::Dataset with the given options.
-      def dataset(opts = nil)
-        Mysql2::Dataset.new(self, opts)
+      # Return the number of matched rows when executing a delete/update statement.
+      def execute_dui(sql, opts={})
+        execute(sql, opts){|c| return c.affected_rows}
       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)
-        else
-          synchronize(opts[:server]){|conn| _execute(conn, sql, opts, &block)}
-        end
+      # Return the last inserted id when executing an insert statement.
+      def execute_insert(sql, opts={})
+        execute(sql, opts){|c| return c.last_id}
       end
 
       # Return the version of the MySQL server two which we are connecting.
@@ -87,14 +84,14 @@ module Sequel
       # yield the connection if a block is given.
       def _execute(conn, sql, opts)
         begin
-          r = log_yield(sql){conn.query(sql, :symbolize_keys => true, :database_timezone => Sequel.database_timezone, :application_timezone => Sequel.application_timezone)}
+          r = log_yield((log_sql = opts[:log_sql]) ? sql + log_sql : sql){conn.query(sql, :database_timezone => timezone, :application_timezone => Sequel.application_timezone)}
           if opts[:type] == :select
             yield r if r
           elsif block_given?
             yield conn
           end
         rescue ::Mysql2::Error => e
-          raise_error(e, :disconnect=>MYSQL_DATABASE_DISCONNECT_ERRORS.match(e.message))
+          raise_error(e)
         end
       end
 
@@ -108,71 +105,75 @@ module Sequel
         [::Mysql2::Error]
       end
 
+      # If a connection object is available, try pinging it.  Otherwise, if the
+      # error is a Mysql2::Error, check the SQL state and exception message for
+      # disconnects.
+      def disconnect_error?(e, opts)
+        super ||
+          ((conn = opts[:conn]) && !conn.ping) ||
+          (e.is_a?(::Mysql2::Error) &&
+            (e.sql_state =~ /\A08/ ||
+             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
 
-      # Closes given database connection.
-      def disconnect_connection(c)
-        c.close
-      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
+        convert_tinyint_to_bool && db_type == 'tinyint(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
 
-      # Delete rows matching this dataset
-      def delete
-        execute_dui(delete_sql){|c| return c.affected_rows}
-      end
+      Database::DatasetClass = self
 
       # Yield all rows matching this dataset.
-      def fetch_rows(sql, &block)
+      def fetch_rows(sql)
         execute(sql) do |r|
-          @columns = r.fields
-          r.each(:cast_booleans => Sequel::MySQL.convert_tinyint_to_bool, &block)
+          if identifier_output_method
+            cols = r.fields
+            @columns = cols2 = cols.map{|c| output_identifier(c.to_s)}
+            cs = cols.zip(cols2)
+            r.each(:cast_booleans=>convert_tinyint_to_bool?) do |row|
+              h = {}
+              cs.each do |a, b|
+                h[b] = row[a]
+              end
+              yield h
+            end
+          else
+            @columns = r.fields
+            r.each(:cast_booleans=>convert_tinyint_to_bool?){|h| yield h}
+          end
         end
         self
       end
 
-      # Insert a new value into this dataset
-      def insert(*values)
-        execute_dui(insert_sql(*values)){|c| return c.last_id}
-      end
-
-      # Replace (update or insert) the matching row.
-      def replace(*args)
-        execute_dui(replace_sql(*args)){|c| return c.last_id}
-      end
+      private
 
-      # Update the matching rows.
-      def update(values={})
-        execute_dui(update_sql(values)){|c| return c.affected_rows}
+      # Whether to cast tinyint(1) columns to integer instead of boolean.
+      # By default, uses the opposite of 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
 
-      private
-
       # Set the :type option to :select if it hasn't been set.
       def execute(sql, opts={}, &block)
         super(sql, {:type=>:select}.merge(opts), &block)
       end
 
-      # Set the :type option to :dui if it hasn't been set.
-      def execute_dui(sql, opts={}, &block)
-        super(sql, {:type=>:dui}.merge(opts), &block)
-      end
-
       # Handle correct quoting of strings using ::Mysql2::Client#escape.
-      def literal_string(v)
-        db.synchronize{|c| "'#{c.escape(v)}'"}
+      def literal_string_append(sql, v)
+        sql << "'" << db.synchronize{|c| c.escape(v)} << "'"
       end
     end
   end

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

@@ -7,12 +7,7 @@ module Sequel
     module MSSQL
       module DatabaseMethods
         include Sequel::MSSQL::DatabaseMethods
-        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'
-        
-        # Return an instance of Sequel::ODBC::MSSQL::Dataset with the given opts.
-        def dataset(opts=nil)
-          Sequel::ODBC::MSSQL::Dataset.new(self, opts)
-        end
+        LAST_INSERT_ID_SQL='SELECT SCOPE_IDENTITY()'.freeze
         
         # Return the last inserted identity value.
         def execute_insert(sql, opts={})
@@ -21,8 +16,8 @@ module Sequel
               log_yield(sql){conn.do(sql)}
               begin
                 s = log_yield(LAST_INSERT_ID_SQL){conn.run(LAST_INSERT_ID_SQL)}
-                if (rows = s.fetch_all) and (row = rows.first)
-                  Integer(row.first)
+                if (rows = s.fetch_all) and (row = rows.first) and (v = row.first)
+                  Integer(v)
                 end
               ensure
                 s.drop if s
@@ -33,9 +28,22 @@ module Sequel
           end
         end
       end
-      
       class Dataset < ODBC::Dataset
         include Sequel::MSSQL::DatasetMethods
+
+        private
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def default_timestamp_format
+          TIMESTAMP_FORMAT
+        end
+
+        # Use ODBC format, not Microsoft format, as the ODBC layer does
+        # some translation.
+        def literal_date(v)
+          v.strftime(ODBC_DATE_FORMAT)
+        end
       end
     end
   end

data/lib/sequel/adapters/odbc.rb

@@ -15,9 +15,16 @@ module Sequel
         when 'mssql'
           Sequel.ts_require 'adapters/odbc/mssql'
           extend Sequel::ODBC::MSSQL::DatabaseMethods
+          @dataset_class = Sequel::ODBC::MSSQL::Dataset
+          set_mssql_unicode_strings
         when 'progress'
           Sequel.ts_require 'adapters/shared/progress'
           extend Sequel::Progress::DatabaseMethods
+          extend_datasets(Sequel::Progress::DatasetMethods)
+        when 'db2'
+          Sequel.ts_require 'adapters/shared/db2'
+          extend ::Sequel::DB2::DatabaseMethods
+          extend_datasets ::Sequel::DB2::DatasetMethods
         end
       end
 
@@ -41,17 +48,17 @@ module Sequel
         conn
       end      
 
-      def dataset(opts = nil)
-        ODBC::Dataset.new(self, opts)
+      def disconnect_connection(c)
+        c.disconnect
       end
-    
+
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           begin
             r = log_yield(sql){conn.run(sql)}
             yield(r) if block_given?
           rescue ::ODBC::Error, ArgumentError => e
-            raise_error(e, :disconnect=>DISCONNECT_ERRORS.match(e.message))
+            raise_error(e)
           ensure
             r.drop if r
           end
@@ -64,7 +71,7 @@ module Sequel
           begin
             log_yield(sql){conn.do(sql)}
           rescue ::ODBC::Error, ArgumentError => e
-            raise_error(e, :disconnect=>DISCONNECT_ERRORS.match(e.message))
+            raise_error(e)
           end
         end
       end
@@ -76,8 +83,12 @@ module Sequel
         :do
       end
 
-      def disconnect_connection(c)
-        c.disconnect
+      def database_error_classes
+        [::ODBC::Error]
+      end
+
+      def disconnect_error?(e, opts)
+        super || (e.is_a?(::ODBC::Error) && DISCONNECT_ERRORS.match(e.message))
       end
     end
     
@@ -87,15 +98,23 @@ module Sequel
       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), i+=1]}
-          @columns = cols.map{|c| c.at(0)}
+          columns = cols.map{|c| c.at(0)}
+          if opts[:offset] && offset_returns_row_number_column?
+            rn = row_number_column
+            columns.delete(rn)
+          end
+          @columns = columns
           if rows = s.fetch_all
             rows.each do |row|
               hash = {}
               cols.each{|n,i| hash[n] = convert_odbc_value(row[i])}
+              hash.delete(rn) if rn
               yield hash
             end
           end
@@ -114,9 +133,9 @@ module Sequel
         # ODBCColumn#mapSqlTypeToGenericType and Column#klass.
         case v
         when ::ODBC::TimeStamp
-          Sequel.database_to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
+          db.to_application_timestamp([v.year, v.month, v.day, v.hour, v.minute, v.second])
         when ::ODBC::Time
-          Sequel.database_to_application_timestamp([now.year, now.month, now.day, v.hour, v.minute, v.second])
+          Sequel::SQLTime.create(v.hour, v.minute, v.second)
         when ::ODBC::Date
           Date.new(v.year, v.month, v.day)
         else

data/lib/sequel/adapters/openbase.rb

@@ -14,11 +14,11 @@ module Sequel
           opts[:password]
         )
       end
-      
-      def dataset(opts = nil)
-        OpenBase::Dataset.new(self, opts)
+
+      def disconnect_connection(c)
+        c.disconnect
       end
-    
+      
       def execute(sql, opts={})
         synchronize(opts[:server]) do |conn|
           r = log_yield(sql){conn.execute(sql)}
@@ -27,16 +27,12 @@ module Sequel
         end
       end
       alias_method :do, :execute
-
-      private
-
-      def disconnect_connection(c)
-        c.disconnect
-      end
     end
     
     class Dataset < Sequel::Dataset
-      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
+      SELECT_CLAUSE_METHODS = clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
+
+      Database::DatasetClass = self
       
       def fetch_rows(sql)
         execute(sql) do |result|