sequel 5.8.0 → 5.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5802a8e3fdb50b3d51f78111c604c86c64f0a3705bcf272423f0b9281800720b
-  data.tar.gz: 2257a05863d62c70a871032ecc5fdff36196ab717094af98c096570c08f380a7
+  metadata.gz: 49e114f3c425c0cdcd798fdcb170ac2112fada51077235f8e53b3d9a3940954a
+  data.tar.gz: db61fd6ab89b98c48fd2461f500db1f35afd2624808721733a8efbdc4c14a9ba
 SHA512:
-  metadata.gz: 3caabfec31c2953c4f0dd57e68dc58466ff416ab80276ae5ac111fffde7a6dcdddf068b074e33e8df4ea6f41ca941f59f60ec1507d5de2a07ce7b3cdb9016c82
-  data.tar.gz: 811720c5223a1e2113b47fb0430870dec6377f8d6d1408f0b61dd52abacd596f26af6077c77cf619692c80a43224f06e44633d5c8bd2ee403eafac3a5e7050db
+  metadata.gz: ff2793a7d47c0fe5ff7669ef248cd2c66bd1761f36a9ca0d2742adb8ee59be88a12264df0155864e7ac34f2795ff8f1a633d4e97fc87bcd9bb7976e93b67615b
+  data.tar.gz: a5996916449312e4a83ecc1e4bdaf2a3789c98321fa622389d675b3b6caf5cc84ce9e413198c2d875d0963ac07b7f3b59f2e80cd50b7eb9f45110b1f87263489

data/CHANGELOG

@@ -1,3 +1,33 @@
+=== 5.9.0 (2018-06-01)
+
+* Support generated columns on MySQL 5.7+ and MariaDB 5.2+ (wjordan, jeremyevans) (#1517)
+
+* Add escaped_like extension for creation of LIKE expressions with placeholders in the pattern without access to a dataset (jeremyevans)
+
+* Modify jdbc adapter exception handling to work around ::NativeException deprecation in JRuby 9.2 (jeremyevans)
+
+* Work around broken BC date handling in JRuby 9.2.0.0 (jeremyevans)
+
+* Switch use of BigDecimal.new() to BigDecimal(), since the former is deprecated (jeremyevans)
+
+* Add Sequel::VERSION_NUMBER for easier version comparisons (jeremyevans)
+
+* Add Model.has_dataset? to determine if the model class has a dataset (AlexWayfer) (#1508)
+
+* Support use of LIKE with ANY function on PostgreSQL by avoiding unnecessary use of ESCAPE syntax (jeremyevans)
+
+* Disconnect connections left allocated by dead threads instead of returning the connections to the pool (jeremyevans)
+
+* Make both threaded connection pools avoid disconnecting connections while holding the connection pool mutex (jeremyevans)
+
+* Don't deadlock when disconnecting connections in the sharded_threaded connection pool when using connection_validator or connection_expiration extensions (jeremyevans)
+
+* Don't modify hash argument passed in Model.nested_attributes in the nested_attributes plugin (jeremyevans)
+
+* Avoid unnecessary hash creation in many places (jeremyevans)
+
+* Fix duplicate objects in nested associations when eager_graphing cascaded many_to_one=>one_to_many associations (jeremyevans)
+
 === 5.8.0 (2018-05-01)
 
 * Don't mark SQLAnywhere as supporting WITH in INSERT statement (jeremyevans)

data/doc/release_notes/5.9.0.txt

@@ -0,0 +1,99 @@
+= New Features
+
+* An escaped_like extension has been added, for the creation of
+  LIKE/ILIKE expressions with placeholders in patterns without
+  access to a dataset.  This adds escaped_like and escaped_ilike
+  methods to the same Sequel expression objects that support like
+  and ilike.  These methods take two arguments, the first being
+  the pattern, with ? placeholders, and the second being the
+  placeholder value (which can be an array for multiple
+  placeholders):
+
+    Sequel.extension :escaped_like
+    DB[:table].where{string_column.escaped_like('?%', user_input)}
+    # user_input is 'foo':
+    #  SELECT * FROM table WHERE string_column LIKE 'foo%'
+    # user_input is '%foo':
+    #  SELECT * FROM table WHERE string_column LIKE '\%foo%'
+
+* Generated columns on MySQL 5.7+ and MariaDB 5.2+ are now supported
+  using the :generated_always_as option when creating the column.
+  The :generated_type option can also be used to specify the type of
+  generated column (virtual or stored).  Examples:
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b'
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b'))
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
+      generated_type: :virtual
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) VIRTUAL
+
+    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
+      generated_type: :stored
+    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
+    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) STORED
+
+* Sequel::Model.has_dataset? has been added for checking whether the
+  model class has an associated dataset.  This will generally be true
+  for most model classes, but will be false for abstract model
+  classes (such as Sequel::Model itself).
+
+* Sequel::VERSION_NUMBER has been added for easier future version
+  comparisons.  The version number for 5.9.0 is 50090.
+
+= Other Improvements
+
+* When disconnecting connections in the threaded connection pools,
+  the disconnection is performed without holding the connection
+  pool mutex, since disconnection may block.
+
+* The sharded threaded connection pool no longer deadlocks when
+  disconnecting connections if the connection_validator or
+  connection_expiration extension is used.
+
+* If a thread dies and does not check a connection back into the
+  connection pool, Sequel now disconnects the connection when it
+  detects the dead thread, instead of assuming the connection is
+  safe to be reused.
+
+* When using eager_graph with cascaded associations, a unique
+  object is now used instead of a shared object in cases where
+  using a shared object may cause further cascaded associated
+  objects to be duplicated.
+
+* On PostgreSQL, the ESCAPE modifier to the LIKE/ILIKE operators is
+  no longer used, since the default ESCAPE value is the one Sequel
+  uses.  This change was made in order to allow the LIKE/ILIKE
+  operators to work with the ANY function, as PostgreSQL does not
+  support the use of the ESCAPE modifier in such cases.
+
+* A hash argument passed to Model.nested_attributes in the
+  nested_attributes plugin is now no longer modified.
+
+* Internal data structures for eager and eager_graph datasets are now
+  frozen to avoid unintentional modification.
+
+* Nondeterministic behavior in Database#foreign_key_list with the
+  :reverse option on PostgreSQL is now avoided by using an
+  unambiguous order.
+
+* Performance has been improved slightly by avoiding unnecessary
+  hash allocations.
+
+* Performance has been improved slightly by using while instead
+  of Kernel#loop.
+
+* BigDecimal() is now used instead of BigDecimal.new(), as the
+  latter has been deprecated.
+
+* The jdbc adapter now avoids referencing ::NativeException on JRuby
+  9.2+, since JRuby has deprecated it.  It is still used on older
+  versions of JRuby, since some JRuby 1.7 code may still require it.
+
+* Sequel now works around multiple Date/Time conversion bugs in
+  JRuby 9.2.0.0 for BC dates in the pg_extended_date_support
+  extension.  These bugs have already been fixed in JRuby, and
+  the workarounds will be removed after the release of JRuby
+  9.2.1.0.

data/doc/testing.rdoc

@@ -13,7 +13,7 @@ These run each test in its own transaction, the recommended way to test.
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
@@ -21,7 +21,7 @@ These run each test in its own transaction, the recommended way to test.
 
   class Minitest::Spec
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
@@ -30,7 +30,7 @@ These run each test in its own transaction, the recommended way to test.
   # Use this class as the base class for your tests
   class SequelTestCase < Minitest::Test
     def run(*args, &block)
-      Sequel::Model.db.transaction(:rollback=>:always, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :auto_savepoint=>true){super}
     end
   end
 
@@ -46,7 +46,7 @@ These run each test in its own transaction, the recommended way to test.
 
 You can use the Sequel.transaction method to run a transaction on multiple databases, rolling all of them back.  Instead of:
 
-  Sequel::Model.db.transaction(:rollback=>:always)
+  DB.transaction(:rollback=>:always)
 
 Use Sequel.transaction with an array of databases:
 
@@ -66,11 +66,11 @@ Example:
   require 'minitest/hooks/default'
   class Minitest::HooksSpec
     def around
-      Sequel::Model.db.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
+      DB.transaction(:rollback=>:always, :savepoint=>true, :auto_savepoint=>true){super}
     end
 
     def around_all
-      Sequel::Model.db.transaction(:rollback=>:always){super}
+      DB.transaction(:rollback=>:always){super}
     end
   end
 
@@ -90,9 +90,9 @@ The order in which you delete/truncate the tables is important if you are using
 
   describe "some test suite" do
     after do
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      [:table1, :table2].each{|x| DB.from(x).truncate}
       # or
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+      [:table1, :table2].each{|x| DB.from(x).delete}
     end
   end
 
@@ -100,9 +100,9 @@ The order in which you delete/truncate the tables is important if you are using
 
   class SomeTestClass < Minitest::Test
     def teardown
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).truncate}
+      [:table1, :table2].each{|x| DB.from(x).truncate}
       # or
-      [:table1, :table2].each{|x| Sequel::Model.db.from(x).delete}
+      [:table1, :table2].each{|x| DB.from(x).delete}
     end
   end
 

data/lib/sequel/adapters/ado.rb

@@ -54,7 +54,7 @@ module Sequel
     end
 
     def cp.numeric(v)
-      BigDecimal.new(v)
+      BigDecimal(v)
     end
 
     def cp.binary(v)

data/lib/sequel/adapters/amalgalite.rb

@@ -30,7 +30,7 @@ module Sequel
       # Return numeric/decimal types as instances of BigDecimal
       # instead of Float
       def decimal(s)
-        BigDecimal.new(s)
+        BigDecimal(s)
       end
       
       # Return datetime types as instances of Sequel.datetime_class

data/lib/sequel/adapters/jdbc.rb

@@ -17,7 +17,19 @@ module Sequel
     # Contains procs keyed on subadapter type that extend the
     # given database object so it supports the correct database type.
     DATABASE_SETUP = {}
+
+    # Create custom NativeException alias for nicer access, and also so that
+    # JRuby 9.2+ so it doesn't use the deprecated ::NativeException
+    NativeException = java.lang.Exception
     
+    # Default database error classes
+    DATABASE_ERROR_CLASSES = [NativeException]
+    if JRUBY_VERSION < '9.2'
+      # On JRuby <9.2, still include ::NativeException, as it is still needed in some cases
+      DATABASE_ERROR_CLASSES << ::NativeException
+    end
+    DATABASE_ERROR_CLASSES.freeze
+
     # Allow loading the necessary JDBC support via a gem.
     def self.load_gem(name)
       begin
@@ -68,7 +80,7 @@ module Sequel
       end
       def RubyBigDecimal(r, i)
         if v = r.getBigDecimal(i)
-          BigDecimal.new(v.to_string)
+          ::Kernel::BigDecimal(v.to_string)
         end
       end
       def RubyBlob(r, i)
@@ -168,7 +180,7 @@ module Sequel
                 last_insert_id(conn, opts)
               end
             end
-          rescue NativeException, JavaSQL::SQLException => e
+          rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
             cps.close
@@ -189,7 +201,7 @@ module Sequel
             JavaSQL::DriverManager.setLoginTimeout(opts[:login_timeout]) if opts[:login_timeout]
             raise StandardError, "skipping regular connection" if opts[:jdbc_properties]
             JavaSQL::DriverManager.getConnection(*args)
-          rescue JavaSQL::SQLException, NativeException, StandardError => e
+          rescue StandardError, *DATABASE_ERROR_CLASSES => e
             raise e unless driver
             # If the DriverManager can't get the connection - use the connect
             # method of the driver. (This happens under Tomcat for instance)
@@ -203,7 +215,7 @@ module Sequel
               c = driver.new.connect(args[0], props)
               raise(Sequel::DatabaseError, 'driver.new.connect returned nil: probably bad JDBC connection string') unless c
               c
-            rescue JavaSQL::SQLException, NativeException, StandardError => e2
+            rescue StandardError, *DATABASE_ERROR_CLASSES => e2
               if e2.respond_to?(:message=) && e2.message != e.message
                 e2.message = "#{e2.message}\n#{e.class.name}: #{e.message}"
               end
@@ -355,7 +367,7 @@ module Sequel
       end
 
       def database_error_classes
-        [NativeException]
+        DATABASE_ERROR_CLASSES
       end
 
       def database_exception_sqlstate(exception, opts)
@@ -436,7 +448,7 @@ module Sequel
                 log_connection_yield(msg, conn, args){cps.executeUpdate}
               end
             end
-          rescue NativeException, JavaSQL::SQLException => e
+          rescue *DATABASE_ERROR_CLASSES => e
             raise_error(e)
           ensure
             cps.close unless name
@@ -661,7 +673,7 @@ module Sequel
       def statement(conn)
         stmt = conn.createStatement
         yield stmt
-      rescue NativeException, JavaSQL::SQLException => e
+      rescue *DATABASE_ERROR_CLASSES => e
         raise_error(e)
       ensure
         stmt.close if stmt

data/lib/sequel/adapters/jdbc/oracle.rb

@@ -23,7 +23,7 @@ module Sequel
           if v == JAVA_BIG_DECIMAL_CONSTRUCTOR.call(i)
             i
           else
-            BigDecimal.new(v.to_string)
+            ::Kernel::BigDecimal(v.to_string)
           end
         end
       end 

data/lib/sequel/adapters/jdbc/postgresql.rb

@@ -135,11 +135,6 @@ module Sequel
 
         private
         
-        DATABASE_ERROR_CLASSES = [NativeException].freeze
-        def database_error_classes
-          DATABASE_ERROR_CLASSES
-        end
-
         def disconnect_error?(exception, opts)
           super || exception.message =~ /\A(This connection has been closed\.|FATAL: terminating connection due to administrator command|An I\/O error occurred while sending to the backend\.)\z/
         end

data/lib/sequel/adapters/postgres.rb

@@ -271,7 +271,7 @@ module Sequel
         def error_info(e)
           e = e.wrapped_exception if e.is_a?(DatabaseError)
           r = e.result
-          h = {
+          {
             :schema => r.error_field(::PG::PG_DIAG_SCHEMA_NAME),
             :table => r.error_field(::PG::PG_DIAG_TABLE_NAME),
             :column => r.error_field(::PG::PG_DIAG_COLUMN_NAME),
@@ -449,7 +449,7 @@ module Sequel
                   raise Error, 'calling #listen with :loop requires a block' unless block
                   loop_call = l.respond_to?(:call)
                   catch(:stop) do
-                    loop do
+                    while true
                       t = timeout_block ? [timeout_block.call] : []
                       conn.wait_for_notify(*t, &block)
                       l.call(conn) if loop_call
@@ -712,7 +712,7 @@ module Sequel
               yield_hash_rows(res, cols){|h| yield h}
               return if res.ntuples < rows_per_fetch
             end
-            loop do
+            while true
               execute(fetch_sql) do |res|
                 yield_hash_rows(res, cols){|h| yield h}
                 return if res.ntuples < rows_per_fetch

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

@@ -109,12 +109,6 @@ module Sequel
           complex_expression_sql_append(sql, :LIKE, args)
         when :'NOT ILIKE'
           complex_expression_sql_append(sql, :'NOT LIKE', args)
-        when :LIKE, :'NOT LIKE'
-          sql << '('
-          literal_append(sql, args[0])
-          sql << ' ' << op.to_s << ' '
-          literal_append(sql, args[1])
-          sql << ')'
         when :'!='
           sql << '('
           literal_append(sql, args[0])
@@ -240,6 +234,11 @@ module Sequel
         end
       end
 
+      # Access doesn't support ESCAPE for LIKE.
+      def requires_like_escape?
+        false
+      end
+
       # Access requires parentheses when joining more than one table
       def select_from_sql(sql)
         if f = @opts[:from]

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

@@ -19,7 +19,7 @@ module Sequel
       include Sequel::Database::SplitAlterTable
 
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}.freeze
-      COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references].freeze
+      COLUMN_DEFINITION_ORDER = [:generated, :collate, :null, :default, :unique, :primary_key, :auto_increment, :references].freeze
       
       # Set the default charset used for CREATE TABLE.  You can pass the
       # :charset option to create_table to override this setting.
@@ -137,6 +137,11 @@ module Sequel
         true
       end
       
+      # Generated columns are supported in MariaDB 5.2.0+ and MySQL 5.7.6+.
+      def supports_generated_columns?
+        server_version >= (mariadb? ? 50200 : 50706)
+      end
+
       # MySQL 5+ supports prepared transactions (two-phase commit) using XA
       def supports_prepared_transactions?
         server_version >= 50000
@@ -331,6 +336,23 @@ module Sequel
         end
       end
 
+      # Add generation clause SQL fragment to column creation SQL.
+      def column_definition_generated_sql(sql, column)
+        if (generated_expression = column[:generated_always_as])
+          sql << " GENERATED ALWAYS AS (#{literal(generated_expression)})"
+          case (type = column[:generated_type])
+          when nil
+            # none, database default
+          when :virtual
+            sql << " VIRTUAL"
+          when :stored
+            sql << (mariadb? ? " PERSISTENT" : " STORED")
+          else
+            raise Error, "unsupported :generated_type option: #{type.inspect}"
+          end
+        end
+      end
+
       def column_definition_order
         COLUMN_DEFINITION_ORDER
       end
@@ -473,7 +495,11 @@ module Sequel
         metadata_dataset.with_sql("DESCRIBE ?", table).map do |row|
           extra = row.delete(:Extra)
           if row[:primary_key] = row.delete(:Key) == 'PRI'
-            row[:auto_increment] = !!(extra.to_s =~ /auto_increment/io)
+            row[:auto_increment] = !!(extra.to_s =~ /auto_increment/i)
+          end
+          if supports_generated_columns?
+            # Extra field contains VIRTUAL or PERSISTENT for generated columns
+            row[:generated] = !!(extra.to_s =~ /VIRTUAL|STORED|PERSISTENT/i)
           end
           row[:allow_null] = row.delete(:Null) == 'YES'
           row[:default] = row.delete(:Default)