sequel 5.91.0 → 5.93.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d13e0998a9eb78392a4f9f7793b2ceceebf87fa5a4dd6f9fcfd5bbd05a686d83
-  data.tar.gz: d4c7da82fb811928c58a096b2d5fc500cdb7cee1bbff14795817b5bd3f4d3360
+  metadata.gz: dd35e8223b7f6d450cf4c1efeaad152236b4a1e360299aa46b03841bb45996c6
+  data.tar.gz: '096a62cc241cf6f48d0c2b3e0799402f21aa24a1196a332e022ef53ebaaeea85'
 SHA512:
-  metadata.gz: c2bbfc37fbd2b97796c96352a0f1d7d41053f91f4b61e3888a5aea712b9a59c7600e8ed58a15919cef7d8b0cc1c35e4bc3d142206ac245ed6f4f13575188f3b9
-  data.tar.gz: 8f4c0b7b95ec967c471455df69e8b5b5ff9c2104790c7c18abaa9601f2e7c4514952d4410aac1e3f720304f30af2d7299ea0f1233a7e083bcb901c8a03f697bb
+  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/database/dataset_defaults.rb

@@ -61,7 +61,7 @@ module Sequel
     #   # SELECT id, name FROM table WHERE active ORDER BY id
     def extend_datasets(mod=nil, &block)
       raise(Error, "must provide either mod or block, not both") if mod && block
-      mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"} if block
+      mod = Sequel.set_temp_name(Dataset::DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location[0,2].join(':')})"} if block
       if @dataset_modules.empty?
        @dataset_modules = [mod]
        @dataset_class = Sequel.set_temp_name(Class.new(@dataset_class)){"Sequel::Dataset::_Subclass"}

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/query.rb

@@ -1240,7 +1240,7 @@ module Sequel
       def with_extend(*mods, &block)
         c = Sequel.set_temp_name(Class.new(self.class)){"Sequel::Dataset::_Subclass"}
         c.include(*mods) unless mods.empty?
-        c.include(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location.join(':')})"}) if block
+        c.include(Sequel.set_temp_name(DatasetModule.new(&block)){"Sequel::Dataset::_DatasetModule(#{block.source_location[0,2].join(':')})"}) if block
         o = c.freeze.allocate
         o.instance_variable_set(:@db, @db)
         o.instance_variable_set(:@opts, @opts)

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
 
@@ -1430,10 +1433,6 @@ module Sequel
     # calls +sql_literal+ if object responds to it, otherwise raises an error.
     # If a database specific type is allowed, this should be overriden in a subclass.
     def literal_other_append(sql, v)
-      # We can't be sure if v will always literalize to the same SQL, so
-      # don't cache SQL for a dataset that uses this.
-      disable_sql_caching!
-
       if v.respond_to?(:sql_literal_append)
         v.sql_literal_append(self, sql)
       elsif v.respond_to?(:sql_literal)
@@ -1441,6 +1440,12 @@ module Sequel
       else
         raise Error, "can't express #{v.inspect} as a SQL literal"
       end
+
+      if !v.respond_to?(:sql_literal_allow_caching?) || !v.sql_literal_allow_caching?(self)
+        # We can't be sure if v will always literalize to the same SQL, so
+        # don't cache SQL for a dataset that uses this.
+        disable_sql_caching!
+      end
     end
 
     # SQL fragment for Sequel::SQLTime, containing just the time part

data/lib/sequel/extensions/migration.rb

@@ -287,6 +287,10 @@ module Sequel
     def set_column_allow_null(name, allow_null=true)
       @actions << [:set_column_allow_null, name, !allow_null]
     end
+
+    def set_column_not_null(name)
+      @actions << [:set_column_allow_null, name]
+    end
   end
 
   # The preferred method for writing Sequel migrations, using a DSL:

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/model/base.rb

@@ -533,10 +533,28 @@ module Sequel
         end
       end
 
+      # Return a qualified identifier or array of qualified identifiers for
+      # the model's primary key.  Uses the given qualifier if provided, or
+      # the table_name otherwise. If the model does not have a primary key,
+      # raises an +Error+.
+      #
+      #   Artist.order(Artist.qualified_primary_key)
+      #   # SELECT * FROM artists ORDER BY artists.id
+      def qualified_primary_key(qualifier=table_name)
+        case key = @primary_key
+        when Symbol
+          SQL::QualifiedIdentifier.new(qualifier, key)
+        when Array
+          key.map{|k| SQL::QualifiedIdentifier.new(qualifier, k)}
+        else
+          raise(Error, "#{self} does not have a primary key")
+        end
+      end
+
       # Return a hash where the keys are qualified column references.  Uses the given
       # qualifier if provided, or the table_name otherwise. This is useful if you
       # plan to join other tables to this table and you want the column references
-      # to be qualified.
+      # to be qualified. If the model does not have a primary key, raises an +Error+.
       #
       #   Artist.where(Artist.qualified_primary_key_hash(1))
       #   # SELECT * FROM artists WHERE (artists.id = 1)
@@ -2260,7 +2278,7 @@ END
       # Return the dataset ordered by the model's primary key.  This should not
       # be used if the model does not have a primary key.
       def _force_primary_key_order
-        cached_dataset(:_pk_order_ds){order(*model.primary_key)}
+        cached_dataset(:_pk_order_ds){order(*unambiguous_primary_key)}
       end
 
       # If the dataset is not already ordered, and the model has a primary key,
@@ -2288,6 +2306,15 @@ END
         end
       end
 
+      # The primary key for the dataset's model, qualified if the dataset is joined.
+      def unambiguous_primary_key
+        if joined_dataset?
+          model.qualified_primary_key
+        else
+          model.primary_key
+        end
+      end
+
       def non_sql_option?(key)
         super || key == :model
       end

data/lib/sequel/plugins/instance_filters.rb

@@ -102,7 +102,10 @@ module Sequel
         
         # Apply the instance filters to the given dataset
         def apply_instance_filters(ds)
-          instance_filters.inject(ds){|ds1, i| ds1.where(*i[0], &i[1])}
+          instance_filters.inject(ds) do |ds1, i|
+            block = i[1]
+            ds1.where(*i[0], &block)
+          end
         end
         
         # Clear the instance filters.

data/lib/sequel/plugins/paged_operations.rb

@@ -157,13 +157,16 @@ module Sequel
             raise Error, "the paged_operations plugin is not supported on DB2 when using emulated offsets, set the :offset_strategy Database option to 'limit_offset' or 'offset_fetch'"
           end
 
-          case pk = model.primary_key
+          case pk = unambiguous_primary_key
           when Symbol
             Sequel.identifier(pk)
           when Array
             raise Error, "cannot use #{meth} on a model with a composite primary key"
-          else
+          when nil
             raise Error, "cannot use #{meth} on a model without a primary key"
+          else
+            # Likely SQL::QualifiedIdentifier, if the dataset is joined.
+            pk
           end
         end
 

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 = 91
+  MINOR = 93
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.91.0
+  version: 5.93.0
 platform: ruby
 authors:
 - Jeremy Evans
 bindir: bin
 cert_chain: []
-date: 2025-04-01 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -448,7 +448,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
 summary: The Database Toolkit for Ruby
 test_files: []