sequel 5.8.0 → 5.38.0

data/lib/sequel/plugins/sharding.rb

@@ -21,7 +21,7 @@ module Sequel
     module Sharding
       module ClassMethods
         # Create a new object on the given shard s.
-        def create_using_server(s, values={}, &block)
+        def create_using_server(s, values=OPTS, &block)
           new_using_server(s, values, &block).save
         end
 
@@ -45,7 +45,7 @@ module Sequel
         # Return a newly instantiated object that is tied to the given
         # shard s.  When the object is saved, a record will be inserted
         # on shard s.
-        def new_using_server(s, values={}, &block)
+        def new_using_server(s, values=OPTS, &block)
           new(values, &block).set_server(s)
         end
 
@@ -107,12 +107,18 @@ module Sequel
         # previous row_proc, but calls set_server on the output of that row_proc,
         # ensuring that objects retrieved by a specific shard know which shard they
         # are tied to.
-        def server(s)
-          ds = super
-          if rp = row_proc
-            ds = ds.with_row_proc(proc{|r| rp.call(r).set_server(s)})
+        def row_proc
+          rp = super
+          if rp
+            case server = db.pool.send(:pick_server, opts[:server])
+            when nil, :default, :read_only
+              # nothing
+            else
+              old_rp = rp
+              rp = proc{|r| old_rp.call(r).set_server(server)}
+            end
           end
-          ds
+          rp 
         end
       end
     end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -163,21 +163,6 @@ module Sequel
           super
         end
 
-        # Copy the necessary attributes to the subclasses, and filter the
-        # subclass's dataset based on the sti_kep_map entry for the class.
-        def inherited(subclass)
-          super
-          key = Array(sti_key_map[subclass]).dup
-          sti_subclass_added(key)
-          rp = dataset.row_proc
-          subclass.set_dataset(sti_subclass_dataset(key), :inherited=>true)
-          subclass.instance_exec do
-            @dataset = @dataset.with_row_proc(rp)
-            @sti_key_array = key
-            self.simple_table = nil
-          end
-        end
-
         # Return an instance of the class specified by sti_key,
         # used by the row_proc.
         def sti_load(r)
@@ -208,6 +193,21 @@ module Sequel
           super
         end
 
+        # Copy the necessary attributes to the subclasses, and filter the
+        # subclass's dataset based on the sti_kep_map entry for the class.
+        def inherited(subclass)
+          super
+          key = Array(sti_key_map[subclass]).dup
+          sti_subclass_added(key)
+          rp = dataset.row_proc
+          subclass.set_dataset(sti_subclass_dataset(key), :inherited=>true)
+          subclass.instance_exec do
+            @dataset = @dataset.with_row_proc(rp)
+            @sti_key_array = key
+            self.simple_table = nil
+          end
+        end
+
         # If calling set_dataset manually, make sure to set the dataset
         # row proc to one that handles inheritance correctly.
         def set_dataset_row_proc(ds)
@@ -250,6 +250,11 @@ module Sequel
           end
           super
         end
+
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
       end
     end
   end

data/lib/sequel/plugins/skip_saving_columns.rb

@@ -0,0 +1,108 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The skip_saving_columms plugin allows skipping specific columns when
+    # saving.  By default, it skips columns that the database schema
+    # indicates are generated columns:
+    #
+    #   # Assume id column, name column, and id2 generated column
+    #   album = Album[1]
+    #   album.id # => 1
+    #   album.name # => 'X'
+    #   album.id2 # => 2
+    #   album.save
+    #   # UPDATE album SET name = 'X' WHERE (id = 1)
+    #
+    # You can override which columns will be skipped:
+    #
+    #   Album.skip_saving_columns = [:name]
+    #   album.save
+    #   # UPDATE album SET id2 = 2 WHERE (id = 1)
+    #
+    # The skipping happens for all usage of Model#save and callers of it (e.g.
+    # Model.create, Model.update).  When using the plugin, the only way to get
+    # it to save a column marked for skipping is to explicitly specify it:
+    #
+    #   album.save(columns: [:name, :id2])
+    #   album.save
+    #   # UPDATE album SET name = 'X', id2 = 2 WHERE (id = 1)
+    #
+    # Usage:
+    #
+    #   # Support skipping saving columns in all Sequel::Model subclasses
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :skip_saving_columns
+    #
+    #   # Support skipping saving columns in the Album class
+    #   Album.plugin :skip_saving_columns
+    module SkipSavingColumns
+      # Setup skipping of the generated columns for a model with an existing dataset.
+      def self.configure(mod)
+        mod.instance_exec do
+          set_skip_saving_generated_columns if @dataset
+        end
+      end
+
+      module ClassMethods
+        # An array of column symbols for columns to skip when saving.
+        attr_reader :skip_saving_columns
+
+        # Over the default array of columns to skip.  Once overridden, future
+        # changes to the class's dataset and future subclasses will automatically
+        # use these overridden columns, instead of introspecting the database schema.
+        def skip_saving_columns=(v) 
+          @_skip_saving_columns_no_override = true
+          @skip_saving_columns = v.dup.freeze
+        end
+
+        Plugins.after_set_dataset(self, :set_skip_saving_generated_columns)
+        Plugins.inherited_instance_variables(self, :@skip_saving_columns=>:dup, :@_skip_saving_columns_no_override=>nil)
+
+        private
+
+        # If the skip saving columns has not been overridden, check the database
+        # schema and automatically skip any generated columns.
+        def set_skip_saving_generated_columns
+          return if @_skip_saving_columns_no_override
+          s = []
+          db_schema.each do |k, v|
+            s << k if v[:generated] 
+          end
+          @skip_saving_columns = s.freeze
+          nil
+        end
+      end
+
+      module InstanceMethods
+        private
+
+        # Skip the columns the model has marked to skip when inserting.
+        def _insert_values
+          _save_removed_skipped_columns(Hash[super])
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # all columns.
+        def _save_update_all_columns_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Skip the columns the model has marked to skip when updating
+        # only changed columns.
+        def _save_update_changed_colums_hash
+          _save_removed_skipped_columns(super)
+        end
+
+        # Remove any columns the model has marked to skip when saving.
+        def _save_removed_skipped_columns(hash)
+          model.skip_saving_columns.each do |column|
+            hash.delete(column)
+          end
+
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/static_cache.rb

@@ -24,6 +24,7 @@ module Sequel
     # * Primary key lookups (e.g. Model[1])
     # * Model.all
     # * Model.each
+    # * Model.first (without block, only supporting no arguments or single integer argument)
     # * Model.count (without an argument or block)
     # * Model.map
     # * Model.as_hash
@@ -54,6 +55,7 @@ module Sequel
     # Now if you +#dup+ a Model object (the resulting object is not frozen), you
     # will be able to update and save the duplicate.
     # Note the caveats around your responsibility to update the cache still applies.
+    # You can update the cache via `.load_cache` method.
     module StaticCache
       # Populate the static caches when loading the plugin. Options:
       # :frozen :: Whether retrieved model objects are frozen.  The default is true,
@@ -70,13 +72,25 @@ module Sequel
         # A frozen ruby hash holding all of the model's frozen instances, keyed by frozen primary key.
         attr_reader :cache
 
-        # An array of all of the model's frozen instances, without issuing a database
-        # query.
-        def all
-          if @static_cache_frozen
-            @all.dup
+        # An array of all of the model's instances, without issuing a database
+        # query. If a block is given, yields each instance to the block.
+        def all(&block)
+          array = @static_cache_frozen ? @all.dup : to_a
+          array.each(&block) if block
+          array
+        end
+
+        # If a block is given, multiple arguments are given, or a single
+        # non-Integer argument is given, performs the default behavior of
+        # issuing a database query.  Otherwise, uses the cached values
+        # to return either the first cached instance (no arguments) or an
+        # array containing the number of instances specified (single integer
+        # argument).
+        def first(*args)
+          if block_given? || args.length > 1 || (args.length == 1 && !args[0].is_a?(Integer))
+            super
           else
-            map{|o| o}
+            @all.first(*args)
           end
         end
 
@@ -194,27 +208,32 @@ module Sequel
           !@static_cache_frozen
         end
 
-        private
-
-        # Return the frozen object with the given pk, or nil if no such object exists
-        # in the cache, without issuing a database query.
-        def primary_key_lookup(pk)
-          static_cache_object(cache[pk])
-        end
-
         # Reload the cache for this model by retrieving all of the instances in the dataset
         # freezing them, and populating the cached array and hash.
         def load_cache
-          a = dataset.all
+          @all = load_static_cache_rows
           h = {}
-          a.each do |o|
+          @all.each do |o|
             o.errors.freeze
             h[o.pk.freeze] = o.freeze
           end
-          @all = a.freeze
           @cache = h.freeze
         end
 
+        private
+
+        # Load the static cache rows from the database.
+        def load_static_cache_rows
+          ret = super if defined?(super)
+          ret || dataset.all.freeze
+        end
+
+        # Return the frozen object with the given pk, or nil if no such object exists
+        # in the cache, without issuing a database query.
+        def primary_key_lookup(pk)
+          static_cache_object(cache[pk])
+        end
+
         # If frozen: false is not used, just return the argument. Otherwise,
         # create a new instance with the arguments values if the argument is
         # not nil.

data/lib/sequel/plugins/static_cache_cache.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The static_cache_cache plugin allows for caching the row content for subclasses
+    # that use the static cache plugin (or just the current class).  Using this plugin
+    # can avoid the need to query the database every time loading the plugin into a
+    # model, which can save time when you have a lot of models using the static_cache
+    # plugin.
+    #
+    # Usage:
+    #
+    #   # Make all model subclasses that use the static_cache plugin use
+    #   # the cached values in the given file
+    #   Sequel::Model.plugin :static_cache_cache, "static_cache.cache"
+    #
+    #   # Make the AlbumType model the cached values in the given file,
+    #   # should be loaded before the static_cache plugin
+    #   AlbumType.plugin :static_cache_cache, "static_cache.cache"
+    module StaticCacheCache
+      def self.configure(model, file)
+        model.instance_variable_set(:@static_cache_cache_file, file)
+        model.instance_variable_set(:@static_cache_cache, File.exist?(file) ? Marshal.load(File.read(file)) : {})
+      end
+
+      module ClassMethods
+        # Dump the in-memory cached rows to the cache file.
+        def dump_static_cache_cache
+          File.open(@static_cache_cache_file, 'wb'){|f| f.write(Marshal.dump(@static_cache_cache))}
+          nil
+        end
+
+        Plugins.inherited_instance_variables(self, :@static_cache_cache_file=>nil, :@static_cache_cache=>nil)
+
+        private
+
+        # Load the rows for the model from the cache if available.
+        # If not available, load the rows from the database, and
+        # then update the cache with the raw rows.
+        def load_static_cache_rows
+          if rows = Sequel.synchronize{@static_cache_cache[name]}
+            rows.map{|row| call(row)}.freeze
+          else
+            rows = dataset.all.freeze
+            raw_rows = rows.map(&:values)
+            Sequel.synchronize{@static_cache_cache[name] = raw_rows}
+            rows
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/string_stripper.rb

@@ -28,7 +28,7 @@ module Sequel
         model.plugin(:input_transformer, :string_stripper){|v| (v.is_a?(String) && !v.is_a?(SQL::Blob)) ? v.strip : v}
       end
       def self.configure(model)
-        model.instance_exec{set_skipped_string_stripping_columns if @dataset}
+        model.send(:set_skipped_string_stripping_columns)
       end
 
       module ClassMethods

data/lib/sequel/plugins/subclasses.rb

@@ -63,6 +63,8 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@subclasses=>lambda{|v| []}, :@on_subclass=>nil)
 
+        private
+
         # Add the subclass to this model's current subclasses,
         # and initialize a new subclasses instance variable
         # in the subclass.

data/lib/sequel/plugins/subset_conditions.rb

@@ -26,8 +26,8 @@ module Sequel
     #   Album.where(Album.published_conditions | {ready: true}).sql
     #   # SELECT * FROM albums WHERE ((published IS TRUE) OR (ready IS TRUE))
     module SubsetConditions
-      def self.apply(mod, &block)
-        mod.instance_exec do
+      def self.apply(model, &block)
+        model.instance_exec do
           @dataset_module_class = Class.new(@dataset_module_class) do
             include DatasetModuleMethods
           end

data/lib/sequel/plugins/tactical_eager_loading.rb

@@ -60,6 +60,55 @@ module Sequel
     #   # SELECT * FROM artists WHERE name > 'N' AND id IN (...)
     #   albums.first.artists(eager: lambda{|ds| ds.where(Sequel[:name] > 'N')})
     #
+    # Note that the :eager option only takes effect if the association
+    # has not already been loaded for the model.
+    #
+    # The tactical_eager_loading plugin also allows transparent eager
+    # loading when calling association methods on associated objects
+    # eagerly loaded via Dataset#eager_graph.  This can reduce N queries
+    # to a single query when iterating over all associated objects.
+    # Consider the following code:
+    #
+    #   artists = Artist.eager_graph(:albums).all
+    #   artists.each do |artist|
+    #     artist.albums.each do |album|
+    #       album.tracks
+    #     end
+    #   end
+    #
+    # By default this will issue a single query to load the artists and
+    # albums, and then one query for each album to load the tracks for
+    # the album:
+    #
+    #   # SELECT artists.id, ...
+    #            albums.id, ...
+    #   # FROM artists
+    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
+    #   # SELECT * FROM tracks WHERE album_id = 1;
+    #   # SELECT * FROM tracks WHERE album_id = 2;
+    #   # SELECT * FROM tracks WHERE album_id = 10;
+    #   # ...
+    #
+    # With the tactical_eager_loading plugin, this uses the same
+    # query to load the artists and albums, but then issues a single query
+    # to load the tracks for all albums.
+    #
+    #   # SELECT artists.id, ...
+    #            albums.id, ...
+    #   # FROM artists
+    #   # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
+    #   # SELECT * FROM tracks WHERE (tracks.album_id IN (1, 2, 10, ...));
+    #
+    # Note that transparent eager loading for associated objects
+    # loaded by eager_graph will only take place if the associated classes
+    # also use the tactical_eager_loading plugin.
+    #
+    # When using this plugin, calling association methods on separate
+    # instances of the same result set is not thread-safe, because this
+    # plugin attempts to modify all instances of the same result set
+    # to eagerly set the associated objects, and having separate threads
+    # modify the same model instance is not thread-safe.
+    #
     # Usage:
     #
     #   # Make all model subclass instances use tactical eager loading (called before loading subclasses)
@@ -96,7 +145,7 @@ module Sequel
           name = opts[:name]
           if (!associations.include?(name) || dynamic_opts[:eager_reload]) && opts[:allow_eager] != false && retrieved_by && !frozen? && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             begin
-              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || {})
+              retrieved_by.send(:eager_load, retrieved_with.reject(&:frozen?), name=>dynamic_opts[:eager] || OPTS)
             rescue Sequel::UndefinedAssociation
               # This can happen if class table inheritance is used and the association
               # is only defined in a subclass.  This particular instance can use the
@@ -112,7 +161,29 @@ module Sequel
       module DatasetMethods
         private
 
-        # Set the retrieved_with and retrieved_by attributes for the object
+        # Set the retrieved_with and retrieved_by attributes for each of the associated objects
+        # created by the eager graph loader with the appropriate class dataset and array of objects.
+        def _eager_graph_build_associations(_, egl)
+          objects = super
+
+          master = egl.master
+          egl.records_map.each do |k, v|
+            next if k == master || v.empty?
+
+            by = opts[:graph][:table_aliases][k]
+            values = v.values
+
+            values.each do |o|
+              next unless o.is_a?(TacticalEagerLoading::InstanceMethods) && !o.retrieved_by
+              o.retrieved_by = by
+              o.retrieved_with = values
+            end
+          end
+
+          objects
+        end
+
+        # Set the retrieved_with and retrieved_by attributes for each object
         # with the current dataset and array of all objects.
         def post_load(objects)
           super