tdiary 5.0.13 → 5.0.14

data/vendor/bundle/gems/sequel-5.18.0/doc/opening_databases.rdoc

@@ -1,407 +0,0 @@
-= Connecting to a database
-
-All Sequel activity begins with connecting to a database, which creates a
-Sequel::Database object. The Database object is used to create datasets and execute
-queries. Sequel provides a powerful and flexible mechanism for connecting to
-databases.  There are two main ways to establish database connections:
-
-1. Using the Sequel.connect method
-2. Using the specialized adapter method (Sequel.sqlite, Sequel.postgres, etc.)
-
-The connection options needed depend on the adapter being used, though most adapters
-share the same basic connection options.
-
-If you are only connecting to a single database, it is recommended that you store the
-database object in a constant named DB.  This is not required, but it is the
-convention that most Sequel code uses.
-
-== Using the Sequel.connect method
-
-The connect method usually takes a well-formed URI, which is parsed into connection options needed to open
-the database connection.  The scheme/protocol part of the URI is used to determine the adapter to use:
-
-  DB = Sequel.connect('postgres://user:password@localhost/blog') # Uses the postgres adapter
-
-You can use URI query parameters to specify options:
-
-  DB = Sequel.connect('postgres://localhost/blog?user=user&password=password')
-
-You can also pass an additional option hash with the connection string:
-
-  DB = Sequel.connect('postgres://localhost/blog', user: 'user', password: 'password')
-
-You can also just use an options hash without a connection string.  If you do this, you must
-provide the adapter to use:
-
-  DB = Sequel.connect(adapter: 'postgres', host: 'localhost', database: 'blog', user: 'user', password: 'password')
-
-All of the above statements are equivalent.
-
-== Using the specialized adapter method
-
-The specialized adapter method is similar to Sequel.connect with an options hash, except that it
-automatically populates the :adapter option and assumes the first argument is the :database option,
-unless the first argument is a hash. So the following statements are equivalent to the previous statements.
-
-  DB = Sequel.postgres('blog', host: 'localhost', user: 'user', password: 'password')
-  DB = Sequel.postgres(host: 'localhost', user: 'user', password: 'password', database: 'blog')
-
-Note that using an adapter method forces the use of the specified adapter, not a database type, even
-though some adapters have the same name as the database type.  So if you
-want to connect to SQLite, for example, you can do so using the sqlite, amalgalite, and jdbc adapters.
-If you want to connect to SQLite on JRuby using the jdbc adapter, you should not use <tt>Sequel.sqlite</tt>
-for example, as that uses the C-based sqlite3 gem. Instead, the <tt>Sequel.jdbc</tt> would be appropriate (though
-as mentioned below, using <tt>Sequel.connect</tt> is recommended instead of <tt>Sequel.jdbc</tt>). 
-
-== Passing a block to either method
-
-Both the Sequel.connect method and the specialized adapter methods take a block.  If you
-provide a block to the method, Sequel will create a Database object and pass it as an argument
-to the block.  When the block returns, Sequel will disconnect the database connection.
-For example:
-
-  Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
-
-Note that if you do not pass a block to Sequel.connect, Sequel will automatically retain a
-reference to the object in the <tt>Sequel::DATABASES</tt> array.  So calling +Sequel.connect+
-multiple times (say once per request), can result in a memory leak.  For any application where
-database access is needed for a long period of time, it's best to store the result of
-Sequel.connection in a constant, as recommended above.
-
-== Using the Sequel.connect method
-== General connection options
-
-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
-: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
-
-The following options can be specified and are passed to the database's internal connection pool.
-
-:after_connect :: A callable object called after each new connection is made, with the
-                  connection object (and server argument if the callable accepts 2 arguments),
-                  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)
-:single_threaded :: Whether to use a single-threaded (non-thread safe) connection pool
-
-== Adapter specific connection options
-
-The following sections explain the options and behavior specific to each adapter.
-If the library the adapter requires is different from the name of the adapter
-scheme, it is listed specifically, otherwise you can assume that is requires the
-library with the same name.
-
-=== ado
-
-Requires: win32ole 
-
-The ADO adapter provides connectivity to ADO databases in Windows. It relies
-on WIN32OLE library, so it isn't usable on other operating systems (except
-possibly through WINE, but that's unlikely).
-
-The following options are supported:
-
-:command_timeout :: Sets the time in seconds to wait while attempting
-                    to execute a command before cancelling the attempt and generating
-                    an error. Specifically, it sets the ADO CommandTimeout property.
-:driver :: The driver to use in the ADO connection string.  If not provided, a default
-           of "SQL Server" is used.
-:conn_string :: The full ADO connection string.  If this is provided,
-                the usual options are ignored.
-:provider :: Sets the Provider of this ADO connection (for example, "SQLOLEDB").
-             If you don't specify a provider, the default one used by WIN32OLE
-             has major problems, such as creating a new native database connection
-             for every query, which breaks things such as transactions and temporary tables.
-
-Pay special attention to the :provider option, as without specifying a provider,
-many things will be broken.  The SQLNCLI10 and SQLNCLI11 providers work well if you
-are connecting to Microsoft SQL Server, but it is not the default as it depends on
-those providers being installed.
-
-Example connections:
-
-  # SQL Server
-  Sequel.connect('ado:///sequel_test?host=server%5cdb_instance')
-  Sequel.connect('ado://user:password@server/database?host=server%5cdb_instance&provider=SQLNCLI10')
-  # Access 2007
-  Sequel.ado(conn_string: 'Provider=Microsoft.ACE.OLEDB.12.0;Data Source=drive:\\path\\filename.accdb')
-  # Access 2000
-  Sequel.ado(conn_string: 'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=drive:\\path\\filename.mdb')
-  # Excel 2000 (for table names, use a dollar after the sheet name, e.g. Sheet1$)
-  Sequel.ado(conn_string: 'Provider=Microsoft.Jet.OLEDB.4.0;Data Source=drive:\\path\\filename.xls;Extended Properties=Excel 8.0;')
-
-=== amalgalite 
-
-Amalgalite is an ruby extension that provides self contained access to SQLite,
-so you don't need to install SQLite separately.  As amalgalite is a file backed
-database, the :host, :user, and :password options are not used.
-
-:database :: The name of the database file
-:timeout :: The busy timeout period given in milliseconds
-
-Without a database argument, assumes a memory database, so you can do:
-
-  Sequel.amalgalite
-
-Handles paths in the connection string similar to the SQLite adapter, so see
-the sqlite section below for details.
-
-=== ibmdb
-
-requires 'ibm_db'
-
-This connects to DB2 using IBM_DB.  This is the recommended adapter if you are
-using a C-based ruby to connect to DB2.
-
-=== jdbc 
-
-Requires: java
-
-Houses Sequel's JDBC support when running on JRuby.
-Support for individual database types is done using subadapters.
-There are currently subadapters for DB2, Derby, H2, HSQLDB, JTDS,
-MySQL, Oracle, PostgreSQL, SQLAnywhere, SQLite, and SQL Server.
-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
-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
-SQLite you do not need 2 preceding slashes for the database name
-(use no preceding slashes for a relative path, and one preceding
-slash for an absolute path).
-
-Sequel does no preprocessing of JDBC connection strings, it passes them directly to JDBC.
-So if you have problems getting a connection string to work, look up the 
-documentation for the JDBC driver.
-
-Example connection strings:
-
-  jdbc:sqlite::memory:
-  jdbc:postgresql://localhost/database?user=username
-  jdbc:mysql://localhost/test?user=root&password=root
-  jdbc:h2:mem:
-  jdbc:hsqldb:mem:mymemdb
-  jdbc:derby:memory:myDb;create=true
-  jdbc:sqlserver://localhost;database=sequel_test;integratedSecurity=true
-  jdbc:jtds:sqlserver://localhost/sequel_test;user=sequel_test;password=sequel_test
-  jdbc:oracle:thin:user/password@localhost:1521:database
-  jdbc:db2://localhost:3700/database:user=user;password=password;
-  jdbc:sqlanywhere://localhost?DBN=Test;UID=user;PWD=password
-
-You can also use JNDI connection strings:
-
-  jdbc:jndi:java:comp/env/jndi_resource_name
-
-The following additional options are supported:
-
-:convert_types :: If set to false, does not attempt to convert some Java types to ruby types.
-                  Setting to false roughly doubles performance when selecting large numbers of rows.
-                  Note that you can't provide this option inside the connection string (as that is passed
-                  directly to JDBC), you have to pass it as a separate option.
-:driver :: Specify the Java driver class to use to connect to the database.  This only has
-           an effect if the database type is not recognized from the connection string,
-           and only helps cases where <tt>java.sql.DriverManager.getConnection</tt> does not
-           return a connection.
-:login_timeout :: Set the login timeout on the JDBC connection (in seconds).
-:jdbc_properties :: A hash for properties to set, skips the normal connection process of using
-                    java.sql.drivermanager.getconnection and tries the backup process of using
-                    driver.new.connect for the appropriate driver.
-
-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.
-
-=== mysql 
-
-Requires: mysql
-
-The MySQL adapter does not support the pure-ruby mysql.rb driver, it requires the C-extension driver.
-
-The following additional options are supported:
-
-:auto_is_null :: If set to true, makes "WHERE primary_key IS NULL" select the last inserted id.
-:charset :: Same as :encoding, :encoding takes precedence.
-:compress :: Whether to compress data sent/received via the socket connection.
-:config_default_group :: The default group to read from the in the MySQL config file, defaults to "client")
-:config_local_infile :: If provided, sets the Mysql::OPT_LOCAL_INFILE option on the connection with the given value.
-:encoding :: Specify the encoding/character set to use for the connection.
-:fractional_seconds :: On MySQL 5.6.5+, this option is recognized and will include fractional seconds in
-                       time/timestamp values, as well as have the schema method create columns that can contain
-                       fractional seconds by deafult.  This option is also supported on other adapters that connect
-                       to MySQL.
-:socket :: Can be used to specify a Unix socket file to connect to instead of a TCP host and port.
-:sql_mode :: Set the sql_mode(s) for a given connection.  Can be single symbol or string,
-             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.
-
-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.
-
-=== mysql2
-
-This is a newer MySQL adapter that does typecasting in C, so it is often faster than the
-mysql adapter.  The options given are passed to Mysql2::Client.new, see the mysql2 documentation
-for details on what options are supported.
-
-=== odbc 
-
-The ODBC adapter allows you to connect to any database with the appropriate ODBC drivers installed.  
-The :database option given ODBC database should be the DSN (Descriptive Service Name) from the ODBC configuration.
-
-  Sequel.odbc('mydb', :user => "user", :password => "password")
-
-The :host and :port options are not respected. The following additional options are supported:
-
-:db_type :: Can be specified as 'mssql', 'progress', or 'db2' to use SQL syntax specific to those databases.
-:drvconnect :: Can be given an ODBC connection string, and will use ODBC::Database#drvconnect to
-               do the connection.  Typical usage would be: <tt>Sequel.odbc(:drvconnect=>'driver={...};...')</tt>
-
-=== oracle 
-
-Requires: oci8
-
-The following additional options are supported:
-
-:autosequence :: Set to true to use Sequel's conventions to guess the sequence to use for datasets.  False
-                 by default.
-:prefetch_rows :: The number of rows to prefetch.  Defaults to 100, a larger number can be specified
-                  and may improve performance when retrieving a large number of rows.
-:privilege :: The Oracle privilege level.
-
-=== postgres
-
-Requires: pg (or postgres-pr/postgres-compat if pg is not available)
-
-The Sequel postgres adapter works with the pg and postgres-pr ruby libraries.
-The pg library is the best supported, as it supports real bound variables and prepared statements.
-If the pg library is being used, Sequel will also attempt to load the sequel_pg library, which is
-a C extension that optimizes performance when Sequel is used with pg.  All users of Sequel who
-use pg are encouraged to install sequel_pg.  For users who want to use postgres-pr to avoid issues
-with C extensions, it is recommended to use jeremyevans-postgres-pr, which fixes many issues in
-the upstream postgres-pr gem, and is regularly tested with Sequel.
-
-The following additional options are supported:
-
-:charset :: Same as :encoding, :encoding takes precedence
-:convert_infinite_timestamps :: Whether infinite timestamps/dates should be converted on retrieval.  By default, no
-                                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)
-:encoding :: Set the client_encoding to the given string
-:notice_receiver :: A proc that be called with the PGresult objects that have notice or warning messages.
-                    The default notice receiver just prints the messages to stderr, but this can be used
-                    to handle notice/warning messages differently.  Only respected if using the pg library).
-:sslmode :: Set to 'disable', 'allow', 'prefer', 'require', 'verify-ca', or 'verify-full' to choose how to treat SSL (only
-            respected if using the pg library)
-:sslrootcert :: Specify the path to the root SSL certificate to use.
-:search_path :: Set to the schema search_path.  This can either be a single string containing the schemas
-                separated by commas (for use via a URL: <tt>postgres:///?search_path=schema1,schema2</tt>), or it
-                can be an array of strings (for use via an option:
-                <tt>Sequel.postgres(:search_path=>['schema1', 'schema2'])</tt>).
-:use_iso_date_format :: This can be set to false to not force the ISO date format.  Sequel forces
-                        it by default to allow for an optimization.
-
-=== sqlanywhere
-
-The sqlanywhere driver works off connection strings, so a connection string
-is built based on the url/options hash provided.  The following additional
-options are respected:
-
-:commlinks :: specify the CommLinks connection string option
-:conn_string :: specify the connection string to use, ignoring all other options
-:connection_name :: specify the ConnectionName connection string option
-:encoding :: specify the CharSet connection string option
-
-=== sqlite
-
-Requires: sqlite3
-
-As SQLite is a file-based database, the :host and :port options are ignored, and
-the :database option should be a path to the file.
-
-Examples:
-
-  # In Memory databases:
-  Sequel.sqlite
-  Sequel.connect('sqlite:/') 
-  Sequel.sqlite(':memory:')
-
-  # Relative Path
-  Sequel.sqlite('blog.db')
-  Sequel.sqlite('./blog.db')
-  Sequel.connect('sqlite://blog.db')
-
-  # Absolute Path
-  Sequel.sqlite('/var/sqlite/blog.db')
-  Sequel.connect('sqlite:///var/sqlite/blog.db') 
-
-The following additional options are supported:
-
-:readonly :: open database in read-only mode
-:timeout :: the busy timeout to use in milliseconds (default: 5000).
-
-Note that SQLite memory databases are restricted to a single connection by
-default.  This is because SQLite does not allow multiple connections to
-a single memory database.  For this reason, Sequel sets the maximum number
-of connections in the connection pool to 1 by default when an SQLite memory
-database is used.  Attempts to force the use of more than 1 connection
-can result in weird behavior, since the connections will be to separate
-memory databases.
-
-=== tinytds
-
-Requires: tiny_tds
-
-The connection options are passed directly
-to tiny_tds, except that the tiny_tds :username option is set to
-the Sequel :user option.  If you want to use an entry in the freetds.conf file, you
-should specify the :dataserver option with that name as the value.  Some other
-options that you may want to set are :login_timeout, :timeout, :tds_version, :azure,
-:appname, and :encoding, see the tiny_tds README for details.
-
-Other Sequel specific options:
-
-: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.
-:textsize :: Override the default TEXTSIZE setting for this connection.  The FreeTDS
-             default is small (around 64000 bytes), but can be set up to around 2GB.
-             This should be specified as an integer.  If you plan on setting large
-             text or blob values via tinytds, you should use this option or modify
-             your freetds.conf file.

data/vendor/bundle/gems/sequel-5.18.0/doc/postgresql.rdoc

@@ -1,532 +0,0 @@
-= PostgreSQL-specific Support in Sequel
-
-Sequel's core database and dataset functions are designed to support the features
-shared by most common SQL database implementations.  However, Sequel's database
-adapters extend the core support to include support for database-specific features.
-
-By far the most extensive database-specific support in Sequel is for PostgreSQL. This
-support is roughly broken into the following areas:
-
-* Database Types
-* DDL Support
-* DML Support
-* sequel_pg
-
-Note that while this guide is extensive, it is not exhaustive.  There are additional
-rarely used PostgreSQL features that Sequel supports which are not mentioned here.
-
-== Adapter/Driver Specific Support
-
-Some of this this support depends on the specific adapter or underlying driver in use.  
-<tt>postgres only</tt> will denote support specific to the postgres adapter (i.e.
-not available when connecting to PostgreSQL via the jdbc adapter).
-<tt>postgres/pg only</tt> will denote support specific to the postgres adapter when
-pg is used as the underlying driver (i.e. not available when using the postgres-pr
-driver).
-
-== PostgreSQL-specific Database Type Support
-
-Sequel's default support on PostgreSQL only includes common database types.  However,
-Sequel ships with support for many PostgreSQL-specific types via extensions.  In general,
-you load these extensions via <tt>Database#extension</tt>.  For example, to load support
-for arrays, you would do:
-
-  DB.extension :pg_array
-
-The following PostgreSQL-specific type extensions are available:
-
-pg_array :: arrays (single and multidimensional, for any scalar type), as a ruby Array-like object
-pg_hstore :: hstore, as a ruby Hash-like object
-pg_inet :: inet/cidr, as ruby IPAddr objects
-pg_interval :: interval, as ActiveSupport::Duration objects
-pg_json :: json, as either ruby Array-like or Hash-like objects
-pg_range :: ranges (for any scalar type), as a ruby Range-like object
-pg_row :: row-valued/composite types, as a ruby Hash-like or Sequel::Model object
-
-In general, these extensions just add support for Database objects to return retrieved
-column values as the appropriate type and support for literalizing
-the objects correctly for use in an SQL string, or using them as bound variable values (<tt>postgres/pg and jdbc/postgres only</tt>).
-
-There are also type-specific extensions that make it easy to use database functions
-and operators related to the type.  These extensions are:
-
-pg_array_ops :: array-related functions and operators
-pg_hstore_ops :: hstore-related functions and operators
-pg_json_ops :: json-related functions and operators
-pg_range_ops :: range-related functions and operators
-pg_row_ops :: row-valued/composite type syntax support
-
-These extensions aren't Database specific, they are global extensions, so you should
-load them via <tt>Sequel.extension</tt>, after loading support for the specific types
-into the Database instance:
-
-  DB.extension :pg_array
-  Sequel.extension :pg_array_ops
-
-With regard to common database types, please note that the generic String type
-is +text+ on PostgreSQL and not <tt>varchar(255)</tt> as it is on some other
-databases.  +text+ is PostgreSQL's recommended type for storage of text data,
-and is more similar to Ruby's String type as it allows for unlimited length.
-If you want to set a maximum size for a text column, you must specify a
-<tt>:size</tt> option.  This will use a <tt>varchar($size)</tt> type and
-impose a maximum size for the column.
-
-== PostgreSQL-specific DDL Support
-
-=== Exclusion Constraints
-
-In +create_table+ blocks, you can use the +exclude+ method to set up exclusion constraints:
-
-  DB.create_table(:table) do
-    daterange :during
-    exclude([[:during, '&&']], name: :table_during_excl)
-  end
-  # CREATE TABLE "table" ("during" daterange,
-  #   CONSTRAINT "table_during_excl" EXCLUDE USING gist ("during" WITH &&))
-
-You can also add exclusion constraints in +alter_table+ blocks using add_exclusion_constraint:
-
-  DB.alter_table(:table) do
-    add_exclusion_constraint([[:during, '&&']], name: :table_during_excl)
-  end
-  # ALTER TABLE "table" ADD CONSTRAINT "table_during_excl" EXCLUDE USING gist ("during" WITH &&)
-
-=== Adding Foreign Key and Check Constraints Without Initial Validation
-
-You can add a <tt>not_valid: true</tt> option when adding constraints to existing tables so
-that it doesn't check if all current rows are valid:
-
-  DB.alter_table(:table) do
-    # Assumes t_id column already exists
-    add_foreign_key([:t_id], :table, not_valid: true, name: :table_fk)
-
-    constraint({name: :col_123, not_valid: true}, col: [1,2,3])
-  end
-  # ALTER TABLE "table" ADD CONSTRAINT "table_fk" FOREIGN KEY ("t_id") REFERENCES "table" NOT VALID
-  # ALTER TABLE "table" ADD CONSTRAINT "col_123" CHECK (col IN (1, 2, 3)) NOT VALID
-
-Such constraints will be enforced for newly inserted and updated rows, but not for existing rows. After
-all existing rows have been fixed, you can validate the constraint:
-
-  DB.alter_table(:table) do
-    validate_constraint(:table_fk)
-    validate_constraint(:col_123)
-  end
-  # ALTER TABLE "table" VALIDATE CONSTRAINT "table_fk"
-  # ALTER TABLE "table" VALIDATE CONSTRAINT "col_123"
-
-=== Creating Indexes Concurrently
-
-You can create indexes concurrently using the <tt>concurrently: true</tt> option:
-
-  DB.add_index(:table, :t_id, concurrently: true)
-  # CREATE INDEX CONCURRENTLY "table_t_id_index" ON "table" ("t_id")
-
-Similarly, you can drop indexes concurrently as well:
-
-  DB.drop_index(:table, :t_id, concurrently: true)
-  # DROP INDEX CONCURRENTLY "table_t_id_index"
-
-=== Specific Conversions When Altering Column Types
-
-When altering a column type, PostgreSQL allows the user to specify how to do the
-conversion via a USING clause, and Sequel supports this using the <tt>:using</tt> option:
-
-  DB.alter_table(:table) do
-    # Assume unix_time column is stored as an integer, and you want to change it to timestamp
-    set_column_type :unix_time, Time, using: (Sequel.cast('epoch', Time) + Sequel.cast('1 second', :interval) * :unix_time)
-  end
-  # ALTER TABLE "table" ALTER COLUMN "unix_time" TYPE timestamp
-  #   USING (CAST('epoch' AS timestamp) + (CAST('1 second' AS interval) * "unix_time"))
-
-=== Creating Unlogged Tables
-
-PostgreSQL allows users to create unlogged tables, which are faster but not crash safe.  Sequel
-allows you do create an unlogged table by specifying the <tt>unlogged: true</tt> option to +create_table+:
-
-  DB.create_table(:table, unlogged: true){Integer :i}
-  # CREATE UNLOGGED TABLE "table" ("i" integer)
-
-=== Creating Identity Columns
-
-You can use the +:identity+ option when creating columns to mark them as identity columns.
-Identity columns are tied to a sequence for the default value.  You can still override the
-default value for the column when inserting:
-
-  DB.create_table(:table){Integer :id, identity: true}
-  # CREATE TABLE "table" ("id" integer GENERATED BY DEFAULT AS IDENTITY)
-
-If you want to disallow using a user provided value when inserting, you can mark the
-identity column using <tt>identity: :always</tt>:
-
-  DB.create_table(:table){Integer :id, identity: :always}
-  # CREATE TABLE "table" ("id" integer GENERATED ALWAYS AS IDENTITY)
-
-=== Creating/Dropping Schemas, Languages, Functions, and Triggers
-
-Sequel has built in support for creating and dropping PostgreSQL schemas, procedural languages, functions, and triggers:
-
-  DB.create_schema(:s)
-  # CREATE SCHEMA "s"
-  DB.drop_schema(:s)
-  # DROP SCHEMA "s"
-
-  DB.create_language(:plperl)
-  # CREATE LANGUAGE plperl
-  DB.drop_language(:plperl)
-  # DROP LANGUAGE plperl
-
-  DB.create_function(:set_updated_at, <<-SQL, language: :plpgsql, returns: :trigger)
-    BEGIN
-      NEW.updated_at := CURRENT_TIMESTAMP;
-      RETURN NEW;
-    END;
-  SQL
-  # CREATE FUNCTION set_updated_at() RETURNS trigger LANGUAGE plpgsql AS '
-  #  BEGIN
-  #    NEW.updated_at := CURRENT_TIMESTAMP;
-  #    RETURN NEW;
-  #  END;'
-  DB.drop_function(:set_updated_at)
-  # DROP FUNCTION set_updated_at()
-
-  DB.create_trigger(:table, :trg_updated_at, :set_updated_at, events: :update, each_row: true, when: {Sequel[:new][:updated_at] => Sequel[:old][:updated_at]})
-  # CREATE TRIGGER trg_updated_at BEFORE UPDATE ON "table" FOR EACH ROW WHEN ("new"."updated_at" = "old"."updated_at") EXECUTE PROCEDURE set_updated_at()
-  DB.drop_trigger(:table, :trg_updated_at)
-  # DROP TRIGGER trg_updated_at ON "table"
-
-However, you may want to consider just use <tt>Database#run</tt> with the necessary SQL code, at least for functions and triggers.
-
-=== Parsing Check Constraints
-
-Sequel has support for parsing CHECK constraints on PostgreSQL using <tt>Sequel::Database#check_constraints</tt>:
-
-  DB.create_table(:foo) do
-    Integer :i
-    Integer :j
-    constraint(:ic, Sequel[:i] > 2)
-    constraint(:jc, Sequel[:j] > 2)
-    constraint(:ijc, Sequel[:i] - Sequel[:j] > 2)
-  end
-  DB.check_constraints(:foo)
-  # => {
-  #  :ic=>{:definition=>"CHECK ((i > 2))", :columns=>[:i]},
-  #  :jc=>{:definition=>"CHECK ((j > 2))", :columns=>[:j]},
-  #  :ijc=>{:definition=>"CHECK (((i - j) > 2))", :columns=>[:i, :j]}
-  # }
-
-=== Parsing Foreign Key Constraints Referencing A Given Table
-
-Sequel has support for parsing FOREIGN KEY constraints that reference a given table, using the +:reverse+
-option to +foreign_key_list+:
-
-  DB.create_table!(:a) do
-    primary_key :id
-    Integer :i
-    Integer :j
-    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
-    unique [:i, :j]
-  end
-  DB.create_table!(:b) do
-    foreign_key :a_id, :a, :foreign_key_constraint_name=>:a_a
-    Integer :c
-    Integer :d
-    foreign_key [:c, :d], :a, :key=>[:j, :i], :name=>:a_c_d
-  end
-  DB.foreign_key_list(:a, :reverse=>true)
-  # => [
-  #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:a, :schema=>:public},
-  #  {:name=>:a_a, :columns=>[:a_id], :key=>[:id], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public},
-  #  {:name=>:a_c_d, :columns=>[:c, :d], :key=>[:j, :i], :on_update=>:no_action, :on_delete=>:no_action, :deferrable=>false, :table=>:b, :schema=>:public}
-  # ]
-
-== PostgreSQL-specific DML Support
-
-=== Returning Rows From Insert, Update, and Delete Statements
-
-Sequel supports the ability to return rows from insert, update, and delete statements, via
-<tt>Dataset#returning</tt>:
-
-  DB[:table].returning.insert
-  # INSERT INTO "table" DEFAULT VALUES RETURNING *
-
-  DB[:table].returning(:id).delete
-  # DELETE FROM "table" RETURNING "id"
-
-  DB[:table].returning(:id, Sequel.*(:id, :id).as(:idsq)).update(id: 2)
-  # UPDATE "table" SET "id" = 2 RETURNING "id", ("id" * "id") AS "idsq"
-
-When returning is used, instead of returning the number of rows affected (for updated/delete)
-or the serial primary key value (for insert), it will return an array of hashes with the
-returning results.
-
-=== VALUES Support
-
-Sequel offers support for the +VALUES+ statement using <tt>Database#values</tt>:
-
-  DB.values([[1,2],[2,3],[3,4]])
-  # VALUES (1, 2), (2, 3), (3, 4)
-
-  DB.values([[1,2],[2,3],[3,4]]).order(2, 1)
-  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1
-
-  DB.values([[1,2],[2,3],[3,4]]).order(2, 1).limit(1,2)
-  # VALUES (1, 2), (2, 3), (3, 4) ORDER BY 2, 1 LIMIT 1 OFFSET 2
-
-=== INSERT ON CONFLICT Support
-
-Starting with PostgreSQL 9.5, you can do an upsert or ignore unique or exclusion constraint
-violations when inserting using <tt>Dataset#insert_conflict</tt>:
-
-  DB[:table].insert_conflict.insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT DO NOTHING
-
-For compatibility with Sequel's MySQL support, you can also use +insert_ignore+:
-
-  DB[:table].insert_ignore.insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT DO NOTHING
- 
-You can pass a specific constraint name using +:constraint+, to only ignore a specific
-constraint violation:
-
-  DB[:table].insert_conflict(constraint: :table_a_uidx).insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT ON CONSTRAINT table_a_uidx DO NOTHING
- 
-If the unique or exclusion constraint covers the whole table (e.g. it isn't a partial unique
-index), then you can just specify the column using the +:target+ option:
-
-  DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT (a) DO NOTHING
- 
-If you want to update the existing row instead of ignoring the constraint violation, you
-can pass an +:update+ option with a hash of values to update.  You must pass either the
-+:target+ or +:constraint+ options when passing the +:update+ option:
-
-  DB[:table].insert_conflict(target: :a, update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT (a) DO UPDATE SET b = excluded.b
-
-If you want to update existing rows but using the current value of the column, you can build
-the desired calculation using <tt>Sequel[]</tt>
-
-  DB[:table]
-    .insert_conflict(
-      target: :a,
-      update: {b: Sequel[:excluded][:b] + Sequel[:table][:a]}
-    )
-    .import([:a, :b], [ [1, 2] ])
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT (a) DO UPDATE SET b = (excluded.b + table.a)
- 
-Additionally, if you only want to do the update in certain cases, you can specify an
-+:update_where+ option, which will be used as a filter.  If the row doesn't match the
-conditions, the constraint violation will be ignored, but the row will not be updated:
-
-  DB[:table].insert_conflict(constraint::table_a_uidx,
-    update: {b: Sequel[:excluded][:b]},
-    update_where: {Sequel[:table][:status_id]=>1}).insert(a: 1, b: 2)
-  # INSERT INTO TABLE (a, b) VALUES (1, 2)
-  # ON CONFLICT ON CONSTRAINT table_a_uidx
-  # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
-
-=== INSERT OVERRIDING SYSTEM|USER VALUE Support
-
-PostgreSQL 10+ supports identity columns, which are designed to replace the serial
-columns previously used for autoincrementing primary keys.  You can use
-Dataset#overriding_system_value and Dataset#overriding_user_value to use this new
-syntax:
-
-  DB.create_table(:table){primary_key :id}
-  # Ignore the given value for id, using the identity's sequence value
-  DB[:table].overriding_user_value.insert(:id=>1)
-
-  DB.create_table(:table){primary_key :id, :identity=>:always}
-  # Force the use of the given value for id, because otherwise the insert will
-  # raise an error, since GENERATED ALWAYS was using when creating the column.
-  DB[:table].overriding_system_value.insert(:id=>1)
-
-=== Distinct On Specific Columns
-
-Sequel allows passing columns to <tt>Dataset#distinct</tt>, which will make the dataset return
-rows that are distinct on just those columns:
-
-  DB[:table].distinct(:id).all
-  # SELECT DISTINCT ON ("id") * FROM "table"
-
-=== Calling PostgreSQL 11+ Procedures <tt>postgres only</tt>
-
-PostgreSQL 11+ added support for procedures, which are different from the user defined
-functions that PostgreSQL has historically supported.  These procedures are
-called via a special +CALL+ syntax, and Sequel supports them via
-<tt>Database#call_procedure</tt>:
-
-  DB.call_procedure(:foo, 1, "bar")
-  # CALL foo(1, 'bar')
-
-<tt>Database#call_procedure</tt> will return a hash of return values if
-the procedure returns a result, or +nil+ if the procedure does not return
-a result.
-
-=== Using a Cursor to Process Large Datasets <tt>postgres only</tt>
-
-The postgres adapter offers a <tt>Dataset#use_cursor</tt> method to process large result sets
-without keeping all rows in memory:
-
-  DB[:table].use_cursor.each{|row| }
-  # BEGIN;
-  # DECLARE sequel_cursor NO SCROLL CURSOR WITHOUT HOLD FOR SELECT * FROM "table";
-  # FETCH FORWARD 1000 FROM sequel_cursor
-  # FETCH FORWARD 1000 FROM sequel_cursor
-  # ...
-  # FETCH FORWARD 1000 FROM sequel_cursor
-  # CLOSE sequel_cursor
-  # COMMIT
-
-This support is used by default when using <tt>Dataset#paged_each</tt>.
-
-Using cursors, it is possible to update individual rows of a large dataset
-easily using the <tt>rows_per_fetch: 1</tt> option in conjunction with
-<tt>Dataset#where_current_of</tt>.  This is useful if the logic needed to
-update the rows exists in the application and not in the database:
-
-  ds.use_cursor(rows_per_fetch: 1).each do |row|
-    ds.where_current_of.update(col: new_col_value(row))
-  end
-
-=== Truncate Modifiers
-
-Sequel supports PostgreSQL-specific truncate options:
-
-  DB[:table].truncate(cascade: true, only: true, restart: true)
-  # TRUNCATE TABLE ONLY "table" RESTART IDENTITY CASCADE
-
-=== COPY Support <tt>postgres/pg and jdbc/postgres only</tt> 
-
-PostgreSQL's COPY feature is pretty much the fastest way to get data in or out of the database.
-Sequel supports getting data out of the database via <tt>Database#copy_table</tt>, either for
-a specific table or for an arbitrary dataset:
-
-  DB.copy_table(:table, format: :csv)
-  # COPY "table" TO STDOUT (FORMAT csv)
-  DB.copy_table(DB[:table], format: :csv)
-  # COPY (SELECT * FROM "table") TO STDOUT (FORMAT csv)
-
-It supports putting data into the database via <tt>Database#copy_into</tt>:
-
-  DB.copy_into(:table, format: :csv, columns: [:column1, :column2], data: "1,2\n2,3\n")
-  # COPY "table"("column1", "column2") FROM STDIN (FORMAT csv)
-
-=== Anonymous Function Execution
-
-You can execute anonymous functions using a database procedural language via <tt>Database#do</tt> (the
-plpgsql language is the default):
-
-  DB.do <<-SQL
-    DECLARE r record;
-    BEGIN
-     FOR r IN SELECT table_schema, table_name FROM information_schema.tables
-       WHERE table_type = 'VIEW' AND table_schema = 'public'
-     LOOP
-       EXECUTE 'GRANT ALL ON ' || quote_ident(r.table_schema) || '.' || quote_ident(r.table_name) || ' TO webuser';
-     END LOOP;
-    END;
-  SQL
-
-=== Listening On and Notifying Channels
-
-You can use <tt>Database#notify</tt> to send notification to channels:
-
-  DB.notify(:channel)
-  # NOTIFY "channel"
-
-<tt>postgres/pg only</tt> You can listen on channels via <tt>Database#listen</tt>.  Note that
-this blocks until the listening thread is notified:
-
-  DB.listen(:channel)
-  # LISTEN "channel"
-  # after notification received:
-  # UNLISTEN *
-
-Note that +listen+ by default only listens for a single notification.  If you want to loop and process
-notifications:
-
-  DB.listen(:channel, loop: true){|channel| p channel}
-
-The +pg_static_cache_updater+ extension uses this support to automatically update
-the caches for models using the +static_cache+ plugin.  Look at the documentation of that
-plugin for details.
-
-=== Locking Tables
-
-Sequel makes it easy to lock tables, though it is generally better to let the database
-handle locking:
-
-  DB[:table].lock('EXCLUSIVE') do
-    DB[:table].insert(id: DB[:table].max(:id)+1)
-  end
-  # BEGIN;
-  # LOCK TABLE "table" IN EXCLUSIVE MODE;
-  # SELECT max("id") FROM "table" LIMIT 1;
-  # INSERT INTO "table" ("id") VALUES (2) RETURNING NULL;
-  # COMMIT;
-
-== Extended Error Info (<tt>postgres/pg only</tt>)
-
-If you run a query that raises a Sequel::DatabaseError, you can pass the exception object to
-<tt>Database#error_info</tt>, and that will return a hash with metadata regarding the error,
-such as the related table and column or constraint.
-
-  DB.create_table(:test1){primary_key :id}
-  DB.create_table(:test2){primary_key :id; foreign_key :test1_id, :test1}
-  DB[:test2].insert(:test1_id=>1) rescue DB.error_info($!)
-  # => {
-  #  :schema=>"public",
-  #  :table=>"test2",
-  #  :column=>nil,
-  #  :constraint=>"test2_test1_id_fkey",
-  #  :type=>nil,
-  #  :severity=>"ERROR",
-  #  :sql_state=>"23503",
-  #  :message_primary=>"insert or update on table \"test2\" violates foreign key constraint \"test2_test1_id_fkey\"",
-  #  :message_detail=>"Key (test1_id)=(1) is not present in table \"test1\"."
-  #  :message_hint=>nil,
-  #  :statement_position=>nil,
-  #  :internal_position=>nil,
-  #  :internal_query=>nil,
-  #  :source_file=>"ri_triggers.c",
-  #  :source_line=>"3321",
-  #  :source_function=>"ri_ReportViolation"
-  # }
-
-== sequel_pg (<tt>postgres/pg only</tt>)
-
-When the postgres adapter is used with the pg driver, Sequel automatically checks for sequel_pg, and
-loads it if it is available.  sequel_pg is a C extension that optimizes the fetching of rows, generally
-resulting in a ~2x speedup.  It is highly recommended to install sequel_pg if you are using the
-postgres adapter with pg.
-
-sequel_pg has additional optimizations when using the Dataset +map+, +as_hash+,
-+to_hash_groups+, +select_hash+, +select_hash_groups+, +select_map+, and +select_order_map+ methods,
-which avoids creating intermediate hashes and can add further speedups.
-
-In addition to optimization, sequel_pg also adds streaming support if used on PostgreSQL 9.2+. Streaming
-support is similar to using a cursor, but it is faster and more transparent.
-
-You can enable the streaming support:
-
-  DB.extension(:pg_streaming)
-
-Then you can stream individual datasets:
-
-  DB[:table].stream.each{|row| }
-
-Or stream all datasets by default:
-
-  DB.stream_all_queries = true
-
-When streaming is enabled, <tt>Dataset#paged_each</tt> will use streaming to implement
-paging.