sequel 5.53.0 → 5.56.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7cd8e3e9c13b3f5593389d91fafe25706716cb7810187db2d1301efb2a99ee96
-  data.tar.gz: f5d92dc333425438d63598d19119dc7ff06a2635756a9970bff2be8d5252477b
+  metadata.gz: 3505371d31fd90d388e3d889117e0dc949e73d41ebd6bee01441be9d061ea33a
+  data.tar.gz: fed52ae3813a0799065e695e90ab95e9633195477d01d1df9de6e6dbddbcaa23
 SHA512:
-  metadata.gz: 8e41100d1bec6bfa083ac57d52a4109bea07cda47d99c7b7b56e086489b36d9dde9361a3ee4b14795a11cdab4bc27d2fdb544a5df8bdc2e65c8df5a73bbf3ec0
-  data.tar.gz: 72be8971e7b44afb58b44115d654d24acb51c425b0019181ab495ffcd61ac23c497d108c6ed7982cddcb0c760270325a0cd1338f4265839bba571198f97e5ae2
+  metadata.gz: 6bdd85a8fbd1ba0c0fc871e2e318836e7463d73f9677c0fbba667b6bc86fbe0cb6f0fe09026a39b9b9c79aa783c60f211ffd993b22dff6f9e0d43d3e18754351
+  data.tar.gz: 6ce33f8f9593e7cf73d1322104b7dd362deca59eb6397e7d4ea2705c8bb17d4087453903edd59389181d9829818fd31dc2b990dc77b4c3f3a714b846c8a5db3b

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 5.56.0 (2022-05-01)
+
+* Make alter_table add_column/add_foreign_key methods support :index option to create an index on the column (jeremyevans)
+
+* Support creation of STRICT tables on SQLite 3.37.0+ via create_table :strict option (jeremyevans)
+
+* Add sqlite_json_ops extension for DSL support for JSON functions and operators added in SQLite 3.38.0 (jeremyevans)
+
+* Recognize "INTEGER" type same as "integer" type in the schema dumper, helpful on SQLite 3.37.0+ (jeremyevans)
+
+=== 5.55.0 (2022-04-01)
+
+* Support :setup_regexp_function Database option in the sqlite adapter to allow the use of regexps when querying (jeremyevans)
+
+* Add auto_restrict_eager_graph plugin for automatically disallow eager_graph with associations needing but lacking graph options (jeremyevans)
+
+* Fix placeholder literalizer optimization for dataset aggregate methods on a model dataset (belousovAV) (#1847, #1848)
+
+=== 5.54.0 (2022-03-01)
+
+* Add enum plugin for treating columns as enums in a model (jeremyevans) (#1839)
+
 === 5.53.0 (2022-02-01)
 
 * Make Dataset#_sql_comment private when using the Database sql_comments extension (jeremyevans)

data/doc/opening_databases.rdoc

@@ -383,6 +383,9 @@ The following additional options are supported:
 
 :readonly :: open database in read-only mode
 :timeout :: the busy timeout to use in milliseconds (default: 5000).
+:setup_regexp_function :: Whether to setup a REGEXP function in the underlying SQLite3::Database object. Doing so
+                          allows you to use regexp support in dataset expressions.  Note that this creates a new
+                          Regexp object per call to the function, so it is not an efficient implementation.
 
 Note that SQLite memory databases are restricted to a single connection by
 default.  This is because SQLite does not allow multiple connections to

data/doc/querying.rdoc

@@ -357,7 +357,9 @@ For ranges, Sequel uses a pair of inequality statements:
   # SELECT * FROM artists WHERE ((id >= 1) AND (id < 5))
 
 Finally, for regexps, Sequel uses an SQL regular expression.  Note that this
-is probably only supported on PostgreSQL and MySQL.
+is only supported by default on PostgreSQL and MySQL.  It can also be supported
+on SQLite when using the sqlite adapter with the :setup_regexp_function
+Database option.
 
   Artist.where(name: /JM$/)
   # SELECT * FROM artists WHERE (name ~ 'JM$')

data/doc/release_notes/5.54.0.txt

@@ -0,0 +1,27 @@
+= New Feature
+
+* An enum plugin has been added.  This plugin allows you to create
+  model-level enums, giving names to underlying values of a column.
+  For example:
+
+    Album.plugin :enum
+    Album.enum :status_id, good: 1, bad: 2
+
+  Adds Album#good! and Album#bad! for changing the status_id to 1 or 
+  2 respectively.  It adds Album#good? and Album#bad? for checking
+  whether the status_id is 1 or 2 respectively.  It overrides
+  Album#status_id to return :good or :bad instead of 1 or 2,
+  respectively, and overrides Album#status_id= to accept :good or
+  :bad instead of 1 or 2 respectively.
+
+  Additionally, it adds good and bad dataset methods for filtering
+  the model's dataset to records where status_id is 1 or 2
+  respectively. It also adds not_good and not_bad dataset methods
+  for filtering the model's dataset to records where status_id is not
+  1 or not 2 respectively.
+
+  You can use :prefix and :suffix options when calling enum to
+  add a prefix or suffix to the method names created.  You can
+  set the :override_accessors option to false to not override
+  the accessor methods for the column, and set the :dataset_methods
+  option to false to not add dataset methods.

data/doc/release_notes/5.55.0.txt

@@ -0,0 +1,21 @@
+= New Features
+
+* An auto_restrict_eager_graph plugin has been added for automatically
+  disallowing the use of eager_graph with associations using blocks but
+  lacking graph_* options.  This can prevent potentionally invalid usage,
+  as the restrictions added by the block are not used by eager_graph.
+
+* The sqlite adapter now supports the :setup_regexp_function
+  Database option. This option will define a REGEXP function in the
+  database that will allow regexp support in queries, such as:
+
+    DB[:table].where(column: /(some|pattern)/)
+
+  Note that this creates a Ruby Regexp object per column value tested,
+  so it isn't the most optimal approach. 
+
+= Other Improvements
+
+* Calling dataset aggregate methods such as #max on a model dataset now
+  works correctly. Previously, it could fail if called enough times to
+  optimize using a placeholder literalizer.

data/doc/release_notes/5.56.0.txt

@@ -0,0 +1,51 @@
+= New Features
+
+* On SQLite, Database#create_table now supports a :strict option to
+  use the STRICT keyword when creating the table.  When this option
+  is used, SQLite will enforce the types for each column. When using
+  this option, you are limited to using the following column types:
+  int, integer, real, text, blob, and any (any allows for dynamic
+  types).
+
+* An sqlite_json_ops extension has been added, providing DSL support
+  for JSON functions and operators supported in SQLite 3.38.0. Usage
+  is similar to the pg_json_ops extension.  First, you create an
+  appropriate object:
+
+    j = Sequel.sqlite_json_op(:json_column)
+    # or:
+    j = Sequel[:json_column].sqlite_json_op
+
+  Then, you call methods on that object to create expressions for the
+  JSON functions and operators:
+
+    j[1]                 # (json_column ->> 1)
+    j.get_text(1)        # (json_column -> 1)
+    j.extract('$.a')     # json_extract(json_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)
+ 
+    j.insert('$.a', 1)   # json_insert(json_column, '$.a', 1)
+    j.set('$.a', 1)      # json_set(json_column, '$.a', 1)
+    j.replace('$.a', 1)  # json_replace(json_column, '$.a', 1)
+    j.remove('$.a')      # json_remove(json_column, '$.a')
+    j.patch('{"a":2}')   # json_patch(json_column, '{"a":2}')
+ 
+    j.each               # json_each(json_column)
+    j.tree               # json_tree(json_column)
+
+= Other Improvements
+
+* The alter_table add_column and add_foreign_key methods now support
+  the :index option to create an index on the added column, for
+  compatibility with the :index option on the create_table column and
+  foreign_key methods.
+
+* The schema_dumper extension now treats the "INTEGER" type the same
+  as the "integer" type.  This fixes some behavior when using SQLite
+  3.37.0+.
+
+* Sequel's website has a much improved visual design.

data/doc/sql.rdoc

@@ -528,7 +528,7 @@ Inverting the LIKE operator works like other inversions:
 
   ~Sequel.like(:name, 'A%') # ("name" NOT LIKE 'A%' ESCAPE '\')
 
-Sequel also supports SQL regular expressions on MySQL and PostgreSQL.  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
+Sequel also supports SQL regular expressions on MySQL and PostgreSQL (and SQLite when using the sqlite adapter with the :setup_regexp_function Database option).  You can use these by passing a Ruby regular expression to +like+ or +ilike+, or by making the regular expression a hash value:
 
   Sequel.like(:name, /^A/) # ("name" ~ '^A')
   ~Sequel.ilike(:name, /^A/) # ("name" !~* '^A')

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

@@ -337,6 +337,11 @@ module Sequel
         ps
       end
 
+      # Support creating STRICT tables via :strict option
+      def create_table_sql(name, generator, options)
+        "#{super}#{' STRICT' if options[:strict]}"
+      end
+
       # SQLite support creating temporary views.
       def create_view_prefix_sql(name, options)
         create_view_sql_append_columns("CREATE #{'TEMPORARY 'if options[:temp]}VIEW #{quote_schema_table(name)}", options[:columns])
@@ -347,6 +352,7 @@ module Sequel
         /foreign key constraint failed\z/i => ForeignKeyConstraintViolation,
         /\A(SQLITE ERROR 275 \(CONSTRAINT_CHECK\) : )?CHECK constraint failed/ => CheckConstraintViolation,
         /\A(SQLITE ERROR 19 \(CONSTRAINT\) : )?constraint failed\z/ => ConstraintViolation,
+        /\Acannot store [A-Z]+ value in [A-Z]+ column / => ConstraintViolation,
         /may not be NULL\z|NOT NULL constraint failed: .+\z/ => NotNullConstraintViolation,
         /\ASQLITE ERROR \d+ \(\) : CHECK constraint failed: / => CheckConstraintViolation
       }.freeze

data/lib/sequel/adapters/sqlite.rb

@@ -98,6 +98,11 @@ module Sequel
       # The conversion procs to use for this database
       attr_reader :conversion_procs
 
+      def initialize(opts = OPTS)
+        super
+        @allow_regexp = typecast_value_boolean(opts[:setup_regexp_function])
+      end
+
       # Connect to the database. Since SQLite is a file based database,
       # available options are limited:
       #
@@ -119,6 +124,12 @@ module Sequel
         end
         
         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
+        end
         
         class << db
           attr_reader :prepared_statements
@@ -128,6 +139,12 @@ module Sequel
         db
       end
 
+      # Whether this Database instance is setup to allow regexp matching.
+      # True if the :setup_regexp_function option was passed when creating the Database.
+      def allow_regexp?
+        @allow_regexp
+      end
+
       # Disconnect given connections from the database.
       def disconnect_connection(c)
         c.prepared_statements.each_value{|v| v.first.close}
@@ -321,6 +338,28 @@ module Sequel
       BindArgumentMethods = prepared_statements_module(:bind, ArgumentMapper)
       PreparedStatementMethods = prepared_statements_module(:prepare, BindArgumentMethods)
 
+      # Support regexp functions if using :setup_regexp_function Database option.
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :~, :'!~', :'~*', :'!~*'
+          return super unless supports_regexp?
+
+          case_insensitive = [:'~*', :'!~*'].include?(op)
+          sql << 'NOT ' if [:'!~', :'!~*'].include?(op)
+          sql << '('
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[0])
+          sql << ')' if case_insensitive
+          sql << ' REGEXP '
+          sql << 'LOWER(' if case_insensitive
+          literal_append(sql, args[1])
+          sql << ')' if case_insensitive
+          sql << ')'
+        else
+          super
+        end
+      end
+
       def fetch_rows(sql)
         execute(sql) do |result|
           cps = db.conversion_procs
@@ -344,6 +383,11 @@ module Sequel
           end
         end
       end
+
+      # Support regexp if using :setup_regexp_function Database option.
+      def supports_regexp?
+        db.allow_regexp?
+      end
       
       private
       

data/lib/sequel/database/schema_generator.rb

@@ -387,8 +387,7 @@ module Sequel
       end
       
       # Add a column with the given name, type, and opts.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       #   add_column(:name, String) # ADD COLUMN name varchar(255)
       #
@@ -401,7 +400,10 @@ module Sequel
       # :after :: The name of an existing column that the new column should be positioned after
       # :first :: Create this new column before all other existing columns
       def add_column(name, type, opts = OPTS)
-        @operations << {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        op = {:op => :add_column, :name => name, :type => type}.merge!(opts)
+        index_opts = op.delete(:index)
+        @operations << op
+        add_index(name, index_opts.is_a?(Hash) ? index_opts : OPTS) if index_opts
         nil
       end
       
@@ -430,8 +432,7 @@ module Sequel
       end
 
       # Add a foreign key with the given name and referencing the given table.
-      # See CreateTableGenerator#column for the available options (except for +:index+, use a
-      # separate +add_index+ call to add an index for the column).
+      # See CreateTableGenerator#column for the available options.
       #
       # You can also pass an array of column names for creating composite foreign
       # keys. In this case, it will assume the columns exist and will only add

data/lib/sequel/database/schema_methods.rb

@@ -183,6 +183,15 @@ module Sequel
     #             keys.
     # :tablespace :: The tablespace to use for the table.
     #
+    # SQLite specific options:
+    # :strict :: Create a STRICT table, which checks that the values for the columns
+    #            are the correct type (similar to all other SQL databases). Note that
+    #            when using this option, all column types used should be one of the
+    #            following: +int+, +integer+, +real+, +text+, +blob+, and +any+.
+    #            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+.
+    #
     # See <tt>Schema::CreateTableGenerator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
       remove_cached_schema(name)

data/lib/sequel/dataset/sql.rb

@@ -894,9 +894,10 @@ module Sequel
     # Clone of this dataset usable in aggregate operations.  Does
     # a from_self if dataset contains any parameters that would
     # affect normal aggregation, or just removes an existing
-    # order if not.
+    # order if not. Also removes the row_proc, which isn't needed
+    # for aggregate calculations.
     def aggregate_dataset
-      options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered
+      (options_overlap(COUNT_FROM_SELF_OPTS) ? from_self : unordered).naked
     end
 
     # Append aliasing expression to SQL string.

data/lib/sequel/extensions/pg_json_ops.rb

@@ -3,7 +3,8 @@
 # The pg_json_ops extension adds support to Sequel's DSL to make
 # it easier to call PostgreSQL JSON functions and operators (added
 # first in PostgreSQL 9.3).  It also supports the JSONB functions
-# and operators added in PostgreSQL 9.4.
+# and operators added in PostgreSQL 9.4, as well as additional
+# functions and operators added in later versions.
 #
 # To load the extension:
 #

data/lib/sequel/extensions/schema_dumper.rb

@@ -183,7 +183,7 @@ END_MIG
       if options[:single_pk] && schema_autoincrementing_primary_key?(schema)
         type_hash = options[:same_db] ? {:type=>schema[:db_type]} : column_schema_to_ruby_type(schema)
         [:table, :key, :on_delete, :on_update, :deferrable].each{|f| type_hash[f] = schema[f] if schema[f]}
-        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"}
+        if type_hash == {:type=>Integer} || type_hash == {:type=>"integer"} || type_hash == {:type=>"INTEGER"}
           type_hash.delete(:type)
         elsif options[:same_db] && type_hash == {:type=>type_literal_generic_bignum_symbol(type_hash).to_s}
           type_hash[:type] = :Bignum
@@ -225,7 +225,7 @@ END_MIG
         col_opts[:null] = false if schema[:allow_null] == false
         if table = schema[:table]
           [:key, :on_delete, :on_update, :deferrable].each{|f| col_opts[f] = schema[f] if schema[f]}
-          col_opts[:type] = type unless type == Integer || type == 'integer'
+          col_opts[:type] = type unless type == Integer || type == 'integer' || type == 'INTEGER'
           gen.foreign_key(name, table, col_opts)
         else
           gen.column(name, type, col_opts)

data/lib/sequel/extensions/sqlite_json_ops.rb

@@ -0,0 +1,255 @@
+# frozen-string-literal: true
+#
+# 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).
+#
+# 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:
+#
+#   j = Sequel.sqlite_json_op(:json_column)
+#
+# Also, on most Sequel expression objects, you can call the sqlite_json_op method
+# to create a Sequel::SQLite::JSONOp object:
+#
+#   j = Sequel[:json_column].sqlite_json_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:
+#
+#   j = :json_column.sqlite_json_op
+#
+# The following methods are available for Sequel::SQLite::JSONOp instances:
+#
+#   j[1]                     # (json_column ->> 1)
+#   j.get(1)                 # (json_column ->> 1)
+#   j.get_text(1)            # (json_column -> 1)
+#   j.extract('$.a')         # json_extract(json_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)
+#
+#   j.insert('$.a', 1)       # json_insert(json_column, '$.a', 1)
+#   j.set('$.a', 1)          # json_set(json_column, '$.a', 1)
+#   j.replace('$.a', 1)      # json_replace(json_column, '$.a', 1)
+#   j.remove('$.a')          # json_remove(json_column, '$.a')
+#   j.patch('{"a":2}')       # json_patch(json_column, '{"a":2}')
+#
+#   j.each                   # json_each(json_column)
+#   j.tree                   # json_tree(json_column)
+#
+# Related modules: Sequel::SQLite::JSONOp
+
+#
+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.
+    #
+    # In the method documentation examples, assume that:
+    #
+    #   json_op = Sequel.sqlite_json_op(:json)
+    class JSONOp < Sequel::SQL::Wrapper
+      GET = ["(".freeze, " ->> ".freeze, ")".freeze].freeze
+      private_constant :GET
+
+      GET_JSON = ["(".freeze, " -> ".freeze, ")".freeze].freeze
+      private_constant :GET_JSON
+
+      # Returns an expression for getting the JSON array element or object field
+      # at the specified path as a SQLite value.
+      #
+      #   json_op[1]         # (json ->> 1)
+      #   json_op['a']       # (json ->> 'a')
+      #   json_op['$.a.b']   # (json ->> '$.a.b')
+      #   json_op['$[1][2]'] # (json ->> '$[1][2]')
+      def [](key)
+        json_op(GET, key)
+      end
+      alias get []
+
+      # Returns an expression for the length of the JSON array, or the JSON array at
+      # the given path.
+      #
+      #   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))
+      end
+
+      # Returns an expression for a set of information extracted from the top-level
+      # members of the JSON array or object, or the top-level members of the JSON array
+      # or object at the given path.
+      #
+      #   json_op.each        # json_each(json)
+      #   json_op.each('$.a') # json_each(json, '$.a')
+      def each(*args)
+        function(:each, *args)
+      end
+
+      # Returns an expression for the JSON array element or object field at the specified
+      # path as a SQLite value, but only accept paths as arguments, and allow the use of
+      # multiple paths.
+      #
+      #   json_op.extract('$.a')        # json_extract(json, '$.a')
+      #   json_op.extract('$.a', '$.b') # json_extract(json, '$.a', '$.b')
+      def extract(*a)
+        function(:extract, *a)
+      end
+
+      # Returns an expression for getting the JSON array element or object field at the
+      # specified path as a JSON value.
+      #
+      #   json_op.get_json(1)         # (json -> 1)
+      #   json_op.get_json('a')       # (json -> 'a')
+      #   json_op.get_json('$.a.b')   # (json -> '$.a.b')
+      #   json_op.get_json('$[1][2]') # (json -> '$[1][2]')
+      def get_json(key)
+        self.class.new(json_op(GET_JSON, key))
+      end
+
+      # Returns an expression for creating new entries at the given paths in the JSON array
+      # or object, but not overwriting existing entries.
+      #
+      #   json_op.insert('$.a', 1)           # json_insert(json, '$.a', 1)
+      #   json_op.insert('$.a', 1, '$.b', 2) # json_insert(json, '$.a', 1, '$.b', 2)
+      def insert(path, value, *args)
+        wrapped_function(:insert, path, value, *args)
+      end
+
+      # Returns an expression for a minified version of the JSON.
+      #
+      #   json_op.json   # json(json)
+      def json
+        self.class.new(SQL::Function.new(:json, self))
+      end
+      alias minify json
+
+      # 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}')
+      def patch(json_patch)
+        wrapped_function(:patch, json_patch)
+      end
+
+      # Returns an expression for removing entries at the given paths from the JSON array or object.
+      #
+      #   json_op.remove('$.a')        # json_remove(json, '$.a')
+      #   json_op.remove('$.a', '$.b') # json_remove(json, '$.a', '$.b')
+      def remove(path, *paths)
+        wrapped_function(:remove, path, *paths)
+      end
+
+      # Returns an expression for replacing entries at the given paths in the JSON array or object,
+      # but not creating new entries.
+      #
+      #   json_op.replace('$.a', 1)           # json_replace(json, '$.a', 1)
+      #   json_op.replace('$.a', 1, '$.b', 2) # json_replace(json, '$.a', 1, '$.b', 2)
+      def replace(path, value, *args)
+        wrapped_function(:replace, path, value, *args)
+      end
+
+      # Returns an expression for creating or replacing entries at the given paths in the
+      # JSON array or object.
+      #
+      #   json_op.set('$.a', 1)           # json_set(json, '$.a', 1)
+      #   json_op.set('$.a', 1, '$.b', 2) # json_set(json, '$.a', 1, '$.b', 2)
+      def set(path, value, *args)
+        wrapped_function(:set, path, value, *args)
+      end
+
+      # Returns an expression for a set of information extracted from the JSON array or object, or
+      # the JSON array or object at the given path.
+      #
+      #   json_op.tree        # json_tree(json)
+      #   json_op.tree('$.a') # json_tree(json, '$.a')
+      def tree(*args)
+        function(:tree, *args)
+      end
+
+      # Returns an expression for the type of the JSON value or the JSON value at the given path.
+      #
+      #   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))
+      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))
+      end
+
+      private
+
+      # Internals of the [], get, get_json methods, using a placeholder literal string.
+      def json_op(str, args)
+        self.class.new(Sequel::SQL::PlaceholderLiteralString.new(str, [self, args]))
+      end
+
+      # Internals of the methods that return functions prefixed with +json_+.
+      def function(name, *args)
+        SQL::Function.new("json_#{name}", self, *args)
+      end
+
+      # Internals of the methods that return functions prefixed with +json_+, that
+      # return JSON values.
+      def wrapped_function(*args)
+        self.class.new(function(*args))
+      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
+    end
+  end
+
+  module SQL::Builders
+    # Return the object wrapped in an SQLite::JSONOp.
+    def sqlite_json_op(v)
+      case v
+      when SQLite::JSONOp
+        v
+      else
+        SQLite::JSONOp.new(v)
+      end
+    end
+  end
+
+  class SQL::GenericExpression
+    include Sequel::SQLite::JSONOpMethods
+  end
+
+  class LiteralString
+    include Sequel::SQLite::JSONOpMethods
+  end
+end
+
+# :nocov:
+if Sequel.core_extensions?
+  class Symbol
+    include Sequel::SQLite::JSONOpMethods
+  end
+end
+
+if defined?(Sequel::CoreRefinements)
+  module Sequel::CoreRefinements
+    refine Symbol do
+      send INCLUDE_METH, Sequel::SQLite::JSONOpMethods
+    end
+  end
+end
+# :nocov:

data/lib/sequel/plugins/auto_restrict_eager_graph.rb

@@ -0,0 +1,62 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_restrict_eager_graph plugin will automatically disallow the use
+    # of eager_graph for associations that have associated blocks but no :graph_*
+    # association options.  The reason for this is the block will have an effect
+    # during regular and eager loading, but not loading via eager_graph, and it
+    # is likely that whatever the block is doing should have an equivalent done
+    # when eager_graphing.  Most likely, not including a :graph_* option was either
+    # an oversight (and one should be added), or use with eager_graph was never
+    # intended (and usage should be forbidden).  Disallowing eager_graph in this
+    # case prevents likely unexpected behavior during eager_graph.
+    #
+    # As an example of this, consider the following code:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    #   Album.eager(:popular_tracks).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM tracks WHERE ((popular IS TRUE) AND (album_id IN (...)))
+    #
+    #   # Notice that no condition for tracks.popular is added.
+    #   Album.eager_graph(:popular_tracks).all
+    #   # SELECT ... FROM albums LEFT JOIN tracks ON (tracks.album_id = albums.id)
+    #   
+    # With the auto_restrict_eager_graph plugin, the eager_graph call above will
+    # raise an error, alerting you to the fact that you either should not be
+    # using eager_graph with the association, or that you should be adding an
+    # appropriate :graph_* option, such as:
+    #
+    #   Album.one_to_many :popular_tracks, class: :Track, graph_conditions: {popular: true} do |ds|
+    #     ds = ds.where(popular: true)
+    #   end  
+    #
+    # Usage:
+    #
+    #   # Automatically restrict eager_graph for associations if appropriate for all
+    #   # model subclasses (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_restrict_eager_graph
+    #
+    #   # Automatically restrict eager_graph for associations in Album class
+    #   Album.plugin :auto_restrict_eager_graph
+    module AutoRestrictEagerGraph
+      module ClassMethods
+        # When defining an association, if a block is given for the association, but
+        # a :graph_* option is not used, disallow the use of eager_graph.
+        def associate(type, name, opts = OPTS, &block)
+          opts = super
+
+          if opts[:block] && !opts.has_key?(:allow_eager_graph) && !opts[:orig_opts].any?{|k,| /\Agraph_/ =~ k}
+            opts[:allow_eager_graph] = false
+          end
+
+          opts
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/enum.rb

@@ -0,0 +1,124 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The enum plugin allows for easily adding methods to modify the value of
+    # a column.  It allows treating the column itself as an enum, returning a
+    # symbol for the related enum value.  It also allows for setting up dataset
+    # methods to easily find records having or not having each enum value.
+    #
+    # After loading the plugin, you can call the +enum+ method to define the
+    # methods.  The +enum+ method accepts a symbol for the underlying
+    # database column, and a hash with symbol keys for the enum values.
+    # For example, the following call:
+    #
+    #   Album.enum :status_id, good: 1, bad: 2
+    #
+    # Will define the following instance methods:
+    #
+    # Album#good! :: Change +status_id+ to +1+ (does not save the receiver)
+    # Album#bad! :: Change +status_id+ to +2+ (does not save the receiver)
+    # Album#good? :: Return whether +status_id+ is +1+
+    # Album#bad? :: Return whether +status_id+ is +2+
+    #
+    # It will override the following instance methods:
+    #
+    # Album#status_id :: Return +:good+/+:bad+ instead of +1+/+2+ (other values returned as-is)
+    # Album#status_id= :: Allow calling with +:good+/+:bad+ to set +status_id+ to +1+/+2+ (other values,
+    #                     such as <tt>'good'</tt>/<tt>'bad'</tt> set as-is)
+    #
+    # If will define the following dataset methods:
+    #
+    # Album.dataset.good :: Return a dataset filtered to rows where +status_id+ is +1+
+    # Album.dataset.not_good :: Return a dataset filtered to rows where +status_id+ is not +1+
+    # Album.dataset.bad:: Return a dataset filtered to rows where +status_id+ is +2+
+    # Album.dataset.not_bad:: Return a dataset filtered to rows where +status_id+ is not +2+
+    #
+    # When calling +enum+, you can also provide the following options:
+    #
+    # :prefix :: Use a prefix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the prefix.
+    #            For example, with <tt>prefix: 'status'</tt>, the instance methods defined above would be +status_good?+, +status_bad?+,
+    #            +status_good!+, and +status_bad!+, and the dataset methods defined would be +status_good+, +status_not_good+, +status_bad+,
+    #            and +status_not_bad+.
+    # :suffix :: Use a suffix for methods defined for each enum value. If +true+ is provided at the value, use the column name as the suffix.
+    #            For example, with <tt>suffix: 'status'</tt>, the instance methods defined above would be +good_status?+, +bad_status?+,
+    #            +good_status!+, and +bad_status!+, and the dataset methods defined would be +good_status+, +not_good_status+, +bad_status+,
+    #            and +not_bad_status+.
+    # :override_accessors :: Set to +false+ to not override the column accessor methods.
+    # :dataset_methods :: Set to +false+ to not define dataset methods.
+    #
+    # Note that this does not use a true enum column in the database.  If you are
+    # looking for enum support in the database, and your are using PostgreSQL,
+    # Sequel supports that via the pg_enum Database extension.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses handle enums
+    #   Sequel::Model.plugin :enum
+    #
+    #   # Make the Album class handle enums
+    #   Album.plugin :enum
+    module Enum
+      module ClassMethods
+        # Define instance and dataset methods in this class to treat column
+        # as a enum.  See Enum documentation for usage.
+        def enum(column, values, opts=OPTS)
+          raise Sequel::Error, "enum column must be a symbol" unless column.is_a?(Symbol)
+          raise Sequel::Error, "enum values must be provided as a hash with symbol keys" unless values.is_a?(Hash) && values.all?{|k,| k.is_a?(Symbol)}
+
+          if prefix = opts[:prefix]
+            prefix = column if prefix == true
+            prefix = "#{prefix}_"
+          end
+
+          if suffix = opts[:suffix]
+            suffix = column if suffix == true
+            suffix = "_#{suffix}"
+          end
+          
+          values = Hash[values].freeze
+          inverted = values.invert.freeze
+
+          unless @enum_methods
+            @enum_methods = Module.new
+            include @enum_methods
+          end
+
+          @enum_methods.module_eval do
+            unless opts[:override_accessors] == false
+              define_method(column) do
+                v = super()
+                inverted.fetch(v, v)
+              end
+
+              define_method(:"#{column}=") do |v|
+                super(values.fetch(v, v))
+              end
+            end
+
+            values.each do |key, value|
+              define_method(:"#{prefix}#{key}#{suffix}!") do
+                self[column] = value
+                nil
+              end
+
+              define_method(:"#{prefix}#{key}#{suffix}?") do
+                self[column] == value
+              end
+            end
+          end
+
+          unless opts[:dataset_methods] == false
+            dataset_module do
+              values.each do |key, value|
+                cond = Sequel[column=>value]
+                where :"#{prefix}#{key}#{suffix}", cond
+                where :"#{prefix}not_#{key}#{suffix}", ~cond
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/instance_specific_default.rb

@@ -29,7 +29,7 @@ module Sequel
     #   end
     #
     # +first_track+ is not instance specific, but +last_track+ and +recent_tracks+ are.
-    # +last_trac+ is because the +num_tracks+ call in the block is calling
+    # +last_track+ is because the +num_tracks+ call in the block is calling
     # <tt>Album#num_tracks</tt>.  +recent_tracks+ is because the value will change over
     # time. This plugin allows you to find these cases, and set the :instance_specific
     # option appropriately for them:

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 = 53
+  MINOR = 56
 
   # 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.53.0
+  version: 5.56.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-02-01 00:00:00.000000000 Z
+date: 2022-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -198,6 +198,9 @@ extra_rdoc_files:
 - doc/release_notes/5.51.0.txt
 - doc/release_notes/5.52.0.txt
 - doc/release_notes/5.53.0.txt
+- doc/release_notes/5.54.0.txt
+- doc/release_notes/5.55.0.txt
+- doc/release_notes/5.56.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
@@ -279,6 +282,9 @@ files:
 - doc/release_notes/5.51.0.txt
 - doc/release_notes/5.52.0.txt
 - doc/release_notes/5.53.0.txt
+- doc/release_notes/5.54.0.txt
+- doc/release_notes/5.55.0.txt
+- doc/release_notes/5.56.0.txt
 - doc/release_notes/5.6.0.txt
 - doc/release_notes/5.7.0.txt
 - doc/release_notes/5.8.0.txt
@@ -449,6 +455,7 @@ files:
 - lib/sequel/extensions/sql_comments.rb
 - lib/sequel/extensions/sql_expr.rb
 - lib/sequel/extensions/sql_log_normalizer.rb
+- lib/sequel/extensions/sqlite_json_ops.rb
 - lib/sequel/extensions/string_agg.rb
 - lib/sequel/extensions/string_date_time.rb
 - lib/sequel/extensions/symbol_aref.rb
@@ -477,6 +484,7 @@ files:
 - lib/sequel/plugins/association_pks.rb
 - lib/sequel/plugins/association_proxies.rb
 - lib/sequel/plugins/async_thread_pool.rb
+- lib/sequel/plugins/auto_restrict_eager_graph.rb
 - lib/sequel/plugins/auto_validations.rb
 - lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb
 - lib/sequel/plugins/before_after_save.rb
@@ -501,6 +509,7 @@ files:
 - lib/sequel/plugins/eager_each.rb
 - lib/sequel/plugins/eager_graph_eager.rb
 - lib/sequel/plugins/empty_failure_backtraces.rb
+- lib/sequel/plugins/enum.rb
 - lib/sequel/plugins/error_splitter.rb
 - lib/sequel/plugins/finder.rb
 - lib/sequel/plugins/forbid_lazy_load.rb
@@ -563,13 +572,13 @@ files:
 - lib/sequel/sql.rb
 - lib/sequel/timezones.rb
 - lib/sequel/version.rb
-homepage: http://sequel.jeremyevans.net
+homepage: https://sequel.jeremyevans.net
 licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/jeremyevans/sequel/issues
-  changelog_uri: http://sequel.jeremyevans.net/rdoc/files/CHANGELOG.html
-  documentation_uri: http://sequel.jeremyevans.net/documentation.html
+  changelog_uri: https://sequel.jeremyevans.net/rdoc/files/CHANGELOG.html
+  documentation_uri: https://sequel.jeremyevans.net/documentation.html
   mailing_list_uri: https://github.com/jeremyevans/sequel/discussions
   source_code_uri: https://github.com/jeremyevans/sequel
 post_install_message: 
@@ -594,7 +603,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key: 
 specification_version: 4
 summary: The Database Toolkit for Ruby