sequel 4.41.0 → 4.42.0

data/lib/sequel/extensions/pg_enum.rb

@@ -7,7 +7,7 @@
 #
 # It allows creation of enum types using create_enum:
 #
-#   DB.create_enum(:type_name, %w'value1 value2 value3')
+#   DB.create_enum(:enum_type_name, %w'value1 value2 value3')
 #
 # You can also add values to existing enums via add_enum_value:
 #
@@ -15,7 +15,7 @@
 #
 # If you want to drop an enum type, you can use drop_enum:
 #
-#   DB.drop_enum(:type_name)
+#   DB.drop_enum(:enum_type_name)
 #
 # Just like any user-created type, after creating the type, you
 # can create tables that have a column of that type:
@@ -44,7 +44,7 @@
 #
 #   Sequel.migration do
 #     change do
-#       create_enum(:type_name, %w'value1 value2 value3')
+#       create_enum(:enum_type_name, %w'value1 value2 value3')
 #     end
 #   end
 #

data/lib/sequel/extensions/query.rb

@@ -6,7 +6,7 @@
 #
 #   dataset = DB[:items].query do
 #     select :x, :y, :z
-#     filter{(x > 1) & (y > 2)}
+#     where{(x > 1) & (y > 2)}
 #     reverse :z
 #   end
 #
@@ -45,13 +45,13 @@ module Sequel
     #
     #   dataset = DB[:items].query do
     #     select :x, :y, :z
-    #     filter{(x > 1) & (y > 2)}
+    #     where{(x > 1) & (y > 2)}
     #     reverse :z
     #   end
     #
     # Which is the same as:
     #
-    #  dataset = DB[:items].select(:x, :y, :z).filter{(x > 1) & (y > 2)}.reverse(:z)
+    #  dataset = DB[:items].select(:x, :y, :z).where{(x > 1) & (y > 2)}.reverse(:z)
     def query(&block)
       query = Dataset::Query.new(self)
       query.instance_eval(&block)

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -27,12 +27,19 @@
 module Sequel
   module Sequel3DatasetMethods
     COMMA = Dataset::COMMA
-    # The database related to this dataset.  This is the Database instance that
-    # will execute all of this dataset's queries.
-    attr_writer :db
+    # Change the database for this dataset.
+    def db=(v)
+      raise_if_frozen!
+      @db = v
+      @cache = {}
+    end
 
-    # The hash of options for this dataset, keys are symbols.
-    attr_writer :opts
+    # Change the options for this dataset.
+    def opts=(v)
+      raise_if_frozen!
+      @opts = v
+      @cache = {}
+    end
 
     # Update all records matching the conditions with the values specified.
     # Returns the number of rows affected.
@@ -40,7 +47,7 @@ module Sequel
     #   DB[:table][:id=>1] = {:id=>2} # UPDATE table SET id = 2 WHERE id = 1
     #   # => 1 # number of rows affected
     def []=(conditions, values)
-      filter(conditions).update(values)
+      where(conditions).update(values)
     end
 
     # Inserts multiple values. If a block is given it is invoked for each
@@ -71,7 +78,7 @@ module Sequel
     # given table. If no columns are currently selected, select all
     # columns of the given table.
     #
-    #   DB[:items].filter(:id=>1).qualify_to(:i)
+    #   DB[:items].where(:id=>1).qualify_to(:i)
     #   # SELECT i.* FROM items WHERE (i.id = 1)
     def qualify_to(table)
       qualify(table)
@@ -83,7 +90,7 @@ module Sequel
     # has columns with the same name as columns in the current dataset.
     # See +qualify_to+.
     #
-    #   DB[:items].filter(:id=>1).qualify_to_first_source
+    #   DB[:items].where(:id=>1).qualify_to_first_source
     #   # SELECT items.* FROM items WHERE (items.id = 1)
     def qualify_to_first_source
       qualify

data/lib/sequel/model/associations.rb

@@ -68,9 +68,9 @@ module Sequel
 
         # Apply all non-instance specific changes to the given dataset and return it.
         def apply_dataset_changes(ds)
-          ds.extend(AssociationDatasetMethods)
-          ds.association_reflection = self
-          self[:extend].each{|m| ds.extend(m)}
+          ds = ds.with_extend(AssociationDatasetMethods).
+            clone(:association_reflection => self)
+          self[:extend].each{|m| ds = ds.with_extend(m)}
           ds = ds.select(*select) if select
           if c = self[:conditions]
             ds = (c.is_a?(Array) && !Sequel.condition_specifier?(c)) ? ds.where(*c) : ds.where(c)
@@ -263,6 +263,7 @@ module Sequel
 
             eager_limit =
               if el = ds.opts[:eager_limit]
+                raise Error, "The :eager_limit dataset option is not supported for associations returning a single record" unless returns_array?
                 strategy ||= true_eager_graph_limit_strategy
                 if el.is_a?(Array)
                   el
@@ -276,6 +277,7 @@ module Sequel
             strategy = true_eager_graph_limit_strategy if strategy == :union
             # Correlated subqueries are not supported for regular eager loading
             strategy = :ruby if strategy == :correlated_subquery
+            strategy = nil if strategy == :ruby && assign_singular?
             objects = apply_eager_limit_strategy(ds, strategy, eager_limit).all
           elsif strategy == :union
             objects = []
@@ -1358,11 +1360,17 @@ module Sequel
     
       # This module contains methods added to all association datasets
       module AssociationDatasetMethods
+        Dataset.def_deprecated_opts_setter(self, :model, :association_reflection)
+
         # The model object that created the association dataset
-        attr_accessor :model_object
+        def model_object
+          @opts[:model_object]
+        end
     
         # The association reflection related to the association dataset
-        attr_accessor :association_reflection
+        def association_reflection
+          @opts[:association_reflection]
+        end
       end
       
       # Each kind of association adds a number of instance methods to the model class which
@@ -1501,6 +1509,10 @@ module Sequel
         #           the given association.  Can be used to DRY up a bunch of similar associations that
         #           all share the same options such as :class and :key, while changing the order and block used.
         # :conditions :: The conditions to use to filter the association, can be any argument passed to where.
+        #                This option is not respected when using eager_graph or association_join, unless it
+        #                is hash or array of two element arrays.  Consider also specifying the :graph_block
+        #                option if the value for this option is not a hash or array of two element arrays
+        #                and you plan to use this association in eager_graph or association_join.
         # :dataset :: A proc that is instance_execed to get the base dataset to use (before the other
         #             options are applied).  If the proc accepts an argument, it is passed the related
         #             association reflection.
@@ -2118,7 +2130,7 @@ module Sequel
           unless ds.kind_of?(AssociationDatasetMethods)
             ds = opts.apply_dataset_changes(ds)
           end
-          ds.model_object = self
+          ds = ds.clone(:model_object => self)
           ds = ds.eager_graph(opts[:eager_graph]) if opts[:eager_graph] && opts.eager_graph_lazy_dataset?
           ds = instance_exec(ds, &opts[:block]) if opts[:block]
           ds
@@ -2697,7 +2709,7 @@ END
         def ungraphed
           ds = super.clone(:eager_graph=>nil)
           if (eg = @opts[:eager_graph]) && (rp = eg[:row_proc])
-            ds.row_proc = rp
+            ds = ds.with_row_proc(rp)
           end
           ds
         end
@@ -2737,9 +2749,14 @@ END
           end
           local_opts = ds.opts[:eager_graph][:local]
           limit_strategy = r.eager_graph_limit_strategy(local_opts[:limit_strategy])
+
+          if r[:conditions] && !Sequel.condition_specifier?(r[:conditions]) && !r[:orig_opts].has_key?(:graph_conditions) && !r[:orig_opts].has_key?(:graph_only_conditions) && !r.has_key?(:graph_block)
+            Sequel::Deprecation.deprecate("Ignoring :conditions for #{r[:model]} #{r[:name]} association during eager_graph/association_join, consider specifying :graph_block") unless r[:ignore_conditions_warning]
+          end
+
           ds = loader.call(:self=>ds, :table_alias=>assoc_table_alias, :implicit_qualifier=>(ta == ds.opts[:eager_graph][:master]) ? first_source : qualifier_from_alias_symbol(ta, first_source), :callback=>callback, :join_type=>local_opts[:join_type], :join_only=>local_opts[:join_only], :limit_strategy=>limit_strategy, :from_self_alias=>ds.opts[:eager_graph][:master])
           if r[:order_eager_graph] && (order = r.fetch(:graph_order, r[:order]))
-            ds = ds.order_more(*qualified_expression(order, assoc_table_alias))
+            ds = ds.order_append(*qualified_expression(order, assoc_table_alias))
           end
           eager_graph = ds.opts[:eager_graph]
           eager_graph[:requirements][assoc_table_alias] = requirements.dup

data/lib/sequel/model/base.rb

@@ -286,25 +286,42 @@ module Sequel
       # Returns the module given or the anonymous module created.
       #
       #   # Usage with existing module
-      #   Artist.dataset_module Sequel::ColumnsIntrospection
+      #   Album.dataset_module Sequel::ColumnsIntrospection
       #
       #   # Usage with anonymous module
-      #   Artist.dataset_module do
+      #   Album.dataset_module do
       #     def foo
       #       :bar
       #     end
       #   end
-      #   Artist.dataset.foo
+      #   Album.dataset.foo
       #   # => :bar
-      #   Artist.foo
+      #   Album.foo
       #   # => :bar
       #
       # Any anonymous modules created are actually instances of Sequel::Model::DatasetModule
-      # (a Module subclass), which allows you to call the subset method on them:
-      #
-      #   Artist.dataset_module do
-      #     subset :released, Sequel.identifier(release_date) > Sequel::CURRENT_DATE
+      # (a Module subclass), which allows you to call the subset method on them, which
+      # defines a dataset method that adds a filter.  There are also a number of other
+      # methods with the same names as the dataset methods, which can use to define
+      # named dataset methods:
+      #
+      #   Album.dataset_module do
+      #     subset :released, Sequel.identifier(release_date) <= Sequel::CURRENT_DATE
+      #     order :by_release_date, :release_date
+      #     select :for_select_options, :id, :name, :release_date
       #   end
+      #   Album.released.sql
+      #   # => "SELECT * FROM artists WHERE (release_date <= CURRENT_DATE)"
+      #   Album.by_release_date.sql
+      #   # => "SELECT * FROM artists ORDER BY release_date"
+      #   Album.for_select_options.sql
+      #   # => "SELECT id, name, release_date FROM artists"
+      #   Album.released.by_release_date.for_select_options.sql
+      #   # => "SELECT id, name, release_date FROM artists WHERE (release_date <= CURRENT_DATE) ORDER BY release_date"
+      #
+      # The following methods are supported: distinct, exclude, exclude_having, grep, group, group_and_count,
+      # group_append, having, limit, offset, order, order_append, order_prepend, select, select_all,
+      # select_append, select_group, where, and server.
       #
       # Any public methods in the dataset module will have class methods created that
       # call the method on the dataset, assuming that the class method is not already
@@ -388,14 +405,15 @@ module Sequel
       # If a block is not given, just define a class method on the model for each argument
       # that calls the dataset method of the same argument name.
       #
-      # It is recommended that you define methods inside a block passed to #dataset_module
-      # instead of using this method, as #dataset_module allows you to use normal
-      # ruby def syntax.
+      # Using dataset_module is recommended over using this method.  In addition to allowing
+      # more natural ruby syntax for defining methods manually, it also offers numerous
+      # helper methods that make defining common dataset methods more easily, as well as
+      # supporting dataset caching (assuming the arguments allow it).
       #
       #   # Add new dataset method and class method that calls it
       #   Artist.def_dataset_method(:by_name){order(:name)}
-      #   Artist.filter(:name.like('A%')).by_name
-      #   Artist.by_name.filter(:name.like('A%'))
+      #   Artist.where(:name.like('A%')).by_name
+      #   Artist.by_name.where(:name.like('A%'))
       #
       #   # Just add a class method that calls an existing dataset method
       #   Artist.def_dataset_method(:server!)
@@ -424,7 +442,7 @@ module Sequel
           # Use optimized finder
           first_where(args.first)
         else
-          filter(*args, &block).first
+          where(*args, &block).first
         end
       end
       
@@ -707,7 +725,7 @@ module Sequel
       # plan to join other tables to this table and you want the column references
       # to be qualified.
       #
-      #   Artist.filter(Artist.qualified_primary_key_hash(1))
+      #   Artist.where(Artist.qualified_primary_key_hash(1))
       #   # SELECT * FROM artists WHERE (artists.id = 1)
       def qualified_primary_key_hash(value, qualifier=table_name)
         case key = @primary_key
@@ -802,11 +820,10 @@ module Sequel
           @columns = superclass.instance_variable_get(:@columns)
           @db_schema = superclass.instance_variable_get(:@db_schema)
         else
-          @dataset_method_modules.each{|m| @dataset.extend(m)} if @dataset_method_modules
+          @dataset = @dataset.with_extend(*@dataset_method_modules.reverse) if @dataset_method_modules
           @db_schema = get_db_schema
         end
 
-        @dataset.model = self if @dataset.respond_to?(:model=)
         reset_instance_dataset
         self
       end
@@ -868,7 +885,14 @@ module Sequel
       # dataset methods that accept arguments, you should use define a
       # method directly inside a #dataset_module block.
       def subset(name, *args, &block)
-        def_dataset_method(name){filter(*args, &block)}
+        if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
+          def_dataset_method(name){filter(*args, &block)}
+        else
+          key = :"_subset_#{name}_ds"
+          def_dataset_method(name) do
+            cached_dataset(key){filter(*args)}
+          end
+        end
       end
       
       # Returns name of primary table for the dataset. If the table for the dataset
@@ -933,15 +957,15 @@ module Sequel
         else
           raise(Error, "Model.set_dataset takes one of the following classes as an argument: Symbol, LiteralString, SQL::Identifier, SQL::QualifiedIdentifier, SQL::AliasedExpression, Dataset")
         end
-        set_dataset_row_proc(ds)
-        ds
+
+        set_dataset_row_proc(ds.clone(:model=>self))
       end
 
       # Add the module to the class's dataset_method_modules.  Extend the dataset with the
       # module if the model has a dataset.  Add dataset methods to the class for all
       # public dataset methods.
       def dataset_extend(mod, opts=OPTS)
-        @dataset.extend(mod) if @dataset
+        @dataset = @dataset.with_extend(mod) if @dataset
         reset_instance_dataset
         dataset_method_modules << mod
         unless opts[:create_class_methods] == false
@@ -1204,7 +1228,7 @@ module Sequel
 
       # Set the dataset's row_proc to the current model.
       def set_dataset_row_proc(ds)
-        ds.row_proc = self
+        ds.with_row_proc(self)
       end
 
       # Reset the fast primary key lookup SQL when the simple_pk value changes.
@@ -1791,7 +1815,7 @@ module Sequel
       # Set the shard that this object is tied to.  Returns self.
       def set_server(s)
         @server = s
-        @this.opts[:server] = s if @this
+        @this = @this.server(s) if @this
         self
       end
 
@@ -2368,10 +2392,14 @@ module Sequel
     # Dataset methods are methods that the model class extends its dataset with in
     # the call to set_dataset.
     module DatasetMethods
+      Dataset.def_deprecated_opts_setter(self, :model)
+
       # The model class associated with this dataset
       #
       #   Artist.dataset.model # => Artist
-      attr_accessor :model
+      def model
+        @opts[:model]
+      end
 
       # Assume if a single integer is given that it is a lookup by primary
       # key, and call with_pk with the argument.
@@ -2449,8 +2477,8 @@ module Sequel
       #   Album.last
       #   # SELECT * FROM albums ORDER BY id DESC LIMIT 1
       def last(*a, &block)
-        if opts[:order].nil? && model && (pk = model.primary_key)
-          order(*pk).last(*a, &block)
+        if ds = _primary_key_order
+          ds.last(*a, &block)
         else
           super
         end
@@ -2465,8 +2493,8 @@ module Sequel
       #   # SELECT * FROM albums ORDER BY id LIMIT 1000 OFFSET 2000
       #   # ...
       def paged_each(*a, &block)
-        if opts[:order].nil? && model && (pk = model.primary_key)
-          order(*pk).paged_each(*a, &block)
+        if ds = _primary_key_order
+          ds.paged_each(*a, &block)
         else
           super
         end
@@ -2500,7 +2528,11 @@ module Sequel
       #   Artist.dataset.with_pk([1, 2])
       #   # SELECT * FROM artists WHERE ((artists.id1 = 1) AND (artists.id2 = 2)) LIMIT 1
       def with_pk(pk)
-        first(model.qualified_primary_key_hash(pk))
+        if loader = _with_pk_loader
+          loader.first(*pk)
+        else
+          first(model.qualified_primary_key_hash(pk))
+        end
       end
 
       # Same as with_pk, but raises NoMatchingRow instead of returning nil if no
@@ -2508,6 +2540,33 @@ module Sequel
       def with_pk!(pk)
         with_pk(pk) || raise(NoMatchingRow.new(self))
       end
+
+      private
+
+      # If the dataset is not already ordered, and the model has a primary key,
+      # return a clone ordered by the primary key.
+      def _primary_key_order
+        if @opts[:order].nil? && model && (pk = model.primary_key)
+          cached_dataset(:_pk_order_ds){order(*pk)}
+        end
+      end
+
+      # A cached placeholder literalizer, if one exists for the current dataset.
+      def _with_pk_loader
+        cached_placeholder_literalizer(:_with_pk_loader) do |pl|
+          table = model.table_name
+          cond = case primary_key = model.primary_key
+          when Array
+            primary_key.map{|key| [SQL::QualifiedIdentifier.new(table, key), pl.arg]}
+          when Symbol
+            {SQL::QualifiedIdentifier.new(table, primary_key)=>pl.arg}
+          else
+            raise(Error, "#{model} does not have a primary key")
+          end
+
+          where(cond).limit(1)
+        end
+      end
     end
 
     extend ClassMethods

data/lib/sequel/model/dataset_module.rb

@@ -20,6 +20,43 @@ module Sequel
         @model.subset(name, *args, &block)
       end
 
+      # Alias for subset
+      def where(name, *args, &block)
+        subset(name, *args, &block)
+      end
+
+      %w'exclude exclude_having having'.map(&:to_sym).each do |meth|
+        define_method(meth) do |name, *args, &block|
+          if block || args.flatten.any?{|arg| arg.is_a?(Proc)}
+            @model.def_dataset_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            @model.def_dataset_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
+      meths = (<<-METHS).split.map(&:to_sym)
+        distinct grep group group_and_count group_append 
+        limit offset order order_append order_prepend 
+        select select_all select_append select_group server
+      METHS
+
+      meths.each do |meth|
+        define_method(meth) do |name, *args, &block|
+          if block
+            @model.def_dataset_method(name){send(meth, *args, &block)}
+          else
+            key = :"_#{meth}_#{name}_ds"
+            @model.def_dataset_method(name) do
+              cached_dataset(key){send(meth, *args)}
+            end
+          end
+        end
+      end
+
       private
 
       # Add a class method to the related model that