sequel 4.33.0 → 4.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3187d95f59e9b0abc9502193d8843e11fc1c46f6
-  data.tar.gz: 7437eeaaa3c1a9f2016ef5d0fbe70a13b6f92a54
+  metadata.gz: 2bbb9208954c7c7fb4d531621af12ac2ce850339
+  data.tar.gz: fb5c58d9906bba99dd60543dae4089f71b3b3037
 SHA512:
-  metadata.gz: 7a6239f275f8d99e78fddfbdce4ee36f28cd00b1d79a895b5b1c1f2a6529de35b437905d20bd9a60fb9e8aff6d2dd00b4a89d5bbbeb9f5ea52b897b0cbe72830
-  data.tar.gz: d123e46cfeb494f9ea8ecb4ee62793bb4873b6df240cec31ea7c290fe8e6c0f24f64f0f419729ee1bf7aedf724d69ad86497c248458c6818af70ccf44d65d525
+  metadata.gz: e00cd2f1752cdd25fd45c30479d4f104c10a7e4b6411eba817601b48b367c1a8cda00f84da65486b948497cf27f7429245654e0f77886ff1088a0d1588b39ca7
+  data.tar.gz: 63fce28567f5a354105a9cf816a6be443b73755beed960567011e3b16169cd22a8ae65fc692b00bd4f337fef57cb1db8105ada35aa150634b738675b83dfdeb8

data/CHANGELOG

@@ -1,3 +1,25 @@
+=== 4.34.0 (2016-05-01)
+
+* Add support for :dataset_associations_join association option to dataset_associations plugin, for making resulting datasets have appropriate joins (jeremyevans)
+
+* Log server connection was attempted to in PoolTimeout exception messages in sharded connection pool (jeremyevans)
+
+* Log Database :name option in PoolTimeout exception messages (bigkevmcd, jeremyevans) (#1176)
+
+* Add duplicate_columns_handler extension, for raising or warning if a dataset returns multiple columns with the same name (TSMMark, jeremyevans) (#1175)
+
+* Support registering per-Database custom range types in the pg_range extension (steveh) (#1174)
+
+* Support :preconnect=>:concurrently Database option for preconnecting in separate threads (kch, jeremyevans) (#1172)
+
+* Make prepared_statements_safe plugin work correctly with CURRENT_DATE/CURRENT_TIMESTAMP defaults (jeremyevans) (#1168)
+
+* Add validates_operator validation helper (petedmarsh) (#1170)
+
+* Recognize additional unique constraint violation on Microsoft SQL Server (jeremyevans)
+
+* Add :hash option to Dataset#(select|to)_hash(_groups)? methods for choosing object to populate (mwpastore) (#1167)
+
 === 4.33.0 (2016-04-01)
 
 * Handle arbitrary objects passed as arguments to the association method (jeremyevans) (#1166)

data/doc/release_notes/4.34.0.txt

@@ -0,0 +1,86 @@
+= New Features
+
+* A duplicate_columns_handler extension has been added, for printing a
+  warning or raising an exception if a dataset returns multiple
+  columns with the same name.  You can set this globally for the
+  Database:
+
+    DB.extension :duplicate_columns_handler
+    DB.opts[:on_duplicate_columns] = :warn
+    DB.opts[:on_duplicate_columns] = proc do |columns|
+      columns.include?(:foo) ? :raise : :ignore
+    end
+
+  or for specific datasets:
+
+    ds = DB[:table].extension(:duplicate_columns_handler)
+    ds = ds.on_duplicate_columns(:raise)
+    ds = ds.on_duplicate_columns do |columns|
+      columns.include?(:foo) ? :raise : :ignore
+    end
+
+  This makes it easier to detect when duplicate columns are returned,
+  which in some cases can cause undesired behavior, such as the values
+  for later columns of the same name overwriting values for earlier
+  columns.
+
+* The Dataset#to_hash, #to_hash_groups, #select_hash, and
+  #select_hash_groups methods now take an options hash as a third
+  argument.  This options hash can now contain a :hash option, which
+  specifies the object in which the resulting values should be
+  placed.  You can use this to have the values inserted into a
+  custom hash, or another object responding to #[] and #[]=.
+
+* A validators_operator validation has been added to the
+  validation_helpers plugin:
+
+    class Example < Sequel::Model
+      def validate
+        super
+        validates_operator(:>, 3, :column1)
+        validates_operator(:<=, 4, [:column2, :column3])
+      end
+    end
+
+* The pg_range extension now adds a #register_range_type Database
+  method, supporting per-Database custom range types:
+
+    DB.register_range_type('timerange')
+
+* The dataset_associations plugin now supports a
+  :dataset_associations_join association option on associations that
+  use joined datasets.  This option will have the datasets returned
+  by the dataset association methods join to the same tables that
+  would be joined when retriving the associated objects, allowing
+  selected columns, orders, and filters that reference columns in
+  the joined tables to work correctly.
+
+* The Database :preconnect option can now be set to :concurrently,
+  which will create the connections in separate threads. This can
+  significantly speed up preconnection in high-latency environments.
+
+* The Database :name option is now supported, holding an arbitrary
+  name for the database.  Currently, it is only used in PoolTimeout
+  exception messages, but it may be used in other places in the
+  future.
+
+= Other Improvements
+
+* The prepared_statements_safe plugin now works correctly when using
+  CURRENT_DATE and CURRENT_TIMESTAMP default values for columns.
+
+* Sequel now recognizes an addition unique constraint violation on
+  Microsoft SQL Server.
+
+* PoolTimeout exception messages now include the server/shard to which
+  the connection was attempted when using the sharded threaded
+  connection pool.
+
+= Backwards Compatibility
+
+* Users of sequel_pg should upgrade to 1.6.17, as older versions of
+  sequel_pg may not work with Sequel 4.34.0+.
+
+* Any custom extensions that override Dataset#to_hash,
+  #to_hash_groups, #select_hash, and #select_hash_groups need to
+  be modified to add support for accepting the options hash.

data/doc/testing.rdoc

@@ -154,6 +154,7 @@ The SEQUEL_INTEGRATION_URL environment variable specifies the Database connectio
 
 SEQUEL_COLUMNS_INTROSPECTION :: Use the columns_introspection extension when running the specs
 SEQUEL_CONNECTION_VALIDATOR :: Use the connection validator extension when running the specs
+SEQUEL_DUPLICATE_COLUMNS_HANDLER :: Use the duplicate columns handler extension with value given when running the specs
 SEQUEL_ERROR_SQL :: Use the error_sql extension when running the specs
 SEQUEL_NO_AUTO_LITERAL_STRINGS :: Use the no_auto_string_literals extension when running the specs
 SEQUEL_NO_CACHE_ASSOCIATIONS :: Don't cache association metadata when running the specs

data/doc/validations.rdoc

@@ -189,7 +189,7 @@ This is similar to +validates_presence+, but only checks for NULL/nil values, al
     def validate
       super
       validates_format /\A\d\d\d-\d-\d{7}-\d-\d\z/, :isbn
-      validates_format /\a[0-9a-zA-Z:' ]+\z/, :name
+      validates_format /\A[0-9a-zA-Z:' ]+\z/, :name
     end
   end
 
@@ -231,6 +231,17 @@ These methods check that the specified attributes can be valid integers or valid
     end
   end
 
+=== +validates_operator+
+
++validates_operator+ checks that a given +operator+ method returns a truthy value when called on attribute with a specified value for comparison.  Generally, this is used for inequality checks (>, >=, etc) but any method that can be called on the attribute that accepts an argument and returns a truthy value may be used.
+
+  class Album < Sequel::Model
+    def validate
+      super
+      validates_operator(:>, 3, :tracks)
+    end
+  end
+
 === +validates_type+
 
 +validates_type+ checks that the specified attributes are instances of the class specified in the first argument.  The class can be specified as the class itself, or as a string or symbol with the class name, or as a an array of classes.

data/lib/sequel/adapters/ado.rb

@@ -135,7 +135,7 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |s|
           columns = cols = s.Fields.extend(Enumerable).map{|column| output_identifier(column.Name)}
-          @columns = columns
+          self.columns = columns
           s.getRows.transpose.each do |r|
             row = {}
             cols.each{|c| row[c] = r.shift}

data/lib/sequel/adapters/amalgalite.rb

@@ -160,7 +160,7 @@ module Sequel
       # Yield a hash for each row in the dataset.
       def fetch_rows(sql)
         execute(sql) do |stmt|
-          @columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
+          self.columns = cols = stmt.result_fields.map{|c| output_identifier(c)}
           col_count = cols.size
           stmt.each do |result|
             row = {}

data/lib/sequel/adapters/cubrid.rb

@@ -127,7 +127,7 @@ module Sequel
         execute(sql) do |stmt|
           begin
             cols = stmt.column_info.map{|c| [output_identifier(c[COLUMN_INFO_NAME]), CUBRID_TYPE_PROCS[c[COLUMN_INFO_TYPE]]]}
-            @columns = cols.map(&:first)
+            self.columns = cols.map(&:first)
             stmt.each do |r|
               row = {}
               cols.zip(r).each{|(k, p), v| row[k] = (v && p) ? p.call(v) : v}

data/lib/sequel/adapters/do.rb

@@ -144,7 +144,7 @@ module Sequel
       # with symbol keys.
       def fetch_rows(sql)
         execute(sql) do |reader|
-          cols = @columns = reader.fields.map{|f| output_identifier(f)}
+          cols = self.columns = reader.fields.map{|f| output_identifier(f)}
           while(reader.next!) do
             h = {}
             cols.zip(reader.values).each{|k, v| h[k] = v}

data/lib/sequel/adapters/ibmdb.rb

@@ -401,7 +401,7 @@ module Sequel
             columns << [key, cps[type]]
           end
           cols = columns.map{|c| c.at(0)}
-          @columns = cols
+          self.columns = cols
 
           while res = stmt.fetch_array
             row = {}

data/lib/sequel/adapters/jdbc.rb

@@ -800,7 +800,7 @@ module Sequel
           i += 1
           cols << [output_identifier(meta.getColumnLabel(i)), i, convert ? type_convertor(map, meta, meta.getColumnType(i), i) : basic_type_convertor(map, meta, meta.getColumnType(i), i)]
         end
-        @columns = cols.map{|c| c.at(0)}
+        self.columns = cols.map{|c| c.at(0)}
 
         while result.next
           row = {}

data/lib/sequel/adapters/mock.rb

@@ -365,7 +365,7 @@ module Sequel
         if cs.empty?
           super
         else
-          @columns = cs
+          self.columns = cs
           self
         end
       end

data/lib/sequel/adapters/mysql.rb

@@ -305,7 +305,7 @@ module Sequel
             type_proc = f.type == 1 && cast_tinyint_integer?(f) ? cps[2] : cps[f.type]
             [output_identifier(f.name), type_proc, i+=1]
           end
-          @columns = cols.map(&:first)
+          self.columns = cols.map(&:first)
           if opts[:split_multiple_result_sets]
             s = []
             yield_rows(r, cols){|h| s << h}

data/lib/sequel/adapters/mysql2.rb

@@ -154,7 +154,7 @@ module Sequel
       # Yield all rows matching this dataset.
       def fetch_rows(sql)
         execute(sql) do |r|
-          @columns = if identifier_output_method
+          self.columns = if identifier_output_method
             r.fields.map!{|c| output_identifier(c.to_s)}
           else
             r.fields

data/lib/sequel/adapters/odbc.rb

@@ -98,7 +98,7 @@ module Sequel
           i = -1
           cols = s.columns(true).map{|c| [output_identifier(c.name), c.type, i+=1]}
           columns = cols.map{|c| c.at(0)}
-          @columns = columns
+          self.columns = columns
           if rows = s.fetch_all
             rows.each do |row|
               hash = {}

data/lib/sequel/adapters/oracle.rb

@@ -366,7 +366,7 @@ module Sequel
           cols = columns = cursor.get_col_names.map{|c| output_identifier(c)}
           metadata = cursor.column_metadata
           cm = cols.zip(metadata).map{|c, m| [c, cps[m.data_type]]}
-          @columns = columns
+          self.columns = columns
           while r = cursor.fetch
             row = {}
             r.zip(cm).each{|v, (c, cp)| row[c] = ((v && cp) ? cp.call(v) : v)}

data/lib/sequel/adapters/postgres.rb

@@ -835,7 +835,7 @@ module Sequel
         res.nfields.times do |fieldnum|
           cols << [fieldnum, procs[res.ftype(fieldnum)], output_identifier(res.fname(fieldnum))]
         end
-        @columns = cols.map{|c| c.at(2)}
+        self.columns = cols.map{|c| c.at(2)}
         cols
       end
       

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

@@ -341,7 +341,7 @@ module Sequel
       end
     
       DATABASE_ERROR_REGEXPS = {
-        /Violation of UNIQUE KEY constraint|Violation of PRIMARY KEY constraint.+Cannot insert duplicate key/ => UniqueConstraintViolation,
+        /Violation of UNIQUE KEY constraint|(Violation of PRIMARY KEY constraint.+)?Cannot insert duplicate key/ => UniqueConstraintViolation,
         /conflicted with the (FOREIGN KEY.*|REFERENCE) constraint/ => ForeignKeyConstraintViolation,
         /conflicted with the CHECK constraint/ => CheckConstraintViolation,
         /column does not allow nulls/ => NotNullConstraintViolation,

data/lib/sequel/adapters/sqlanywhere.rb

@@ -159,7 +159,7 @@ module Sequel
             col_infos << [i, output_identifier(name), cp]
           end
 
-          @columns = col_infos.map{|a| a[1]}
+          self.columns = col_infos.map{|a| a[1]}
 
           if rs
             while api.sqlany_fetch_next(rs) == 1

data/lib/sequel/adapters/sqlite.rb

@@ -324,7 +324,7 @@ module Sequel
           cps = db.conversion_procs
           type_procs = result.types.map{|t| cps[base_type_name(t)]}
           cols = result.columns.map{|c| i+=1; [output_identifier(c), i, type_procs[i]]}
-          @columns = cols.map(&:first)
+          self.columns = cols.map(&:first)
           result.each do |values|
             row = {}
             cols.each do |name,id,type_proc|

data/lib/sequel/adapters/swift.rb

@@ -134,7 +134,7 @@ module Sequel
       def fetch_rows(sql)
         execute(sql) do |res|
           col_map = {}
-          @columns = res.fields.map do |c|
+          self.columns = res.fields.map do |c|
             col_map[c] = output_identifier(c)
           end
           tz = db.timezone if Sequel.application_timezone

data/lib/sequel/adapters/tinytds.rb

@@ -225,7 +225,7 @@ module Sequel
             result.each(*args) do |r|
               unless cols
                 cols = result.fields.map{|c| [c, output_identifier(c)]}
-                @columns = columns = cols.map(&:last)
+                self.columns = columns = cols.map(&:last)
               end
               h = {}
               cols.each do |s, sym|
@@ -234,7 +234,7 @@ module Sequel
               yield h
             end
           else
-            @columns = columns
+            self.columns = columns
             if db.timezone == :utc
               result.each(:timezone=>:utc){|r| yield r}
             else

data/lib/sequel/connection_pool.rb

@@ -79,6 +79,8 @@ class Sequel::ConnectionPool
   # :preconnect :: Automatically create the maximum number of connections, so that they don't
   #                need to be created as needed.  This is useful when connecting takes a long time
   #                and you want to avoid possible latency during runtime.
+  #                Set to :concurrently to create the connections in separate threads. Otherwise
+  #                they'll be created sequentially.
   def initialize(db, opts=OPTS)
     @db = db
     @after_connect = opts[:after_connect]

data/lib/sequel/connection_pool/sharded_single.rb

@@ -102,7 +102,7 @@ class Sequel::ShardedSingleConnectionPool < Sequel::ConnectionPool
   end
   
   # Make sure there is a valid connection for each server.
-  def preconnect
+  def preconnect(concurrent = nil)
     servers.each{|s| hold(s){}}
   end
   

data/lib/sequel/connection_pool/sharded_threaded.rb

@@ -193,7 +193,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
         until conn = _acquire(thread, server)
           deadline ||= time + @timeout
           current_time = Time.now
-          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{current_time - time}") if current_time > deadline
+          raise_pool_timeout(current_time - time, server) if current_time > deadline
           # :nocov:
           # It's difficult to get to this point, it can only happen if there is a race condition
           # where a connection cannot be acquired even after the thread is signalled by the condition
@@ -215,7 +215,7 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
         sleep_time = @sleep_time
         sleep sleep_time
         until conn = sync{_acquire(thread, server)}
-          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{Time.now - time}") if Time.now > timeout
+          raise_pool_timeout(Time.now - time, server) if Time.now > timeout
           sleep sleep_time
         end
       end
@@ -290,8 +290,21 @@ class Sequel::ShardedThreadedConnectionPool < Sequel::ThreadedConnectionPool
   end
   
   # Create the maximum number of connections to each server immediately.
-  def preconnect
-    servers.each{|s| (max_size - size(s)).times{checkin_connection(s, make_new(s))}}
+  def preconnect(concurrent = false)
+    conn_servers = @servers.keys.map{|s| Array.new(max_size - size(s), s)}.flatten
+
+    if concurrent
+      conn_servers.map{|s| Thread.new{[s, make_new(s)]}}.map(&:join).each{|t| checkin_connection(*t.value)}
+    else
+      conn_servers.each{|s| checkin_connection(s, make_new(s))}
+    end
+  end
+  
+  # Raise a PoolTimeout error showing the current timeout, the elapsed time, the server
+  # the connection attempt was made to, and the database's name (if any).
+  def raise_pool_timeout(elapsed, server)
+    name = db.opts[:name]
+    raise ::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{elapsed}, server: #{server}#{", database name: #{name}" if name}"
   end
   
   # Releases the connection assigned to the supplied thread and server. If the

data/lib/sequel/connection_pool/single.rb

@@ -44,7 +44,7 @@ class Sequel::SingleConnectionPool < Sequel::ConnectionPool
   private
 
   # Make sure there is a valid connection.
-  def preconnect
+  def preconnect(concurrent = nil)
     hold{}
   end
 

data/lib/sequel/connection_pool/threaded.rb

@@ -160,7 +160,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
         until conn = _acquire(thread)
           deadline ||= time + @timeout
           current_time = Time.now
-          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{current_time - time}") if current_time > deadline
+          raise_pool_timeout(current_time - time) if current_time > deadline
           # :nocov:
           # It's difficult to get to this point, it can only happen if there is a race condition
           # where a connection cannot be acquired even after the thread is signalled by the condition
@@ -181,7 +181,7 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
         sleep_time = @sleep_time
         sleep sleep_time
         until conn = sync{_acquire(thread)}
-          raise(::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{Time.now - time}") if Time.now > timeout
+          raise_pool_timeout(Time.now - time) if Time.now > timeout
           sleep sleep_time
         end
       end
@@ -243,8 +243,21 @@ class Sequel::ThreadedConnectionPool < Sequel::ConnectionPool
   end
   
   # Create the maximum number of connections immediately.
-  def preconnect
-    (max_size - size).times{checkin_connection(make_new(nil))}
+  def preconnect(concurrent = false)
+    enum = (max_size - size).times
+
+    if concurrent
+      enum.map{Thread.new{make_new(nil)}}.map(&:join).each{|t| checkin_connection(t.value)}
+    else
+      enum.each{checkin_connection(make_new(nil))}
+    end
+  end
+
+  # Raise a PoolTimeout error showing the current timeout, the elapsed time, and the
+  # database's name (if any).
+  def raise_pool_timeout(elapsed)
+    name = db.opts[:name]
+    raise ::Sequel::PoolTimeout, "timeout: #{@timeout}, elapsed: #{elapsed}#{", database name: #{name}" if name}"
   end
   
   # Releases the connection assigned to the supplied thread back to the pool.