sequel 4.36.0 → 5.61.0

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
@@ -30,10 +32,16 @@ module Sequel
     #
     #   Model.skip_auto_validations(:all)
     #
+    # It is possible to skip auto validations on a per-model-instance basis via:
+    #
+    #   instance.skip_auto_validations(:unique, :not_null) do
+    #     puts instance.valid?
+    #   end
+    #
     # By default, the plugin uses a not_null validation for NOT NULL columns, but that
     # can be changed to a presence validation using an option:
     #
-    #   Model.plugin :auto_validations, :not_null=>:presence
+    #   Model.plugin :auto_validations, not_null: :presence
     #
     # This is useful if you want to enforce that NOT NULL string columns do not
     # allow empty values.
@@ -45,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)
@@ -58,11 +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_eval do
+        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 = []
@@ -70,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,
@@ -81,23 +98,33 @@ module Sequel
 
       # Setup auto validations for the model if it has a dataset.
       def self.configure(model, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           setup_auto_validations if @dataset
           if opts[:not_null] == :presence
             @auto_validate_presence = true
           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
 
@@ -114,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
@@ -127,15 +162,31 @@ module Sequel
           @auto_validate_types
         end
 
-        # Skip automatic validations for the given validation type (:not_null, :types, :unique).
+        # 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
+          @auto_validate_unique_columns.freeze
+
+          super
+        end
+
+        # 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)
-          if type == :all
-            [:not_null, :types, :unique, :max_length].each{|v| skip_auto_validations(v)}
-          elsif type == :types
+          case type
+          when :all
+            [: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
+          when :types
             @auto_validate_types = false
           else
-            send("auto_validate_#{type}_columns").clear
+            public_send("auto_validate_#{type}_columns").clear
           end
         end
 
@@ -148,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]}
@@ -158,38 +210,53 @@ module Sequel
       end
 
       module InstanceMethods
+        # Skip the given types of auto validations on this instance inside the block.
+        def skip_auto_validations(*types)
+          types << :all if types.empty?
+          @_skip_auto_validations = types
+          yield
+        ensure
+          @_skip_auto_validations = nil
+        end
+
         # Validate the model's auto validations columns
         def validate
           super
+          skip = @_skip_auto_validations || EMPTY_ARRAY
+          return if skip.include?(:all)
           opts = model.auto_validate_options
 
-          unless (not_null_columns = model.auto_validate_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:not_null])
-            else
-              validates_not_null(not_null_columns, opts[:not_null])
-            end
+          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 (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
-            if model.auto_validate_presence?
-              validates_presence(not_null_columns, opts[:explicit_not_null])
-            else
-              validates_not_null(not_null_columns, opts[:explicit_not_null])
+
+          unless skip.include?(:not_null)
+            not_null_method = model.auto_validate_presence? ? :validates_presence : :validates_not_null
+            unless (not_null_columns = model.auto_validate_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:not_null])
+            end
+            unless (not_null_columns = model.auto_validate_explicit_not_null_columns).empty?
+              public_send(not_null_method, not_null_columns, opts[:explicit_not_null])
             end
           end
-          unless (max_length_columns = model.auto_validate_max_length_columns).empty?
+
+          unless skip.include?(:max_length) || (max_length_columns = model.auto_validate_max_length_columns).empty?
             max_length_columns.each do |col, len|
               validates_max_length(len, col, opts[:max_length])
             end
           end
 
-          validates_schema_types(keys, opts[:schema_types]) if model.auto_validate_types?
+          unless skip.include?(:types) || !model.auto_validate_types?
+            validates_schema_types(keys, opts[:schema_types])
+          end
 
-          unique_opts = Hash[opts[:unique]]
-          if model.respond_to?(:sti_dataset)
-            unique_opts[:dataset] = model.sti_dataset
+          unless skip.include?(:unique)
+            unique_opts = Hash[opts[:unique]]
+            if model.respond_to?(:sti_dataset)
+              unique_opts[:dataset] = model.sti_dataset
+            end
+            model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
           end
-          model.auto_validate_unique_columns.each{|cols| validates_unique(cols, unique_opts)}
         end
       end
     end

data/lib/sequel/plugins/auto_validations_constraint_validations_presence_message.rb

@@ -0,0 +1,68 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The auto_validations_constraint_validations_presence_message plugin provides
+    # integration for the auto_validations and constraint_validations plugins in
+    # the following situation:
+    #
+    # * A column has a NOT NULL constraint in the database
+    # * A constraint validation for presence exists on the column, with a :message
+    #   option to set a column-specific message, and with the :allow_nil option set
+    #   to true because the CHECK constraint doesn't need to check for NULL values
+    #   as the column itself is NOT NULL
+    # 
+    # In this case, by default the validation error message on the column will
+    # use the more specific constraint validation error message if the column
+    # has a non-NULL empty value, but will use the default auto_validations
+    # message if the column has a NULL value.  With this plugin, the column-specific
+    # constraint validation error message will be used in both cases.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use this auto_validations/constraint_validations
+    #   # integration (called before loading subclasses)
+    #   Sequel::Model.plugin :auto_validations_constraint_validations_presence_message
+    #
+    #   # Make the Album class use this auto_validations/constraint_validations integration
+    #   Album.plugin :auto_validations_constraint_validations_presence_message
+    module AutoValidationsConstraintValidationsPresenceMessage
+      def self.apply(model)
+        model.plugin :auto_validations
+        model.plugin :constraint_validations
+      end
+
+      def self.configure(model, opts=OPTS)
+        model.send(:_adjust_auto_validations_constraint_validations_presence_message)
+      end
+
+      module ClassMethods
+        Plugins.after_set_dataset(self, :_adjust_auto_validations_constraint_validations_presence_message)
+
+        private
+
+        def _adjust_auto_validations_constraint_validations_presence_message
+          if @dataset &&
+             !@auto_validate_options[:not_null][:message] &&
+             !@auto_validate_options[:explicit_not_null][:message]
+
+            @constraint_validations.each do |array|
+              meth, column, opts = array
+
+              if meth == :validates_presence &&
+                 opts &&
+                 opts[:message] &&
+                 opts[:allow_nil] &&
+                 (@auto_validate_not_null_columns.include?(column) || @auto_validate_explicit_not_null_columns.include?(column))
+
+                @auto_validate_not_null_columns.delete(column)
+                @auto_validate_explicit_not_null_columns.delete(column)
+                array[2] = array[2].merge(:allow_nil=>false)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/before_after_save.rb

@@ -2,49 +2,7 @@
 
 module Sequel
   module Plugins
-    # The before_after_save plugin reorders some internal
-    # Sequel operations so they happen before after_create,
-    # after_update, and after_save are called, instead of
-    # after.  These operations are:
-    # 
-    # * Resetting the explicit modified flag
-    # * Refreshing the model or clearing changed columns after creation
-    #
-    # This behavior will become the default in Sequel 5.
-    #
-    # Usage:
-    #
-    #   # Make all model subclasses perform the operations before after_save
-    #   Sequel::Model.plugin :before_after_save
-    #
-    #   # Make the Album class perform the operations before after_save
-    #   Album.plugin :before_after_save
     module BeforeAfterSave
-      module InstanceMethods
-        private
-
-        # Refresh and reset modified flag right after INSERT query.
-        def _after_create(pk)
-          super
-          @modified = false
-          pk ? _save_refresh : changed_columns.clear
-        end
-
-        # Don't refresh or reset modified flag, as it was already done.
-        def _after_save(pk)
-          if @was_new
-            @was_new = nil
-          else
-            @columns_updated = nil
-          end
-        end
-
-        # Refresh and reset modified flag right after UPDATE query.
-        def _after_update
-          super
-          @modified = false
-        end
-      end
     end
   end
 end

data/lib/sequel/plugins/blacklist_security.rb

@@ -15,12 +15,25 @@ module Sequel
     #   # Make the Album class support the blacklist security features.
     #   Album.plugin :blacklist_security
     module BlacklistSecurity
+      # Special array subclass used for marking methods to be removed.
+      class ExceptionList < Array
+      end
+
       module ClassMethods
         # Which columns are specifically restricted in a call to set/update/new/etc.
         # (default: not set).  Some columns are restricted regardless of
         # this setting, such as the primary key column and columns in Model::RESTRICTED_SETTER_METHODS.
         attr_reader :restricted_columns
   
+        Plugins.inherited_instance_variables(self, :@restricted_columns=>:dup)
+
+        # Freeze restricted columns when freezing model class.
+        def freeze
+          @restricted_columns.freeze
+
+          super
+        end
+
         # Set the columns to restrict when using mass assignment (e.g. +set+).  Using this means that
         # attempts to call setter methods for the columns listed here will cause an
         # exception or be silently skipped (based on the +strict_param_setting+ setting).
@@ -28,12 +41,12 @@ module Sequel
         # want not to be used during mass assignment, they need to be listed here as well (without the =).
         #
         # It's generally a bad idea to rely on a blacklist approach for security.  Using a whitelist
-        # approach such as set_allowed_columns or the instance level set_only or set_fields methods
+        # approach such as the whitelist_security plugin or the set_fields methods
         # is usually a better choice.  So use of this method is generally a bad idea.
         #
         #   Artist.set_restricted_columns(:records_sold)
-        #   Artist.set(:name=>'Bob', :hometown=>'Sactown') # No Error
-        #   Artist.set(:name=>'Bob', :records_sold=>30000) # Error
+        #   Artist.set(name: 'Bob', hometown: 'Sactown') # No Error
+        #   Artist.set(name: 'Bob', records_sold: 30000) # Error
         def set_restricted_columns(*cols)
           clear_setter_methods_cache
           @restricted_columns = cols
@@ -45,7 +58,7 @@ module Sequel
         # restricted_columns.
         def get_setter_methods
           meths = super
-          if !allowed_columns && restricted_columns
+          if (!defined?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !is_a?(::Sequel::Plugins::WhitelistSecurity::ClassMethods) || !allowed_columns) && restricted_columns
             meths -= restricted_columns.map{|x| "#{x}="}
           end
           meths
@@ -53,25 +66,21 @@ module Sequel
       end
 
       module InstanceMethods
-        # Special array subclass used for marking methods to be removed.
-        class ExceptionList < Array
-        end
-
         # Set all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +set_fields+ or +set_only+
+        # given in except.  You should probably use +set_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.set_except({:name=>'Jim'}, :hometown)
+        #   artist.set_except({name: 'Jim'}, :hometown)
         #   artist.name # => 'Jim'
         def set_except(hash, *except)
           set_restricted(hash, ExceptionList.new(except.flatten))
         end
     
         # Update all values using the entries in the hash, except for the keys
-        # given in except.  You should probably use +update_fields+ or +update_only+
+        # given in except.  You should probably use +update_fields+
         # instead of this method, as blacklist approaches to security are a bad idea.
         #
-        #   artist.update_except({:name=>'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
+        #   artist.update_except({name: 'Jim'}, :hometown) # UPDATE artists SET name = 'Jim' WHERE (id = 1)
         def update_except(hash, *except)
           update_restricted(hash, ExceptionList.new(except.flatten))
         end

data/lib/sequel/plugins/boolean_readers.rb

@@ -2,7 +2,7 @@
 
 module Sequel
   module Plugins
-    # The BooleanReaders plugin allows for the creation of attribute? methods
+    # The boolean_readers plugin allows for the creation of attribute? methods
     # for boolean columns, which provides a nicer API.  By default, the accessors
     # are created for all columns of type :boolean.  However, you can provide a
     # block to the plugin to change the criteria used to determine if a
@@ -28,8 +28,8 @@ module Sequel
       # Add the boolean_attribute? class method to the model, and create
       # attribute? boolean reader methods for the class's columns if the class has a dataset.
       def self.configure(model, &block)
-        model.instance_eval do
-          (class << self; self; end).send(:define_method, :boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
+        model.instance_exec do
+          define_singleton_method(:boolean_attribute?, &(block || DEFAULT_BOOLEAN_ATTRIBUTE_PROC))
           send(:create_boolean_readers) if @dataset
         end
       end
@@ -48,8 +48,8 @@ module Sequel
 
         # Add attribute? methods for all of the boolean attributes for this model.
         def create_boolean_readers
-          im = instance_methods.collect(&:to_s)
-          if cs = check_non_connection_error{columns}
+          im = instance_methods.map(&:to_s)
+          if cs = check_non_connection_error(false){columns}
             cs.each{|c| create_boolean_reader(c) if boolean_attribute?(c) && !im.include?("#{c}?")}
           end
         end

data/lib/sequel/plugins/boolean_subsets.rb

@@ -9,7 +9,7 @@ module Sequel
     # <tt>column IS TRUE</tt> (assuming the database supports that syntax).
     #
     # You can provide a block to the plugin, which will be called with column name
-    # symbol, and should return an array of arguments to pass to +subset+.
+    # symbol, and should return an array of arguments to pass to +dataset_module.where+.
     # Using this, you can change the method name and arguments for each column.
     # This block is executed in the context of the model class.
     #
@@ -28,12 +28,14 @@ module Sequel
     #     [column.to_s.sub(/\Ais_/, ''), {column=>'Y'}]
     #   end
     module BooleanSubsets
-      # Add the boolean_attribute? class method to the model, and create
-      # attribute? boolean reader methods for the class's columns if the class has a dataset.
+      # Create boolean subset methods for each boolean column.
       def self.configure(model, &block)
-        model.instance_eval do
-          (class << self; self; end).send(:define_method, :boolean_subset_args, &block) if block
-          send(:create_boolean_subsets) if @dataset
+        model.instance_exec do
+          if block
+            define_singleton_method(:boolean_subset_args, &block)
+            singleton_class.send(:private, :boolean_subset_args)
+          end
+          create_boolean_subsets if @dataset
         end
       end
 
@@ -49,8 +51,11 @@ module Sequel
 
         # Add subset methods for all of the boolean columns in this model.
         def create_boolean_subsets
-          if cs = check_non_connection_error{columns}
-            cs.each{|c| subset(*boolean_subset_args(c)) if db_schema[c][:type] == :boolean}
+          if cs = check_non_connection_error(false){columns}
+            cs = cs.select{|c| db_schema[c][:type] == :boolean}.map{|c| boolean_subset_args(c)}
+            dataset_module do
+              cs.each{|c| where(*c)}
+            end
           end
         end
       end