sequel 5.28.0 → 5.33.0

data/MIT-LICENSE

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

@@ -894,7 +894,7 @@ 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 of keeping it becomes a support issue.  The minimum Ruby version
+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.
 
 == Maintainer

data/doc/advanced_associations.rdoc

@@ -731,7 +731,7 @@ associations:
     one_to_one :tracks, key: [:disc_number, :number, :album_id], primary_key: [:disc_number, :number, :album_id]
   end
 
-=== Tree - All Ancestors and Descendents
+=== Tree - All Ancestors and Descendants
 
 Let's say you want to store a tree relationship in your database, it's pretty
 simple:
@@ -749,7 +749,7 @@ node.children.  You can even eager load the relationship up to a certain depth:
   # Load parents and grandparents for a group of nodes
   Node.where{id < 10}.eager(parent: :parent).all
 
-What if you want to get all ancestors up to the root node, or all descendents,
+What if you want to get all ancestors up to the root node, or all descendants,
 without knowing the depth of the tree?
 
   class Node < Sequel::Model
@@ -770,7 +770,7 @@ without knowing the depth of the tree?
         id_map = {}
         # Create an map of parent_ids to nodes that have that parent id
         non_root_nodes.each{|n| (id_map[n.parent_id] ||= []) << n}
-        # Doesn't cause an infinte loop, because when only the root node
+        # Doesn't cause an infinite loop, because when only the root node
         # is left, this is not called.
         Node.where(id: id_map.keys).eager(:ancestors).all do |node|
           # Populate the parent association for each node
@@ -879,4 +879,4 @@ associated tickets.
   end
 
 Note that it is often better to use a sum cache instead of this approach.  You can implement
-a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferrably using a database trigger.
+a sum cache using +after_create+, +after_update+, and +after_delete+ hooks, or preferably using a database trigger.

data/doc/association_basics.rdoc

@@ -113,7 +113,7 @@ many rows in the current table, by using a join table to associate the two table
 The one_through_one association can be thought of as a subset of the many_to_many
 association, but where there can only be 0 or 1 records in the associated table.
 This is useful if there is a unique constraint on the foreign key in the join table
-that refrences the current table.  It's also useful if you want to impose an order
+that references the current table.  It's also useful if you want to impose an order
 on the association and just want the first record returned.  The one_through_one
 association is so named because it sets up a one-to-one association through a
 single join table.
@@ -781,7 +781,7 @@ Sequel is designed to be very flexible.  If the default behavior of the
 association modification methods isn't what you desire, you can override
 the methods in your classes.  However, you should be aware that for each
 of the association modification methods described, there is a private
-method that is preceeded by an underscore that does the actual
+method that is preceded by an underscore that does the actual
 modification.  The public method without the underscore handles caching
 and callbacks, and shouldn't be overridden by the user.
 
@@ -1069,7 +1069,7 @@ option of the first association, it doesn't attempt to merge them.
 In addition to the options hash, the :clone option will copy a block argument
 from the existing situation.  If you want a cloned association to not have the
 same block as the association you are cloning from, specify the block: nil option
-in additon to the :clone option.
+in addition to the :clone option.
 
 ==== :dataset
 

data/doc/code_order.rdoc

@@ -7,7 +7,7 @@ this guide will be specific about which are strictly necessary.
 
 == Require Sequel
 
-This is sort of a no brainer, but you need to require the library
+This is sort of a no-brainer, but you need to require the library
 first.  This is a strict requirement, none of the other code can
 be executed unless the library has been required first. Example:
 
@@ -70,7 +70,7 @@ copied into the subclass when model subclasses are created.  Example:
 == Load Model Classes
 
 After you have established a database connection, and configured your
-global model configration and global plugins, you can load your model
+global model configuration and global plugins, you can load your model
 classes.  It's recommended to have a separate file for each model class,
 unless the model classes are very simple.  Example:
 
@@ -91,6 +91,16 @@ unsafe runtime modification of the configuration:
   model_classes.each(&:freeze)
   DB.freeze
 
+The `subclasses` plugin can be used to keep track of all model classes
+that have been setup in your application. Finalizing their associations
+and freezing them can easily be achieved through the plugin:
+
+  # Register the plugin before setting up the models
+  Sequel::Model.plugin :subclasses
+  # ... setup models
+  # Now finalize associations & freeze models by calling the plugin:
+  Sequel::Model.freeze_descendents
+
 == Disconnect If Using Forking Webserver with Code Preloading
 
 If you are using a forking webserver such as unicorn or passenger, with

data/doc/model_dataset_method_design.rdoc

@@ -4,7 +4,7 @@ How you design your model dataset methods can significantly affect the flexibili
 
 == Flexibility: Use Single Method Per Task
 
-In general, it is recommended that you have a single method per task for maximum flexibilty.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
+In general, it is recommended that you have a single method per task for maximum flexibility.  For example, let's say you need to retrieve all albums released in a given year, ordered by number of units sold descending, and only care about the id, name and number of units sold.  One way to do this is in your application code (outside the model), you can
 call the dataset methods directly:
 
   Album.

data/doc/postgresql.rdoc

@@ -139,6 +139,77 @@ conversion via a USING clause, and Sequel supports this using the :using
   # ALTER TABLE "table" ALTER COLUMN "unix_time" TYPE timestamp
   #   USING (CAST('epoch' AS timestamp) + (CAST('1 second' AS interval) * "unix_time"))
 
+=== Creating Partitioned Tables
+
+PostgreSQL allows marking tables as partitioned tables, and adding partitions to such tables. Sequel
+offers support for this.  You can create a partitioned table using the +:partition_by+ option and
++:partition_type+ options (the default partition type is range partitioning):
+
+  DB.create_table(:table1, partition_by: :column, partition_type: :range) do
+    Integer :id
+    Date :column
+  end
+
+  DB.create_table(:table2, partition_by: :column, partition_type: :list) do
+    Integer :id
+    String :column
+  end
+
+  DB.create_table(:table3, partition_by: :column, partition_type: :hash) do
+    Integer :id
+    Integer :column
+  end
+
+To add partitions of other tables, you use the +:partition_of+ option.  This option will use
+a custom DSL specific to partitioning other tables. For range partitioning, you can use the
++from+ and +to+ methods to specify the inclusive beginning and exclusive ending of the
+range of the partition.  You can call the +minvalue+ and +maxvalue+ methods to get the minimum
+and maximum values for the column(s) in the range, useful as arguments to +from+ and +to+:
+
+  DB.create_table(:table1a, partition_of: :table1) do
+    from minvalue
+    to 0
+  end
+  DB.create_table(:table1b, partition_of: :table1) do
+    from 0
+    to 100
+  end
+  DB.create_table(:table1c, partition_of: :table1) do
+    from 100
+    to maxvalue
+  end
+
+For list partitioning, you use the +values_in+ method.  You can also use the +default+ method
+to mark a partition as the default partition:
+
+  DB.create_table(:table2a, partition_of: :table2) do
+    values_in 1, 2, 3
+  end
+  DB.create_table(:table2b, partition_of: :table2) do
+    values_in 4, 5, 6
+  end
+  DB.create_table(:table2c, partition_of: :table2) do
+    default
+  end
+
+For hash partitioning, you use the +modulus+ and +remainder+ methods:
+
+  DB.create_table(:table3a, partition_of: :table3) do
+    modulus 3
+    remainder 0
+  end
+  DB.create_table(:table3b, partition_of: :table3) do
+    modulus 3
+    remainder 1
+  end
+  DB.create_table(:table3c, partition_of: :table3) do
+    modulus 3
+    remainder 2
+  end
+
+There is currently no support for using custom column or table constraints in partitions of
+other tables.  Support may be added in the future.
+
 === Creating Unlogged Tables
 
 PostgreSQL allows users to create unlogged tables, which are faster but not crash safe.  Sequel

data/doc/release_notes/5.29.0.txt

@@ -0,0 +1,22 @@
+= New Features
+
+* An empty_failure_backtraces plugin has been added for using empty
+  backtraces for ValidationFailed and HookFailed exceptions. In many
+  cases, these exceptions are automatically handled (e.g. web form
+  submission handling to display appropriate error pages), and using
+  empty backtraces is 10-15x faster on JRuby 9.2.7.0+.
+
+* Dataset#json_serializer_opts has been added to the json_serializer
+  plugin.  This allows setting default options on a per-Dataset basis
+  for all Dataset#to_json calls.
+
+= Other Improvements
+
+* Another disconnect error is now recognized in the tinytds adapter.
+
+* Using Sequel with the the CRuby master branch (what will be Ruby 3)
+  now works by supporting a second argument for
+  Dataset#initialize_clone.
+
+* Sequel now avoids a warning in verbose mode when using the postgres
+  adapter, a recent version of ruby-pg, and bound variables.

data/doc/release_notes/5.30.0.txt

@@ -0,0 +1,20 @@
+= New Features
+
+* Sequel now supports generated columns on SQLite 3.31+ using the
+  :generated_always_as and :generated_type options. Example:
+
+    DB.create_table(:table) do
+      primary_key :id
+      Numeric :amount, null: false
+      Numeric :tax, null: false
+      Numeric :total, generated_always_as: (Sequel[:amount] + :tax)
+    end
+
+= Other Improvements
+
+* The Database#transaction :before_retry option is now called before
+  retrying the transaction even when the :num_retries option is set
+  to nil.
+
+* The gem no longer ships with specs and older release notes, reducing
+  the gem size by over 40%.

data/doc/release_notes/5.31.0.txt

@@ -0,0 +1,148 @@
+= New Features
+
+* A forbid_lazy_load plugin has been added to forbid the lazy loading
+  of model associations if the current object was retreived with other
+  objects.  This plugin helps detect N+1 query issues.  This plugin
+  will raise an error if a lazy load is detected in such cases:
+
+    Album.plugin :forbid_lazy_load
+    Album.one_to_many :tracks
+
+    Album.each do |album|
+      album.tracks
+      # Could be N+1, raises Sequel::Plugins::ForbidLazyLoad::Error
+    end
+
+    Album.first.tracks
+    # Could not be N+1, no error raised
+
+  The forbid_lazy_load plugin is designed to be loaded into the base
+  model class (generally Sequel::Model), and can be loaded only in
+  test mode, or only in certain test mode configurations, so that it
+  does not have any production performance impact.
+
+  Note that an alternative approach that Sequel has supported for many
+  years is the tactical_eager_loading plugin, which automatically
+  eager loads when an N+1 query issue is detected.
+
+* An association_lazy_eager_option plugin has been added which supports
+  the :eager option for the association method.  If the association has
+  not been loaded, this eagerly loads the associations specified by the
+  :eager option when loading the association.  If the association has
+  already been loaded, this option is ignored, with the assumption that
+  whatever loaded the association already used the correct eager
+  loading.  Example:
+
+    Album.plugin :association_lazy_eager_option
+    Album.one_to_many :tracks
+    Track.many_to_one :artist
+
+    album = Album.first
+    album.tracks(:eager=>:artist)
+    # Loads tracks for album, then artist for each track (2 queries)
+
+    album.tracks(:eager=>:artist)
+    # No query issued as association is cached
+
+  You could previously have similar behavior for uncached associations
+  by passing a block to the association method and calling eager on
+  the yielded dataset.  However, that would ignore any cached
+  association, causing redundant loading of the association in such
+  cases.
+
+* On PostgreSQL 10+, creating partitioned tables and partitions of
+  other tables is now supported.
+
+  To create a partitioned table, use the :partition_by option:
+
+    DB.create_table(:table1, partition_by: :date_column,
+                            partition_type: :range) do
+      Integer :id
+      Date :date_column
+    end
+
+    DB.create_table(:table2, partition_by: :string_column,
+                             partition_type: :list) do
+      Integer :id
+      String :string_column
+    end
+
+    DB.create_table(:table3, partition_by: :int_column,
+                             partition_type: :hash) do
+      Integer :id
+      Integer :int_column
+    end
+
+  To add partitions of other tables, use the :partition_of option.
+  This option will use a custom DSL specific to partitions of other
+  tables.
+  
+  For range partitioning, you can use the from and to methods to
+  specify the inclusive beginning and exclusive ending of the range
+  of the partition.  You can call the minvalue and maxvalue methods
+  to get the minimum and maximum values for the column(s) in the
+  range, useful as arguments to from and to:
+
+    DB.create_table(:table1a, partition_of: :table1) do
+      from minvalue
+      to 0
+    end
+    DB.create_table(:table1b, partition_of: :table1) do
+      from 0
+      to 100
+    end
+    DB.create_table(:table1c, partition_of: :table1) do
+      from 100
+      to maxvalue
+    end
+
+  For list partitioning, you use the values_in method.  You can also
+  use the default method to mark a partition as the default partition:
+
+    DB.create_table(:table2a, partition_of: :table2) do
+      values_in 1, 2, 3
+    end
+    DB.create_table(:table2b, partition_of: :table2) do
+      values_in 4, 5, 6
+    end
+    DB.create_table(:table2c, partition_of: :table2) do
+      default
+    end
+
+  For hash partitioning, you use the modulus and remainder methods:
+
+    DB.create_table(:table3a, partition_of: :table3) do
+      modulus 3
+      remainder 0
+    end
+    DB.create_table(:table3b, partition_of: :table3) do
+      modulus 3
+      remainder 1
+    end
+    DB.create_table(:table3c, partition_of: :table3) do
+      modulus 3
+      remainder 2
+    end
+
+* On PostgreSQL 12+ and SQLite 3.31+, column schema hashes now have
+  a :generated entry for whether the column is a generated column.
+
+* The schema_dumper extension now dumps generated columns correctly
+  when using the :same_db option on PostgreSQL 12+.
+
+* A skip_saving_columns plugin has been added.  This allows skipping
+  saving of specific columns for the model.  By default, it skips
+  saving of generated columns, but you can customize the columns
+  that it skips:
+
+    Album.plugin :skip_saving_columns
+    Album.skip_saving_columns = [:some_column]
+
+= Other Improvements
+
+* The alter_table drop_constraint :primary_key option on SQLite now
+  works correctly for non-integer primary keys.
+
+* When an error is raised due to an irreversible migration, the error
+  message now includes the file containing the migration for easier
+  debugging.

data/doc/release_notes/5.32.0.txt

@@ -0,0 +1,46 @@
+= New Features
+
+* A fiber_concurrency extension has been added, for using
+  Fiber.current instead of Thread.current when checking out a
+  connection.  This allows separate fibers of the same thread
+  to use separate connections.  In addition to allowing direct use
+  of fibers, this also allows concurrent use of multiple enumerators
+  that use database connections in the same thread.
+
+  When using this extension, you must be careful and ensure that you
+  are not using more concurrent fibers than your connection pool size.
+  Otherwise, all fibers will block while one fiber waits until a
+  connection is available.  It is possible this issue will be
+  addressed when Ruby implements a fiber scheduler (currently
+  being discussed for inclusion in Ruby 3).
+
+* A run_transaction_hooks Database extension has been added,
+  allowing for running the transaction hooks before commit/rollback,
+  which can be helpful for testing the hooks when using transactional
+  testing.
+
+= Other Improvements
+
+* Database#create_table? now works correctly with the :partition_of
+  option on PostgreSQL.
+
+* The timestamp(N) with time zone type is now recognized by the
+  schema parser.
+
+* Singleton methods of the Sequel module have now been moved into a
+  Sequel::SequelMethods module.  This allows you to extend Sequel
+  with a module that overrides the methods and call super to get
+  the default behavior.
+
+* The pg_inet extension no longer defines inet/cidr conversion procs
+  if sequel_pg 1.13.0+ is in use.  This is because sequel_pg 1.13.0+
+  will respect the conversion procs and defining them makes things
+  slower.  sequel_pg 1.13.0+ handles the same conversion by default
+  without needing a conversion proc.
+
+* Method visibility issues in the model, plugin, extension, and adapter
+  code have been fixed.  Most cases fixed were private methods being
+  accidentally made public when they were overridden.
+
+  During this change, Model#_insert_values was changed from public to
+  private, since it was originally intended to be private.

data/doc/release_notes/5.33.0.txt

@@ -0,0 +1,24 @@
+= New Features
+
+* Custom join types are now supported on a per-association basis when
+  using eager_graph/association_join.  This builds on the previous
+  support for custom aliases, using Sequel::SQL::AliasedExpression:
+
+    class Artist < Sequel::Model; end
+    class Album < Sequel::Model; end
+    class Track < Sequel::Model; end
+    Artist.one_to_many :albums
+    Album.one_to_many :tracks
+    Artist.eager_graph(
+      Sequel[:albums].as(:a, join_type: :inner) =>
+        Sequel[:tracks].as(:t, join_type: :left)
+    )
+
+* A Database#current_timestamp_utc accessor has been added on SQLite.
+  Setting this to true will keep CURRENT_TIMESTAMP, CURRENT_TIME, and
+  CURRENT_DATE in UTC instead of converting them to localtime.
+
+= Other Improvements
+
+* The smallserial PostgreSQL type is now recognized and Sequel will
+  not try to mark smallserial columns as identity columns.