sequel 5.15.0 → 5.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 965fa50e6e91a5630a4e484651180b38b9d2eb2c785be8b91dd5b099e3ba5be6
-  data.tar.gz: 3c3c5bd93d51326fff0081272e41a0a23b0dbb47d393603f073cbc0f0486e6c7
+  metadata.gz: 50240675066a0bd3e480a52ba3ff556b962ae3d8403fb22ee210272f2fffb023
+  data.tar.gz: d1c86ff37811732211b00b251c49bf7c4929ca7b18bf7c6ffeda1b8d0335482f
 SHA512:
-  metadata.gz: a633436d4a066e195e847cffc7dd68d0cd2902915ddca33d5df724dc020aee22dbd95a261f8b15ea1581a73517d5736423a8693f40a3ef59fb27c88b8c24ca01
-  data.tar.gz: bee56c79793138296ced8395deabf2652a68fe2de3bc4f144470d885b253883017e15ca0281e36e04c6064b590b505daed285b23699140e77cae119bddee3914
+  metadata.gz: 6a5a5b35a91ff83c6a0dab3e5cb88e26d79dced018f46fa78ad8be2b4da37c602adba56f849c0591c12f976006ea6e511bb3153478e70f3824ac940772f14de6
+  data.tar.gz: 50f5217691ec39036999623ce8d791fc93c270876d857e30b53892def7d36e0f3c99a3c69b13f97162f45b49dd066f1a5fcbf8b9660f96a1cd5c0c5a23c9ee72

data/CHANGELOG

@@ -1,3 +1,31 @@
+=== 5.16.0 (2019-01-02)
+
+* Convert integer columns to bigint columns when copying SQLite databases to other databases using bin/sequel -C (jeremyevans) (#1584)
+
+* Use nicer error messages for missing or empty migration directories (Lavode) (#1585)
+
+* Make alter table emulation work correctly in SQLite 3.26.0+ (jeremyevans) (#1582)
+
+* Do not unset new one_to_one associated objects' reciprocal associations before saving associated objects in the nested_attributes plugin (jeremyevans)
+
+* Do not validate new one_to_one associated objects twice when saving in the nested_attributes plugin (jeremyevans)
+
+* Fix :qualify_tables option to class_table_inheritance plugin to work correctly with subclasses of subclasses (benalavi) (#1581)
+
+* Make class_table_inheritance plugin use the schema cache instead of sending a query to get columns for tables (kenaniah) (#1580)
+
+* Remove loading of mysqlplus in the mysql adapter (jeremyevans)
+
+* Make mysql adapter work correctly on ruby 2.6+ (jeremyevans)
+
+* Add Database#rollback_on_exit to rollback transactions instead of committing them when exiting the transaction block (jeremyevans)
+
+* Enable window functions in SQLite 3.26.0+ (jeremyevans)
+
+* Do not override existing methods when creating Sequel::Model attribute getter/setter methods (jeremyevans) (#1578)
+
+* Use parentheses for expressions being subscripted (e.g. (array_agg(column))[1]) (jeremyevans)
+
 === 5.15.0 (2018-12-01)
 
 * Add :conn_str option in the postgres adapter for PostgreSQL connection strings, if the pg driver is used (graywolf) (#1572)

data/bin/sequel

@@ -195,6 +195,10 @@ begin
     same_db = DB.database_type==TO_DB.database_type
     index_opts = {:same_db=>same_db}
     index_opts[:index_names] = :namespace if !DB.global_index_namespace? && TO_DB.global_index_namespace?
+    if DB.database_type == :sqlite && !same_db
+      # SQLite integer types allows 64-bit integers
+      TO_DB.extension :integer64
+    end
 
     puts "Databases connections successful"
     schema_migration = eval(DB.dump_schema_migration(:indexes=>false, :same_db=>same_db))

data/doc/opening_databases.rdoc

@@ -233,7 +233,7 @@ jdbc-h2 :: jdbc-h2 versions greater than 1.3.175 have issues with ORDER BY not w
 
 === mysql 
 
-Requires: mysqlplus (or mysql if mysqlplus is not available)
+Requires: mysql
 
 The MySQL adapter does not support the pure-ruby mysql.rb driver, it requires the C-extension driver.
 

data/doc/release_notes/5.16.0.txt

@@ -0,0 +1,110 @@
+= New Features
+
+* Database#rollback_on_exit has been added, which allows you to
+  rollback transactions instead of committing them when exiting
+  the transaction block.  Previously, the only way to rollback
+  a transaction from inside a transaction block was to raise
+  an exception.  This allows you to tell Sequel to roll the
+  transaction back on exit, and then use return or throw to exit
+  the transaction block.
+
+  Database#rollback_on_exit supports savepoints, including
+  multiple savepoint levels, as well as canceling rollbacks:
+
+    DB.transaction do # BEGIN
+      DB.rollback_on_exit
+    end # ROLLBACK
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(savepoint: true)
+      end # ROLLBACK TO SAVEPOINT
+    end # COMMIT
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.transaction(savepoint: true) do # SAVEPOINT
+          DB.rollback_on_exit(savepoint: true)
+        end # ROLLBACK TO SAVEPOINT
+      end # RELEASE SAVEPOINT
+    end # COMMIT
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(savepoint: true)
+      end # ROLLBACK TO SAVEPOINT
+    end # COMMIT
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.transaction(savepoint: true) do # SAVEPOINT
+          DB.rollback_on_exit(savepoint: 2)
+        end # ROLLBACK TO SAVEPOINT
+      end # ROLLBACK TO SAVEPOINT
+    end # COMMIT
+  
+    DB.transaction do # BEGIN
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.transaction(savepoint: true) do # SAVEPOINT
+          DB.rollback_on_exit(savepoint: 3)
+        end # ROLLBACK TO SAVEPOINT
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK
+
+    DB.transaction do # BEGIN
+      DB.rollback_on_exit
+      DB.rollback_on_exit(cancel: true)
+    end # COMMIT
+  
+* Sequel now supports window functions on SQLite 3.26.0+. SQLite
+  technically supports window functions on 3.25.0+, but enabling
+  window function support in Sequel opens up a code path that
+  generates queries that cause older versions of SQLite to produce a
+  segmentation fault.  This bug in SQLite has been fixed in 3.26.0.
+
+= Other Improvements
+
+* Sequel::Model no longer overrides existing methods when defining
+  getters and setters.  Historically, it only checked for existing
+  method definitions for methods that could be directly expressed
+  (e.g. not requiring send).  Sequel 5 broke the check for setter
+  methods that could be directly expressed.  This fixes cases where
+  model inheritance is used and the setter methods are overridden
+  in a parent class.
+
+* Alter table emulation now works correctly on SQLite 3.26.0+.
+
+* The one_to_one association setter does not modify reciprocal
+  associations in cases where doing so is not necessary.  This can
+  fix some cases where the nested_attributes plugin is used.
+
+* The class_table_inheritance plugin can now take advantage of the
+  schema_caching extension to prevent database queries to determine
+  column information when the class is created.
+
+* The nested_attributes plugin no longer validates one_to_one
+  associations twice when saving.
+
+* The class_table_inheritance plugin :qualify_tables option now
+  correctly qualifies subclasses of subclasses.
+
+* SQL expressions that are subscripted are now wrapped in parentheses.
+  This fixes at least subscripting a function expression on
+  PostgreSQL:
+
+    DB[:t].select{array_agg(column).sql_subscript(1)}
+    # SELECT (array_agg(column))[1] FROM t
+
+* Sequel::Migrator now uses more descriptive error messages if a
+  missing or empty migration directory is given.
+
+* bin/sequel -C when converting from SQLite to another database
+  type will now use 64-bit integer columns in the other database when
+  the SQLite column type is integer, as SQLite supports storing
+  64-bit values in integer columns, and most other databases only
+  support 32-bit values in integer columns.
+
+= Backwards Compatibility
+
+* The mysql adapter no longer attempts to load the mysqlplus driver,
+  it now only attempts to load the mysql driver.

data/doc/transactions.rdoc

@@ -36,6 +36,12 @@ If any other exception is raised, the transaction is rolled back, and the except
   end # ROLLBACK
   # ArgumentError raised
 
+If you want the current transaction to be rolled back when the transaction block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit</tt>
+
+  DB.transaction do # BEGIN
+    DB.rollback_on_exit
+  end # ROLLBACK
+
 If you want Sequel::Rollback exceptions to be reraised, use the <tt>rollback: :reraise</tt> option:
 
   DB.transaction(rollback: :reraise) do # BEGIN
@@ -121,6 +127,48 @@ Other exceptions, unless rescued inside the outer transaction block, will rollba
   end # ROLLBACK
   # ArgumentError raised
 
+If you want the current savepoint to be rolled back when the savepoint block exits instead of being committed (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.rollback_on_exit(:savepoint=>true)
+    end # ROLLBACK TO SAVEPOINT
+  end # COMMIT
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>true)
+      end # ROLLBACK TO SAVEPOINT
+    end # RELEASE SAVEPOINT
+  end # COMMIT
+
+If you want the current savepoint to be rolled back when the savepoint block exits (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>true)</tt>
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.rollback_on_exit(:savepoint=>true)
+    end # ROLLBACK TO SAVEPOINT
+  end # COMMIT
+
+If you want the current savepoint and potentially enclosing savepoints to be rolled back when the savepoint blocks exit  (even if an exception is not raised), use <tt>Database#rollback_on_exit(:savepoint=>integer)</tt>
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>2)
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK TO SAVEPOINT
+  end # COMMIT
+
+  DB.transaction do # BEGIN
+    DB.transaction(savepoint: true) do # SAVEPOINT
+      DB.transaction(savepoint: true) do # SAVEPOINT
+        DB.rollback_on_exit(:savepoint=>3)
+      end # ROLLBACK TO SAVEPOINT
+    end # ROLLBACK TO SAVEPOINT
+  end # ROLLBACK
+
 == 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/transactions.rb

@@ -43,17 +43,15 @@ module Sequel
         true
       end
 
+      # JDBC savepoint object for the current savepoint for the connection.
+      def savepoint_obj(conn)
+        _trans(conn)[:savepoints][-1][:obj]
+      end
+
       # Use JDBC connection's setAutoCommit to false to start transactions
       def begin_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          th = _trans(conn)
-          if sps = th[:savepoint_objs]
-            sps << log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
-          else
-            log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
-            th[:savepoint_objs] = []
-            set_transaction_isolation(conn, opts)
-          end
+        if in_savepoint?(conn)
+          _trans(conn)[:savepoints][-1][:obj] = log_connection_yield('Transaction.savepoint', conn){conn.set_savepoint}
         else
           log_connection_yield('Transaction.begin', conn){conn.setAutoCommit(false)}
           set_transaction_isolation(conn, opts)
@@ -62,12 +60,9 @@ module Sequel
       
       # Use JDBC connection's commit method to commit transactions
       def commit_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_connection_yield('Transaction.commit', conn){conn.commit}
-          elsif supports_releasing_savepoints?
-            log_connection_yield('Transaction.release_savepoint', conn){supports_releasing_savepoints? ? conn.release_savepoint(sps.last) : sps.last}
+        if in_savepoint?(conn)
+          if supports_releasing_savepoints?
+            log_connection_yield('Transaction.release_savepoint', conn){conn.release_savepoint(savepoint_obj(conn))}
           end
         else
           log_connection_yield('Transaction.commit', conn){conn.commit}
@@ -77,13 +72,9 @@ module Sequel
       # Use JDBC connection's setAutoCommit to true to enable non-transactional behavior
       def remove_transaction(conn, committed)
         if jdbc_level = _trans(conn)[:original_jdbc_isolation_level]
-          conn.setTransactionIsolation(jdbc_level)
+          log_connection_yield("Transaction.restore_isolation_level", conn){conn.setTransactionIsolation(jdbc_level)}
         end
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          conn.setAutoCommit(true) if sps.empty?
-          sps.pop
-        else
+        unless in_savepoint?(conn)
           conn.setAutoCommit(true)
         end
       ensure
@@ -92,13 +83,8 @@ module Sequel
       
       # Use JDBC connection's rollback method to rollback transactions
       def rollback_transaction(conn, opts=OPTS)
-        if supports_savepoints?
-          sps = _trans(conn)[:savepoint_objs]
-          if sps.empty?
-            log_connection_yield('Transaction.rollback', conn){conn.rollback}
-          else
-            log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(sps.last)}
-          end
+        if in_savepoint?(conn)
+          log_connection_yield('Transaction.rollback_savepoint', conn){conn.rollback(savepoint_obj(conn))}
         else
           log_connection_yield('Transaction.rollback', conn){conn.rollback}
         end

data/lib/sequel/adapters/mysql.rb

@@ -1,10 +1,6 @@
 # frozen-string-literal: true
 
-begin
-  require "mysqlplus"
-rescue LoadError
-  require 'mysql'
-end
+require 'mysql'
 raise(LoadError, "require 'mysql' did not define Mysql::CLIENT_MULTI_RESULTS!\n  You are probably using the pure ruby mysql.rb driver,\n  which Sequel does not support. You need to install\n  the C based adapter, and make sure that the mysql.so\n  file is loaded instead of the mysql.rb file.\n") unless defined?(Mysql::CLIENT_MULTI_RESULTS)
 
 require_relative 'utils/mysql_mysql2'
@@ -21,7 +17,7 @@ module Sequel
     # Hash with integer keys and callable values for converting MySQL types.
     MYSQL_TYPES = {}
     {
-      [0, 246] => ::BigDecimal.method(:new),
+      [0, 246] => ::Kernel.method(:BigDecimal),
       [2, 3, 8, 9, 13, 247, 248] => tt.method(:integer),
       [4, 5] => tt.method(:float),
       [249, 250, 251, 252] => ::Sequel::SQL::Blob.method(:new)

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

@@ -177,7 +177,10 @@ module Sequel
       # needed for drop column.
       def apply_alter_table(table, ops)
         fks = fetch("PRAGMA foreign_keys")
-        run "PRAGMA foreign_keys = 0" if fks
+        if fks
+          run "PRAGMA foreign_keys = 0"
+          run "PRAGMA legacy_alter_table = 1" if sqlite_version >= 32600
+        end
         transaction do 
           if ops.length > 1 && ops.all?{|op| op[:op] == :add_constraint || op[:op] == :set_column_null}
             null_ops, ops = ops.partition{|op| op[:op] == :set_column_null}
@@ -196,7 +199,10 @@ module Sequel
         end
         remove_cached_schema(table)
       ensure
-        run "PRAGMA foreign_keys = 1" if fks
+        if fks
+          run "PRAGMA foreign_keys = 1"
+          run "PRAGMA legacy_alter_table = 0" if sqlite_version >= 32600
+        end
       end
 
       # SQLite supports limited table modification.  You can add a column
@@ -725,6 +731,14 @@ module Sequel
         false
       end
       
+      # SQLite 3.25+ supports window functions.  However, support is only enabled
+      # on SQLite 3.26.0+ because internal Sequel usage of window functions
+      # to implement eager loading of limited associations triggers
+      # an SQLite crash bug in versions 3.25.0-3.25.3.
+      def supports_window_functions?
+        db.sqlite_version >= 32600
+      end
+    
       private
       
       # SQLite uses string literals instead of identifiers in AS clauses.

data/lib/sequel/database/transactions.rb

@@ -52,7 +52,48 @@ module Sequel
         end
       end
     end
-    
+
+    # When exiting the transaction block through methods other than an exception
+    # (e.g. normal exit, non-local return, or throw), set the current transaction
+    # to rollback instead of committing.  This is designed for use in cases where
+    # you want to preform a non-local return but also want to rollback instead of
+    # committing.
+    # Options:
+    # :cancel :: Cancel the current rollback_on_exit setting, so exiting will commit instead
+    #            of rolling back.
+    # :savepoint :: Rollback only the current savepoint if inside a savepoint.
+    #               Can also be an positive integer value to rollback that number of enclosing savepoints,
+    #               up to and including the transaction itself.
+    #               If the database does not support savepoints, this option is ignored and the entire
+    #               transaction is affected.
+    # :server :: The server/shard the transaction is being executed on.
+    def rollback_on_exit(opts=OPTS)
+      synchronize(opts[:server]) do |conn|
+        raise Error, "Cannot call Sequel:: Database#rollback_on_exit! unless inside a transaction" unless h = _trans(conn)
+        rollback = !opts[:cancel]
+
+        if supports_savepoints?
+          savepoints = h[:savepoints]
+
+          if level = opts[:savepoint]
+            level = 1 if level == true
+            raise Error, "invalid :savepoint option to Database#rollback_on_exit: #{level.inspect}" unless level.is_a?(Integer)
+            raise Error, "cannot pass nonpositive integer (#{level.inspect}) as :savepoint option to Database#rollback_on_exit" if level < 1
+            level.times do |i|
+              break unless savepoint = savepoints[-1 - i]
+              savepoint[:rollback_on_exit] = rollback
+            end
+          else
+            savepoints[0][:rollback_on_exit] = rollback
+          end
+        else
+          h[:rollback_on_exit] = rollback
+        end
+      end
+
+      nil
+    end
+
     # Return true if already in a transaction given the options,
     # false otherwise.  Respects the :server option for selecting
     # a shard.
@@ -164,7 +205,7 @@ module Sequel
               end
             end
 
-            if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last
+            if opts[:savepoint] != false && (stack = _trans(conn)[:savepoints]) && stack.last[:auto_savepoint]
               opts[:savepoint] = true
             end
 
@@ -242,10 +283,10 @@ module Sequel
 
       if supports_savepoints?
         if t = _trans(conn)
-          t[:savepoints].push(opts[:auto_savepoint])
+          t[:savepoints].push({:auto_savepoint=>opts[:auto_savepoint]})
           return
         else
-          hash[:savepoints] = [opts[:auto_savepoint]]
+          hash[:savepoints] = [{:auto_savepoint=>opts[:auto_savepoint]}]
           if (prep = opts[:prepare]) && supports_prepared_transactions?
             hash[:prepare] = prep
           end
@@ -293,12 +334,8 @@ module Sequel
 
     # Start a new database transaction or a new savepoint on the given connection.
     def begin_transaction(conn, opts=OPTS)
-      if supports_savepoints?
-        if savepoint_level(conn) > 1
-          begin_savepoint(conn, opts)
-        else
-          begin_new_transaction(conn, opts)
-        end
+      if in_savepoint?(conn)
+        begin_savepoint(conn, opts)
       else
         begin_new_transaction(conn, opts)
       end
@@ -318,7 +355,7 @@ module Sequel
       if exception
         false
       else
-        if Thread.current.status == 'aborting'
+        if rollback_on_transaction_exit?(conn, opts)
           rollback_transaction(conn, opts)
           false
         else
@@ -359,10 +396,15 @@ module Sequel
       []
     end
 
+    # Whether the connection is currently inside a savepoint.
+    def in_savepoint?(conn)
+      supports_savepoints? && savepoint_level(conn) > 1
+    end
+
     # Retrieve the transaction hooks that should be run for the given
     # connection and commit status.
     def transaction_hooks(conn, committed)
-      if !supports_savepoints? || savepoint_level(conn) == 1
+      unless in_savepoint?(conn)
         _trans(conn)[committed ? :after_commit : :after_rollback]
       end
     end
@@ -372,7 +414,7 @@ module Sequel
       callbacks = transaction_hooks(conn, committed)
 
       if transaction_finished?(conn)
-        h = @transactions[conn]
+        h = _trans(conn)
         rolled_back = !committed
         Sequel.synchronize{h[:rolled_back] = rolled_back}
         Sequel.synchronize{@transactions.delete(conn)}
@@ -386,6 +428,17 @@ module Sequel
       "ROLLBACK TO SAVEPOINT autopoint_#{depth}"
     end
 
+    # Whether to rollback the transaction when exiting the transaction.
+    def rollback_on_transaction_exit?(conn, opts)
+      return true if Thread.current.status == 'aborting'
+      h = _trans(conn)
+      if supports_savepoints?
+        h[:savepoints].last[:rollback_on_exit]
+      else
+        h[:rollback_on_exit]
+      end
+    end
+
     # Rollback the active transaction on the connection
     def rollback_transaction(conn, opts=OPTS)
       if supports_savepoints?