sequel 4.36.0 → 5.61.0

data/doc/release_notes/3.0.0.txt

@@ -1,221 +0,0 @@
-Deprecated Methods/Features Removed
------------------------------------
-
-Methods and features that were deprecated in 2.12.0 have been removed
-in 3.0.0.  Many features were moved into plugins or extensions, so in
-many cases you just need to require an extension or use Model.plugin
-and not make any changes to your code.  See the 2.12.0 release notes
-for the list of methods/features deprecated in 2.12.0.
-
-If you are upgrading from a previous 2.x release, please upgrade to
-2.12.0 first, fix your code to remove all deprecation warnings, and
-then upgrade to 3.0.0.
-
-New Adapter
------------
-
-* Sequel now has an Amalgalite adapter.  Amalgalite is a ruby
-  extension that embeds SQLite without requiring a separate SQLite
-  installation.  The adapter is functionality complete but
-  significantly slower than the native SQLite adapter.
-
-New Features
-------------
-
-* The JDBC, PostgreSQL, MySQL, and SQLite adapters all now have a
-  Database#indexes method that returns indexes for a given table:
-
-    DB.indexes(:songs)
-    => {:songs_name_index=>{:unique=>true, :columns=>[:name]},
-        :songs_lyricid_index=>{:unique=>false, :columns=>[:lyricid]}}
-
-* A schema_dumper extension was added to Sequel.  It supports dumping
-  the schema of a table (including indexes) as a string that can be
-  evaluated in the context of a Database object to create the table.
-  It also supports dumping all tables in the database as a string
-  containing a Migration subclass that will rebuild the database.
-
-    require 'sequel/extensions/schema_dumper'
-    DB.dump_table_schema(:table)
-    DB.dump_schema_migration
-    DB.dump_schema_migration(:same_db=>true)
-    DB.dump_schema_migration(:indexes=>false)
-    DB.dump_indexes_migration
-
-  The :same_db option causes Sequel to not translate column types
-  to generic column types.  By default, the migration created will
-  use generic types so it will run on other databases.  However, if
-  you only want to support a single database, using the :same_db
-  option will make the migration use the exact database type parsed
-  from the database.
-
-  The :indexes=>false option causes indexes not be included in the
-  migration.  The dump_indexes_migration can be used to create a
-  separate migration with the indexes.  This can be useful if you 
-  plan on loading a lot of data right after creating the tables,
-  since it is faster to add indexes after the data has been added.
-
-* Using options with the generic database types is now supported to
-  a limited extent.  For example, the following code now works:
-
-    DB.create_table(:table) do
-      String :a, :size=>50               # varchar(50)
-      String :b, :text=>true             # text
-      String :c, :fixed=>true, :size=>30 # char(30)
-      Time :ts                           # timestamp
-      Time :t, :only_time=>true          # time
-    end
-
-* Using Dataset#filter and related methods with multiple arguments
-  now works much more intuitively:
-
-    # 2.12.0
-    dataset.filter(:a, :b=>1) # a IS NULL AND (b = 1) IS NULL
-    # 3.0.0
-    dataset.filter(:a, :b=>1) # a AND b = 1
-
-* You can now create temporary tables by passing the :temp=>true
-  option to Database#create_table.
-
-* The Oracle shared adapter now supports emulation of
-  autoincrementing primary keys by creating a sequence and a trigger,
-  similar to how the Firebird adapter works.
-
-* The Database#database_type method was added that returns a symbol
-  specifying the database type being used.  This can be different
-  than Database.adapter_scheme if you are using an adapter like
-  JDBC that allows connecting to multiple different types of
-  databases.
-
-* Database#drop_index and related methods now support an options
-  hash that respects the :name option, so they can now be used to
-  drop an index that doesn't use the default index name.
-
-* The PostgreSQL shared adapter now supports a
-  Database#reset_primary_key_sequence method to reset the
-  primary key sequence for a given table, based on code from
-  ActiveRecord.
-
-* SQL::QualifiedIdentifiers can now be qualified, allowing you to do:
-
-   :column.qualify(:table).qualify(:schema)
- 
-* Using the :db_type=>'mssql' option with the DBI adapter will now
-  load the MSSQL support.
-
-* The MySQL shared adapter now supports Dataset#full_text_sql, which
-  you can use in queries like the following:
-
-    ds.select(:table.*, ds.full_text_sql(:column, 'value').as(:ft))
-
-Other Improvements
-------------------
-
-* Sequel will now release connections from the connection pool
-  automatically if they are held by a dead thread.  This can happen
-  if you are using MRI 1.8 and you are heavily multithreaded or
-  you call Thread#exit! or similar method explicitly.  Those methods
-  skip the execution of ensure blocks which normally release the
-  connections when the threads exit.
-
-* Model#save will now always use the same server when refreshing data
-  after an insert.  This fixes an issue when Sequel's master/slave
-  database support is used with models.
-
-* SQL Array references are now quoted correctly, so code like this
-  now works:
-
-    :table__column.sql_subscript(1)
-
-* The PostgreSQL shared adapter now handles sequences that need to be
-  quoted correctly (previously these were quoted twice).
-
-* String quoting on Oracle no longer doubles backslashes. 
-
-* Database#count now works correctly when used on MSSQL when using
-  an adapter that doesn't handle unnamed columns.
-
-* Full text searching in the MySQL adapter now works correctly when
-  multiple search terms are used.
-
-* Altering a column's name, type, default, or NULL/NOT NULL status
-  on MySQL now keeps other relevent column information.  For example,
-  if you alter a column's type, it'll keep an existing default. This
-  functionality isn't complete, there may be other column information
-  that is lost.
-
-* Fix creation of an index with a given type on MySQL, since MySQL's
-  documentation lies.
-
-* The schema parser now handles decimal types with size specifiers,
-  fixing use on MySQL.
-
-* Dataset#quote_identifier now works correctly when given an
-  SQL::Identifier.  This allows you to do:
-
-    dataset.select{sum(hours).as(hours)}
-
-Backwards Compatibility
------------------------
-
-* Sequel will now use instance_eval on all virtual row blocks without
-  an argument.  This can lead to much nicer code:
-
-    dataset.filter{(number > 10) & (name > 'M')}
-    # WHERE number > 10 AND name > 'M'
-
-  2.12.0 raised a deprecation warning if you used a virtual row block
-  without an argument and you hadn't set
-  Sequel.virtual_row_instance_eval = true.
-
-* Dataset#exclude now inverts the given argument, instead of negating
-  it. This only changes its behavior if it is called with a hash or
-  array of all two pairs that have more than one element.
-
-    # 2.12.0
-    dataset.exclude(:a=>1, :b=>1) # a != 1 AND b != 1
-    # 3.0.0
-    dataset.exclude(:a=>1, :b=>1) # a != 1 OR b != 1
-
-  This was done for consistency, since exclude would only negate a
-  hash if it was given an argument, it would invert the same hash
-  if you used a block:
-
-    # 2.12.0
-    dataset.exclude{{:a=>1, :b=>1}} # a != 1 OR b != 1
-  
-  If you want the previous behavior,
-  change the code to the following:
-
-    dataset.filter({:a=>1, :b=>1}.sql_negate)
-
-* As noted above, the methods/features deprecated in 2.12.0 were
-  removed.
-
-* The private Dataset#select_*_sql methods now only take a single
-  argument, the SQL string being built.
-
-* Dataset#from when called without arguments would previously cause an
-  error to be raised when the SQL string is generated.  Now it causes
-  no FROM clause to be used, similar to how Dataset#select with no
-  arguments causes SELECT * to be used.
-
-* The internals of the generic type support and the schema generators
-  were changed significantly, which could have some fallout in terms
-  of old migrations breaking if they used the generic types and were
-  relying on some undocumented behavior (such as using Integer as a
-  type with the :unsigned option).
-
-* The Firebird adapter no longer translates the text database
-  specific type.  Use the following instead:
-    
-    String :column, :text=>true 
-
-* The MySQL shared adapter used to use the timestamp type for Time,
-  now it uses datetime.  This is because the timestamp type cannot
-  represent everything that the ruby Time class can represent.
-
-* Metaprogramming#metaattr_accessor and #metaattr_reader methods were
-  removed.
-
-* Dataset#irregular_function_sql was removed.

data/doc/release_notes/3.1.0.txt

@@ -1,406 +0,0 @@
-New Plugins
------------
-
-3 new plugins were added that implement features supported by
-DataMapper: identity_map, tactical_eager_loading, and
-lazy_attributes.  These plugins don't add any real new features, 
-since you can do most of what they allow before simply by being
-a little more explicit in your Sequel code. However, some people
-prefer a less explicit approach that uses a bit more magic, and
-now Sequel can accomodate them.
-
-* The identity_map plugin allows you to create a 1-1
-  correspondence of model objects to database rows via a temporary
-  thread-local identity map.  It makes the following statment true:
-
-    Sequel::Model.with_identity_map do
-      Album.filter{(id > 0) & (id < 2)}.first.object_id == \
-        Album.first(:id=>1).object_id
-    end
-
-  As the code above implies, you need to use the with_identity_map
-  method with a block to use the identity mapping feature.
-
-  By itself, identity maps don't offer much, but Sequel uses them
-  as a cache when looking up objects by primary key or looking up
-  many_to_one associated objects.  Basically, it can be used as a
-  performance enhancer, and it also allows the support of the
-  lazy_attributes plugin.
-
-  The identity_map plugin is expected to be most useful in web
-  applications.  With that in mind, here's a Rack middleware that
-  wraps each request in a with_identity_map call, so the
-  identity_map features are available inside the web app:
-
-    Sequel::Model.plugin :identity_map
-    class SequelIdentityMap
-      def initialize(app)
-        @app = app
-      end
-      def call(env)
-        Sequel::Model.with_identity_map{@app.call(env)}
-      end
-    end
-
-* The tactical_eager_loading plugin allows you to eagerly load an
-  association for all models retrieved in the same group whenever
-  one of the models accesses the association:
-
-    # 2 queries total
-    Album.filter{id<100}.all do |a|
-      a.artists
-    end
-
-  In order for this correctly, you must use Dataset#all to load the
-  records, you cannot iterate over them via Dataset#each.  This is
-  because eager loading requires that you have all records in
-  advance, and when using Dataset#each you cannot know about later
-  records in the dataset.
-
-  Before, you could just be explicit about the associations you
-  needed and make sure to eagerly load them using eager before
-  calling Dataset#all.
-
-* The lazy_attributes plugin builds on the identity_map and
-  tactical_eager_loading plugins and allows you to create
-  attributes that are lazily loaded from the database:
-
-    Album.plugin :lazy_attributes, :review
-
-  This will remove the :review attribute from being selected by
-  default.  If you try to access the attribute after it is selected,
-  it'll retrieve the value from the database.  If the object was
-  retrieved with a group of other objects and an identity map is in
-  use, it'll retrieve the lazy attribute for the entire group of
-  objects at once, similar to the tatical_eager_loading plugin:
-
-    # 2 queries total
-    Sequel::Model.with_identity_map do
-      Album.filter{id<100}.all do |a|
-        a.review
-      end
-    end
-
-  Before, you could just set the default selected columns for a model
-  to not include the lazy attributes, and just use select_more to
-  add them to any query where the resulting model objects will
-  need the attributes.
-
-* A many_through_many plugin was also added.  This very powerful
-  plugin allows you to create associations to multiple objects through
-  multiple join tables.  Here are some examples:
-
-    # Assume the following many to many associations:
-    Artist.many_to_many :albums
-    Album.many_to_many :tags
-
-    # Same as Artist.many_to_many :albums
-    Artist.many_through_many :albums,
-      [[:albums_artists, :artist_id, :album_id]]
-
-    # All tags associated to any album this artist is associated to
-    Artist.many_through_many :tags,
-      [[:albums_artists, :artist_id, :album_id],
-       [:albums, :id, :id],
-       [:albums_tags, :album_id, :tag_id]]
-
-    # All artists associated to any album this artist is associated to
-    Artist.many_through_many :artists,
-      [[:albums_artists, :artist_id, :album_id],
-       [:albums, :id, :id],
-       [:albums_artists, :album_id, :artist_id]]
-
-    # All albums by artists that are associated to any album this
-    # artist is associated to
-    Artist.many_through_many :artist_albums,
-      [[:albums_artists, :artist_id, :album_id],
-       [:albums, :id, :id],
-       [:albums_artists, :album_id, :artist_id],
-       [:artists, :id, :id],
-       [:albums_artists, :artist_id, :album_id]]
-
-  Basically, for each join table between this model and the
-  associated model, you use an array with a join table name, left key
-  name (key closer to this model), and right key name (key closer to
-  the associated model).
-
-  In usual Sequel fashion, this association type works not just
-  for single objects, but it can also be eagerly loaded via eager or
-  eager_graph.  There are numerous additional configuration options,
-  please see the RDoc for details.
-
-New bin/sequel Features
------------------------
-
-The bin/sequel command line tool now supports the following options:
-
-* -C: Copies one database to another.  You must specify two database
-  arguments.  Works similar to Taps, copying the table schema, then
-  the table data, then creating the indexes.
-
-* -d: Dump the schema of the database in the database-independent
-  migration format.
-
-* -D: Dump the schema of the database in the database-specific
-  migration format.
-
-* -h: Display the help
-
-* -t: Output the full backtrace if an exception is raised
-
-The bin/sequel tool is now better about checking which options can
-be used together.  It also now supports using the -L option multiple
-times and having it load model files from multiple directory trees.
-
-New Features
-------------
-
-* Dataset#qualify_to and #qualify_to_first_source were added.  They
-  allow you to qualify unqualified columns in the current dataset
-  to the given table or the first source. This can be used to join
-  a dataset that has unqualified columns to a new table which has
-  columns with the same name.
-  
-  For example, take this dataset:
-  
-    ds = DB[:albums].select(:name).order(:name).filter(:id=>1)
-    # SELECT name FROM albums WHERE (id = 1) ORDER BY name
-
-  Let's say you want to join it to the artists table:
-  
-    ds2 = ds.join(:artists, :id=>:artist_id)
-    # SELECT name FROM albums 
-    #  INNER JOIN artists ON (artists.id = albums.artist_id)
-    #  WHERE (id = 1) ORDER BY name
-    
-  That's going to give you an error, as the artists table already has
-  columns named id and name.  This new feature allows you to do the
-  following:
-  
-    ds2 = ds.qualify_to_first_source.join(:artists, :id=>:artist_id)
-    # SELECT albums.name FROM albums
-    #  INNER JOIN artists ON (artists.id = albums.artist_id)
-    #  WHERE (albums.id = 1) ORDER BY albums.name
-    
-  By doing this, all unqualified columns are qualified, so you get
-  a usable query.  This is expected to be most useful for users that
-  have a default order or filter on their models and want to join
-  the model to another table.  Before you had to replace the filters,
-  selection, etc. manually, or use qualified columns by default even
-  though the weren't needed in most cases.
-
-* Savepoints are now supported using SQLite and MySQL, assuming you
-  are using a database version that supports them.  You need to
-  pass the :savepoint option to Database#transaction to use a
-  savepoint.
-
-* Model plugins can now depend on other plugins, simply by calling
-  the Model.plugin method inside the plugin's apply method:
-
-    module LazyAttributes
-      def self.apply(model)
-        model.plugin :tactical_eager_loading
-      end
-
-* Model.plugin now takes a block with is passed to the plugin's
-  apply and configure method (see Backwards Compatibility section for
-  more information on the configure method).
-
-* You can see which plugins are loaded for a model by using
-  Model.plugins.
-
-* You can use Sequel.extension method to load extensions:
-
-    Sequel.extension :pagination, :query
-
-  This will only load extensions that ship with Sequel, unlike the
-  Model.plugin method which will also load external plugins.
-
-* You can now use Database#create_table? to create the table if it
-  doesn't already exist (a very common need, it seems).  The schema
-  plugin now supports Model.create_table? as well.
-
-* #sql_subscript is now an allowed method on most SQL expression
-  objects that Sequel generates.  Also, arguments to #sql_subscript
-  can now be other expressions instead of just integers.
-
-* Associations can now take a :cartesian_product_number option, which
-  can be used to tell Sequel whether to turn on duplicate object
-  detection when eagerly loading objects through eager_graph.  This
-  number should be 0 if the association can never create multiple
-  rows for each row in the current table, 1 if it can create multiple
-  rows in the each row in the current table, and 2 if the association
-  itself causes a cartesian product.
-
-* On MySQL, Dataset#insert_ignore now affects #insert as well as
-  multi_insert and import.
-
-* Database#create_table now supports an :ignore_index_errors option,
-  and Database#add_index now supports an :ignore_errors option.
-  These are used by the schema_dumper when dumping an database
-  schema to be restored on another database type, since indexes
-  aren't usually required for proper operation and some indexes
-  can't be transferred.
-
-* The ADO adapter now takes a :provider option, which can be used
-  to set the provider.
-
-* The ADO adapter now takes a :command_timeout option, which tells
-  the connection how long to wait before giving up and raising an
-  exception.
-
-* The Sequel.amalgalite adapter method was added.  Like the
-  Sequel.sqlite method, you can call it with no arguments to get
-  an in memory database.
-
-Other Improvements
-------------------
-
-* MySQL "commands out of sync" errors should no longer occur unless
-  you are nesting queries (calling Dataset#each inside Dataset#each).
-  A bug dating at least to 2007 and possibly since the initial
-  creation of the Sequel MySQL adapter was the cause.  Before, SQL
-  that caused a result set that was sent using a method where Sequel
-  doesn't yield a result set would cause the "commands out of sync"
-  error on the following query.  For example, the following code
-  would cause the error:
-
-    DB << "SHOW DATABASES"
-
-  If for some reason a "commands out of sync" error does occur,
-  Sequel will disconnect the connection from the connection pool,
-  so it won't continually stay in the pool and raise errors every
-  time it is used.
-
-* The schema_dumper extension is much better about parsing defaults
-  from the database.  It can now correctly parse most defaults on
-  MySQL, SQLite, and PostgreSQL databases.  It no longer includes
-  defaults that it can't parse to a ruby object unless a database-
-  specific dump is requested.
-
-* The schema_dumper extension now dumps tables in alphabetical order.
-
-* Ordered and limited datasets are now handled correctly when using
-  union, intersect, and except.  Also, union, intersect, and except
-  now always return a from_self dataset, so further limiting,
-  filtering, and ordering of them now works as expected.
-
-* Dataset#graph now works correctly with a complex dataset without
-  having to use from_self.  Before, code like the following didn't
-  do what was expected:
-
-    DB[:albums].
-      graph(DB[:artists].filter{name > 'M'}, :id=>:artist_id)
-
-  Before, the filter on DB[:artists] would be dropped.  Now, Sequel
-  correctly uses a subselect.
-
-* You can now specify serialization formats per column in the
-  serialization plugin, either by calling the plugin multiple
-  times or by using the new serialize_attributes method:
-
-    Album.plugin :serialization
-    Album.serialize_attributes :marshal, :review
-    Album.serialize_attributes :yaml, :name
-    Album.serialization_map #{:name=>:yaml, :review=>:marshal}
-
-  The public API for the serialization plugin is still backwards
-  compatible, but the internals have changed slightly to support
-  this new feature.
-
-* You can now use eager_graph to eagerly load associations for models
-  that lack primary keys.
-
-* The :eager_graph association option now works when lazily-loading
-  many_to_many associations.
-
-* Dataset#add_graph_aliases now works correctly even if
-  set_graph_aliases hasn't been used.
-
-* The PostgreSQL Database#tables method now assumes the public schema
-  if a schema is not given and there is no default_schema.
-
-* The PostgreSQL Database#indexes method no longer returns partial
-  indexes or functional indexes.
-  
-* The MySQL Database#indexes method no longer returns indexes on
-  partial columns (prefix indexes).
-
-* Default values for String :text=>true and File columns on MySQL
-  are ignored, since MySQL doesn't support them.  They are not
-  ignored if you use text and blob, since then you are using the
-  database-specific syntax and Sequel doesn't do translation when
-  the database-specific syntax is used.
-
-* On PostgreSQL, attempting the reset the primary key sequence for a
-  table without a primary key no longer causes an error.
-
-* Using a placeholder string in an association's :condition option
-  now works correctly (e.g. :conditions=>['n = ?', 1])
-
-* An error is no longer raised if you attempt to load a plugin that
-  has a DatasetMethods module but no public dataset methods.
-
-* The check for dataset[n] where n is an integer was fixed.  It now
-  raises an error inside of returning a limited dataset.
-
-* On PostgreSQL, Dataset#insert with static SQL now works correctly.
-
-* A reflection.rdoc file was added giving an overview of Sequel's
-  reflection support.
-
-* The Migrator now works correctly with file names like
-  001_12312412_file_name.rb.
-
-* The association code now requires the classes match when looking
-  for a reciprocal association.
-
-* An unlikely threading bug (race condition) was possible when using
-  the validation_class_methods plugin. The plugin was refactored and
-  now uses a mutex to avoid the issue.  One of the refactoring changes
-  makes it so that you can no longer use a class level vaildation
-  inside a Class.new block (since inherited isn't called until the
-  block finishes).
-
-* The exception messages when Sequel.string_to_* fail have been fixed.
-
-* The String :text=>true generic database type has been fixed when
-  using the Firebird adapter.
-
-Backwards Compatibility
------------------------
-
-* A plugin's apply method is now only called the first time a plugin
-  is loaded.  Plugins can now have a configure method that is called
-  every time the plugin is loaded, and is always called after the
-  instance methods, class methods, and dataset method submodules have
-  been added to the model.  This is different from apply, which is
-  called before the submodules are loaded.
-
-  If you are a plugin author, please check your implementation to
-  make sure this doesn't cause problems for you.  If you have
-  questions, please post on the Sequel mailing list.
-
-  This new plugin feature will make certain things a lot easier, and
-  it should be mostly backwards compatible.  However, if a plugin
-  was previously expected to be loaded multiple times with the apply
-  method called each time, it will no longer work correctly.
-
-* The plugin_opts methods defined now include multiple args in an
-  array if multiple args are given.  Before, the plugin_opts methods
-  just returned the first argument.
-
-* Database#table_exists? no longer checks the cached schema
-  information.  By default, it will always do a database query
-  (unless overridden in an adapter).  This shouldn't affect the
-  results, but if were using the method a lot and expecting it to
-  use cached information, it doesn't have the same performance
-  characteristics.
-
-* The internal storage of the :select option for datasets have
-  changed.  You can no longer use a hash as a way of aliasing
-  columns.  Dataset#select now does the translation from the hash to
-  SQL::AliasedExpression instances.  Basically, if you were using
-  Dataset#clone directly with a :select option with hashes for
-  aliasing, you should switch to using Dataset#select or changing
-  the hashes to AliasedExpressions yourself.