sequel 5.83.0 → 5.106.0

data/lib/sequel/plugins/many_through_many.rb

@@ -146,6 +146,27 @@ module Sequel
           ds
         end
 
+        def lateral_subquery_filter_limit_strategy_conditions_key
+          qualify(reverse_edges.first[:table], reverse_edges.first[:left])
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_lateral_dataset(ds)
+          ds.where(Array(qualify(edges.first[:table], edges.first[:right])).zip(Array(qualify(self[:model].table_name, edges.first[:left]))))
+        end
+
+        def lateral_subquery_filter_limit_strategy_filter_dataset(ds, obj)
+          first_edge, *remaining_edges = edges
+          filter_ds = ds.db.from(first_edge[:table]).
+            select(*qualify(first_edge[:table], first_edge[:right])).
+            where(lateral_subquery_filter_limit_strategy_conditions(obj))
+
+          remaining_edges.each do |edge|
+            filter_ds = filter_ds.join(edge[:table], Array(edge[:right]).zip(Array(edge[:left])))
+          end
+
+          ds.where(qualify(self[:model].table_name, self[:left_primary_key]) => filter_ds)
+        end
+
         # Make sure to use unique table aliases when lazy loading or eager loading
         def calculate_reverse_edge_aliases(reverse_edges)
           aliases = [associated_class.table_name]

data/lib/sequel/plugins/modification_detection.rb

@@ -34,6 +34,8 @@ module Sequel
     #   Album.plugin :modification_detection
     module ModificationDetection
       module ClassMethods
+        Plugins.model_instance_variables(self, :@values_hashes)
+
         # Calculate the hashes for all of the column values, so that they
         # can be compared later to determine if the column value has changed.
         def call(_)

data/lib/sequel/plugins/mssql_optimistic_locking.rb

@@ -55,7 +55,7 @@ module Sequel
         def _update_without_checking(columns)
           ds = _update_dataset
           lc = model.lock_column
-          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel[:inserted][lc]]).update_sql(columns))).all
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.output(nil, [Sequel[:inserted][lc]]).update_sql(columns).freeze)).all
           values[lc] = rows.first[lc] unless rows.empty?
           rows.length
         end

data/lib/sequel/plugins/nested_attributes.rb

@@ -129,7 +129,7 @@ module Sequel
         #
         # If a block is provided, it is used to set the :reject_if option.
         def nested_attributes(*associations, &block)
-          include(@nested_attributes_module ||= Module.new) unless @nested_attributes_module
+          include(@nested_attributes_module ||= Sequel.set_temp_name(Module.new){"#{name}::@nested_attributes_module"}) unless @nested_attributes_module
           opts = associations.last.is_a?(Hash) ? associations.pop : OPTS
           reflections = associations.map{|a| association_reflection(a) || raise(Error, "no association named #{a} for #{self}")}
           reflections.each do |r|
@@ -188,11 +188,10 @@ module Sequel
         
         # Create a new associated object with the given attributes, validate
         # it when the parent is validated, and save it when the object is saved.
-        # Returns the object created.
+        # Returns the new object.
         def nested_attributes_create(meta, attributes)
+          obj = nested_attributes_new(meta, attributes)
           reflection = meta[:reflection]
-          obj = reflection.associated_class.new
-          nested_attributes_set_attributes(meta, obj, attributes)
           delay_validate_associated_object(reflection, obj)
           if reflection.returns_array?
             public_send(reflection[:name]) << obj
@@ -254,7 +253,13 @@ module Sequel
           end
           obj
         end
-        
+
+        # Returns a new object of the associated class with the given attributes set.
+        def nested_attributes_new(meta, attributes)
+          obj = meta[:reflection].associated_class.new
+          nested_attributes_set_attributes(meta, obj, attributes)
+        end
+
         # Set the fields in the obj based on the association, only allowing
         # specific :fields if configured.
         def nested_attributes_set_attributes(meta, obj, attributes)

data/lib/sequel/plugins/paged_operations.rb

@@ -157,13 +157,16 @@ module Sequel
             raise Error, "the paged_operations plugin is not supported on DB2 when using emulated offsets, set the :offset_strategy Database option to 'limit_offset' or 'offset_fetch'"
           end
 
-          case pk = model.primary_key
+          case pk = unambiguous_primary_key
           when Symbol
             Sequel.identifier(pk)
           when Array
             raise Error, "cannot use #{meth} on a model with a composite primary key"
-          else
+          when nil
             raise Error, "cannot use #{meth} on a model without a primary key"
+          else
+            # Likely SQL::QualifiedIdentifier, if the dataset is joined.
+            pk
           end
         end
 

data/lib/sequel/plugins/pg_array_associations.rb

@@ -541,7 +541,7 @@ module Sequel
             if (assoc_pks = obj.get_column_value(key)) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks.to_a]
             end
-          when Array
+          when Array, Set
             if (assoc_pks = obj.map{|o| o.get_column_value(key)}.flatten.compact.uniq) && !assoc_pks.empty?
               Sequel[pk=>assoc_pks]
             end
@@ -563,7 +563,7 @@ module Sequel
             if pkv = obj.get_column_value(ref.primary_key_method)
               Sequel.pg_array_op(key).contains(Sequel.pg_array([pkv], ref.array_type))
             end
-          when Array
+          when Array, Set
             if (pkvs = obj.map{|o| o.get_column_value(ref.primary_key_method)}.compact) && !pkvs.empty?
               Sequel.pg_array(key).overlaps(Sequel.pg_array(pkvs, ref.array_type))
             end

data/lib/sequel/plugins/pg_auto_constraint_validations.rb

@@ -135,7 +135,12 @@ module Sequel
           raise Error, "No pg_auto_constraint_validations setup" unless file = @pg_auto_constraint_validations_cache_file
           pg_auto_constraint_validations_cache = {}
           @pg_auto_constraint_validations_cache.sort.each do |k, v|
-            pg_auto_constraint_validations_cache[k] = v
+            h = {}
+            v.each do |k, entry|
+              entry = Hash[entry.sort] if entry.is_a?(Hash)
+              h[k] = entry
+            end
+            pg_auto_constraint_validations_cache[k] = h
           end
           File.open(file, 'wb'){|f| f.write(Marshal.dump(pg_auto_constraint_validations_cache))}
           nil

data/lib/sequel/plugins/pg_auto_validate_enums.rb

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_auto_validate_enums plugin implements automatic validations for
+    # enum columns, ensuring that enum columns have a valid value.  With this
+    # plugin, trying to save with an invalid enum value results in
+    # Sequel::ValidationFailed before saving, instead of Sequel::DatabaseError
+    # (wrapping PG::InvalidTextRepresentation or similar exception) during saving.
+    # 
+    #   class Person < Sequel::Model
+    #     # assume state enum column with allowed values active and inactive
+    #     plugin :pg_auto_validate_enums
+    #   end
+    #   p = Person.new(state: "active").valid? # => true
+    #   p = Person.new(state: "inactive").valid? # => true
+    #   p = Person.new(state: "other").valid? # => false
+    #
+    # While you can load this into individual model classes, typical use would
+    # be to load it into Sequel::Model or the appropriate model base class,
+    # and have all models that inherit from that class automatically pick it up.
+    #
+    # This plugin depends on the validation_helpers plugin.
+    module PgAutoValidateEnums
+      # Load the validation_helpers plugin.
+      def self.apply(model, opts=OPTS)
+        model.plugin(:validation_helpers)
+      end
+
+      # Load the pg_enum extension into the database, and reload the schema
+      # if it is already loaded. The opts given are used for the validates_includes
+      # validations (with allow_nil: true and from: :values enabled by default,
+      # to avoid issues with nullable enum columns and cases where the column
+      # method has been overridden.
+      def self.configure(model, opts=OPTS)
+        model.instance_exec do
+          db.extension(:pg_enum) unless @db.instance_variable_get(:@enum_labels)
+          if @db_schema
+            get_db_schema(true)
+            _get_pg_pg_auto_validate_enums_metadata
+          end
+          @pg_auto_validate_enums_opts = {allow_nil: true, from: :values}.merge!(opts).freeze
+        end
+      end
+
+      module ClassMethods
+        # Hash with enum column symbol values and arrays of valid string values.
+        attr_reader :pg_auto_validate_enums_metadata
+
+        # Options to pass to the validates_includes calls used by the plugin.
+        attr_reader :pg_auto_validate_enums_opts
+
+        Plugins.after_set_dataset(self, :_get_pg_pg_auto_validate_enums_metadata)
+
+        Plugins.inherited_instance_variables(self,
+          :@pg_auto_validate_enums_metadata=>nil,
+          :@pg_auto_validate_enums_opts=>nil)
+
+        private
+
+        # Parse the column schema to find columns with :enum_values entries,
+        # which will be used to setup validations.
+        def _get_pg_pg_auto_validate_enums_metadata
+          metadata = {}
+          @db_schema.each do |key, sch|
+            if enum_values = sch[:enum_values]
+              metadata[key] = enum_values
+            end
+          end
+          @pg_auto_validate_enums_metadata = metadata.freeze
+        end
+      end
+
+      module InstanceMethods
+        # Validate that all of the model's enum columns have valid values.
+        def validate
+          super
+
+          klass = self.class
+          opts = klass.pg_auto_validate_enums_opts
+          klass.pg_auto_validate_enums_metadata.each do |column, values|
+            validates_includes(values, column, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_eager_any_typed_array.rb

@@ -0,0 +1,95 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The pg_eager_any_typed_array plugin automatically converts
+    # the predicate expressions used for eager loading from:
+    #
+    #   table.column IN (value_list)
+    #
+    # to:
+    #
+    #   table.column = ANY(array_expr::type[])
+    #
+    # This makes it easier to use the pg_auto_parameterize_in_array
+    # extension with the :treat_string_list_as_text_array option,
+    # when using foreign keys with non-text database types that are represented
+    # by Ruby strings, such as enum and uuid types.
+    #
+    # Most association types that ship with Sequel have their predicate
+    # expressions converted by this plugin.  Here are the exceptions:
+    #
+    # * associations using composite predicate keys
+    # * many_to_pg_array associations
+    # * many_to_many/one_through_one associations using :join_table_db option
+    # * many_through_many/one_through_many associations using
+    #   :separate_table_per_query option
+    #
+    # To avoid predicate conversion for particular associations, set the
+    # :eager_loading_predicate_transform association option to nil/false.
+    #
+    # This plugin loads the pg_array extension into the model's Database.
+    module PgEagerAnyTypedArray
+      # Add the pg_array extension to the database
+      def self.apply(model)
+        model.db.extension(:pg_array)
+      end
+
+      module ClassMethods
+        TRANSFORM = proc do |values, ref|
+          type = ref.send(:cached_fetch, :_pg_eager_any_typed_array_type) do
+            key = ref.predicate_key
+            next if key.is_a?(Array)
+
+            while key.is_a?(SQL::QualifiedIdentifier)
+              key = key.column
+            end
+
+            # :nocov:
+            # many_to_pg_array association type does not need changes, as it
+            # already converts the values to a typed postgres array, it does
+            # not call the code that uses :eager_loading_predicate_transform.
+            #
+            # No association type that ships with Sequel can reach this code
+            # unless it is one of these types, but external association types
+            # could potentially reach it.
+            sch = case ref[:type]
+            # :nocov:
+            when :many_to_one, :one_to_one, :one_to_many, :pg_array_to_many
+              ref.associated_class.db_schema
+            when :many_to_many, :one_through_one
+              # Not compatible with the :join_table_db option, but that option
+              # does not call into this code.
+              Hash[ref.associated_class.db.schema(ref.join_table_source)]
+            when :many_through_many, :one_through_many
+              # Not compatible with the :separate_query_per_table option, but
+              # that option does not call into this code.
+              Hash[ref.associated_class.db.schema(ref[:through][0][:table])]
+            end
+
+            if sch && (sch = sch[key])
+              sch[:db_type]
+            end
+          end
+
+          if type
+            Sequel.function(:ANY, Sequel.pg_array(values, type))
+          else
+            values
+          end
+        end
+
+        # Set the :eager_loading_predicate_transform option if not already set
+        def associate(type, name, opts = OPTS, &block)
+          res = super
+
+          unless res.has_key?(:eager_loading_predicate_transform)
+            res[:eager_loading_predicate_transform] = TRANSFORM
+          end
+
+          res
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/pg_xmin_optimistic_locking.rb

@@ -99,7 +99,7 @@ module Sequel
         # Add an RETURNING clause to fetch the updated xmin when updating the row.
         def _update_without_checking(columns)
           ds = _update_dataset
-          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.returning(:xmin).update_sql(columns))).all
+          rows = ds.clone(ds.send(:default_server_opts, :sql=>ds.returning(:xmin).update_sql(columns).freeze)).all
           values[:xmin] = rows.first[:xmin] unless rows.empty?
           rows.length
         end

data/lib/sequel/plugins/rcte_tree.rb

@@ -81,7 +81,7 @@ module Sequel
 
         opts = opts.dup
         opts[:class] = model
-        opts[:methods_module] = Module.new
+        opts[:methods_module] = Sequel.set_temp_name(Module.new){"#{model.name}::_rcte_tree[:methods_module]"}
         opts[:union_all] = opts[:union_all].nil? ? true : opts[:union_all]
         model.send(:include, opts[:methods_module])
         
@@ -111,7 +111,7 @@ module Sequel
           ancestor_base_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           descendant_base_case_columns = key_array.zip(key_aliases).map{|k, ka_| SQL::AliasedExpression.new(k, ka_)} + c_all
           recursive_case_columns = prkey_array.zip(key_aliases).map{|k, ka_| SQL::QualifiedIdentifier.new(t, ka_)} + c_all
-          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.values.delete(ka_)]}}
+          extract_key_alias = lambda{|m| key_aliases.map{|ka_| bd_conv[m.remove_key!(ka_)]}}
         else
           key_present = key_conv = lambda{|m| m[key]}
           prkey_conv = lambda{|m| m[prkey]}
@@ -119,7 +119,7 @@ module Sequel
           ancestor_base_case_columns = [SQL::AliasedExpression.new(prkey, ka)] + c_all
           descendant_base_case_columns = [SQL::AliasedExpression.new(key, ka)] + c_all
           recursive_case_columns = [SQL::QualifiedIdentifier.new(t, ka)] + c_all
-          extract_key_alias = lambda{|m| bd_conv[m.values.delete(ka)]}
+          extract_key_alias = lambda{|m| bd_conv[m.remove_key!(ka)]}
         end
         
         parent = opts.merge(opts.fetch(:parent, OPTS)).fetch(:name, :parent)
@@ -200,7 +200,7 @@ module Sequel
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil)) do |obj|
             opk = prkey_conv[obj]
             if idm_obj = parent_map[opk]
-              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
               obj = idm_obj
             else
               obj.associations[parent] = nil
@@ -307,12 +307,12 @@ module Sequel
           ds = ds.select_append(ka) unless ds.opts[:select] == nil
           model.eager_load_results(r, eo.merge(:loader=>false, :initialize_rows=>false, :dataset=>ds, :id_map=>nil, :associations=>OPTS)) do |obj|
             if level
-              no_cache = no_cache_level == obj.values.delete(la)
+              no_cache = no_cache_level == obj.remove_key!(la)
             end
             
             opk = prkey_conv[obj]
             if idm_obj = parent_map[opk]
-              key_aliases.each{|ka_| idm_obj.values[ka_] = obj.values[ka_]}
+              key_aliases.each{|ka_| idm_obj[ka_] = obj[ka_]}
               obj = idm_obj
             else
               obj.associations[childrena] = [] unless no_cache

data/lib/sequel/plugins/serialization.rb

@@ -30,6 +30,15 @@ module Sequel
     # Otherwise, it is possible that the default column accessors will take
     # precedence.
     #
+    # Note that use of an unsafe serialization method can result in an attack vector
+    # (potentially allowing remote code execution) if an attacker has the ability to
+    # store data directly in the underlying column. This would affect the marshal
+    # serialization format, and on older versions of Ruby, potentially the yaml and
+    # json serialization formats as well. It can also affect custom formats. You
+    # should ensure that attackers do not have access to store data directly in the
+    # underlying column when using this plugin (especially when using an unsafe
+    # serialization method).
+    #
     # == Example
     #
     #   # Require json if you plan to use it, as the plugin doesn't require it for you.
@@ -37,7 +46,8 @@ module Sequel
     #
     #   # Register custom serializer/deserializer pair, if desired
     #   require 'sequel/plugins/serialization'
-    #   Sequel::Plugins::Serialization.register_format(:reverse, :reverse.to_proc, :reverse.to_proc)
+    #   require 'base64'
+    #   Sequel::Plugins::Serialization.register_format(:base64, Base64.method(:encode64), Base64.method(:decode64))
     #
     #   class User < Sequel::Model
     #     # Built-in format support when loading the plugin
@@ -48,10 +58,10 @@ module Sequel
     #     serialize_attributes :marshal, :permissions
     #
     #     # Use custom registered serialization format just like built-in format
-    #     serialize_attributes :reverse, :password
+    #     serialize_attributes :base64, :password
     #
     #     # Use a custom serializer/deserializer pair without registering
-    #     serialize_attributes [:reverse.to_proc, :reverse.to_proc], :password
+    #     serialize_attributes [ Base64.method(:encode64), Base64.method(:decode64)], :password
     #   end
     #   user = User.create
     #   user.permissions = {global: 'read-only'}
@@ -96,13 +106,15 @@ module Sequel
       register_format(:marshal, lambda{|v| [Marshal.dump(v)].pack('m')},
         lambda do |v|
           # Handle unpacked marshalled data for backwards compat
-          v = v.unpack('m')[0] unless v[0..1] == "\x04\x08"
+          v = v.unpack('m')[0] unless v.start_with?("\x04\x08")
           Marshal.load(v)
         end)
       register_format(:yaml, :to_yaml.to_proc, lambda{|s| YAML.load(s)})
       register_format(:json, Sequel.method(:object_to_json), Sequel.method(:parse_json))
 
       module ClassMethods
+        Plugins.model_instance_variables(self, :@deserialized_values)
+
         # A hash with column name symbols and callable values, with the value
         # called to deserialize the column.
         attr_reader :deserialization_map
@@ -123,7 +135,12 @@ module Sequel
         end
         
         # Create instance level reader that deserializes column values on request,
-        # and instance level writer that stores new deserialized values.
+        # and instance level writer that stores new deserialized values. If +format+
+        # is a symbol, it should correspond to a previously-registered format using +register_format+.
+        # Otherwise, +format+ is expected to be a 2-element array of callables,
+        # with the first element being the serializer, used to convert the value used by the application
+        # to the value that will be stored in the database, and the second element being the deserializer,
+        # used to convert the value stored the database to the value used by the application.
         def serialize_attributes(format, *columns)
           if format.is_a?(Symbol)
             unless format = Sequel.synchronize{REGISTERED_FORMATS[format]}
@@ -140,7 +157,7 @@ module Sequel
         # Add serializated attribute acessor methods to the serialization_module
         def define_serialized_attribute_accessor(serializer, deserializer, *columns)
           m = self
-          include(@serialization_module ||= Module.new) unless @serialization_module
+          include(@serialization_module ||= Sequel.set_temp_name(Module.new){"#{name}::@serialization_module"}) unless @serialization_module
           @serialization_module.class_eval do
             columns.each do |column|
               m.serialization_map[column] = serializer

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -30,6 +30,10 @@ module Sequel
       def self.apply(model)
         model.plugin :serialization
       end
+
+      module ClassMethods
+        Plugins.model_instance_variables(self, :@original_deserialized_values)
+      end
       
       module InstanceMethods
         # Clear the cache of original deserialized values after saving so that it doesn't

data/lib/sequel/plugins/single_statement_dataset_destroy.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The single_statement_dataset_destroy plugin makes the
+    # model dataset.destroy method delete all rows in a
+    # single DELETE statement. It runs all before_destroy
+    # hooks before the DELETE, and all after_destroy hooks
+    # after the delete.
+    #
+    # This is not compatible with around_destroy hooks,
+    # so if the model is using custom around_destroy hooks,
+    # dataset.destroy falls back to a separate DELETE statement
+    # per row.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses use a single DELETE
+    #   # statement for dataset.destroy
+    #   Sequel::Model.plugin :single_statement_dataset_destroy
+    #
+    #   # Make the Album class use a single DELETE
+    #   # statement for dataset.destroy
+    #   Album.plugin :single_statement_dataset_destroy
+    module SingleStatementDatasetDestroy
+      module DatasetMethods
+        # Destroy all rows in a single DELETE statement. Run the before_destroy
+        # hooks for all rows before the DELETE, and all after_destroy hooks
+        # for all rows after the DELETE. If the model uses an around_destroy
+        # hook, fallback to using a separate DELETE statement per row.
+        def destroy
+          return super unless model.instance_method(:around_destroy).owner == Sequel::Model::InstanceMethods
+
+          db.transaction do
+            rows = all
+            rows.each(&:before_destroy)
+            expected_rows = rows.length
+            n = delete
+            unless n == expected_rows
+              raise Error, "dataset changed during destroy, expected rows: #{expected_rows}, actual rows: #{n}"
+            end
+            rows.each(&:after_destroy)
+            n
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/split_values.rb

@@ -36,6 +36,8 @@ module Sequel
     #   Album.plugin :split_values
     module SplitValues
       module ClassMethods
+        Plugins.model_instance_variables(self, :@noncolumn_values)
+
         # Split the noncolumn values when creating a new object retrieved from
         # the database.
         def call(_)
@@ -54,6 +56,16 @@ module Sequel
           end
         end
 
+        # Remove the key from noncolumn values if it is present there. If it is not
+        # present there, then use the default behavior of removing it from values.
+        def remove_key!(key)
+          if @noncolumn_values && @noncolumn_values.key?(key)
+            @noncolumn_values.delete(key)
+          else
+            super
+          end
+        end
+
         # Check all entries in the values hash.  If any of the keys are not columns,
         # move the entry into the noncolumn_values hash.
         def split_noncolumn_values

data/lib/sequel/plugins/sql_comments.rb

@@ -40,7 +40,8 @@ module Sequel
     #   Album.sql_comments_dataset_methods :to_csv # csv_serializer plugin
     #
     # In order for the sql_comments plugin to work, the sql_comments
-    # Database extension must be loaded into the model's database.
+    # Database extension must be loaded into the model's database, so
+    # loading the plugin does this automatically.
     #
     # Note that in order to make sure SQL comments are included, some
     # optimizations are disabled if this plugin is loaded.
@@ -67,6 +68,10 @@ module Sequel
         # :nocov:
       end
 
+      def self.apply(model)
+        model.db.extension(:sql_comments)
+      end
+
       def self.configure(model)
         model.send(:reset_fast_pk_lookup_sql)
       end
@@ -85,7 +90,7 @@ module Sequel
         # Use automatic SQL comments for the given dataset methods.
         def sql_comments_dataset_methods(*meths)
           unless @_sql_comments_dataset_module
-            dataset_module(@_sql_comments_dataset_module = Module.new)
+            dataset_module(@_sql_comments_dataset_module = Sequel.set_temp_name(Module.new){"#{name}::@_sql_comments_dataset_module"})
           end
           _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
         end

data/lib/sequel/plugins/static_cache.rb

@@ -176,6 +176,19 @@ module Sequel
           h
         end
 
+        # Use the cache instead of a query to get the results.
+        def as_set(column)
+          set = Set.new
+
+          if column.is_a?(Array)
+            @all.each{|r| set.add(r.values.values_at(*column))}
+          else
+            @all.each{|r| set.add(r[column])}
+          end
+
+          set
+        end
+
         # Alias of as_hash for backwards compatibility.
         def to_hash(*a)
           as_hash(*a)