sequel 5.70.0 → 5.80.0

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

@@ -498,6 +498,25 @@ module Sequel
         :postgres
       end
 
+      # For constraints that are deferrable, defer constraints until 
+      # transaction commit. Options:
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.defer_constraints
+      #   # SET CONSTRAINTS ALL DEFERRED
+      #
+      #   DB.defer_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" DEFERRED
+      def defer_constraints(opts=OPTS)
+        _set_constraints(' DEFERRED', opts)
+      end
+
       # Use PostgreSQL's DO syntax to execute an anonymous code block.  The code should
       # be the literal code string to use in the underlying procedural language.  Options:
       #
@@ -611,6 +630,24 @@ module Sequel
         super
       end
 
+      # Immediately apply deferrable constraints.
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.immediate_constraints
+      #   # SET CONSTRAINTS ALL IMMEDIATE
+      #
+      #   DB.immediate_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" IMMEDIATE
+      def immediate_constraints(opts=OPTS)
+        _set_constraints(' IMMEDIATE', opts)
+      end
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
@@ -822,6 +859,41 @@ module Sequel
         pg_class_relname(relkind, opts)
       end
 
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which should be
+      # a 64-bit integer).  If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      #   DB.with_advisory_lock(1347){DB.get(1)}
+      #   # SELECT pg_try_advisory_lock(1357) LIMIT 1
+      #   # SELECT 1 AS v LIMIT 1
+      #   # SELECT pg_advisory_unlock(1357) LIMIT 1
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        ds = dataset
+        if server = opts[:server]
+          ds = ds.server(server)
+        end
+      
+        synchronize(server) do |c|
+          begin
+            if opts[:wait]
+              ds.get{pg_advisory_lock(lock_id)}
+              locked = true
+            else
+              unless locked = ds.get{pg_try_advisory_lock(lock_id)}
+                raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+              end
+            end
+
+            yield
+          ensure
+            ds.get{pg_advisory_unlock(lock_id)} if locked
+          end
+        end
+      end
+
       private
 
       # Dataset used to retrieve CHECK constraint information
@@ -1038,6 +1110,31 @@ module Sequel
         end
       end
 
+      # Internals of defer_constraints/immediate_constraints
+      def _set_constraints(type, opts)
+        execute_ddl(_set_constraints_sql(type, opts), opts)
+      end
+
+      # SQL to use for SET CONSTRAINTS
+      def _set_constraints_sql(type, opts)
+        sql = String.new
+        sql << "SET CONSTRAINTS "
+        if constraints = opts[:constraints]
+          dataset.send(:source_list_append, sql, Array(constraints))
+        else
+          sql << "ALL"
+        end
+        sql << type
+      end
+
+      # Consider lock or statement timeout errors as evidence that the table exists
+      # but is locked.
+      def _table_exists?(ds)
+        super
+      rescue DatabaseError => e    
+        raise e unless /canceling statement due to (?:statement|lock) timeout/ =~ e.message 
+      end
+    
       def alter_table_add_column_sql(table, op)
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
@@ -1328,7 +1425,7 @@ module Sequel
         elsif options[:foreign]
           raise(Error, "can't provide both :foreign and :unlogged to create_table") if options[:unlogged]
           'FOREIGN '
-        elsif options[:unlogged]
+        elsif options.fetch(:unlogged){typecast_value_boolean(@opts[:unlogged_tables_default])}
           'UNLOGGED '
         end
 
@@ -1451,7 +1548,11 @@ module Sequel
       # currently visible schemas.
       def filter_schema(ds, opts)
         expr = if schema = opts[:schema]
-          schema.to_s
+          if schema.is_a?(SQL::Identifier)
+            schema.value.to_s
+          else
+            schema.to_s
+          end
         else
           Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
@@ -1719,7 +1820,7 @@ module Sequel
 
       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 override values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
-      Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
+      Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values compounds order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if server_version >= 90100', %w'with update table set from where returning'], ['else', %w'update table set from where returning']])
 
       # Return the results of an EXPLAIN ANALYZE query as a string
@@ -1745,8 +1846,6 @@ module Sequel
           literal_append(sql, args[0])
           sql << ' ' << op.to_s << ' '
           literal_append(sql, args[1])
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
           sql << ')'
         else
           super
@@ -1800,7 +1899,7 @@ module Sequel
       # :phrase :: Similar to :plain, but also adding an ILIKE filter to ensure that
       #            returned rows also include the exact phrase used.
       # :rank :: Set to true to order by the rank, so that closer matches are returned first.
-      # :to_tsquery :: Can be set to :plain or :phrase to specify the function to use to
+      # :to_tsquery :: Can be set to :plain, :phrase, or :websearch to specify the function to use to
       #                convert the terms to a ts_query.
       # :tsquery :: Specifies the terms argument is already a valid SQL expression returning a
       #             tsquery, and can be used directly in the query.
@@ -1820,6 +1919,8 @@ module Sequel
           query_func = case to_tsquery = opts[:to_tsquery]
           when :phrase, :plain
             :"#{to_tsquery}to_tsquery"
+          when :websearch
+            :"websearch_to_tsquery"
           else
             (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
           end
@@ -2084,10 +2185,14 @@ module Sequel
         server_version >= 90500
       end
 
+      # :nocov:
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
+        # SEQUEL6: Remove
         true
       end
+      # :nocov:
 
       # PostgreSQL 8.4+ supports WINDOW clause.
       def supports_window_clause?
@@ -2207,6 +2312,11 @@ module Sequel
         raise(InvalidOperation, "Joined datasets cannot be truncated") if opts[:join]
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%6N%z'"
+      end
+
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << ' FROM '

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

@@ -281,10 +281,6 @@ module Sequel
         false
       end
 
-      def supports_timestamp_usecs?
-        false
-      end
-
       def supports_window_clause?
         true
       end
@@ -378,6 +374,16 @@ module Sequel
 
       private
 
+      # SQLAnywhere only supports 3 digits after the decimal point for times.
+      def default_time_format
+        "'%H:%M:%S.%3N'"
+      end
+
+      # SQLAnywhere only supports 3 digits after the decimal point for timestamps.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%3N'"
+      end
+
       # Use 1 for true on Sybase
       def literal_true
         '1'

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

@@ -145,6 +145,11 @@ module Sequel
         sqlite_version >= 30608
       end
 
+      # SQLite 3.8.2+ supports the without rowid table constraint
+      def support_without_rowid?
+        sqlite_version >= 30802
+      end
+
       # Override the default setting for whether to use timezones in timestamps.
       # It is set to +false+ by default, as SQLite's date/time methods do not
       # support timezones in timestamps.
@@ -344,9 +349,17 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT tables via :strict option
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
       def create_table_sql(name, generator, options)
-        "#{super}#{' STRICT' if options[:strict]}"
+        if options[:strict] && options[:without_rowid]
+          "#{super} STRICT, WITHOUT ROWID"
+        elsif options[:strict]
+          "#{super} STRICT"
+        elsif options[:without_rowid]
+          "#{super} WITHOUT ROWID"
+        else
+          super
+        end
       end
 
       # SQLite support creating temporary views.
@@ -504,7 +517,6 @@ module Sequel
             # table_xinfo PRAGMA used, remove hidden columns
             # that are not generated columns
             if row[:generated] = (row.delete(:hidden) != 0)
-              next unless row[:type].end_with?(' GENERATED ALWAYS')
               row[:type] = row[:type].sub(' GENERATED ALWAYS', '')
             end
           end
@@ -918,6 +930,11 @@ module Sequel
         500
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        db.use_timestamp_timezones? ? "'%Y-%m-%d %H:%M:%S.%6N%z'" : super
+      end
+
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(', ')

data/lib/sequel/adapters/sqlite.rb

@@ -111,6 +111,18 @@ module Sequel
       #              static data that you do not want to modify
       # :timeout :: how long to wait for the database to be available if it
       #             is locked, given in milliseconds (default is 5000)
+      # :setup_regexp_function :: enable use of Regexp objects with SQL
+      #             'REGEXP' operator. If the value is :cached or "cached",
+      #             caches the generated regexps, which can result in a memory
+      #             leak if dynamic regexps are used.  If the value is a Proc,
+      #             it will be called with a string for the regexp and a string
+      #             for the value to compare, and should return whether the regexp
+      #             matches.
+      # :regexp_function_cache :: If setting +setup_regexp_function+ to +cached+, this
+      #             determines the cache to use.  It should either be a proc or a class, and it
+      #             defaults to +Hash+. You can use +ObjectSpace::WeakKeyMap+ on Ruby 3.3+ to
+      #             have the VM automatically remove regexps from the cache after they
+      #             are no longer used.
       def connect(server)
         opts = server_opts(server)
         opts[:database] = ':memory:' if blank_object?(opts[:database])
@@ -126,9 +138,7 @@ module Sequel
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
 
         if typecast_value_boolean(opts[:setup_regexp_function])
-          db.create_function("regexp", 2) do |func, regexp_str, string|
-            func.result = Regexp.new(regexp_str).match(string) ? 1 : 0
-          end
+          setup_regexp_function(db, opts[:setup_regexp_function])
         end
         
         class << db
@@ -202,6 +212,35 @@ module Sequel
         @conversion_procs['datetime'] = @conversion_procs['timestamp'] = method(:to_application_timestamp)
         set_integer_booleans
       end
+
+      def setup_regexp_function(db, how)
+        case how
+        when Proc
+          # nothing
+        when :cached, "cached"
+          cache = @opts[:regexp_function_cache] || Hash
+          cache = cache.is_a?(Proc) ? cache.call : cache.new
+          how = if RUBY_VERSION >= '2.4'
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match?(str)
+            end
+          else
+            lambda do |regexp_str, str|
+              (cache[regexp_str] ||= Regexp.new(regexp_str)).match(str)
+            end
+          end
+        else
+          how = if RUBY_VERSION >= '2.4'
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match?(str)}
+          else
+            lambda{|regexp_str, str| Regexp.new(regexp_str).match(str)}
+          end
+        end
+
+        db.create_function("regexp", 2) do |func, regexp_str, str|
+          func.result = how.call(regexp_str, str) ? 1 : 0
+        end
+      end
       
       # Yield an available connection.  Rescue
       # any SQLite3::Exceptions and turn them into DatabaseErrors.

data/lib/sequel/connection_pool.rb

@@ -70,8 +70,10 @@ class Sequel::ConnectionPool
       else
         pc = if opts[:single_threaded]
           opts[:servers] ? :sharded_single : :single
-        #elsif RUBY_VERSION >= '3.2' # SEQUEL6 or maybe earlier
-        #  opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :nocov:
+        elsif RUBY_VERSION >= '3.4' # SEQUEL6 or maybe earlier switch to 3.2
+          opts[:servers] ? :sharded_timed_queue : :timed_queue
+        # :nocov:
         else
           opts[:servers] ? :sharded_threaded : :threaded
         end

data/lib/sequel/database/misc.rb

@@ -149,6 +149,7 @@ module Sequel
       @schemas = {}
       @prepared_statements = {}
       @transactions = {}
+      @transactions.compare_by_identity
       @symbol_literal_cache = {}
 
       @timezone = nil
@@ -263,8 +264,8 @@ module Sequel
     # Proxy the literal call to the dataset.
     #
     #   DB.literal(1)   # 1
-    #   DB.literal(:a)  # a
-    #   DB.literal('a') # 'a'
+    #   DB.literal(:a)  # "a" # or `a`, [a], or a, depending on identifier quoting
+    #   DB.literal("a") # 'a'
     def literal(v)
       schema_utility_dataset.literal(v)
     end

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,12 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
+    #                   'rowid' column, that uniquely identifies that row within the table.
+    #                   If this option is used, the 'rowid' column is omitted, which can
+    #                   sometimes provide some space and speed advantages. Note that you
+    #                   must then provide an explicit primary key when you create the table.
+    #                   This option is supported on SQLite 3.8.2+.
     #
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
@@ -246,10 +252,10 @@ module Sequel
     # For databases where replacing a view is not natively supported, support
     # is emulated by dropping a view with the same name before creating the view.
     def create_or_replace_view(name, source, options = OPTS)
-      if supports_create_or_replace_view?
+      if supports_create_or_replace_view? && !options[:materialized]
         options = options.merge(:replace=>true)
       else
-        swallow_database_error{drop_view(name)}
+        swallow_database_error{drop_view(name, options)}
       end
 
       create_view(name, source, options)
@@ -712,8 +718,9 @@ module Sequel
       e = options[:ignore_index_errors] || options[:if_not_exists]
       generator.indexes.each do |index|
         begin
-          pr = proc{index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}}
-          supports_transactional_ddl? ? transaction(:savepoint=>:only, &pr) : pr.call
+          transaction(:savepoint=>:only, :skip_transaction=>supports_transactional_ddl? == false) do
+            index_sql_list(name, [index]).each{|sql| execute_ddl(sql)}
+          end
         rescue Error
           raise unless e
         end

data/lib/sequel/database/transactions.rb

@@ -166,6 +166,8 @@ module Sequel
     #               uses :auto_savepoint, you can set this to false to not use a savepoint.
     #               If the value given for this option is :only, it will only create a
     #               savepoint if it is inside a transaction.
+    # :skip_transaction :: If set, do not actually open a transaction or savepoint,
+    #                      just checkout a connection and yield it.
     #
     # PostgreSQL specific options:
     #
@@ -193,6 +195,10 @@ module Sequel
         end
       else
         synchronize(opts[:server]) do |conn|
+          if opts[:skip_transaction]
+            return yield(conn)
+          end
+
           if opts[:savepoint] == :only
             if supports_savepoints?
               if _trans(conn)

data/lib/sequel/dataset/actions.rb

@@ -356,9 +356,11 @@ module Sequel
     #            This does not have an effect if +values+ is a Dataset.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
+    # :skip_transaction :: Do not use a transaction even when using multiple
+    #                      INSERT queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.
     def import(columns, values, opts=OPTS)
-      return @db.transaction{insert(columns, values)} if values.is_a?(Dataset)
+      return insert(columns, values) if values.is_a?(Dataset)
 
       return if values.empty?
       raise(Error, 'Using Sequel::Dataset#import with an empty column array is not allowed') if columns.empty?
@@ -588,6 +590,8 @@ module Sequel
     #                   if your ORDER BY expressions are not simple columns, if they contain
     #                   qualified identifiers that would be ambiguous unqualified, if they contain
     #                   any identifiers that are aliased in SELECT, and potentially other cases.
+    # :skip_transaction :: Do not use a transaction. This can be useful if you want to prevent
+    #                      a lock on the database table, at the expense of consistency.
     #
     # Examples:
     #
@@ -1111,11 +1115,9 @@ module Sequel
     # are provided. When only a single value or statement is provided, then yield
     # without using a transaction.
     def _import_transaction(values, trans_opts, &block)
-      if values.length > 1
-        @db.transaction(trans_opts, &block)
-      else
-        yield
-      end
+      # OK to mutate trans_opts as it is generated by _import
+      trans_opts[:skip_transaction] = true if values.length <= 1
+      @db.transaction(trans_opts, &block)
     end
   
     # Internals of +select_hash+ and +select_hash_groups+

data/lib/sequel/dataset/dataset_module.rb

@@ -21,7 +21,7 @@ module Sequel
         where exclude exclude_having having
         distinct grep group group_and_count group_append 
         limit offset order order_append order_prepend reverse 
-        select select_all select_append select_group server
+        select select_all select_append select_group select_prepend server
       METHS
 
       # Define a method in the module

data/lib/sequel/dataset/features.rb

@@ -25,11 +25,16 @@ module Sequel
       false
     end
 
+    # :nocov:
+
     # Whether the dataset requires SQL standard datetimes. False by default,
-    # as most allow strings with ISO 8601 format.
+    # as most allow strings with ISO 8601 format. Only for backwards compatibility,
+    # no longer used internally, do not use in new code.
     def requires_sql_standard_datetimes?
+      # SEQUEL6: Remove
       false
     end
+    # :nocov:
 
     # Whether type specifiers are required for prepared statement/bound
     # variable argument placeholders (i.e. :bv__integer), false by default.
@@ -183,10 +188,14 @@ module Sequel
       true
     end
 
+    # :nocov:
+
     # Whether the dataset supports timezones in literal timestamps, false by default.
     def supports_timestamp_timezones?
+      # SEQUEL6: Remove
       false
     end
+    # :nocov:
     
     # Whether the dataset supports fractional seconds in literal timestamps, true by default.
     def supports_timestamp_usecs?

data/lib/sequel/dataset/graph.rb

@@ -253,6 +253,7 @@ module Sequel
     # Remove the splitting of results into subhashes, and all metadata
     # related to the current graph (if any).
     def ungraphed
+      return self unless opts[:graph]
       clone(:graph=>nil)
     end