sequel 5.77.0 → 5.79.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9951772dd3785c8ce91090bd31034a1e57ac5dcbc17af774b980a115cea15347
-  data.tar.gz: 3cfcaefaf6aa4758ef2cfaf78cbe6ccdc688e8b3836718bd63c42c5bdb220026
+  metadata.gz: 154517820668c8c59f141797157a9945ae3afaeb482e997619e68e9bebc5c70a
+  data.tar.gz: c7991308e696d0f931f46cf38c301986c9094a44bca94a1d6749a0b798cb1d9c
 SHA512:
-  metadata.gz: '0885577c11fd7285a5278d0a1b52ae411e557cec7bce2f3a49f8128a0be63928ebfa55b2b1a86c8b28ee1c3782c1dc5ebf5d4ecf00f0194ad33da89cb6ffc12a'
-  data.tar.gz: ccc7b8b6c68049ee1fed2211a3d193157ee36fde9c340324eba2a8cebd8925bc97b4dc1777b61f8a2fb94d83439c41f33afb832c080f4d54bab16d09924a4fe2
+  metadata.gz: 7efb6286d8eded4c0064199f7335e9cd2b0575942fd52040b29c52e26498d1531168435d86ca6e42474512ac21c1b151db85dd4db0fa5ff6b3f90dad73568a3b
+  data.tar.gz: 7ef17f79333fdabe90485b105fdc24925c8c75f41dc78f83f5400ebc39b0ac2b3709881624086526559132c8346c1dc8f07b9384a39bb838d1132bf4a7040ec1

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 5.79.0 (2024-04-01)
+
+* Support create_or_replace_view with :materialized option on PostgreSQL (nashby) (#2144)
+
+* Support :unlogged_tables_default Database option on Postgres for making created tables unlogged by default (jeremyevans) (#2134)
+
+* Add Dataset#select_prepend for prepending to the current selected columns (jeremyevans) (#2139)
+
+=== 5.78.0 (2024-03-01)
+
+* Support SQLite 3.45+ jsonb functions in the sqlite_json_ops extension (jeremyevans) (#2133)
+
+* Support compounds (e.g. UNION) in conjunction with Database#values on PostgreSQL (jeremyevans) (#2137)
+
+* Support :use_advisory_lock option to Migrator.run to use advisory locks when running migrations (jeremyevans) (#2089)
+
+* Support Database#with_advisory_lock on PostgreSQL, MySQL, and Microsoft SQL Server (jeremyevans) (#2089)
+
 === 5.77.0 (2024-02-01)
 
 * Support create_table :without_rowid option on SQLite (loranger32) (#2126)
@@ -16,7 +34,7 @@
 
 * Support on_duplicate_columns={raise,warn} parameter in connection URL when using duplicate_columns_handler extension (jeremyevans)
 
-* Add transaction_connection_validator extension for retrying transactions on new connection if ther is a disconnect error when starting transaction (jeremyevans)
+* Add transaction_connection_validator extension for retrying transactions on new connection if there is a disconnect error when starting transaction (jeremyevans)
 
 === 5.76.0 (2024-01-01)
 

data/README.rdoc

@@ -22,10 +22,10 @@ RDoc Documentation :: https://sequel.jeremyevans.net/rdoc
 Source Code :: https://github.com/jeremyevans/sequel
 Bug tracking (GitHub Issues) :: https://github.com/jeremyevans/sequel/issues
 Discussion Forum (GitHub Discussions) :: https://github.com/jeremyevans/sequel/discussions
-Alternate Discussion Forum (sequel-talk Google Group) :: http://groups.google.com/group/sequel-talk
+Archived Discussion Forum (sequel-talk Google Group) :: https://www.mail-archive.com/sequel-talk@googlegroups.com/
 
 If you have questions about how to use Sequel, please ask on
-GitHub Discussions or the sequel-talk Google Group.
+GitHub Discussions.
 Only use the the bug tracker to report
 bugs in Sequel, not to ask for help on using Sequel.
 
@@ -368,10 +368,12 @@ Like +order+, +select+ overrides an existing selection:
   posts.select(:stamp).select(:name)
   # SELECT name FROM posts
 
-As you might expect, there is an +order_append+ equivalent for +select+ called +select_append+:
+As you might expect, there are +order_append+ and +order_prepend+ equivalents for +select+ called +select_append+ and +select_prepend+:
 
   posts.select(:stamp).select_append(:name)
   # SELECT stamp, name FROM posts
+  posts.select(:stamp).select_prepend(:name)
+  # SELECT name, stamp FROM posts
   
 === Deleting Records
 

data/doc/dataset_basics.rdoc

@@ -65,7 +65,7 @@ Most Dataset methods that users will use can be broken down into two types:
 
 Most dataset methods fall into this category, which can be further broken down by the clause they affect:
 
-SELECT:: select, select_all, select_append, select_group, select_more
+SELECT:: select, select_all, select_append, select_group, select_more, select_prepend
 FROM:: from, from_self
 JOIN:: join, left_join, right_join, full_join, natural_join, natural_left_join, natural_right_join, natural_full_join, cross_join, inner_join, left_outer_join, right_outer_join, full_outer_join, join_table
 WHERE:: where, filter, exclude, or, grep, invert, unfiltered

data/doc/opening_databases.rdoc

@@ -346,6 +346,8 @@ The following additional options are supported:
                 separated by commas (for use via a URL: <tt>postgres:///?search_path=schema1,schema2</tt>), or it
                 can be an array of strings (for use via an option:
                 <tt>Sequel.postgres(search_path: ['schema1', 'schema2'])</tt>).
+:unlogged_tables_default :: Set to true to use UNLOGGED by default for created tables, for potentially better performance
+                            when data integrity is not important.
 :use_iso_date_format :: This can be set to false to not force the ISO date format.  Sequel forces
                         it by default to allow for an optimization.
 

data/doc/querying.rdoc

@@ -624,11 +624,16 @@ Like +order+, +select+ replaces the existing selected columns:
   Artist.select(:id).select(:name)
   # SELECT name FROM artists
 
-To add to the existing selected columns, use +select_append+:
+To append to the existing selected columns, use +select_append+:
 
   Artist.select(:id).select_append(:name)
   # SELECT id, name FROM artists
 
+To prepend to the existing selected columns, use +select_prepend+:
+
+  Artist.select(:id).select_prepend(:name)
+  # SELECT name, id FROM artists
+
 To remove specifically selected columns, and default back to all
 columns, use +select_all+:
 

data/doc/release_notes/5.78.0.txt

@@ -0,0 +1,67 @@
+= New Features
+
+* SQLite 3.45+ jsonb functions are now supported in the sqlite_json_ops
+  extension.  Similar to the postgres_json_ops extension, there are
+  now separate methods for dealing with json and jsonb types:
+
+    Sequel.sqlite_json_op(:column)  # json
+    Sequel.sqlite_jsonb_op(:column) # jsonb
+
+  Some methods that use json_* functions for json ops use jsonb_*
+  functions for jsonb ops:
+
+    jb = Sequel.sqlite_jsonb_op(:column)
+    jb.extract('$.a')    # jsonb_extract(column, '$.a')
+    jb.insert('$.a', 1)  # jsonb_insert(column, '$.a', 1)
+    jb.set('$.a', 1)     # jsonb_set(column, '$.a', 1)
+    jb.replace('$.a', 1) # jsonb_replace(column, '$.a', 1)
+    jb.remove('$.a')     # jsonb_remove(column, '$.a')
+    jb.patch('{"a":2}')  # jsonb_patch(column, '{"a":2}')
+
+  You can use the json and jsonb methods to convert jsonb to json
+  and json to jsonb, respectively.
+
+    jb.json              # json(column)
+
+  Use of the json method on jsonb types is important, because if you
+  want to be able to deal with the values in Ruby, you must convert
+  the jsonb value to json in the database before the database returns
+  the value.  Unlike PostgreSQL, SQLite will not convert the value
+  from jsonb to json on retrieval, and direct use of SQLite's jsonb
+  format is unsupported by SQLite as it is subject to change.
+
+* Database#with_advisory_lock is now supported on PostgreSQL, MySQL,
+  and Microsoft SQL Server. This supports advisory (explicit)
+  locking, using the database-specific APIs.  To work on all three
+  servers, lock ids should be integers in the signed 64-bit range.
+
+    DB.with_advisory_lock(1234) do
+      # do something
+    end
+
+  By default, an AdvisoryLockError is raised if the lock cannot be
+  immediately acquired.  You can use the :wait option to wait until
+  the lock can be acquired, instead of raising.
+
+    DB.with_advisory_lock(1234, wait: true) do
+      # do something
+    end
+
+* Migrator.run now supports a :use_advisory_lock option to use
+  advisory locks when running migrations, so that it does not
+  attempt to run the same migration more than once in the case
+  where multiple processes are running the migrator simultaneously.
+  It's probably best to avoid running the migrator in multiple
+  processes simultaneously instead of relying on this option.
+
+= Other Improvements
+
+* Database#values now supports chaining with compounds on
+  PostgreSQL.
+
+    DB.values([[1, 2]]).union(DB.values([[3, 4]]))
+    # SELECT * FROM (VALUES (1, 2) UNION (VALUES (3, 4))) AS t1
+
+* The internal hash used to store transaction metadata now uses
+  compare_by_identity, which is faster and avoids potential
+  issues if a driver implements connection object equality.

data/doc/release_notes/5.79.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* Dataset#select_prepend has been added for prepending to the
+  currently selected columns:
+
+    DB[:table].select_prepend(:column)
+    # SELECT column, table.*
+
+  As not all databases support "SELECT column, *", select_prepend
+  qualifies wildcard selections to all tables referenced in the
+  query.
+
+  The only reason to use select_prepend is if you want the hashes
+  returned by Sequel to be in a specific order.  Otherwise, it is
+  better to use select_append.
+
+* On PostgreSQL, Sequel now supports an :unlogged_tables_default
+  Database option, which will default created tables to be UNLOGGED.
+  This can be useful to speedup testing in some cases, but it should
+  never be used in cases where data integrity is important.
+
+= Other Improvements
+
+* On PostgreSQL, Database#create_or_replace_view now supports the
+  :materialized option.  This allows for dropping an existing
+  materialized view and creating a new one with the same name
+  (PostgreSQL does not have native support for replacing materialized
+  views).

data/doc/schema_modification.rdoc

@@ -81,8 +81,8 @@ appropriate 64-bit integer type for the database you are using.
 
 === Column options
 
-When using the type name as method, the third argument is an options hash, and when using the +column+
-method, the fourth argument is the options hash.  The following options are supported:
+When using the type name as method, the second argument is an options hash, and when using the +column+
+method, the third argument is the options hash.  The following options are supported:
 
 :default :: The default value for the column.
 :index :: Create an index on this column. If given a hash, use the hash as the

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

@@ -32,7 +32,7 @@ module Sequel
       #
       # Options:
       # :args :: Arguments to stored procedure.  For named arguments, this should be a
-      #          hash keyed by argument named.  For unnamed arguments, this should be an
+      #          hash keyed by argument name.  For unnamed arguments, this should be an
       #          array.  Output parameters to the function are specified using :output.
       #          You can also name output parameters and provide a type by using an
       #          array containing :output, the type name, and the parameter name.
@@ -246,6 +246,34 @@ module Sequel
         information_schema_tables('VIEW', opts)
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will
+      # be converted to a string). If successful, yield to the block, then release the advisory lock
+      # when the block exits.  If unsuccessful, raise a Sequel::AdvisoryLockError.
+      #
+      # Options:
+      # :wait :: Do not raise an error, instead, wait until the advisory lock can be acquired.
+      def with_advisory_lock(lock_id, opts=OPTS)
+        lock_id = lock_id.to_s
+        timeout = opts[:wait] ? -1 : 0
+        server = opts[:server]
+      
+        synchronize(server) do
+          begin
+            res = call_mssql_sproc(:sp_getapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockTimeout'=>timeout, 'LockMode'=>'Exclusive', 'LockOwner'=>'Session'})
+
+            unless locked = res[:result] >= 0
+                raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            if locked
+              call_mssql_sproc(:sp_releaseapplock, :server=>server, :args=>{'Resource'=>lock_id, 'LockOwner'=>'Session'})
+            end
+          end
+        end
+      end
+
       private
       
       # Add CLUSTERED or NONCLUSTERED as needed

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

@@ -197,6 +197,41 @@ module Sequel
         renames.each{|from,| remove_cached_schema(from)}
       end
       
+      # Attempt to acquire an exclusive advisory lock with the given lock_id (which will be
+      # converted to a string).  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(1357){DB.get(1)}
+      #   # SELECT GET_LOCK('1357', 0) LIMIT 1
+      #   # SELECT 1 AS v LIMIT 1
+      #   # SELECT RELEASE_LOCK('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)
+        lock_id = lock_id.to_s
+        ds = dataset
+        if server = opts[:server]
+          ds = ds.server(server)
+        end
+
+        # MariaDB doesn't support negative values for infinite wait.  A wait of 34 years
+        # should be reasonably similar to infinity for this case.
+        timeout = opts[:wait] ? 1073741823 : 0
+      
+        synchronize(server) do |c|
+          begin
+            unless locked = ds.get{GET_LOCK(lock_id, timeout)} == 1
+              raise AdvisoryLockError, "unable to acquire advisory lock #{lock_id.inspect}"
+            end
+
+            yield
+          ensure
+            ds.get{RELEASE_LOCK(lock_id)} if locked
+          end
+        end
+      end
+
       private
       
       def alter_table_add_column_sql(table, op)

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

@@ -859,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
@@ -1390,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
 
@@ -1785,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

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

data/lib/sequel/database/schema_methods.rb

@@ -252,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)

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

@@ -43,7 +43,7 @@ module Sequel
       add_graph_aliases distinct except exclude exclude_having
       filter for_update from from_self graph grep group group_and_count group_append group_by having intersect invert
       limit lock_style naked offset or order order_append order_by order_more order_prepend qualify
-      reverse reverse_order select select_all select_append select_group select_more server
+      reverse reverse_order select select_all select_append select_group select_more select_prepend server
       set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
     METHS
@@ -944,14 +944,8 @@ module Sequel
     #   DB[:items].select(:a).select_append(:b) # SELECT a, b FROM items
     #   DB[:items].select_append(:b) # SELECT *, b FROM items
     def select_append(*columns, &block)
-      cur_sel = @opts[:select]
-      if !cur_sel || cur_sel.empty?
-        unless supports_select_all_and_column?
-          return select_all(*(Array(@opts[:from]) + Array(@opts[:join]))).select_append(*columns, &block)
-        end
-        cur_sel = [WILDCARD]
-      end
-      select(*(cur_sel + columns), &block)
+      virtual_row_columns(columns, block)
+      select(*(_current_select(true) + columns))
     end
 
     # Set both the select and group clauses with the given +columns+.
@@ -973,6 +967,18 @@ module Sequel
       select_append(*columns, &block)
     end
     
+    # Returns a copy of the dataset with the given columns added
+    # to the existing selected columns.  If no columns are currently selected,
+    # it will select the columns given in addition to *.
+    #
+    #   DB[:items].select(:a).select(:b) # SELECT b FROM items
+    #   DB[:items].select(:a).select_prepend(:b) # SELECT b, a FROM items
+    #   DB[:items].select_prepend(:b) # SELECT b, * FROM items
+    def select_prepend(*columns, &block)
+      virtual_row_columns(columns, block)
+      select(*(columns + _current_select(false)))
+    end
+
     # Set the server for this dataset to use.  Used to pick a specific database
     # shard to run a query against, or to override the default (where SELECT uses
     # :read_only database and all other queries use the :default database).  This
@@ -1353,6 +1359,36 @@ module Sequel
     end
     # :nocov:
 
+    # A frozen array for the currently selected columns.
+    def _current_select(allow_plain_wildcard)
+      cur_sel = @opts[:select]
+
+      if !cur_sel || cur_sel.empty?
+        cur_sel = if allow_plain_wildcard && supports_select_all_and_column?
+          [WILDCARD].freeze
+        else
+          _current_select_column_all
+        end
+      elsif !allow_plain_wildcard && cur_sel.include?(WILDCARD)
+        cur_sel = cur_sel.dup
+        index = cur_sel.index(WILDCARD)
+        cur_sel.delete(WILDCARD)
+        _current_select_column_all.each_with_index do |ca, i|
+          cur_sel.insert(index+i, ca)
+        end
+        cur_sel.freeze
+      end
+
+      cur_sel
+    end
+
+    # An array of SQL::ColumnAll objects for all FROM and JOIN tables.  Used for select_append
+    # and select_prepend.
+    def _current_select_column_all
+      tables = Array(@opts[:from]) + Array(@opts[:join])
+      tables.map{|t| i, a = split_alias(t); a || i}.map!{|t| SQL::ColumnAll.new(t)}.freeze
+    end
+
     # If invert is true, invert the condition.
     def _invert_filter(cond, invert)
       if invert

data/lib/sequel/exceptions.rb

@@ -18,6 +18,11 @@ module Sequel
       end
     end
   end  
+
+  (
+  # Error raised when there is a failed attempt to acquire an advisory lock.
+  AdvisoryLockError = Class.new(Error)
+  ).name
     
   (
   # Error raised when the adapter requested doesn't exist or can't be loaded.

data/lib/sequel/extensions/async_thread_pool.rb

@@ -176,6 +176,13 @@
 # +:preempt_async_thread+ Database option before loading the
 # async_thread_pool extension.
 #
+# Note that the async_thread_pool extension creates the thread pool
+# when it is loaded into the Database.  If you fork after loading
+# the extension, the extension will not work, as fork does not
+# copy the thread pools.  If you are using a forking webserver
+# (or any other system that forks worker processes), load this
+# extension in each child process, do not load it before forking.
+#
 # Related module: Sequel::Database::AsyncThreadPool::DatasetMethods
 
 

data/lib/sequel/extensions/migration.rb

@@ -403,6 +403,11 @@ module Sequel
       migrator_class(directory).new(db, directory, opts).is_current?
     end
 
+    # Lock ID to use for advisory locks when running migrations
+    # "sequel-migration".codepoints.reduce(:*) % (2**63)
+    MIGRATION_ADVISORY_LOCK_ID = 4966325471869609408
+    private_constant :MIGRATION_ADVISORY_LOCK_ID
+
     # Migrates the supplied database using the migration files in the specified directory. Options:
     # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
     #                                   It is very risky to use this option, since it can result in
@@ -416,6 +421,8 @@ module Sequel
     # :table :: The table containing the schema version (default: :schema_info for integer migrations and
     #           :schema_migrations for timestamped migrations).
     # :target :: The target version to which to migrate.  If not given, migrates to the maximum version.
+    # :use_advisory_lock :: Use advisory locks in migrations (only use this if Sequel supports advisory
+    #                       locks for the database).
     #
     # Examples: 
     #   Sequel::Migrator.run(DB, "migrations")
@@ -423,7 +430,11 @@ module Sequel
     #   Sequel::Migrator.run(DB, "app1/migrations", column: :app2_version)
     #   Sequel::Migrator.run(DB, "app2/migrations", column: :app2_version, table: :schema_info2)
     def self.run(db, directory, opts=OPTS)
-      migrator_class(directory).new(db, directory, opts).run
+      if opts[:use_advisory_lock]
+        db.with_advisory_lock(MIGRATION_ADVISORY_LOCK_ID){run(db, directory, opts.merge(:use_advisory_lock=>false))}
+      else
+        migrator_class(directory).new(db, directory, opts).run
+      end
     end
 
     # Choose the Migrator subclass to use.  Uses the TimestampMigrator

data/lib/sequel/extensions/sqlite_json_ops.rb

@@ -2,27 +2,34 @@
 #
 # The sqlite_json_ops extension adds support to Sequel's DSL to make
 # it easier to call SQLite JSON functions and operators (added
-# first in SQLite 3.38.0).
+# first in SQLite 3.38.0).  It also supports the SQLite JSONB functions
+# added in SQLite 3.45.0.
 #
 # To load the extension:
 #
 #   Sequel.extension :sqlite_json_ops
 #
-# This extension works by calling methods on Sequel::SQLite::JSONOp objects,
-# which you can create via Sequel.sqlite_json_op:
+# This extension works by calling methods on Sequel::SQLite::JSONOp and
+# Sequel::SQLite::JSONBOp objects, which you can create using
+# Sequel.sqlite_json_op and Sequel.sqlite_jsonb_op:
 #
 #   j = Sequel.sqlite_json_op(:json_column)
+#   jb = Sequel.sqlite_jsonb_op(:jsonb_column)
 #
-# Also, on most Sequel expression objects, you can call the sqlite_json_op method
-# to create a Sequel::SQLite::JSONOp object:
+# Also, on most Sequel expression objects, you can call the sqlite_json_op or
+# sqlite_jsonb_op method to create a Sequel::SQLite::JSONOp or 
+# Sequel::SQLite::JSONBOp object:
 #
 #   j = Sequel[:json_column].sqlite_json_op
+#   jb = Sequel[:jsonb_column].sqlite_jsonb_op
 #
 # If you have loaded the {core_extensions extension}[rdoc-ref:doc/core_extensions.rdoc],
 # or you have loaded the core_refinements extension
 # and have activated refinements for the file, you can also use Symbol#sqlite_json_op:
+# or Symbol#sqlite_jsonb_op:
 #
 #   j = :json_column.sqlite_json_op
+#   jb = :json_column.sqlite_jsonb_op
 #
 # The following methods are available for Sequel::SQLite::JSONOp instances:
 #
@@ -30,11 +37,13 @@
 #   j.get(1)                 # (json_column ->> 1)
 #   j.get_text(1)            # (json_column -> 1)
 #   j.extract('$.a')         # json_extract(json_column, '$.a')
+#   jb.extract('$.a')        # jsonb_extract(jsonb_column, '$.a')
 #
 #   j.array_length           # json_array_length(json_column)
 #   j.type                   # json_type(json_column)
 #   j.valid                  # json_valid(json_column)
-#   j.json                   # json(json_column)
+#   jb.json                  # json(jsonb_column)
+#   j.jsonb                  # jsonb(json_column)
 #
 #   j.insert('$.a', 1)       # json_insert(json_column, '$.a', 1)
 #   j.set('$.a', 1)          # json_set(json_column, '$.a', 1)
@@ -42,22 +51,30 @@
 #   j.remove('$.a')          # json_remove(json_column, '$.a')
 #   j.patch('{"a":2}')       # json_patch(json_column, '{"a":2}')
 #
+#   jb.insert('$.a', 1)      # jsonb_insert(jsonb_column, '$.a', 1)
+#   jb.set('$.a', 1)         # jsonb_set(jsonb_column, '$.a', 1)
+#   jb.replace('$.a', 1)     # jsonb_replace(jsonb_column, '$.a', 1)
+#   jb.remove('$.a')         # jsonb_remove(jsonb_column, '$.a')
+#   jb.patch('{"a":2}')      # jsonb_patch(jsonb_column, '{"a":2}')
+#
 #   j.each                   # json_each(json_column)
 #   j.tree                   # json_tree(json_column)
 #
-# Related modules: Sequel::SQLite::JSONOp
+# Related modules: Sequel::SQLite::JSONBaseOp, Sequel::SQLite::JSONOp,
+# Sequel::SQLite::JSONBOp
 
 #
 module Sequel
   module SQLite
-    # The JSONOp class is a simple container for a single object that
-    # defines methods that yield Sequel expression objects representing
-    # SQLite json operators and functions.
+    # JSONBaseOp is an abstract base wrapper class for a object that
+    # defines methods that return Sequel expression objects representing
+    # SQLite json operators and functions. It is subclassed by both
+    # JSONOp and JSONBOp for json and jsonb specific behavior.
     #
     # In the method documentation examples, assume that:
     #
     #   json_op = Sequel.sqlite_json_op(:json)
-    class JSONOp < Sequel::SQL::Wrapper
+    class JSONBaseOp < Sequel::SQL::Wrapper
       GET = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
       private_constant :GET
 
@@ -82,7 +99,7 @@ module Sequel
       #   json_op.array_length         # json_array_length(json)
       #   json_op.array_length('$[1]') # json_array_length(json, '$[1]')
       def array_length(*args)
-        Sequel::SQL::NumericExpression.new(:NOOP, function(:array_length, *args))
+        Sequel::SQL::NumericExpression.new(:NOOP, SQL::Function.new(:json_array_length, self, *args))
       end
 
       # Returns an expression for a set of information extracted from the top-level
@@ -92,7 +109,7 @@ module Sequel
       #   json_op.each        # json_each(json)
       #   json_op.each('$.a') # json_each(json, '$.a')
       def each(*args)
-        function(:each, *args)
+        SQL::Function.new(:json_each, self, *args)
       end
 
       # Returns an expression for the JSON array element or object field at the specified
@@ -129,10 +146,17 @@ module Sequel
       #
       #   json_op.json   # json(json)
       def json
-        self.class.new(SQL::Function.new(:json, self))
+        JSONOp.new(SQL::Function.new(:json, self))
       end
       alias minify json
 
+      # Returns the JSONB format of the JSON.
+      #
+      #   json_op.jsonb   # jsonb(json)
+      def jsonb
+        JSONBOp.new(SQL::Function.new(:jsonb, self))
+      end
+
       # Returns an expression for updating the JSON object using the RFC 7396 MergePatch algorithm
       #
       #   json_op.patch('{"a": 1, "b": null}') # json_patch(json, '{"a": 1, "b": null}')
@@ -172,7 +196,7 @@ module Sequel
       #   json_op.tree        # json_tree(json)
       #   json_op.tree('$.a') # json_tree(json, '$.a')
       def tree(*args)
-        function(:tree, *args)
+        SQL::Function.new(:json_tree, self, *args)
       end
 
       # Returns an expression for the type of the JSON value or the JSON value at the given path.
@@ -180,13 +204,13 @@ module Sequel
       #   json_op.type         # json_type(json)
       #   json_op.type('$[1]') # json_type(json, '$[1]')
       def type(*args)
-        Sequel::SQL::StringExpression.new(:NOOP, function(:type, *args))
+        Sequel::SQL::StringExpression.new(:NOOP, SQL::Function.new(:json_type, self, *args))
       end
       alias typeof type
 
       # Returns a boolean expression for whether the JSON is valid or not.
       def valid
-        Sequel::SQL::BooleanExpression.new(:NOOP, function(:valid))
+        Sequel::SQL::BooleanExpression.new(:NOOP, SQL::Function.new(:json_valid, self))
       end
 
       private
@@ -198,7 +222,7 @@ module Sequel
 
       # Internals of the methods that return functions prefixed with +json_+.
       def function(name, *args)
-        SQL::Function.new("json_#{name}", self, *args)
+        SQL::Function.new("#{function_prefix}_#{name}", self, *args)
       end
 
       # Internals of the methods that return functions prefixed with +json_+, that
@@ -208,12 +232,36 @@ module Sequel
       end
     end
 
+    # JSONOp is used for SQLite json-specific functions and operators.
+    class JSONOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "json"
+      end
+    end
+
+    # JSONOp is used for SQLite jsonb-specific functions and operators.
+    class JSONBOp < JSONBaseOp
+      private
+
+      def function_prefix
+        "jsonb"
+      end
+    end
+
     module JSONOpMethods
       # Wrap the receiver in an JSONOp so you can easily use the SQLite
       # json functions and operators with it.
       def sqlite_json_op
         JSONOp.new(self)
       end
+
+      # Wrap the receiver in an JSONBOp so you can easily use the SQLite
+      # jsonb functions and operators with it.
+      def sqlite_jsonb_op
+        JSONBOp.new(self)
+      end
     end
   end
 
@@ -227,6 +275,16 @@ module Sequel
         SQLite::JSONOp.new(v)
       end
     end
+
+    # Return the object wrapped in an SQLite::JSONBOp.
+    def sqlite_jsonb_op(v)
+      case v
+      when SQLite::JSONBOp
+        v
+      else
+        SQLite::JSONBOp.new(v)
+      end
+    end
   end
 
   class SQL::GenericExpression

data/lib/sequel/model/base.rb

@@ -17,7 +17,7 @@ module Sequel
     #   natural_join, natural_left_join, natural_right_join, offset, order, order_append, order_by,
     #   order_more, order_prepend, paged_each, qualify, reverse, reverse_order, right_join,
     #   right_outer_join, select, select_all, select_append, select_group, select_hash,
-    #   select_hash_groups, select_map, select_more, select_order_map, server,
+    #   select_hash_groups, select_map, select_more, select_order_map, select_prepend, server,
     #   single_record, single_record!, single_value, single_value!, sum, to_hash, to_hash_groups,
     #   truncate, unfiltered, ungraphed, ungrouped, union, unlimited, unordered, where, where_all,
     #   where_each, where_single_value, with, with_recursive, with_sql

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 5.77.0
+  version: 5.79.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-01 00:00:00.000000000 Z
+date: 2024-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bigdecimal
@@ -224,6 +224,8 @@ extra_rdoc_files:
 - doc/release_notes/5.75.0.txt
 - doc/release_notes/5.76.0.txt
 - doc/release_notes/5.77.0.txt
+- doc/release_notes/5.78.0.txt
+- doc/release_notes/5.79.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 files:
@@ -329,6 +331,8 @@ files:
 - doc/release_notes/5.75.0.txt
 - doc/release_notes/5.76.0.txt
 - doc/release_notes/5.77.0.txt
+- doc/release_notes/5.78.0.txt
+- doc/release_notes/5.79.0.txt
 - doc/release_notes/5.8.0.txt
 - doc/release_notes/5.9.0.txt
 - doc/schema_modification.rdoc