sequel 3.34.0 → 3.35.0

data/lib/sequel/plugins/dirty.rb

@@ -0,0 +1,214 @@
+module Sequel
+  module Plugins
+    # The dirty plugin makes Sequel save the initial value of
+    # a column when setting a new value for the column.  This
+    # makes it easier to see what changes were made to the object:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.initial_value(:name)   # 'Foo'
+    #   artist.column_change(:name)   # ['Foo', 'Bar']
+    #   artist.column_changes         # {:name => ['Foo', 'Bar']}
+    #   artist.column_changed?(:name) # true
+    #   artist.reset_column(:name)
+    #   artist.name                   # => 'Foo'
+    #   artist.column_changed?(:name) # false
+    #
+    # It allows makes changed_columns more accurate in that it
+    # can detect when a the column value is changed and then
+    # changed back:
+    #
+    #   artist.name                   # => 'Foo'
+    #   artist.name = 'Bar'
+    #   artist.changed_columns        # => [:name]
+    #   artist.name = 'Foo'
+    #   artist.changed_columns        # => []
+    #
+    # It can handle situations where a column value is
+    # modified in place:
+    #
+    #   artist.will_change_column(:name)
+    #   artist.name.gsub!(/o/, 'u')
+    #   artist.changed_columns       # => [:name]
+    #   artist.initial_value(:name)  # => 'Foo'
+    #   artist.column_change(:name)  # => ['Foo', 'Fuu']
+    #
+    # It also saves the previously changed values after an update:
+    #
+    #   artist.update(:name=>'Bar')
+    #   artist.column_changes        # => {}
+    #   artist.previous_changes      # => {:name=>['Foo', 'Bar']}
+    # 
+    # Usage:
+    #
+    #   # Make all model subclass instances record previous values (called before loading subclasses)
+    #   Sequel::Model.plugin :dirty
+    #
+    #   # Make the Album class record previous values
+    #   Album.plugin :dirty
+    module Dirty
+      module InstanceMethods
+        # A hash of previous changes before the object was
+        # saved, in the same format as #column_changes.
+        # Note that this is not necessarily the same as the columns
+        # that were used in the update statement.
+        attr_reader :previous_changes
+
+        # An array with the initial value and the current value
+        # of the column, if the column has been changed.  If the
+        # column has not been changed, returns nil.
+        #
+        #   column_change(:name) # => ['Initial', 'Current']
+        def column_change(column)
+          [initial_value(column), send(column)] if column_changed?(column)
+        end
+
+        # A hash with column symbol keys and pairs of initial and
+        # current values for all changed columns.
+        #
+        #   column_changes # => {:name => ['Initial', 'Current']}
+        def column_changes
+          h = {}
+          initial_values.each do |column, value|
+            h[column] = [value, send(column)]
+          end
+          h
+        end
+
+        # Either true or false depending on whether the column has
+        # changed.  Note that this is not exactly the same as checking if
+        # the column is in changed_columns, if the column was not set
+        # initially.
+        #
+        #   column_changed?(:name) # => true
+        def column_changed?(column)
+          initial_values.has_key?(column)
+        end
+
+        # The initial value of the given column.  If the column value has
+        # not changed, this will be the same as the current value of the
+        # column.
+        #
+        #   initial_value(:name) # => 'Initial'
+        def initial_value(column)
+          initial_values.fetch(column){send(column)}
+        end
+
+        # A hash with column symbol keys and initial values.
+        #
+        #   initial_values # {:name => 'Initial'}
+        def initial_values
+          @initial_values ||= {}
+        end
+
+        # Reset the column to its initial value.  If the column was not set
+        # initial, removes it from the values.
+        #
+        #   reset_column(:name)
+        #   name # => 'Initial'
+        def reset_column(column)
+          if initial_values.has_key?(column)
+            send(:"#{column}=", initial_values[column])
+          end
+          if missing_initial_values.include?(column)
+            values.delete(column)
+          end
+        end
+
+        # Manually specify that a column will change.  This should only be used
+        # if you plan to modify a column value in place, which is not recommended.
+        #
+        #   will_change_column(:name)
+        #   name.gsub(/i/i, 'o')
+        #   column_change(:name) # => ['Initial', 'onotoal']
+        def will_change_column(column)
+          changed_columns << column unless changed_columns.include?(column)
+          check_missing_initial_value(column)
+
+          value = if initial_values.has_key?(column)
+            initial_values[column]
+          else
+            send(column)
+          end
+
+          initial_values[column] = if value && value != true && value.respond_to?(:clone)
+            begin
+              value.clone
+            rescue TypeError
+              value
+            end
+          else
+            value
+          end
+        end
+
+        private
+
+        # Reset the initial values after saving.
+        def after_save
+          super
+          reset_initial_values
+        end
+
+        # Save the current changes so they are available after updating.  This happens
+        # before after_save resets them.
+        def after_update
+          super
+          @previous_changes = column_changes
+        end
+
+        # Reset the initial values when refreshing.
+        def _refresh(dataset)
+          super
+          reset_initial_values
+        end
+
+        # When changing the column value, save the initial column value.  If the column
+        # value is changed back to the initial value, update changed columns to remove
+        # the column.
+        def change_column_value(column, value)
+          if (iv = initial_values).has_key?(column)
+            initial = iv[column]
+            super
+            if value == initial
+              changed_columns.delete(column) unless missing_initial_values.include?(column)
+              iv.delete(column)
+            end
+          else
+            check_missing_initial_value(column)
+            iv[column] = send(column)
+            super
+          end
+        end
+
+        # If the values hash does not contain the column, make sure missing_initial_values
+        # does so that it doesn't get deleted from changed_columns if changed back,
+        # and so that reseting the column value can be handled correctly.
+        def check_missing_initial_value(column)
+          unless values.has_key?(column) || (miv = missing_initial_values).include?(column)
+            miv << column
+          end
+        end
+
+        # Reset the initial values when initializing.
+        def initialize_set(h)
+          super
+          reset_initial_values
+        end
+
+        # Array holding column symbols that were not present initially.  This is necessary
+        # to differentiate between values that were not present and values that were
+        # present but equal to nil.
+        def missing_initial_values
+          @missing_initial_values ||= []
+        end
+
+        # Clear the data structures that store the initial values.
+        def reset_initial_values
+          @initial_values.clear if @initial_values
+          @missing_initial_values.clear if @missing_initial_values
+        end
+      end
+    end
+  end
+end

data/lib/sequel/plugins/identity_map.rb

@@ -111,7 +111,7 @@ module Sequel
               eo[:rows].each{|object| object.associations[name] = []}
               ds = opts.associated_class 
               opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-              ft = opts[:final_reverse_edge]
+              ft = opts.final_reverse_edge
               conds = uses_lcks ? [[left_keys.map{|k| SQL::QualifiedIdentifier.new(ft[:table], k)}, h.keys]] : [[left_key, h.keys]]
 
               # See above comment in many_to_many eager_loader

data/lib/sequel/plugins/json_serializer.rb

@@ -56,6 +56,11 @@ module Sequel
     #   Album.to_json
     #   Album.filter(:artist_id=>1).to_json(:include=>:tags)
     #
+    # If you have an existing array of model instances you want to convert to
+    # JSON, you can call the class to_json method with the :array option:
+    #
+    #   Album.to_json(:array=>[Album[1], Album[2]])
+    #
     # Usage:
     #
     #   # Add JSON output capability to all model subclass instances (called before loading subclasses)
@@ -203,7 +208,17 @@ module Sequel
           else
             opts = model.json_serializer_opts
           end
-          res = row_proc ? all.map{|obj| Literal.new(obj.to_json(opts))} : all
+          res = if row_proc 
+            array = if opts[:array]
+              opts = opts.dup
+              opts.delete(:array)
+            else
+              all
+            end
+            array.map{|obj| Literal.new(obj.to_json(opts))}
+           else
+            all
+          end
           opts[:root] ? {model.send(:pluralize, model.send(:underscore, model.to_s)) => res}.to_json(*a) : res.to_json(*a)
         end
       end

data/lib/sequel/plugins/many_through_many.rb

@@ -47,30 +47,18 @@ module Sequel
       class ManyThroughManyAssociationReflection < Sequel::Model::Associations::ManyToManyAssociationReflection
         Sequel::Model::Associations::ASSOCIATION_TYPES[:many_through_many] = self
 
-        # The table containing the column to use for the associated key when eagerly loading
-        def associated_key_table
-          self[:associated_key_table] = self[:final_reverse_edge][:alias]
-        end
-        
         # The default associated key alias(es) to use when eager loading
         # associations via eager.
         def default_associated_key_alias
           self[:uses_left_composite_keys] ? (0...self[:through].first[:left].length).map{|i| :"x_foreign_key_#{i}_x"} : :x_foreign_key_x
         end
 
-        # The hash key to use for the eager loading predicate (left side of IN (1, 2, 3))
-        def eager_loading_predicate_key
-          self[:eager_loading_predicate_key] ||= begin
-            calculate_edges
-            e = self[:edges].first
-            f = self[:final_reverse_edge]
-            qualify(f[:alias], e[:right])
-          end
-        end
-    
-        # The list of joins to use when eager graphing
-        def edges
-          self[:edges] || calculate_edges || self[:edges]
+        %w'associated_key_table eager_loading_predicate_key edges final_edge final_reverse_edge reverse_edges'.each do |meth|
+          class_eval(<<-END, __FILE__, __LINE__+1)
+            def #{meth}
+              cached_fetch(:#{meth}){calculate_edges[:#{meth}]}
+            end
+          END
         end
 
         # Many through many associations don't have a reciprocal
@@ -78,11 +66,6 @@ module Sequel
           nil
         end
 
-        # The list of joins to use when lazy loading or eager loading
-        def reverse_edges
-          self[:reverse_edges] || calculate_edges || self[:reverse_edges]
-        end
-
         private
 
         # Make sure to use unique table aliases when lazy loading or eager loading
@@ -119,11 +102,18 @@ module Sequel
           reverse_edges = es.reverse.map{|e| {:table=>e[:left_table], :left=>e[:left_key], :right=>e[:right_key]}}
           reverse_edges.pop
           calculate_reverse_edge_aliases(reverse_edges)
-          self[:final_edge] = edges.pop
-          self[:final_reverse_edge] = reverse_edges.pop
-          self[:edges] = edges
-          self[:reverse_edges] = reverse_edges
-          nil
+          final_reverse_edge = reverse_edges.pop
+          final_reverse_alias = final_reverse_edge[:alias]
+
+          h = {:final_edge=>edges.pop,
+               :final_reverse_edge=>final_reverse_edge,
+               :edges=>edges,
+               :reverse_edges=>reverse_edges,
+               :eager_loading_predicate_key=>qualify(final_reverse_alias, edges.first[:right]),
+               :associated_key_table=>final_reverse_edge[:alias],
+          }
+          h.each{|k, v| cached_set(k, v)}
+          h
         end
       end
 
@@ -185,7 +175,7 @@ module Sequel
           opts[:dataset] ||= lambda do
             ds = opts.associated_class
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
+            ft = opts.final_reverse_edge
             ds.join(ft[:table],  Array(ft[:left]).zip(Array(ft[:right])) + left_keys.zip(left_pks.map{|k| send(k)}), :table_alias=>ft[:alias])
           end
 
@@ -196,7 +186,7 @@ module Sequel
             rows.each{|object| object.associations[name] = []}
             ds = opts.associated_class 
             opts.reverse_edges.each{|t| ds = ds.join(t[:table], Array(t[:left]).zip(Array(t[:right])), :table_alias=>t[:alias])}
-            ft = opts[:final_reverse_edge]
+            ft = opts.final_reverse_edge
             ds = ds.join(ft[:table], Array(ft[:left]).zip(Array(ft[:right])) + [[opts.eager_loading_predicate_key, h.keys]], :table_alias=>ft[:alias])
             ds = model.eager_loading_dataset(opts, ds, nil, eo[:associations], eo)
             case opts.eager_limit_strategy
@@ -240,7 +230,7 @@ module Sequel
               ds = ds.graph(t[:table], t.fetch(:only_conditions, (Array(t[:right]).zip(Array(t[:left])) + t[:conditions])), :select=>false, :table_alias=>ds.unused_table_alias(t[:table]), :join_type=>t[:join_type], :implicit_qualifier=>iq, &t[:block])
               iq = nil
             end
-            fe = opts[:final_edge]
+            fe = opts.final_edge
             ds.graph(opts.associated_class, use_only_conditions ? only_conditions : (Array(opts.right_primary_key).zip(Array(fe[:left])) + conditions), :select=>select, :table_alias=>eo[:table_alias], :join_type=>join_type, &graph_block)
           end
 
@@ -269,7 +259,7 @@ module Sequel
           end
           meths = ref.right_primary_keys
           meths = ref.qualify(obj.model.table_name, meths) if obj.is_a?(Sequel::Dataset)
-          exp = association_filter_key_expression(ref.qualify(last_alias, Array(ref[:final_edge][:left])), meths, obj)
+          exp = association_filter_key_expression(ref.qualify(last_alias, Array(ref.final_edge[:left])), meths, obj)
           if exp == SQL::Constants::FALSE
             association_filter_handle_inversion(op, exp, Array(lpks))
           else

data/lib/sequel/plugins/many_to_one_pk_lookup.rb

@@ -38,8 +38,8 @@ module Sequel
         # caching if the associated model is using caching.
         def _load_associated_object(opts, dynamic_opts)
           klass = opts.associated_class
-          cache_lookup = opts.fetch(:many_to_one_pk_lookup) do 
-            opts[:many_to_one_pk_lookup] = opts[:type] == :many_to_one &&
+          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

data/lib/sequel/plugins/prepared_statements.rb

@@ -31,14 +31,14 @@ module Sequel
 
       # Setup the datastructure used to hold the prepared statements in the model.
       def self.apply(model)
-        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{})
+        model.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{})
       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=>{})
+          subclass.instance_variable_set(:@prepared_statements, :insert=>{}, :insert_select=>{}, :update=>{}, :lookup_sql=>{}, :fixed=>{})
         end
 
         private
@@ -58,30 +58,30 @@ module Sequel
 
         # Return a prepared statement that can be used to delete a row from this model's dataset.
         def prepared_delete
-          @prepared_statements[:delete] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)
+          cached_prepared_statement(:fixed, :delete){prepare_statement(filter(prepared_statement_key_array(primary_key)), :delete)}
         end
 
         # Return a prepared statement that can be used to insert a row using the given columns.
         def prepared_insert(cols)
-          @prepared_statements[:insert][prepared_columns(cols)] ||= prepare_statement(dataset, :insert, prepared_statement_key_hash(cols))
+          cached_prepared_statement(:insert, prepared_columns(cols)){prepare_statement(dataset, :insert, prepared_statement_key_hash(cols))}
         end
 
         # Return a prepared statement that can be used to insert a row using the given columns
         # and return that column values for the row created.
         def prepared_insert_select(cols)
           if dataset.supports_insert_select?
-            @prepared_statements[:insert_select][prepared_columns(cols)] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))
+            cached_prepared_statement(:insert_select, prepared_columns(cols)){prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)), :insert_select, prepared_statement_key_hash(cols))}
           end
         end
 
         # Return a prepared statement that can be used to lookup a row solely based on the primary key.
         def prepared_lookup
-          @prepared_statements[:lookup] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :first)
+          cached_prepared_statement(:fixed, :lookup){prepare_statement(filter(prepared_statement_key_array(primary_key)), :first)}
         end
 
         # Return a prepared statement that can be used to refresh a row to get new column values after insertion.
         def prepared_refresh
-          @prepared_statements[:refresh] ||= prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)
+          cached_prepared_statement(:fixed, :refresh){prepare_statement(naked.clone(:server=>dataset.opts.fetch(:server, :default)).filter(prepared_statement_key_array(primary_key)), :first)}
         end
 
         # Return an array of two element arrays with the column symbol as the first entry and the
@@ -108,13 +108,27 @@ module Sequel
 
         # Return a prepared statement that can be used to update row using the given columns.
         def prepared_update(cols)
-          @prepared_statements[:update][prepared_columns(cols)] ||= prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))
+          cached_prepared_statement(:update, prepared_columns(cols)){prepare_statement(filter(prepared_statement_key_array(primary_key)), :update, prepared_statement_key_hash(cols))}
         end
 
         # Use a prepared statement to query the database for the row matching the given primary key.
         def primary_key_lookup(pk)
           prepared_lookup.call(primary_key_hash(pk))
         end
+
+        private
+
+        # If a prepared statement has already been cached for the given type and subtype,
+        # return it.  Otherwise, yield to the block to get the prepared statement, and cache it.
+        def cached_prepared_statement(type, subtype)
+          h = @prepared_statements[type]
+          Sequel.synchronize do
+            if v = h[subtype]
+              return v end
+          end
+          ps = yield
+          Sequel.synchronize{h[subtype] = ps}
+        end
       end
 
       module InstanceMethods

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -53,8 +53,7 @@ module Sequel
           when :many_to_many
             association_bound_variable_hash(opts.join_table_alias, opts[:left_keys], opts[:left_primary_keys])
           when :many_through_many
-            opts.reverse_edges
-            association_bound_variable_hash(opts[:final_reverse_edge][:alias], Array(opts[:left_key]), opts[:left_primary_keys])
+            association_bound_variable_hash(opts.final_reverse_edge[:alias], Array(opts[:left_key]), opts[:left_primary_keys])
           end
         end
 
@@ -62,7 +61,7 @@ module Sequel
         # that, given appropriate bound variables, the prepared statement will work correctly for any
         # instance.
         def association_prepared_statement(opts)
-          opts[:prepared_statement] ||= begin
+          opts.send(:cached_fetch, :prepared_statement) do
             ps = _associated_dataset(opts, {}).unbind.first.prepare(opts.returns_array? ? :select : :first, :"smpsap_#{NEXT.call}")
             ps.log_sql = true
             ps

data/lib/sequel/plugins/prepared_statements_with_pk.rb

@@ -31,7 +31,7 @@ module Sequel
         # Return a prepared statement that can be used to lookup a row given a dataset for the row matching
         # the primary key.
         def prepared_lookup_dataset(ds)
-          @prepared_statements[:lookup_sql][ds.sql] ||= prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)
+          cached_prepared_statement(:lookup_sql, ds.sql){prepare_statement(ds.filter(prepared_statement_key_array(primary_key).map{|k, v| [SQL::QualifiedIdentifier.new(ds.model.table_name, k), v]}), :first)}
         end
       end
 

data/lib/sequel/plugins/single_table_inheritance.rb

@@ -131,7 +131,7 @@ module Sequel
         # keys for all of their descendant classes.
         def sti_subclass_added(key)
           if sti_key_array
-            sti_key_array << key
+            Sequel.synchronize{sti_key_array << key}
             superclass.sti_subclass_added(key)
           end
         end

data/lib/sequel/plugins/subclasses.rb

@@ -28,7 +28,7 @@ module Sequel
 
         # All descendent classes of this model.
         def descendents
-          subclasses.map{|x| [x] + x.descendents}.flatten
+          Sequel.synchronize{_descendents}
         end
 
         # Add the subclass to this model's current subclasses,
@@ -36,9 +36,17 @@ module Sequel
         # in the subclass.
         def inherited(subclass)
           super
-          subclasses << subclass
+          Sequel.synchronize{subclasses << subclass}
           subclass.instance_variable_set(:@subclasses, [])
         end
+
+        private
+
+        # Recursive, non-thread safe version of descendents, since
+        # the mutex Sequel uses isn't reentrant.
+        def _descendents
+          subclasses.map{|x| [x] + x.send(:_descendents)}.flatten
+        end
       end
     end
   end

data/lib/sequel/plugins/timestamps.rb

@@ -19,7 +19,7 @@ module Sequel
     #   # timestamp, and setting the update timestamp when creating
     #   Album.plugin :timestamps, :force=>true, :update_on_create=>true
     module Timestamps
-      # Configure the plugin by setting the avialable options.  Note that
+      # Configure the plugin by setting the available options.  Note that
       # if this method is run more than once, previous settings are ignored,
       # and it will just use the settings given or the default settings.  Options:
       # * :create - The field to hold the create timestamp (default: :created_at)

data/lib/sequel/plugins/xml_serializer.rb

@@ -79,6 +79,11 @@ module Sequel
     #
     #   Album.array_from_xml(Album.to_xml) # same as Album.all
     #
+    # If you have an existing array of model instances you want to convert to
+    # XML, you can call the class to_xml method with the :array option:
+    #
+    #   Album.to_xml(:array=>[Album[1], Album[2]])
+    #
     # Usage:
     #
     #   # Add XML output capability to all model subclass instances (called before loading subclasses)
@@ -316,8 +321,14 @@ module Sequel
           raise(Sequel::Error, "Dataset#to_xml") unless row_proc
           x = model.xml_builder(opts)
           name_proc = model.xml_serialize_name_proc(opts)
+          array = if opts[:array]
+            opts = opts.dup
+            opts.delete(:array)
+          else
+            all
+          end
           x.send(name_proc[opts.fetch(:array_root_name, model.send(:pluralize, model.send(:underscore, model.name))).to_s]) do |x1|
-            all.each do |obj|
+            array.each do |obj|
               obj.to_xml(opts.merge(:builder=>x1))
             end
           end

data/lib/sequel/sql.rb

@@ -138,7 +138,7 @@ module Sequel
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*]
 
       # Bitwise mathematical operators used in +NumericMethods+
-      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>]
+      BITWISE_OPERATORS = [:&, :|, :^, :<<, :>>, :%]
 
       # Inequality operators used in +InequalityMethods+
       INEQUALITY_OPERATORS = [:<, :>, :<=, :>=]

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 34
+  MINOR = 35
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0