sequel 5.18.0 → 5.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f181e0ec05e457e72b2517202bbd159a6a066c9dd946201de44576b64bca302
-  data.tar.gz: f554f6268798f72c667851c6d952f960564e70ebb1e2d3d1208db74bbcd98834
+  metadata.gz: e092b5439a78eec1bb50a0bbc8a62c1d84ee5b27b9c5f034c250b632d03e17af
+  data.tar.gz: 231708d52405407b11113c55d5fdcd95e7d6155b0a8283f736876569ced6e4b1
 SHA512:
-  metadata.gz: 474c441a62bb901abaf12968ec62cdd239f9679ce4cb1743cd58e7ec6032cb1e26d128fd49bbe7c3edfce9a0fb63b33975aa6426ebb8ee79f1309a09967ffef5
-  data.tar.gz: 8717400fcb03235ad51ab208d35e9accca05018c6531da025bbcefb8f4b557345e1afbbfd65862f2c213ca4b05826db72c5ecc6b8abdda5920af83dcd8fe35d9
+  metadata.gz: 4c2d7e19056e53f2d780f57f5da3c4675531f9678c6a54e922e0d59895bd2e485f12ee0b2644ed801c832a53653f75531d849cb7d60dcd9fb6a4edbfa8cb4c0b
+  data.tar.gz: 701b041185cc57c1966ea3b4be040e26a9e0aabfd6df45f0192f5b0b51133bfb94629f0634fa6edfc513a1c9193d455cb6222b388683d638e474b344e663ca50

data/CHANGELOG

@@ -1,3 +1,43 @@
+=== 5.20.0 (2019-05-01)
+
+* Fix reversing of alter_table add_foreign_key when :type option is used (jeremyevans) (#1615)
+
+* Switch from using instance_exec to define_method for model associations and in some plugins (jeremyevans)
+
+* Fix Database#server_version when using mysql2 adapter with mysql driver on MariaDB 10+ database (v-kolesnikov) (#1614)
+
+* Make one_to_one setter method handle models that use joined datasets (jeremyevans) (#1612)
+
+* Make auto_validations plugin work with the class_table_inheritance plugin (jeremyevans) (#1611)
+
+* Avoid use of instance_exec for PlaceholderLiteralString#with_dataset (jeremyevans)
+
+* Recognize float unsigned database types as float (keeguon, jeremyevans) (#1609)
+
+* Support :savepoint options to Database#{after_commit,after_rollback} for making the hooks handle savepoints (jeremyevans)
+
+* Avoid use of instance_exec in association_dependencies plugin (jeremyevans)
+
+* Add pg_auto_constraint_validation_override to the pg_auto_constraint_validations plugin, for customizing columns and error message per constraint (jeremyevans)
+
+* Make Database#check_constraints on PostgreSQL also include constraints where the related columns are not known (jeremyevans)
+
+=== 5.19.0 (2019-04-02)
+
+* Use more optimized approach to merging hashes in ruby 2.5+ (jeremyevans)
+
+* Use SQLite extended result codes when using ruby-sqlite3 1.4.0+ (jeremyevans)
+
+* Recognize additional SQLite extended result codes in the shared sqlite adapter (jeremyevans)
+
+* Add Database#rename_enum_value to the pg_enum extension (AlexWayfer) (#1603)
+
+* Make Database#drop_table delete constraint validations metadata for that table if using the constraint_validations extension (jeremyevans)
+
+* Speed up row fetching in the sqlite adapter (jeremyevans)
+
+* Speed up row fetching and type conversion in the sqlanywhere adapter (jeremyevans)
+
 === 5.18.0 (2019-03-01)
 
 * Use singleton .call methods on plain objects instead of procs/methods for faster type conversion (jeremyevans)

data/doc/opening_databases.rdoc

@@ -187,9 +187,8 @@ For Derby, H2, HSQLDB, JTDS, MySQL, Postgres, SQLite3
 the adapters can use the `jdbc-*` gem, for the others you need to have the `.jar` in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
-
 Note that when using a JDBC adapter, the best way to use Sequel
-is via Sequel.connect, NOT Sequel.jdbc.  Use the JDBC connection
+is via Sequel.connect using a connection string, NOT Sequel.jdbc.  Use the JDBC connection
 string when connecting, which will be in a different format than
 the native connection string.  The connection string should start
 with 'jdbc:'.  For PostgreSQL, use 'jdbc:postgresql:', and for
@@ -201,6 +200,10 @@ Sequel does no preprocessing of JDBC connection strings, it passes them directly
 So if you have problems getting a connection string to work, look up the 
 documentation for the JDBC driver.
 
+The jdbc adapter does not handle common options such as +:host+,
++:user+, and +:port+.  If you must use a hash of options when connecting,
+provide the full JDBC connection string as the :uri option.
+
 Example connection strings:
 
   jdbc:sqlite::memory:

data/doc/release_notes/5.19.0.txt

@@ -0,0 +1,28 @@
+= New Features
+
+* A Database#rename_enum_value method has been added to the pg_enum
+  extension. It is supported on PostgreSQL 10+:
+
+    DB.rename_enum_value(:enum_type, 'old_name', 'new_name')
+
+= Other Improvements
+
+* The performance of row fetching and type conversion in the
+  sqlanywhere adapter has been improved.
+
+* The performance of row fetching in the sqlite adapter has been
+  improved.
+
+* Calling Database#drop_table now drops any constraint validations
+  metadata for the table if using the constraint_validations
+  extension.  However, modifying the table using Database#alter_table
+  does not affect the constraint validations metadata.
+
+* The sqlite adapter when used with ruby-sqlite3 1.4.0+ now uses
+  SQLite extended result codes for a more accurate determination of
+  specific database errors types.
+
+* Performance for typecasting to decimal and floats has been improved
+  slightly.
+
+* Performance when merging hashes has been improved slightly.

data/doc/release_notes/5.20.0.txt

@@ -0,0 +1,89 @@
+= New Features
+
+* Database#after_commit and #after_rollback transaction hook methods
+  now support a :savepoint option.  Using the :savepoint option makes
+  the hooks savepoint-aware, so after_commit will only be called if
+  all enclosing savepoints and the transaction are committed, and
+  after_rollback will be called when any of the enclosing savepoints
+  are rolled back (which may be before transaction commit/rollback).
+  Examples:
+
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+      end # RELEASE SAVEPOINT
+      x # nil
+    end # COMMIT
+    x # 1
+
+    x = nil
+    DB.transaction do  # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+        x # nil
+        raise Sequel::Rollback
+      end # ROLLBACK TO SAVEPOINT
+      x # 2
+    end # COMMIT
+    x # 2
+  
+    x = nil
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.after_commit(savepoint: true){x = 1}
+        DB.after_rollback(savepoint: true){x = 2}
+      end # RELEASE SAVEPOINT
+      x # nil
+      raise Sequel::Rollback
+    end
+    x # 2
+
+* The pg_auto_constraint_validations plugin now supports a
+  pg_auto_constraint_validation_override method for overriding
+  the columns and message for a specific constraint.  This is
+  useful if the database cannot determine the columns (due
+  to the constraint containing a database function call), or
+  if you would like to customize the message per constraint.
+
+= Other Improvements
+
+* The one_to_one association setter now works with models that use
+  joined datasets, such as child models when using the
+  class_table_inheritance plugin.
+
+* Database#check_constraints on PostgreSQL now also includes CHECK
+  constraints where the related columns are not known.  The :columns
+  entry in the hash will be an empty array in such cases.  The
+  exclusion of such constraints in previous versions was not
+  intentional, and the documentation implied that all CHECK
+  constraints were returned.
+
+* Many cases where instance_exec was previously used on model
+  instances have been changed so that instance methods are defined
+  and called instead.  This avoids the creation of singleton classes
+  for model instances, and can significantly improve performance in
+  some cases.  This affects all associations as well as the
+  following plugins:
+
+  * composition
+  * hook_class_methods
+  * validation_class_methods
+
+  Other cases where instance_exec is now avoided and a different
+  approach is used:
+
+  * association_dependencies plugin
+  * PlaceholderLiteralString#with_dataset
+
+* The auto_validations plugin now works with child models when using
+  the class_table_inheritance plugin.
+
+* Database#server_version now works correctly in the mysql2 adapter
+  when using the MySQL driver with MariaDB 10+.
+
+* The float unsigned type is now recognized and supported in the
+  schema parser and schema_dumper extension.

data/doc/sharding.rdoc

@@ -268,3 +268,15 @@ the Database, just remove that option.  If you are setting:
   Sequel.single_threaded = true 
 
 just remove or comment out that code.
+
+== JDBC
+
+If you are using the jdbc adapter, note that it does not handle separate
+options such as +:host+, +:user+, and +:port+.  If you would like to use
+the +:servers+ option when connecting to a JDBC database, each hash value in
+the +servers+ option should contain a +:uri+ key with a JDBC connection string
+for that shard as the value.  Example:
+
+  DB=Sequel.connect('jdbc:postgresql://primary_server/database', 
+    servers: {read_only: {uri: 'jdbc:postgresql://replica_server/database'}})
+

data/doc/transactions.rdoc

@@ -169,6 +169,44 @@ If you want the current savepoint and potentially enclosing savepoints to be rol
     end # ROLLBACK TO SAVEPOINT
   end # ROLLBACK
 
+=== Savepoint Hooks
+
+When using savepoints, you can use the +:savepoint+ option to +after_commit+ or +after_rollback+ to use a savepoint hook.  For +after_commit+, this will only run the hook after transaction commit if all enclosing savepoints are released (not rolled back). For +after_rollback+, this will run the hook after any enclosing savepoint is rolled back (before transaction commit), or after the transaction is rolled back if all enclosing savepoints are released:
+
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+    end # RELEASE SAVEPOINT
+    x # nil
+  end # COMMIT
+  x # 1
+  
+  x = nil
+  DB.transaction do  # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+      x # nil
+      raise Sequel::Rollback
+    end # ROLLBACK TO SAVEPOINT
+    x # 2
+  end # COMMIT
+  x # 2
+  
+  x = nil
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.after_commit(savepoint: true){x = 1}
+      DB.after_rollback(savepoint: true){x = 2}
+    end # RELEASE SAVEPOINT
+    x # nil
+    raise Sequel::Rollback
+  end
+  x # 2
+
 == Prepared Transactions / Two-Phase Commit
 
 Sequel supports database prepared transactions on PostgreSQL, MySQL, and H2.  With prepared transactions, at the end of the transaction, the transaction is not immediately committed (it acts like a rollback).  Later, you can call +commit_prepared_transaction+ to commit the transaction or +rollback_prepared_transaction+ to roll the transaction back.  Prepared transactions are usually used with distributed databases to make sure all databases commit the same transaction or none of them do.

data/lib/sequel/adapters/jdbc.rb

@@ -254,7 +254,9 @@ module Sequel
                 log_connection_yield(sql, conn){stmt.execute(sql)}
               when :insert
                 log_connection_yield(sql, conn){execute_statement_insert(stmt, sql)}
-                last_insert_id(conn, Hash[opts].merge!(:stmt=>stmt))
+                opts = Hash[opts]
+                opts[:stmt] = stmt
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(sql, conn){stmt.executeUpdate(sql)}
               end
@@ -449,7 +451,10 @@ module Sequel
                 log_connection_yield(msg, conn, args){cps.execute}
               when :insert
                 log_connection_yield(msg, conn, args){execute_prepared_statement_insert(cps)}
-                last_insert_id(conn, Hash[opts].merge!(:prepared=>true, :stmt=>cps))
+                opts = Hash[opts]
+                opts[:prepared] = true
+                opts[:stmt] = cps
+                last_insert_id(conn, opts)
               else
                 log_connection_yield(msg, conn, args){cps.executeUpdate}
               end

data/lib/sequel/adapters/mysql2.rb

@@ -78,8 +78,8 @@ module Sequel
       end
 
       # Return the version of the MySQL server to which we are connecting.
-      def server_version(server=nil)
-        @server_version ||= (synchronize(server){|conn| conn.server_info[:id]} || super)
+      def server_version(_server=nil)
+        @server_version ||= super()
       end
 
       private

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

@@ -220,24 +220,22 @@ module Sequel
       # A hash of metadata for CHECK constraints on the table.
       # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
       # :definition :: An SQL fragment for the definition of the constraint
-      # :columns :: An array of column symbols for the columns referenced in the constraint
+      # :columns :: An array of column symbols for the columns referenced in the constraint,
+      #             can be an empty array if the database cannot deteremine the column symbols.
       def check_constraints(table)
         m = output_identifier_meth
 
         rows = metadata_dataset.
           from{pg_constraint.as(:co)}.
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
           where(:conrelid=>regclass_oid(table), :contype=>'c').
           select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
 
         hash = {}
         rows.each do |row|
           constraint = m.call(row[:constraint])
-          if entry = hash[constraint]
-            entry[:columns] << m.call(row[:column])
-          else
-            hash[constraint] = {:definition=>row[:definition], :columns=>[m.call(row[:column])]}
-          end
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry[:columns] << m.call(row[:column]) if row[:column]
         end
         
         hash
@@ -1733,7 +1731,9 @@ module Sequel
       def _import(columns, values, opts=OPTS)
         if @opts[:returning]
           statements = multi_insert_sql(columns, values)
-          @db.transaction(Hash[opts].merge!(:server=>@opts[:server])) do
+          trans_opts = Hash[opts]
+          trans_opts[:server] = @opts[:server]
+          @db.transaction(trans_opts) do
             statements.map{|st| returning_fetch_rows(st)}
           end.first.map{|v| v.length == 1 ? v.values.first : v}
         elsif opts[:return] == :primary_key

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

@@ -323,7 +323,7 @@ module Sequel
         case sqlite_error_code(exception)
         when 1299
           NotNullConstraintViolation
-        when 2067
+        when 1555, 2067, 2579
           UniqueConstraintViolation
         when 787
           ForeignKeyConstraintViolation
@@ -331,6 +331,8 @@ module Sequel
           CheckConstraintViolation
         when 19
           ConstraintViolation
+        when 517
+          SerializationFailure
         else
           super
         end

data/lib/sequel/adapters/sqlanywhere.rb

@@ -17,21 +17,34 @@ module Sequel
       end
     end
 
-    tt = Class.new do
-      def blob(s) ::Sequel::SQL::Blob.new(s) end
-      def boolean(s) s.to_i != 0 end
-      def date(s) ::Date.strptime(s) end
-      def decimal(s) BigDecimal(s) end
-      def time(s) ::Sequel.string_to_time(s) end
-    end.new
+    boolean = Object.new
+    def boolean.call(s)
+      s.to_i != 0
+    end
+
+    date = Object.new
+    def date.call(s)
+      ::Date.strptime(s)
+    end
+
+    decimal = Object.new
+    class << decimal
+      alias call BigDecimal
+      public :call
+    end
+
+    time = Object.new
+    def time.call(s)
+      ::Sequel.string_to_time(s)
+    end
 
     SQLANYWHERE_TYPES = {}
     {
-        [0, 484] => tt.method(:decimal),
-        [384] => tt.method(:date),
-        [388] =>  tt.method(:time),
-        [500] => tt.method(:boolean),
-        [524, 528] => tt.method(:blob)
+        [0, 484] => decimal,
+        [384] => date,
+        [388] => time,
+        [500] => boolean,
+        [524, 528] => ::Sequel::SQL::Blob
     }.each do |k,v|
       k.each{|n| SQLANYWHERE_TYPES[n] = v}
     end
@@ -153,17 +166,20 @@ module Sequel
             else
               cps[type]
             end
-            col_infos << [i, output_identifier(name), cp]
+            col_infos << [output_identifier(name), cp]
           end
 
-          self.columns = col_infos.map{|a| a[1]}
+          self.columns = col_infos.map(&:first)
+          max = col_infos.length
 
           if rs
             while api.sqlany_fetch_next(rs) == 1
+              i = -1
               h = {}
-              col_infos.each do |i, name, cp|
-                _, v = api.sqlany_get_column(rs, i)
-                h[name] = cp && v ? cp[v] : v
+              while (i+=1) < max
+                name, cp = col_infos[i]
+                v = api.sqlany_get_column(rs, i)[1]
+                h[name] = cp && v ? cp.call(v) : v
               end
               yield h
             end

data/lib/sequel/adapters/sqlite.rb

@@ -5,7 +5,7 @@ require_relative 'shared/sqlite'
 
 module Sequel
   module SQLite
-    FALSE_VALUES = (%w'0 false f no n' + [0]).freeze
+    FALSE_VALUES = (%w'0 false f no n'.each(&:freeze) + [0]).freeze
 
     blob = Object.new
     def blob.call(s)
@@ -77,6 +77,10 @@ module Sequel
       k.each{|n| SQLITE_TYPES[n] = v}
     end
     SQLITE_TYPES.freeze
+
+    sqlite_version = SQLite3::VERSION.split('.').map(&:to_i)[0..1]
+    sqlite_version = sqlite_version[0] * 100 + sqlite_version[1]
+    USE_EXTENDED_RESULT_CODES = sqlite_version >= 104
     
     class Database < Sequel::Database
       include ::Sequel::SQLite::DatabaseMethods
@@ -109,6 +113,10 @@ module Sequel
         sqlite3_opts[:readonly] = typecast_value_boolean(opts[:readonly]) if opts.has_key?(:readonly)
         db = ::SQLite3::Database.new(opts[:database].to_s, sqlite3_opts)
         db.busy_timeout(opts.fetch(:timeout, 5000))
+
+        if USE_EXTENDED_RESULT_CODES
+          db.extended_result_codes = true
+        end
         
         connection_pragmas.each{|s| log_connection_yield(s, db){db.execute_batch(s)}}
         
@@ -279,13 +287,12 @@ module Sequel
         Dataset
       end
 
-      # Support SQLite exception codes if ruby-sqlite3 supports them.
-      # This is disabled by default because ruby-sqlite3 doesn't currently
-      # support them (returning nil), and even if it did, it doesn't support
-      # extended error codes, which would lead to worse behavior.
-      #def sqlite_error_code(exception)
-      #  exception.code if exception.respond_to?(:code)
-      #end
+      if USE_EXTENDED_RESULT_CODES
+        # Support SQLite exception codes if ruby-sqlite3 supports them.
+        def sqlite_error_code(exception)
+          exception.code if exception.respond_to?(:code)
+        end
+      end
     end
     
     class Dataset < Sequel::Dataset
@@ -318,18 +325,18 @@ module Sequel
 
       def fetch_rows(sql)
         execute(sql) do |result|
-          i = -1
           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]]}
-          max = i+1
+          j = -1
+          cols = result.columns.map{|c| [output_identifier(c), type_procs[(j+=1)]]}
           self.columns = cols.map(&:first)
+          max = cols.length
           result.each do |values|
             row = {}
             i = -1
             while (i += 1) < max
-              name, id, type_proc = cols[i]
-              v = values[id]
+              name, type_proc = cols[i]
+              v = values[i]
               if type_proc && v
                 v = type_proc.call(v)
               end