sequel 3.46.0 → 3.47.0

data/lib/sequel/plugins/many_through_many.rb

@@ -190,7 +190,7 @@ module Sequel
           opts[:eager_loader_key] = left_pk unless opts.has_key?(:eager_loader_key)
           left_pks = opts[:left_primary_keys] = Array(left_pk)
           lpkc = opts[:left_primary_key_column] ||= left_pk
-          lpkcs = opts[:left_primary_key_columns] ||= Array(lpkc)
+          opts[:left_primary_key_columns] ||= Array(lpkc)
           opts[:dataset] ||= lambda do
             ds = opts.associated_dataset
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias], :qualify=>:deep)}
@@ -267,7 +267,6 @@ module Sequel
           lpks = ref.qualify(model.table_name, lpks)
           edges = ref.edges
           first, rest = edges.first, edges[1..-1]
-          last = edges.last
           ds = model.db[first[:table]].select(*Array(ref.qualify(first[:table], first[:right])))
           rest.each{|e| ds = ds.join(e[:table], e.fetch(:only_conditions, (Array(e[:right]).zip(Array(e[:left])) + e[:conditions])), :table_alias=>ds.unused_table_alias(e[:table]), :qualify=>:deep, &e[:block])}
           last_alias = if rest.empty?

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -1,26 +1,16 @@
 module Sequel
   module Plugins
-    # This is a fairly simple plugin that modifies the internal association loading logic
+    # The ManyToOnePkLookup plugin that modifies the internal association loading logic
     # for many_to_one associations to use a simple primary key lookup on the associated
     # class, which is generally faster as it uses mostly static SQL.  Additional, if the
     # associated class is caching primary key lookups, you get the benefit of a cached
     # lookup.
     #
-    # This plugin is generally not as fast as the prepared_statements_associations plugin
-    # in the case where the model is not caching primary key lookups, however, it is
-    # probably significantly faster if the model is caching primary key lookups.  If
-    # the prepared_statements_associations plugin has been loaded first, this
-    # plugin will only use the primary key lookup code if the associated model is
-    # caching primary key lookups.
-    #
     # This plugin attempts to determine cases where the primary key lookup would have
-    # different results than the regular lookup, and use the regular lookup in that case,
-    # but it cannot handle all situations correctly, which is why it is not Sequel's
-    # default behavior.
+    # different results than the regular lookup, and use the regular lookup in that case.
+    # If you want to explicitly force whether or not to use primary key lookups for
+    # a given association, set the :many_to_one_pk_lookup association option.
     #
-    # You can disable primary key lookups on a per association basis with this
-    # plugin using the :many_to_one_pk_lookup=>false association option.
-    # 
     # Usage:
     #
     #   # Make all model subclass instances use primary key lookups for many_to_one
@@ -30,37 +20,31 @@ module Sequel
     #   # Do so for just the album class.
     #   Album.plugin :many_to_one_pk_lookup
     module ManyToOnePkLookup
+      module ClassMethods
+        # Disable primary key lookup in cases where it will result in a different
+        # query than the association query.
+        def def_many_to_one(opts)
+          if !opts.has_key?(:many_to_one_pk_lookup) &&
+             (opts[:dataset] || opts[:conditions] || opts[:block] || opts[:select] ||
+              (opts.has_key?(:key) && opts[:key] == nil))
+            opts[:many_to_one_pk_lookup] = false
+          end
+          super
+        end
+      end
+
       module InstanceMethods
         private
 
-        # If the current association is a fairly simple many_to_one association, use
+        # If the current association is a simple many_to_one association, use
         # a simple primary key lookup on the associated model, which can benefit from
         # caching if the associated model is using caching.
-        def _load_associated_object(opts, dynamic_opts)
-          klass = opts.associated_class
-          cache_lookup = opts.send(:cached_fetch, :many_to_one_pk_lookup) do 
-            opts[:type] == :many_to_one &&
-              opts[:key] &&
-              opts.primary_key == klass.primary_key
-          end
-          if cache_lookup &&
-            !dynamic_opts[:callback] &&
-            (o = klass.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| send(c)} : send(fk))))
-            o
-          else
-            super
-          end
-        end
-
-        # Deal with the situation where the prepared_statements_associations plugin is
-        # loaded first, by using a primary key lookup for many_to_one associations if
-        # the associated class is using caching, and using the default code otherwise.
-        # This is done because the prepared_statements_associations code is probably faster
-        # than the primary key lookup this plugin uses if the model is not caching lookups,
-        # but probably slower if the model is caching lookups.
         def _load_associated_objects(opts, dynamic_opts={})
-          if opts.can_have_associated_objects?(self) && opts[:type] == :many_to_one && opts.associated_class.respond_to?(:cache_get_pk)
-            _load_associated_object(opts, dynamic_opts)
+          return super unless opts.can_have_associated_objects?(self) && opts[:type] == :many_to_one
+          klass = opts.associated_class
+          if !dynamic_opts[:callback] &&
+             opts.send(:cached_fetch, :many_to_one_pk_lookup){opts.primary_key == klass.primary_key}
+            klass.send(:primary_key_lookup, ((fk = opts[:key]).is_a?(Array) ? fk.map{|c| send(c)} : send(fk)))
           else
             super
           end

data/lib/sequel/plugins/optimistic_locking.rb

@@ -38,11 +38,7 @@ module Sequel
         # The column holding the version of the lock
         attr_accessor :lock_column
         
-        # Copy the lock_column value into the subclass
-        def inherited(subclass)
-          super
-          subclass.lock_column = lock_column
-        end
+        Plugins.inherited_instance_variables(self, :@lock_column=>nil)
       end
     
       module InstanceMethods

data/lib/sequel/plugins/pg_row.rb

@@ -100,7 +100,9 @@ module Sequel
       module ClassMethods
         # Register the model's row type with the database.
         def register_row_type
-          db.register_row_type(model.table_name, :converter=>self, :typecaster=>method(:new))
+          table = dataset.first_source_table
+          db.register_row_type(table, :converter=>self, :typecaster=>method(:new))
+          db.instance_variable_get(:@schema_type_classes)[:"pg_row_#{table}"] = self
         end
       end
 
@@ -113,7 +115,7 @@ module Sequel
           sql << ROW
           ds.literal_append(sql, values.values_at(*columns))
           sql << CAST
-          ds.quote_schema_table_append(sql, model.table_name)
+          ds.quote_schema_table_append(sql, model.dataset.first_source_table)
         end
       end
     end

data/lib/sequel/plugins/pg_typecast_on_load.rb

@@ -41,11 +41,7 @@ module Sequel
           @pg_typecast_on_load_columns.concat(columns)
         end
 
-        # Give the subclass a copy of the columns to typecast on load.
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@pg_typecast_on_load_columns, pg_typecast_on_load_columns.dup)
-        end
+        Plugins.inherited_instance_variables(self, :@pg_typecast_on_load_columns=>:dup)
       end
 
       module InstanceMethods
@@ -53,8 +49,8 @@ module Sequel
         # object, and use it to convert the value.
         def set_values(values)
           model.pg_typecast_on_load_columns.each do |c|
-            if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid])
-              values[c] = db.conversion_procs[oid].call(v)
+            if (v = values[c]).is_a?(String) && (oid = db_schema[c][:oid]) && (pr = db.conversion_procs[oid])
+              values[c] = pr.call(v)
             end
           end
           super

data/lib/sequel/plugins/prepared_statements.rb

@@ -36,11 +36,7 @@ module Sequel
       end
 
       module ClassMethods
-        # Setup the datastructure used to hold the prepared statements in the subclass.
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{})
-        end
+        Plugins.inherited_instance_variables(self, :@prepared_statements=>lambda{|v| {:insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{}}})
 
         private
 

data/lib/sequel/plugins/prepared_statements_safe.rb

@@ -33,17 +33,8 @@ module Sequel
         # that can be created is 2^N (where N is the number of free columns).
         attr_reader :prepared_statements_column_defaults
         
-        def inherited(subclass)
-          super
-          subclass.instance_variable_set(:@prepared_statements_column_defaults, @prepared_statements_column_defaults) if @prepared_statements_column_defaults && !subclass.prepared_statements_column_defaults
-        end
-
-        # Set the column defaults to use when creating on the subclass.
-        def set_dataset(*)
-          x = super
-          set_prepared_statements_column_defaults
-          x
-        end
+        Plugins.inherited_instance_variables(self, :@prepared_statements_column_defaults=>:dup)
+        Plugins.after_set_dataset(self, :set_prepared_statements_column_defaults)
 
         private
 

data/lib/sequel/plugins/rcte_tree.rb

@@ -190,7 +190,7 @@ module Sequel
           elds = elds.select_append(ka) unless elds.opts[:select] == nil
           elds.all do |obj|
             opk = obj[prkey]
-            if in_pm = parent_map.has_key?(opk)
+            if parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
                 idm_obj.values[ka] = obj.values[ka]
                 obj = idm_obj
@@ -298,7 +298,7 @@ module Sequel
             end
             
             opk = obj[prkey]
-            if in_pm = parent_map.has_key?(opk)
+            if parent_map.has_key?(opk)
               if idm_obj = parent_map[opk]
                 idm_obj.values[ka] = obj.values[ka]
                 obj = idm_obj

data/lib/sequel/plugins/serialization.rb

@@ -30,11 +30,11 @@ module Sequel
     #
     # == Example
     #
-    #   require 'sequel'
-    #   # Require json, as the plugin doesn't require it for you.
+    #   # Require json if you plan to use it, as the plugin doesn't require it for you.
     #   require 'json'
     #
-    #   # Register custom serializer/deserializer pair
+    #   # Register custom serializer/deserializer pair, if desired
+    #   require 'sequel/plugins/serialization'
     #   Sequel::Plugins::Serialization.register_format(:reverse,
     #     lambda{|v| v.reverse},
     #     lambda{|v| v.reverse})
@@ -111,16 +111,7 @@ module Sequel
         # call be overridden and call super to get the serialization behavior
         attr_accessor :serialization_module
 
-        # Copy the serialization_map and deserialization map into the subclass.
-        def inherited(subclass)
-          super
-          sm = serialization_map.dup
-          dsm = deserialization_map.dup
-          subclass.instance_eval do
-            @deserialization_map = dsm
-            @serialization_map = sm
-          end
-        end
+        Plugins.inherited_instance_variables(self, :@deserialization_map=>:dup, :@serialization_map=>:dup)
         
         # Create instance level reader that deserializes column values on request,
         # and instance level writer that stores new deserialized values.
@@ -154,6 +145,8 @@ module Sequel
               define_method(column) do 
                 if deserialized_values.has_key?(column)
                   deserialized_values[column]
+                elsif frozen?
+                  deserialize_value(column, super())
                 else
                   deserialized_values[column] = deserialize_value(column, super())
                 end
@@ -179,6 +172,11 @@ module Sequel
           @deserialized_values ||= {}
         end
 
+        def freeze
+          deserialized_values.freeze
+          super
+        end
+
         # Initialization the deserialized values for objects retrieved from the database.
         def set_values(hash)
           @deserialized_values.clear if @deserialized_values

data/lib/sequel/plugins/serialization_modification_detection.rb

@@ -40,10 +40,18 @@ module Sequel
         # Detect which serialized columns have changed.
         def changed_columns
           cc = super
+          cc = cc.dup if frozen?
           deserialized_values.each{|c, v| cc << c if !cc.include?(c) && original_deserialized_value(c) != v} 
           cc
         end
 
+        # Freeze the original deserialized values when freezing the instance.
+        def freeze
+          @original_deserialized_values ||= {}
+          @original_deserialized_values.freeze
+          super
+        end
+
         private
 
         # For new objects, serialize any existing deserialized values so that changes can
@@ -55,7 +63,11 @@ module Sequel
 
         # Return the original deserialized value of the column, caching it to improve performance.
         def original_deserialized_value(column)
-          (@original_deserialized_values ||= {})[column] ||= deserialize_value(column, self[column])
+          if frozen?
+            @original_deserialized_values[column] || deserialize_value(column, self[column])
+          else
+            (@original_deserialized_values ||= {})[column] ||= deserialize_value(column, self[column])
+          end
         end
       end
     end

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -77,9 +77,9 @@ module Sequel
           @sti_model_map = opts[:model_map] || lambda{|v| v if v && v != ''}
           @sti_key_map = if km = opts[:key_map]
             if km.is_a?(Hash)
-              h = Hash.new do |h,k| 
+              h = Hash.new do |h1,k| 
                 unless k.is_a?(String)
-                  h[k.to_s]
+                  h1[k.to_s]
                 else
                   []
                 end
@@ -93,9 +93,9 @@ module Sequel
               km
             end
           elsif sti_model_map.is_a?(Hash)
-            h = Hash.new do |h,k| 
+            h = Hash.new do |h1,k| 
               unless k.is_a?(String)
-                h[k.to_s]
+                h1[k.to_s]
               else
                 []
               end

data/lib/sequel/plugins/static_cache.rb

@@ -35,6 +35,15 @@ module Sequel
           @all.dup
         end
 
+        # Get the number of records in the cache, without issuing a database query.
+        def count(*a, &block)
+          if a.empty? && !block
+            @all.size
+          else
+            super
+          end
+        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 cache_get_pk(pk)
@@ -47,33 +56,72 @@ module Sequel
           @all.each(&block)
         end
 
-        # If no arguments are given, yield each of the model's frozen instances to the block.
-        # and return a new array, without issuing a database query.  If any arguments are
-        # given, use the default Sequel behavior.
-        def map(*a)
-          if a.empty?
-            @all.map(&(Proc.new if block_given?))
+        # Use the cache instead of a query to get the results.
+        def map(column=nil, &block)
+          if column
+            raise(Error, "Cannot provide both column and block to map") if block
+            if column.is_a?(Array)
+              @all.map{|r| r.values.values_at(*column)}
+            else
+              @all.map{|r| r[column]}
+            end
           else
-            super
+            @all.map(&(Proc.new if block_given?))
           end
         end
 
-        # Reload the cache when the dataset changes.
-        def set_dataset(*)
-          s = super
-          load_cache
-          s
+        Plugins.after_set_dataset(self, :load_cache)
+
+        # Use the cache instead of a query to get the results.
+        def to_hash(key_column = nil, value_column = nil)
+        return cache.dup if key_column.nil? && value_column.nil?
+
+        h = {}
+        if value_column
+          if value_column.is_a?(Array)
+            if key_column.is_a?(Array)
+              each{|r| h[r.values.values_at(*key_column)] = r.values.values_at(*value_column)}
+            else
+              each{|r| h[r[key_column]] = r.values.values_at(*value_column)}
+            end
+          else
+            if key_column.is_a?(Array)
+              each{|r| h[r.values.values_at(*key_column)] = r[value_column]}
+            else
+              each{|r| h[r[key_column]] = r[value_column]}
+            end
+          end
+        elsif key_column.is_a?(Array)
+          each{|r| h[r.values.values_at(*key_column)] = r}
+        else
+          each{|r| h[r[key_column]] = r}
+        end
+        h
         end
 
-        # If no arguments are given, yield an identity map for the model with frozen primary keys
-        # and instances, without issuing a database query. If any arguments are
-        # given, use the default Sequel behavior.
-        def to_hash(*a)
-          if a.empty?
-            cache.dup
+        # Use the cache instead of a query to get the results
+        def to_hash_groups(key_column, value_column = nil)
+          h = {}
+          if value_column
+            if value_column.is_a?(Array)
+              if key_column.is_a?(Array)
+                each{|r| (h[r.values.values_at(*key_column)] ||= []) << r.values.values_at(*value_column)}
+              else
+                each{|r| (h[r[key_column]] ||= []) << r.values.values_at(*value_column)}
+              end
+            else
+              if key_column.is_a?(Array)
+                each{|r| (h[r.values.values_at(*key_column)] ||= []) << r[value_column]}
+              else
+                each{|r| (h[r[key_column]] ||= []) << r[value_column]}
+              end
+            end
+          elsif key_column.is_a?(Array)
+            each{|r| (h[r.values.values_at(*key_column)] ||= []) << r}
           else
-            super
+            each{|r| (h[r[key_column]] ||= []) << r}
           end
+          h
         end
 
         private

data/lib/sequel/plugins/string_stripper.rb

@@ -22,34 +22,24 @@ module Sequel
     #   # Make the Album class strip strings
     #   Album.plugin :string_stripper
     module StringStripper
-      # Set blob columns as skipping stripping when plugin is loaded.
+      def self.apply(model)
+        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_variable_set(:@skipped_string_stripping_columns, [])
-        model.send(:set_skipped_string_stripping_columns)
+        model.instance_eval{set_skipped_string_stripping_columns if @dataset}
       end
 
       module ClassMethods
-        # Copy skipped stripping columns from superclass into subclass.
-        def inherited(subclass)
-          subclass.instance_variable_set(:@skipped_string_stripping_columns, @skipped_string_stripping_columns.dup)
-          super
-        end
-
-        # Set blob columns as skipping stripping when plugin is loaded.
-        def set_dataset(*)
-          res = super
-          set_skipped_string_stripping_columns
-          res
-        end
+        Plugins.after_set_dataset(self, :set_skipped_string_stripping_columns)
 
         # Skip stripping for the given columns.
         def skip_string_stripping(*columns)
-          @skipped_string_stripping_columns.concat(columns).uniq!
+          skip_input_transformer(:string_stripper, *columns)
         end
 
         # Return true if the column should not have values stripped.
         def skip_string_stripping?(column)
-          @skipped_string_stripping_columns.include?(column)
+          skip_input_transformer?(:string_stripper, column)
         end
 
         private
@@ -62,16 +52,6 @@ module Sequel
           end
         end
       end
-
-      module InstanceMethods
-        # Strip value if it is a non-blob string and the model hasn't been set
-        # to skip stripping for the column, before attempting to assign
-        # it to the model's values.
-        def []=(k, v)
-          v = v.strip if v.is_a?(String) && !v.is_a?(SQL::Blob) && !model.skip_string_stripping?(k)
-          super(k, v)
-        end
-      end
     end
   end
 end