sequel 4.19.0 → 4.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ce1762f276f7bfdac15fe395f0eef9696c185397
-  data.tar.gz: f1164599a6a4bccd41e20d7ff36f443e6a46551f
+  metadata.gz: 6daa0c1ef4f76e1d9bfdeedbf9208bf32646ab20
+  data.tar.gz: f2cf0e139a84f465fe1146de98b767fad029fca9
 SHA512:
-  metadata.gz: 31ecc2aef0b4d68eb9424f60cd2b1b7256b8916ca57d5fe6b74c5d3681e0b72a73014fa7225c4a87c87ee23656699ea85d027d919ac30613aa99269007676f22
-  data.tar.gz: fe8a6d58fab4a544a5cc5168b6721dc7d72c93567b8d17d04a940efd0ac4fb5dcf5bbe6968ed8fe9e6d52c30dbde418d571567b7f49103ec20f9f86cf9a82a7c
+  metadata.gz: 28f1f4b25bd2c5db83ce6630ebd9310524dafb59a60ce9e72e3c8e6d12f0a9ea9eff9e1e2ec492fa3f7f655b76ee51b6f5a8e233a36b80370d51922d3024f504
+  data.tar.gz: 7309df3435d53878e8aa1945fc728fedad302727d503af24c399285fbf511b70571ca7cbef4f9c1b5c615aac689d9971f8072b0c9e2fb77f89491410384be665

data/CHANGELOG

@@ -1,3 +1,39 @@
+=== 4.20.0 (2015-03-03)
+
+* Restore the use of AUTOINCREMENT on SQLite (jeremyevans) (#965)
+
+* Duplicate the associations hash when duplicating a model object (jeremyevans)
+
+* Correctly apply association limit when eager loading with an eager block using default limit strategy on some databases (jeremyevans)
+
+* Fix eager loading when using the :window_function limit strategy with an eager block and cascaded associations (jeremyevans)
+
+* Add support for set_column_type :auto_increment=>true to add AUTO_INCREMENT to existing column on MySQL (jeremyevans) (#959)
+
+* Add support for overridding the :instance_specific association option (jeremyevans)
+
+* Recognize MSSQL bit type as boolean in the schema_dumper (jeremyevans)
+
+* Skip eager loading queries if there are no matching keys (jeremyevans) (#952)
+
+* Dataset#paged_each now returns an enumerator if not passed a block (jeremyevans)
+
+* Use to_json :root option with string value as the JSON object key in the json_serializer plugin (jeremyevans)
+
+* Allow create_enum in the pg_enum extension be reversible in migrations (celsworth) (#951)
+
+* Have swift adapter respect database and application timezone settings (asppsa, jeremyevans) (#946)
+
+* Don't have the static cache plugin attempt to validate objects (jeremyevans)
+
+* Make freeze not validate objects if their errors are already frozen (jeremyevans)
+
+* Only use prepared statements for associations if caching association metadata (jeremyevans)
+
+* Set parent association when loading descendants in the rcte_tree plugin (jeremyevans)
+
+* Add Database#transaction :before_retry option, specifying a proc to call before retrying (uhoh-itsmaciek) (#941)
+
 === 4.19.0 (2015-02-01)
 
 * Make jdbc/sqlanywhere correctly set :auto_increment entry in schema hashes (jeremyevans)

data/doc/association_basics.rdoc

@@ -268,9 +268,9 @@ an example of a directed graph:
   #   :name       \----- :predecessor_id
 
   class Node
-    many_to_many :direct_successors, :left_key=>:successor_id,
+    many_to_many :direct_predecessors, :left_key=>:successor_id,
       :right_key=>:predecessor_id, :join_table=>:edges, :class=>self
-    many_to_many :direct_predecessors, :right_key=>:successor_id,
+    many_to_many :direct_successors, :right_key=>:successor_id,
       :left_key=>:predecessor_id, :join_table=>:edges, :class=>self
   end
 
@@ -886,6 +886,22 @@ that returns all albums of an artist that went gold (sold at least
     ds.where{copies_sold > 500000}
   end
 
+The result of the block is cached as an optimization.  One of the side
+effects of that is that if your block depends on external state, it won't
+work correctly unless you setup a delayed evaluation.  For example:
+
+  Artist.one_to_many :gold_albums, :class=>:Album do |ds|
+    ds.where{copies_sold > $gold_limit}
+  end
+
+In this case if you change <tt>$gold_limit</tt> later, the changes won't
+effect the association.  If you want to pick up changes to <tt>$gold_limit</tt>,
+you need to setup a delayed evaluation:
+
+  Artist.one_to_many :gold_albums, :class=>:Album do |ds|
+    ds.where{copies_sold > Sequel.delay{$gold_limit}}
+  end
+
 ==== :class
 
 This is the class of the associated objects that will be used.  It's
@@ -1719,6 +1735,15 @@ This is usually used if the association dataset depends on specific values in
 model instance that would not be valid when eager loading for multiple
 instances.
 
+==== :instance_specific
+
+This allows you to override the setting of whether the dataset contains instance
+specific code.  For example, if you are passing a block to the association,
+Sequel sets this to true by default, which disables some optimizations that
+would be invalid if the association is instance specific.  If you know that the
+block does not contain instance specific code, you can set this to false to
+reenable the optimizations.
+
 ==== :cartesian_product_number 
 
 The number of joins completed by this association that could cause more

data/doc/release_notes/4.20.0.txt

@@ -0,0 +1,79 @@
+= New Features
+
+* A :before_retry option has been added to Database#transaction, which
+  specifies a proc to call when retrying if the :retry_on option
+  is used.  This can be used to implement additional logging, sleeping
+  between retries, or other things.
+
+* The to_json method :root option in the json_serializer plugin can now
+  be a string value to specify the name for the object key, instead of
+  using the underscored model name.
+
+* Dataset#paged_each now returns an enumerator if not passed a block.
+
+* You can now set the :instance_specific association option to false.
+  Previously, it was automatically set to true in some cases.  If you
+  know the association does not depend on anything instance-specific
+  other than the foreign/primary key, setting this option can allow
+  Sequel to perform some additional optimizations.
+
+= Other Improvements
+
+* Eager loading queries are now skipped if there are no matching keys.
+  There was code to check this previously, but it was accidently
+  removed in an earlier refactoring.
+
+* Eager loading an association with a limit and an eager block and
+  cascaded associations now works correctly when the window_function
+  limit strategy is used (the default on databases that support
+  window functions).
+
+* Eager loading an association with a limit with an eager block now
+  works correctly on databases do not support window functions but do
+  support correlated subqueries.
+
+* The parent association is now set on associated objects when loading
+  descendants in the rcte_tree plugin.  This allows the parent method
+  on any of the descendants to work without issuing a database query.
+
+* The prepared_statements_associations plugin now only uses prepared
+  statements if association metadata is being cached.  Previously, it
+  would use prepared statements even if association metadata was not
+  cached, which could leak the prepared statements.
+
+* Model#dup now duplicates the associations hash for the object.
+
+* Model#freeze no longer validates an object if the the errors for the
+  object are already frozen.  The static_cache plugin now freezes the
+  errors before freezing the object, so that it doesn't validate the
+  object.  This can skip many database queries when the
+  auto_validations plugin is used and there is a unique constraint or
+  index on the related table.
+
+* AUTOINCREMENT is now used again on SQLite by default for primary
+  keys.  It was removed when :auto_increment was added to the schema
+  hashes, but the removal changed SQLite's behavior.  This restores
+  the previous behavior.
+
+* Microsoft SQL Server's bit type is now recognized as a boolean type
+  by the schema dumper.
+
+* The pg_enum extension's create_enum method can now be used in
+  reversible migrations.
+
+* set_column_type with the :auto_increment=>true option once again
+  works on MySQL.  It had been broken since Sequel started adding
+  :auto_increment to the schema hashes.
+
+* The mysql2 adapter now recognizes the :charset option as a synonym
+  for :encoding.
+
+* The swift adapter now respects database and application timezone
+  settings.
+
+= Backwards Compatibility
+
+* AssociationReflection#apply_ruby_eager_limit_strategy no longer
+  checks that the strategy is :ruby, callers are now expected to
+  check the value themselves.  This should only matter if you are
+  using custom association types.

data/doc/schema_modification.rdoc

@@ -142,7 +142,7 @@ as it's third argument.  A simple example is:
 
 +foreign_key+ accepts the same options as +column+.  For example, to have a unique foreign key with varchar(16) type:
 
-  foreign_key :column_name, :unique=>true, :type=>'varchar(16)'
+  foreign_key :column_name, :table, :unique=>true, :type=>'varchar(16)'
 
 +foreign_key+ also accepts some specific options:
 

data/doc/sharding.rdoc

@@ -41,6 +41,16 @@ is the simplest configuration:
 This will use the slave_server for SELECT queries and master_server for
 other queries.
 
+If you want to ensure your queries are going to a specific database, you
+can force this for a given query by using the .server method and passing 
+the symbol name defined in the connect options. For example:
+
+  # Force the SELECT to run on the master
+  DB[:users].server(:default).all
+
+  # Force the SELECT to run on the read-only slave
+  DB[:users].server(:read_only).all
+
 === Multiple Read-Only Slaves, Single Master
 
 Let's say you have 4 slave database servers with names slave_server0,

data/lib/sequel/adapters/mysql2.rb

@@ -32,6 +32,7 @@ module Sequel
         opts[:username] ||= opts.delete(:user)
         opts[:flags] ||= 0
         opts[:flags] |= ::Mysql2::Client::FOUND_ROWS if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
+        opts[:encoding] ||= opts[:charset]
         conn = ::Mysql2::Client.new(opts)
         conn.query_options.merge!(:symbolize_keys=>true, :cache_rows=>false)
 
@@ -41,7 +42,7 @@ module Sequel
         # in case the READ_DEFAULT_GROUP overrode the provided encoding.
         # Doesn't work across implicit reconnects, but Sequel doesn't turn on
         # that feature.
-        if encoding = opts[:encoding] || opts[:charset]
+        if encoding = opts[:encoding]
           sqls.unshift("SET NAMES #{conn.escape(encoding.to_s)}")
         end
 

data/lib/sequel/adapters/shared/mysql.rb

@@ -215,7 +215,9 @@ module Sequel
             raise Error, "cannot determine database type to use for CHANGE COLUMN operation"
           end
           opts = op.merge(opts)
-          opts.delete(:auto_increment) if op[:auto_increment] == false
+          if op.has_key?(:auto_increment)
+            opts[:auto_increment] = op[:auto_increment]
+          end
           "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(opts)}"
         when :drop_constraint
           case op[:type]

data/lib/sequel/adapters/shared/sqlite.rb

@@ -160,10 +160,8 @@ module Sequel
       end
 
       # Override the default setting for whether to use timezones in timestamps.
-      # For backwards compatibility, it is set to +true+ by default.
-      # Anyone wanting to use SQLite's datetime functions should set it to +false+
-      # using this method.  It's possible that the default will change in a future version,
-      # so anyone relying on timezones in timestamps should set this to +true+.
+      # It is set to +false+ by default, as SQLite's date/time methods do not
+      # support timezones in timestamps.
       attr_writer :use_timestamp_timezones
 
       # SQLite supports timezones in timestamps, since it just stores them as strings,
@@ -282,11 +280,6 @@ module Sequel
         end
       end
 
-      # SQLite does not need to specify AUTOINCREMENT, integer primary keys are automatically auto incrementing.
-      def auto_increment_sql
-        ''
-      end
-
       def begin_new_transaction(conn, opts)
         mode = opts[:mode] || @transaction_mode
         sql = TRANSACTION_MODE[mode] or raise Error, "transaction :mode must be one of: :deferred, :immediate, :exclusive, nil"
@@ -353,6 +346,7 @@ module Sequel
         cols.each do |c|
           c[:default] = LiteralString.new(c[:default]) if c[:default]
           c[:type] = c[:db_type]
+          c.delete(:auto_increment)
         end
         cols
       end

data/lib/sequel/adapters/swift.rb

@@ -135,10 +135,18 @@ module Sequel
           @columns = res.fields.map do |c|
             col_map[c] = output_identifier(c)
           end
+          tz = db.timezone if Sequel.application_timezone
           res.each do |r|
             h = {}
             r.each do |k, v|
-              h[col_map[k]] = v.is_a?(StringIO) ? SQL::Blob.new(v.read) : v
+              h[col_map[k]] = case v
+              when StringIO
+                SQL::Blob.new(v.read)
+              when DateTime
+                tz ? Sequel.database_to_application_timestamp(Sequel.send(:convert_input_datetime_no_offset, v, tz)) : v
+              else
+                v
+              end
             end
             yield h
           end

data/lib/sequel/database/transactions.rb

@@ -45,6 +45,9 @@ module Sequel
     # :num_retries :: The number of times to retry if the :retry_on option is used.
     #                 The default is 5 times.  Can be set to nil to retry indefinitely,
     #                 but that is not recommended.
+    # :before_retry :: Proc to execute before rertrying if the :retry_on option is used.
+    #                  Called with two arguments: the number of retry attempts (counting
+    #                  the current one) and the error the last attempt failed with.
     # :prepare :: A string to use as the transaction identifier for a
     #             prepared transaction (two-phase commit), if the database/adapter
     #             supports prepared transactions.
@@ -57,7 +60,8 @@ module Sequel
     # :rollback :: Can the set to :reraise to reraise any Sequel::Rollback exceptions
     #              raised, or :always to always rollback even if no exceptions occur
     #              (useful for testing).
-    # :server :: The server to use for the transaction.
+    # :server :: The server to use for the transaction. Set to :default, :read_only, or
+    #            whatever symbol you used in the connect string when naming your servers.
     # :savepoint :: Whether to create a new savepoint for this transaction,
     #               only respected if the database/adapter supports savepoints.  By
     #               default Sequel will reuse an existing transaction, so if you want to
@@ -73,13 +77,17 @@ module Sequel
     #                 and :remote_write (9.2+).
     def transaction(opts=OPTS, &block)
       if retry_on = opts[:retry_on]
-        num_retries = opts.fetch(:num_retries, 5)
+        tot_retries = opts.fetch(:num_retries, 5)
+        num_retries = 0 unless tot_retries.nil?
         begin
           transaction(opts.merge(:retry_on=>nil, :retrying=>true), &block)
-        rescue *retry_on
+        rescue *retry_on => e
           if num_retries
-            num_retries -= 1
-            retry if num_retries >= 0
+            num_retries += 1
+            if num_retries <= tot_retries
+              opts[:before_retry].call(num_retries, e) if opts[:before_retry]
+              retry
+            end
           else
             retry
           end

data/lib/sequel/dataset/actions.rb

@@ -449,7 +449,7 @@ module Sequel
     #              for using an approach with a limit and offset for every page.  This can
     #              be set to :filter, which uses a limit and a filter that excludes
     #              rows from previous pages.  In order for this strategy to work, you must be
-    #              selecting the columns you are ordering by, and non of the columns can contain
+    #              selecting the columns you are ordering by, and none of the columns can contain
     #              NULLs.  Note that some Sequel adapters have optimized implementations that will
     #              use cursors or streaming regardless of the :strategy option used.
     # :filter_values :: If the :strategy=>:filter option is used, this option should be a proc
@@ -486,6 +486,9 @@ module Sequel
       unless @opts[:order]
         raise Sequel::Error, "Dataset#paged_each requires the dataset be ordered"
       end
+      unless block_given?
+        return enum_for(:paged_each, opts)
+      end
 
       total_limit = @opts[:limit]
       offset = @opts[:offset]

data/lib/sequel/dataset/query.rb

@@ -16,7 +16,7 @@ module Sequel
 
     # Which options don't affect the SQL generation.  Used by simple_select_all?
     # to determine if this is a simple SELECT * FROM table.
-    NON_SQL_OPTIONS = [:server, :defaults, :overrides, :graph, :eager_graph, :graph_aliases]
+    NON_SQL_OPTIONS = [:server, :defaults, :overrides, :graph, :eager, :eager_graph, :graph_aliases]
     
     # These symbols have _join methods created (e.g. inner_join) that
     # call join_table with the symbol, passing along the arguments and

data/lib/sequel/extensions/constraint_validations.rb

@@ -264,7 +264,7 @@ module Sequel
 
     private
 
-    # Modify the default create_table generator to include
+    # Modify the default alter_table generator to include
     # the constraint validation methods.
     def alter_table_generator(&block)
       super do

data/lib/sequel/extensions/pg_enum.rb

@@ -37,6 +37,15 @@
 #   DB[:table_name].get(:column_name)
 #   # ['value1', 'value2']
 #
+# If the migration extension is loaded before this one (the order is important),
+# you can use create_enum in a reversible migration:
+#
+#   Sequel.migration do
+#     change do
+#       create_enum(:type_name, %w'value1 value2 value3')
+#     end
+#   end
+#
 # Finally, typecasting for enums is setup to cast to strings, which
 # allows you to use symbols in your model code.  Similar, you can provide
 # the enum values as symbols when creating enums using create_enum or
@@ -132,5 +141,15 @@ module Sequel
     end
   end
 
+  # support reversible create_enum statements if the migration extension is loaded
+  if defined?(MigrationReverser)
+    class MigrationReverser
+      private
+      def create_enum(name, _)
+        @actions << [:drop_enum, name]
+      end
+    end
+  end
+
   Database.register_extension(:pg_enum, Postgres::EnumDatabaseMethods)
 end

data/lib/sequel/extensions/schema_dumper.rb

@@ -31,7 +31,7 @@ module Sequel
         {:type=>Bignum}
       when /\A(?:real|float|double(?: precision)?|double\(\d+,\d+\)(?: unsigned)?)\z/o
         {:type=>Float}
-      when 'boolean'
+      when 'boolean', 'bit'
         {:type=>TrueClass}
       when /\A(?:(?:tiny|medium|long|n)?text|clob)\z/o
         {:type=>String, :text=>true}

data/lib/sequel/model/associations.rb

@@ -144,15 +144,13 @@ module Sequel
         # If the ruby eager limit strategy is being used, slice the array using the slice
         # range to return the object(s) at the correct offset/limit.
         def apply_ruby_eager_limit_strategy(rows)
-          if eager_limit_strategy == :ruby
-            name = self[:name]
-            if returns_array?
-              range = slice_range
-              rows.each{|o| o.associations[name] = o.associations[name][range] || []}
-            elsif slice_range
-              offset = slice_range.begin
-              rows.each{|o| o.associations[name] = o.associations[name][offset]}
-            end
+          name = self[:name]
+          if returns_array?
+            range = slice_range
+            rows.each{|o| o.associations[name] = o.associations[name][range] || []}
+          elsif slice_range
+            offset = slice_range.begin
+            rows.each{|o| o.associations[name] = o.associations[name][offset]}
           end
         end
 
@@ -241,18 +239,24 @@ module Sequel
         def eager_load_results(eo, &block)
           rows = eo[:rows]
           initialize_association_cache(rows) unless eo[:initialize_rows] == false
+          if eo[:id_map]
+            ids = eo[:id_map].keys
+            return ids if ids.empty?
+          end
           strategy = eager_limit_strategy
           cascade = eo[:associations]
 
           if eo[:eager_block] || eo[:loader] == false
             strategy = true_eager_graph_limit_strategy if strategy == :union
+            # Correlated subqueries are not supported for regular eager loading
+            strategy = :ruby if strategy == :correlated_subquery
             objects = apply_eager_limit_strategy(eager_loading_dataset(eo), strategy).all
           elsif strategy == :union
             objects = []
             ds = associated_dataset
             loader = union_eager_loader
             joiner = " UNION ALL "
-            eo[:id_map].keys.each_slice(subqueries_per_union).each do |slice|
+            ids.each_slice(subqueries_per_union).each do |slice|
               objects.concat(ds.with_sql(slice.map{|k| loader.sql(*k)}.join(joiner)).to_a)
             end
             ds = ds.eager(cascade) if cascade
@@ -260,11 +264,13 @@ module Sequel
           else
             loader = placeholder_eager_loader
             loader = loader.with_dataset{|dataset| dataset.eager(cascade)} if cascade
-            objects = loader.all(eo[:id_map].keys)
+            objects = loader.all(ids)
           end
 
           objects.each(&block)
-          apply_ruby_eager_limit_strategy(rows)
+          if strategy == :ruby
+            apply_ruby_eager_limit_strategy(rows)
+          end
         end
 
         # The key to use for the key hash when eager loading
@@ -1651,7 +1657,7 @@ module Sequel
 
           opts = orig_opts.merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
           opts[:block] = block if block
-          if block || orig_opts[:block] || orig_opts[:dataset]
+          if !opts.has_key?(:instance_specific) && (block || orig_opts[:block] || orig_opts[:dataset])
             # It's possible the association is instance specific, in that it depends on
             # values other than the foreign key value.  This needs to be checked for
             # in certain places to disable optimizations.
@@ -2210,6 +2216,13 @@ module Sequel
           end
         end
 
+        # Duplicate the associations hash when duplicating the object.
+        def initialize_copy(other)
+          super
+          @associations = @associations.dup if @associations
+          self
+        end
+
         # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
         def load_associated_objects(opts, dynamic_opts=nil)
           if dynamic_opts == true or dynamic_opts == false or dynamic_opts == nil

data/lib/sequel/model/base.rb

@@ -1329,9 +1329,10 @@ module Sequel
       def freeze
         values.freeze
         changed_columns.freeze
-        errors
-        validate
-        errors.freeze
+        unless errors.frozen?
+          validate
+          errors.freeze
+        end
         this.freeze if !new? && model.primary_key
         super
       end

data/lib/sequel/plugins/json_serializer.rb

@@ -253,7 +253,9 @@ module Sequel
         # :only :: Symbol or Array of Symbols of columns to only
         #          include in the JSON output, ignoring all other
         #          columns.
-        # :root :: Qualify the JSON with the name of the object.
+        # :root :: Qualify the JSON with the name of the object.  If a
+        #          string is given, use the string as the key, otherwise
+        #          use an underscored version of the model's name.
         def to_json(*a)
           if opts = a.first.is_a?(Hash)
             opts = model.json_serializer_opts.merge(a.first)
@@ -286,7 +288,12 @@ module Sequel
               Array(inc).each{|c| h[c.to_s] = send(c)}
             end
           end
-          h = {model.send(:underscore, model.to_s) => h} if opts[:root]
+
+          if root = opts[:root]
+            root = model.send(:underscore, model.to_s) unless root.is_a?(String)
+            h = {root => h}
+          end
+
           Sequel.object_to_json(h, *a)
         end
       end
@@ -299,16 +306,13 @@ module Sequel
         #
         # :array :: An array of instances.  If this is not provided,
         #           calls #all on the receiver to get the array.
-        # :root :: If set to :collection, only wraps the collection
-        #          in a root object.  If set to :instance, only wraps
+        # :root :: If set to :collection, wraps the collection
+        #          in a root object using the pluralized, underscored model
+        #          name as the key.  If set to :instance, only wraps
         #          the instances in a root object.  If set to :both,
         #          wraps both the collection and instances in a root
-        #          object.  Unfortunately, for backwards compatibility,
-        #          if this option is true and doesn't match one of those
-        #          symbols, it defaults to both.  That may change in a
-        #          future version, so for forwards compatibility, you
-        #          should pick a specific symbol for your desired
-        #          behavior.
+        #          object.  If set to a string, wraps the collection in
+        #          a root object using the string as the key.  
         def to_json(*a)
           if opts = a.first.is_a?(Hash)
             opts = model.json_serializer_opts.merge(a.first)
@@ -317,15 +321,17 @@ module Sequel
             opts = model.json_serializer_opts
           end
 
-          collection_root = case opts[:root]
+          case collection_root = opts[:root]
           when nil, false, :instance
-            false
-          when :both
-            true
+            collection_root = false
           else
             opts = opts.dup
-            opts.delete(:root)
-            true
+            unless collection_root == :both
+              opts.delete(:root)
+            end
+            unless collection_root.is_a?(String)
+              collection_root = model.send(:pluralize, model.send(:underscore, model.to_s))
+            end
           end
 
           res = if row_proc 
@@ -341,7 +347,7 @@ module Sequel
           end
 
           if collection_root
-            Sequel.object_to_json({model.send(:pluralize, model.send(:underscore, model.to_s)) => res}, *a)
+            Sequel.object_to_json({collection_root => res}, *a)
           else
             Sequel.object_to_json(res, *a)
           end

data/lib/sequel/plugins/prepared_statements_associations.rb

@@ -50,6 +50,7 @@ module Sequel
         # that, given appropriate bound variables, the prepared statement will work correctly for any
         # instance.  Return false if such a prepared statement cannot be created.
         def association_prepared_statement(opts, assoc_bv)
+          return unless model.cache_associations
           opts.send(:cached_fetch, :prepared_statement) do
             unless opts[:instance_specific]
               ds, bv = _associated_dataset(opts, {}).unbind

data/lib/sequel/plugins/rcte_tree.rb

@@ -272,7 +272,11 @@ module Sequel
               end
             end
             children_map.each do |parent_id, objs|
-              parent_map[parent_id].associations[childrena] = objs
+              parent_obj = parent_map[parent_id]
+              parent_obj.associations[childrena] = objs
+              objs.each do |obj|
+                obj.associations[parent] = parent_obj
+              end
             end
           end
         end
@@ -333,7 +337,12 @@ module Sequel
             (children_map[key_conv[obj]] ||= []) << obj
           end
           children_map.each do |parent_id, objs|
-            parent_map[parent_id].associations[childrena] = objs.uniq
+            objs = objs.uniq
+            parent_obj = parent_map[parent_id]
+            parent_obj.associations[childrena] = objs
+            objs.each do |obj|
+              obj.associations[parent] = parent_obj
+            end
           end
         end
         model.one_to_many descendants, d

data/lib/sequel/plugins/static_cache.rb

@@ -12,7 +12,10 @@ module Sequel
     # instances.  This is slower as it requires creating new objects, but it allows
     # you to make changes to the object and save them.  If you set the option to false,
     # you are responsible for updating the cache manually (the pg_static_cache_updater
-    # extension can handle this automatically).
+    # extension can handle this automatically).  Note that it is not safe to use the
+    # :frozen=>false option if you are mutating column values directly.  If you are
+    # mutating column values, you should also override Model.call to dup each mutable
+    # column value to ensure it is not shared by other instances.
     #
     # The caches this plugin creates are used for the following things:
     #
@@ -180,7 +183,10 @@ module Sequel
         def load_cache
           a = dataset.all
           h = {}
-          a.each{|o| h[o.pk.freeze] = o.freeze}
+          a.each do |o|
+            o.errors.freeze
+            h[o.pk.freeze] = o.freeze
+          end
           @all = a.freeze
           @cache = h.freeze
         end

data/lib/sequel/version.rb

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

data/spec/adapters/mysql_spec.rb

@@ -90,6 +90,13 @@ describe "MySQL", '#create_table' do
     @db.create_table!(:dolls){column :t, "enum('a', 'b', 'c', 'd')", :default=>'b'}
     @db.schema(:dolls).first.last[:ruby_default].should == 'b'
   end
+
+  specify "should allow setting auto_increment for existing column" do
+    @db.create_table(:dolls){Integer :a, :primary_key=>true}
+    @db.schema(:dolls).first.last[:auto_increment].should == false
+    @db.set_column_type :dolls, :a, Integer, :auto_increment=>true
+    @db.schema(:dolls).first.last[:auto_increment].should == true
+  end
 end
 
 if [:mysql, :mysql2].include?(DB.adapter_scheme)

data/spec/core/database_spec.rb

@@ -682,6 +682,19 @@ shared_examples_for "Database#transaction" do
     a.should == [1] * 100
   end
   
+  specify "should support :before_retry option for invoking callback before retrying" do
+    a, errs, calls = [], [], []
+    retryer = proc{|n, err| calls << n; errs << err }
+    @db.transaction(:retry_on=>Sequel::DatabaseDisconnectError, :before_retry => retryer) do
+      a << 1; raise Sequel::DatabaseDisconnectError if a.length < 3
+    end
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
+    a.should == [1, 1, 1]
+    errs.count.should == 2
+    errs.each { |e| e.class.should == Sequel::DatabaseDisconnectError }
+    calls.should == [1, 2]
+  end
+  
   specify "should raise an error if attempting to use :retry_on inside another transaction" do
     proc{@db.transaction{@db.transaction(:retry_on=>Sequel::ConstraintViolation){}}}.should raise_error(Sequel::Error)
     @db.sqls.should == ['BEGIN', 'ROLLBACK']

data/spec/core/dataset_spec.rb

@@ -4641,6 +4641,11 @@ describe "Dataset#paged_each" do
     @rows.should == @db
   end
 
+  it "should return enumerator when called without block" do
+    @ds.paged_each.each(&@proc)
+    @rows.should == @db
+  end
+
   it "should respect the row_proc" do
     @ds.row_proc = lambda{|row| {:x=>row[:x]*2}}
     @ds.paged_each(&@proc)

data/spec/extensions/json_serializer_spec.rb

@@ -207,6 +207,11 @@ describe "Sequel::Plugins::JsonSerializer" do
     @album.to_json(:root=>true, :only => :name).to_s.should == '{"album":{"name":"RF"}}'
   end
   
+  it "should handle the :root option with a string to qualify single records using the string as the key" do
+    @album.to_json(:root=>"foo", :except => [:name, :artist_id]).to_s.should == '{"foo":{"id":1}}'
+    @album.to_json(:root=>"bar", :only => :name).to_s.should == '{"bar":{"name":"RF"}}'
+  end
+  
   it "should handle the :root=>:both option to qualify a dataset of records" do
     Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
     Album.dataset.to_json(:root=>:both, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
@@ -223,6 +228,12 @@ describe "Sequel::Plugins::JsonSerializer" do
     Album.dataset.to_json(:root=>:instance, :only => :id).to_s.should == '[{"album":{"id":1}},{"album":{"id":1}}]'
   end
 
+  it "should handle the :root=>string option to qualify just the collection using the string as the key" do
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
+    Album.dataset.to_json(:root=>"foos", :only => :id).to_s.should == '{"foos":[{"id":1},{"id":1}]}'
+    Album.dataset.to_json(:root=>"bars", :only => :id).to_s.should == '{"bars":[{"id":1},{"id":1}]}'
+  end
+
   it "should store the default options in json_serializer_opts" do
     Album.json_serializer_opts.should == {:naked=>true}
     c = Class.new(Album)

data/spec/extensions/pg_enum_spec.rb

@@ -1,6 +1,8 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-describe "pg_inet extension" do
+Sequel.extension :migration
+
+describe "pg_enum extension" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @db.extend(Module.new do
@@ -61,4 +63,30 @@ describe "pg_inet extension" do
     @db.add_enum_value(:foo, :a, :if_not_exists=>true)
     @db.sqls.first.should == "ALTER TYPE foo ADD VALUE IF NOT EXISTS 'a'"
   end
+
+  it "should reverse a create_enum directive in a migration" do
+    c = Class.new do
+      attr_reader :actions
+      def initialize(&block)
+        @actions = []
+      end
+      def method_missing(*args)
+        @actions << args
+      end
+    end
+
+    db = c.new
+
+    p = Proc.new do
+      create_enum(:type_name, %w'value1 value2 value3')
+    end
+
+    Sequel.migration{change(&p)}.apply(db, :up)
+    Sequel.migration{change(&p)}.apply(db, :down)
+
+    db.actions.should == [
+      [:create_enum, :type_name, ["value1", "value2", "value3"] ],
+      [:drop_enum, :type_name]
+    ]
+  end
 end

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -90,6 +90,14 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
     @db.sqls.should == []
   end
 
+  specify "should run a regular query if not caching association metadata" do
+    @Artist.cache_associations = false
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @Artist.load(:id=>1).album
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) LIMIT 1"]
+  end
+
   specify "should run a regular query if there is a callback" do
     @Artist.load(:id=>1).albums(proc{|ds| ds})
     @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]

data/spec/extensions/rcte_tree_spec.rb

@@ -91,14 +91,17 @@ describe Sequel::Model, "rcte_tree" do
     @o.associations[:p].associations[:p].associations[:p].associations.fetch(:p, 1).should == nil
   end
   
-  it "should add all children associations when lazily loading descendants" do
+  it "should add all parent and children associations when lazily loading descendants" do
     @c.plugin :rcte_tree
     @ds._fetch = [[{:id=>3, :name=>'??', :parent_id=>1}, {:id=>1, :name=>'A', :parent_id=>2}, {:id=>4, :name=>'B', :parent_id=>2}, {:id=>5, :name=>'?', :parent_id=>3}]]
     @o.descendants.should == [@c.load(:id=>3, :name=>'??', :parent_id=>1), @c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2), @c.load(:id=>5, :name=>'?', :parent_id=>3)]
     @o.associations[:children].should == [@c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2)]
     @o.associations[:children].map{|c1| c1.associations[:children]}.should == [[@c.load(:id=>3, :name=>'??', :parent_id=>1)], []]
+    @o.associations[:children].map{|c1| c1.associations[:parent]}.should == [@o, @o]
     @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children]}}.should == [[[@c.load(:id=>5, :name=>'?', :parent_id=>3)]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:parent]}}.should == [[@o.children.first], []]
     @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:children]}}}.should == [[[[]]], []]
+    @o.associations[:children].map{|c1| c1.associations[:children].map{|c2| c2.associations[:children].map{|c3| c3.associations[:parent]}}}.should == [[[@o.children.first.children.first]], []]
   end
   
   it "should add all children associations when lazily loading descendants and giving options" do
@@ -182,7 +185,9 @@ describe Sequel::Model, "rcte_tree" do
       [@c.load(:id=>4, :name=>'?', :parent_id=>7), @c.load(:id=>5, :name=>'?', :parent_id=>4)]]
     os.map{|o| o.children}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
+    os.map{|o1| o1.children.map{|o2| o2.parent}}.should == [[os[0], os[0]], [os[1]], [os[2]]]
     os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
+    os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.parent}}}.should == [[[os[0].children[0]], []], [[]], [[os[2].children[0]]]]
     @db.sqls.should == []
   end
   

data/spec/extensions/schema_dumper_spec.rb

@@ -647,7 +647,7 @@ END_MIG
       %w"nvarchar ntext smalldatetime smallmoney binary varbinary nchar" +
       ["timestamp(6) without time zone", "timestamp(6) with time zone", 'mediumint(10) unsigned', 'int(9) unsigned',
        'int(10) unsigned', "int(12) unsigned", 'bigint unsigned', 'tinyint(3) unsigned', 'identity', 'int identity'] +
-      %w"integer(10)"
+      %w"integer(10) bit"
     @d.meta_def(:schema) do |t, *o|
       i = 0
       types.map{|x| [:"c#{i+=1}", {:db_type=>x, :allow_null=>true}]}
@@ -726,6 +726,7 @@ create_table(:x) do
   Integer :c70
   Integer :c71
   Integer :c72
+  TrueClass :c73
   
   check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c64), 0)
   check Sequel::SQL::BooleanExpression.new(:>=, Sequel::SQL::Identifier.new(:c65), 0)

data/spec/extensions/static_cache_spec.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
+describe "Sequel::Plugins::StaticCache" do
   before do
     @db = Sequel.mock
     @db.fetch = [{:id=>1}, {:id=>2}]
@@ -9,6 +9,12 @@ describe "Sequel::Plugins::StaticCache with :frozen=>false option" do
     @c.columns :id, :name
   end
 
+  it "should not attempt to validate objects" do
+    @c.send(:define_method, :validate){errors.add(:name, 'bad')}
+    proc{@c.plugin(:static_cache)}.should_not raise_error
+    @c.map{|o| o.valid?}.should == [true, true]
+  end
+
   shared_examples_for "Sequel::Plugins::StaticCache" do  
     it "should use a ruby hash as a cache of all model instances" do
       @c.cache.should == {1=>@c.load(:id=>1), 2=>@c.load(:id=>2)}

data/spec/integration/timezone_test.rb

@@ -39,7 +39,7 @@ describe "Sequel timezone support" do
     @db.drop_table(:t)
   end
 
-  cspecify "should support using UTC for database storage and local time for the application", [:swift], [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using UTC for database storage and local time for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :utc
     Sequel.application_timezone = :local
     test_timezone
@@ -48,7 +48,7 @@ describe "Sequel timezone support" do
     test_timezone
   end
 
-  cspecify "should support using local time for database storage and UTC for the application", [:swift], [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
+  cspecify "should support using local time for database storage and UTC for the application", [:tinytds], [:do, :mysql], [:do, :postgres], [:oracle] do
     Sequel.database_timezone = :local
     Sequel.application_timezone = :utc
     test_timezone
@@ -65,7 +65,7 @@ describe "Sequel timezone support" do
     test_timezone
   end
 
-  cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle], [:swift, :postgres], [:swift, :mysql] do
+  cspecify "should support using local time for both database storage and for application", [:do, :postgres], [:oracle] do
     Sequel.default_timezone = :local
     test_timezone
     Sequel.database_timezone = :utc

data/spec/model/associations_spec.rb

@@ -136,6 +136,14 @@ describe Sequel::Model, "associate" do
     proc{c.one_to_many :cs, :clone=>:c}.should raise_error(Sequel::Error)
   end
 
+  it "should allow overriding the :instance_specific option" do
+    c = Class.new(Sequel::Model(:c))
+    c.many_to_one :c, :instance_specific=>true
+    c.association_reflection(:c)[:instance_specific].should == true
+    c.many_to_one :c, :instance_specific=>false do |ds| ds end
+    c.association_reflection(:c)[:instance_specific].should == false
+  end
+
   it "should allow cloning of one_to_many to one_to_one associations and vice-versa" do
     c = Class.new(Sequel::Model(:c))
     c.one_to_one :c
@@ -4207,12 +4215,21 @@ describe "Model#freeze" do
     Album::B.dataset._fetch = {:album_id=>1, :id=>2}
     @o.b.should == Album::B.load(:id=>2, :album_id=>1)
     @o.associations[:b].should be_nil
+
+    @o = @o.dup
+    @o.b.should == Album::B.load(:id=>2, :album_id=>1)
+    @o.associations[:b].should == Album::B.load(:id=>2, :album_id=>1)
   end
 
   it "should not break reciprocal associations" do
     b = Album::B.load(:id=>2, :album_id=>nil)
     b.album = @o
     @o.associations[:b].should be_nil
+
+    @o = @o.dup
+    b = Album::B.load(:id=>2, :album_id=>nil)
+    b.album = @o
+    @o.associations[:b].should == Album::B.load(:id=>2, :album_id=>1)
   end
 end
 

data/spec/model/eager_loading_spec.rb

@@ -131,6 +131,16 @@ describe Sequel::Model, "#eager" do
     DB.sqls.should == []
   end
   
+  it "should skip eager loading for a many_to_one association with no matching keys" do
+    EagerAlbum.dataset._fetch = [{:id=>1, :band_id=>nil}]
+    a = EagerAlbum.eager(:band).all
+    DB.sqls.should == ['SELECT * FROM albums']
+    a.should == [EagerAlbum.load(:id => 1, :band_id => nil)]
+    a.first.associations.fetch(:band).should == nil
+    a.first.band.should == nil
+    DB.sqls.should == []
+  end
+  
   it "should eagerly load a single many_to_one association with the same name as the column" do
     EagerAlbum.def_column_alias(:band_id_id, :band_id)
     EagerAlbum.many_to_one :band_id, :key_column=>:band_id, :class=>EagerBand
@@ -1055,6 +1065,35 @@ describe Sequel::Model, "#eager" do
     DB.sqls.should == []
   end
 
+  it "should allow cascading of eager loading with custom callback with symbol value when association has a limit" do
+    EagerAlbum.dataset._fetch = (1..11).map{|i| {:band_id=>2, :id=>i}}
+    EagerTrack.dataset._fetch = [{:id=>3, :album_id=>1}]
+    a = EagerBand.eager(:top_10_albums=>{proc{|ds| ds.select(:id, :name)}=>:tracks}).all
+    a.should == [EagerBand.load(:id => 2)]
+    sqls = DB.sqls
+    sqls.pop.should =~ /SELECT \* FROM tracks WHERE \(tracks.album_id IN \((\d+, ){10}\d+\)\)/
+    sqls.should == ['SELECT * FROM bands', 'SELECT id, name FROM albums WHERE (albums.band_id IN (2))']
+    a = a.first
+    a.top_10_albums.should == (1..10).map{|i| EagerAlbum.load(:band_id=>2, :id=>i)}
+    a.top_10_albums.map{|x| x.tracks}.should == [[EagerTrack.load(:id => 3, :album_id=>1)]] + ([[]] * 9)
+    DB.sqls.should == []
+  end
+
+  it "should allow cascading of eager loading with custom callback with symbol value when association has a limit when using window function eager limit strategy" do
+    def (EagerAlbum.dataset).supports_window_functions?() true end
+    EagerAlbum.dataset._fetch = {:band_id=>2, :id=>1}
+    EagerTrack.dataset._fetch = [{:id=>3, :album_id=>1}]
+    a = EagerBand.eager(:top_10_albums=>{proc{|ds| ds.select(:id, :name)}=>:tracks}).all
+    a.should == [EagerBand.load(:id => 2)]
+    DB.sqls.should == ['SELECT * FROM bands',
+      'SELECT * FROM (SELECT id, name, row_number() OVER (PARTITION BY albums.band_id) AS x_sequel_row_number_x FROM albums WHERE (albums.band_id IN (2))) AS t1 WHERE (x_sequel_row_number_x <= 10)',
+      'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
+    a = a.first
+    a.top_10_albums.should == [EagerAlbum.load(:band_id=>2, :id=>1)]
+    a.top_10_albums.first.tracks.should == [EagerTrack.load(:id => 3, :album_id=>1)]
+    DB.sqls.should == []
+  end
+
   it "should allow cascading of eager loading with custom callback with array value" do
     a = EagerTrack.eager(:album=>{proc{|ds| ds.select(:id, :band_id)}=>[:band, :band_name]}).all
     a.should == [EagerTrack.load(:id => 3, :album_id => 1)]

data/spec/model/record_spec.rb

@@ -446,6 +446,15 @@ describe "Model#freeze" do
     o.valid?.should == false
   end
 
+  it "should not call validate if errors is already frozen" do
+    @o.valid?.should == true
+    o = Album.new
+    o.errors.freeze
+    def o.validate() errors.add(:foo, '') end
+    proc{o.freeze}.should_not raise_error
+    o.valid?.should == true
+  end
+
   it "should raise an Error if trying to save/destroy/delete/refresh" do
     proc{@o.save}.should raise_error(Sequel::Error)
     proc{@o.destroy}.should raise_error(Sequel::Error)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel
 version: !ruby/object:Gem::Version
-  version: 4.19.0
+  version: 4.20.0
 platform: ruby
 authors:
 - Jeremy Evans
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-01 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -192,6 +192,7 @@ extra_rdoc_files:
 - doc/release_notes/4.17.0.txt
 - doc/release_notes/4.18.0.txt
 - doc/release_notes/4.19.0.txt
+- doc/release_notes/4.20.0.txt
 files:
 - CHANGELOG
 - MIT-LICENSE
@@ -299,6 +300,7 @@ files:
 - doc/release_notes/4.18.0.txt
 - doc/release_notes/4.19.0.txt
 - doc/release_notes/4.2.0.txt
+- doc/release_notes/4.20.0.txt
 - doc/release_notes/4.3.0.txt
 - doc/release_notes/4.4.0.txt
 - doc/release_notes/4.5.0.txt