sequel 5.8.0 → 5.38.0

data/MIT-LICENSE

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

@@ -9,7 +9,7 @@ toolkit for Ruby.
   records to Ruby objects and handling associated records.
 * Sequel supports advanced database features such as prepared
   statements, bound variables, savepoints, two-phase commit,
-  transaction isolation, master/slave configurations, and
+  transaction isolation, primary/replica configurations, and
   database sharding.
 * Sequel currently has adapters for ADO, Amalgalite, 
   IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle,
@@ -172,7 +172,7 @@ Datasets are the primary way records are retrieved and manipulated.  They are ge
   posts = DB.from(:posts)
   posts = DB[:posts] # same
 
-Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc..  Datasets are always frozen, and they safe to use by multiple threads concurrently.
+Datasets will only fetch records when you tell them to. They can be manipulated to filter records, change ordering, join tables, etc.  Datasets are always frozen, and they are safe to use by multiple threads concurrently.
 
 === Retrieving Records
 
@@ -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
@@ -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/bin/sequel

@@ -195,6 +195,10 @@ begin
     same_db = DB.database_type==TO_DB.database_type
     index_opts = {:same_db=>same_db}
     index_opts[:index_names] = :namespace if !DB.global_index_namespace? && TO_DB.global_index_namespace?
+    if DB.database_type == :sqlite && !same_db
+      # SQLite integer types allows 64-bit integers
+      TO_DB.extension :integer64
+    end
 
     puts "Databases connections successful"
     schema_migration = eval(DB.dump_schema_migration(:indexes=>false, :same_db=>same_db))

data/doc/advanced_associations.rdoc

@@ -1,29 +1,149 @@
 = Advanced Associations
 
-Sequel::Model's association support is very powerful and flexible, but using that power and flexibility
-often results in complexity.
+Sequel::Model's association support is powerful and flexible, but it can be difficult for
+new users to understand what the support enables.  This guide shows off some of the more
+advanced Sequel::Model association features.
 
 You should probably review the {Model Associations Basics and Options guide}[rdoc-ref:doc/association_basics.rdoc]
 before reviewing this guide.
 
-== Background: Sequel::Model association options
+== Sequel::Model Eager Loading
+
+Sequel::Model offers two different ways to perform eager loading, +eager+ and
++eager_graph+. +eager+ uses an SQL query per association, +eager_graph+ uses a single
+SQL query containing JOINs.
+
+Assuming the following associations:
+
+  Artist.one_to_many :albums
+  Album.one_to_many :tracks
+  Tracks.many_to_one :lyric
+
+Let's say you wanted to load all artists and eagerly load the related albums, tracks, and lyrics.
+
+  Artist.eager(albums: {tracks: :lyric})
+  # 4 Queries:
+  # SELECT * FROM artists;
+  # SELECT * FROM albums WHERE (artist_id IN (...));
+  # SELECT * FROM tracks WHERE (album_id IN (...));
+  # SELECT * FROM lyrics WHERE (id IN (...));
+
+  Artist.eager_graph(albums: {tracks: :lyric})
+  # 1 Query:
+  # SELECT artists.id, artists.name, ...
+  #        albums.id AS albums_id, albums.name AS albums_name, ...
+  #        tracks.id AS tracks_id, tracks.name AS tracks_name, ...
+  #        lyric.id AS lyric_id, ...
+  # FROM artists
+  # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+  # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+  # LEFT OUTER JOIN lyrics AS lyric ON (lyric.id = tracks.lyric_id);
+
+In general, the recommendation is to use +eager+ unless you have a reason to use +eager_graph+.
++eager_graph+ is needed when you want to reference columns in an associated table.  For example,
+if you want to order the loading of returned artists based on the names of the albums, you cannot
+do:
+
+  Artist.eager(albums: {tracks: :lyric}).order{albums[:name]}
+
+because the initial query Sequel will use would be:
+
+  # SELECT * FROM artists ORDER BY albums.name;
+
+and +albums+ is not a valid qualifier in such a query.  In this situation, you must use +eager_graph+:
+
+  Artist.eager_graph(albums: {tracks: :lyric}).order{albums[:name]}
+
+Whether +eager+ or +eager_graph+ performs better is association and database dependent. If
+you are concerned about performance, you should try benchmarking both cases with appropriate
+data to see which performs better.
+
+=== Mixing eager and eager_graph
+
+Sequel offers the ability to mix +eager+ and +eager_graph+ when loading results.  This can
+be done at the main level by calling both +eager+ and +eager_graph+ on the same dataset:
+
+  Album.eager(:artist).eager_graph(:tracks)
+  # 2 Queries:
+  # SELECT albums.id, albums.name, ...
+  #        artist.id AS artist_id, artist.name AS artist_name, ...
+  # FROM albums
+  # LEFT OUTER JOIN artists AS artist ON (artist.id = albums.artist_id);
+  # SELECT * FROM artists WHERE (id IN (...));
+
+You can also use +eager+ to load initial associations, and +eager_graph+ to load
+remaining associations, by using +eager_graph+ in an eager load callback:
+
+  Artist.eager(albums: {tracks: proc{|ds| ds.eager_graph(:lyric)}})
+  # 3 Queries:
+  # SELECT * FROM artists;
+  # SELECT * FROM albums WHERE (artist_id IN (...));
+  # SELECT tracks.id, tracks.name, ...
+  #        lyric.id AS lyric_id, ...
+  # FROM tracks
+  # LEFT OUTER JOIN lyrics AS lyric ON (lyric.id = tracks.lyric_id)
+  # WHERE (tracks.album_id IN (...));
+
+Using the +eager_graph_eager+ plugin, you can use +eager_graph+ to load the
+initial associations, and +eager+ to load the remaining associations.  When
+you call +eager_graph_eager+, you must specify the dependency chain at
+which to start the eager loading via +eager+:
+
+  Artist.plugin :eager_graph_eager
+  Artist.eager_graph(albums: :tracks).eager_graph_eager([:albums, :tracks], :lyric)
+  # 2 Queries:
+  # SELECT artists.id, artists.name, ...
+  #        albums.id AS albums_id, albums.name AS albums_name, ...
+  #        tracks.id AS tracks_id, tracks.name AS tracks_name, ...
+  # FROM artists
+  # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id)
+  # LEFT OUTER JOIN tracks ON (tracks.album_id= albums.id);
+  # SELECT * FROM lyrics WHERE (id IN (...));
+
+These two approaches can also be nested, with +eager+ -> +eager_graph+ -> +eager+:
+
+  Album.plugin :eager_graph_eager
+  Artist.eager(albums: proc{|ds| ds.eager_graph(:tracks).eager_graph_eager([:tracks], :lyric)})
+  # 3 Queries:
+  # SELECT * FROM artists;
+  # SELECT albums.id, albums.name, ...
+  #        tracks.id AS tracks_id, tracks.name AS tracks_name, ...
+  # FROM albums 
+  # LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)
+  # WHERE (albums.artist_id IN (...));
+  # SELECT * FROM lyrics WHERE (id IN (...));
+
+Or with 2 separate +eager_graph+ queries:
+
+  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, ...
+  # FROM artists
+  # LEFT OUTER JOIN albums ON (albums.artist_id = artists.id);
+  # SELECT tracks.id, tracks.name, ...
+  #        lyric.id AS lyric_id, ...
+  # FROM tracks
+  # LEFT OUTER JOIN lyrics AS lyric ON (lyric.id = tracks.lyric_id)
+  # WHERE (tracks.album_id IN (...));
+
+== Sequel::Model Association Loading Options
 
 There are a bunch of advanced association options that are available to
 handle more complex cases.  First we'll go over some of the simpler ones:
 
 All associations take a block that can be used to further filter/modify the
-default dataset.  There's also an :eager_block option if you want to use
-a different block when eager loading via <tt>Dataset#eager</tt>. Association blocks are
-useful for things like:
+default dataset:
 
   Artist.one_to_many :gold_albums, class: :Album do |ds|
     ds.where{copies_sold > 500000}
   end
 
-There are a whole bunch of options for changing how the association is eagerly
-loaded via <tt>Dataset#eager_graph</tt>: <tt>:graph_block</tt>, <tt>:graph_conditions</tt>,
-<tt>:graph_only_conditions</tt>, <tt>:graph_join_type</tt> (and <tt>:graph_join_table_*</tt> ones for
-JOINing to the join table in a many_to_many association).
+There's also an :eager_block option if you want to use a different block when
+eager loading via <tt>Dataset#eager</tt>.
+
+There are many options for changing how the association is eagerly
+loaded via <tt>Dataset#eager_graph</tt>:
 
 :graph_join_type :: The type of join to do (<tt>:inner</tt>, <tt>:left</tt>, <tt>:right</tt>)
 :graph_conditions :: Additional conditions to put on join (needs to be a
@@ -62,10 +182,6 @@ These can be used like this:
   # Handles the case where both key columns have the name artist_name, and you want to use
   # a JOIN USING
   Artist.one_to_many :albums, key: :artist_name, graph_only_conditions: [:artist_name]
-  
-Remember, using +eager_graph+ is generally only necessary when you need to
-filter/order based on columns in an associated table, it is recommended to
-use +eager+ for eager loading if possible.
 
 One advantage of using +eager_graph+ is that you can easily filter/order
 on columns in an associated table on a per-query basis, using regular
@@ -83,6 +199,8 @@ For lazy loading (e.g. Model[1].association), the <tt>:dataset</tt> option can b
 to specify an arbitrary dataset (one that uses different keys, multiple keys,
 joins to other tables, etc.).
 
+== Custom Eager Loaders
+
 For eager loading via +eager+, the <tt>:eager_loader</tt> option can be used to specify
 how to eagerly load a complex association.  This is an extremely powerful
 option.  Though it can often be verbose (compared to other things in Sequel),
@@ -613,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:
@@ -631,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
@@ -652,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
@@ -761,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
 
@@ -1676,11 +1676,16 @@ instances.
 ==== :instance_specific
 
 This allows you to override the setting of whether the dataset contains instance
-specific code.  For example, if you are passing a block to the association,
+specific code.  If you are passing a block to the association,
 Sequel sets this to true by default, which disables some optimizations that
 would be invalid if the association is instance specific.  If you know that the
 block does not contain instance specific code, you can set this to false to
-reenable the optimizations.
+reenable the optimizations.  Instance specific code is mostly commonly calling
+model instance methods inside an association block, but also
+includes cases where the association block can return different values based
+on the runtime environment, such as calls to <tt>Time.now</tt> in the block.
+Associations that use the :dataset option are always considered instance specific,
+even if explicitly specified otherwise.
 
 ==== :cartesian_product_number 
 

data/doc/cheat_sheet.rdoc

@@ -55,6 +55,7 @@ Without a filename argument, the sqlite adapter will setup a new sqlite database
 
   dataset.exclude(:active).delete
   dataset.where{price < 100}.update(:active => true)
+  dataset.where(:active).update(:price => Sequel[:price] * 0.90)
 
 == Datasets are Enumerable
 

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/dataset_filtering.rdoc

@@ -36,8 +36,8 @@ Ranges (both inclusive and exclusive) can also be used:
 
 If you need to select multiple items from a dataset, you can supply an array:
 
-	items.where(id: [1, 38, 47, 99]).sql
-	# "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
+  items.where(id: [1, 38, 47, 99]).sql
+  # "SELECT * FROM items WHERE (id IN (1, 38, 47, 99))"
 
 == Filtering using expressions
 
@@ -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/mass_assignment.rdoc

@@ -15,13 +15,13 @@ and you call a mass assignment method with a hash:
 
 the mass assignment method will go through each key in the hash, append <tt>=</tt> to it to determine the
 setter method, and if the setter method is defined and access to it is not restricted, Sequel will call the
-setter method with the hash value.  So if we assume that the posts table has subject and text columns, what
+setter method with the hash value.  So if we assume that the posts table has title and body columns, what
 the above mass assignment call actually does is:
- 
+
   post.title=('T')
   post.body=('B')
 
-By default, there are two types of setter methods that are restricted.  
+By default, there are two types of setter methods that are restricted.
 The first is methods like <tt>typecast_on_assignment=</tt> and <tt>==</tt>, which don't affect columns.
 These methods cannot be enabled for mass assignment.
 The second is primary key setters.

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/model_plugins.rdoc

@@ -212,7 +212,7 @@ In general you should only require plugin arguments if you absolutely must have
 
 == Handling Subclasses
 
-Sequel::Model uses a copy-on-subclassing approach to model state.  So instead of model subclasses asking their parent class for a value if they don't have it defined, the value is automatically copied from the parent class to the subclass when the subclass is created.  While you can do this by overriding the inherited class method, there is a available shortcut that handles most cases:
+Sequel::Model uses a copy-on-subclassing approach to model state.  So instead of having a model subclass ask its superclass for a value if the subclass don't have the value defined, the value should be copied from the parent class to the subclass when the subclass is created.  While this can be implemented by overriding the +inherited+ class method, there is an available shortcut that handles most cases:
 
   module Sequel::Plugins::Foo
     module ClassMethods

data/doc/opening_databases.rdoc

@@ -75,15 +75,24 @@ These options are shared by all adapters unless otherwise noted.
 
 :adapter :: The adapter to use
 :database :: The name of the database to which to connect
+:extensions :: Extensions to load into this Database instance.  Can be a symbol, array of symbols,
+               or string with extensions separated by columns.  These extensions are loaded after
+               connections are made by the :preconnect option.
 :cache_schema :: Whether schema should be cached for this database (true by default)
 :default_string_column_size :: The default size for string columns (255 by default)
 :host :: The hostname of the database server to which to connect
 :keep_reference :: Whether to keep a reference to the database in Sequel::DATABASES (true by default)
+:logger :: A specific SQL logger to log to
 :loggers :: An array of SQL loggers to log to
 :log_connection_info :: Whether to include connection information in log messages (false by default)
 :log_warn_duration :: The amount of seconds after which the queries are logged at :warn level
 :password :: The password for the user account
-:servers :: A hash with symbol keys and hash or proc values, used with master/slave/partitioned database configurations
+:preconnect :: Whether to automatically make the maximum number of connections when setting up the pool.
+               Can be set to "concurrently" to connect in parallel.
+:preconnect_extensions :: Similar to the :extensions option, but loads the extensions before the
+                          connections are made by the :preconnect option.
+:quote_identifiers :: Whether to quote identifiers.
+:servers :: A hash with symbol keys and hash or proc values, used with primary/replica and sharded database configurations
 :sql_log_level :: The level at which to issue queries to the loggers (:info by default)
 :test :: Whether to test that a valid database connection can be made (true by default)
 :user :: The user account name to use logging in
@@ -95,8 +104,6 @@ The following options can be specified and are passed to the database's internal
                   useful for customizations that you want to apply to all connections (nil by default).
 :max_connections :: The maximum size of the connection pool (4 connections by default on most databases)
 :pool_timeout :: The number of seconds to wait if a connection cannot be acquired before raising an error (5 seconds by default)
-:preconnect :: Whether to automatically make the maximum number of connections when setting up the pool.
-               Can be set to "concurrently" to connect in parallel.
 :single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
 
 == Adapter specific connection options
@@ -180,9 +187,8 @@ For Derby, H2, HSQLDB, JTDS, MySQL, Postgres, SQLite3
 the adapters can use the `jdbc-*` gem, for the others you need to have the `.jar` in your CLASSPATH
 or load the Java class manually before calling Sequel.connect.
 
-
 Note that when using a JDBC adapter, the best way to use Sequel
-is via Sequel.connect, NOT Sequel.jdbc.  Use the JDBC connection
+is via Sequel.connect using a connection string, NOT Sequel.jdbc.  Use the JDBC connection
 string when connecting, which will be in a different format than
 the native connection string.  The connection string should start
 with 'jdbc:'.  For PostgreSQL, use 'jdbc:postgresql:', and for
@@ -194,11 +200,15 @@ Sequel does no preprocessing of JDBC connection strings, it passes them directly
 So if you have problems getting a connection string to work, look up the 
 documentation for the JDBC driver.
 
+The jdbc adapter does not handle common options such as +:host+,
++:user+, and +:port+.  If you must use a hash of options when connecting,
+provide the full JDBC connection string as the :uri option.
+
 Example connection strings:
 
   jdbc:sqlite::memory:
   jdbc:postgresql://localhost/database?user=username
-  jdbc:mysql://localhost/test?user=root&password=root
+  jdbc:mysql://localhost/test?user=root&password=root&serverTimezone=UTC
   jdbc:h2:mem:
   jdbc:hsqldb:mem:mymemdb
   jdbc:derby:memory:myDb;create=true
@@ -230,10 +240,14 @@ The following additional options are supported:
 There are a few issues with specific jdbc driver gems:
 
 jdbc-h2 :: jdbc-h2 versions greater than 1.3.175 have issues with ORDER BY not working correctly in some cases.
+jdbc-mysql :: Depending on the configuration of the MySQL server, jdbc-mysql versions greater 8 may complain
+              about the server time zone being unrecognized.  You can either use an older jdbc-mysql version,
+              or you can specify the +serverTimezone+ option in the connection string, as shown in the example
+              jdbc:mysql connection string above.
 
 === mysql 
 
-Requires: mysqlplus (or mysql if mysqlplus is not available)
+Requires: mysql
 
 The MySQL adapter does not support the pure-ruby mysql.rb driver, it requires the C-extension driver.
 
@@ -254,7 +268,8 @@ The following additional options are supported:
              or an array of symbols or strings (e.g. <tt>:sql_mode=>[:no_zero_date, :pipes_as_concat]</tt>).
 :timeout :: Sets the wait_timeout for the connection, defaults to 1 month.
 :read_timeout :: Set the timeout in seconds for reading back results to a query.
-:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned.
+:connect_timeout :: Set the timeout in seconds before a connection attempt is abandoned
+                    (may not be supported when using MariaDB 10.2+ client libraries).
 
 The :sslkey, :sslcert, :sslca, :sslcapath, and :sslca options (in that order) are passed to Mysql#ssl_set method
 if either the :sslca or :sslkey option is given.
@@ -309,6 +324,10 @@ The following additional options are supported:
                                 conversion is done, so an error is raised if you attempt to retrieve an infinite
                                 timestamp/date.  You can set this to :nil to convert to nil, :string to leave
                                 as a string, or :float to convert to an infinite float.
+:conn_str :: Use connection string (in form of `host=x port=y ...`). Ignores all other options, only supported with pg
+             library. See https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING and 
+             https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-PARAMKEYWORDS for format and list of supported
+             options.
 :connect_timeout :: Set the number of seconds to wait for a connection (default 20, only respected
                     if using the pg library).
 :driver_options :: A hash of options to pass to the underlying driver (only respected if using the pg library)
@@ -386,6 +405,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.