sequel 5.58.0 → 5.78.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f02f6a35677e8af2ea2b164f655cc869213864e5b27f67cdd3e17c7db28c546
-  data.tar.gz: ee09f1b4d5b3f4decbf4d4af3b8ae16ef7e488af40011808dac94f8ca05da89f
+  metadata.gz: 2d821d7a1270874ced864c3a4bc66b519b3b5e3c050d2792e8dfc907a677e36a
+  data.tar.gz: 67390870d998d266a1a07d44e72dc85e357226e7f5dd215ca695ab9037840638
 SHA512:
-  metadata.gz: 89efe5f1a7f2c2eedba5ac1cf336adee1abf489278f79413756e70a41e4ba073ea818562aaf176c1f092e7ab9e763693473a0d96edc6782d9da037c759afd05d
-  data.tar.gz: 84986009ccb30a7a0fd15a555262631f539b95ef9ec8d74d6ca2a4078bd07c33ffda725092bad5afbc93b27901e67dc6d06ca735481448174ac695ef14b6ee99
+  metadata.gz: 50b737d3a944ec7d1df62dce2df68b6558e912c0d333d0cdf1d32bccd18ecb5dad8439e73f8c5497b4e627ea8caee34f131dee5a57217a479acfab95287f306d
+  data.tar.gz: 3b9631235606432b44cc57aa624c6509dd14833fdc0e5e900945232c3593904a249dbe3106aef1e4e863cf939517cb1abbd16ca179eec6e5b1de90b815de941f

data/CHANGELOG

@@ -1,3 +1,291 @@
+=== 5.78.0 (2024-03-01)
+
+* Support SQLite 3.45+ jsonb functions in the sqlite_json_ops extension (jeremyevans) (#2133)
+
+* Support compounds (e.g. UNION) in conjunction with Database#values on PostgreSQL (jeremyevans) (#2137)
+
+* Support :use_advisory_lock option to Migrator.run to use advisory locks when running migrations (jeremyevans) (#2089)
+
+* Support Database#with_advisory_lock on PostgreSQL, MySQL, and Microsoft SQL Server (jeremyevans) (#2089)
+
+=== 5.77.0 (2024-02-01)
+
+* Support create_table :without_rowid option on SQLite (loranger32) (#2126)
+
+* Warn by default if trying to eager_graph/association_join an association that uses a block, when the block would be ignored (jeremyevans)
+
+* Speed up validates_unique in validation_helpers plugin by using empty? instead of count == 0 (numbata) (#2122)
+
+* Speed up regexp matches in sqlite adapter on Ruby 2.4+ (jeremyevans)
+
+* Add sqlite adapter :regexp_function_cache option for specifying the cache object to use (paddor, jeremyevans) (#2116)
+
+* Respect list plugin :top option when inserting the first row into the model's table (johanmagnusson) (#2115)
+
+* Switch default connection pool to timed_queue on Ruby 3.4+ (jeremyevans)
+
+* Support on_duplicate_columns={raise,warn} parameter in connection URL when using duplicate_columns_handler extension (jeremyevans)
+
+* Add transaction_connection_validator extension for retrying transactions on new connection if there is a disconnect error when starting transaction (jeremyevans)
+
+=== 5.76.0 (2024-01-01)
+
+* Improve performance and flexibility of regexp matching in sqlite adapter (paddor) (#2108)
+
+* Support SQL::Identifier for Database#tables :schema option values on PostgreSQL (jeremyevans)
+
+* Support generating rcte queries using UNION or UNION ALL in the rcte plugin (jonathanfrias) (#2107)
+
+* Make Database#table_exists? on PostgreSQL handle lock or statement timeout errors as evidence the table exists (jeremyevans) (#2106)
+
+* Work around DateTime.jd fractional second bug on JRuby in named_timezones extension (jeremyevans)
+
+* Support fractional times and timestamps on SQLAnywhere (jeremyevans)
+
+* Make round_timestamps extension use Dataset#sqltime_precision for rounding Sequel::SQLTime values (jeremyevans)
+
+* Remove special handling of %N modifier in Dataset#default_timestamp_format (jeremyevans)
+
+* Add Dataset#default_time_format private method, for adapters to override for time (not timestamp) formatting (jeremyevans)
+
+* Remove Dataset#format_timestamp_offset private method (jeremyevans)
+
+* Remove special handling of %z modifier in Dataset#default_timestamp_format (jeremyevans)
+
+* Add Dataset#literal_date_or_time, for simpler use by bound argument code (jeremyevans)
+
+* Add auto_cast_date_and_time extension, for casting date and time values using SQL standard functions (jeremyevans)
+
+=== 5.75.0 (2023-12-01)
+
+* Make any_not_empty? extension support passing pattern argument to any? (jeremyevans) (#2100)
+
+* Respect :skip_transaction option in PostgreSQL Dataset#paged_each (jeremyevans) (#2097)
+
+* Add TimestampMigrator.run_single to run a single migration file up or down (opya, jeremyevans) (#2093)
+
+* Support INSERT RETURNING on MariaDB 10.5+, and use it when saving new model objects (jeremyevans)
+
+* Add Database#{defer,immediate}_constraints on PostgreSQL for changing handling of deferrable constraints in a transaction (jeremyevans)
+
+=== 5.74.0 (2023-11-01)
+
+* Make generated columns show up in Database#schema when using SQLite 3.37+ (jeremyevans) (#2087)
+
+* Add revert method for Sequel.migration blocks, to revert changes inside the block on up, and apply the changes on down (jeremyevans)
+
+* Re-add is_json and is_not_json methods to the pg_json_ops extension, as the support was re-added in PostgreSQL 16 (jeremyevans)
+
+* Avoid infinite loop when handling exceptions with a cause loop in jdbc adapter (jeremyevans)
+
+=== 5.73.0 (2023-10-01)
+
+* Handle disconnect errors in ibmdb and jdbc/db2 adapters (jeremyevans) (#2083)
+
+* Support skipping transactions in Dataset#{import,paged_each} using :skip_transaction option (jeremyevans)
+
+* Add Database#transaction :skip_transaction option to skip creating a transaction or savepoint (jeremyevans)
+
+* Stop using a transaction for a single query if calling Dataset#import with a dataset (jeremyevans)
+
+* Add paged_operations plugin for paged deletes and updates and other custom operations (jeremyevans) (#2080)
+
+* Support to_tsquery: :websearch option to Dataset#full_text_search on PostgreSQL 11+ (jeremyevans) (#2075)
+
+* Add MassAssignmentRestriction#model and #column for getting the model instance and related column for mass assignment errors (artofhuman, jeremyevans) (#2079)
+
+* Stop using base64 library in column_encryption plugin (jeremyevans)
+
+=== 5.72.0 (2023-09-01)
+
+* Sort caches before marshalling when using schema_caching, index_caching, static_cache_cache, and pg_auto_constraint_validations (jeremyevans)
+
+* Change the defaults_setter plugin do a deep-copy of database default hash/array values and delegates (jeremyevans) (#2069)
+
+* Add pg_auto_parameterize_in_array extension, for converting IN/NOT IN to = ANY or != ALL for more types (jeremyevans)
+
+* Fix literalization of infinite and NaN float values in PostgreSQL array bound variables (jeremyevans)
+
+=== 5.71.0 (2023-08-01)
+
+* Support ILIKE ANY on PostgreSQL by not forcing the use of ESCAPE for ILIKE (gilesbowkett) (#2066)
+
+* Add pg_xmin_optimistic_locking plugin for optimistic locking for all models without database changes (jeremyevans)
+
+* Recognize the xid PostgreSQL type as an integer type in the jdbc/postgresql adapter (jeremyevans)
+
+* Make set_column_allow_null method reversible in migrations (enescakir) (#2060)
+
+=== 5.70.0 (2023-07-01)
+
+* Make static_cache plugin better handle cases where forbid_lazy_load plugin is already loaded (jeremyevans)
+
+* Fix ShardedThreadedConnectionPool#remove_server to disconnect all connections if removing multiple servers (jeremyevans)
+
+* Support SEQUEL_DEFAULT_CONNECTION_POOL environment variable for choosing connection pool when :pool_class Database option is not set (jeremyevans)
+
+* Add sharded_timed_queue connection pool (jeremyevans)
+
+* Make connection_{validator,expiration} and async_thread_pool extensions work with timed_queue connection pool (jeremyevans)
+
+* Make connection_{validator,expiration} extensions raise error when used with single threaded pools (HoneyryderChuck, jeremyevans) (#2049)
+
+* Workaround possible resource starvation in threaded connection pool (ioquatix) (#2048)
+
+=== 5.69.0 (2023-06-01)
+
+* Avoid unsupported flag warning when using the mysql adapter with ruby-mysql 3+ (jeremyevans)
+
+* Make mysql adapter work with ruby-mysql 4+ (jeremyevans)
+
+* Add Model::DatasetModule#model accessor (davekaro) (#2040)
+
+* Add trilogy adapter (jeremyevans)
+
+=== 5.68.0 (2023-05-01)
+
+* Add validation_helpers_generic_type_messages plugin for more useful type validation failure messages (jeremyevans) (#2028)
+
+* Make constraint_validations plugin not validate missing columns that have a default value (jeremyevans) (#2023)
+
+* Skip normal type name parsing for enum/array/composite/range/multirange types on PostgreSQL (jeremyevans) (#2019)
+
+* Fix corner case where pg_extended_date_support did not work correctly when using the jdbc/postgresql adapter (jeremyevans)
+
+* Include :min_value and :max_value schema entries for date/timestamp/timestamptz columns on PostgreSQL 9.6+ (jeremyevans)
+
+=== 5.67.0 (2023-04-01)
+
+* Fix dumping of string column sizes in the schema dumper on MSSQL (jeremyevans) (#2013)
+
+* Improve dumping of tables in non-default schemas in the schema_dumper extension (jeremyevans) (#2006)
+
+* Make Database#{tables,views} support :qualify option on Microsoft SQL Server (jeremyevans)
+
+* Avoid use of singleton classes for datasets instances on Ruby 2.4+ (jeremyevans) (#2007)
+
+* Deprecate registering datasets extensions using an object other than a module (jeremyevans)
+
+* Add set_literalizer extension, for treating set usage in datasets similar to array usage (jeremyevans) (#1997)
+
+=== 5.66.0 (2023-03-01)
+
+* Recognize SQLite error related to strict tables as a constraint violation when using the amalgalite adapter (jeremyevans)
+
+* Make Dataset#count work correctly for datasets using Dataset#values (jeremyevans) (#1992)
+
+* Make Dataset#count with no argument/block handle dataset with custom SQL using ORDER BY on MSSQL (jeremyevans)
+
+* Make Dataset#empty? correctly handle datasets with custom SQL or using Dataset#values where the first value is NULL (andy-k, jeremyevans) (#1990)
+
+=== 5.65.0 (2023-02-01)
+
+* Allow pg_auto_parameterize extension to use placeholder loaders (jeremyevans)
+
+* Do not include :min_value and :max_value schema entries for decimal/numeric columns on MySQL versions not supporting check constraints (jeremyevans)
+
+* Make Database#indexes return indexes for partitioned tables on PostgreSQL 11+ (jeremyevans)
+
+=== 5.64.0 (2023-01-01)
+
+* Make :db_type column schema entries on SQLAnywhere include precision/scale information (jeremyevans)
+
+* Include :min_value and :max_value schema entries for decimal/numeric columns on most databases (rolftimmermans, jeremyevans) (#1975)
+
+* Support :graph_use_association_block association option to make eager_graph use the association block (jeremyevans)
+
+* Make many_through_many and many_through_one associations support eager_graph callbacks (jeremyevans)
+
+=== 5.63.0 (2022-12-01)
+
+* Make validates_associated plugin avoid database type errors for non-integer association keys (jeremyevans) (#1968)
+
+* Make tactical_eager_loading plugin work better with table inheritance plugins (rolftimmermans, jeremyevans) (#1962)
+
+* Add support for pool_class: :timed_queue on Ruby 3.2+, using a Queue for available connections (jeremyevans)
+
+* Allow :pool_class Database option to be specified as a string to more easily choose a different pool type (jeremyevans)
+
+* Use compare_by_identity hashes for Thread-keyed hashes in threaded connection pools (jeremyevans)
+
+* Skip use of JRuby workaround on JRuby 9.3.9.0+ in named_timezones extension as JRuby fixed the related bug (jeremyevans)
+
+=== 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)

data/MIT-LICENSE

@@ -1,5 +1,5 @@
 Copyright (c) 2007-2008 Sharon Rosner
-Copyright (c) 2008-2022 Jeremy Evans
+Copyright (c) 2008-2023 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

@@ -13,7 +13,7 @@ toolkit for Ruby.
   database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, 
   IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle,
-  PostgreSQL, SQLAnywhere, SQLite3, and TinyTDS.
+  PostgreSQL, SQLAnywhere, SQLite3, TinyTDS, and Trilogy.
 
 == Resources
 
@@ -24,8 +24,9 @@ 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.  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,13 +411,13 @@ 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 statment is done using <tt>merge*</tt> methods.
+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
@@ -447,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
@@ -460,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
@@ -705,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 
@@ -719,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:
@@ -760,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
@@ -824,7 +825,7 @@ You can dynamically customize eager loads for both +eager+ and +eager_graph+ whi
 
 === Joining with Associations
 
-You can use the +association_join+ method to add a join to the model's dataset based on the assocation:
+You can use the +association_join+ method to add a join to the model's dataset based on the association:
 
   Post.association_join(:author)
   # SELECT * FROM posts
@@ -926,7 +927,7 @@ Sequel fully supports the currently supported versions of Ruby (MRI) and JRuby.
 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, and the minimum JRuby version is
-9.0.0.0.
+9.2.0.0 (due to the bigdecimal dependency).
 
 == 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
@@ -670,8 +670,10 @@ polymorphic associations in Sequel about as easy as it is in ActiveRecord.  Howe
 here's how they can be done using Sequel's custom associations (the sequel_polymorphic
 external plugin is just a generic version of this code):
 
+  Sequel.extension :inflector # for attachable_type.constantize
+
   class Asset < Sequel::Model
-    many_to_one :attachable, reciprocal: :assets,
+    many_to_one :attachable, reciprocal: :assets, reciprocal_type: :one_to_many,
       setter: (lambda do |attachable|
         self[:attachable_id] = (attachable.pk if attachable)
         self[:attachable_type] = (attachable.class.name if attachable)
@@ -853,7 +855,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).