sequel 4.26.0 → 5.37.0

data/doc/release_notes/3.2.0.txt

@@ -1,268 +0,0 @@
-New Features
-------------
-
-* Common table expressions (CTEs) are now supported.  CTEs use the
-  SQL WITH clause, and specify inline views that queries can use.
-  They also support a recursive mode, where the CTE can recursively
-  query its own output, allowing you do do things like load all
-  branches for a given node in a plain tree structure.
-  
-  The standard with takes an alias and a dataset:
-  
-    DB[:vw].with(:vw, DB[:table].filter{col < 1})
-    # WITH vw AS (SELECT * FROM table WHERE col < 1)
-    # SELECT * FROM vw
-    
-  The recursive with takes an alias, a nonrecursive dataset, and a
-  recursive dataset:
-    
-    DB[:vw].with_recursive(:vw,
-      DB[:tree].filter(:id=>1),
-      DB[:tree].join(:vw, :id=>:parent_id).
-                select(:vw__id, :vw__parent_id))
-    # WITH RECURSIVE vw AS (SELECT * FROM tree
-    #     WHERE (id = 1)
-    #     UNION ALL
-    #     SELECT vw.id, vw.parent_id
-    #     FROM tree
-    #     INNER JOIN vw ON (vw.id = tree.parent_id))
-    # SELECT * FROM vw
-
-  CTEs are supported by Microsoft SQL Server 2005+, DB2 7+,
-  Firebird 2.1+, Oracle 9+, and PostgreSQL 8.4+.
-  
-* SQL window functions are now supported, and a DSL has been added to
-  ease their creation.  Window functions act similarly to aggregate
-  functions but operate on sliding ranges of rows.
-  
-  In virtual row blocks (blocks passed to filter, select, order, etc.)
-  you can now provide a block to method calls to change the default
-  behavior to create functions that weren't possible previously.  The
-  blocks aren't called, but their presence serves as a flag.
-  
-  What function is created depends on the arguments to the method:
-  
-  * If there are no arguments, an SQL::Function is created with the
-    name of method used, and no arguments.  Previously, it was not
-    possible to create functions without arguments using the virtual
-    row block DSL.  Example:
-    
-      DB.dataset.select{version{}} # SELECT version()
-    
-  * If the first argument is :*, an SQL::Function is created with a
-    single wildcard argument (*).  This is mostly useful for count:
-    
-      DB[:t].select{count(:*){}} # SELECT count(*) FROM t
-    
-  * If the first argument is :distinct, an SQL::Function is created
-    with the keyword DISTINCT prefacing all remaining arguments. This
-    is useful for aggregate functions such as count:
-    
-      DB[:t].select{count(:distinct, col1){}}
-      # SELECT count(DISTINCT col1) FROM t
-    
-  * If the first argument is :over, the second argument, if provided,
-    should be a hash of options to pass to SQL::Window.  The options
-    hash can also contain :*=>true to use a wildcard argument as the
-    function argument, or :args=>... to specify an array of arguments
-    to use as the function arguments.
-
-      DB[:t].select{rank(:over){}} # SELECT rank() OVER ()
-      DB[:t].select{count(:over, :*=>true){}} # SELECT count(*) OVER ()
-      DB[:t].select{sum(:over, :args=>col1,
-                    :partition=>col2, :order=>col3){}}
-      # SELECT sum(col1) OVER (PARTITION BY col2 ORDER BY col3)
-      
-  PostgreSQL also supports named windows.  Named windows can be
-  specified by Dataset#window, and window functions can reference
-  them using the :window option.
-  
-* Schema information for columns now includes a :ruby_default entry
-  which contains a ruby object that represents the default given by
-  the database (which is stored in :default).  Not all :default
-  entries can be parsed into a :ruby_default, but if the
-  schema_dumper extension previously supported it, it should work.
-
-* Methods to create compound datasets (union, intersect, except), now
-  take an options hash instead of a true/false flag.  The previous
-  API is still supported, but switching to specifying the ALL setting
-  using :all=>true is recommended.
-  
-  Additionally, you can now set :from_self=>false to not wrap the
-  returned dataset in a "SELECT * FROM (...)".
-  
-* Dataset#ungraphed was added that removes the graphing information
-  from the dataset.  This allows you to use Dataset#graph for the
-  automatic aliasing, or #eager_graph for the automatic aliasing and
-  joining, and then remove the graphing information so that the
-  resulting objects will not be split into subhashes or associations.
-
-* There were some introspection methods added to Dataset to describe
-  which capabilities that dataset does or does not support:
-  
-    supports_cte?
-    supports_distinct_on?
-    supports_intersect_except?
-    supports_intersect_except_all?
-    supports_window_functions?
-
-  In addition to being available for the user to use, these are also
-  used internally, so attempting to use a CTE on a dataset that
-  doesn't support it will raise an Error.
-
-* Dataset#qualify was added, which is like qualify_to with a default
-  of first_source.
-
-  Additionally, qualify now affects PlaceholderLiteralStrings.  It
-  doesn't scan the string (as Sequel never attempts to parse SQL),
-  but if you provide the column as a symbol placeholder argument, it
-  will qualify it.
-  
-* You can now specify the table and column Sequel::Migrator will use
-  to record the current schema version.  The new Migrator.run method
-  must be used to use these new options.
-  
-* The JDBC adapter now accepts :user and :password options, instead
-  of requiring them to be specified in the connection string and 
-  handled by the JDBC driver.  This should allow connections to
-  Oracle using the Thin JDBC driver.
-  
-* You can now specify the max_connections, pool_timeout, and
-  single_threaded settings directly in the connection string:
-  
-    postgres:///database?single_threaded=t
-    postgres:///database?max_connections=10&pool_timeout=20
-
-* Dataset#on_duplicate_key_update now affects Dataset#insert when
-  using MySQL.
-
-* You can now specify the :opclass option when creating PostgreSQL
-  indexes.  Currently, this only supports a single operator class
-  for all columns.  If you need different operator classes per
-  column, please post on sequel-talk.
-  
-* Model#autoincrementing_primary_key was added and can be used if
-  the autoincrementing key isn't the same as the primary key.  The
-  only likely use for this is on MySQL MyISAM tables with composite
-  primary keys where only one of the composite parts is
-  autoincrementing.
-
-* You can now use database column values as search patterns and
-  specify the text to search as a String or Regexp:
-  
-    String.send(:include, Sequel::SQL::StringMethods)
-    Regexp.send(:include, Sequel::SQL::StringMethods)
-
-    'a'.like(:x)  # ('a' LIKE x)
-    /a/.like(:x)  # ('a' ~ x)
-    /a/i.like(:x) # ('a' ~* x)
-    /a/.like(:x, 'b') # (('a' ~ x) OR ('a' ~ 'b'))
-
-* The Dataset#dataset_alias private method was added.  It can be
-  overridden if you have tables named t0, t1, etc and want to make
-  sure the default dataset aliases that Sequel uses do not clash
-  with existing table names.
-  
-* Sequel now raises an Error if you call Sequel.connect with
-  something that is not a Hash or String.
-  
-* bin/sequel now accepts a -N option to not test the database
-  connection.
-  
-* An opening_databases.rdoc file was added to the documentation
-  directory, which should be a good introduction for new users about
-  how to set up your Database connection.
-
-Other Improvements
-------------------
-
-* MySQL native adapter SELECT is much faster than before, up to 75%
-  faster.
-
-* JDBC SELECT is about 10% faster than before.  It's still much
-  slower than the native adapters, due to conversion issues.
-
-* bin/sequel now works with a YAML file on ruby 1.9.
-
-* MySQL foreign key table constraints have been fixed.
-
-* Database#indexes now works on PostgreSQL if the schema used is a
-  Symbol.  It also works on PostgreSQL versions all the way back to
-  7.4.
-
-* Graphing of datasets with dataset sources has been fixed.
-
-* Changing a columns name, type, or NULL status on MySQL now
-  supports a much wider selection of column defaults.
-  
-* The stored procedure code is now thread-safe.  Sequel is
-  thread-safe in general, but due to a bug the previous stored 
-  procedure code was not thread-safe.
-
-* The ODBC adapter now drops statements automatically instead of
-  requiring the user to do so manually, making it more similar
-  to other adapters.
-
-* The single_table_inheritance plugin no longer overwrites the STI
-  field if the field already has a value.  This allows you to use
-  create in the generic class to insert a value that will be
-  returned as a subclass:
-  
-    Person.create(:kind => "Manager")
-    
-* When altering colums on MySQL, :unsigned, :elements, :size and other
-  options given are no longer ignored.
-
-* The PostgreSQL shared adapter's explain and analyze methods have
-  been fixed, they had been broken in 3.0.
-  
-* Parsing of the server's version is more robust on PostgreSQL.
-  It should now work correctly for 8.4 and 8.4rc1 type versions.
-
-Backwards Compatibility
------------------------
-
-* Dataset#table_exists? has been removed, since it never worked
-  perfectly.  Use Database#table_exists? instead.
-  
-* Model.grep now calls Dataset#grep instead of Enumerable#grep.
-  If you are using Model.grep, you need to modify your application.
-
-* The MSSQL shared adapter previously used the :with option for
-  storing the NOLOCK setting of the query.  That option has been
-  renamed to :table_options, since :with is now used for CTEs.
-  This should not have an effect unless you where using the option
-  manually.
-
-* Previously, providing a block to a method calls in virtual row
-  blocks did not change behavior, where now it causes a different
-  code path to be used.  In both cases, the block is not evaluated,
-  but that may change in a future version.
-  
-* Dataset#to_table_reference protected method was removed, as it was
-  no longer used.
-  
-* The pool_timeout setting is now converted to an Integer, so if you
-  used to pass in a Float, it no longer works the same way.
-  
-* Most files in adapters/utils have been removed, in favor of 
-  integrating the code directly into Database and Dataset.  If you
-  were previously checking for the UnsupportedIntersectExcept or
-  related modules, use the Dataset introspection methods instead
-  (e.g. supports_intersect_except?).
-  
-* If you were using the ODBC adapter and manually dropping returned
-  statements, you should note that now statements are dropped
-  automatically, and the execute method doesn't return a statement
-  object.
-  
-* The MySQL adapter on_duplicate_key_update_sql is now a private
-  method.
-  
-* If you were modifying the :from dataset option directly, note that
-  Sequel now expects this option to be preprocessed.  See the new
-  implementation of Dataset#from for an idea of the changes
-  required.
-  
-* Dataset#simple_select_all? now returns false instead of true for a
-  dataset that selects from another dataset.

data/doc/release_notes/3.20.0.txt

@@ -1,41 +0,0 @@
-= New Features
-
-* The swift adapter now supports an SQLite subadapter.  Use the
-  :db_type => 'sqlite' option when connecting.  You can use an
-  in memory database with the following connection string:
-  
-    swift:///?database=:memory:&db_type=sqlite
-
-* Arbitrary JDBC properties can now be set in the JDBC adapter
-  using the :jdbc_properties option when connecting.  The value
-  of this option should be a hash where keys and values are JDBC
-  property keys and values.
-  
-* Basic Microsoft Access support was added to the ado adapter.
-  The creation of autoincrementing primary key integers now works,
-  and identifiers are now quoted with [].
-
-* The Database#indexes method now supports a :partial option when
-  connecting to MySQL, which makes it include partial indexes (which
-  are usually excluded).
-
-= Other Improvements
-
-* The class_table_inheritance plugin now handles subclass
-  associations better.  Previously, the implicit eager loading code
-  had issues when you called an association method that only existed
-  in the subclass.
-
-* The error message used when a validates_max_length validation is
-  applied to a nil column value has been improved.  You can override
-  the message yourself using the :nil_message option.
-  
-* The read_timeout and connect_timeout options now work correctly in
-  the mysql adapter.
-
-* Another MySQL disconnect error message is now recognized.
-
-= Backwards Compatibility
-
-* The swift adapter was upgraded to support swift 0.8.1.  Older
-  versions of swift are no longer supported.

data/doc/release_notes/3.21.0.txt

@@ -1,87 +0,0 @@
-= New Features
-
-* A tinytds adapter was added, enabling Sequel users on a C-based
-  ruby running on *nix easy access to Microsoft SQL Server.
-  Previously, the best way to connect to Microsoft SQL Server from
-  a C-based ruby on *nix was to use the ODBC adapter with unixodbc
-  and freetds.  However, setting that up is nontrivial, while
-  setting up tinytds is very easy.
-  
-  Note that the tinytds adapter currently requires the git master
-  branch of tiny_tds, but tiny_tds 0.4.0 should include the related
-  changes.
-  
-* An association_autoreloading plugin has been added to Sequel,
-  which removes stale many_to_one associations from the cache when
-  the associated foreign key setter is used to change the value of
-  the foreign key.
-
-* bin/sequel now operates more like a standard *nix utility.
-  If given a file on the command line after the connection
-  string, it will assume that file has ruby code and load it.
-  If stdin is not a tty, it will read from stdin and execute it
-  as ruby code.
-  
-  For recent Linux users, this means you can have a shebang line
-  such as:
-  
-    #!/usr/bin/sequel postgres://user:pass@host/db
-    
-  to create a self contained script.
-
-* bin/sequel now supports -r and -I options similar to ruby's
-  -r and -I options.
-  
-* MySQL datasets now have a calc_found_rows method that uses
-  SQL_CALC_FOUND_ROWS, which provides a fast way to limit the
-  number of results returned by a dataset while having an easy
-  way to determine how many rows would have been returned if no
-  limit was applied.
-
-= Other Improvements
-
-* The Sequel::Model.plugin method can now be overridden just like
-  any other method.  Previously, it was the only method that
-  was defined directly on the class.  This allows the creation
-  of plugins that can modify the plugin system itself.
-
-* Symbol splitting (:table__column___alias) now works correctly
-  for identifiers that include characters that aren't in [\w ].
-  Among other things, this means that identifiers with accented
-  characters or even kanji characters can be used with symbol
-  splitting.
-  
-* If cover? is defined, it is now used in preference to include?
-  for the validates_includes/validates_inclusion_of validations.
-  ruby 1.9 defines include? differently for some ranges and can
-  be very slow, while cover? is similar to the 1.8 behavior of
-  just checking the beginning and end of the range.
-  
-* The bin/sequel -L option now takes effect even if the -m,
-  -C, -d, or -D options are used.
-  
-* The schema_dumper extension now recognizes the "bigint unsigned"
-  type.
-  
-* On Microsoft SQL Server, if joining to a subselect that uses a
-  common table expression, that common table expression is
-  promoted to the main dataset.  This allows most queries to work
-  correctly, but is vulnerable to issues if both the current
-  dataset and the joined dataset use common table expressions with
-  the same name.  Unfortunately, unlike PostgreSQL, Microsoft SQL
-  Server does not allow common table expressions to occur in
-  subselects.
-
-* The NULL/NOT NULL, DEFAULT, and UNIQUE column options now
-  use the proper order on H2 and Oracle, so they can now be
-  used in conjunction with each other.
-  
-* Row locks are now enabled on Oracle.
-
-* The join_table method on MySQL no longer ignores the block it was
-  given.
-  
-* The informix adapter now supports ruby-informix version >= 0.7.3,
-  while still being backwards compatible with older versions.
-
-* The specs now run under both RSpec 2 and RSpec 1.

data/doc/release_notes/3.22.0.txt

@@ -1,39 +0,0 @@
-= New Features
-
-* Support COLLATE in column definitions.  At least MySQL and Microsoft
-  SQL Server support them, and PostgreSQL 9.1 should as well.
-
-* When connecting to Microsoft SQL Server, you can use the
-  mssql_unicode_strings accessor to turn of the default usage
-  of unicode strings (N'') and use regular strings (''). This
-  can improve performance, but changes the behavior.  It's
-  set to true by default for backwards compatibility.  You can
-  change it at both the dataset and database level:
-
-    DB.mssql_unicode_strings = false # default for datasets
-    dataset.mssql_unicode_strings = false # just this dataset
-
-* In the oracle adapter, if Sequel.application_timezone is :utc, set
-  the timezone for the connection to use the 00:00 timezone.
-
-= Other Improvements
-
-* In the single_table_inheritance plugin, correctly handle a
-  multi-level class hierarchy so that loading instances from a
-  middle level of the hierarchy can return instances of subclasses.
-
-* Don't use a schema when creating a temporary table, even if
-  default_schema is set.
-
-* Fix the migrator when a default_schema is used.
-
-* In the ado adapter, assume a connection to SQL Server if the
-  :conn_string is given and doesn't indicate Access/Jet.
-
-* Fix fetching rows in the tinytds adapter when the
-  identifier_output_method is nil.
-
-* The tinytds adapter now checks for disconnect errors, but it might
-  not be reliable until the next release of tiny_tds.
-
-* The odbc adapter now handles ODBC::Time instances correctly.

data/doc/release_notes/3.23.0.txt

@@ -1,172 +0,0 @@
-= New Features
-
-* Sequel now allows dynamic customization for eager loading.
-  Previously, the parameters for eager loading were fixed at
-  association creation time.  Now, they can be modified at query
-  time.  To dynamically modify an eager load, you use a hash with
-  the proc as the value. For example, if you have this code:
-
-    Artist.eager(:albums)
-
-  And you only want to eagerly load albums where the id is greater
-  than or equal to some number provided by the user, you do:
-
-    min = params[:min].to_i
-    Artist.eager(:albums=>proc{|ds| ds.where{id > min}})
-    
-  This also works when eager loading via eager_graph:
-  
-    Artist.eager_graph(:albums=>proc{|ds| ds.where{id > min}})
-  
-  For eager_graph, the dataset is the dataset to graph into the
-  current dataset, and filtering it will result in an SQL query
-  that joins to a subquery.
-  
-  You can also use dynamic customization while cascading to also
-  eagerly load dependent associations, by making the hash value
-  a single entry hash with a proc key and the value being the
-  dependent associations to eagerly load. For example, if you want
-  to eagerly load tracks for those albums:
-
-    Artist.eager(:albums=>{proc{|ds| ds.where{id > min}}=>:tracks})
-
-* Sequel also now allows dynamic customization for regular
-  association loading.  Previously, this was possible by using the
-  association's dataset:
-
-    albums = artist.albums_dataset.filter{id > min}
-
-  However, then there was no handling of caching, callbacks, or
-  reciprocals.  For example:
-
-    albums.each{|album| album.artist}
-    
-  Would issue one query per album to get the artist, because the
-  reciprocal association was not set.  Now you can provide a
-  block to the association method:
-  
-    albums = artist.albums{|ds| ds.filter{id > min}}
-    
-  This block is called with the dataset used to retrieve the
-  associated objects, and should return a modified version of that
-  dataset.
-  
-  Note that ruby 1.8.6 doesn't allow blocks to take block arguments,
-  so you have to pass the block as a separate proc argument to the
-  association method if you are still using 1.8.6.
-
-* Sequel now supports filtering by associations.  This wasn't
-  previously supported as filtering is a dataset level feature and
-  associations are a model level feature, and datasets do not depend
-  on models.  Now, model datasets have the ability to filter by
-  associations.  For example, to get all albums for a given artist,
-  you could do:
-  
-    artist = Artist[1]
-    Album.filter(:artist=>artist)
-    
-  Since the above can also be accomplished with:
-  
-    artist.albums
-    
-  this may not seem like a big improvement, but it allows you to
-  filter on multiple associations simultaneously:
-  
-    Album.filter(:artist=>artist, :publisher=>publisher)
-    
-  For simple many_to_one associations, the above is just a simpler
-  way to do:
-  
-    Album.filter(:artist_id=>artist.id, :publisher_id=>publisher.id)
-    
-  Sequel supports this for all association types, including
-  many_to_many and many_through_many, where a subquery is used, and
-  it also works when composite key associations are used:
-  
-    Album.filter(:artist=>artist, :tags=>tag)
-    
-  This will give you the albums for that artist that are also tagged
-  with that tag.  To provide multiple values for the same
-  association, mostly useful for many_to_many associations, you can
-  either use separate filter calls or specify the conditions as an
-  array:
-  
-    Album.filter(:tags=>tag1).filter(:tags=>tag2)
-    Album.filter([[:tags, tag1], [:tags, tag2]])
-
-* A columns_introspection extension has been added that makes
-  datasets attempt to guess their columns in some cases instead of
-  issuing a database query.  This can improve performance in cases
-  where the columns are needed implicitly, such as graphing.  After
-  loading the extension, you can enable the support for specific
-  datasets by extending them with Sequel::ColumnIntrospection.  To
-  enable introspection for all datasets, use:
-  
-    Sequel::Dataset.introspect_all_columns
-
-* A serialization_modification_detection plugin has been added.
-  Previously, Sequel could not detect modifications made to
-  serialized objects.  It could detect modification if you assigned
-  a new value:
-  
-    model.hash_column = model.hash_column.merge(:foo=>:bar)
-    
-  but not if you just modified the object directly:
-  
-    model.hash_columns[:foo] = :bar
-    
-  With this plugin, such modifications can be detected, at a
-  potentially significant performance cost.
-
-= Other Improvements
-
-* When using a migration directory containing both older integer
-  migrations and newer timestamp migrations, where some integer
-  migrations have not been applied, make sure to apply the remaining
-  integer migrations before the timestamp migrations.  Previously,
-  they could be applied out of order due to a lexicographic sort
-  being used instead of a numeric sort.
-
-* If a model does not select all columns from its table, the
-  insert_select optimization is no longer used.  Previously,
-  creating a new model object for such a model could result in the
-  object containing columns that the model does not select.
-
-* You can now use :select=>[] as an option for many_to_many
-  associations to select all columns from both the associated
-  table and the join table.  Previously, this raised an error and
-  required you do :select=>'*'.lit as a workaround.  The default
-  remains to select all columns in the associated table and none
-  from the join table.
-
-* The xml_serializer plugin now handles namespaced models by
-  using __ instead of / as the namespace separator.  Previously, /
-  was used and caused problems as it is not valid XML.
-  
-* The :eager_grapher association option can now accept a proc that
-  takes a single hash of options instead of a fixed 3 arguments.
-  This is the recommended way going forward of writing custom
-  :eager_graphers, and all of the internal ones have been converted.
-  The previous way of using 3 arguments is still supported.
-  
-* A bug in the identity_map plugin for many_to_one associations
-  without full association reflection information has been fixed.
-
-* Sequel is now using GitHub Issues for issue tracking.  Old issues
-  have been migrated from Google Code.
-
-= Backwards Compatibility
-
-* The filter by associations support breaks backward compatibilty for
-  users who previously added an sql_literal instance method to
-  Sequel::Model.  Usually, that was done to for reasons similar to
-  but inferior than the filter by association support.  The following
-  code can be used as a temporary workaround until you can modify
-  your program to use the new filter by associations support:
-  
-    Sequel::Model::Associations::DatasetMethods.
-      send(:remove_method, :complex_expression_sql)
-
-* The private Sequel::Model#_load_associated_objects method now takes
-  an additional, optional options hash.  Plugins that override that
-  method need to be modified.