sequel 5.11.0 → 5.12.0

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

@@ -441,7 +441,7 @@ module Sequel
         /cannot be null/ => NotNullConstraintViolation,
         /Deadlock found when trying to get lock; try restarting transaction/ => SerializationFailure,
         /CONSTRAINT .+ failed for/ => CheckConstraintViolation,
-        /\AStatement aborted because lock\(s\) could not be acquired immediately and NOWAIT is set\./ => DatabaseLockTimeout,
+        /\A(Statement aborted because lock\(s\) could not be acquired immediately and NOWAIT is set\.|Lock wait timeout exceeded; try restarting transaction)/ => DatabaseLockTimeout,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -804,9 +804,9 @@ module Sequel
         true
       end
 
-      # MySQL does not support INTERSECT or EXCEPT
+      # MariaDB 10.3+ supports INTERSECT or EXCEPT
       def supports_intersect_except?
-        false
+        db.mariadb? && db.server_version >= 100300
       end
       
       # MySQL does not support limits in correlated subqueries (or any subqueries that use IN).
@@ -819,9 +819,9 @@ module Sequel
         true
       end
 
-      # MySQL 8+ supports NOWAIT.
+      # MySQL 8+ and MariaDB 10.3+ support NOWAIT.
       def supports_nowait?
-        !db.mariadb? && db.server_version >= 80000
+        db.server_version >= (db.mariadb? ? 100300 : 80000)
       end
 
       # MySQL's DISTINCT ON emulation using GROUP BY does not respect the

data/lib/sequel/adapters/sqlite.rb

@@ -306,11 +306,6 @@ module Sequel
         def prepared_arg(k)
           LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)

data/lib/sequel/adapters/tinytds.rb

@@ -194,11 +194,6 @@ module Sequel
         def prepared_arg(k)
           LiteralString.new("@#{k.to_s.gsub('.', '__')}")
         end
-
-        # Always assume a prepared argument.
-        def prepared_arg?(k)
-          true
-        end
       end
       
       PreparedStatementMethods = prepared_statements_module("sql = prepared_sql; opts = Hash[opts]; opts[:arguments] = bind_arguments", ArgumentMapper)

data/lib/sequel/adapters/utils/emulate_offset_with_reverse_and_count.rb

@@ -32,14 +32,11 @@ module Sequel
       row_count = @opts[:offset_total_count] || ds.clone(:append_sql=>String.new, :placeholder_literal_null=>true).count
       dsa1 = dataset_alias(1)
 
-      if o.is_a?(Symbol) && @opts[:bind_vars] && (match = /\A\$(.*)\z/.match(o.to_s))
+      if o.is_a?(Symbol) && @opts[:bind_vars] && /\A\$(.*)\z/ =~ o
         # Handle use of bound variable offsets.  Unfortunately, prepared statement
         # bound variable offsets cannot be handled, since the bound variable value
         # isn't available until later.
-        s = match[1].to_sym
-        if prepared_arg?(s)
-          o = prepared_arg(s)
-        end
+        o = prepared_arg($1.to_sym)
       end
 
       reverse_offset = row_count - o

data/lib/sequel/core.rb

@@ -58,6 +58,11 @@ module Sequel
     #
     #   Sequel.single_threaded = true
     attr_accessor :single_threaded
+
+    # Alias of original require method, as Sequel.require is does a relative
+    # require for backwards compatibility.
+    alias orig_require require
+    private :orig_require
   end
 
   # Returns true if the passed object could be a specifier of conditions, false otherwise.
@@ -142,7 +147,7 @@ module Sequel
   #   Sequel.extension(:blank)
   #   Sequel.extension(:core_extensions, :named_timezones)
   def self.extension(*extensions)
-    extensions.each{|e| Kernel.require "sequel/extensions/#{e}"}
+    extensions.each{|e| orig_require("sequel/extensions/#{e}")}
   end
   
   # The exception classed raised if there is an error parsing JSON.

data/lib/sequel/dataset/graph.rb

@@ -96,10 +96,30 @@ module Sequel
       
       table_alias_qualifier = qualifier_from_alias_symbol(table_alias, table)
       implicit_qualifier = options[:implicit_qualifier]
+      joined_dataset = joined_dataset?
       ds = self
+      graph = opts[:graph]
+
+      if !graph && (select = @opts[:select]) && !select.empty?
+        select_columns = nil
+
+        unless !joined_dataset && select.length == 1 && (select[0].is_a?(SQL::ColumnAll))
+          force_from_self = false
+          select_columns = select.map do |sel|
+            unless col = _hash_key_symbol(sel)
+              force_from_self = true
+              break
+            end
+
+            [sel, col]
+          end
+
+          select_columns = nil if force_from_self
+        end
+      end
 
       # Use a from_self if this is already a joined table (or from_self specifically disabled for graphs)
-      if (@opts[:graph_from_self] != false && !@opts[:graph] && joined_dataset?)
+      if (@opts[:graph_from_self] != false && !graph && (joined_dataset || force_from_self))
         from_selfed = true
         implicit_qualifier = options[:from_self_alias] || first_source
         ds = ds.from_self(:alias=>implicit_qualifier)
@@ -115,7 +135,7 @@ module Sequel
       # Whether to include the table in the result set
       add_table = options[:select] == false ? false : true
 
-      if graph = opts[:graph]
+      if graph
         graph = graph.dup
         select = opts[:select].dup
         [:column_aliases, :table_aliases, :column_alias_num].each{|k| graph[k] = graph[k].dup}
@@ -137,12 +157,8 @@ module Sequel
         # Keep track of the alias numbers used
         ca_num = graph[:column_alias_num] = Hash.new(0)
 
-        # All columns in the master table are never
-        # aliased, but are not included if set_graph_aliases
-        # has been used.
-        if (select = @opts[:select]) && !select.empty? && !(select.length == 1 && (select.first.is_a?(SQL::ColumnAll)))
-          select = select.map do |sel|
-            raise Error, "can't figure out alias to use for graphing for #{sel.inspect}" unless column = _hash_key_symbol(sel)
+        select = if select_columns
+          select_columns.map do |sel, column|
             column_aliases[column] = [master, column]
             if from_selfed
               # Initial dataset was wrapped in subselect, selected all
@@ -155,7 +171,7 @@ module Sequel
             end
           end
         else
-          select = columns.map do |column|
+          columns.map do |column|
             column_aliases[column] = [master, column]
             SQL::QualifiedIdentifier.new(qualifier, column)
           end

data/lib/sequel/dataset/placeholder_literalizer.rb

@@ -77,23 +77,8 @@ module Sequel
         # Yields the receiver and the dataset to the block, which should
         # call #arg on the receiver for each placeholder argument, and
         # return the dataset that you want to load.
-        def loader(dataset)
-          @argn = -1
-          @args = []
-          ds = yield self, dataset
-          sql = ds.clone(:placeholder_literalizer=>self).sql
-
-          last_offset = 0
-          fragments = @args.map do |used_sql, offset, arg, t|
-            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
-            a = [sql[last_offset...offset], arg, t]
-            last_offset = offset
-            a
-          end
-          final_sql = sql[last_offset..-1]
-
-          arity = @argn+1
-          PlaceholderLiteralizer.new(ds.clone, fragments, final_sql, arity)
+        def loader(dataset, &block)
+          PlaceholderLiteralizer.new(*process(dataset, &block))
         end
 
         # Return an Argument with the specified position, or the next position. In
@@ -111,6 +96,51 @@ module Sequel
         def use(sql, arg, transformer)
           @args << [sql, sql.length, arg, transformer]
         end
+
+        private
+
+        # Return an array with two elements, the first being an
+        # SQL string with interpolated prepared argument placeholders
+        # (suitable for inspect), the the second being an array of
+        # SQL fragments suitable for using for creating a 
+        # Sequel::SQL::PlaceholderLiteralString. Designed for use with
+        # emulated prepared statements.
+        def prepared_sql_and_frags(dataset, prepared_args, &block)
+          _, frags, final_sql, _ = process(dataset, &block)
+
+          frags = frags.map(&:first)
+          prepared_sql = String.new
+          frags.each_with_index do |sql, i|
+            prepared_sql << sql
+            prepared_sql << "$#{prepared_args[i]}"
+          end
+          if final_sql
+            frags << final_sql
+            prepared_sql << final_sql
+          end
+
+          [prepared_sql, frags]
+        end
+
+        # Internals of #loader and #prepared_sql_and_frags.
+        def process(dataset)
+          @argn = -1
+          @args = []
+          ds = yield self, dataset
+          sql = ds.clone(:placeholder_literalizer=>self).sql
+
+          last_offset = 0
+          fragments = @args.map do |used_sql, offset, arg, t|
+            raise Error, "placeholder literalizer argument literalized into different string than dataset returned" unless used_sql.equal?(sql)
+            a = [sql[last_offset...offset], arg, t]
+            last_offset = offset
+            a
+          end
+          final_sql = sql[last_offset..-1]
+
+          arity = @argn+1
+          [ds, fragments, final_sql, arity]
+        end
       end
 
       # Create a PlaceholderLiteralizer by yielding a Recorder and dataset to the

data/lib/sequel/dataset/prepared_statements.rb

@@ -67,6 +67,14 @@ module Sequel
         end
         cache_set(:_prepared_sql, super)
       end
+
+      private
+
+      # Report that prepared statements are not emulated, since
+      # all adapters that use this use native prepared statements.
+      def emulate_prepared_statements?
+        false
+      end
     end
 
     # Backbone of the prepared statement support.  Grafts bind variable
@@ -155,13 +163,8 @@ module Sequel
       # prepared_args is present.  If so, they are considered placeholders,
       # and they are substituted using prepared_arg.
       def literal_symbol_append(sql, v)
-        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
-          s = match[1].to_sym
-          if prepared_arg?(s)
-            literal_append(sql, prepared_arg(s))
-          else
-            sql << v.to_s
-          end
+        if @opts[:bind_vars] && /\A\$(.*)\z/ =~ v
+          literal_append(sql, prepared_arg($1.to_sym))
         else
           super
         end
@@ -214,11 +217,6 @@ module Sequel
         @opts[:bind_vars][k]
       end
 
-      # Whether there is a bound value for the given key.
-      def prepared_arg?(k)
-        @opts[:bind_vars].has_key?(k)
-      end
-
       # The symbol cache should always be skipped, since placeholders are symbols.
       def skip_symbol_cache?
         true
@@ -228,9 +226,12 @@ module Sequel
       # support and using the same argument hash so that you can use
       # bind variables/prepared arguments in subselects.
       def subselect_sql_append(sql, ds)
-        ds.clone(:append_sql=>sql, :prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
-          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules).
-          prepared_sql
+        subselect_sql_dataset(sql, ds).prepared_sql
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:prepared_args=>prepared_args, :bind_vars=>@opts[:bind_vars]).
+          send(:to_prepared_statement, :select, nil, :extend=>prepared_statement_modules)
       end
     end
     
@@ -258,11 +259,63 @@ module Sequel
         prepared_args << k
         prepared_arg_placeholder
       end
+    end
+    
+    # Prepared statements emulation support for adapters that don't
+    # support native prepared statements.  Uses a placeholder
+    # literalizer to hold the prepared sql with the ability to
+    # interpolate arguments to prepare the final SQL string.
+    module EmulatePreparedStatementMethods
+      include UnnumberedArgumentMapper
+
+      def run(&block)
+        if @opts[:prepared_sql_frags]
+          sql = literal(Sequel::SQL::PlaceholderLiteralString.new(@opts[:prepared_sql_frags], @opts[:bind_arguments], false))
+          clone(:prepared_sql_frags=>nil, :sql=>sql, :prepared_sql=>sql).run(&block)
+        else
+          super
+        end
+      end
+
+      private
       
-      # Always assume there is a prepared arg in the argument mapper.
-      def prepared_arg?(k)
+      # Turn emulation of prepared statements back on, since ArgumentMapper
+      # turns it off.
+      def emulate_prepared_statements?
         true
       end
+        
+      def emulated_prepared_statement(type, name, values)
+        prepared_sql, frags = Sequel::Dataset::PlaceholderLiteralizer::Recorder.new.send(:prepared_sql_and_frags, self, prepared_args) do |pl, ds|
+          ds = ds.clone(:recorder=>pl)
+
+          case type
+          when :first
+            ds.limit(1)
+          when :update, :insert, :insert_select, :delete
+            ds.with_sql(:"#{type}_sql", *values)
+          when :insert_pk
+            ds.with_sql(:insert_sql, *values)
+          else
+            ds
+          end
+        end
+
+        prepared_args.freeze
+        clone(:prepared_sql_frags=>frags, :prepared_sql=>prepared_sql, :sql=>prepared_sql)
+      end
+
+      # Associates the argument with name k with the next position in
+      # the output array.
+      def prepared_arg(k)
+        prepared_args << k
+        @opts[:recorder].arg
+      end
+
+      def subselect_sql_dataset(sql, ds)
+        super.clone(:recorder=>@opts[:recorder]).
+          with_extend(EmulatePreparedStatementMethods)
+      end
     end
     
     # Set the bind variables to use for the call.  If bind variables have
@@ -315,7 +368,16 @@ module Sequel
     #   DB.call(:select_by_name, name: 'Blah') # Same thing
     def prepare(type, name, *values)
       ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
-      ps.prepared_sql
+
+      ps = if ps.send(:emulate_prepared_statements?)
+        ps = ps.with_extend(EmulatePreparedStatementMethods)
+        ps.send(:emulated_prepared_statement, type, name, values)
+      else
+        sql = ps.prepared_sql
+        ps.prepared_args.freeze
+        ps.clone(:prepared_sql=>sql, :sql=>sql)
+      end
+
       db.set_prepared_statement(name, ps)
       ps
     end
@@ -344,6 +406,12 @@ module Sequel
       prepared_statement_modules
     end
 
+    # Whether prepared statements should be emulated.  True by
+    # default so that adapters have to opt in.
+    def emulate_prepared_statements?
+      true
+    end
+
     def prepared_statement_modules
       []
     end

data/lib/sequel/dataset/sql.rb

@@ -1553,7 +1553,11 @@ module Sequel
 
     # Append literalization of the subselect to SQL string.
     def subselect_sql_append(sql, ds)
-      ds.clone(:append_sql=>sql).sql
+      subselect_sql_dataset(sql, ds).sql
+    end
+
+    def subselect_sql_dataset(sql, ds)
+      ds.clone(:append_sql=>sql)
     end
 
     # The number of decimal digits of precision to use in timestamps.

data/lib/sequel/extensions/caller_logging.rb

@@ -0,0 +1,79 @@
+# frozen-string-literal: true
+#
+# The caller_logging extension includes caller information before
+# query logging, showing which code caused the query.  It skips
+# internal Sequel code, showing the first non-Sequel caller line.
+#
+#   DB.extension :caller_logging
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (source: /path/to/app/foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# You can further filter the caller lines by setting
+# <tt>Database#caller_logging_ignore</tt> to a regexp of additional
+# caller lines to ignore.  This is useful if you have specific
+# methods or internal extensions/plugins that you would also
+# like to ignore as they obscure the code actually making the
+# request.
+#
+#   DB.caller_logging_ignore = %r{/path/to/app/lib/plugins}
+#
+# You can also format the caller before it is placed in the logger,
+# using +caller_logging_formatter+:
+#
+#   DB.caller_logging_formatter = lambda do |caller|
+#     "(#{caller.sub(/\A\/path\/to\/app\//, '')})"
+#   end
+#   DB[:table].first
+#   # Logger:
+#   # (0.000041s) (foo/t.rb:12 in `get_first`) SELECT * FROM table LIMIT 1
+#
+# Related module: Sequel::CallerLogging
+
+require 'rbconfig'
+
+#
+module Sequel
+  module CallerLogging
+    SEQUEL_LIB_PATH = (File.expand_path('../../..', __FILE__) + '/').freeze
+
+    # A regexp of caller lines to ignore, in addition to internal Sequel and Ruby code.
+    attr_accessor :caller_logging_ignore
+
+    # A callable to format the external caller
+    attr_accessor :caller_logging_formatter
+
+    # Include caller information when logging query.
+    def log_connection_yield(sql, conn, args=nil)
+      if !@loggers.empty? && (external_caller = external_caller_for_log)
+        sql = "#{external_caller} #{sql}"
+      end
+      super
+    end
+
+    private
+
+    # The caller to log, ignoring internal Sequel and Ruby code, and user specified
+    # lines to ignore.
+    def external_caller_for_log
+      ignore = caller_logging_ignore
+      c = caller.find do |line|
+        !(line.start_with?(SEQUEL_LIB_PATH) ||
+          line.start_with?(RbConfig::CONFIG["rubylibdir"]) ||
+          (ignore && line =~ ignore))
+      end
+
+      if c
+        c = if formatter = caller_logging_formatter
+          formatter.call(c)
+        else
+          "(source: #{c})"
+        end
+      end
+
+      c
+    end
+  end
+
+  Database.register_extension(:caller_logging, CallerLogging)
+end