sequel 5.92.0 → 5.93.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df46d23e3607466eb34477a5ba9c31d14fd57294275088599f8ef4d561179faf
-  data.tar.gz: 9566fcb614fded77e5e20c929c9ed5cb6786e0548c3e59837ae2dd1a1877762d
+  metadata.gz: dd35e8223b7f6d450cf4c1efeaad152236b4a1e360299aa46b03841bb45996c6
+  data.tar.gz: '096a62cc241cf6f48d0c2b3e0799402f21aa24a1196a332e022ef53ebaaeea85'
 SHA512:
-  metadata.gz: 8375cb4204be00b492b841fea5427dce809e43d119c6fd9f559cbfa1b4b9f652e752d22e52a93942a8a228166829d4227202e0f783a89f790d4fad40a8eb0963
-  data.tar.gz: 4c6bbc4bd1172ed8c5117bd628651757b8685fab754b4d664ceb3254917fbeb58d778bccd3b8dbe998e4694f185baa4e630910dc1de8fe1b5026d23e95c215b4
+  metadata.gz: 0b66c7e30dfb69468ad41bfe64de4e0442ad62590ea735b2e4bb591c46b949794a7a453c21532999c89296694f0136d9353041ec56fc470ab2ba0483f0534d61
+  data.tar.gz: 978dcd457829ff39f1ae9769dc574049cf29d07a2dbc8e307aa806a7b1954cd72432257de37d9e5236269b5746f615f8d0f7feb4979e9b86b619f582344afc29

data/lib/sequel/adapters/oracle.rb

@@ -353,6 +353,20 @@ module Sequel
           i = prepared_args.length
           LiteralString.new(":#{i}")
         end
+
+        # Avoid infinite recursion on Oracle <12 for datasets with limits
+        # (which are implemented via subqueries).  If the given dataset's
+        # prepared args are the same object as current dataset's, call the
+        # standard Sequel::Dataset#subselect_sql_append method, instead
+        # of calling super (which will call prepared_sql and result in
+        # infinite recursion).
+        def subselect_sql_append(sql, ds)
+          if !supports_fetch_next_rows? && ds.opts[:prepared_args].equal?(@opts[:prepared_args])
+            orig_subselect_sql_append(sql, ds)
+          else
+            super
+          end
+        end
       end
       
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
@@ -383,6 +397,8 @@ module Sequel
 
       private
 
+      alias orig_subselect_sql_append subselect_sql_append
+
       def literal_other_append(sql, v)
         case v
         when OraDate

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

@@ -101,7 +101,7 @@ module Sequel
 
     def self.mock_adapter_setup(db)
       db.instance_exec do
-        @server_version = 150000
+        @server_version = 170000
         initialize_postgres_adapter
         extend(MockAdapterDatabaseMethods)
       end
@@ -1888,9 +1888,48 @@ module Sequel
         super
       end
 
-      # Return the results of an EXPLAIN query as a string
+      # Return the results of an EXPLAIN query.  Boolean options:
+      #
+      # :analyze :: Use the ANALYZE option.
+      # :buffers :: Use the BUFFERS option.
+      # :costs :: Use the COSTS option.
+      # :generic_plan :: Use the GENERIC_PLAN option.
+      # :memory :: Use the MEMORY option.
+      # :settings :: Use the SETTINGS option.
+      # :summary :: Use the SUMMARY option.
+      # :timing :: Use the TIMING option.
+      # :verbose :: Use the VERBOSE option.
+      # :wal :: Use the WAL option.
+      #
+      # Non boolean options:
+      #
+      # :format :: Use the FORMAT option to change the format of the
+      #            returned value.  Values can be :text, :xml, :json,
+      #            or :yaml.
+      # :serialize :: Use the SERIALIZE option to get timing on
+      #               serialization.  Values can be :none, :text, or
+      #               :binary.
+      #
+      # See the PostgreSQL EXPLAIN documentation for an explanation of
+      # what each option does.
+      #
+      # In most cases, the return value is a single string.  However,
+      # using the <tt>format: :json</tt> option can result in the return
+      # value being an array containing a hash.
       def explain(opts=OPTS)
-        with_sql((opts[:analyze] ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ') + select_sql).map(:'QUERY PLAN').join("\r\n")
+        rows = clone(:append_sql=>explain_sql_string_origin(opts)).map(:'QUERY PLAN')
+
+        if rows.length == 1
+          rows[0]
+        elsif rows.all?{|row| String === row}
+          rows.join("\r\n") 
+        # :nocov:
+        else
+          # This branch is unreachable in tests, but it seems better to just return
+          # all rows than throw in error if this case actually happens.
+          rows
+        # :nocov:
+        end
       end
 
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
@@ -2417,7 +2456,65 @@ module Sequel
           c ||= true
         end
       end
+
+      EXPLAIN_BOOLEAN_OPTIONS = {}
+      %w[analyze verbose costs settings generic_plan buffers wal timing summary memory].each do |str|
+        EXPLAIN_BOOLEAN_OPTIONS[str.to_sym] = str.upcase.freeze
+      end
+      EXPLAIN_BOOLEAN_OPTIONS.freeze
+
+      EXPLAIN_NONBOOLEAN_OPTIONS = {
+        :serialize => {:none=>"SERIALIZE NONE", :text=>"SERIALIZE TEXT", :binary=>"SERIALIZE BINARY"}.freeze,
+        :format => {:text=>"FORMAT TEXT", :xml=>"FORMAT XML", :json=>"FORMAT JSON", :yaml=>"FORMAT YAML"}.freeze
+      }.freeze
     
+      # A mutable string used as the prefix when explaining a query.
+      def explain_sql_string_origin(opts)
+        origin = String.new
+        origin << 'EXPLAIN '
+
+        # :nocov:
+        if server_version < 90000
+          if opts[:analyze]
+            origin << 'ANALYZE '
+          end
+
+          return origin
+        end
+        # :nocov:
+
+        comma = nil
+        paren = "("
+
+        add_opt = lambda do |str, value|
+          origin << paren if paren
+          origin << comma if comma
+          origin << str
+          origin << " FALSE" unless value
+          comma ||= ', '
+          paren &&= nil
+        end
+
+        EXPLAIN_BOOLEAN_OPTIONS.each do |key, str|
+          unless (value = opts[key]).nil?
+            add_opt.call(str, value)
+          end
+        end
+
+        EXPLAIN_NONBOOLEAN_OPTIONS.each do |key, e_opts|
+          if value = opts[key]
+            if str = e_opts[value]
+              add_opt.call(str, true)
+            else
+              raise Sequel::Error, "unrecognized value for Dataset#explain #{key.inspect} option: #{value.inspect}"
+            end
+          end
+        end
+
+        origin << ') ' unless paren
+        origin
+      end
+
       # Add ON CONFLICT clause if it should be used
       def insert_conflict_sql(sql)
         if opts = @opts[:insert_conflict]

data/lib/sequel/dataset/prepared_statements.rb

@@ -91,8 +91,14 @@ module Sequel
         @opts[:log_sql]
       end
       
-      # The type of prepared statement, should be one of :select, :first,
-      # :insert, :update, :delete, or :single_value
+      # The type of SQL to generate for the prepared statement.  Generally
+      # the same as #prepared_type, but can be different.
+      def prepared_sql_type
+        @opts[:prepared_sql_type] || prepared_type
+      end
+      
+      # The type of prepared statement, which controls how the prepared statement
+      # handles results from the database.
       def prepared_type
         @opts[:prepared_type]
       end
@@ -141,7 +147,7 @@ module Sequel
       # Returns the SQL for the prepared statement, depending on
       # the type of the statement and the prepared_modify_values.
       def prepared_sql
-        case prepared_type
+        case prepared_sql_type
         when :select, :all, :each
           # Most common scenario, so listed first.
           select_sql
@@ -182,34 +188,30 @@ module Sequel
       
       # Run the method based on the type of prepared statement.
       def run(&block)
-        case prepared_type
+        case type = prepared_type
         when :select, :all
-          all(&block)
+          with_sql_all(prepared_sql, &block)
         when :each
-          each(&block)
-        when :insert_select
-          with_sql(prepared_sql).first
-        when :first
-          first
+          with_sql_each(prepared_sql, &block)
+        when :insert_select, :first
+          with_sql_first(prepared_sql)
         when :insert, :update, :delete
           if opts[:returning] && supports_returning?(prepared_type)
             returning_fetch_rows(prepared_sql)
-          elsif prepared_type == :delete
-            delete
+          elsif type == :delete
+            with_sql_delete(prepared_sql)
           else
-            public_send(prepared_type, *prepared_modify_values)
+            force_prepared_sql.public_send(type, *prepared_modify_values)
           end
-        when :insert_pk
-          fetch_rows(prepared_sql){|r| return r.values.first}
+        when :insert_pk, :single_value
+          with_sql_single_value(prepared_sql)
         when Array
           # :nocov:
-          case prepared_type[0]
+          case type[0]
           # :nocov:
           when :map, :as_hash, :to_hash, :to_hash_groups
-            public_send(*prepared_type, &block) 
+            force_prepared_sql.public_send(*type, &block) 
           end
-        when :single_value
-          single_value
         else
           raise Error, "unsupported prepared statement type used: #{prepared_type.inspect}"
         end
@@ -217,6 +219,16 @@ module Sequel
       
       private
       
+      # If the prepared_sql_type does not match the prepared statement, return a clone that
+      # with the prepared SQL, to ensure the prepared_sql_type is respected.
+      def force_prepared_sql
+        if prepared_sql_type != prepared_type
+          with_sql(prepared_sql)
+        else
+          self
+        end
+      end
+      
       # Returns the value of the prepared_args hash for the given key.
       def prepared_arg(k)
         @opts[:bind_vars][k]
@@ -294,11 +306,12 @@ module Sequel
         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
+          sql_type = prepared_sql_type || type
+          case sql_type
           when :first, :single_value
             ds.limit(1)
           when :update, :insert, :insert_select, :delete
-            ds.with_sql(:"#{type}_sql", *values)
+            ds.with_sql(:"#{sql_type}_sql", *values)
           when :insert_pk
             ds.with_sql(:insert_sql, *values)
           else
@@ -344,13 +357,23 @@ module Sequel
       clone(:bind_vars=>bind_vars)
     end
     
-    # For the given type (:select, :first, :insert, :insert_select, :update, :delete, or :single_value),
-    # run the sql with the bind variables specified in the hash.  +values+ is a hash passed to
-    # insert or update (if one of those types is used), which may contain placeholders.
+    # For the given type, run the sql with the bind variables specified in the hash.
+    # +values+ is a hash passed to insert or update (if one of those types is used),
+    # which may contain placeholders.
+    #
+    # The following types are supported:
+    # 
+    # * :select, :all, :each, :first, :single_value, :insert, :insert_select, :insert_pk, :update, :delete
+    # * Array where first element is :map, :as_hash, :to_hash, :to_hash_groups (remaining elements
+    #   are passed to the related method)
     #
     #   DB[:table].where(id: :$id).call(:first, id: 1)
     #   # SELECT * FROM table WHERE id = ? LIMIT 1 -- (1)
     #   # => {:id=>1}
+    #
+    #   DB[:table].where(id: :$id).call(:update, {c: 1, id: 2}, col: :$c)
+    #   # UPDATE table WHERE id = ? SET col = ? -- (2, 1)
+    #   # => 1
     def call(type, bind_variables=OPTS, *values, &block)
       to_prepared_statement(type, values, :extend=>bound_variable_modules).call(bind_variables, &block)
     end
@@ -371,6 +394,14 @@ module Sequel
     #   # => {:id=>1, :name=>'Blah'}
     #
     #   DB.call(:select_by_name, name: 'Blah') # Same thing
+    #
+    # +values+ given are passed to +insert+ or +update+ if they are used:
+    #
+    #   ps = DB[:table].where(id: :$i).prepare(:update, :update_name, name: :$n)
+    #
+    #   ps.call(i: 1, n: 'Blah')
+    #   # UPDATE table WHERE id = ? SET name = ? -- (1, 'Blah')
+    #   # => 1
     def prepare(type, name, *values)
       ps = to_prepared_statement(type, values, :name=>name, :extend=>prepared_statement_modules, :no_delayed_evaluations=>true)
 
@@ -387,6 +418,19 @@ module Sequel
       ps
     end
     
+    # Set the type of SQL to use for prepared statements based on this
+    # dataset.  Prepared statements default to using the same SQL type
+    # as the type that is passed to #prepare/#call, but there are cases
+    # where it is helpful to use a different SQL type.
+    #
+    # Available types are: :select, :first, :single_value, :update,
+    # :delete, :insert, :insert_select, :insert_pk
+    #
+    # Other types are treated as :select.
+    def prepare_sql_type(type)
+      clone(:prepared_sql_type => type)
+    end
+
     protected
     
     # Return a cloned copy of the current dataset extended with

data/lib/sequel/dataset/sql.rb

@@ -685,10 +685,10 @@ module Sequel
     # being quoted, returns name as a string.  If identifiers are being quoted
     # quote the name with quoted_identifier.
     def quote_identifier_append(sql, name)
+      name = name.value if name.is_a?(SQL::Identifier)
       if name.is_a?(LiteralString)
         sql << name
       else
-        name = name.value if name.is_a?(SQL::Identifier)
         name = input_identifier(name)
         if quote_identifiers?
           quoted_identifier_append(sql, name)
@@ -700,11 +700,14 @@ module Sequel
 
     # Append literalization of identifier or unqualified identifier to SQL string.
     def quote_schema_table_append(sql, table)
-      schema, table = schema_and_table(table)
-      if schema
-        quote_identifier_append(sql, schema)
+      qualifiers = split_qualifiers(table)
+      table = qualifiers.pop
+
+      qualifiers.each do |q|
+        quote_identifier_append(sql, q)
         sql << '.'
       end
+
       quote_identifier_append(sql, table)
     end
 

data/lib/sequel/extensions/pg_auto_parameterize.rb

@@ -463,6 +463,11 @@ module Sequel
           @opts[:no_auto_parameterize] ? super : QueryString.new
         end
 
+        # A mutable string used as the prefix when explaining a query.
+        def explain_sql_string_origin(opts)
+          @opts[:no_auto_parameterize] ? super : (QueryString.new << super)
+        end
+
         # If subquery uses with_sql with a method name symbol, get the dataset
         # with_sql was called on, and use that as the subquery, recording the
         # arguments to with_sql that will be used to calculate the sql.

data/lib/sequel/sql.rb

@@ -1733,12 +1733,11 @@ module Sequel
 
       # Automatically convert SQL::Identifiers to strings
       def convert_identifier(identifier)
-        case identifier
-        when SQL::Identifier
-          identifier.value.to_s
-        else
-          identifier
+        if identifier.is_a?(SQL::Identifier)
+          identifier = identifier.value
+          identifier = identifier.to_s unless identifier.is_a?(LiteralString)
         end
+        identifier
       end
     end
     
@@ -2053,6 +2052,9 @@ module Sequel
     end
   end
   
+  SQL::Constants::OLD = SQL::Identifier.new(LiteralString.new("OLD").freeze)
+  SQL::Constants::NEW = SQL::Identifier.new(LiteralString.new("NEW").freeze)
+
   include SQL::Constants
   extend SQL::Builders
   extend SQL::OperatorBuilders

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 92
+  MINOR = 93
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.92.0
+  version: 5.93.0
 platform: ruby
 authors:
 - Jeremy Evans