sequel 5.7.1 → 5.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a08d35934b3f831634bb0f33f7cab46262242c453f42e1991926d35d7420c17f
-  data.tar.gz: 530c498255c985753b5a2b2411d77d9087606f6f43f91a0e915299b1579c2e67
+  metadata.gz: 5802a8e3fdb50b3d51f78111c604c86c64f0a3705bcf272423f0b9281800720b
+  data.tar.gz: 2257a05863d62c70a871032ecc5fdff36196ab717094af98c096570c08f380a7
 SHA512:
-  metadata.gz: d285a38669b61c579e5388fcd215637ca2f523cdfcf3e4d8290165883e3d567d91bacb3a3212d494aabecb022afa90be2bd0767393429cdc0035566fc9f702de
-  data.tar.gz: 8a81806f41fee72c293aa70b68023e3f3ec79413906649e3deea13198a8c588825166fe70b0bd37f9c77c39aadc77678415a3fea2f00ad7f912036e4861b6982
+  metadata.gz: 3caabfec31c2953c4f0dd57e68dc58466ff416ab80276ae5ac111fffde7a6dcdddf068b074e33e8df4ea6f41ca941f59f60ec1507d5de2a07ce7b3cdb9016c82
+  data.tar.gz: 811720c5223a1e2113b47fb0430870dec6377f8d6d1408f0b61dd52abacd596f26af6077c77cf619692c80a43224f06e44633d5c8bd2ee403eafac3a5e7050db

data/CHANGELOG

@@ -1,7 +1,59 @@
-=== 5.7.1 (2018-04-04)
+=== 5.8.0 (2018-05-01)
+
+* Don't mark SQLAnywhere as supporting WITH in INSERT statement (jeremyevans)
+
+* Support :search_path as a shard option on PostgreSQL (jeremyevans)
+
+* Add Dataset#nowait for raising a Sequel::DatabaseLockTimeout when a locked row is encountered, supported on PostgreSQL, MySQL 8+, MSSQL, and Oracle (jeremyevans)
+
+* Support Dataset#skip_locked on MySQL 8+ (jeremyevans)
+
+* Make schema modification methods in the pg_enum extension work on a frozen Database object (jeremyevans)
+
+* Support common table expressions and window functions on MySQL 8+ (jeremyevans)
+
+* Ignore Dataset#explain :extended option on MySQL 5.7+, since extended output is then the MySQL default (jeremyevans)
+
+* Work around REGEXP BINARY not working correctly on MySQL 8+ by using REGEXP_LIKE with the 'c' match_type (jeremyevans)
+
+* Force correct column order in Database#foreign_key_list on MySQL (jeremyevans)
+
+* Add ConnectionPool#connection_expiration_random_delay to connection_expiration extension, to avoid thundering herd if preallocating connections (hex2a, jeremyevans) (#1503)
+
+* Emit deprecation warning in association_proxies plugin if using #filter on an association proxy, since behavior will change on ruby 2.6+ (utilum) (#1497)
+
+* Handle multiple add_constraint calls and a set_column_null call in the same alter_table block on SQLite (jeremyevans) (#1498)
+
+* Add Database#rename_enum to the pg_enum extension (AlexWayfer) (#1495)
+
+* Make tactical_eager_loading plugin respect the :allow_eager association option (jeremyevans) (#1494)
+
+* Add pg_auto_constraint_validations plugin, for automatically converting constraint violations to validation failures on PostgreSQL (jeremyevans)
+
+* Don't make Model#_valid? public in the error_splitter plugin (jeremyevans)
+
+* Support Database#indexes :include_partial option on PostgreSQL for including partial indexes (jeremyevans)
+
+* Include more diagnostic information in Database#error_info on PostgreSQL (jeremyevans)
+
+* Support Database#foreign_key_list :reverse option on PostgreSQL for parsing foreign key constraints that reference a given table (jeremyevans)
+
+* Add Database#check_constraints on PostgreSQL for parsing CHECK constraints (jeremyevans)
 
 * Don't use identity columns if :serial=>true or :type=>:serial|:bigserial column options are used (#1490) (jeremyevans)
 
+* Cache Dataset#select_all datasets if no arguments are given (jeremyevans)
+
+* Cache Dataset#returning datasets if no arguments are given (jeremyevans)
+
+* Cache Dataset#qualify datasets if no argument is given (jeremyevans)
+
+* Cache Dataset#lateral datasets (jeremyevans)
+
+* Cache Dataset#from_self datasets if no options are given (jeremyevans)
+
+* Cache Dataset#distinct datasets if no arguments or block is given (jeremyevans)
+
 === 5.7.0 (2018-04-01)
 
 * Add Sequel.start_timer and .elapsed_seconds_since for more accurate elapsed time calculations on ruby 2.1+ (jeremyevans)

data/doc/association_basics.rdoc

@@ -859,13 +859,13 @@ The defaults for any of these options can be set at the class level using
 <tt>Sequel::Model.default_association_options</tt>.  To make
 associations read only by default:
 
-Sequel::Model.default_association_options[:read_only] = true
+  Sequel::Model.default_association_options[:read_only] = true
 
 Many of these options are specific to particular association types, and
 the defaults can be set on a per association type basis.  To make one_to_many
 associations read only by default:
 
-Sequel::Model.default_association_type_options[:one_to_many] = {read_only: true}
+  Sequel::Model.default_association_type_options[:one_to_many] = {read_only: true}
 
 === Association Dataset Modification Options
 

data/doc/migration.rdoc

@@ -469,21 +469,16 @@ or equal to that version will be migrated up.
 
 == Running migrations from a Rake task
 
-You can also incorporate migrations into a Rakefile. Here's an example
-using integer migration versions.
+You can also incorporate migrations into a Rakefile:
 
   namespace :db do
     desc "Run migrations"
     task :migrate, [:version] do |t, args|
-      require "sequel"
+      require "sequel/core"
       Sequel.extension :migration
-      db = Sequel.connect(ENV.fetch("DATABASE_URL"))
-      if args[:version]
-        puts "Migrating to version #{args[:version]}"
-        Sequel::Migrator.run(db, "db/migrations", target: args[:version].to_i)
-      else
-        puts "Migrating to latest"
-        Sequel::Migrator.run(db, "db/migrations")
+      version = args[:version].to_i if args[:version]
+      Sequel.connect(ENV.fetch("DATABASE_URL")) do |db|
+        Sequel::Migrator.run(db, "db/migrations", target: version)
       end
     end
   end
@@ -506,6 +501,12 @@ migration takes, you can use the <tt>-E</tt> option to +sequel+ to set up a
 +Database+ logger that logs to +STDOUT+.  You can also log that same output to
 a file using the <tt>-l</tt> option with a log file name.
 
+If you want to include a logger in the rake task above, add a +:logger+ option
+when calling Sequel.connect:
+
+  require "logger"
+  Sequel.connect(ENV.fetch("DATABASE_URL"), logger: Logger.new($stderr))
+
 == Using models in your migrations
 
 Just don't do it.

data/doc/postgresql.rdoc

@@ -189,6 +189,49 @@ Sequel has built in support for creating and dropping PostgreSQL schemas, proced
 
 However, you may want to consider just use <tt>Database#run</tt> with the necessary SQL code, at least for functions and triggers.
 
+=== Parsing Check Constraints
+
+Sequel has support for parsing CHECK constraints on PostgreSQL using <tt>Sequel::Database#check_constraints</tt>:
+
+  DB.create_table(:foo) do
+    Integer :i
+    Integer :j
+    constraint(:ic, Sequel[:i] > 2)
+    constraint(:jc, Sequel[:j] > 2)
+    constraint(:ijc, Sequel[:i] - Sequel[:j] > 2)
+  end
+  DB.check_constraints(:foo)
+  # => {
+  #  :ic=>{:definition=>"CHECK ((i > 2))", :columns=>[:i]},
+  #  :jc=>{:definition=>"CHECK ((j > 2))", :columns=>[:j]},
+  #  :ijc=>{:definition=>"CHECK (((i - j) > 2))", :columns=>[:i, :j]}
+  # }
+
+=== Parsing Foreign Key Constraints Referencing A Given Table
+
+Sequel has support for parsing FOREIGN KEY constraints that reference a given table, using the +:reverse+
+option to +foreign_key_list+:
+
+  DB.create_table!(:a) do
+    primary_key :id
+    Integer :i
+    Integer :j
+    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+    unique [:i, :j]
+  end
+  DB.create_table!(:b) do
+    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+    Integer :c
+    Integer :d
+    foreign_key [:c, :d], :a, :key=>[:j, :i], :name=>:a_c_d
+  end
+  DB.foreign_key_list(:a, :reverse=>true)
+  # => [
+  #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:a, :schema=>:public},
+  #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public},
+  #  {:name=>:a_c_d, :columns=>[:c, :d], :key=>[:j, :i], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public}
+  # ]
+
 == PostgreSQL-specific DML Support
 
 === Returning Rows From Insert, Update, and Delete Statements
@@ -397,6 +440,34 @@ handle locking:
   # INSERT INTO "table" ("id") VALUES (2) RETURNING NULL;
   # COMMIT;
 
+== Extended Error Info (<tt>postgres/pg only</tt>)
+
+If you run a query that raises a Sequel::DatabaseError, you can pass the exception object to
+<tt>Database#error_info</tt>, and that will return a hash with metadata regarding the error,
+such as the related table and column or constraint.
+
+  DB.create_table(:test1){primary_key :id}
+  DB.create_table(:test2){primary_key :id; foreign_key :test1_id, :test1}
+  DB[:test2].insert(:test1_id=>1) rescue DB.error_info($!)
+  # => {
+  #  :schema=>"public",
+  #  :table=>"test2",
+  #  :column=>nil,
+  #  :constraint=>"test2_test1_id_fkey",
+  #  :type=>nil,
+  #  :severity=>"ERROR",
+  #  :sql_state=>"23503",
+  #  :message_primary=>"insert or update on table \"test2\" violates foreign key constraint \"test2_test1_id_fkey\"",
+  #  :message_detail=>"Key (test1_id)=(1) is not present in table \"test1\"."
+  #  :message_hint=>nil,
+  #  :statement_position=>nil,
+  #  :internal_position=>nil,
+  #  :internal_query=>nil,
+  #  :source_file=>"ri_triggers.c",
+  #  :source_line=>"3321",
+  #  :source_function=>"ri_ReportViolation"
+  # }
+
 == sequel_pg (<tt>postgres/pg only</tt>)
 
 When the postgres adapter is used with the pg driver, Sequel automatically checks for sequel_pg, and

data/doc/release_notes/5.8.0.txt

@@ -0,0 +1,170 @@
+= New Features
+
+* A pg_auto_constraint_validations plugin has been added, which
+  automatically converts many constraint violations raised as
+  exceptions to ValidationFailed exceptions when saving a model
+  instance.
+
+  The following constraint violation types are recognized and
+  supported:
+
+  * NOT NULL
+  * CHECK
+  * UNIQUE (except expression/functional indexes)
+  * FOREIGN KEY (both referencing and referenced by)
+
+  In the cases where the plugin cannot determine an appropriate
+  validation failure for the constraint violation, it just
+  reraises the original exception.
+
+  This plugin is not intended as a replacement for other validations,
+  it is intended as a last resort.  The purpose of validations is to
+  provide nice error messages for the user, and the error messages
+  generated by this plugin are fairly generic.  The error messages can
+  be customized using the :messages plugin option, but there is only a
+  single message used per constraint type.
+
+* Database#check_constraints has been added on PostgreSQL.  This
+  returns metadata related to each check constraint on a table:
+
+    DB.create_table(:foo) do
+      Integer :i
+      Integer :j
+      constraint(:ic, Sequel[:i] > 2)
+      constraint(:jc, Sequel[:j] > 2)
+      constraint(:ijc, Sequel[:i] - Sequel[:j] > 2)
+    end
+    DB.check_constraints(:foo)
+    # => {
+    #  :ic=>{:definition=>"CHECK ((i > 2))", :columns=>[:i]},
+    #  :jc=>{:definition=>"CHECK ((j > 2))", :columns=>[:j]},
+    #  :ijc=>{:definition=>"CHECK (((i - j) > 2))", :columns=>[:i, :j]}
+    # }
+
+* Database#foreign_key_list now supports a :reverse option on
+  PostgreSQL, which returns foreign keys referencing the given table,
+  instead of of foreign keys in the given table referencing other
+  tables:
+
+    DB.create_table!(:a) do
+      primary_key :id
+      Integer :i
+      Integer :j
+      foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+      unique [:i, :j]
+    end
+    DB.create_table!(:b) do
+      foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
+      Integer :c
+      Integer :d
+      foreign_key [:c, :d], :a, :key=>[:j, :i], :name=>:a_c_d
+    end
+    DB.foreign_key_list(:a, :reverse=>true)
+    # => [
+    #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action,
+    #   :on_delete=>:no_action, :deferrable=>false, :table=>:a, :schema=>:public},
+    #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action,
+    #   :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public},
+    #  {:name=>:a_c_d, :columns=>[:c, :d], :key=>[:j, :i], :on_update=>:no_action,
+    #   :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public}
+    # ]
+
+* Dataset#nowait has been added, which will make the query fail
+  with a Sequel::DatabaseLockTimeout exception if it encounters
+  a locked row, overriding the default database behavior that
+  would wait until the lock was released. This method is supported
+  on PostgreSQL, Microsoft SQL Server, Oracle, and MySQL 8+.
+
+* Database#indexes now supports an :include_partial option on
+  PostgreSQL, which will include partial indexes in the output (Sequel
+  by default excludes partial indexes).
+
+* Common table expressions and window functions are now supported when
+  using MySQL 8+.
+
+* Dataset#skip_locked is now supported on MySQL 8+.
+
+* The connection_expiration extension now supports a
+  Database#connection_expiration_random_delay attribute, which is used
+  to randomize the expiration times, avoiding the thundering herd
+  problem.
+
+* The pg_enum extension now supports a rename_enum method for renaming
+  existing enum types.
+
+* Database#error_info on PostgreSQL now returns much more metadata
+  regarding the error.
+
+= Other Improvements
+
+* The dataset returned by the following dataset methods is cached,
+  which can improve performance significantly in certain cases:
+
+  * #distinct (without arguments or block)
+  * #from_self (without options)
+  * #lateral
+  * #qualify (without argument)
+  * #returning (without arguments)
+  * #select_all (without arguments)
+
+* If the primary_key serial: true, type: :serial, or type: :bigserial
+  options are given on PostgreSQL 10.2+, use a serial primary key
+  instead of an identity primary key.  This change was included in
+  Sequel 5.7.1.
+
+* The :search_path Database option is now supported as a shard
+  option on PostgreSQL, so different shards can use different
+  search paths.
+
+* The correct column order in Database#foreign_key_list on MySQL is
+  now forced, fixing issues on MySQL 8+.
+
+* When using case sensitive regexp matches on MySQL 8+, Sequel now
+  uses the REGEXP_LIKE function instead of the REGEXP BINARY
+  operator, to work around what appears to be a bug in MySQL 8+
+  related to the change in MySQL's regexp engine.
+
+* On MySQL 5.7+, the :extended option to Dataset#explain is now
+  ignored, since the :extended option's behavior in previous
+  MySQL versions is now the default behavior.
+
+* The MySQL HY000 generic SQL state error code is now ignored
+  in the mysql2 adapter, so it falls back to using the more
+  accurate backup error mapping in that case.
+
+* The pg_enum extension's schema modification methods now work
+  correctly if the Database instance is frozen.
+
+* The tactical_eager_loading plugin now respects the :allow_eager
+  association option, and will not attempt to eagerly load
+  associations when :allow_eager is false.
+
+* Using multiple add_constraint calls and a set_column_null call in
+  the same alter_table block on SQLite now works correctly.  Note
+  that if you are planning on ever modifying existing tables beyond
+  adding columns, you should probably choose a database that natively
+  supports such modification (SQLite does not).
+
+* Hashes returned by Database#foreign_key_list on PostgreSQL now
+  include a :schema entry, unless the support has been enabled
+  to make the :table entry be a qualified identifier.
+
+* Dataset#support_cte?(:insert) no longer returns true on
+  SQLAnywhere.  SQLAnywhere only supports common table
+  expressions for INSERT ... SELECT, not for all INSERT
+  statements. INSERT ... WITH ... SELECT is already
+  supported in Sequel using:
+
+    DB[:t1].insert(DB[:t2].with(DB[:t3]))
+
+* Model#_valid? is no longer made a public method in the
+  error_splitter plugin.
+
+= Backwards Compatibility
+
+* Calling the filter method on a proxy object returned by the
+  association_proxies plugin now warns on ruby <2.6.  This is
+  because starting in ruby 2.6, the behavior will change and the
+  method will be called on the array of associated objects
+  instead of on the dataset, as Enumerable#filter is being added
+  in ruby 2.6.

data/lib/sequel/adapters/jdbc.rb

@@ -211,7 +211,7 @@ module Sequel
             end
           end
         end
-        setup_connection(conn)
+        setup_connection_with_opts(conn, opts)
       end
 
       # Close given adapter connections, and delete any related prepared statements.
@@ -585,6 +585,11 @@ module Sequel
         conn
       end
 
+      # Setup the connection using the given connection options. Return the connection.  Can be overridden in subadapters for database specific setup.
+      def setup_connection_with_opts(conn, opts)
+        setup_connection(conn)
+      end
+
       def schema_column_set_db_type(schema)
         case schema[:type]
         when :string

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

@@ -187,10 +187,10 @@ module Sequel
         end
 
         # Execute the connection configuration SQL queries on the connection.
-        def setup_connection(conn)
-          conn = super(conn)
+        def setup_connection_with_opts(conn, opts)
+          conn = super
           statement(conn) do |stmt|
-            connection_configuration_sqls.each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
+            connection_configuration_sqls(opts).each{|sql| log_connection_yield(sql, conn){stmt.execute(sql)}}
           end
           conn
         end

data/lib/sequel/adapters/mysql2.rb

@@ -195,7 +195,8 @@ module Sequel
       end
 
       def database_exception_sqlstate(exception, opts)
-        exception.sql_state
+        state = exception.sql_state
+        state unless state == 'HY000'
       end
 
       def dataset_class_default

data/lib/sequel/adapters/postgres.rb

@@ -220,7 +220,7 @@ module Sequel
           end
         end
 
-        connection_configuration_sqls.each{|sql| conn.execute(sql)}
+        connection_configuration_sqls(opts).each{|sql| conn.execute(sql)}
         conn
       end
       
@@ -247,26 +247,48 @@ module Sequel
 
       if USES_PG && Object.const_defined?(:PG) && ::PG.const_defined?(:Constants) && ::PG::Constants.const_defined?(:PG_DIAG_SCHEMA_NAME)
         # Return a hash of information about the related PGError (or Sequel::DatabaseError that
-        # wraps a PGError), with the following entries:
+        # wraps a PGError), with the following entries (any of which may be +nil+):
         #
         # :schema :: The schema name related to the error
         # :table :: The table name related to the error
         # :column :: the column name related to the error
         # :constraint :: The constraint name related to the error
         # :type :: The datatype name related to the error
+        # :severity :: The severity of the error (e.g. "ERROR")
+        # :sql_state :: The SQL state code related to the error
+        # :message_primary :: A single line message related to the error
+        # :message_detail :: Any detail supplementing the primary message
+        # :message_hint :: Possible suggestion about how to fix the problem
+        # :statement_position :: Character offset in statement submitted by client where error occurred (starting at 1)
+        # :internal_position :: Character offset in internal statement where error occurred (starting at 1)
+        # :internal_query :: Text of internally-generated statement where error occurred
+        # :source_file :: PostgreSQL source file where the error occurred
+        # :source_line :: Line number of PostgreSQL source file where the error occurred
+        # :source_function :: Function in PostgreSQL source file where the error occurred
         #
         # This requires a PostgreSQL 9.3+ server and 9.3+ client library,
         # and ruby-pg 0.16.0+ to be supported.
         def error_info(e)
           e = e.wrapped_exception if e.is_a?(DatabaseError)
           r = e.result
-          h = {}
-          h[:schema] = r.error_field(::PG::PG_DIAG_SCHEMA_NAME)
-          h[:table] = r.error_field(::PG::PG_DIAG_TABLE_NAME)
-          h[:column] = r.error_field(::PG::PG_DIAG_COLUMN_NAME)
-          h[:constraint] = r.error_field(::PG::PG_DIAG_CONSTRAINT_NAME)
-          h[:type] = r.error_field(::PG::PG_DIAG_DATATYPE_NAME)
-          h
+          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),
+            :constraint => r.error_field(::PG::PG_DIAG_CONSTRAINT_NAME),
+            :type => r.error_field(::PG::PG_DIAG_DATATYPE_NAME),
+            :severity => r.error_field(::PG::PG_DIAG_SEVERITY),
+            :sql_state => r.error_field(::PG::PG_DIAG_SQLSTATE),
+            :message_primary => r.error_field(::PG::PG_DIAG_MESSAGE_PRIMARY),
+            :message_detail => r.error_field(::PG::PG_DIAG_MESSAGE_DETAIL),
+            :message_hint => r.error_field(::PG::PG_DIAG_MESSAGE_HINT),
+            :statement_position => r.error_field(::PG::PG_DIAG_STATEMENT_POSITION),
+            :internal_position => r.error_field(::PG::PG_DIAG_INTERNAL_POSITION),
+            :internal_query => r.error_field(::PG::PG_DIAG_INTERNAL_QUERY),
+            :source_file => r.error_field(::PG::PG_DIAG_SOURCE_FILE),
+            :source_line => r.error_field(::PG::PG_DIAG_SOURCE_LINE),
+            :source_function => r.error_field(::PG::PG_DIAG_SOURCE_FUNCTION)
+          }
         end
       end
       
@@ -482,7 +504,7 @@ module Sequel
       end
 
       # Set the DateStyle to ISO if configured, for faster date parsing.
-      def connection_configuration_sqls
+      def connection_configuration_sqls(opts=@opts)
         sqls = super
         sqls << "SET DateStyle = 'ISO'" if @use_iso_date_format
         sqls