sequel 5.2.0 → 5.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef9b7568e8d79bc20f28c50164f3f51da9882fa6
-  data.tar.gz: 24f2cda374fdc6e9b2e552d69cdad19542a9a06f
+  metadata.gz: ac284f3deba98d7ef4b7213b3f6d17c9df344333
+  data.tar.gz: 3396c7263e758fa01b6820cd1eed79e9f1676be0
 SHA512:
-  metadata.gz: 142a793eec4984fb6e83637758cb2211981199caa498b8bcee98cc87c0e4facf16b2c6829df0fc5cd8a783c99a728eefb84b53fb36d49d312815f712c6cdb667
-  data.tar.gz: '083f6448c19ec9d55567954c316b6a14934f1743e599ccf459b276485064f0af749a7492f42b728ee70df38bf61589775cdd77157b7fee3fcfdf5518d9719f3f'
+  metadata.gz: c0c7a62b97b76a7a10a8ebe6df53c17de99efb70a2403a18362a32bb11a66b736885430911e982a834d60013ba84c154ebb7609c0b1d7d8c103fe8d4000cb549
+  data.tar.gz: 9cffa3dd8f2c87aec5598a5ac14676d061c6214f24f1851f721952c3b9c90a263dd2c4d220dfc828f87181faafe9a4d61fe7daf3d82861db0f752871450611f6

data/CHANGELOG

@@ -1,3 +1,35 @@
+=== 5.3.0 (2017-12-01)
+
+* Add logger to Database instance before making first connection in bin/sequel (jeremyevans)
+
+* Drop support for PostgreSQL <8.1 in Database#indexes (jeremyevans)
+
+* Add synchronize_sql extension, for checking out a connection around SQL generation (KJTsanaktsidis, jeremyevans) (#1451)
+
+* Deprecate Dataset#where calls with no existing filter, no argument, and where the virtual row block returns nil (jeremyevans) (#1454)
+
+* Add DatasetModule#reverse for simpler use of descending orders (jeremyevans)
+
+* Support WITH clauses in subqueries on SQLite, but not in UNION/INTERSECT/EXCEPT (jeremyevans)
+
+* Hoist WITH clauses to INSERT statement level if INSERT subquery uses a CTE on MSSQL (jeremyevans)
+
+* Respect indislive and ignore indcheckxmin index attributes when using Database#indexes on PostgreSQL (jeremyevans)
+
+* Explicitly disallow use of server-side prepared statements when using Dataset#call in the jdbc/postgresql adapter (jeremyevans) (#1448)
+
+* Support common table expressions, window functions, dropping CHECK constraints, and recognizing CURRENT_DATE defaults on MariaDB 10.2+ (jeremyevans)
+
+* Make Database#reset_primary_key_sequence work on PostgreSQL 10+ (jeremyevans)
+
+* Support :connect_sqls Database option for easily issuing sql commands on all new connections (jeremyevans)
+
+* Support :extensions Database option for loading extensions when initializing, useful in connection strings (jeremyevans)
+
+* Avoid warning if trying to rollback after a commit or rollback raises an exception in the postgres adapter (jeremyevans)
+
+* Support Date::Infinity values in the pg_extended_date_support extension (jeremyevans)
+
 === 5.2.0 (2017-10-27)
 
 * Fix type conversion for smallint unsigned and integer unsigned types on jdbc/mysql (jeremyevans) (#1443)

data/bin/sequel

@@ -124,20 +124,19 @@ error_proc["Error: Must specify -m if using -M"] if migrate_ver && !migrate_dir
 error_proc["Error: Cannot specify #{exclusive_options.map{|v| "-#{v}"}.join(' and ')} together"] if exclusive_options.length > 1
 
 connect_proc = lambda do |database|
-  db = if database.nil? || database.empty?
-    Sequel.connect('mock:///')
+  db_opts = {:test=>test, :loggers=>loggers}
+  if database.nil? || database.empty?
+    Sequel.connect('mock:///', db_opts)
   elsif File.exist?(database)
     require 'yaml'
     env ||= "development"
     db_config = YAML.load_file(database)
     db_config = db_config[env] || db_config[env.to_sym] || db_config
     db_config.keys.each{|k| db_config[k.to_sym] = db_config.delete(k)}
-    Sequel.connect(db_config, :test=>test)
+    Sequel.connect(db_config, db_opts)
   else
-    Sequel.connect(database, :test=>test)
+    Sequel.connect(database, db_opts)
   end
-  db.loggers = loggers
-  db
 end
 
 begin

data/doc/release_notes/5.3.0.txt

@@ -0,0 +1,121 @@
+= New Features
+
+* An :extensions Database option is now supported, which will load the
+  named extensions into the Database before any connections are
+  initiated:
+
+    DB = Sequel.connect('mock:///', :extensions=>[:error_sql, :synchronize_sql])
+    DB = Sequel.connect('mock:///?extensions=error_sql,synchronize_sql')
+
+* A :connect_sqls Database option is now supported, which will issue
+  the given queries on all new connections:
+
+    DB = Sequel.connect('postgres:///', :connect_sqls=>[
+        'SET random_page_cost = 1.0',
+        "SET default_tablespace = 'foo'"
+      ])
+
+* DatasetModule#reverse has been added for simpler use of descending
+  orders:
+
+    class Foo < Sequel::Model
+      dataset_module do
+        reverse :newest_first, :created_at
+      end
+    end
+    Foo.newest_first.first(10)
+
+* A synchronize_sql extension has been added.  This extension checks
+  out a connection around SQL string creation, and is useful in the
+  cases where escaping values in the query requires a connection and
+  a large number of values need to be escaped.
+
+* The following features are now supported on MariaDB 10.2+:
+
+  * Common table expressions.
+
+  * Window functions.
+
+  * Dropping CHECK constraints. Older versions of MariaDB/MySQL
+    ignored CHECK constraints that were added, and Sequel did not
+    attempt to filter them out, so Sequel did not require changes to
+    add CHECK constraints.  MariaDB 10.2 CHECK constraints work
+    correctly with Sequel's constraint_validations extension/plugin.
+
+  * Raising CHECK constraint violations as
+    Sequel::CheckConstraintViolation instances.
+
+  * Recognizing curdate() as Sequel::CURRENT_DATE when used as the
+    default value for a date column.
+
+* Date::Infinity values are now supported in the
+  pg_extended_date_support extension:
+
+    DB.convert_infinite_timestamps = :date  
+
+  This returns infinite dates/timestamps as Date::Infinity instances,
+  and literalizes Date::Infinity instances correctly.
+
+= Improvements
+
+* Database#reset_primary_key_sequence now works correctly on
+  PostgreSQL 10.
+
+* If a commit or rollback raises an exception when using the postgres
+  adapter, Sequel will check the connection's current transaction
+  status and only send another rollback if the connection is currently
+  inside a transaction.  This fixes a warning that is issued in most
+  cases if a commit or rollback fails.
+
+* The jdbc/postgresql adapter now forces JDBC PreparedStatement
+  instances created by Dataset#call to never be prepared server side,
+  working around an caching issue in the jdbc-postgres drier in
+  versions greater than 9.4.1200.
+
+* Database#indexes will no longer return indexes which are in the
+  process of being dropped on PostgreSQL 9.3+.  Additionally,
+  Database#indexes will now return indexes that have indcheckxmin
+  set.  The previous removal of indexes with indcheckxmin set is
+  more likely to cause false negatives than correctly remove
+  indexes not yet valid.
+
+* Common table expressions are no longer hoisted from subqueries on
+  SQLite.  They are still hoisted from queries used in
+  UNION/INSERT/EXCEPT, since SQLite does not support common table
+  expressions at that level.
+
+* On Microsoft SQL Server, using an INSERT query with a subquery that
+  uses a common table expression now hoists the common table
+  expression from subquery level to main query level, allowing such
+  queries to work.
+
+* An additional disconnect error is now recognized in the oracle
+  adapter.
+
+* bin/sequel now adds a Database logger before the initial
+  connection is made, allowing you to see any connection setup
+  statements issued to the database.
+
+= Backwards Compatibility
+
+* Calling a filtering method with no argument and a virtual row
+  block that returns nil on a dataset with no existing filter is
+  deprecated in this version and will emit a warning.  The behavior
+  in this version remains the same, where the dataset is not
+  modified. The behavior will change in Sequel 5.4.0 so that a
+  WHERE NULL filter will be added in that case, instead of the
+  filter being ignored, so that the behavior is similar to calling
+  the filtering method with a nil argument.
+
+    # Sequel 5.3.0
+    DB[:a].where{nil}
+    # SELECT * FROM a
+
+    # Sequel 5.4.0
+    DB[:a].where{nil}
+    # SELECT * FROM a WHERE NULL
+
+* Support for PostgreSQL <8.1 has been dropped from Database#indexes.
+  Sequel's PostgreSQL support requires >=8.2 for Dataset#insert to
+  work, so it doesn't make sense to support earlier versions in other
+  cases.

data/doc/schema_modification.rdoc

@@ -398,15 +398,26 @@ creates a new column:
   end
 
 If you want to add a new foreign key constraint to an existing column, you provide an
-array with a single element.  It's encouraged to provide a name when adding the constraint,
-via the :name option:
+array with a single element:
+
+  alter_table(:albums) do
+    add_foreign_key [:artist_id], :artists
+  end
+
+It's encouraged to provide a name when adding the constraint, via the :foreign_key_constraint_name
+option if adding the column and the constraint:
+
+  alter_table(:albums) do
+    add_foreign_key :artist_id, :artists, foreign_key_constraint_name: :albums_artist_id_fkey
+  end
+
+or via the :name option if just adding the constraint:
 
   alter_table(:albums) do
     add_foreign_key [:artist_id], :artists, name: :albums_artist_id_fkey
   end
 
-To set up a multiple column foreign key constraint, use an array with multiple column
-symbols:
+To set up a multiple column foreign key constraint, use an array with multiple column symbols:
 
   alter_table(:albums) do
     add_foreign_key [:artist_name, :artist_location], :artists, name: :albums_artist_name_location_fkey

data/doc/testing.rdoc

@@ -164,3 +164,4 @@ SEQUEL_NO_CHECK_SQLS :: Don't check for specific SQL syntax when running the spe
 SEQUEL_CHECK_PENDING :: Try running all specs (note, can cause lockups for some adapters), and raise errors for skipped specs that don't fail
 SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can cause lockups for some adapters)
 SEQUEL_SPLIT_SYMBOLS :: Turn on symbol splitting when running the adapter and integration specs
+SEQUEL_SYNCHRONIZE_SQL :: Use the synchronize_sql extension when running the specs

data/lib/sequel/adapters/jdbc.rb

@@ -404,6 +404,10 @@ module Sequel
             cps = cps[1]
           else
             log_connection_yield("CLOSE #{name}", conn){cps[1].close} if cps
+            if name
+              opts = Hash[opts]
+              opts[:name] = name
+            end
             cps = log_connection_yield("PREPARE#{" #{name}:" if name} #{sql}", conn){prepare_jdbc_statement(conn, sql, opts)}
             if size = fetch_size
               cps.setFetchSize(size)

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

@@ -151,6 +151,21 @@ module Sequel
           nil
         end
 
+        # Work around issue when using Sequel's bound variable support where the
+        # same SQL is used in different bound variable calls, but the schema has
+        # changed between the calls.  This is necessary as jdbc-postgres versions
+        # after 9.4.1200 violate the JDBC API.  These versions cache separate
+        # PreparedStatement instances, which are eventually prepared server side after the
+        # prepareThreshold is met.  The JDBC API violation is that PreparedStatement#close
+        # does not release the server side prepared statement.
+        def prepare_jdbc_statement(conn, sql, opts)
+          ps = super
+          unless opts[:name]
+            ps.prepare_threshold = 0
+          end
+          ps
+        end
+
         # If the given argument is a recognized PostgreSQL-specific type, create
         # a PGObject instance with unknown type and the bound argument string value,
         # and set that as the prepared statement argument.

data/lib/sequel/adapters/oracle.rb

@@ -11,9 +11,10 @@ module Sequel
 
       # ORA-00028: your session has been killed
       # ORA-01012: not logged on
+      # ORA-02396: exceeded maximum idle time, please connect again
       # ORA-03113: end-of-file on communication channel
       # ORA-03114: not connected to ORACLE
-      CONNECTION_ERROR_CODES = [ 28, 1012, 3113, 3114 ].freeze
+      CONNECTION_ERROR_CODES = [ 28, 1012, 2396, 3113, 3114 ].freeze
       
       ORACLE_TYPES = {
         :blob=>lambda{|b| Sequel::SQL::Blob.new(b.read)},

data/lib/sequel/adapters/postgres.rb

@@ -549,6 +549,10 @@ module Sequel
       def log_connection_execute(conn, sql)
         conn.execute(sql)
       end
+
+      def rollback_transaction(conn, opts=OPTS)
+        super unless conn.transaction_status == 0
+      end
     end
     
     class Dataset < Sequel::Dataset

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

@@ -74,6 +74,7 @@ module Sequel
 
       def freeze
         server_version
+        mariadb?
         supports_timestamp_usecs?
         super
       end
@@ -116,10 +117,16 @@ module Sequel
         run("XA ROLLBACK #{literal(transaction_id)}", opts)
       end
 
+      # Whether the database is MariaDB and not MySQL
+      def mariadb?
+        return @is_mariadb if defined?(@is_mariadb)
+        @is_mariadb = !(fetch('SELECT version()').single_value! !~ /mariadb/i)
+      end
+
       # Get version of MySQL server, used for determined capabilities.
       def server_version
         @server_version ||= begin
-          m = /(\d+)\.(\d+)\.(\d+)/.match(get(SQL::Function.new(:version)))
+          m = /(\d+)\.(\d+)\.(\d+)/.match(fetch('SELECT version()').single_value!)
           (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
         end
       end
@@ -237,6 +244,10 @@ module Sequel
           "DROP FOREIGN KEY #{quote_identifier(name)}"
         when :unique
           "DROP INDEX #{quote_identifier(op[:name])}"
+        when :check, nil 
+          if supports_check_constraints?
+            "DROP CONSTRAINT #{quote_identifier(op[:name])}"
+          end
         end
       end
 
@@ -265,6 +276,11 @@ module Sequel
         super(default, type)
       end
 
+      def column_schema_to_ruby_default(default, type)
+        return Sequel::CURRENT_DATE if mariadb? && server_version >= 100200 && default == 'curdate()'
+        super
+      end
+
       # Don't allow combining adding foreign key operations with other
       # operations, since in some cases adding a foreign key constraint in
       # the same query as other operations results in MySQL error 150.
@@ -390,6 +406,7 @@ module Sequel
         /foreign key constraint fails/ => ForeignKeyConstraintViolation,
         /cannot be null/ => NotNullConstraintViolation,
         /Deadlock found when trying to get lock; try restarting transaction/ => SerializationFailure,
+        /CONSTRAINT .+ failed for/ => CheckConstraintViolation,
       }.freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -470,6 +487,11 @@ module Sequel
         server_version >= 50600 && (op[:op] == :drop_index || (op[:op] == :drop_constraint && op[:type] == :unique))
       end
 
+      # Whether the database supports CHECK constraints
+      def supports_check_constraints?
+        mariadb? && server_version >= 100200
+      end
+
       # MySQL can combine multiple alter table ops into a single query.
       def supports_combining_alter_table_ops?
         true
@@ -545,7 +567,7 @@ module Sequel
 
       Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
-      Dataset.def_sql_method(self, :select, %w'select distinct calc_found_rows columns from join where group having compounds order limit lock')
+      Dataset.def_sql_method(self, :select, %w'with select distinct calc_found_rows columns from join where group having compounds order limit lock')
       Dataset.def_sql_method(self, :update, %w'update ignore table set where order limit')
 
       include Sequel::Dataset::Replace
@@ -713,6 +735,10 @@ module Sequel
         sql << '`' << c.to_s.gsub('`', '``') << '`'
       end
 
+      def supports_cte?(type=:select)
+        type == :select && db.mariadb? && db.server_version >= 100200
+      end
+
       # MySQL does not support derived column lists
       def supports_derived_column_lists?
         false
@@ -760,7 +786,11 @@ module Sequel
       def supports_timestamp_usecs?
         db.supports_timestamp_usecs?
       end
-      
+
+      def supports_window_functions?
+        db.mariadb? && db.server_version >= 100200
+      end
+
       # Sets up the update methods to use UPDATE IGNORE.
       # Useful if you have a unique key and want to just skip
       # updating rows that violate the unique key restriction.
@@ -929,6 +959,11 @@ module Sequel
         sql << ' SQL_CALC_FOUND_ROWS' if opts[:calc_found_rows]
       end
 
+      # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
+      def select_with_sql_base
+        opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
+      end
+
       # MySQL uses WITH ROLLUP syntax.
       def uses_with_rollup?
         true

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

@@ -203,7 +203,6 @@ module Sequel
       # This should be used for types without fixed OIDs, which includes all types that
       # are not included in a default PostgreSQL installation.
       def add_named_conversion_proc(name, &block)
-        name = name.to_s if name.is_a?(Symbol)
         unless oid = from(:pg_type).where(:typtype=>['b', 'e'], :typname=>name.to_s).get(:oid)
           raise Error, "No matching type in pg_type for #{name.inspect}"
         end
@@ -411,10 +410,9 @@ module Sequel
         else
           range = 0...32
           order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
-          attnums = range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])} unless server_version >= 80100 
         end
 
-        attnums ||= SQL::Function.new(:ANY, Sequel[:ind][:indkey])
+        attnums = SQL::Function.new(:ANY, Sequel[:ind][:indkey])
 
         ds = metadata_dataset.
           from{pg_class.as(:tab)}.
@@ -432,7 +430,8 @@ module Sequel
           order(*order).
           select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
-        ds = ds.where(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
+        ds = ds.where(:indisready=>true) if server_version >= 80300
+        ds = ds.where(:indislive=>true) if server_version >= 90300
 
         indexes = {}
         ds.each do |r|
@@ -506,10 +505,20 @@ module Sequel
         return unless seq = primary_key_sequence(table)
         pk = SQL::Identifier.new(primary_key(table))
         db = self
-        seq_ds = db.from(LiteralString.new(seq))
         s, t = schema_and_table(table)
         table = Sequel.qualify(s, t) if s
-        get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
+
+        if server_version >= 100000
+          seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq)))
+          increment_by = :seqincrement
+          min_value = :seqmin
+        else
+          seq_ds = metadata_dataset.from(LiteralString.new(seq))
+          increment_by = :increment_by
+          min_value = :min_value
+        end
+
+        get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)}
       end
 
       def rollback_prepared_transaction(transaction_id, opts=OPTS)