sequel 5.21.0 → 5.26.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 33b35675e5f68471b8216acbbe10085992616ae93b6f47191c44bb3860b38285
-  data.tar.gz: e1be4ce80c4810a9022505f7e5d0becaa11912f6e91344b860195e6b11438d27
+  metadata.gz: 8c7e9baac1a3a326ffdc2506dde798441b376fecbe71594cd91efb54bc56a9a7
+  data.tar.gz: d051640fc5fb89053beaa43915eca9920222d7978be91bc704cde94f1b425532
 SHA512:
-  metadata.gz: fedb31816a3c56136b007317f135072c318e71938c3375feff8c0ab2ec7ddc5744457008266434dff285095b09bfdf78ab33a24b0b4ac255119f9e80ae6758f1
-  data.tar.gz: eea67a798eedf2cb8b10bbf20eaf3b0deb7e9eabd1c9b8f238754ffbbd4afea394caa8b4574db7bda6373db987a8a088f83732ea353591eeca37ee4583d57730
+  metadata.gz: 0e424392185dec97acca2092fb5b3127a6619033dd62eef683f29501ece0ecacd17ada2a2b1edf27682155c6d59633fa88a475dd1ebf4bdbf8f1641f73a566a8
+  data.tar.gz: 8c1ac728b94de7b5f0cf9a3df230f35732906accea64a0b61b6eba90203e49396eacc95786ad7a78bc56b3b812cda8bd94d4e8f1d0be188b9d9ae4f49792a9de

data/CHANGELOG

@@ -1,3 +1,83 @@
+=== 5.26.0 (2019-11-01)
+
+* Recognize two additional foreign key constraint violation codes on MySQL 8.0.13+ (rianmcguire) (#1657)
+
+* Support table aliases for single-table INSERT statements on PostgreSQL 9.5+ (jeremyevans) (#1656)
+
+* Implement Sequel::Postgres::PGRange#hash so instances work correctly in hashes (jeremyevans) (#1648)
+
+* Make dirty plugin work correctly with typecast_on_load plugin (jeremyevans) (#1647)
+
+* Add support for :require_modification option when setting up nested_attributes (jeremyevans)
+
+* Add support for SQL/JSON path expressions to the pg_json_ops extension, supported by PostgreSQL 12+ (jeremyevans)
+
+=== 5.25.0 (2019-10-01)
+
+* Fix Sequel::SQL::NumericMethods#coerce to not raise NoMethodError if super method is not defined (jeremyevans) (#1645)
+
+* Allow setting a default for a column that already has a default on Microsoft SQL Server (jeremyevans)
+
+* Fix keyword argument separation warnings on Ruby master branch in csv_serializer plugin (jeremyevans)
+
+* Add association_multi_add_remove plugin for adding/removing multiple associated objects in a single method call (AlexWayfer, jeremyevans) (#1641, #1643)
+
+* Make sharding plugin integrate with server_block extension (jeremyevans)
+
+=== 5.24.0 (2019-09-01)
+
+* Add Database#skip_logging? private method designed for extensions to force query timing even if no logger is present (adam12) (#1640)
+
+* Allow a hostname specified in a defaults_file in the mysql2 adapter, by not explicitly setting :host (sapio-bdeamer) (#1638)
+
+* Convert all database array types to Ruby arrays in the jdbc adapter (jeremyevans)
+
+* Add static_cache_cache plugin for caching rows for static_cache models to a file to avoid database queries during model initialization (jeremyevans)
+
+* Add :cache_file plugin option to pg_auto_constraint_validations plugin, for caching metadata to a file for faster initialization (jeremyevans)
+
+* Support :unique_deferrable and :primary_key_deferrable column options (jeremyevans)
+
+* Support :generated_always_as column option on PostgreSQL 12+ (jeremyevans)
+
+=== 5.23.0 (2019-08-01)
+
+* Work around a bug on jdbc-sqlite3 3.27.2.1 when parsing schema for tables with columns with default values (jeremyevans)
+
+* Work around a bug in jdbc-sqlite3 3.27.2.1 when in Database#foreign_key_list in the jdbc/sqlite3 adapter (jeremyevans)
+
+* Make Dataset#execute* private methods respect explicit servers option, fixing Dataset#paged_each in the postgres adapter when sharding (jeremyevans) (#1632)
+
+* Handle instances of subclasses of core classes when wrapping objects in the pg_json extension (jeremyevans) (#1631)
+
+* Support :ansi Database option in the tinytds adapter (kenaniah) (#1629)
+
+* Support cross-database and linked servers when parsing schema on Microsoft SQL Server (kenaniah) (#1629)
+
+* Add insert_conflict plugin for automatically handling unique constraint conflicts when saving new model instances on PostgreSQL 9.5+ and SQLite 3.24.0+ (jeremyevans)
+
+* Avoid errors when parsing schema in the mock sqlite adapter (jeremyevans)
+
+* Avoid possible thread-safety issue in the timezones support (jeremyevans)
+
+* Handle offsets when typecasting an array or hash to datetime when Sequel.datetime_class = Time (jeremyevans)
+
+* Support Sequel.datetime_class = Time when using the named_timezones extension (jeremyevans)
+
+=== 5.22.0 (2019-07-01)
+
+* Fix Dataset#multi_insert and #import with return: :primary_key on MSSQL when the dataset has a row_proc (jeremyevans) (#1627)
+
+* Support Dataset#with :materialized option on PostgreSQL 12 for [NOT] MATERIALIZED (jeremyevans)
+
+* Make Database#primary_key_sequence work on tables without serial sequences on PostgreSQL 12 (jeremyevans)
+
+* Support ruby 2.7+ startless ranges in the pg_range extension (jeremyevans)
+
+* Support ruby 2.7+ startless, endless ranges in filters, using an always true condition for them (jeremyevans)
+
+* Support ruby 2.7+ startless ranges in filters, using just a <= or < operator for them (jeremyevans)
+
 === 5.21.0 (2019-06-01)
 
 * Recognize additional DatabaseLockTimeout errors in mysql and mysql2 adapters (jeremyevans)

data/README.rdoc

@@ -578,7 +578,7 @@ A single model instance can also be fetched by specifying a condition:
   post = Post.first(title: 'hello world')
   post = Post.first{num_comments < 10}
 
-The dataset for a model class returns rows a model instances instead of plain hashes:
+The dataset for a model class returns rows of model instances instead of plain hashes:
 
   DB[:posts].first.class # => Hash
   Post.first.class # => Post

data/doc/dataset_filtering.rdoc

@@ -106,6 +106,21 @@ You can also use placeholders with :placeholder and a hash of placeholder values
   items.where(Sequel.lit('category = :category', category: "ruby")).sql
   # "SELECT * FROM items WHERE category = 'ruby'"
 
+In order to combine AND and OR together, you have a few options:
+
+  items.where(category: nil).or(category: "ruby")
+  # SELECT * FROM items WHERE (category IS NULL) OR (category = 'ruby')
+
+This won't work if you add other conditions:
+
+  items.where(name: "Programming in Ruby").where(category: nil).or(category: 'ruby')
+  # SELECT * FROM items WHERE ((name = 'Programming in Ruby') AND (category IS NULL)) OR (category = 'ruby')
+
+The OR applies globally and not locally. To fix this, use & and |:
+
+  items.where(Sequel[name: "Programming in Ruby"] & (Sequel[category: nil] | Sequel[category: "ruby"]))
+  # SELECT * FROM items WHERE ((name = 'Programming in Ruby') AND ((category IS NULL) OR (category = 'ruby')))
+
 === Specifying SQL functions
 
 Sequel also allows you to specify functions by using the Sequel.function method:

data/doc/opening_databases.rdoc

@@ -401,6 +401,9 @@ options that you may want to set are :login_timeout, :timeout, :tds_version, :az
 
 Other Sequel specific options:
 
+:ansi :: Set to true to enable the ANSI compatibility settings when connecting
+         (ANSI_NULLS, ANSI_PADDING, ANSI_WARNINGS, ANSI_NULL_DFLT_ON, QUOTED_IDENTIFIER,
+         CONCAT_NULL_YIELDS_NULL).
 :server_version :: Override the server version to use (9000000 = SQL Server 2005).
                    This also works on any other adapter that connects to Microsoft
                    SQL Server.

data/doc/postgresql.rdoc

@@ -341,12 +341,12 @@ Dataset#overriding_system_value and Dataset#overriding_user_value to use this ne
 syntax:
 
   DB.create_table(:table){primary_key :id}
-  # Ignore the given value for id, using the identity's sequence value
+  # Ignore the given value for id, using the identity's sequence value.
   DB[:table].overriding_user_value.insert(:id=>1)
 
   DB.create_table(:table){primary_key :id, :identity=>:always}
   # Force the use of the given value for id, because otherwise the insert will
-  # raise an error, since GENERATED ALWAYS was using when creating the column.
+  # raise an error, since GENERATED ALWAYS was used when creating the column.
   DB[:table].overriding_system_value.insert(:id=>1)
 
 === Distinct On Specific Columns

data/doc/release_notes/5.22.0.txt

@@ -0,0 +1,48 @@
+= New Features
+
+* Sequel now supports Ruby 2.7+ startless ranges in filters:
+
+    DB[:table].where(:column=>(..10))
+    # SELECT * FROM table WHERE (column <= 10)
+
+    DB[:table].where(:column=>(...10))
+    # SELECT * FROM table WHERE (column < 10)
+
+  It also supports startless, endless ranges in filters, using a
+  condition that is always true:
+
+    DB[:table].where(:column=>(nil..nil))
+    # SELECT * FROM table WHERE (1 = 1)
+
+* Sequel now supports startless ranges in the pg_range extension:
+
+    DB.extension :pg_range
+
+    DB[:table].insert(:column=>(..10))
+    # INSERT INTO "table" ("column") VALUES ('[,10]') RETURNING "id"
+
+    DB[:table].insert(:column=>(...10))
+    # INSERT INTO "table" ("column") VALUES ('[,10)') RETURNING "id"
+
+    DB[:table].insert(:column=>(nil..nil))
+    # INSERT INTO "table" ("column") VALUES ('[,]') RETURNING "id"
+
+* Sequel now supports a :materialized option in Dataset#with on
+  PostgreSQL 12+, to control the inlining of common table expressions:
+
+    DB[:t].with(:t, DB[:t2], :materialized=>false)
+    # WITH "t" AS NOT MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+    DB[:t].with(:t, DB[:t2], :materialized=>true)
+    # WITH "t" AS MATERIALIZED (SELECT * FROM "t2")
+    # SELECT * FROM "t"
+
+= Other Improvements
+
+* Database#primary_key_sequence now works for tables without serial
+  sequences on PostgreSQL 12+.
+
+* Dataset#multi_insert and #import with return: :primary_key option
+  on Microsoft SQL Server now work correctly if the dataset uses
+  a row_proc (e.g. for model datasets).

data/doc/release_notes/5.23.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* An insert_conflict plugin has been added for automatically handling
+  constraint conflicts when saving new model instances.  It is
+  supported on PostgreSQL 9.5+ and SQLite 3.24.0+.
+
+    Album.new(name: 'Foo', copies_sold: 1000).
+      insert_conflict(
+        target: :name,
+        update: {copies_sold: Sequel[:excluded][:b]}
+      ).
+      save
+
+* On Microsoft SQL Server, the Database :ansi option has been added,
+  which sets the following ANSI related options:
+
+  * ANSI_NULLS
+  * ANSI_PADDING
+  * ANSI_WARNINGS
+  * ANSI_NULL_DFLT_ON
+  * QUOTED_IDENTIFIER
+  * CONCAT_NULL_YIELDS_NULL
+
+= Other Improvements
+
+* Sequel.datetime_class = Time is now supported when using the
+  named_timezones extension.  For backwards compatibility, the
+  named_timezones extension still sets
+  Sequel.datetime_class = DateTime.  When using Ruby 2.6+, the
+  Time instances have the timezone set on them using Ruby 2.6+'s
+  timezone support, but basic support works correctly in earlier
+  versions of Ruby.
+
+* On Microsoft SQL Server, Sequel now handles parsing schema for
+  tables in another database on the same server or in a database
+  on a linked server.
+
+* The pg_json extension now correctly handles subclasses of core
+  classes when wrapping objects.  This stopped working in Sequel
+  5.21.0, when support for wrapping JSON primitives was added.
+
+* Sequel now works around a couple bugs in jdbc-sqlite 3.27.2.1,
+  allowing schema parsing and foreign key parsing to work.
+
+* Dataset#execute* private methods now respect an explicitly given
+  :server option, fixing Dataset#paged_each in the postgres adapter
+  when using sharding.
+
+* Timezone offsets are now handled correctly when typecasting an array
+  or hash to datetime when Sequel.datetime_class = Time.
+
+* Sequel now avoids errors when parsing schema when using the mock
+  SQLite adapter.
+
+* A minor thread-safety issue has been fixed in the named_timezones
+  extension.

data/doc/release_notes/5.24.0.txt

@@ -0,0 +1,56 @@
+= New Features
+
+* A :cache_file plugin option has been added to the
+  pg_auto_constraint_validations plugin.  This option specifies
+  a file to use to cache the metadata the plugin uses, so the
+  plugin does not need to run 5 queries per model at startup to
+  load the metadata.  This can dramatically improve startup time
+  when using the plugin with a large number of models.
+
+  To create the metadata file, load the plugin into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) with the :cache_file option, and after loading
+  all of the subclasses of that class, run:
+
+    Sequel::Model.dump_pg_auto_constraint_validations_cache
+
+  As when using the schema_caching and index_caching extensions,
+  it is up to the user to ensure that the cached metadata matches
+  the current database schema.  Sequel does no checking of this,
+  as checking would take more time, and the point of this plugin
+  is to improve startup performance.
+
+* A static_cache_cache plugin has been added.  This plugin allows
+  for caching rows for models using the static_cache plugin. This
+  prevents the need to issue a query at model creation time to
+  get the rows.  This plugin should be loaded into Sequel::Model
+  (or whatever class you are using as the base class for your
+  model classes) before loading the models using the static_cache
+  plugin.  To create the metadata file, after all subclasses of
+  that class have been loaded, run:
+
+    Sequel::Model.dump_static_cache_cache
+
+* :unique_deferrable and :primary_key_deferrable column
+  options are now supported on PostgreSQL 9+ and Oracle. This
+  allows you to created deferrable unique and primary key
+  column constraints.  You could already create deferrable
+  table constraints using the :deferrable option to the primary_key
+  and unique methods.
+
+* A :generated_always_as column option is now supported on
+  PostgreSQL 12+, for creating generated columns.
+
+* A Database#skip_logging? private method has been added.  This
+  is designed for use in extensions, to force log timing even
+  when no loggers are configured.
+
+= Other Improvements
+
+* Sequel no longer sets the :host option to localhost by default
+  in the mysql2 adapter.  This prevents Sequel from overriding
+  a host specified in the defaults_file.
+
+* All database array types are converted to Ruby arrays in the
+  jdbc adapter.  Previously, this was only done in the
+  jdbc/postgresql subadapter.

data/doc/release_notes/5.25.0.txt

@@ -0,0 +1,32 @@
+= New Features
+
+* An association_multi_add_remove plugin has been added.  This plugin
+  adds a shortcut for adding or removing multiple associated objects
+  in a single method call:
+
+    Artist.plugin :association_multi_add_remove
+    Artist.many_to_one :albums
+    Artist[1].add_albums([Album[2], Album[3]])
+    Artist[1].remove_albums([Album[4], Album[5]])
+
+  It also offers a setter method, which will add and remove associated
+  objects as necessary:
+
+    Artist[1].albums = [Album[3], Album[4]]
+
+= Other Improvements
+
+* The sharding plugin now integrates with the server_block extension.
+  This makes it so if you retrieve a model instance inside a
+  with_server block, saving the model instance will save it back to
+  the shard from which it was retrieved.
+
+* Setting a default for a column on Microsoft SQL Server now works
+  correctly if the column already has a default.
+
+* Sequel::SQL::NumericMethods#coerce no longer raises NoMethodError
+  if the super method is not defined.  This fixes some cases when
+  comparing Date/DateTime instances to Sequel objects.
+
+* The csv_serializer plugin now avoids keyword argument separation
+  issues on Ruby 2.7+.

data/doc/release_notes/5.26.0.txt

@@ -0,0 +1,35 @@
+= New Features
+
+* Support for SQL/JSON path expressions has been added to the
+  pg_json_ops extension. These are supported in PostgreSQL 12+.
+  Examples:
+
+    j = Sequel.pg_json_op(:json_column)
+    j.path_exists('$.foo')      # (jsonb_column @? '$.foo')
+    j.path_match('$.foo')       # (jsonb_column @@ '$.foo')
+    j.path_exists!('$.foo')     # jsonb_path_exists(jsonb_column, '$.foo')
+    j.path_match!('$.foo')      # jsonb_path_match(jsonb_column, '$.foo')
+    j.path_query('$.foo')       # jsonb_path_query(jsonb_column, '$.foo')
+    j.path_query_array('$.foo') # jsonb_path_query_array(jsonb_column, '$.foo')
+    j.path_query_first('$.foo') # jsonb_path_query_first(jsonb_column, '$.foo')
+
+* The nested_attributes method in the nested_attributes plugin now
+  supports a :require_modification option, which can override the
+  default require_modification setting for the nested objects. This
+  can be useful to avoid errors if multiple requests are submitted
+  simultaneously to delete the same nested row.
+
+= Other Improvements
+
+* The dirty plugin now works correctly with the typecast_on_load
+  plugin.
+
+* Sequel::Postgres::PGRange#hash has been added to the pg_range
+  extension, allowing PGRange instances to be usable as hash keys.
+
+* Table aliases are now supported for single table INSERT
+  statements on PostgreSQL 9.5+, which can make some insert_conflict
+  usage easier.
+
+* Two more foreign key constraint violation types are now recognized
+  on MySQL 8.0.13+.

data/doc/testing.rdoc

@@ -169,3 +169,4 @@ SEQUEL_NO_PENDING :: Don't skip any specs, try running all specs (note, can caus
 SEQUEL_PG_TIMESTAMPTZ :: Use the pg_timestamptz extension when running the postgres specs
 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
+SEQUEL_TZINFO_VERSION :: Force the given tzinfo version when running the specs (e.g. '>=2')

data/lib/sequel/adapters/jdbc.rb

@@ -102,12 +102,17 @@ module Sequel
           v.getSubString(1, v.length)
         end
       end
+      x = convertors[:RubyArray] = Object.new
+      def x.call(r, i)
+        if v = r.getArray(i)
+          v.array.to_ary
+        end
+      end 
 
       MAP = Hash.new(convertors[:Object])
       types = Java::JavaSQL::Types
 
       {
-        :ARRAY => :Array,
         :BOOLEAN => :Boolean,
         :CHAR => :String,
         :DOUBLE => :Double,
@@ -126,6 +131,7 @@ module Sequel
       BASIC_MAP = MAP.dup
 
       {
+        :ARRAY => :Array,
         :BINARY => :Blob,
         :BLOB => :Blob,
         :CLOB => :Clob,

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

@@ -195,17 +195,7 @@ module Sequel
 
         STRING_TYPE = Java::JavaSQL::Types::VARCHAR
         ARRAY_TYPE = Java::JavaSQL::Types::ARRAY
-        PG_SPECIFIC_TYPES = [ARRAY_TYPE, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
-
-        # Return PostgreSQL array types as ruby Arrays instead of
-        # JDBC PostgreSQL driver-specific array type. Only used if the
-        # database does not have a conversion proc for the type.
-        ARRAY_METHOD = Object.new
-        def ARRAY_METHOD.call(r, i)
-          if v = r.getArray(i)
-            v.array.to_ary
-          end
-        end 
+        PG_SPECIFIC_TYPES = [Java::JavaSQL::Types::ARRAY, Java::JavaSQL::Types::OTHER, Java::JavaSQL::Types::STRUCT, Java::JavaSQL::Types::TIME_WITH_TIMEZONE, Java::JavaSQL::Types::TIME].freeze
 
         # Return PostgreSQL hstore types as ruby Hashes instead of
         # Java HashMaps.  Only used if the database does not have a
@@ -223,8 +213,6 @@ module Sequel
             oid = meta.getField(i).getOID
             if pr = db.oid_convertor_proc(oid)
               pr
-            elsif type == ARRAY_TYPE
-              ARRAY_METHOD
             elsif oid == 2950 # UUID
               map[STRING_TYPE]
             elsif meta.getPGType(i) == 'hstore'