sequel 5.33.0 → 5.58.0

data/lib/sequel/model/base.rb

@@ -491,6 +491,11 @@ module Sequel
       # the module using a the camelized plugin name under Sequel::Plugins.
       def plugin(plugin, *args, &block)
         m = plugin.is_a?(Module) ? plugin : plugin_module(plugin)
+
+        if !m.respond_to?(:apply) && !m.respond_to?(:configure) && (!args.empty? || block)
+          Deprecation.deprecate("Plugin #{plugin} accepts no arguments or block, and passing arguments/block to it", "Remove arguments and block when loading the plugin")
+        end
+
         unless @plugins.include?(m)
           @plugins << m
           m.apply(self, *args, &block) if m.respond_to?(:apply)
@@ -500,8 +505,12 @@ module Sequel
             dataset_extend(m::DatasetMethods, :create_class_methods=>false)
           end
         end
+
         m.configure(self, *args, &block) if m.respond_to?(:configure)
       end
+      # :nocov:
+      ruby2_keywords(:plugin) if respond_to?(:ruby2_keywords, true)
+      # :nocov:
 
       # Returns primary key attribute hash.  If using a composite primary key
       # value such be an array with values for each primary key in the correct
@@ -593,7 +602,7 @@ module Sequel
           @columns = superclass.instance_variable_get(:@columns)
           @db_schema = superclass.instance_variable_get(:@db_schema)
         else
-          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse) if @dataset_method_modules
+          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse)
           @db_schema = get_db_schema
         end
 
@@ -632,8 +641,7 @@ module Sequel
   
       # Cache of setter methods to allow by default, in order to speed up mass assignment.
       def setter_methods
-        return @setter_methods if @setter_methods
-        @setter_methods = get_setter_methods
+        @setter_methods || (@setter_methods = get_setter_methods)
       end
 
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -674,13 +682,11 @@ module Sequel
       
       # Yield to the passed block and if do_raise is false, swallow all errors other than DatabaseConnectionErrors.
       def check_non_connection_error(do_raise=require_valid_table)
-        begin
-          db.transaction(:savepoint=>:only){yield}
-        rescue Sequel::DatabaseConnectionError
-          raise
-        rescue Sequel::Error
-          raise if do_raise
-        end
+        db.transaction(:savepoint=>:only){yield}
+      rescue Sequel::DatabaseConnectionError
+        raise
+      rescue Sequel::Error
+        raise if do_raise
       end
 
       # Convert the given object to a Dataset that should be used as
@@ -721,8 +727,14 @@ module Sequel
         im = instance_methods
         overridable_methods_module.module_eval do
           meth = :"#{column}="
-          define_method(column){self[column]} unless im.include?(column)
-          define_method(meth){|v| self[column] = v} unless im.include?(meth)
+          unless im.include?(column)
+            define_method(column){self[column]}
+            alias_method(column, column)
+          end
+          unless im.include?(meth)
+            define_method(meth){|v| self[column] = v}
+            alias_method(meth, meth)
+          end
         end
       end
   
@@ -735,8 +747,14 @@ module Sequel
         im = instance_methods
         columns.each do |column|
           meth = :"#{column}="
-          overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__) unless im.include?(column)
-          overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__) unless im.include?(meth)
+          unless im.include?(column)
+            overridable_methods_module.module_eval("def #{column}; self[:#{column}] end", __FILE__, __LINE__)
+            overridable_methods_module.send(:alias_method, column, column)
+          end
+          unless im.include?(meth)
+            overridable_methods_module.module_eval("def #{meth}(v); self[:#{column}] = v end", __FILE__, __LINE__)
+            overridable_methods_module.send(:alias_method, meth, meth)
+          end
         end
       end
   
@@ -751,6 +769,10 @@ module Sequel
         else
           define_singleton_method(meth){|*args, &block| dataset.public_send(meth, *args, &block)}
         end
+        singleton_class.send(:alias_method, meth, meth)
+        # :nocov:
+        singleton_class.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
 
       # Get the schema from the database, fall back on checking the columns
@@ -820,7 +842,6 @@ module Sequel
         super
         ivs = subclass.instance_variables
         inherited_instance_variables.each do |iv, dup|
-          next if ivs.include?(iv)
           if (sup_class_value = instance_variable_get(iv)) && dup
             sup_class_value = case dup
             when :dup
@@ -1070,7 +1091,7 @@ module Sequel
         @modified = true
         initialize_set(values)
         _clear_changed_columns(:initialize)
-        yield self if block_given?
+        yield self if defined?(yield)
       end
 
       # Returns value of the column's attribute.
@@ -1116,7 +1137,7 @@ module Sequel
         when nil
           return false
         when Array
-          return false if pk.any?(&:nil?)
+          return false if pkv.any?(&:nil?)
         end
 
         (obj.class == model) && (obj.pk == pkv)
@@ -1237,12 +1258,12 @@ module Sequel
       # Once an object is frozen, you cannot modify it's values, changed_columns,
       # errors, or dataset.
       def freeze
-        values.freeze
-        _changed_columns.freeze
         unless errors.frozen?
           validate
           errors.freeze
         end
+        values.freeze
+        _changed_columns.freeze
         this if !new? && model.primary_key
         super
       end
@@ -1607,11 +1628,9 @@ module Sequel
       #   artist.set(name: 'Invalid').valid? # => false
       #   artist.errors.full_messages # => ['name cannot be Invalid']
       def valid?(opts = OPTS)
-        begin
-          _valid?(opts)
-        rescue HookFailed
-          false
-        end
+        _valid?(opts)
+      rescue HookFailed
+        false
       end
 
       private
@@ -2232,7 +2251,9 @@ module Sequel
     plugin self
 
     singleton_class.send(:undef_method, :dup, :clone, :initialize_copy)
+    # :nocov:
     if RUBY_VERSION >= '1.9.3'
+    # :nocov:
       singleton_class.send(:undef_method, :initialize_clone, :initialize_dup)
     end
   end

data/lib/sequel/model/errors.rb

@@ -38,7 +38,7 @@ module Sequel
       def full_messages
         inject([]) do |m, kv| 
           att, errors = *kv
-          errors.each {|e| m << (e.is_a?(LiteralString) ? e : "#{Array(att).join(' and ')} #{e}")}
+          errors.each {|e| m << (e.is_a?(LiteralString) ? e : full_message(att, e))}
           m
         end
       end
@@ -53,6 +53,15 @@ module Sequel
           v
         end
       end
+
+      private
+
+      # Create full error message to use for the given attribute (or array of attributes)
+      # and error message. This can be overridden for easier internalization.
+      def full_message(att, error_msg)
+        att = att.join(' and ') if att.is_a?(Array)
+        "#{att} #{error_msg}"
+      end
     end
   end
 end

data/lib/sequel/model/inflections.rb

@@ -4,7 +4,7 @@ module Sequel
   # Yield the Inflections module if a block is given, and return
   # the Inflections module.
   def self.inflections
-    yield Inflections if block_given?
+    yield Inflections if defined?(yield)
     Inflections
   end
 

data/lib/sequel/model/plugins.rb

@@ -31,6 +31,9 @@ module Sequel
     def self.def_dataset_methods(mod, meths)
       Array(meths).each do |meth|
         mod.class_eval("def #{meth}(*args, &block); dataset.#{meth}(*args, &block) end", __FILE__, __LINE__)
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
     end
 
@@ -119,6 +122,7 @@ module Sequel
 
       model.send(:define_method, meth, &block)
       model.send(:private, meth)
+      model.send(:alias_method, meth, meth)
       call_meth
     end
 
@@ -140,6 +144,8 @@ module Sequel
           keyword = :required
         when :key, :keyrest
           keyword ||= true
+        else
+          raise Error, "invalid arg_type passed to _define_sequel_method_arg_numbers: #{arg_type}"
         end
       end
       arity = callable.arity
@@ -149,9 +155,8 @@ module Sequel
       required_args = arity
       arity -= 1 if keyword == :required
 
-      if callable.is_a?(Proc) && !callable.lambda?
-        optional_args -= arity
-      end
+      # callable currently is always a non-lambda Proc
+      optional_args -= arity
 
       [required_args, optional_args, rest, keyword]
     end

data/lib/sequel/model.rb

@@ -69,7 +69,9 @@ module Sequel
     require_relative "model/base"
     require_relative "model/exceptions"
     require_relative "model/errors"
+    # :nocov:
     if !defined?(::SEQUEL_NO_ASSOCIATIONS) && !ENV.has_key?('SEQUEL_NO_ASSOCIATIONS')
+    # :nocov:
       require_relative 'model/associations'
       plugin Model::Associations
     end
@@ -77,7 +79,7 @@ module Sequel
     def_Model(::Sequel)
 
     # The setter methods (methods ending with =) that are never allowed
-    # to be called automatically via +set+/+update+/+new+/etc..
+    # to be called automatically via +set+/+update+/+new+/etc.
     RESTRICTED_SETTER_METHODS = instance_methods.map(&:to_s).select{|l| l.end_with?('=')}.freeze
   end
 end

data/lib/sequel/plugins/association_pks.rb

@@ -2,13 +2,17 @@
 
 module Sequel
   module Plugins
-    # The association_pks plugin adds association_pks and association_pks=
-    # instance methods to the model class for each association added.  These
-    # methods allow for easily returning the primary keys of the associated
-    # objects, and easily modifying which objects are associated:
+    # The association_pks plugin adds association_pks, association_pks=, and
+    # association_pks_dataset instance methods to the model class for each
+    # one_to_many and many_to_many association added.  These methods allow for
+    # easily returning the primary keys of the associated objects, and easily
+    # modifying which objects are associated:
     #
     #   Artist.one_to_many :albums
     #   artist = Artist[1]
+    #   artist.album_pks_dataset
+    #   # SELECT id FROM albums WHERE (albums.artist_id = 1)
+    #
     #   artist.album_pks # [1, 2, 3]
     #   artist.album_pks = [2, 4]
     #   artist.album_pks # [2, 4]
@@ -22,11 +26,18 @@ module Sequel
     # This plugin makes modifications directly to the underlying tables,
     # it does not create or return any model objects, and therefore does
     # not call any callbacks.  If you have any association callbacks,
-    # you probably should not use the setter methods.
+    # you probably should not use the setter methods this plugin adds.
     #
     # By default, changes to the association will not happen until the object
-    # is saved.  However, using the delay_pks: false option, you can have the
-    # changes made immediately when the association_pks setter method is called.
+    # is saved.  However, using the delay_pks: false association option, you can have
+    # the changes made immediately when the association_pks setter method is called.
+    #
+    # By default, repeated calls to the association_pks getter method will not be
+    # cached, unless the setter method has been used and the delay_pks: false
+    # association option is not used.  You can set caching of repeated calls to the
+    # association_pks getter method using the :cache_pks association option.  You can
+    # pass the :refresh option when calling the getter method to ignore any existing
+    # cached values, similar to how the :refresh option works with associations.
     #
     # By default, if you pass a nil value to the setter, an exception will be raised.
     # You can change this behavior by using the :association_pks_nil association option.
@@ -60,9 +71,11 @@ module Sequel
 
         # Define a association_pks method using the block for the association reflection 
         def def_association_pks_methods(opts)
+          association_module_def(opts[:pks_dataset_method], &opts[:pks_dataset])
+
           opts[:pks_getter_method] = :"#{singularize(opts[:name])}_pks_getter"
           association_module_def(opts[:pks_getter_method], &opts[:pks_getter])
-          association_module_def(:"#{singularize(opts[:name])}_pks", opts){_association_pks_getter(opts)}
+          association_module_def(:"#{singularize(opts[:name])}_pks", opts){|dynamic_opts=OPTS| _association_pks_getter(opts, dynamic_opts)}
 
           if opts[:pks_setter]
             opts[:pks_setter_method] = :"#{singularize(opts[:name])}_pks_setter"
@@ -84,7 +97,9 @@ module Sequel
           clpk = lpk.is_a?(Array)
           crk = rk.is_a?(Array)
 
-          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = if join_associated_table = opts[:association_pks_use_associated_table]
             tname = opts[:join_table]
             lambda do
               cond = if clpk
@@ -95,16 +110,26 @@ module Sequel
               rpk = opts.associated_class.primary_key
               opts.associated_dataset.
                 naked.where(cond).
-                select_map(Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
+                select(*Sequel.public_send(rpk.is_a?(Array) ? :deep_qualify : :qualify, opts.associated_class.table_name, rpk))
             end
           elsif clpk
             lambda do
               cond = lk.zip(lpk).map{|k, pk| [k, get_column_value(pk)]}
-              _join_table_dataset(opts).where(cond).select_map(rk)
+              _join_table_dataset(opts).where(cond).select(*rk)
+            end
+          else
+            lambda do
+              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select(*rk)
+            end
+          end
+
+          opts[:pks_getter] = if join_associated_table = opts[:association_pks_use_associated_table]
+            lambda do
+              public_send(dataset_method).map(opts.associated_class.primary_key)
             end
           else
             lambda do
-              _join_table_dataset(opts).where(lk=>get_column_value(lpk)).select_map(rk)
+              public_send(dataset_method).map(rk)
             end
           end
 
@@ -145,8 +170,14 @@ module Sequel
 
           key = opts[:key]
 
+          dataset_method = opts[:pks_dataset_method] = :"#{singularize(opts[:name])}_pks_dataset"
+
+          opts[:pks_dataset] = lambda do
+            public_send(opts[:dataset_method]).select(*opts.associated_class.primary_key)
+          end
+
           opts[:pks_getter] = lambda do
-            public_send(opts[:dataset_method]).select_map(opts.associated_class.primary_key)
+            public_send(dataset_method).map(opts.associated_class.primary_key)
           end
 
           unless opts[:read_only]
@@ -207,12 +238,22 @@ module Sequel
         # Return the primary keys of the associated objects.
         # If the receiver is a new object, return any saved
         # pks, or an empty array if no pks have been saved.
-        def _association_pks_getter(opts)
+        def _association_pks_getter(opts, dynamic_opts=OPTS)
+          do_cache = opts[:cache_pks]
           delay = opts.fetch(:delay_pks, true)
-          if new? && delay
+          cache_or_delay = do_cache || delay
+
+          if dynamic_opts[:refresh] && @_association_pks
+            @_association_pks.delete(opts[:name])
+          end
+
+          if new? && cache_or_delay
             (@_association_pks ||= {})[opts[:name]] ||= []
-          elsif delay && @_association_pks && (objs = @_association_pks[opts[:name]])
+          elsif cache_or_delay && @_association_pks && (objs = @_association_pks[opts[:name]])
             objs
+          elsif do_cache
+           # pks_getter_method is private
+            (@_association_pks ||= {})[opts[:name]] = send(opts[:pks_getter_method])
           else
            # pks_getter_method is private
             send(opts[:pks_getter_method])
@@ -254,9 +295,10 @@ module Sequel
 
           if primary_key.is_a?(Array)
             if (cols = sch.values_at(*klass.primary_key)).all? && (convs = cols.map{|c| c[:type] == :integer}).all?
+              db = model.db
               pks.map do |cpk|
-                cpk.zip(convs).map do |pk, conv|
-                  conv ? model.db.typecast_value(:integer, pk) : pk
+                cpk.map do |pk|
+                  db.typecast_value(:integer, pk)
                 end
               end
             else

data/lib/sequel/plugins/association_proxies.rb

@@ -99,6 +99,9 @@ module Sequel
           end
           v.public_send(meth, *args, &block)
         end
+        # :nocov:
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+        # :nocov:
       end
 
       module ClassMethods

data/lib/sequel/plugins/async_thread_pool.rb

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+
+module Sequel
+  extension 'async_thread_pool'
+
+  module Plugins
+    # The async_thread_pool plugin makes it slightly easier to use the async_thread_pool
+    # Database extension with models.  It makes Model.async return an async dataset for the
+    # model, and support async behavior for #destroy, #with_pk, and #with_pk! for model
+    # datasets:
+    #
+    #   # Will load the artist with primary key 1 asynchronously
+    #   artist = Artist.async.with_pk(1)
+    #
+    # You must load the async_thread_pool Database extension into the Database object the
+    # model class uses in order for async behavior to work.
+    #
+    # Usage:
+    #
+    #   # Make all model subclass datasets support support async class methods and additional
+    #   # async dataset methods
+    #   Sequel::Model.plugin :async_thread_pool
+    #
+    #   # Make the Album class support async class method and additional async dataset methods
+    #   Album.plugin :async_thread_pool
+    module AsyncThreadPool
+      module ClassMethods
+        Plugins.def_dataset_methods(self, :async)
+      end
+
+      module DatasetMethods
+        [:destroy, :with_pk, :with_pk!].each do |meth|
+          ::Sequel::Database::AsyncThreadPool::DatasetMethods.define_async_method(self, meth)
+        end
+      end
+    end
+  end
+end
+

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

@@ -14,7 +14,9 @@ module Sequel
     # the plugin looks at the database schema for the model's table.  To determine
     # the unique validations, Sequel looks at the indexes on the table.  In order
     # for this plugin to be fully functional, the underlying database adapter needs
-    # to support both schema and index parsing.
+    # to support both schema and index parsing.  Additionally, unique validations are
+    # only added for models that select from a simple table, they are not added for models
+    # that select from a subquery or joined dataset.
     #
     # This plugin uses the validation_helpers plugin underneath to implement the
     # validations.  It does not allow for any per-column validation message
@@ -51,6 +53,11 @@ module Sequel
     # This works for unique_opts, max_length_opts, schema_types_opts,
     # explicit_not_null_opts, and not_null_opts.
     #
+    # If you only want auto_validations to add validations to columns that do not already
+    # have an error associated with them, you can use the skip_invalid option:
+    #
+    #   Model.plugin :auto_validations, skip_invalid: true
+    #
     # Usage:
     #
     #   # Make all model subclass use auto validations (called before loading subclasses)
@@ -64,12 +71,14 @@ module Sequel
       MAX_LENGTH_OPTIONS = {:from=>:values, :allow_nil=>true}.freeze
       SCHEMA_TYPES_OPTIONS = NOT_NULL_OPTIONS
       UNIQUE_OPTIONS = NOT_NULL_OPTIONS
+      NO_NULL_BYTE_OPTIONS = MAX_LENGTH_OPTIONS
       EMPTY_ARRAY = [].freeze
 
       def self.apply(model, opts=OPTS)
         model.instance_exec do
           plugin :validation_helpers
           @auto_validate_presence = false
+          @auto_validate_no_null_byte_columns = []
           @auto_validate_not_null_columns = []
           @auto_validate_explicit_not_null_columns = []
           @auto_validate_max_length_columns = []
@@ -77,6 +86,7 @@ module Sequel
           @auto_validate_types = true
 
           @auto_validate_options = {
+              :no_null_byte=>NO_NULL_BYTE_OPTIONS,
               :not_null=>NOT_NULL_OPTIONS,
               :explicit_not_null=>EXPLICIT_NOT_NULL_OPTIONS,
               :max_length=>MAX_LENGTH_OPTIONS,
@@ -95,16 +105,26 @@ module Sequel
           end
 
           h = @auto_validate_options.dup
-          [:not_null, :explicit_not_null, :max_length, :schema_types, :unique].each do |type|
+          [:not_null, :explicit_not_null, :max_length, :no_null_byte, :schema_types, :unique].each do |type|
             if type_opts = opts[:"#{type}_opts"]
               h[type] = h[type].merge(type_opts).freeze
             end
           end
+
+          if opts[:skip_invalid]
+            [:not_null, :explicit_not_null, :no_null_byte, :max_length, :schema_types].each do |type|
+              h[type] = h[type].merge(:skip_invalid=>true).freeze
+            end
+          end
+
           @auto_validate_options = h.freeze
         end
       end
 
       module ClassMethods
+        # The columns with automatic no_null_byte validations
+        attr_reader :auto_validate_no_null_byte_columns
+
         # The columns with automatic not_null validations
         attr_reader :auto_validate_not_null_columns
 
@@ -121,7 +141,15 @@ module Sequel
         # Inherited options
         attr_reader :auto_validate_options
 
-        Plugins.inherited_instance_variables(self, :@auto_validate_presence=>nil, :@auto_validate_types=>nil, :@auto_validate_not_null_columns=>:dup, :@auto_validate_explicit_not_null_columns=>:dup, :@auto_validate_max_length_columns=>:dup, :@auto_validate_unique_columns=>:dup, :@auto_validate_options => :dup)
+        Plugins.inherited_instance_variables(self,
+          :@auto_validate_presence=>nil,
+          :@auto_validate_types=>nil,
+          :@auto_validate_no_null_byte_columns=>:dup,
+          :@auto_validate_not_null_columns=>:dup,
+          :@auto_validate_explicit_not_null_columns=>:dup,
+          :@auto_validate_max_length_columns=>:dup,
+          :@auto_validate_unique_columns=>:dup,
+          :@auto_validate_options => :dup)
         Plugins.after_set_dataset(self, :setup_auto_validations)
 
         # Whether to use a presence validation for not null columns
@@ -136,6 +164,7 @@ module Sequel
 
         # Freeze auto_validation settings when freezing model class.
         def freeze
+          @auto_validate_no_null_byte_columns.freeze
           @auto_validate_not_null_columns.freeze
           @auto_validate_explicit_not_null_columns.freeze
           @auto_validate_max_length_columns.freeze
@@ -144,12 +173,13 @@ module Sequel
           super
         end
 
-        # Skip automatic validations for the given validation type (:not_null, :types, :unique).
+        # Skip automatic validations for the given validation type
+        # (:not_null, :types, :unique, :max_length, :no_null_byte).
         # If :all is given as the type, skip all auto validations.
         def skip_auto_validations(type)
           case type
           when :all
-            [:not_null, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
+            [:not_null, :no_null_byte, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
           when :not_null
             auto_validate_not_null_columns.clear
             auto_validate_explicit_not_null_columns.clear
@@ -169,6 +199,7 @@ module Sequel
           explicit_not_null_cols += Array(primary_key)
           @auto_validate_explicit_not_null_columns = explicit_not_null_cols.uniq
           @auto_validate_max_length_columns = db_schema.select{|col, sch| sch[:type] == :string && sch[:max_length].is_a?(Integer)}.map{|col, sch| [col, sch[:max_length]]}
+          @auto_validate_no_null_byte_columns = db_schema.select{|_, sch| sch[:type] == :string}.map{|col, _| col}
           table = dataset.first_source_table
           @auto_validate_unique_columns = if db.supports_index_parsing? && [Symbol, SQL::QualifiedIdentifier, SQL::Identifier, String].any?{|c| table.is_a?(c)}
             db.indexes(table).select{|name, idx| idx[:unique] == true}.map{|name, idx| idx[:columns].length == 1 ? idx[:columns].first : idx[:columns]}
@@ -195,6 +226,9 @@ module Sequel
           return if skip.include?(:all)
           opts = model.auto_validate_options
 
+          unless skip.include?(:no_null_byte) || (no_null_byte_columns = model.auto_validate_no_null_byte_columns).empty?
+            validates_no_null_byte(no_null_byte_columns, opts[:no_null_byte])
+          end
 
           unless skip.include?(:not_null)
             not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null