sequel 2.10.0 → 2.11.0

data/doc/release_notes/2.3.0.txt

@@ -0,0 +1,88 @@
+JRuby and Ruby 1.9 Officially Supported
+---------------------------------------
+
+Sequel now officially supports JRuby 1.1.3 and Ruby 1.9 (svn revision
+18194 at least).  Using JRuby with the JDBC adapter, PostgreSQL,
+MySQL, and SQLite now enjoy almost full support, though not
+everything works the same as using the native adapter.  Depending on
+what you are doing, it may make sense to use postgres-pr on JRuby
+instead of PostgreSQL-JDBC.
+
+To use the new JDBC support, the database connection string you give
+Sequel is now passed directly to JDBC, here are a few examples:
+
+  Sequel.connect('jdbc:postgresql://host/database?user=*&password=*')
+  Sequel.connect('jdbc:mysql://host/database?user=*&password=*')
+  Sequel.connect('jdbc:sqlite::memory:')
+  Sequel.connect('jdbc:sqlite:relative/path.db')
+  Sequel.connect('jdbc:sqlite:/absolute/path.db')
+
+Single Gem
+----------
+
+Sequel is now distributed as a single gem named sequel, by combining
+the previous sequel_core and sequel gems.  You can still just
+"require 'sequel_core'" if you don't want the model functionality.
+
+Database Adapter Improvements
+-----------------------------
+
+* Dataset#empty? now works using the MySQL adapter.
+
+* The Oracle adapter now works with a nonstandard database port.
+
+* The JDBC adapter should load JDBC drivers automatically for
+  PostgreSQL, MySQL, SQLite, Oracle, and MSSQL.  For PostgreSQL,
+  MySQL, and SQLite, the jdbc-* gem can be used, for the others, you
+  must have the correct .jar in your CLASSPATH.
+
+* The PostgreSQL adapter no longer raises an error when inserting
+  records into a table without a primary key.
+
+* Database#disconnect now works for the ADO adapter.
+
+* The ADO adapter no longer raises an error if the dataset contains
+  no records.
+
+* The ODBC adapter no longer errors when converting ::ODBC::Time
+  values.
+
+Backwards Incompatible Changes
+------------------------------
+
+* Sequel::Worker has been removed.  There are no known users, and the
+  specs caused problems on JRuby.
+
+* Assigning an empty string to a non-string, non-blob model attribute
+  converts it to nil by default.  You can use
+  "Model.typecast_empty_string_to_nil = false" to get the old
+  behavior.  This should make web development with Sequel
+  significantly easier, hopefully at no expense to other uses.
+
+* Database.uri_to_options is now a private class method.
+
+* Model.create_table! now acts the same as Database.create_table!,
+  dropping the table unconditionally and then creating it.  This was
+  done for consistency.  If you are using Model.create_table! in
+  production code, you should change it to
+  "Model.create_table unless Model.table_exists?", otherwise you risk
+  wiping out your production data.  I recommended you use the
+  migration feature instead of Model.set_schema, as that handles
+  altering existing tables.
+
+Other Notable Changes
+---------------------
+
+* Using validates_length_of more than once on the same attribute with
+  different options without a tag no longer causes the first use to
+  be ignored.  This was a side effect of the validation tags added
+  in 2.2.0.
+
+* Other than the adapters, Sequel now has 100% code coverage (line
+  coverage).
+
+* Model#set* methods now return self.
+
+* An integration test suite was added, testing Sequel against a live
+  database with nothing mocked, which helped greatly when testing the
+  new support for JDBC adapters.

data/doc/release_notes/2.4.0.txt

@@ -0,0 +1,106 @@
+Prepared Statements/Bound Variables
+===================================
+
+Sequel now supports prepared statements and bound variables.  No
+matter which database you are using, Sequel uses exactly the same API.
+To specify placeholders, you use the :$placeholder syntax:
+
+  ds = DB[:items].filter(:name=>:$n)
+
+To use a bound variable:
+
+  ds.call(:select, :n=>'Jim')
+
+This will do the equivalent of selecting records that have the name
+'Jim'.  In addition to :select, you can use :first or :delete. There
+is also support for bound variables when inserting or updating
+records:
+
+  ds.call(:update, {:n=>'Jim', :new_n=>'Bob'}, :name=>:$new_n)
+
+Which will update all records that have the name 'Jim' to have the
+name 'Bob'.
+
+Prepared statement support is very similar to bound variable support,
+except that the statement is first prepared with a name:
+
+  ps = ds.prepare(:select, :select_by_name)
+
+It is then called later with the bound arguments to use:
+
+  ps.call(:n=>'Jim')
+  DB.call(:select_by_name, :n=>'Jim') # same as above
+
+For inserting or updating, the hash to use when inserting or updating
+is given to prepare:
+
+  ps2 = ds.prepare(:update, :update_name, :name=>:$new_n)
+  ps2.call(:n=>'Jim', :new_n=>'Bob')
+
+There is some level of native support for these features in the
+PostgreSQL, MySQL, SQLite, and JDBC adapters.  For other adapters,
+support is emulated, but it shouldn't be too difficult to add native
+support for them.
+
+For more details see:
+http://sequel.rubyforge.org/rdoc/files/doc/prepared_statements_rdoc.html
+
+Read-Only Slave/Writable Master and Database Sharding
+=====================================================
+
+Sequel now has built in support for master/slave database
+configurations, just by setting an option in Sequel.connect:
+
+  DB=Sequel.connect('postgres://master_server/database', \
+    :servers=>{:read_only=>{:host=>'slave_server'}})
+
+That will use slave_server for SELECT queries and master_server for
+other queries.  It's fairly easy to use multiple slaves or even
+multiple masters, examples are included in the link below.
+
+Sharding support requires some code other than the database
+configuration, but is still fairly simple.  For example, to set up
+a 16 shard configuration based on a hex character:
+
+  servers = {}
+  (('0'..'9').to_a + ('a'..'f').to_a).each do |hex|
+    servers[hex.to_sym] = {:host=>"hash_host_#{hex}"}
+  end
+  DB=Sequel.connect('postgres://hash_host/hashes', :servers=>servers)
+
+To set which shard to use for a query, use the Dataset#server method:
+
+  DB[:hashes].server(:a).filter(:hash=>/31337/)
+
+For more details see:
+http://sequel.rubyforge.org/rdoc/files/doc/sharding_rdoc.html
+
+Other Changes
+=============
+
+* The sequel.rubyforge.org website has a new design thanks to boof.
+  The online RDoc is now located at http://sequel.rubyforge.org/rdoc.
+
+* Support was added for anonymous column names in the ADO adapter.
+
+* Better MSSQL support in the ADO, ODBC, and JDBC adapters.  The
+  odbc_mssql adapter has been removed. If you use MSSQL with ODBC,
+  please use the odbc adapter with a :db_type=>'mssql' option.
+
+* The following Sequel::Error exception subclasses were removed:
+  InvalidExpression, InvalidFilter, InvalidJoinType, and WorkerStop.
+
+* Documentation was added for the PostgreSQL, MySQL, SQLite, and
+  JDBC adapters.
+
+* Various internal interfaces were refactored.  For example, if you
+  use an adapter not included with Sequel, it probably won't work
+  until you update it to the new internal API.
+
+* Many low level methods (such as Database#transaction), now take
+  an optional server argument to indicate which server to use.
+
+* Model plugins that have a DatasetMethods module with non-public
+  methods no longer have Model methods created that call those
+  methods.
+

data/doc/release_notes/2.5.0.txt

@@ -0,0 +1,137 @@
+New Features
+------------
+
+* The values that are used to insert/update records can now be
+  scoped similar to how filter expressions can be scoped.
+  set_defaults is used to set defaults which can be overridden,
+  and set_overrides is used to set defaults which cannot be
+  overridden:
+
+      DB[:t].set_defaults(:x=>1).insert_sql
+      # => INSERT INTO t (x) VALUES (1)
+      DB[:t].set_defaults(:x=>1).insert_sql(:x=>2)
+      # => INSERT INTO t (x) VALUES (2)
+      DB[:t].set_defaults(:x=>1).insert_sql(:y=>2)
+      # => INSERT INTO t (x, y) VALUES (1, 2)
+      DB[:t].set_overrides(:x=>1).insert_sql(:x=>2)
+      # => INSERT INTO t (x) VALUES (1)
+
+  The difference between set_defaults and set_overrides is that
+  with set_defaults, the last value takes precedence, while with
+  set_overrides, the first value takes precedence.
+
+* The schema generators now support creating and altering tables
+  with composite primary and/or foreign keys:
+
+    DB.create_table(:items) do
+      integer :id
+      text :name
+      primary_key [:id, :name]
+      foreign_key [:id, :name], :other_table, \
+        :key=>[:item_id, :item_name]
+    end
+
+    DB.alter_table(:items) do
+      add_primary_key [:id, :name]
+      add_foreign_key [:id, :name], :other_table, \
+        :key=>[:item_id, :item_name]
+    end
+
+* The AlterTableGenerator now supports unique constraints:
+
+    DB.alter_table(:items) do
+      add_unique_constraint [:aaa, :bbb, :ccc], :name => :con3
+    end
+
+* The schema generators now support ON UPDATE (previously, they only
+  supported ON DELETE):
+
+    DB.create_table(:items) do
+      foreign_key :project_id, :projects, :on_update => :cascade
+    end
+
+* When connecting to a PostgreSQL server version 8.2 and higher,
+  Sequel now uses the INSERT ... RETURNING ... syntax, which should
+  speed up row inserts on PostgreSQL.  In addition, Sequel Models
+  use RETURNING * to speed up model object creation.
+
+* You can now validate multiple attributes at once.  This is useful
+  if the combination of two or more attribute values is important,
+  such as checking the uniqueness of multiple columns.
+  validates_uniqueness_of now supports this directly:
+
+    validates_uniqueness_of [:column1, :column2]
+
+  This protects against the database having multiple rows with the
+  same values for both :column1 and :column2.  This is different
+  from:
+
+    validates_uniqueness_of :column1, :column2
+
+  Which checks that the value of column1 is unique in the table, and
+  that the value of column2 is unique in the table (which is much
+  more restrictive).
+
+Other Improvements
+------------------
+
+* Dataset methods insert_sql, delete_sql, and update_sql respect the
+  :sql option, allowing you to do things such as:
+
+    ds = DB['INSERT INTO t (time) VALUES (CURRENT_TIMESTAMP)']
+    ds.insert
+    ds.insert
+
+* The database adapters (at least MySQL, PostgreSQL, SQLite, and
+  JDBC) generally raise Sequel::DatabaseError for database problems,
+  making it easier to tell what is a true database error versus an
+  error raised by Sequel itself.
+
+* Sequel uses the async features of ruby-pg so that the entire
+  interpreter is not blocked while waiting for the results of
+  queries.
+
+* Sequel now supports the 2008.08.17 version of ruby-pg.
+
+* MSSQL support has been improved when using the ODBC and ADO
+  adapters.
+
+* Index names are quoted and creating or dropping indexes.
+
+* Automatically generated column accessor methods no longer override
+  instance methods specified by plugins.
+
+* Inserting a row with an already specified primary key inside a
+  transaction now works correctly when using PostgreSQL.
+
+* before_save and before_update hooks now work as expected when using
+  save_changes.
+
+* count and paginate now work correctly on graphed datasets.
+
+Backwards Compatibility
+-----------------------
+
+* The SQLite adapter now raises Sequel::DatabaseError instead of
+  Sequel::Error::InvalidStatement whenever an SQLite3::Exception is
+  raised by the SQLite3 driver.
+
+* Date and DateTime conversions now convert 2 digit years.  To revert
+  to the previous behavior:
+
+    Sequel.convert_two_digit_years = false
+
+  Note that Ruby 1.8 and 1.9 handle Date parsing differently, so
+  there is no backwards compatibility change for Ruby 1.9.  However,
+  this also means that the MM/DD/YY date syntax commonly used in the
+  United States is not always parsed correctly on Ruby 1.9, greatly
+  limiting the use of 2 digit year conversion.
+
+* You can no longer abuse the SQL function syntax for specifying
+  database types.  For example, you must change:
+
+    :type=>:varchar[255]
+
+  to:
+
+    :type=>:varchar, :size=>255

data/doc/release_notes/2.6.0.txt

@@ -0,0 +1,157 @@
+New Features
+------------
+
+* Schema parsing was refactored, resulting in a huge speedup when
+  using MySQL.  MySQL now uses the DESCRIBE statement instead of the
+  INFORMATION_SCHEMA.  PostgreSQL now uses the pg_* system catalogs
+  instead of the INFORMATION schema.
+
+* The schema information now includes the :primary_key field.  Models
+  now use this field to automatically determine the primary key for
+  a table, so it no longer needs to be specified explicitly.  Models
+  even handle the composite primary key case.
+
+* The raise_on_typecast_failure switch was added, with it being true
+  by default (so no change in behavior).  This allows the user to
+  silently ignore errors when typecasting fails, at the global, class,
+  and instance levels.
+
+    Sequel::Model.raise_on_typecast_failure = false # Global
+    Artist.raise_on_typecast_failure = true # Class
+    artist = Artist.new
+    artist.raise_on_typecast_failure = false # Instance
+
+    Album.raise_on_typecast_failure = true
+    Album.new(:numtracks=>'a') # => raises Sequel::Error::InvalidValue
+    Album.raise_on_typecast_failure = false
+    Album.new(:numtracks=>'a') # => #<Album @values={:numtracks=>"a"}>
+
+* Associations' orders are now respected when eager loading via
+  eager_graph.  Sequel will qualify the columns in the order with
+  the alias being used, so you can have overlapping columns when
+  eager loading multiple associations.
+
+    Artist.one_to_many :albums, :order=>:name
+    Album.one_to_many :tracks, :order=>:number
+    Artist.order(:artists__name).eager_graph(:albums=>:tracks).sql
+    # => ... ORDER BY artists.name, albums.name, tracks.number
+
+* The support for CASE expressions has been enhanced by allowing the
+  use of an optional expression:
+
+    {1=>2}.case(0, :x)
+    # => CASE x WHEN 1 THEN 2 ELSE 0 END
+    [[:a, 1], [:b, 2], [:c, 3]].case(4, :y)
+    # => CASE y WHEN a THEN 1 WHEN b THEN 2 WHEN c THEN 3 ELSE 4 END
+
+  Previously, to get something equivalent to this, you had to do:
+
+    {{:x=>1}=>2}.case(0)
+    # => CASE WHEN (x = 1) THEN 2 ELSE 0 END
+    [[{:y=>:a}, 1], [{:y=>:b}, 2], [{:y=>:c}, 3]].case(4)
+    # => CASE WHEN (y = a) THEN 1 WHEN (y = b) THEN 2 WHEN (y = c)
+         THEN 3 ELSE 4 END
+
+* You can now change the NULL/NOT NULL value of an existing column
+  using the set_column_allow_null method.
+
+    # Set NOT NULL
+    DB.alter_table(:artists){set_column_allow_null :name, false}
+    # Set NULL
+    DB.alter_table(:artists){set_column_allow_null :name, true}
+
+* You can now get the schema information for a table in a non-public
+  schema in PostgreSQL using the implicit :schema__table syntax.
+  Before, the :schema option had to be given explicitly to
+  Database#schema.  This allows models to get schema information for
+  tables outside the public schema.
+
+* Transactions are now supported on MSSQL.
+
+* Dataset#tables now returns all tables in the database for MySQL
+  databases accessed via JDBC.
+
+* Database#drop_view can now drop multiple views at once.
+
+Other Improvements
+------------------
+
+* The SQLite adapter now respects the Sequel.datetime_class option
+  for timestamp and datetime columns.
+
+* Adding a unique constraint no longer explicity creates a unique
+  index.  If you want a unique index, use index :unique=>true.
+
+* If no language is specified when creating a full text index on
+  PostgreSQL, the simple language is assumed.
+
+* Errors when typecasting fails are now Sequel::Error::InvalidValue
+  instead of the more generic Sequel::Error.
+
+* Specifying constraints now works correctly for all types of
+  arguments.  Previously, it did not work unless a block or
+  interpolated string were used.
+
+* Loading an association with the same name as a table in the FROM
+  clause no longer causes an error.
+
+* When eagerly loading many_to_one associations where no objects have
+  an associated object, the negative lookup is now cached.
+
+* String keys can now be used with Dataset#multi_insert, just like
+  they can be used for Dataset#insert.
+
+* Dataset#join_table now generates the correct SQL when doing the
+  first join to a dataset where the first source is a dataset, when
+  an unqualified column is used in the conditions.
+
+* Cascading associations after *_to_many associations can now be
+  eagerly loaded via eager_graph.
+
+* Eagerly loading *_to_many associations that are cascaded behind a
+  many_to_one association now have their duplicates removed if a
+  cartesian product join is done.
+
+* The SQLite adapter now uses string literals in all of the AS
+  clauses.  While the SQL standard specifies that identifiers should
+  be used, SQLite documentation explicitly states that string
+  literals are expected (though it generally works with identifiers
+  by converting them implicitly).
+
+* Database methods that modify the schema now remove the cached
+  schema entry.
+
+* The hash keys that Database#schema returns when no table is
+  requested are now always supposed to be symbols.
+
+* The generation of SQL for composite foreign keys on MySQL has been
+  fixed.
+
+* A schema.rdoc file was added to the documentation explaining the
+  various parts of Sequel related to schema generation and
+  modification and how they interact
+  (http://sequel.rubyforge.org/rdoc/files/doc/schema_rdoc.html).
+
+* The RDoc template for the website was changed from the default
+  template to the hanna template.
+
+Backwards Compatibility
+-----------------------
+
+* The :numeric_precision and :max_chars schema entries have been
+  removed.  Use the :db_type entry to determine this information,
+  if available.
+
+* The SQLite adapter used to always return Time instances for
+  timestamp types, even if Sequel.datetime_class was DateTime.  For
+  datetime types it always returned a DateTime instance.  It
+  now returns an instance of Sequel.datetime_class in both cases.
+
+* It's possible that the including of associations' orders when eager
+  loading via eager_graph could cause problems.  You can use the
+  :order_eager_graph=>false option to not use the :order option when
+  eager loading via :eager_graph.
+
+* There were small changes in SQL creation where the AS keyword is
+  now used explicitly.  These should have no effect, but could break
+  tests for explicit SQL.