sequel 5.39.0 → 5.62.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b995589f8bb51611b490ae4cd1d84c2ecfbb5889cb4f940dd786a841fe9ecf9f
-  data.tar.gz: afa86ae9dfc39cd21138aff35955fb4194c359a1ea56c9a80026f04b85b79a4a
+  metadata.gz: df5fea5cf2d6dae7a5721c549c89a190df5a1cf79f2e7d48921dcdaeae398839
+  data.tar.gz: e1155c60bb4c2845a96cddf0a7d5498358f1cba826fdc9d7f00754a017b4310f
 SHA512:
-  metadata.gz: 553d5c2b92a49d079503c9e8e0f8dfecef1a4abf2ed2fe242c8aec19d53c918912de4f5d1453626a05c1b654c5582c508199df10aa7540ec590331b3ecb355da
-  data.tar.gz: f0fc7bceadccc74651573f82ed957ab91061ecb05f5f30050d0814a0142b915a79175d146b3bcac6f7269cd4f3b3b69eb58a92a4df439a944c081b45f1deaa2c
+  metadata.gz: 8e52498bbcc1c2d472592b213be8e6e508f5881de5c1ae0579b426211aa448960e06bdb297f43eb26ee3024923f78e54bb17f9a886710c3ffe60f0c134746029
+  data.tar.gz: 0d5ae732cde0ad90a4c331f40628628e346386c483267173eb50eaad067d7de14ba6ff3c83f598d7440a6fcc752e4439cf1856706489cc3d3b7cffaf5b6d8de8

data/CHANGELOG

@@ -1,3 +1,297 @@
+=== 5.62.0 (2022-11-01)
+
+* Add back the pg_auto_parameterize extension for automatically using bound variables when using postgres adapter with pg driver (jeremyevans)
+
+* Add pg_extended_integer_support extension for customizing behavior when literalizing a Ruby integer outside PostgreSQL bigint range (jeremyevans)
+
+* Raise Postgres::IntegerOutsideBigintRange if attempting to literalize a Ruby integer outside PostgreSQL bigint range (jeremyevans)
+
+* Add primary_key_lookup_check_values plugin for typecasting and checking primary key values during lookup (jeremyevans)
+
+* Setup validation of minimum and maximum values for integer columns in auto_validations (jeremyevans)
+
+* Add validates_max_value and validates_min_value to validation_helpers (jeremyevans)
+
+* Include :min_value and :max_value schema entries for integer columns on most databases (jeremyevans)
+
+* Don't wrap multi-inserts in a transaction when it's not required (shannoncole, jeremyevans) (#1945)
+
+* Update mock PostgreSQL adapter to default to PostgreSQL 15 instead of PostgreSQL 14 (jeremyevans)
+
+* Support fractional seconds in the named_timezones extension (jeremyevans) (#1943)
+
+* Cache reflection datasets in the postgres adapter to improve performance (jeremyevans)
+
+* Handle BC dates and timestamps in bound variables when using the pg_extended_date_support extension (jeremyevans)
+
+* Correctly format hstore[] types in bound variables on PostgreSQL (jeremyevans)
+
+* Fix corner case in eager loading where window function eager limit strategy is used, but row number entry is not removed (jeremyevans)
+
+* Support server/shard specific :after_connect and :connect_sqls Database options (jeremyevans) (#1935)
+
+=== 5.61.0 (2022-10-01)
+
+* Make Database#foreign_key_list on PostgreSQL return results for partitioned tables (jeremyevans)
+
+* Add Database#check_string_typecast_bytesize for checking bytesize of strings before typecasting (jeremyevans)
+
+* Treat negative hexidecimal strings similar to positive hexidecimal strings when typecasting to integer (jeremyevans)
+
+* Remove is_json and is_not_json methods from the pg_json_ops extension, as the support was removed in PostgreSQL 15 beta 4 (jeremyevans)
+
+* Fix handling of timestamps before the date of calendar reform when using pg_extended_date_support extension on Ruby 3.2 (jeremyevans)
+
+=== 5.60.1 (2022-09-02)
+
+* Revert conversion of respond_to? to defined?, as it breaks with unused refinements on Ruby 2 (jeremyevans) (#1919)
+
+=== 5.60.0 (2022-09-01)
+
+* Support arbitrary expressions for date_arithmetic interval values on PostgreSQL 9.4+ (jeremyevans)
+
+* Support native IS DISTINCT FROM on SQLite 3.39+ instead of emulating support in the is_distinct_from extension (jeremyevans)
+
+* Support HAVING without GROUP BY on SQLite 3.39+ (jeremyevans)
+
+* Convert most respond_to? calls to equivalent defined? for better performance (jeremyevans)
+
+=== 5.59.0 (2022-08-01)
+
+* Set :allow_eager association option to false for instance specific associations without eager loaders (jeremyevans)
+
+* Add require_valid_schema plugin for checking that model classes have schema parsed as expected (jeremyevans)
+
+* Model classes created from aliased expressions and literal strings no longer use the simple table optimization (jeremyevans)
+
+* Model code that does not swallow connection errors will now also not swallow disconnect errors (jeremyevans) (#1892)
+
+* Add is_json and is_not_json methods to the pg_json_ops extension, for the PostgreSQL 15+ IS [NOT] JSON operator (jeremyevans)
+
+* Support :security_invoker view option on PostgreSQL 15+, for views where access uses permissions of user instead of owner (jeremyevans)
+
+* Support :nulls_distinct index option on PostgreSQL 15+, for NULLS [NOT] DISTINCT (jeremyevans)
+
+* Support sequel-postgres-pr driver in the postgres adapter (jeremyevans)
+
+=== 5.58.0 (2022-07-01)
+
+* Support :disable_split_materialized Database option on MySQL to work around optimizer bug in MariaDB 10.5+ affecting association tests (jeremyevans)
+
+* Add Dataset#merge* methods to support MERGE statement on PostgreSQL 15+, MSSQL, Oracle, DB2, H2, HSQLDB, and Derby (jeremyevans)
+
+=== 5.57.0 (2022-06-01)
+
+* Make Database#create_function on PostgreSQL accept :parallel option (bananarne) (#1870)
+
+* Add support for :on_update_current_timestamp column option on MySQL (jeremyevans)
+
+* Add is_distinct_from extension with support for the IS DISTINCT FROM operator (jeremyevans)
+
+=== 5.56.0 (2022-05-01)
+
+* Make alter_table add_column/add_foreign_key methods support :index option to create an index on the column (jeremyevans)
+
+* Support creation of STRICT tables on SQLite 3.37.0+ via create_table :strict option (jeremyevans)
+
+* Add sqlite_json_ops extension for DSL support for JSON functions and operators added in SQLite 3.38.0 (jeremyevans)
+
+* Recognize "INTEGER" type same as "integer" type in the schema dumper, helpful on SQLite 3.37.0+ (jeremyevans)
+
+=== 5.55.0 (2022-04-01)
+
+* Support :setup_regexp_function Database option in the sqlite adapter to allow the use of regexps when querying (jeremyevans)
+
+* Add auto_restrict_eager_graph plugin for automatically disallow eager_graph with associations needing but lacking graph options (jeremyevans)
+
+* Fix placeholder literalizer optimization for dataset aggregate methods on a model dataset (belousovAV) (#1847, #1848)
+
+=== 5.54.0 (2022-03-01)
+
+* Add enum plugin for treating columns as enums in a model (jeremyevans) (#1839)
+
+=== 5.53.0 (2022-02-01)
+
+* Make Dataset#_sql_comment private when using the Database sql_comments extension (jeremyevans)
+
+* Fix prepared statements in the mysql2 adapter to reuse native prepared statements (jeremyevans) (#1832)
+
+* Support H2 version 2+ in the jdbc/h2 adapter (jeremyevans) (#1817)
+
+* Work around active_support breaking subclasses plugin on Ruby <3.1 (jeremyevans) (#1816)
+
+* Fix error handling if trying to setup column_encryption plugin without keys (jeremyevans) (#1815)
+
+=== 5.52.0 (2022-01-01)
+
+* Use Class#subclasses if available in the subclasses plugin, instead of a custom Model.subclasses accessor (jeremyevans)
+
+* Add Model.descendants and .freeze_descendants to subclasses plugin (jeremyevans)
+
+* Avoid use of deprecated Refinement#include on Ruby 3.1+ (jeremyevans)
+
+* Add date_parse_input_handler extension for custom handling of input to date parsing methods (jeremyevans)
+
+* Make postgres adapter respect Database#default_string_column_size (jeremyevans)
+
+* Make pg_interval extension work with ActiveSupport 7.0 (jeremyevans)
+
+* Make :ruby_default schema entry for type: :datetime respect Sequel.datetime_class (jeremyevans)
+
+* Make alter_table drop_constraint have an effect on MySQL 8.0.19+ (jeremyevans)
+
+* Make mysql adapter support ruby-mysql 3 API (jeremyevans) (#1795)
+
+* Make mysql adapter no longer use connection's server_version, since it isn't accurate when using the ruby-mysql driver (jeremyevans)
+
+* Add sql_comments plugin for automatically including comments on queries generated by model class, instance, and dataset methods (jeremyevans)
+
+* Make sql_comments Database extension support Database#with_comments, for automatically including comments for queries executed inside the block (jeremyevans)
+
+* Fix sql_comments extension to not modify cached SQL for a dataset (jeremyevans)
+
+=== 5.51.0 (2021-12-01)
+
+* Make eager loading via tactical_eager_loading no longer modify objects who already have a cached value for the association (jeremyevans)
+
+* Make association cloning handle cases where clone association sets different :class option than cloned association (jeremyevans)
+
+* Make column schema entries on MySQL include an :extra entry for the Extra column in DESCRIBE output (bschmeck) (#1791)
+
+* Update mock PostgreSQL adapter to default to PostgreSQL 14 instead of PostgreSQL 9.5 (jeremyevans)
+
+* Support Dataset#with_recursive :search and :cycle options on PostgreSQL 14+ for result ordering and cycle detection (jeremyevans)
+
+* Avoid method redefined verbose mode warnings in lazy_attributes plugin (jeremyevans)
+
+=== 5.50.0 (2021-11-01)
+
+* Make Migrator :allow_missing_migration_files also allow down migrations where the current database version is greater than the last migration file version (francisconeves97) (#1789)
+
+* Fix Model#freeze in composition, serialization, and serialization_modification_detection plugins to return self (jeremyevans) (#1788)
+
+* Fix typecasting of lazy columns when using lazy_attributes plugin in model where dataset selects from subquery (jeremyevans)
+
+* Add :before_preconnect Database option, for configuring extensions loaded via :preconnect_extensions (MarcPer, jeremyevans) (#1786)
+
+* Change Dataset#columns! to use a LIMIT 0 query instead of a LIMIT 1 query (jeremyevans)
+
+* Add sql_log_normalizer extension for normalizing logged SQL, helpful for analytics and sensitive data (jeremyevans)
+
+* Add support for range_merge, multirange, and unnest, and PGMultiRange#op to pg_range_ops extension (jeremyevans)
+
+* Add pg_multirange extension with support for PostgreSQL 14+ multirange types (jeremyevans)
+
+=== 5.49.0 (2021-10-01)
+
+* Switch block_given? usage to defined?(yield) (jeremyevans)
+
+* Support table aliases for JOIN USING columns on PostgreSQL 14+ (jeremyevans)
+
+* Support calling PostgreSQL procedures without arguments (jeremyevans)
+
+* Support hstore subscripts in pg_hstore_ops on PostgreSQL 14+, for updating only part of an hstore value (jeremyevans)
+
+* Support JSONB subscripts in pg_json_ops on PostgreSQL 14+, for updating only part of a JSONB value (jeremyevans)
+
+* Support SQL::Expression#sequel_ast_transform for custom AST transforms on arbitrary expressions (jeremyevans)
+
+* Add Database#create_trigger :replace option on PostgreSQL 14+ for CREATE OR REPLACE TRIGGER (jeremyevans)
+
+* Make auto_validations plugin automatically setup no_null_byte validations (jeremyevans)
+
+* Add Model#validates_no_null_byte to validation_helpers plugin (jeremyevans)
+
+=== 5.48.0 (2021-09-01)
+
+* Make the unused_associations plugin association reflection tracking work correctly when combining coverage runs (jeremyevans)
+
+* Add Database#like_without_collate on MSSQL, to avoid using COLLATE on LIKE arguments, which can significantly improve performance (jeremyevans)
+
+* Add Model::Errors#full_message private method for easiest i18n support for errors with multiple attributes (jeremyevans) (#1779)
+
+=== 5.47.0 (2021-08-01)
+
+* Make the unused_associations plugin track access to association reflections to determine whether associations are used (jeremyevans)
+
+* Support :db option for join tables in {many,one}_through_many to use a separate query for each join table (jeremyevans)
+
+* Support :join_table_db option for many_to_many/one_through_one associations, to use a separate query for the join table (jeremyevans)
+
+* Support :allow_eager_graph and :allow_filtering_by association options (jeremyevans)
+
+* Add Database#rename_tables on MySQL, for renaming multiple tables in a single call (nick96) (#1774)
+
+* Support Dataset#returning on SQLite 3.35+ (jeremyevans)
+
+=== 5.46.0 (2021-07-01)
+
+* Add unused_associations plugin, for determining which associations and association methods are not used (jeremyevans)
+
+* Make nil :setter/:adder/:remover/:clearer association options not create related methods (jeremyevans)
+
+=== 5.45.0 (2021-06-01)
+
+* Fix handling of NULL values in boolean columns in the ODBC adapter (jeremyevans) (#1765)
+
+* Add auto_validations_constraint_validations_presence_message plugin for auto_validations/constraint_validations presence message integration (jeremyevans)
+
+* Support Dataset#with :materialized option on SQLite 3.35+ for [NOT] MATERIALIZED (jeremyevans)
+
+* Use ALTER TABLE DROP COLUMN for dropping columns on SQLite 3.35+ (jeremyevans)
+
+=== 5.44.0 (2021-05-01)
+
+* Add concurrent_eager_loading plugin, for eager loading multiple associations concurrently using separate threads (jeremyevans)
+
+* Support :weeks as a interval unit in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Raise an exception if an interval hash with an unsupported key is passed in the date_arithmetic extension (jeremyevans) (#1759)
+
+* Support dropping non-composite unique constraints on SQLite (jeremyevans) (#1755)
+
+=== 5.43.0 (2021-04-01)
+
+* Add column_encryption plugin, for encrypting column values (jeremyevans)
+
+=== 5.42.0 (2021-03-01)
+
+* Make the ado timestamp conversion proc a normal conversion proc that can be overridden similar to other conversion procs (jeremyevans)
+
+* Add :reject_nil option to the nested_attributes method, to ignore calls where nil is passed as the associated object data (jeremyevans)
+
+* Add async_thread_pool plugin for easier async usage with model classes and support for async destroy, with_pk, and with_pk! methods (jeremyevans)
+
+* Add async_thread_pool Database extension for executing queries asynchronously using a thread pool (jeremyevans)
+
+* Fix possible thread safety issue in Database#extension that could allow Module#extended to be called twice with the same Database instance (jeremyevans)
+
+* Support cases where validations make modifications beyond setting errors in Model#freeze (jeremyevans)
+
+* Add Model#to_json_data to the json_serializer plugin, returning a JSON data structure (jeremyevans)
+
+=== 5.41.0 (2021-02-01)
+
+* Have explicit :text option for a String column take priority over :size option on PostgreSQL (jeremyevans) (#1750)
+
+* Support a :skip_invalid option in auto_validations plugin for not adding errors to a column that already has an error (jeremyevans)
+
+* Support a :skip_invalid option in validation_helpers for not adding an error to a column that already has an error (jeremyevans)
+
+* Support :adder, :remover, and :clearer association options that use keyword arguments in Ruby 2.7+ (jeremyevans)
+
+* Make pg_interval use the same number of seconds per year and per month as ActiveSupport::Duration when using ActiveSupport 5.1+ (jeremyevans)
+
+=== 5.40.0 (2021-01-01)
+
+* Support UPDATE FROM syntax in SQLite 3.33.0+ (jeremyevans)
+
+* Have pg_interval extension work with ActiveSupport 6.1 (jeremyevans)
+
+* Have date_arithmetic extension work with ActiveSupport 6.1 (jeremyevans)
+
+* Avoid method redefinition warnings in verbose warning mode (jeremyevans)
+
 === 5.39.0 (2020-12-01)
 
 * Support :clustered option for primary key and unique constraints on Microsoft SQL Server (jeremyevans)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2020 Jeremy Evans
+Copyright (c) 2008-2022 Jeremy Evans
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/README.rdoc

@@ -17,15 +17,16 @@ toolkit for Ruby.
 
 == Resources
 
-Website :: http://sequel.jeremyevans.net
-RDoc Documentation :: http://sequel.jeremyevans.net/rdoc
+Website :: https://sequel.jeremyevans.net
+RDoc Documentation :: https://sequel.jeremyevans.net/rdoc
 Source Code :: https://github.com/jeremyevans/sequel
-Bug tracking (GitHub Issues) :: http://github.com/jeremyevans/sequel/issues
-Discussion Forum (sequel-talk Google Group) :: http://groups.google.com/group/sequel-talk
-IRC Channel (#sequel) :: irc://irc.freenode.net/sequel
+Bug tracking (GitHub Issues) :: https://github.com/jeremyevans/sequel/issues
+Discussion Forum (GitHub Discussions) :: https://github.com/jeremyevans/sequel/discussions
+Alternate Discussion Forum (sequel-talk Google Group) :: http://groups.google.com/group/sequel-talk
 
-If you have questions about how to use Sequel, please ask on the
-sequel-talk Google Group or IRC.  Only use the the bug tracker to report
+If you have questions about how to use Sequel, please ask on
+GitHub Discussions or the sequel-talk Google Group.
+Only use the the bug tracker to report
 bugs in Sequel, not to ask for help on using Sequel.
 
 To check out the source code:
@@ -55,9 +56,9 @@ If you have any comments or suggestions please post to the Google group.
   items = DB[:items] # Create a dataset
   
   # Populate the table
-  items.insert(:name => 'abc', :price => rand * 100)
-  items.insert(:name => 'def', :price => rand * 100)
-  items.insert(:name => 'ghi', :price => rand * 100)
+  items.insert(name: 'abc', price: rand * 100)
+  items.insert(name: 'def', price: rand * 100)
+  items.insert(name: 'ghi', price: rand * 100)
   
   # Print out the number of records
   puts "Item count: #{items.count}"
@@ -83,7 +84,7 @@ Sequel uses the concept of datasets to retrieve data. A Dataset object encapsula
 
 For example, the following one-liner returns the average GDP for countries in the middle east region:
 
-  DB[:countries].where(:region => 'Middle East').avg(:GDP)
+  DB[:countries].where(region: 'Middle East').avg(:GDP)
   
 Which is equivalent to:
 
@@ -91,7 +92,7 @@ Which is equivalent to:
 
 Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes, and are accessed using an +Enumerable+ interface:
 
-  middle_east = DB[:countries].where(:region => 'Middle East')
+  middle_east = DB[:countries].where(region: 'Middle East')
   middle_east.order(:name).each{|r| puts r[:name]}
   
 Sequel also offers convenience methods for extracting data from Datasets, such as an extended +map+ method:
@@ -209,12 +210,12 @@ If the dataset is ordered, you can also ask for the last record:
   
 You can also provide a filter when asking for a single record:
 
-  posts.first(:id => 1)
+  posts.first(id: 1)
   # SELECT * FROM posts WHERE id = 1 LIMIT 1
   
 Or retrieve a single value for a specific record:
 
-  posts.where(:id => 1).get(:name)
+  posts.where(id: 1).get(:name)
   # SELECT name FROM posts WHERE id = 1 LIMIT 1
   
 === Filtering Records
@@ -410,9 +411,34 @@ As with +delete+, +update+ affects all rows in the dataset, so +where+ first,
 +update+ second:
 
   # DO THIS:
-  posts.where(Sequel[:stamp] < Date.today - 7).update(:state => 'archived')
+  posts.where(Sequel[:stamp] < Date.today - 7).update(state: 'archived')
   # NOT THIS:
-  posts.update(:state => 'archived').where(Sequel[:stamp] < Date.today - 7)
+  posts.update(state: 'archived').where(Sequel[:stamp] < Date.today - 7)
+
+=== Merging records
+
+Merging records using the SQL MERGE statement is done using <tt>merge*</tt> methods.
+You use +merge_using+ to specify the merge source and join conditions.
+You can use +merge_insert+, +merge_delete+, and/or +merge_update+ to set the
+INSERT, DELETE, and UPDATE clauses for the merge. +merge_insert+ takes the same
+arguments as +insert+, and +merge_update+ takes the same arguments as +update+.
++merge_insert+, +merge_delete+, and +merge_update+ can all be called with blocks,
+to set the conditions for the related INSERT, DELETE, or UPDATE.
+
+Finally, after calling all of the other <tt>merge_*</tt> methods, you call +merge+
+to run the MERGE statement on the database.
+
+  ds = DB[:m1]
+    merge_using(:m2, i1: :i2).
+    merge_insert(i1: :i2, a: Sequel[:b]+11).
+    merge_delete{a > 30}.
+    merge_update(i1: Sequel[:i1]+:i2+10, a: Sequel[:a]+:b+20)
+
+  ds.merge
+  # MERGE INTO m1 USING m2 ON (i1 = i2)
+  # WHEN NOT MATCHED THEN INSERT (i1, a) VALUES (i2, (b + 11))
+  # WHEN MATCHED AND (a > 30) THEN DELETE
+  # WHEN MATCHED THEN UPDATE SET i1 = (i1 + i2 + 10), a = (a + b + 20)
 
 === Transactions
 
@@ -422,7 +448,7 @@ You can wrap a block of code in a database transaction using the <tt>Database#tr
     # BEGIN
     posts.insert(category: 'ruby', author: 'david')
     # INSERT
-    posts.where(Sequel[:stamp] < Date.today - 7).update(:state => 'archived')
+    posts.where(Sequel[:stamp] < Date.today - 7).update(state: 'archived')
     # UPDATE 
   end
   # COMMIT
@@ -435,9 +461,9 @@ and not raise an exception outside the block, you can raise the
 
   DB.transaction do
     # BEGIN
-    posts.insert(:category => 'ruby', :author => 'david')
+    posts.insert(category: 'ruby', author: 'david')
     # INSERT
-    if posts.where('stamp < ?', Date.today - 7).update(:state => 'archived') == 0
+    if posts.where('stamp < ?', Date.today - 7).update(state: 'archived') == 0
     # UPDATE 
       raise Sequel::Rollback
     end
@@ -680,8 +706,8 @@ You can delete individual records by calling +delete+ or +destroy+. The only dif
 
 Records can also be deleted en-masse by calling <tt>delete</tt> and <tt>destroy</tt> on the model's dataset. As stated above, you can specify filters for the deleted records:
 
-  Post.where(:category => 32).delete # => bypasses hooks
-  Post.where(:category => 32).destroy # => runs hooks
+  Post.where(category: 32).delete # => bypasses hooks
+  Post.where(category: 32).destroy # => runs hooks
 
 Please note that if <tt>destroy</tt> is called, each record is deleted 
 separately, but <tt>delete</tt> deletes all matching records with a single 
@@ -694,9 +720,9 @@ Associations are used in order to specify relationships between model classes th
   class Post < Sequel::Model
     many_to_one :author
     one_to_many :comments
-    one_to_one :first_comment, :class=>:Comment, :order=>:id
+    one_to_one :first_comment, class: :Comment, order: :id
     many_to_many :tags
-    one_through_one :first_tag, :class=>:Tag, :order=>:name, :right_key=>:tag_id
+    one_through_one :first_tag, class: :Tag, order: :name, right_key: :tag_id
   end
 
 +many_to_one+ and +one_to_one+ create a getter and setter for each model object:
@@ -735,7 +761,7 @@ All associations add a dataset method that can be used to further filter or reor
 Associations can be eagerly loaded via +eager+ and the <tt>:eager</tt> association option. Eager loading is used when loading a group of objects. It loads all associated objects for all of the current objects in one query, instead of using a separate query to get the associated objects for each current object. Eager loading requires that you retrieve all model objects at once via +all+ (instead of individually by +each+). Eager loading can be cascaded, loading association's associated objects.
 
   class Person < Sequel::Model
-    one_to_many :posts, :eager=>[:tags]
+    one_to_many :posts, eager: [:tags]
   end
 
   class Post < Sequel::Model
@@ -880,6 +906,11 @@ raise an error by default:
     end
   end
 
+== Testing Sequel
+
+Please see the {testing guide}[rdoc-ref:doc/testing.rdoc] for recommendations on testing
+applications that use Sequel, as well as the how to run the tests for Sequel itself.
+
 == Sequel Release Policy
 
 New major versions of Sequel do not have a defined release policy, but historically have
@@ -895,7 +926,8 @@ in the most current release.
 Sequel fully supports the currently supported versions of Ruby (MRI) and JRuby.  It may
 support unsupported versions of Ruby or JRuby, but such support may be dropped in any
 minor version if keeping it becomes a support issue.  The minimum Ruby version
-required to run the current version of Sequel is 1.9.2.
+required to run the current version of Sequel is 1.9.2, and the minimum JRuby version is
+9.0.0.0.
 
 == Maintainer
 

data/bin/sequel

@@ -194,7 +194,11 @@ begin
     TO_DB = connect_proc[db2]
     same_db = DB.database_type==TO_DB.database_type
     index_opts = {:same_db=>same_db}
+
+    # :nocov:
     index_opts[:index_names] = :namespace if !DB.global_index_namespace? && TO_DB.global_index_namespace?
+    # :nocov:
+
     if DB.database_type == :sqlite && !same_db
       # SQLite integer types allows 64-bit integers
       TO_DB.extension :integer64
@@ -212,18 +216,20 @@ begin
     puts "Begin copying data"
     DB.transaction do
       TO_DB.transaction do
+        all_status_lines = ENV['SEQUEL_BIN_STATUS_ALL_LINES']
+
         DB.tables.each do |table|
           puts "Begin copying records for table: #{table}"
           time = Time.now
           to_ds = TO_DB.from(table)
           j = 0
           DB.from(table).each do |record|
-            if Time.now - time > 5
+            to_ds.insert(record)
+            j += 1
+            if Time.now - time > 5 || all_status_lines
               puts "Status: #{j} records copied" 
               time = Time.now
             end
-            to_ds.insert(record)
-            j += 1
           end
           puts "Finished copying #{j} records for table: #{table}"
         end
@@ -260,8 +266,10 @@ if !ARGV.empty?
   ARGV.each{|v| load(v)}
 elsif !$stdin.isatty
   eval($stdin.read)
+# :nocov:
 else
   require 'irb'
   puts "Your database is stored in DB..."
   IRB.start
 end
+# :nocov:

data/doc/advanced_associations.rdoc

@@ -115,7 +115,7 @@ These two approaches can also be nested, with +eager+ -> +eager_graph+ -> +eager
 
 Or with 2 separate +eager_graph+ queries:
 
-  Artist.eager_graph(:albums).eager_graph_eager([:albums], :tracks=>proc{|ds| ds.eager_graph(:lyric)})
+  Artist.eager_graph(:albums).eager_graph_eager([:albums], tracks: proc{|ds| ds.eager_graph(:lyric)})
   # 2 Queries:
   # SELECT artists.id, artists.name, ...
   #        albums.id AS albums_id, albums.name AS albums_name, ...
@@ -238,9 +238,9 @@ have the following associations
     
 and the following three albums in the database:
 
-  album1 = Album.create(:artist_id=>3) # id: 1
-  album2 = Album.create(:artist_id=>3) # id: 2
-  album3 = Album.create(:artist_id=>2) # id: 3
+  album1 = Album.create(artist_id: 3) # id: 1
+  album2 = Album.create(artist_id: 3) # id: 2
+  album3 = Album.create(artist_id: 2) # id: 3
 
 If you try to eager load this dataset:
 
@@ -256,7 +256,7 @@ the are both in the array related to that key.  album3 has a different
 artist_id, so it is in a different array. Eager loading of artists is
 done by looking for any artist having one of the keys in the hash:
 
-  artists = Artist.where(:id=>id_map.keys).all
+  artists = Artist.where(id: id_map.keys).all
 
 When the artists are retrieved, you can iterate over them, find entries
 with matching keys, and manually associate them to the albums:
@@ -281,7 +281,7 @@ case each array only has a single object, because id is the primary key).  So wh
 looking for tracks to eagerly load, you only need to look for ones that have an
 album_id with one of the keys in the hash:
 
-  tracks = Track.where(:album_id=>id_map.keys).all
+  tracks = Track.where(album_id: id_map.keys).all
 
 When the tracks are retrieved, you can iterate over them, find entries with matching
 keys, and manually associate them to the albums:
@@ -314,10 +314,10 @@ artist or tracks method on the album will not do another database lookup.
 
 So putting everything together, the artist eager loader looks like:
 
-  Album.many_to_one :artist, :eager_loader=>(proc do |eo_opts|
+  Album.many_to_one :artist, eager_loader: (proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:artist] = nil}
     id_map = eo_opts[:id_map]
-    Artist.where(:id=>id_map.keys).all do |artist|
+    Artist.where(id: id_map.keys).all do |artist|
       if albums = id_map[artist.id]
         albums.each do |album|
           album.associations[:artist] = artist
@@ -328,10 +328,10 @@ So putting everything together, the artist eager loader looks like:
 
 and the tracks eager loader looks like:
 
-  Album.one_to_many :tracks, :eager_loader=>(proc do |eo_opts|
+  Album.one_to_many :tracks, eager_loader: (proc do |eo_opts|
     eo_opts[:rows].each{|album| album.associations[:tracks] = []}
     id_map = eo_opts[:id_map]
-    Track.where(:album_id=>id_map.keys).all do |track|
+    Track.where(album_id: id_map.keys).all do |track|
       if albums = id_map[track.album_id]
         albums.each do |album|
           album.associations[:tracks] << track
@@ -405,7 +405,7 @@ the window function strategy:
 
   Artist.one_to_many :first_10_albums, class: :Album, order: :release_date, limit: 10,
     eager_limit_strategy: :window_function
-  Artist.where(:id=>[1,2]).eager(:first_10_albums).all
+  Artist.where(id: [1,2]).eager(:first_10_albums).all
   # SELECT * FROM (
   #   SELECT *, row_number() OVER (PARTITION BY albums.artist_id ORDER BY release_date) AS x_sequel_row_number_x
   #   FROM albums
@@ -483,7 +483,7 @@ function:
 The :correlated_subquery approach JOINs to a nested subquery using a correlated
 subquery:
 
-  Artist.eager_graph_with_options(:first_10_albums, :limit_strategy=>:correlated_subquery).all
+  Artist.eager_graph_with_options(:first_10_albums, limit_strategy: :correlated_subquery).all
   # SELECT artists.id, artists.name, first_10_albums.id AS first_10_albums_id,
   #        first_10_albums.name AS first_10_albums_name, first_10_albums.artist_id,
   #        first_10_albums.release_date
@@ -853,7 +853,7 @@ associated tickets.
   class Project < Sequel::Model
     one_to_many :tickets
     many_to_one :ticket_hours, read_only: true, key: :id,
-     dataset: proc{Ticket.where(:project_id=>id).select{sum(hours).as(hours)}},
+     dataset: proc{Ticket.where(project_id: id).select{sum(hours).as(hours)}},
      eager_loader: (lambda do |eo|
       eo[:rows].each{|p| p.associations[:ticket_hours] = nil}
       Ticket.where(project_id: eo[:id_map].keys).