sequel 4.36.0 → 5.61.0

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -39,11 +39,11 @@ module Sequel
     #   # Using integers to store the class type, with a :model_map hash
     #   # and an sti_key of :type
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{1=>:Staff, 2=>:Manager}
+    #     model_map: {1=>:Staff, 2=>:Manager}
     #
     #   # Using non-class name strings
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager}
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager}
     #
     #   # By default the plugin sets the respective column value
     #   # when a new instance is created.
@@ -53,22 +53,22 @@ module Sequel
     #   # You can customize this behavior with the :key_chooser option.
     #   # This is most useful when using a non-bijective mapping.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'line staff'=>:Staff, 'supervisor'=>:Manager},
-    #     :key_chooser=>proc{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger' }
+    #     model_map: {'line staff'=>:Staff, 'supervisor'=>:Manager},
+    #     key_chooser: lambda{|instance| instance.model.sti_key_map[instance.model.to_s].first || 'stranger'}
     #
     #   # Using custom procs, with :model_map taking column values
     #   # and yielding either a class, string, symbol, or nil, 
     #   # and :key_map taking a class object and returning the column
     #   # value to use
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>proc(&:reverse),
-    #     :key_map=>proc{|klass| klass.name.reverse}
+    #     model_map: :reverse.to_proc,
+    #     key_map: lambda{|klass| klass.name.reverse}
     #
     #   # You can use the same class for multiple values.
     #   # This is mainly useful when the sti_key column contains multiple values
     #   # which are different but do not require different code.
     #   Employee.plugin :single_table_inheritance, :type,
-    #     :model_map=>{'staff' => "Staff",
+    #     model_map: {'staff' => "Staff",
     #                  'manager' => "Manager",
     #                  'overpayed staff' => "Staff",
     #                  'underpayed staff' => "Staff"}
@@ -80,7 +80,7 @@ module Sequel
     module SingleTableInheritance
       # Setup the necessary STI variables, see the module RDoc for SingleTableInheritance
       def self.configure(model, key, opts=OPTS)
-        model.instance_eval do
+        model.instance_exec do
           @sti_key_array = nil
           @sti_key = key 
           @sti_dataset = dataset
@@ -95,7 +95,7 @@ module Sequel
                 end
               end
               km.each do |k,v|
-                h[k.to_s] = [ ] unless h.key?(k.to_s)
+                h[k.to_s] = [] unless h.key?(k.to_s)
                 h[k.to_s].push( *Array(v) )
               end
               h
@@ -111,7 +111,7 @@ module Sequel
               end
             end
             sti_model_map.each do |k,v|
-              h[v.to_s] = [ ] unless h.key?(v.to_s)
+              h[v.to_s] = [] unless h.key?(v.to_s)
               h[v.to_s] << k
             end
             h
@@ -119,7 +119,8 @@ module Sequel
             lambda{|klass| klass.name.to_s}
           end
           @sti_key_chooser = opts[:key_chooser] || lambda{|inst| Array(inst.model.sti_key_map[inst.model]).last }
-          dataset.row_proc = lambda{|r| model.sti_load(r)}
+
+          @dataset = @dataset.with_row_proc(model.method(:sti_load))
         end
       end
 
@@ -151,25 +152,26 @@ module Sequel
 
         Plugins.inherited_instance_variables(self, :@sti_dataset=>nil, :@sti_key=>nil, :@sti_key_map=>nil, :@sti_model_map=>nil, :@sti_key_chooser=>nil)
 
-        # 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)
+        # Freeze STI information when freezing model class.  Note that
+        # because of how STI works, you should not freeze an STI subclass
+        # until after all subclasses of it have been created.
+        def freeze
+          @sti_key_array.freeze if @sti_key_array
+          @sti_key_map.freeze if @sti_key_map.is_a?(Hash)
+          @sti_model_map.freeze if @sti_model_map.is_a?(Hash)
+
           super
-          key = Array(sti_key_map[subclass]).dup
-          sti_subclass_added(key)
-          rp = dataset.row_proc
-          subclass.set_dataset(sti_dataset.filter(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>key), :inherited=>true)
-          subclass.instance_eval do
-            dataset.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)
-          sti_class(sti_model_map[r[sti_key]]).call(r)
+          sti_class_from_sti_key(r[sti_key]).call(r)
+        end
+
+        # Return the sti class based on one of the keys from sti_model_map.
+        def sti_class_from_sti_key(key)
+          sti_class(sti_model_map[key])
         end
 
         # Make sure that all subclasses of the parent class correctly include 
@@ -184,10 +186,36 @@ module Sequel
 
         private
 
+        # Extend the sti dataset with the module when extending the main
+        # dataset.
+        def dataset_extend(mod, opts=OPTS)
+          @sti_dataset = @sti_dataset.with_extend(mod)
+          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)
-          ds.row_proc = @dataset.row_proc if @dataset
+          if @dataset
+            ds.with_row_proc(@dataset.row_proc)
+          else
+            super
+          end
         end
 
         # Return a class object.  If a class is given, return it directly.
@@ -206,18 +234,29 @@ module Sequel
             raise(Error, "Invalid class type used: #{v.inspect}")
           end
         end
+
+        # Use the given dataset for the subclass, with key being the allowed
+        # values for the sti_kind field.
+        def sti_subclass_dataset(key)
+          sti_dataset.where(SQL::QualifiedIdentifier.new(sti_dataset.first_source_alias, sti_key)=>Sequel.delay{Sequel.synchronize{key}})
+        end
       end
 
       module InstanceMethods
-        private
-
         # Set the sti_key column based on the sti_key_map.
-        def _before_validation
+        def before_validation
           if new? && model.sti_key && !self[model.sti_key]
             set_column_value("#{model.sti_key}=", model.sti_key_chooser.call(self))
           end
           super
         end
+
+        private
+
+        # Don't allow use of prepared statements.
+        def use_prepared_statements_for?(type)
+          false
+        end
       end
     end
   end

data/lib/sequel/plugins/skip_create_refresh.rb

@@ -2,9 +2,9 @@
 
 module Sequel
   module Plugins
-    # SkipCreateRefresh is a simple plugin that make Sequel not
+    # The skip_create_refresh plugin skips the
     # refresh after saving a new model object.  Sequel does the
-    # refresh to make sure all columns are populated, which is
+    # refresh by default to make sure all columns are populated, which is
     # necessary so that database defaults work correctly.
     #
     # This plugin is mostly for performance reasons where you
@@ -12,7 +12,7 @@ module Sequel
     # but it could also help cases where records are not
     # immediately available for selection after insertion.
     #
-    # Note that Sequel does not attempt to refresh records when
+    # Note that Sequel by default does not attempt to refresh records when
     # updating existing model objects, only when inserting new
     # model objects.
     # 

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

@@ -47,17 +47,22 @@ module Sequel
         # If there isn't an entry in the values hash, but there is a noncolumn_values
         # hash, look in that hash for the value.
         def [](k)
-          super || (@noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values)
+          if  (res = super).nil?
+            @noncolumn_values[k] if !@values.has_key?(k) && @noncolumn_values
+          else
+            res
+          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
-          @values.keys.each do |k|
-            unless columns.include?(k)
-              (@noncolumn_values ||= {})[k] = @values.delete(k)
-            end
-          end
+          cols = (@values.keys - columns)
+          return self if cols.empty?
+
+          nc = @noncolumn_values ||= {}
+          vals = @values
+          cols.each{|k| nc[k] = vals.delete(k)}
           self
         end
       end

data/lib/sequel/plugins/sql_comments.rb

@@ -0,0 +1,189 @@
+# frozen-string-literal: true
+
+module Sequel
+  module Plugins
+    # The sql_comments plugin will automatically use SQL comments on
+    # queries for the model it is loaded into.  These comments will
+    # show the related model, what type of method was called, and
+    # the method name (or association name for queries to load
+    # associations):
+    #
+    #   album = Album[1]
+    #   # SELECT * FROM albums WHERE (id = 1) LIMIT 1
+    #   # -- model:Album,method_type:class,method:[]
+    #
+    #   album.update(:name=>'A')
+    #   # UPDATE albums SET name = 'baz' WHERE (id = 1)
+    #   # -- model:Album,method_type:instance,method:update
+    #
+    #   album.artist
+    #   # SELECT * FROM artists WHERE (artists.id = 1)
+    #   # -- model:Album,method_type:association_load,association:artist
+    #
+    #   Album.eager(:artists).all
+    #   # SELECT * FROM albums
+    #   # SELECT * FROM artists WHERE (artists.id IN (1))
+    #   # -- model:Album,method_type:association_eager_load,association:artist
+    #   
+    #   Album.where(id: 1).delete
+    #   # DELETE FROM albums WHERE (id = 1)
+    #   # -- model:Album,method_type:dataset,method:delete
+    #
+    # This plugin automatically supports the class, instance, and dataset
+    # methods are are supported by default in Sequel::Model.  To support
+    # custom class, instance, and dataset methods, such as those added by
+    # other plugins, you can use the appropriate <tt>sql_comments_*_methods</tt>
+    # class method:
+    #
+    #   Album.sql_comments_class_methods :first_by_name # example from finder plugin, with :mod option
+    #   Album.sql_comments_instance_methods :lazy_attribute_lookup # lazy_attributes plugin
+    #   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.
+    #
+    # Note that in order to make sure SQL comments are included, some
+    # optimizations are disabled if this plugin is loaded.
+    # 
+    # Usage:
+    #
+    #   # Make all model subclasses support automatic SQL comments
+    #   # (called before loading subclasses)
+    #   Sequel::Model.plugin :sql_comments
+    #
+    #   # Make the Album class support automatic SQL comments
+    #   Album.plugin :sql_comments
+    module SqlComments
+      # Define a method +meth+ on the given module +mod+ that will use automatic
+      # SQL comments with the given model, method_type, and method.
+      def self.def_sql_commend_method(mod, model, method_type, meth)
+        mod.send(:define_method, meth) do |*a, &block|
+          model.db.with_comments(:model=>model, :method_type=>method_type, :method=>meth) do
+            super(*a, &block)
+          end
+        end
+        # :nocov:
+        mod.send(:ruby2_keywords, meth) if mod.respond_to?(:ruby2_keywords, true)
+        # :nocov:
+      end
+
+      def self.configure(model)
+        model.send(:reset_fast_pk_lookup_sql)
+      end
+
+      module ClassMethods
+        # Use automatic SQL comments for the given class methods.
+        def sql_comments_class_methods(*meths)
+          _sql_comments_methods(singleton_class, :class, meths)
+        end
+
+        # Use automatic SQL comments for the given instance methods.
+        def sql_comments_instance_methods(*meths)
+          _sql_comments_methods(self, :instance, meths)
+        end
+
+        # 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)
+          end
+          _sql_comments_methods(@_sql_comments_dataset_module, :dataset, meths)
+        end
+
+        [:[], :create, :find, :find_or_create, :with_pk, :with_pk!].each do |meth|
+          define_method(meth) do |*a, &block|
+            db.with_comments(:model=>self, :method_type=>:class, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Don't optimize the fast PK lookups, as it uses static SQL that
+        # won't support the SQL comments.
+        def reset_fast_pk_lookup_sql
+          @fast_pk_lookup_sql = @fast_instance_delete_sql = nil
+        end
+
+        # Define automatic SQL comment methods in +mod+ for each method in +meths+,
+        # with the given +method_type+.
+        def _sql_comments_methods(mod, method_type, meths)
+          meths.each do |meth|
+            SqlComments.def_sql_commend_method(mod, self, method_type, meth)
+          end
+        end
+      end
+
+      module InstanceMethods
+        [:delete, :destroy, :lock!, :refresh, :save, :save_changes, :update, :update_fields].each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:instance, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Do not use a placeholder loader for associations.
+        def _associated_object_loader(opts, dynamic_opts)
+          nil
+        end
+
+        # Use SQL comments on normal association load queries, showing they are association loads.
+        def _load_associated_objects(opts, dynamic_opts=OPTS)
+          db.with_comments(:model=>model, :method_type=>:association_load, :association=>opts[:name]) do
+            super
+          end
+        end
+      end
+
+      module DatasetMethods
+        Dataset::ACTION_METHODS.each do |meth|
+          define_method(meth) do |*a, &block|
+            t = Sequel.current
+            return super(*a, &block) if (hash = Sequel.synchronize{db.comment_hashes[t]}) && hash[:model]
+
+            db.with_comments(:model=>model, :method_type=>:dataset, :method=>meth) do
+              super(*a, &block)
+            end
+          end
+          # :nocov:
+          ruby2_keywords(meth) if respond_to?(:ruby2_keywords, true)
+          # :nocov:
+        end
+
+        private
+
+        # Add the association name as part of the eager load data, so
+        # perform_eager_load has access to it.
+        def prepare_eager_load(a, reflections, eager_assoc)
+          res = super
+          
+          reflections.each do |r|
+            res[r[:eager_loader]][:association] = r[:name]
+          end
+
+          res
+        end
+
+        # Use SQL comments on eager load queries, showing they are eager loads.
+        def perform_eager_load(loader, eo)
+          db.with_comments(:model=>model, :method_type=>:association_eager_load, :method=>nil, :association=>eo[:association]) do
+            super
+          end
+        end
+      end
+    end
+  end
+end