sequel 4.31.0 → 4.32.0

data/lib/sequel/extensions/pg_enum.rb

@@ -52,6 +52,8 @@
 # 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
 # add_enum_value.
+#
+# Related module: Sequel::Postgres::EnumDatabaseMethods
 
 #
 module Sequel

data/lib/sequel/extensions/pg_hstore.rb

@@ -80,11 +80,9 @@
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using hstore columns in CREATE/ALTER TABLE statements.
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using hstore
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension requires the delegate and strscan libraries.
+#
+# Related module: Sequel::Postgres::HStore
 
 require 'delegate'
 require 'strscan'

data/lib/sequel/extensions/pg_hstore_ops.rb

@@ -75,6 +75,8 @@
 # pg_hstore extension is loaded.  Methods representing expressions that return
 # PostgreSQL arrays will have the returned expression automatically wrapped in a
 # Postgres::ArrayOp if the pg_array_ops extension is loaded.
+#
+# Related module: Sequel::Postgres::HStoreOp
 
 #
 module Sequel

data/lib/sequel/extensions/pg_inet.rb

@@ -11,10 +11,6 @@
 #
 #   DB.extension :pg_inet
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using inet/cidr
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension integrates with the pg_array extension.  If you plan
 # to use the inet[] or cidr[] types, load the pg_array extension before
 # the pg_inet extension:
@@ -29,6 +25,8 @@
 #
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using inet/cidr columns in CREATE/ALTER TABLE statements.
+#
+# Related module: Sequel::Postgres::InetDatabaseMethods
 
 require 'ipaddr'
 Sequel.require 'adapters/utils/pg_types'

data/lib/sequel/extensions/pg_inet_ops.rb

@@ -56,6 +56,8 @@
 #
 # See the PostgreSQL network function and operator documentation for more
 # details on what these functions and operators do.
+#
+# Related module: Sequel::Postgres::InetOp
 
 require 'ipaddr'
 

data/lib/sequel/extensions/pg_interval.rb

@@ -17,10 +17,6 @@
 #
 #   DB.extension :pg_interval
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using interval
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # This extension integrates with the pg_array extension.  If you plan
 # to use arrays of interval types, load the pg_array extension before the
 # pg_interval extension:
@@ -36,6 +32,8 @@
 #
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using interval columns in CREATE/ALTER TABLE statements.
+#
+# Related module: Sequel::Postgres::IntervalDatabaseMethods
 
 require 'active_support/duration'
 Sequel.require 'adapters/utils/pg_types'

data/lib/sequel/extensions/pg_json.rb

@@ -45,10 +45,6 @@
 #
 #   DB.extension :pg_json
 #
-# If you are not using the native postgres adapter and are using json
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using json columns in CREATE/ALTER TABLE statements.
 #
@@ -62,6 +58,10 @@
 # Attempting to use other values (such as symbols) will not work correctly.
 #
 # This extension requires both the json and delegate libraries.
+#
+# Related modules: Sequel::Postgres::JSONArrayBase, Sequel::Postgres::JSONArray,
+# Sequel::Postgres::JSONArray, Sequel::Postgres::JSONBArray, Sequel::Postgres::JSONHashBase,
+# Sequel::Postgres::JSONHash, Sequel::Postgres::JSONBHash, Sequel::Postgres::JSONDatabaseMethods
 
 require 'delegate'
 require 'json'

data/lib/sequel/extensions/pg_json_ops.rb

@@ -80,6 +80,9 @@
 # In order to get the automatic conversion from a ruby array to a PostgreSQL array
 # (as shown in the #[] and #get_text examples above), you need to load the pg_array
 # extension.
+#
+# Related modules: Sequel::Postgres::JSONBaseOp,  Sequel::Postgres::JSONOp,
+# Sequel::Postgres::JSONBOp
 
 #
 module Sequel

data/lib/sequel/extensions/pg_loose_count.rb

@@ -17,6 +17,8 @@
 # To load the extension into the database:
 #
 #   DB.extension :pg_loose_count
+#
+# Related module: Sequel::Postgres::LooseCount
 
 #
 module Sequel

data/lib/sequel/extensions/pg_range.rb

@@ -47,10 +47,6 @@
 #
 #   DB.extension :pg_range
 #
-# If you are not using the native postgres or jdbc/postgresql adapters and are using range
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using range type columns in CREATE/ALTER TABLE statements.
 #
@@ -59,6 +55,8 @@
 # pg_range extension:
 #
 #   DB.extension :pg_array, :pg_range
+#
+# Related module: Sequel::Postgres::PGRange
 
 Sequel.require 'adapters/utils/pg_types'
 

data/lib/sequel/extensions/pg_range_ops.rb

@@ -53,6 +53,8 @@
 # If you are also using the pg_range extension, you should load it before
 # loading this extension.  Doing so will allow you to use PGArray#op to get
 # an RangeOp, allowing you to perform range operations on range literals.
+#
+# Related module: Sequel::Postgres::RangeOp
 
 #
 module Sequel

data/lib/sequel/extensions/pg_row.rb

@@ -76,14 +76,12 @@
 #   DB.conversion_procs.select{|k,v| v.is_a?(Sequel::Postgres::PGRow::Parser) && \
 #     v.converter && (v.converter.name.nil? || v.converter.name == '') }.map{|k,v| v}
 # 
-# If you are not using the native postgres or jdbc/postgresql adapters and are using composite types
-# types as model column values you probably should use the
-# pg_typecast_on_load plugin if the column values are returned as a string.
-#
 # See the {schema modification guide}[rdoc-ref:doc/schema_modification.rdoc]
 # for details on using row type columns in CREATE/ALTER TABLE statements.
 #
 # This extension requires both the strscan and delegate libraries.
+#
+# Related module: Sequel::Postgres::PGRow
 
 require 'delegate'
 require 'strscan'

data/lib/sequel/extensions/pg_row_ops.rb

@@ -80,6 +80,8 @@
 #                                      Sequel.pg_row_op(:b).splat(:b))
 #   # SELECT (a.*)::a, (b.*)::b FROM a INNER JOIN b ON (b.id = a.b_id)
 #   # => {:a=>{:id=>1, :b_id=>2}, :b=>{:id=>2}}
+#
+# Related module: Sequel::Postgres::PGRowOp
 
 #
 module Sequel

data/lib/sequel/extensions/pg_static_cache_updater.rb

@@ -63,6 +63,8 @@
 #   with the pg driver (the model classes do not have to
 #   use the same Database).
 # * Must be using a thread-safe connection pool (the default).
+#
+# Related module: Sequel::Postgres::StaticCacheUpdater
 
 #
 module Sequel

data/lib/sequel/extensions/pretty_table.rb

@@ -20,6 +20,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:pretty_table)
+#
+# Related module: Sequel::DatasetPrinter
 
 #
 module Sequel

data/lib/sequel/extensions/query.rb

@@ -19,6 +19,9 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:query)
+#
+# Related modules: Sequel::DatabaseQuery, Sequel::DatasetQuery,
+# Sequel::Dataset::Query
 
 #
 module Sequel

data/lib/sequel/extensions/query_literals.rb

@@ -17,11 +17,11 @@
 #   SELECT a, b, 2, FROM table GROUP BY a, b ORDER BY c
 #
 # This extension makes select, group, and order methods operate
-# like filter methods, which support the same interface.
-#
-# There are very few places where Sequel's default behavior is
-# desirable in this area, but for backwards compatibility, the
-# defaults won't be changed until the next major release.
+# like filter methods, which support the same interface.  Note
+# that this extension can add SQL injection vulnerabilities to existing
+# code if any of the strings passed to one of the supported
+# methods is derived from user input.  For that reason, it should
+# be used with caution.
 #
 # You can load this extension into specific datasets:
 #
@@ -32,6 +32,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:query_literals)
+#
+# Related module: Sequel::QueryLiterals
 
 #
 module Sequel

data/lib/sequel/extensions/round_timestamps.rb

@@ -4,9 +4,8 @@
 # values to the database's supported level of precision before literalizing
 # them.
 #
-# For example, if the database supports microsecond precision, and you give
-# it a Time value with greater than microsecond precision, it will round it
-# appropriately:
+# For example, if the database supports millisecond precision, and you give
+# it a Time value with microsecond precision, it will round it appropriately:
 #
 #   Time.at(1405341161.917999982833862)
 #   # default: 2014-07-14 14:32:41.917999
@@ -23,6 +22,8 @@
 # To round timestamps for all datasets on a single database:
 #
 #   DB.extension(:round_timestamps)
+#
+# Related module: Sequel::Dataset::RoundTimestamps
 
 unless RUBY_VERSION >= '1.9'
   # :nocov:

data/lib/sequel/extensions/schema_caching.rb

@@ -43,6 +43,8 @@
 # The cached schema is dumped in Marshal format, since it is the fastest
 # and it handles all ruby objects used in the schema hash.  Because of this,
 # you should not attempt to load the schema from a untrusted file.
+#
+# Related module: Sequel::SchemaCaching
 
 #
 module Sequel

data/lib/sequel/extensions/schema_dumper.rb

@@ -9,6 +9,8 @@
 # To load the extension:
 #
 #   DB.extension :schema_dumper
+#
+# Related module: Sequel::SchemaDumper
 
 Sequel.extension :eval_inspect
 

data/lib/sequel/extensions/select_remove.rb

@@ -13,6 +13,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:select_remove)
+#
+# Related module: Sequel::SelectRemove
 
 #
 module Sequel

data/lib/sequel/extensions/sequel_3_dataset_methods.rb

@@ -20,6 +20,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:sequel_3_dataset_methods)
+#
+# Related module: Sequel::Sequel3DatasetMethods
 
 #
 module Sequel

data/lib/sequel/extensions/server_block.rb

@@ -38,6 +38,9 @@
 #     DB[:a].server(:default).all # Uses shard1
 #     DB[:a].server(:read_only).all # Uses shard1
 #   end
+#
+# Related modules: Sequel::ServerBlock, Sequel::UnthreadedServerBlock,
+# Sequel::ThreadedServerBlock
 
 #
 module Sequel

data/lib/sequel/extensions/set_overrides.rb

@@ -15,6 +15,8 @@
 # is probably the desired behavior if you are using this extension:
 #
 #   DB.extension(:set_overrides)
+#
+# Related module: Sequel::SetOverrides
 
 #
 module Sequel

data/lib/sequel/extensions/split_array_nil.rb

@@ -32,6 +32,8 @@
 # To use this extension for all of a database's datasets:
 #
 #   DB.extension(:split_array_nil)
+#
+# Related module: Sequel::Dataset::SplitArrayNil
 
 #
 module Sequel

data/lib/sequel/extensions/thread_local_timezones.rb

@@ -35,6 +35,8 @@
 #   Sequel.application_timezone # => :utc
 #   Sequel.thread_application_timezone = :nil
 #   Sequel.application_timezone # => nil
+#
+# Related module: Sequel::ThreadLocalTimezones
 
 #
 module Sequel

data/lib/sequel/extensions/to_dot.rb

@@ -8,6 +8,8 @@
 # To load the extension:
 #
 #   Sequel.extension :to_dot
+#
+# Related module: Sequel::ToDot
 
 #
 module Sequel

data/lib/sequel/model/associations.rb

@@ -14,6 +14,7 @@ module Sequel
           @association_reflections = {}
           @autoreloading_associations = {}
           @cache_associations = true
+          @default_association_options = {}
         end
       end
 
@@ -489,40 +490,21 @@ module Sequel
         
         private
 
-        if defined?(RUBY_ENGINE) && RUBY_ENGINE != 'ruby'
-        # :nocov:
-          # On non-GVL rubies, assume the need to synchronize access.  Store the key
-          # in a special sub-hash that always uses this method to synchronize access.
-          def cached_fetch(key)
-            fetch(key) do
-              return yield unless h = self[:cache]
-              Sequel.synchronize{return h[key] if h.has_key?(key)}
-              value = yield
-              Sequel.synchronize{h[key] = value}
-            end
-          end
-
-          # Cache the value at the given key, synchronizing access.
-          def cached_set(key, value)
-            return unless h = self[:cache]
+        # On non-GVL rubies, assume the need to synchronize access.  Store the key
+        # in a special sub-hash that always uses this method to synchronize access.
+        def cached_fetch(key)
+          fetch(key) do
+            return yield unless h = self[:cache]
+            Sequel.synchronize{return h[key] if h.has_key?(key)}
+            value = yield
             Sequel.synchronize{h[key] = value}
           end
-        # :nocov:
-        else
-          # On MRI, use a plain fetch, since the GVL will synchronize access.
-          def cached_fetch(key)
-            fetch(key) do 
-              return yield unless h = self[:cache]
-              h.fetch(key){h[key] = yield}
-            end
-          end
+        end
 
-          # On MRI, just set the value at the key in the cache, since the GVL
-          # will synchronize access.
-          def cached_set(key, value)
-            return unless h = self[:cache]
-            h[key] = value
-          end
+        # Cache the value at the given key, synchronizing access.
+        def cached_set(key, value)
+          return unless h = self[:cache]
+          Sequel.synchronize{h[key] = value}
         end
 
         # The base dataset used for the association, before any order/conditions
@@ -1436,11 +1418,14 @@ module Sequel
         attr_reader :autoreloading_associations
 
         # Whether association metadata should be cached in the association reflection.  If not cached, it will be computed
-        # on demand.  In general you only want to set this to default when using code reloading.  When using code reloading,
+        # on demand.  In general you only want to set this to false when using code reloading.  When using code reloading,
         # setting this will make sure that if an associated class is removed or modified, this class will not hang on to
         # the previous class.
         attr_accessor :cache_associations
 
+        # The default options to use for all associations.
+        attr_accessor :default_association_options
+
         # The default :eager_limit_strategy option to use for limited or offset associations (default: true, causing Sequel
         # to use what it considers the most appropriate strategy).
         attr_accessor :default_eager_limit_strategy
@@ -1674,7 +1659,7 @@ module Sequel
             orig_opts = cloned_assoc[:orig_opts].merge(orig_opts)
           end
 
-          opts = orig_opts.merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
+          opts = default_association_options.merge(orig_opts).merge(:type => type, :name => name, :cache=>({} if cache_associations), :model => self)
           opts[:block] = block if block
           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
@@ -1757,7 +1742,7 @@ module Sequel
           associate(:one_to_one, name, opts, &block)
         end
 
-        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
+        Plugins.inherited_instance_variables(self, :@association_reflections=>:dup, :@autoreloading_associations=>:hash_dup, :@default_association_options=>:dup, :@cache_associations=>nil, :@default_eager_limit_strategy=>nil)
         Plugins.def_dataset_methods(self, [:eager, :eager_graph, :eager_graph_with_options, :association_join, :association_full_join, :association_inner_join, :association_left_join, :association_right_join])
         
         private
@@ -1818,7 +1803,6 @@ module Sequel
         # Configures many_to_many and one_through_one association reflection and adds the related association methods
         def def_many_to_many(opts)
           one_through_one = opts[:type] == :one_through_one
-          opts[:read_only] = true if one_through_one
           left = (opts[:left_key] ||= opts.default_left_key)
           lcks = opts[:left_keys] = Array(left)
           right = (opts[:right_key] ||= opts.default_right_key)
@@ -1872,21 +1856,54 @@ module Sequel
             end
           end
       
-          return if opts[:read_only] || one_through_one
+          return if opts[:read_only]
       
-          opts[:adder] ||= proc do |o|
-            h = {}
-            lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
-            rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
-            _join_table_dataset(opts).insert(h)
-          end
+          if one_through_one
+            opts[:setter] ||= proc do |o|
+              h = {}
+              lh = lcks.zip(lcpks.map{|k| get_column_value(k)})
+              jtds = _join_table_dataset(opts).where(lh)
 
-          opts[:remover] ||= proc do |o|
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
-          end
+              checked_transaction do
+                current = jtds.first
+
+                if o
+                  new_values = []
+                  rcks.zip(opts.right_primary_key_methods).each{|k, pk| new_values << (h[k] = o.get_column_value(pk))}
+                end
 
-          opts[:clearer] ||= proc do
-            _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+                if current
+                  current_values = rcks.map{|k| current[k]}
+                  jtds = jtds.where(rcks.zip(current_values))
+                  if o
+                    if current_values != new_values
+                      jtds.update(h)
+                    end
+                  else
+                    jtds.delete
+                  end
+                elsif o
+                  lh.each{|k,v| h[k] = v}
+                  jtds.insert(h)
+                end
+              end
+            end
+            opts[:_setter] = proc{|o| set_one_through_one_associated_object(opts, o)}
+          else 
+            opts[:adder] ||= proc do |o|
+              h = {}
+              lcks.zip(lcpks).each{|k, pk| h[k] = get_column_value(pk)}
+              rcks.zip(opts.right_primary_key_methods).each{|k, pk| h[k] = o.get_column_value(pk)}
+              _join_table_dataset(opts).insert(h)
+            end
+
+            opts[:remover] ||= proc do |o|
+              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)}) + rcks.zip(opts.right_primary_key_methods.map{|k| o.get_column_value(k)})).delete
+            end
+
+            opts[:clearer] ||= proc do
+              _join_table_dataset(opts).where(lcks.zip(lcpks.map{|k| get_column_value(k)})).delete
+            end
           end
         end
 
@@ -2242,18 +2259,34 @@ module Sequel
           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
-            dynamic_opts = {:reload=>dynamic_opts}
-          elsif dynamic_opts.respond_to?(:call)
-            dynamic_opts = {:callback=>dynamic_opts}
+        # Handle parsing of options when loading associations.  For historical
+        # reasons, you can pass true/false/nil or a callable argument to
+        # associations.  That will be going away in Sequel 5, but we'll still
+        # support it until then.
+        def load_association_objects_options(dynamic_opts, &block)
+          dynamic_opts = case dynamic_opts
+          when true, false, nil
+            {:reload=>dynamic_opts}
+          when Hash
+            Hash[dynamic_opts]
+          else
+            if dynamic_opts.respond_to?(:call)
+              {:callback=>dynamic_opts}
+            end
           end
+
           if block_given?
-            dynamic_opts = Hash[dynamic_opts].merge!(:callback=>Proc.new)
+            dynamic_opts[:callback] = block
           end
+
+          dynamic_opts
+        end
+
+        # Load the associated objects using the dataset, handling callbacks, reciprocals, and caching.
+        def load_associated_objects(opts, dynamic_opts=nil, &block)
+          dynamic_opts = load_association_objects_options(dynamic_opts, &block)
           name = opts[:name]
-          if associations.include?(name) and !dynamic_opts[:callback] and !dynamic_opts[:reload]
+          if associations.include?(name) && !dynamic_opts[:callback] && !dynamic_opts[:reload]
             associations[name]
           else
             objs = _load_associated_objects(opts, dynamic_opts)
@@ -2386,6 +2419,13 @@ module Sequel
           _set_associated_object(opts, o)
         end
 
+        # Set the given object as the associated object for the given one_through_one association reflection
+        def set_one_through_one_associated_object(opts, o)
+          raise(Error, "object #{inspect} does not have a primary key") unless pk
+          raise(Error, "associated object #{o.inspect} does not have a primary key") if o && !o.pk
+          _set_associated_object(opts, o)
+        end
+
         # Set the given object as the associated object for the given one_to_one association reflection
         def set_one_to_one_associated_object(opts, o)
           raise(Error, "object #{inspect} does not have a primary key") unless pk