sequel 4.34.0 → 4.35.0

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

@@ -24,9 +24,9 @@ module Sequel
         def execute_insert(sql, opts=OPTS)
           synchronize(opts[:server]) do |conn|
             begin
-              log_yield(sql){conn.do(sql)}
+              log_connection_yield(sql, conn){conn.do(sql)}
               begin
-                s = log_yield(LAST_INSERT_ID_SQL){conn.run(LAST_INSERT_ID_SQL)}
+                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

data/lib/sequel/adapters/oracle.rb

@@ -80,10 +80,10 @@ module Sequel
             if args = opts[:arguments]
               r = conn.parse(sql)
               args = cursor_bind_params(conn, r, args)
-              nr = log_yield(sql, args){r.exec}
+              nr = log_connection_yield(sql, conn, args){r.exec}
               r = nr unless block_given?
             else
-              r = log_yield(sql){conn.exec(sql)}
+              r = log_connection_yield(sql, conn){conn.exec(sql)}
             end
             if block_given?
               begin
@@ -172,7 +172,7 @@ module Sequel
           end
         end
         unless cursor
-          cursor = log_yield("PREPARE #{name}: #{sql}"){conn.parse(sql)}
+          cursor = log_connection_yield("PREPARE #{name}: #{sql}", conn){conn.parse(sql)}
           conn.prepared_statements[name] = [cursor, sql]
         end
         args = cursor_bind_params(conn, cursor, opts[:arguments])
@@ -182,7 +182,7 @@ module Sequel
           log_sql << sql
           log_sql << ")"
         end
-        r = log_yield(log_sql, args){cursor.exec}
+        r = log_connection_yield(log_sql, conn, args){cursor.exec}
         if block_given?
           yield(cursor)
         elsif type == :insert
@@ -201,7 +201,7 @@ module Sequel
         if sequence
           sql = "SELECT #{literal(sequence)}.currval FROM dual"
           begin
-            cursor = log_yield(sql){conn.exec(sql)}
+            cursor = log_connection_yield(sql, conn){conn.exec(sql)}
             row = cursor.fetch
             row.each{|v| return (v.to_i if v)}
           rescue OCIError
@@ -213,12 +213,12 @@ module Sequel
       end
 
       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
       
       def commit_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_COMMIT){conn.commit}
+        log_connection_yield(TRANSACTION_COMMIT, conn){conn.commit}
       end
 
       def disconnect_error?(e, opts)
@@ -250,7 +250,7 @@ module Sequel
       end
       
       def rollback_transaction(conn, opts=OPTS)
-        log_yield(TRANSACTION_ROLLBACK){conn.rollback}
+        log_connection_yield(TRANSACTION_ROLLBACK, conn){conn.rollback}
       end
 
       def schema_parse_table(table, opts=OPTS)
@@ -283,7 +283,7 @@ module Sequel
 
         metadata = synchronize(opts[:server]) do |conn|
           begin
-          log_yield("Connection.describe_table"){conn.describe_table(schema_and_table)}
+            log_connection_yield("Connection.describe_table", conn){conn.describe_table(schema_and_table)}
           rescue OCIError => e
             raise_error(e)
           end

data/lib/sequel/adapters/postgres.rb

@@ -183,7 +183,7 @@ module Sequel
       # Return the PGResult object that is returned by executing the given
       # sql and args.
       def execute_query(sql, args)
-        @db.log_yield(sql, args){args ? async_exec(sql, args) : async_exec(sql)}
+        @db.log_connection_yield(sql, self, args){args ? async_exec(sql, args) : async_exec(sql)}
       end
     end
     
@@ -584,7 +584,7 @@ module Sequel
 
         unless conn.prepared_statements[ps_name] == sql
           conn.execute("DEALLOCATE #{ps_name}") if conn.prepared_statements.include?(ps_name)
-          conn.check_disconnect_errors{log_yield("PREPARE #{ps_name} AS #{sql}"){conn.prepare(ps_name, sql)}}
+          conn.check_disconnect_errors{log_connection_yield("PREPARE #{ps_name} AS #{sql}", conn){conn.prepare(ps_name, sql)}}
           conn.prepared_statements[ps_name] = sql
         end
 
@@ -595,7 +595,7 @@ module Sequel
           log_sql << ")"
         end
 
-        q = conn.check_disconnect_errors{log_yield(log_sql, args){_execute_prepared_statement(conn, ps_name, args, opts)}}
+        q = conn.check_disconnect_errors{log_connection_yield(log_sql, conn, args){_execute_prepared_statement(conn, ps_name, args, opts)}}
         begin
           block_given? ? yield(q) : q.cmd_tuples
         ensure

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

@@ -516,8 +516,10 @@ module Sequel
       BOOL_TRUE = '1'.freeze
       BOOL_FALSE = '0'.freeze
       COMMA_SEPARATOR = ', '.freeze
-      NOLOCK = ' WITH (NOLOCK)'.freeze
-      UPDLOCK = ' WITH (UPDLOCK)'.freeze
+      TABLE_HINT = " WITH (".freeze
+      READPAST = "READPAST".freeze
+      NOLOCK = 'NOLOCK'.freeze
+      UPDLOCK = 'UPDLOCK'.freeze
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
       EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}
@@ -732,7 +734,7 @@ module Sequel
         is_2005_or_later?
       end
 
-      # MSSQL 2005+ supports GROUPING SETS
+      # MSSQL 2008+ supports GROUPING SETS
       def supports_grouping_sets?
         is_2008_or_later?
       end
@@ -782,6 +784,11 @@ module Sequel
         supports_insert_select?
       end
 
+      # MSSQL uses READPAST to skip locked rows.
+      def supports_skip_locked?
+        true
+      end
+
       # MSSQL 2005+ supports window functions
       def supports_window_functions?
         true
@@ -965,11 +972,32 @@ module Sequel
 
       # Support different types of locking styles
       def select_lock_sql(sql)
-        case @opts[:lock]
-        when :update
-          sql << UPDLOCK
-        when :dirty
-          sql << NOLOCK
+        lock = @opts[:lock]
+        skip_locked = @opts[:skip_locked]
+        for_update = lock == :update
+        dirty = lock == :dirty
+        lock_hint = for_update || dirty
+
+        if lock_hint || skip_locked
+          sql << TABLE_HINT
+
+          if lock_hint
+            sql << if for_update
+              UPDLOCK
+            else
+              NOLOCK
+            end
+          end
+
+          if lock_hint && skip_locked
+            sql << COMMA_SEPARATOR
+          end
+
+          if skip_locked
+            sql << READPAST
+          end
+
+          sql << PAREN_CLOSE
         else
           super
         end

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

@@ -287,6 +287,7 @@ module Sequel
       HSTAR = "H*".freeze
       DUAL = ' FROM DUAL'.freeze
       BITAND_PROC = lambda{|a, b| Sequel.lit(["CAST(BITAND(", ", ", ") AS INTEGER)"], a, b)}
+      SKIP_LOCKED = " SKIP LOCKED".freeze
 
       include(Module.new do
         Dataset.def_sql_method(self, :select, %w'with select distinct columns from join where group having compounds order lock')
@@ -431,6 +432,11 @@ module Sequel
         false
       end
       
+      # Oracle supports SKIP LOCKED.
+      def supports_skip_locked?
+        true
+      end
+
       # Oracle supports timezones in literal timestamps.
       def supports_timestamp_timezones?
         true
@@ -536,6 +542,15 @@ module Sequel
         :union
       end
 
+      # Use SKIP LOCKED if skipping locked rows.
+      def select_lock_sql(sql)
+        super
+
+        if @opts[:skip_locked]
+          sql << SKIP_LOCKED
+        end
+      end
+
       # Oracle supports quoted function names.
       def supports_quoted_function_names?
         true

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

@@ -1214,6 +1214,7 @@ module Sequel
       SELECT_VALUES = "VALUES ".freeze
       EMPTY_STRING = ''.freeze
       LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
+      SKIP_LOCKED = " SKIP LOCKED".freeze
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
       Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
@@ -1305,6 +1306,8 @@ module Sequel
       # of any of the terms in any of the cols.
       #
       # Options:
+      # :headline :: Append a expression to the selected columns aliased to headline that
+      #              contains an extract of the matched text.
       # :language :: The language to use for the search (default: 'simple')
       # :plain :: Whether a plain search should be used (default: false).  In this case,
       #           terms should be a single string, and it will do a search where cols
@@ -1341,6 +1344,10 @@ module Sequel
           ds = ds.reverse{ts_rank_cd(cols, terms)}
         end
 
+        if opts[:headline]
+          ds = ds.select_append{ts_headline(lang, phrase_cols, terms).as(:headline)}
+        end
+
         ds
       end
 
@@ -1504,6 +1511,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL 9.5+ supports SKIP LOCKED.
+      def supports_skip_locked?
+        server_version >= 90500
+      end
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
         true
@@ -1684,8 +1696,17 @@ module Sequel
       end
 
       # Support FOR SHARE locking when using the :share lock style.
+      # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
-        @opts[:lock] == :share ? (sql << FOR_SHARE) : super
+        if @opts[:lock] == :share
+          sql << FOR_SHARE
+        else
+          super
+        end
+
+        if @opts[:skip_locked]
+          sql << SKIP_LOCKED
+        end
       end
 
       # Support VALUES clause instead of the SELECT clause to return rows.

data/lib/sequel/adapters/sqlanywhere.rb

@@ -102,7 +102,7 @@ module Sequel
 
       LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
       def _execute(conn, type, sql, opts)
-        unless rs = log_yield(sql){@api.sqlany_execute_direct(conn, sql)}
+        unless rs = log_connection_yield(sql, conn){@api.sqlany_execute_direct(conn, sql)}
           result, errstr = @api.sqlany_error(conn)
           raise_error(SQLAnywhereException.new(errstr, result, sql))
         end

data/lib/sequel/adapters/sqlite.rb

@@ -109,7 +109,7 @@ module Sequel
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
         db.busy_timeout(opts.fetch(:timeout, 5000))
         
-        connection_pragmas.each{|s| log_yield(s){db.execute_batch(s)}}
+        connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         
         class << db
           attr_reader :prepared_statements
@@ -184,12 +184,12 @@ module Sequel
             opts.fetch(:arguments, {}).each{|k, v| args[k] = prepared_statement_argument(v)}
             case type
             when :select
-              log_yield(sql, log_args){conn.query(sql, args, &block)}
+              log_connection_yield(sql, conn, log_args){conn.query(sql, args, &block)}
             when :insert
-              log_yield(sql, log_args){conn.execute(sql, args)}
+              log_connection_yield(sql, conn, log_args){conn.execute(sql, args)}
               conn.last_insert_row_id
             when :update
-              log_yield(sql, log_args){conn.execute_batch(sql, args)}
+              log_connection_yield(sql, conn, log_args){conn.execute_batch(sql, args)}
               conn.changes
             end
           end
@@ -241,7 +241,7 @@ module Sequel
           end
         end
         unless cps
-          cps = log_yield("PREPARE #{name}: #{sql}"){conn.prepare(sql)}
+          cps = log_connection_yield("PREPARE #{name}: #{sql}", conn){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
         log_sql = String.new
@@ -252,9 +252,9 @@ module Sequel
           log_sql << ")"
         end
         if block
-          log_yield(log_sql, args){cps.execute(ps_args, &block)}
+          log_connection_yield(log_sql, conn, args){cps.execute(ps_args, &block)}
         else
-          log_yield(log_sql, args){cps.execute!(ps_args){|r|}}
+          log_connection_yield(log_sql, conn, args){cps.execute!(ps_args){|r|}}
           case type
           when :insert
             conn.last_insert_row_id

data/lib/sequel/adapters/swift.rb

@@ -50,7 +50,7 @@ module Sequel
       def execute(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            res = log_yield(sql){conn.execute(sql)}
+            res = log_connection_yield(sql, conn){conn.execute(sql)}
             yield res if block_given?
             nil
           rescue ::Swift::Error => e
@@ -64,7 +64,7 @@ module Sequel
       def execute_dui(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.execute(sql).affected_rows}
+            log_connection_yield(sql, conn){conn.execute(sql).affected_rows}
           rescue ::Swift::Error => e
             raise_error(e)
           end
@@ -76,7 +76,7 @@ module Sequel
       def execute_insert(sql, opts=OPTS)
         synchronize(opts[:server]) do |conn|
           begin
-            log_yield(sql){conn.execute(sql).insert_id}
+            log_connection_yield(sql, conn){conn.execute(sql).insert_id}
           rescue ::Swift::Error => e
             raise_error(e)
           end

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

@@ -27,7 +27,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.execute(sql)}}
+          mysql_connection_setting_sqls.each{|sql| log_connection_yield(sql, conn){conn.execute(sql)}}
           super
         end
       end

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

@@ -38,7 +38,7 @@ module Sequel
         def setup_connection(conn)
           conn = super(conn)
           conn.native_bind_format = true
-          connection_configuration_sqls.each{|sql| log_yield(sql){conn.execute(sql)}}
+          connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){conn.execute(sql)}}
           conn
         end
       end

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

@@ -28,7 +28,7 @@ module Sequel
         # Set the correct pragmas on the connection.
         def connect(opts)
           c = super
-          connection_pragmas.each{|s| log_yield(s){c.execute(s)}}
+          connection_pragmas.each{|s| log_connection_yield(s, c){c.execute(s)}}
           c
         end
       end

data/lib/sequel/adapters/tinytds.rb

@@ -18,7 +18,7 @@ module Sequel
 
         if (ts = opts[:textsize])
           sql = "SET TEXTSIZE #{typecast_value_integer(ts)}"
-          log_yield(sql){c.execute(sql)}
+          log_connection_yield(sql, c){c.execute(sql)}
         end
       
         c
@@ -52,12 +52,12 @@ module Sequel
                 single_value = true
               end
               sql = "EXEC sp_executesql N'#{c.escape(sql)}', N'#{c.escape(types.join(', '))}', #{values.join(', ')}"
-              log_yield(sql) do
+              log_connection_yield(sql, c) do
                 r = c.execute(sql)
                 r.each{|row| return row.values.first} if single_value
               end
             else
-              log_yield(sql) do
+              log_connection_yield(sql, c) do
                 r = c.execute(sql)
                 return r.send(m) if m
               end
@@ -139,16 +139,14 @@ module Sequel
 
       # Dispose of any possible results of execution.
       def log_connection_execute(conn, sql)
-        log_yield(sql){conn.execute(sql).each}
+        log_connection_yield(sql, conn){conn.execute(sql).each}
       end
 
       # Return a 2 element array with the literal value and type to use
       # in the prepared statement call for the given value and connection.
       def ps_arg_type(v)
         case v
-        when Fixnum
-          [v, 'int']
-        when Bignum
+        when Integer
           [v, 'bigint']
         when Float
           [v, 'double precision']

data/lib/sequel/database/logging.rb

@@ -14,6 +14,9 @@ module Sequel
     # Array of SQL loggers to use for this database.
     attr_accessor :loggers
     
+    # Whether to include information about the connection in use when logging queries.
+    attr_accessor :log_connection_info
+    
     # Log level at which to log SQL queries.  This is actually the method
     # sent to the logger, so it should be the method name symbol. The default
     # is :info, it can be set to :debug to log at DEBUG level.
@@ -31,9 +34,15 @@ module Sequel
 
     # Yield to the block, logging any errors at error level to all loggers,
     # and all other queries with the duration at warn or info level.
-    def log_yield(sql, args=nil)
+    def log_yield(sql, args=nil, &block)
+      log_connection_yield(sql, nil, args, &block)
+    end
+
+    # Yield to the block, logging any errors at error level to all loggers,
+    # and all other queries with the duration at warn or info level.
+    def log_connection_yield(sql, conn, args=nil)
       return yield if @loggers.empty?
-      sql = "#{sql}; #{args.inspect}" if args
+      sql = "#{connection_info(conn) if conn && log_connection_info}#{sql}#{"; #{args.inspect}" if args}"
       start = Time.now
       begin
         yield
@@ -53,11 +62,17 @@ module Sequel
     end
 
     private
+
+    # String including information about the connection, for use when logging
+    # connection info.
+    def connection_info(conn)
+      "(conn: #{conn.__id__}) "
+    end
     
     # Log the given SQL and then execute it on the connection, used by
     # the transaction code.
     def log_connection_execute(conn, sql)
-      log_yield(sql){conn.send(connection_execute_method, sql)}
+      log_connection_yield(sql, conn){conn.send(connection_execute_method, sql)}
     end
 
     # Log message with message prefixed by duration at info level, or