tdiary 5.0.9 → 5.0.10

data/vendor/bundle/gems/sequel-5.9.0/doc/release_notes/5.6.0.txt

@@ -1,31 +0,0 @@
-= Improvements
-
-* Running migrations using one of the included migrators on separate
-  Database objects in separate threads simultaneously is now
-  supported.  Previously, the migrators were not thread-safe.
-
-* On Ruby 2.5+, :db_type entries in the schema hashes are now deduped
-  for a slight memory savings when using many columns with the same
-  database type.
-
-* The schema_caching extension now freezes string values in the
-  resulting hashes, just as the default schema parsing code started
-  doing in 5.5.0.
-
-* The schema_caching extension now supports the :callable_default
-  schema values used by the pg_json, pg_array, and pg_hstore
-  extensions, by removing the entry before caching and resetting it
-  after restoring the cache.
-
-* Identifier mangling rules are now respected when renaming columns on
-  Microsoft SQL Server.
-
-= Backwards Compatibility
-
-* The migrator internals were modified in order to support
-  thread-safety.  The private Migrator#remove_migration_classes
-  method has been removed, and #load_migration_file now returns the
-  migration object/class instead of populating Migration.descendants.
-  Migration.descendants is now only used for temporary storage, and
-  will no longer contain all migration objects/classes used by the
-  migrator.

data/vendor/bundle/gems/sequel-5.9.0/doc/release_notes/5.7.0.txt

@@ -1,108 +0,0 @@
-= New Features
-
-* An integer64 extension has been added, which treats the Integer
-  class as a generic 64-bit integer type.  Sequel's default behavior
-  for Integer is to use the integer type, which on most databases
-  is a 32-bit type.
-
-  This affects all internal use of the Integer class as a generic
-  database type, so that methods like primary_key and foreign_key
-  also default to using a 64-bit integer type when using this
-  extension.
-
-* When using PostgreSQL 10+, you can use the :identity option when
-  creating columns to create identity columns:
-
-    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,
-  or updating you can use a value of :always:
-
-    DB.create_table(:table){Integer :id, identity: :always}
-    # CREATE TABLE "table" ("id" integer GENERATED ALWAYS AS IDENTITY)
-
-* Database#convert_serial_to_identity has been added on PostgreSQL 10.2+.
-  This method can convert existing serial columns to identity columns
-  in most cases, but it currently requires superuser permissions as it
-  modifies the system tables directly.
-
-* Dataset#overriding_system_value and #overriding_user_value are
-  now supported on PostgreSQL to work with identity columns.  You can
-  use #overriding_system_value to force the use of a user provided
-  value for identity columns that are GENERATED ALWAYS, and you can
-  use #overriding_user_value to ignore any user value for identity
-  columns and always use the next entry in the sequence.
-
-= Other Improvements
-
-* On PostgreSQL 10.2+, identity columns are now used instead of serial
-  columns as the default for auto incrementing primary keys:
-
-    DB.create_table(:table){primary_key :id}
-
-    # Sequel 5.7.0+ and PostgreSQL 10.2+
-    # CREATE TABLE "table" ("id" integer
-    #   GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY)
-
-    # Older Sequel version or older PostgreSQL version
-    # CREATE TABLE "table" ("id" serial PRIMARY KEY)
-
-  Identity columns fix many issues that serial columns have, in
-  addition to being the SQL standard way to support auto incrementing
-  columns.
-
-* PostgreSQL identity columns are now correctly recognized and the
-  :auto_increment schema entry is now populated for them.
-
-* Dataset#with_sql_{all,each,first,single_value} now use a cached
-  dataset to avoid clobbering the current dataset's columns.
-  Previously, the clobbering of the current dataset's columns was
-  documented and the method warned against using SQL with
-  different columns.  These methods are now safe to use in such
-  cases, but will not have the same performance advantages if the
-  current dataset is not cached.
-
-* On ruby 2.1+, Sequel now uses Process::CLOCK_MONOTONIC when
-  performing elapsed time calculations so that it is not affected by
-  modifications to the system's time.
-
-* In the postgres adapter, prepared statement errors related to
-  changing types are now treated as disconnect errors. While they
-  are not technically disconnect errors, treating them as such
-  will in general reduce the total number of exceptions generated
-  from 1 per affected statement per connection to 1 per
-  connection.
-
-* In the pg_array_associations plugin, the array_type for
-  pg_array_to_many and many_to_pg_array association reflections is
-  now always the scalar type for the array (e.g. integer). Previously,
-  the array type (e.g. integer[]) was used in some cases.  This didn't
-  previously result in issues as PostgreSQL considers integer[][] the
-  same type as integer[].
-
-* In the pg_array_associations plugin, the many_to_pg_array
-  association remove_all_* method now uses the appropriate cast to
-  work for non-integer array types such as bigint[].
-
-* Database#server_version on PostgreSQL 10.1+ now works correctly
-  when the connection does not support the server_version method.
-  Now the server_version_num database setting is always used to
-  ensure consistent behavior across adapters.
-
-* In the jdbc/oracle adapter, temporary clobs are now manually
-  freed to prevent a memory leak, in line with the Oracle JDBC
-  driver recommendations.
-
-* The Sequel <4 release notes and changelog are no longer shipped
-  with the gem, decreasing the size of the gem by 20%.
-
-= Backwards Compatibility
-
-* The switch to using identity columns instead of serial columns
-  by default on PostgreSQL 10.2+ may break backwards compatibilty
-  in some situations, such as code that relies on what are generally
-  considered bugs in serial columns, such as CREATE TABLE LIKE
-  using the same sequence for the column in both the existing table
-  and the new table, or that dropping the default value for the
-  column does not drop the related sequence.

data/vendor/bundle/gems/sequel-5.9.0/doc/release_notes/5.8.0.txt

@@ -1,170 +0,0 @@
-= New Features
-
-* A pg_auto_constraint_validations plugin has been added, which
-  automatically converts many constraint violations raised as
-  exceptions to ValidationFailed exceptions when saving a model
-  instance.
-
-  The following constraint violation types are recognized and
-  supported:
-
-  * NOT NULL
-  * CHECK
-  * UNIQUE (except expression/functional indexes)
-  * FOREIGN KEY (both referencing and referenced by)
-
-  In the cases where the plugin cannot determine an appropriate
-  validation failure for the constraint violation, it just
-  reraises the original exception.
-
-  This plugin is not intended as a replacement for other validations,
-  it is intended as a last resort.  The purpose of validations is to
-  provide nice error messages for the user, and the error messages
-  generated by this plugin are fairly generic.  The error messages can
-  be customized using the :messages plugin option, but there is only a
-  single message used per constraint type.
-
-* Database#check_constraints has been added on PostgreSQL.  This
-  returns metadata related to each check constraint on a table:
-
-    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]}
-    # }
-
-* Database#foreign_key_list now supports a :reverse option on
-  PostgreSQL, which returns foreign keys referencing the given table,
-  instead of of foreign keys in the given table referencing other
-  tables:
-
-    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}
-    # ]
-
-* Dataset#nowait has been added, which will make the query fail
-  with a Sequel::DatabaseLockTimeout exception if it encounters
-  a locked row, overriding the default database behavior that
-  would wait until the lock was released. This method is supported
-  on PostgreSQL, Microsoft SQL Server, Oracle, and MySQL 8+.
-
-* Database#indexes now supports an :include_partial option on
-  PostgreSQL, which will include partial indexes in the output (Sequel
-  by default excludes partial indexes).
-
-* Common table expressions and window functions are now supported when
-  using MySQL 8+.
-
-* Dataset#skip_locked is now supported on MySQL 8+.
-
-* The connection_expiration extension now supports a
-  Database#connection_expiration_random_delay attribute, which is used
-  to randomize the expiration times, avoiding the thundering herd
-  problem.
-
-* The pg_enum extension now supports a rename_enum method for renaming
-  existing enum types.
-
-* Database#error_info on PostgreSQL now returns much more metadata
-  regarding the error.
-
-= Other Improvements
-
-* The dataset returned by the following dataset methods is cached,
-  which can improve performance significantly in certain cases:
-
-  * #distinct (without arguments or block)
-  * #from_self (without options)
-  * #lateral
-  * #qualify (without argument)
-  * #returning (without arguments)
-  * #select_all (without arguments)
-
-* If the primary_key serial: true, type: :serial, or type: :bigserial
-  options are given on PostgreSQL 10.2+, use a serial primary key
-  instead of an identity primary key.  This change was included in
-  Sequel 5.7.1.
-
-* The :search_path Database option is now supported as a shard
-  option on PostgreSQL, so different shards can use different
-  search paths.
-
-* The correct column order in Database#foreign_key_list on MySQL is
-  now forced, fixing issues on MySQL 8+.
-
-* When using case sensitive regexp matches on MySQL 8+, Sequel now
-  uses the REGEXP_LIKE function instead of the REGEXP BINARY
-  operator, to work around what appears to be a bug in MySQL 8+
-  related to the change in MySQL's regexp engine.
-
-* On MySQL 5.7+, the :extended option to Dataset#explain is now
-  ignored, since the :extended option's behavior in previous
-  MySQL versions is now the default behavior.
-
-* The MySQL HY000 generic SQL state error code is now ignored
-  in the mysql2 adapter, so it falls back to using the more
-  accurate backup error mapping in that case.
-
-* The pg_enum extension's schema modification methods now work
-  correctly if the Database instance is frozen.
-
-* The tactical_eager_loading plugin now respects the :allow_eager
-  association option, and will not attempt to eagerly load
-  associations when :allow_eager is false.
-
-* Using multiple add_constraint calls and a set_column_null call in
-  the same alter_table block on SQLite now works correctly.  Note
-  that if you are planning on ever modifying existing tables beyond
-  adding columns, you should probably choose a database that natively
-  supports such modification (SQLite does not).
-
-* Hashes returned by Database#foreign_key_list on PostgreSQL now
-  include a :schema entry, unless the support has been enabled
-  to make the :table entry be a qualified identifier.
-
-* Dataset#support_cte?(:insert) no longer returns true on
-  SQLAnywhere.  SQLAnywhere only supports common table
-  expressions for INSERT ... SELECT, not for all INSERT
-  statements. INSERT ... WITH ... SELECT is already
-  supported in Sequel using:
-
-    DB[:t1].insert(DB[:t2].with(DB[:t3]))
-
-* Model#_valid? is no longer made a public method in the
-  error_splitter plugin.
-
-= Backwards Compatibility
-
-* Calling the filter method on a proxy object returned by the
-  association_proxies plugin now warns on ruby <2.6.  This is
-  because starting in ruby 2.6, the behavior will change and the
-  method will be called on the array of associated objects
-  instead of on the dataset, as Enumerable#filter is being added
-  in ruby 2.6.

data/vendor/bundle/gems/sequel-5.9.0/doc/release_notes/5.9.0.txt

@@ -1,99 +0,0 @@
-= New Features
-
-* An escaped_like extension has been added, for the creation of
-  LIKE/ILIKE expressions with placeholders in patterns without
-  access to a dataset.  This adds escaped_like and escaped_ilike
-  methods to the same Sequel expression objects that support like
-  and ilike.  These methods take two arguments, the first being
-  the pattern, with ? placeholders, and the second being the
-  placeholder value (which can be an array for multiple
-  placeholders):
-
-    Sequel.extension :escaped_like
-    DB[:table].where{string_column.escaped_like('?%', user_input)}
-    # user_input is 'foo':
-    #  SELECT * FROM table WHERE string_column LIKE 'foo%'
-    # user_input is '%foo':
-    #  SELECT * FROM table WHERE string_column LIKE '\%foo%'
-
-* Generated columns on MySQL 5.7+ and MariaDB 5.2+ are now supported
-  using the :generated_always_as option when creating the column.
-  The :generated_type option can also be used to specify the type of
-  generated column (virtual or stored).  Examples:
-
-    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b'
-    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
-    # GENERATED ALWAYS AS (CONCAT(`a`, 'b'))
-
-    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
-      generated_type: :virtual
-    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
-    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) VIRTUAL
-
-    DB.add_column :t, :c, Integer, generated_always_as: Sequel[:a]+'b',
-      generated_type: :stored
-    # ALTER TABLE `t` ADD COLUMN `c` varchar(255)
-    # GENERATED ALWAYS AS (CONCAT(`a`, 'b')) STORED
-
-* Sequel::Model.has_dataset? has been added for checking whether the
-  model class has an associated dataset.  This will generally be true
-  for most model classes, but will be false for abstract model
-  classes (such as Sequel::Model itself).
-
-* Sequel::VERSION_NUMBER has been added for easier future version
-  comparisons.  The version number for 5.9.0 is 50090.
-
-= Other Improvements
-
-* When disconnecting connections in the threaded connection pools,
-  the disconnection is performed without holding the connection
-  pool mutex, since disconnection may block.
-
-* The sharded threaded connection pool no longer deadlocks when
-  disconnecting connections if the connection_validator or
-  connection_expiration extension is used.
-
-* If a thread dies and does not check a connection back into the
-  connection pool, Sequel now disconnects the connection when it
-  detects the dead thread, instead of assuming the connection is
-  safe to be reused.
-
-* When using eager_graph with cascaded associations, a unique
-  object is now used instead of a shared object in cases where
-  using a shared object may cause further cascaded associated
-  objects to be duplicated.
-
-* On PostgreSQL, the ESCAPE modifier to the LIKE/ILIKE operators is
-  no longer used, since the default ESCAPE value is the one Sequel
-  uses.  This change was made in order to allow the LIKE/ILIKE
-  operators to work with the ANY function, as PostgreSQL does not
-  support the use of the ESCAPE modifier in such cases.
-
-* A hash argument passed to Model.nested_attributes in the
-  nested_attributes plugin is now no longer modified.
-
-* Internal data structures for eager and eager_graph datasets are now
-  frozen to avoid unintentional modification.
-
-* Nondeterministic behavior in Database#foreign_key_list with the
-  :reverse option on PostgreSQL is now avoided by using an
-  unambiguous order.
-
-* Performance has been improved slightly by avoiding unnecessary
-  hash allocations.
-
-* Performance has been improved slightly by using while instead
-  of Kernel#loop.
-
-* BigDecimal() is now used instead of BigDecimal.new(), as the
-  latter has been deprecated.
-
-* The jdbc adapter now avoids referencing ::NativeException on JRuby
-  9.2+, since JRuby has deprecated it.  It is still used on older
-  versions of JRuby, since some JRuby 1.7 code may still require it.
-
-* Sequel now works around multiple Date/Time conversion bugs in
-  JRuby 9.2.0.0 for BC dates in the pg_extended_date_support
-  extension.  These bugs have already been fixed in JRuby, and
-  the workarounds will be removed after the release of JRuby
-  9.2.1.0.

data/vendor/bundle/gems/sequel-5.9.0/doc/schema_modification.rdoc

@@ -1,679 +0,0 @@
-= Schema modification methods
-
-Here's a brief description of the most common schema modification methods:
-
-== +create_table+
-
-+create_table+ is the most common schema modification method, and it's used for adding new tables
-to the database.  You provide it with the name of the table as a symbol, as well a block:
-
-  create_table(:artists) do
-    primary_key :id
-    String :name
-  end
-
-Note that if you want a primary key for the table, you need to specify it, Sequel does not create one
-by default.
-
-=== Column types
-
-Most method calls inside the create_table block will create columns, since +method_missing+ calls +column+.
-Columns are generally created by specifying the column type as the method
-name, followed by the column name symbol to use, and after that any options that should be used.
-If the method is a ruby class name that Sequel recognizes, Sequel will transform it into the appropriate
-type for the given database.  So while you specified +String+, Sequel will actually use +varchar+ or
-+text+ depending on the underlying database.  Here's a list of all ruby classes that Sequel will
-convert to database types:
-
-  create_table(:columns_types) do     # common database type used
-    Integer :a0                       # integer
-    String :a1                        # varchar(255)
-    String :a2, size: 50              # varchar(50)
-    String :a3, fixed: true           # char(255)
-    String :a4, fixed: true, size: 50 # char(50)
-    String :a5, text: true            # text
-    File :b                           # blob
-    Fixnum :c                         # integer
-    Bignum :d                         # bigint
-    Float :e                          # double precision
-    BigDecimal :f                     # numeric
-    BigDecimal :f2, size: 10          # numeric(10)
-    BigDecimal :f3, size: [10, 2]     # numeric(10, 2)
-    Date :g                           # date
-    DateTime :h                       # timestamp
-    Time :i                           # timestamp
-    Time :i2, only_time: true         # time
-    Numeric :j                        # numeric
-    TrueClass :k                      # boolean
-    FalseClass :l                     # boolean
-  end
-
-Note that in addition to the ruby class name, Sequel also pays attention to the column options when
-determining which database type to use.  Also note that for boolean columns, you can use either
-TrueClass or FalseClass, they are treated the same way (ruby doesn't have a Boolean class).
-
-Also note that this conversion is only done if you use a supported ruby class name.  In all other
-cases, Sequel uses the type specified verbatim:
-
-  create_table(:columns_types) do  # database type used
-    string :a1                     # string
-    datetime :a2                   # datetime
-    blob :a3                       # blob
-    inet :a4                       # inet
-  end
-
-In addition to specifying the types as methods, you can use the +column+ method and specify the types
-as the second argument, either as ruby classes, symbols, or strings:
-
-  create_table(:columns_types) do  # database type used
-    column :a1, :string            # string
-    column :a2, String             # varchar(255)
-    column :a3, 'string'           # string
-    column :a4, :datetime          # datetime
-    column :a5, DateTime           # timestamp
-    column :a6, 'timestamp(6)'     # timestamp(6)
-  end
-
-If you use a ruby class as the type, Sequel will try to guess the appropriate type name for the
-database you are using.  If a symbol or string is used as the type, it is used verbatim as the type
-name in SQL, with the exception of :Bignum.  Using the symbol :Bignum as a type will use the
-appropriate 64-bit integer type for the database you are using.
-
-=== Column options
-
-When using the type name as method, the third argument is an options hash, and when using the +column+
-method, the fourth argument is the options hash.  The following options are supported:
-
-:default :: The default value for the column.
-:index :: Create an index on this column. If given a hash, use the hash as the
-          options for the index.
-:null :: Mark the column as allowing NULL values (if true),
-         or not allowing NULL values (if false).  If unspecified, will default
-         to whatever the database default is (usually true).
-:primary_key :: Mark this column as the primary key.  This is used instead of the
-                primary key method if you want a non-autoincrementing primary key.
-:primary_key_constraint_name :: The name to give the primary key constraint.
-:type :: Overrides the type given as the method name or a separate argument.
-         Not usually used by +column+ itself, but often by other methods such
-         as +primary_key+ or +foreign_key+.
-:unique :: Mark the column as unique, generally has the same effect as
-           creating a unique index on the column.
-:unique_constraint_name :: The name to give the unique constraint.
-
-=== Other methods
-
-In addition to the +column+ method and other methods that create columns, there are other methods that can be used:
-
-==== +primary_key+
-
-You've seen this one used already.  It's used to create an autoincrementing integer primary key column.
-
-  create_table(:a0){primary_key :id}
-
-If you want an autoincrementing 64-bit integer:
-
-  create_table(:a0){primary_key :id, type: :Bignum}
-
-If you want to create a primary key column that doesn't use an autoincrementing integer, you should
-not use this method.  Instead, you should use the :primary_key option to the +column+ method or type
-method:
-
-  create_table(:a1){Integer :id, primary_key: true} # Non autoincrementing integer primary key
-  create_table(:a2){String :name, primary_key: true} # varchar(255) primary key
-
-If you want to create a composite primary key, you should call the +primary_key+ method with an
-array of column symbols.  You can provide a specific name to use for the primary key constraint
-via the :name option:
-
-  create_table(:items) do
-    Integer :group_id
-    Integer :position
-    primary_key [:group_id, :position], name: :items_pk
-  end
-
-If provided with an array, +primary_key+ does not create a column, it just sets up the primary key constraint.
-
-==== +foreign_key+
-
-+foreign_key+ is used to create a foreign key column that references a column in another table (or the same table).
-It takes the column name as the first argument, the table it references as the second argument, and an options hash
-as its third argument.  A simple example is:
-
-  create_table(:albums) do
-    primary_key :id
-    foreign_key :artist_id, :artists
-    String :name
-  end
-
-+foreign_key+ accepts the same options as +column+.  For example, to have a unique foreign key with varchar(16) type:
-
-  foreign_key :column_name, :table, unique: true, type: 'varchar(16)'
-
-+foreign_key+ also accepts some specific options:
-
-:deferrable :: Makes the foreign key constraint checks deferrable, so they aren't checked
-               until the end of the transaction.
-:foreign_key_constraint_name :: The name to give the foreign key constraint.
-:key :: The column in the associated table
-        that this column references.  Unnecessary if this column
-        references the primary key of the associated table, at least
-        on most databases.
-:on_delete :: Specify the behavior of this foreign key column when the row with the primary key
-              it references is deleted, can be :restrict, :cascade, :set_null, or :set_default.
-              You can also use a string, which is used literally.
-:on_update :: Specify the behavior of this foreign key column when the row with the primary key
-              it references modifies the value of the primary key.  Takes the same options as
-              :on_delete.
-
-Like +primary_key+, if you provide +foreign_key+ with an array of symbols, it will not create a
-column, but create a foreign key constraint:
-
-  create_table(:artists) do
-    String :name
-    String :location
-    primary_key [:name, :location]
-  end
-  create_table(:albums) do
-    String :artist_name
-    String :artist_location
-    String :name
-    foreign_key [:artist_name, :artist_location], :artists
-  end
-
-When using an array of symbols, you can also provide a :name option to name the constraint:
-
-  create_table(:albums) do
-    String :artist_name
-    String :artist_location
-    String :name
-    foreign_key [:artist_name, :artist_location], :artists, name: 'albums_artist_name_location_fkey'
-  end
-
-If you want to add a foreign key for a single column with a named constraint, you must use
-the array form with a single symbol:
-
-  create_table(:albums) do
-    primary_key :id
-    Integer :artist_id
-    String :name
-    foreign_key [:artist_id], :artists, name: 'albums_artist_id_fkey'
-  end
-
-==== +index+
-
-+index+ creates indexes on the table.  For single columns, calling index is the same as using the
-<tt>:index</tt> option when creating the column:
-
-  create_table(:a){Integer :id, index: true}
-  # Same as:
-  create_table(:a) do
-    Integer :id
-    index :id
-  end
-
-  create_table(:a){Integer :id, index: {unique: true}}
-  # Same as:
-  create_table(:a) do
-    Integer :id
-    index :id, unique: true
-  end
-
-Similar to the +primary_key+ and +foreign_key+ methods, calling +index+ with an array of symbols
-will create a multiple column index:
-
-  create_table(:albums) do
-    primary_key :id
-    foreign_key :artist_id, :artists
-    Integer :position
-    index [:artist_id, :position]
-  end
-
-The +index+ method also accepts some options:
-
-:name :: The name of the index (generated based on the table and column names if not provided).
-:type :: The type of index to use (only supported by some databases)
-:unique :: Make the index unique, so duplicate values are not allowed.
-:where :: Create a partial index (only supported by some databases)
-
-==== +unique+
-
-The +unique+ method creates a unique constraint on the table.  A unique constraint generally
-operates identically to a unique index, so the following three +create_table+ blocks are
-pretty much identical:
-
-  create_table(:a){Integer :a, unique: true}
-
-  create_table(:a) do
-    Integer :a
-    index :a, unique: true
-  end
-
-  create_table(:a) do
-    Integer :a
-    unique :a
-  end
-
-Just like +index+, +unique+ can set up a multiple column unique constraint, where the
-combination of the columns must be unique:
-
-  create_table(:a) do
-    Integer :a
-    Integer :b
-    unique [:a, :b]
-  end
-
-==== +full_text_index+ and +spatial_index+
-
-Both of these create specialized index types supported by some databases.  They
-both take the same options as +index+.
-
-==== +constraint+
-
-+constraint+ creates a named table constraint:
-
-  create_table(:artists) do
-    primary_key :id
-    String :name
-    constraint(:name_min_length){char_length(name) > 2}
-  end
-
-Instead of using a block, you can use arguments that will be handled similarly
-to <tt>Dataset#where</tt>:
-
-  create_table(:artists) do
-    primary_key :id
-    String :name
-    constraint(:name_length_range, Sequel.function(:char_length, :name)=>3..50)
-  end
-
-==== +check+
-
-+check+ operates just like +constraint+, except that it doesn't take a name
-and it creates an unnamed constraint:
-
-  create_table(:artists) do
-    primary_key :id
-    String :name
-    check{char_length(name) > 2}
-  end
-
-It's recommended that you use the +constraint+ method and provide a name for the
-constraint, as that makes it easier to drop the constraint later if necessary.
-
-== +create_join_table+
-
-+create_join_table+ is a shortcut that you can use to create simple many-to-many join tables:
-
-  create_join_table(artist_id: :artists, album_id: :albums)
-
-which expands to:
-
-  create_table(:albums_artists) do
-    foreign_key :album_id, :albums
-    foreign_key :artist_id, :artists
-    primary_key [:album_id, :artist_id]
-    index [:artist_id, :album_id]
-  end
-
-== <tt>create_table :as</tt>
-
-To create a table from the result of a SELECT query, instead of passing a block
-to +create_table+, provide a dataset to the :as option:
-
-  create_table(:older_items, as: DB[:items].where{updated_at < Date.today << 6})
-
-== +alter_table+
-
-+alter_table+ is used to alter existing tables, changing their columns, indexes,
-or constraints.  It it used just like +create_table+, accepting a block which
-is instance_evaled, and providing its own methods:
-
-=== +add_column+
-
-One of the most common methods, +add_column+ is used to add a column to the table.
-Its API is similar to that of +create_table+'s +column+ method, where the first
-argument is the column name, the second is the type, and the third is an options
-hash:
-
-  alter_table(:albums) do
-    add_column :copies_sold, Integer, default: 0
-  end
-
-=== +drop_column+
-
-As you may expect, +drop_column+ takes a column name and drops the column.  It's
-often used in the +down+ block of a migration to drop a column added in an +up+ block:
-
-  alter_table(:albums) do
-    drop_column :copies_sold
-  end
-
-=== +rename_column+
-
-+rename_column+ is used to rename a column.  It takes the old column name as the first
-argument, and the new column name as the second argument:
-
-  alter_table(:albums) do
-    rename_column :copies_sold, :total_sales
-  end
-
-=== +add_primary_key+
-
-If you forgot to include a primary key on the table, and want to add one later, you
-can use +add_primary_key+.  A common use of this is to make many_to_many association
-join tables into real models:
-
-  alter_table(:albums_artists) do
-    add_primary_key :id
-  end
-
-Just like +create_table+'s +primary_key+ method, if you provide an array of symbols,
-Sequel will not add a column, but will add a composite primary key constraint:
-
-  alter_table(:albums_artists) do
-    add_primary_key [:album_id, :artist_id]
-  end
-
-It is possible to specify a name for the primary key constraint: via the :name option:
-
-  alter_table(:albums_artists) do
-    add_primary_key [:album_id, :artist_id], :name=>:albums_artists_pkey
-  end
-
-If you just want to take an existing single column and make it a primary key, call
-+add_primary_key+ with an array with a single symbol:
-
-  alter_table(:artists) do
-    add_primary_key [:id]
-  end
-
-=== +add_foreign_key+
-
-+add_foreign_key+ can be used to add a new foreign key column or constraint to a table.
-Like +add_primary_key+, if you provide it with a symbol as the first argument, it
-creates a new column:
-
-  alter_table(:albums) do
-    add_foreign_key :artist_id, :artists
-  end
-
-If you want to add a new foreign key constraint to an existing column, you provide an
-array with a single element:
-
-  alter_table(:albums) do
-    add_foreign_key [:artist_id], :artists
-  end
-
-It's encouraged to provide a name when adding the constraint, via the :foreign_key_constraint_name
-option if adding the column and the constraint:
-
-  alter_table(:albums) do
-    add_foreign_key :artist_id, :artists, foreign_key_constraint_name: :albums_artist_id_fkey
-  end
-
-or via the :name option if just adding the constraint:
-
-  alter_table(:albums) do
-    add_foreign_key [:artist_id], :artists, name: :albums_artist_id_fkey
-  end
-
-To set up a multiple column foreign key constraint, use an array with multiple column symbols:
-
-  alter_table(:albums) do
-    add_foreign_key [:artist_name, :artist_location], :artists, name: :albums_artist_name_location_fkey
-  end
-
-=== +drop_foreign_key+
-
-+drop_foreign_key+ is used to drop foreign keys from tables.  If you provide a symbol as
-the first argument, it drops both the foreign key constraint and the column:
-
-  alter_table(:albums) do
-    drop_foreign_key :artist_id
-  end
-
-If you want to just drop the foreign key constraint without dropping the column, use
-an array.  It's encouraged to use the :name option to provide the constraint name to
-drop, though on some databases Sequel may be able to find the name through introspection:
-
-  alter_table(:albums) do
-    drop_foreign_key [:artist_id], name: :albums_artist_id_fkey
-  end
-
-An array is also used to drop a composite foreign key constraint:
-
-  alter_table(:albums) do
-    drop_foreign_key [:artist_name, :artist_location], name: :albums_artist_name_location_fkey
-  end
-
-If you do not provide a :name option and Sequel is not able to determine the name
-to use, it will probably raise a Sequel::Error exception.
-
-=== +add_index+
-
-+add_index+ works just like +create_table+'s +index+ method, creating a new index on
-the table:
-
-  alter_table(:albums) do
-    add_index :artist_id
-  end
-
-It accepts the same options as +create_table+'s +index+ method, and you can set up
-a multiple column index using an array:
-
-  alter_table(:albums_artists) do
-    add_index [:album_id, :artist_id], unique: true
-  end
-
-=== +drop_index+
-
-As you may expect, +drop_index+ drops an existing index:
-
-  alter_table(:albums) do
-    drop_index :artist_id
-  end
-
-Just like +drop_column+, it is often used in the +down+ block of a migration.
-
-To drop an index with a specific name, use the <tt>:name</tt> option:
-
-  alter_table(:albums) do
-    drop_index :artist_id, name: :artists_id_index
-  end
-
-=== +add_full_text_index+, +add_spatial_index+
-
-Corresponding to +create_table+'s +full_text_index+ and +spatial_index+ methods,
-these two methods create new indexes on the table.
-
-=== +add_constraint+
-
-This adds a named constraint to the table, similar to +create_table+'s +constraint+
-method:
-
-  alter_table(:albums) do
-    add_constraint(:name_min_length){char_length(name) > 2}
-  end
-
-There is no method to add an unnamed constraint, but you can pass +nil+ as the first
-argument of +add_constraint+ to do so.  However, it's not recommended to do that
-as it is more difficult to drop such a constraint.
-
-=== +add_unique_constraint+
-
-This adds a unique constraint to the table, similar to +create_table+'s +unique+
-method.  This usually has the same effect as adding a unique index.
-
-  alter_table(:albums) do
-    add_unique_constraint [:artist_id, :name]
-  end
-
-You can also specify a name via the :name option when adding the constraint:
-
-  alter_table(:albums) do
-    add_unique_constraint [:artist_id, :name], name: :albums_artist_id_name_ukey
-  end
-
-=== +drop_constraint+
-
-This method drops an existing named constraint:
-
-  alter_table(:albums) do
-    drop_constraint(:name_min_length)
-  end
-
-There is no database independent method to drop an unnamed constraint.  Generally, the
-database will give it a name automatically, and you will have to figure out what it is.
-For that reason, you should not add unnamed constraints that you ever might need to remove.
-
-On some databases, you must specify the type of constraint via a <tt>:type</tt> option:
-
-  alter_table(:albums) do
-    drop_constraint(:albums_pk, type: :primary_key)
-    drop_constraint(:albums_fk, type: :foreign_key)
-    drop_constraint(:albums_uk, type: :unique)
-  end
-
-=== +set_column_default+
-
-This modifies the default value of a column:
-
-  alter_table(:albums) do
-    set_column_default :copies_sold, 0
-  end
-
-To remove a default value for a column, use +nil+ as the value:
-
-  alter_table(:albums) do
-    set_column_default :copies_sold, nil
-  end
-
-=== +set_column_type+
-
-This modifies a column's type.  Most databases will attempt to convert existing values in
-the columns to the new type:
-
-  alter_table(:albums) do
-    set_column_type :copies_sold, :Bignum
-  end
-
-You can specify the type as a string or symbol, in which case it is used verbatim, or as a supported
-ruby class or the :Bignum symbol, in which case it gets converted to an appropriate database type.
-
-=== +set_column_allow_null+
-
-This allows you to set the column as allowing NULL values:
-
-  alter_table(:albums) do
-    set_column_allow_null :artist_id
-  end
-
-=== +set_column_not_null+
-
-This allows you to set the column as not allowing NULL values:
-
-  alter_table(:albums) do
-    set_column_not_null :artist_id
-  end
-
-== Other +Database+ schema modification methods
-
-<tt>Sequel::Database</tt> has many schema modification instance methods,
-most of which are shortcuts to the same methods in +alter_table+.  The
-following +Database+ instance methods just call +alter_table+ with a
-block that calls the method with the same name inside the +alter_table+
-block with all arguments after the first argument (which is used as
-the table name):
-
-* +add_column+
-* +drop_column+
-* +rename_column+
-* +add_index+
-* +drop_index+
-* +set_column_default+
-* +set_column_type+
-
-For example, the following two method calls do the same thing:
-
-  alter_table(:artists){add_column :copies_sold, Integer}
-  add_column :artists, :copies_sold, Integer
-
-There are some other schema modification methods that have no +alter_table+
-counterpart:
-
-=== +drop_table+
-
-+drop_table+ takes multiple arguments and treats all arguments as a
-table name to drop:
-
-  drop_table(:albums_artists, :albums, :artists)
-
-Note that when dropping tables, you may need to drop them in a specific order
-if you are using foreign keys and the database is enforcing referential
-integrity.  In general, you need to drop the tables containing the foreign
-keys before the tables containing the primary keys they reference.
-
-=== <tt>drop_table?</tt>
-
-<tt>drop_table?</tt> is similar to drop_table, except that it only drops
-the table if the table already exists.  On some databases, it uses
-<tt>IF NOT EXISTS</tt>, on others it does a separate query to check for
-existence.
-
-=== +rename_table+
-
-You can rename an existing table using +rename_table+.  Like +rename_column+,
-the first argument is the current name, and the second is the new name:
-
-  rename_table(:artist, :artists)
-
-=== <tt>create_table!</tt>
-
-<tt>create_table!</tt> drops the table if it exists
-before attempting to create it, so:
-
-  create_table!(:artists) do
-    primary_key :id
-  end
-
-is the same as:
-
-  drop_table?(:artists)
-  create_table(:artists) do
-    primary_key :id
-  end
-
-=== <tt>create_table?</tt>
-
-<tt>create_table?</tt> only creates the table if it does
-not already exist, so:
-
-  create_table?(:artists) do
-    primary_key :id
-  end
-
-is the same as:
-
-  unless table_exists?(:artists)
-    create_table(:artists) do
-      primary_key :id
-    end
-  end
-
-=== +create_view+ and +create_or_replace_view+
-
-These can be used to create views.  The difference between them is that
-+create_or_replace_view+ will unconditionally replace an existing view of
-the same name, while +create_view+ will probably raise an error.  Both methods
-take the name as the first argument, and either an string or a dataset as the
-second argument:
-
-  create_view(:gold_albums, DB[:albums].where{copies_sold > 500000})
-  create_or_replace_view(:gold_albums, "SELECT * FROM albums WHERE copies_sold > 500000")
-
-=== +drop_view+
-
-+drop_view+ drops existing views.  Just like +drop_table+, it can accept multiple
-arguments:
-
-  drop_view(:gold_albums, :platinum_albums)