sequel 4.36.0 → 5.61.0

data/doc/release_notes/2.2.0.txt

@@ -1,253 +0,0 @@
-The Most Powerful and Flexible Associations of Any Ruby ORM
------------------------------------------------------------
-
-Sequel can now support any association type supported by
-ActiveRecord, and many association types ActiveRecord doesn't
-support.
-
-Association callbacks (:before_add, :after_add, :before_remove,
-:after_remove) have been added, and work for all association
-types.  Each of the callback options can be a Symbol specifying an
-instance method that takes one argument (the associated object), or a
-Proc that takes two arguments (the current object and the associated
-object), or an array of Symbols and Procs.  Additionally, an
-:after_load callback is available, which is running after loading the
-associated record(s) from the database.
-
-Association extensions are now supported:
-
-  class FindOrCreate
-    def find_or_create(vals)
-      first(vals) || create(vals)
-    end
-  end
-  class Author < Sequel::Model
-    one_to_many :authorships, :extend=>FindOrCreate
-  end
-  Author.first.authorships_dataset.find_or_create(:name=>'Bob')
-
-Sequel has been able to support most has_many :through style
-associations since 1.3, via many_to_many (since it doesn't break on
-join tables that are also model tables, unlike ActiveRecord's
-has_and_belongs_to_many).  Now it can also support has_many :through
-style associations where it goes through a has_many association.
-
-Sequel can now support polymorphic associations.  Polymorphic
-associations are really a design flaw, so Sequel doesn't support them
-directly, but the tools that Sequel gives you make them pretty easy
-to implement.
-
-Sequel can also support associations that ActiveRecord does not.  For
-example, a belongs_to association where the column referenced in the
-associated table is not the primary key, an association that depends
-on multiple columns in each table, or even situations where the
-association has a column in the primary table that can be referenced
-by any of multiple columns in a second table that has a has_one style
-association with the table you want to associate with.
-
-Some of those associations can be supported for a single object using
-custom SQL in ActiveRecord, but none are supported when eager
-loading or allow further filtering.
-
-Not only can all of these cases be supported with Sequel::Model, all
-can be supported with eager loading, and can allow for further
-filtering. See
-http://sequel.rubyforge.org/files/sequel/doc/advanced_associations_rdoc.html
-for details and example code for all association types covered above.
-
-There have also been many additional options added for controlling
-eager loading via eager_graph.  Every part of the SQL JOINs can now
-be controlled via one of the options, so you can use JOIN USING,
-NATURAL JOIN, or arbitrary JOIN ON conditions.
-
-Finally, just to show off the power that Sequel gives you when eager
-loading, here is example code that will eagerly load all descendants
-and ancestors in a tree structure, without knowing the depth of the
-tree:
-
-  class Node < Sequel::Model
-    set_schema do
-      primary_key :id
-      foreign_key :parent_id, :nodes
-    end
-    create_table
-
-    many_to_one :parent
-    one_to_many :children, :key=>:parent_id
-
-    # Only useful when eager loading
-    many_to_one :ancestors, :eager_loader=>(proc do |key_hash, nodes,
-associations|
-      # Handle cases where the root node has the same parent_id as
-primary_key
-      # and also when it is NULL
-      non_root_nodes = nodes.reject do |n|
-        if [nil, n.pk].include?(n.parent_id)
-          # Make sure root nodes have their parent association set to
-nil
-          n.associations[:parent] = nil
-          true
-        else
-          false
-        end
-      end
-      unless non_root_nodes.empty?
-        id_map = {}
-        # Create an map of parent_ids to nodes that have that parent id
-        non_root_nodes.each{|n| (id_map[n.parent_id] ||= []) << n}
-        # Doesn't cause an infinte loop, because when only the root node
-        # is left, this is not called.
-        Node.filter(Node.primary_key=>id_map.keys).eager(:ancestors).all
-do |node|
-          # Populate the parent association for each node
-          id_map[node.pk].each{|n| n.associations[:parent] = node}
-        end
-      end
-    end)
-    many_to_one :descendants, :eager_loader=>(proc do |key_hash, nodes,
-associations|
-      id_map = {}
-      nodes.each do |n|
-        # Initialize an empty array of child associations for each
-parent node
-        n.associations[:children] = []
-        # Populate identity map of nodes
-        id_map[n.pk] = n
-      end
-      # Doesn't cause an infinite loop, because the :eager_loader is not
-called
-      # if no records are returned.  Exclude id = parent_id to avoid
-infinite loop
-      # if the root note is one of the returned records and it has
-parent_id = id
-      # instead of parent_id = NULL.
-      Node.filter(:parent_id=>id_map.keys).exclude(:id=>:parent_id).eager(:descendants).all
-do |node|
-        # Get the parent from the identity map
-        parent = id_map[node.parent_id]
-        # Set the child's parent association to the parent
-        node.associations[:parent] = parent
-        # Add the child association to the array of children in the
-parent
-        parent.associations[:children] << node
-      end
-    end)
-  end
-
-  nodes = Node.filter(:id < 10).eager(:ancestors, :descendants).all
-
-New Adapter Features
---------------------
-
-* PostgreSQL bytea fields are now fully supported.
-
-* The PostgreSQL adapter now uses the safer connection-specific
-  string escaping if you are using ruby-pg.
-
-* The SQLite adapter supports drop_column and add_index.
-
-* You can now use URL parameters in the connection string, enabling
-  you to connect to PostgreSQL via a socket using
-  postgres://user:password@blah/database?host=/tmp
-
-Other New Features
-------------------
-
-* Dataset#graph now takes a block which it passes to join_table.
-
-* Symbol#identifier has been added, which can be used if another
-  library defines the same operator(s) on Symbol that Sequel defines.
-
-* Filter blocks now yield a VirtualRow instance, which can yield
-  Identifiers, QualifiedIdentifiers, or Functions.  Like
-  Symbol#identifier, this is useful if another library defines the
-  same operator(s) on Symbol that Sequel defines.
-
-* You can now call Model.to_hash to get an identity map for all
-  rows (before this required Model.dataset.to_hash).
-
-* A model that can get it's column information from the schema will
-  set it in the dataset, potentially saving many queries.
-
-* Model.validates_presence_of now works correctly for boolean
-  columns.
-
-Notable Bug Fixes
------------------
-
-* Caching now works with Model subclasses.
-
-* Model validation methods now work with source reloading.
-
-* The PostgreSQL adapter no longer raises an Error if you try to
-  insert a record with the primary key already specified.
-
-* Sequel no longer messes with the native MySQL adapter, so you can
-  use Sequel and ActiveRecord with MySQL in the same process.
-
-* Dataset#count now works correctly for limited dataset.
-
-* PostgreSQL Database#transaction method yields a connection, similar
-  to the other adapters.
-
-* Using a hash argument in #distinct, #order, or #group is treated
-  as an expression instead of a column alias.
-
-* Cloned datasets no longer ignore the existing columns unless it is
-  necessary.
-
-* The :quote_identifiers and :single_threaded Database options now
-  work correctly.
-
-Backwards Incompatible Changes
-------------------------------
-
-* ParseTree support, deprecated in 2.1.0, has been removed in 2.2.0.
-  You should use the expression filter syntax instead, perferably
-  without the block (though it can be used inside a block as well).
-  This usually involves the following types of changes:
-
-    filter{:x == :y} => filter(:x => :y)
-    filter{:x << :y} => filter(:x => :y)
-    filter{:x && :y} => filter(:x & :y) # Don't forget about change
-    filter{:x || :y} => filter(:x | :y) #  in operator precedence
-    filter{:x.like?('%blah%')} => filter(:x.like('%blah%'))
-    filter do => filter((:x > 1) & (:y < 2))
-      :x > 1
-      :y < 2
-    end
-
-* Attempts to save an invalid Model instance will raise an error by
-  default.  To revert to returning a nil value, use:
-
-    Sequel::Model.raise_on_save_failure = false # Global
-    Album.raise_on_save_failure = false # Class
-    album = Album.new
-    album.raise_on_save_failure = false # Instance
-
-  Note that before, save would return false where now it returns nil
-  if you disable raising on save failure.
-
-* Dataset#update no longer takes a block, as it's use of the block
-  depended on ParseTree.  With the introduction of the expression
-  syntax in 2.0.0, it's no longer necessary.  You should use a hash
-  with an expression as the value instead:
-
-    DB[:table].update(:column=>:column + 1)
-
-* validates_presence of now considers false as present instead of
-  absent.  This is so it works with boolean columns.
-
-* Dataset#graph ignores any previously selected columns when it is
-  called for the first time.
-
-* Dataset#columns ignores any filtering, ordering, or distinct
-  clauses.  This shouldn't cause issues unless you were using
-  SQL functions with side effects and expecting them to be called
-  when columns was called (unlikely at best).
-
-One significant point of note is that the 2.2.0 release will be the
-last release with both a sequel_core and sequel gem.  Starting
-with 2.3.0 they will be combined into one sequel gem.  You will still
-be able to get just the sequel_core part by requiring 'sequel_core',
-but they will be packaged together.

data/doc/release_notes/2.3.0.txt

@@ -1,88 +0,0 @@
-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

@@ -1,106 +0,0 @@
-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

@@ -1,137 +0,0 @@
-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