sequel 4.34.0 → 4.35.0

data/lib/sequel/adapters/do.rb

@@ -52,7 +52,7 @@ module Sequel
         synchronize(opts[:server]) do |conn|
           begin
             command = conn.create_command(sql)
-            res = log_yield(sql){block_given? ? command.execute_reader : command.execute_non_query}
+            res = log_connection_yield(sql, conn){block_given? ? command.execute_reader : command.execute_non_query}
           rescue ::DataObjects::Error => e
             raise_error(e)
           end
@@ -126,7 +126,7 @@ module Sequel
       
       # Execute SQL on the connection by creating a command first
       def log_connection_execute(conn, sql)
-        log_yield(sql){conn.create_command(sql).execute_non_query}
+        log_connection_yield(sql, conn){conn.create_command(sql).execute_non_query}
       end
       
       # Allow extending the given connection when it is first created.

data/lib/sequel/adapters/do/mysql.rb

@@ -36,7 +36,7 @@ module Sequel
 
         # Apply the connectiong setting SQLs for every new connection.
         def setup_connection(conn)
-          mysql_connection_setting_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
+          mysql_connection_setting_sqls.each{|sql| log_connection_yield(sql, conn){conn.create_command(sql).execute_non_query}}
           super
         end
       end

data/lib/sequel/adapters/do/postgres.rb

@@ -35,7 +35,7 @@ module Sequel
         # Extend the adapter with the DataObjects PostgreSQL AdapterMethods
         def setup_connection(conn)
           conn = super(conn)
-          connection_configuration_sqls.each{|sql| log_yield(sql){conn.create_command(sql).execute_non_query}}
+          connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){conn.create_command(sql).execute_non_query}}
           conn
         end
       end

data/lib/sequel/adapters/do/sqlite3.rb

@@ -32,7 +32,7 @@ module Sequel
         def setup_connection(conn)
           connection_pragmas.each do |s|
             com = conn.create_command(s)
-            log_yield(s){com.execute_non_query}
+            log_connection_yield(s, conn){com.execute_non_query}
           end
           super
         end

data/lib/sequel/adapters/ibmdb.rb

@@ -242,7 +242,7 @@ module Sequel
         sql = ps.prepared_sql
         synchronize(opts[:server]) do |conn|
           unless conn.prepared_statements.fetch(ps_name, []).first == sql
-            log_yield("PREPARE #{ps_name}: #{sql}"){conn.prepare(sql, ps_name)}
+            log_connection_yield("PREPARE #{ps_name}: #{sql}", conn){conn.prepare(sql, ps_name)}
           end
           args = args.map{|v| v.nil? ? nil : prepared_statement_arg(v)}
           log_sql = "EXECUTE #{ps_name}"
@@ -252,7 +252,7 @@ module Sequel
             log_sql << ")"
           end
           begin
-            stmt = log_yield(log_sql, args){conn.execute_prepared(ps_name, *args)}
+            stmt = log_connection_yield(log_sql, conn, args){conn.execute_prepared(ps_name, *args)}
             if block_given?
               yield(stmt)
             else  
@@ -268,7 +268,7 @@ module Sequel
 
       # Execute the given SQL on the database.
       def _execute(conn, sql, opts)
-        stmt = log_yield(sql){conn.execute(sql)}
+        stmt = log_connection_yield(sql, conn){conn.execute(sql)}
         if block_given?
           yield(stmt)
         else  
@@ -286,14 +286,14 @@ module Sequel
       # IBM_DB uses an autocommit setting instead of sending SQL queries.
       # So starting a transaction just turns autocommit off.
       def begin_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_BEGIN){conn.autocommit = false}
+        log_connection_yield(TRANSACTION_BEGIN, conn){conn.autocommit = false}
         set_transaction_isolation(conn, opts)
       end
 
       # This commits transaction in progress on the
       # connection and sets autocommit back on.
       def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
+        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
       end
     
       def database_error_classes
@@ -337,7 +337,7 @@ module Sequel
       # This rolls back the transaction in progress on the
       # connection and sets autocommit back on.
       def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
       end
 
       # Convert smallint type to boolean if convert_smallint_to_bool is true

data/lib/sequel/adapters/jdbc.rb

@@ -178,14 +178,14 @@ module Sequel
 
           begin
             if block_given?
-              yield log_yield(sql){cps.executeQuery}
+              yield log_connection_yield(sql, conn){cps.executeQuery}
             else
               case opts[:type]
               when :insert
-                log_yield(sql){cps.executeUpdate}
+                log_connection_yield(sql, conn){cps.executeUpdate}
                 last_insert_id(conn, opts)
               else
-                log_yield(sql){cps.executeUpdate}
+                log_connection_yield(sql, conn){cps.executeUpdate}
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
@@ -250,16 +250,16 @@ module Sequel
               if size = fetch_size
                 stmt.setFetchSize(size)
               end
-              yield log_yield(sql){stmt.executeQuery(sql)}
+              yield log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             else
               case opts[:type]
               when :ddl
-                log_yield(sql){stmt.execute(sql)}
+                log_connection_yield(sql, conn){stmt.execute(sql)}
               when :insert
-                log_yield(sql){execute_statement_insert(stmt, sql)}
+                log_connection_yield(sql, conn){execute_statement_insert(stmt, sql)}
                 last_insert_id(conn, Hash[opts].merge!(:stmt=>stmt))
               else
-                log_yield(sql){stmt.executeUpdate(sql)}
+                log_connection_yield(sql, conn){stmt.executeUpdate(sql)}
               end
             end
           end
@@ -418,8 +418,8 @@ module Sequel
           if name and cps = cps_sync(conn){|cpsh| cpsh[name]} and cps[0] == sql
             cps = cps[1]
           else
-            log_yield("CLOSE #{name}"){cps[1].close} if cps
-            cps = log_yield("PREPARE#{" #{name}:" if name} #{sql}"){prepare_jdbc_statement(conn, sql, opts)}
+            log_connection_yield("CLOSE #{name}", conn){cps[1].close} if cps
+            cps = log_connection_yield("PREPARE#{" #{name}:" if name} #{sql}", conn){prepare_jdbc_statement(conn, sql, opts)}
             if size = fetch_size
               cps.setFetchSize(size)
             end
@@ -429,22 +429,22 @@ module Sequel
           args.each{|arg| set_ps_arg(cps, arg, i+=1)}
           msg = "EXECUTE#{" #{name}" if name}"
           if ps.log_sql
-            msg << " ("
+            msg += " ("
             msg << sql
             msg << ")"
           end
           begin
             if block_given?
-              yield log_yield(msg, args){cps.executeQuery}
+              yield log_connection_yield(msg, conn, args){cps.executeQuery}
             else
               case opts[:type]
               when :ddl
-                log_yield(msg, args){cps.execute}
+                log_connection_yield(msg, conn, args){cps.execute}
               when :insert
-                log_yield(msg, args){execute_prepared_statement_insert(cps)}
+                log_connection_yield(msg, conn, args){execute_prepared_statement_insert(cps)}
                 last_insert_id(conn, Hash[opts].merge!(:prepared=>true, :stmt=>cps))
               else
-                log_yield(msg, args){cps.executeUpdate}
+                log_connection_yield(msg, conn, args){cps.executeUpdate}
               end
             end
           rescue NativeException, JavaSQL::SQLException => e
@@ -519,7 +519,7 @@ module Sequel
       # Log the given SQL and then execute it on the connection, used by
       # the transaction code.
       def log_connection_execute(conn, sql)
-        statement(conn){|s| log_yield(sql){s.execute(sql)}}
+        statement(conn){|s| log_connection_yield(sql, conn){s.execute(sql)}}
       end
 
       # By default, there is no support for determining the last inserted

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

@@ -66,7 +66,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = IDENTITY_VAL_LOCAL
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end

data/lib/sequel/adapters/jdbc/derby.rb

@@ -90,7 +90,7 @@ module Sequel
         # Add NOT LOGGED for temporary tables to improve performance.
         def create_table_sql(name, generator, options)
           s = super
-          s << ' NOT LOGGED' if options[:temp]
+          s += ' NOT LOGGED' if options[:temp]
           s
         end
 
@@ -131,7 +131,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY_VAL_LOCAL() FROM sysibm.sysdummy1'
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
@@ -157,7 +157,7 @@ module Sequel
           if column[:identity]
             sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
             if sw = column[:start_with]
-              sql << " (START WITH #{sw.to_i}"
+              sql += " (START WITH #{sw.to_i}"
               sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
               sql << ")"
             end

data/lib/sequel/adapters/jdbc/h2.rb

@@ -95,7 +95,7 @@ module Sequel
                 op = cs.merge!(op)
               end
             end
-            sql = "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+            sql = "ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}".dup
             column_definition_order.each{|m| send(:"column_definition_#{m}_sql", sql, op)}
             sql
           when :drop_constraint
@@ -130,7 +130,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'SELECT IDENTITY();'
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
@@ -146,7 +146,7 @@ module Sequel
         end
 
         # Use BIGINT IDENTITY for identity columns that use bigint, fixes
-        # the case where primary_key :column, :type=>Bignum is used.
+        # the case where primary_key :column, :type=>:Bignum is used.
         def type_literal_generic_bignum(column)
           column[:identity] ? 'BIGINT IDENTITY' : super
         end

data/lib/sequel/adapters/jdbc/hsqldb.rb

@@ -101,7 +101,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = 'CALL IDENTITY()'
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end
@@ -119,7 +119,7 @@ module Sequel
           if column[:identity]
             sql = "#{super} GENERATED BY DEFAULT AS IDENTITY"
             if sw = column[:start_with]
-              sql << " (START WITH #{sw.to_i}"
+              sql += " (START WITH #{sw.to_i}"
               sql << " INCREMENT BY #{column[:increment_by].to_i}" if column[:increment_by]
               sql << ")"
             end

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

@@ -22,7 +22,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = opts[:prepared] ? ATAT_IDENTITY : SCOPE_IDENTITY
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end

data/lib/sequel/adapters/jdbc/mysql.rb

@@ -83,7 +83,7 @@ module Sequel
         # Run the default connection setting SQL statements.
         # Apply the connectiong setting SQLs for every new connection.
         def setup_connection(conn)
-          mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_yield(sql){s.execute(sql)}}}
+          mysql_connection_setting_sqls.each{|sql| statement(conn){|s| log_connection_yield(sql, conn){s.execute(sql)}}}
           super
         end
       end

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

@@ -72,7 +72,7 @@ module Sequel
             sql = "SELECT #{literal(sequence)}.currval FROM dual"
             statement(conn) do |stmt|
               begin
-                rs = log_yield(sql){stmt.executeQuery(sql)}
+                rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
                 rs.next
                 rs.getLong(1)
               rescue java.sql.SQLException

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -100,7 +100,7 @@ module Sequel
                 end
                 nil
               else
-                b = ''
+                b = String.new
                 while buf = copier.readFromCopy
                   b << String.from_java_bytes(buf)
                 end
@@ -171,7 +171,7 @@ module Sequel
         def setup_connection(conn)
           conn = super(conn)
           statement(conn) do |stmt|
-            connection_configuration_sqls.each{|sql| log_yield(sql){stmt.execute(sql)}}
+            connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
           end
           conn
         end

data/lib/sequel/adapters/jdbc/sqlanywhere.rb

@@ -51,7 +51,7 @@ module Sequel
         def last_insert_id(conn, opts=OPTS)
           statement(conn) do |stmt|
             sql = LAST_INSERT_ID
-            rs = log_yield(sql){stmt.executeQuery(sql)}
+            rs = log_connection_yield(sql, conn){stmt.executeQuery(sql)}
             rs.next
             rs.getLong(1)
           end

data/lib/sequel/adapters/jdbc/sqlite.rb

@@ -67,7 +67,7 @@ module Sequel
         def setup_connection(conn)
           conn = super(conn)
           statement(conn) do |stmt|
-            connection_pragmas.each{|s| log_yield(s){stmt.execute(s)}}
+            connection_pragmas.each{|s| log_connection_yield(s, conn){stmt.execute(s)}}
           end
           conn
         end

data/lib/sequel/adapters/jdbc/transactions.rb

@@ -36,7 +36,7 @@ module Sequel
         if (jdbc_level = JDBC_TRANSACTION_ISOLATION_LEVELS[level]) &&
             conn.getMetaData.supportsTransactionIsolationLevel(jdbc_level)
           _trans(conn)[:original_jdbc_isolation_level] = conn.getTransactionIsolation
-          log_yield("Transaction.isolation_level = #{level}"){conn.setTransactionIsolation(jdbc_level)}
+          log_connection_yield("Transaction.isolation_level = #{level}", conn){conn.setTransactionIsolation(jdbc_level)}
         end
       end
 
@@ -50,14 +50,14 @@ module Sequel
         if supports_savepoints?
           th = _trans(conn)
           if sps = th[:savepoint_objs]
-            sps << log_yield(TRANSACTION_SAVEPOINT){conn.set_savepoint}
+            sps << log_connection_yield(TRANSACTION_SAVEPOINT, conn){conn.set_savepoint}
           else
-            log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+            log_connection_yield(TRANSACTION_BEGIN, conn){conn.setAutoCommit(false)}
             th[:savepoint_objs] = []
             set_transaction_isolation(conn, opts)
           end
         else
-          log_yield(TRANSACTION_BEGIN){conn.setAutoCommit(false)}
+          log_connection_yield(TRANSACTION_BEGIN, conn){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
         end
       end
@@ -67,12 +67,12 @@ module Sequel
         if supports_savepoints?
           sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
-            log_yield(TRANSACTION_COMMIT){conn.commit}
+            log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
           elsif supports_releasing_savepoints?
-            log_yield(TRANSACTION_RELEASE_SP){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+            log_connection_yield(TRANSACTION_RELEASE_SP, conn){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
           end
         else
-          log_yield(TRANSACTION_COMMIT){conn.commit}
+          log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
         end
       end
       
@@ -97,12 +97,12 @@ module Sequel
         if supports_savepoints?
           sps = _trans(conn)[:savepoint_objs]
           if sps.empty?
-            log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+            log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
           else
-            log_yield(TRANSACTION_ROLLBACK_SP){conn.rollback(sps.last)}
+            log_connection_yield(TRANSACTION_ROLLBACK_SP, conn){conn.rollback(sps.last)}
           end
         else
-          log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+          log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
         end
       end
     end

data/lib/sequel/adapters/mock.rb

@@ -204,7 +204,7 @@ module Sequel
         sql += " -- args: #{opts[:arguments].inspect}" if opts[:arguments]
         sql += " -- #{@opts[:append]}" if @opts[:append]
         sql += " -- #{c.server.is_a?(Symbol) ? c.server : c.server.inspect}" if c.server != :default
-        log_info(sql) unless opts[:log] == false
+        log_connection_yield(sql, c){} unless opts[:log] == false
         @sqls << sql 
 
         ds = opts[:dataset]

data/lib/sequel/adapters/mysql.rb

@@ -118,7 +118,7 @@ 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
@@ -174,7 +174,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?

data/lib/sequel/adapters/mysql2.rb

@@ -48,7 +48,7 @@ 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
@@ -77,7 +77,7 @@ module Sequel
       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)}
+          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

data/lib/sequel/adapters/odbc.rb

@@ -43,7 +43,7 @@ module Sequel
       def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            r = log_yield(sql){conn.run(sql)}
+            r = log_connection_yield(sql, conn){conn.run(sql)}
             yield(r) if block_given?
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
@@ -57,7 +57,7 @@ module Sequel
       def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.do(sql)}
+            log_connection_yield(sql, conn){conn.do(sql)}
           rescue ::ODBC::Error, ArgumentError => e
             raise_error(e)
           end