viking-sequel 3.10.0

data/doc/release_notes/1.0.txt

@@ -0,0 +1,38 @@
+=== New code organization
+
+Sequel is now divided into two parts: sequel_core and sequel_model.
+These two parts are distributed as two separate gems. The sequel gem
+bundles sequel_core and sequel_model together. If you don't use
+Sequel::Model in your code, you can just install and use sequel_core.
+
+=== New model hooks implementation
+
+The hooks implementation have been rewritten from scratch, is much
+more robust and offers a few new features:
+
+* More ways to define hooks: hooks can now be defined by supplying a
+block or a method name, or by overriding the hook instance method.
+
+* Inheritable hooks: Hooks can now be inherited, which means that you
+can define general hooks in a model superclass, and use them in
+subclasses. You can also define global hooks on Sequel::Model that
+will be invoked for all model classes.
+
+* Hook chains can be broken by returning false from within the hook.
+
+* New after_initialize hook, invoked after instance initialization.
+
+* The hook invocation order can no longer be changed. Hooks are
+invoked in order of definition, from the top of the class hierarchy
+(that is, from Sequel::Model) down to the specific class.
+
+=== Miscellanea
+
+* Removed deprecated adapter stubs, and all other deprecations in both
+sequel_core and sequel_model.
+
+* Fixed String#to_time to raise error correctly for invalid time
+stamps.
+
+* Fixed error behavior when parse_tree or ruby2ruby are not available.
+

data/doc/release_notes/1.1.txt

@@ -0,0 +1,143 @@
+=== DRY Sequel models
+
+With the new Sequel release you no longer need to explicitly specify
+the table
+name for each model class, assuming your model name is the singular of
+the
+table name (just like in ActiveRecord or DataMapper):
+
+  class UglyBug < Sequel::Model
+  end
+
+  UglyBug.table_name #=> :ugly_bugs
+
+=== New model validations and support for virtual attributes
+
+Sequel model now include validation functionality which largly follows
+the
+validations offered in ActiveRecord. Validations can be checked
+anytime by
+calling Model#valid?, with validation errors accessible through
+Model#errors:
+
+  class Item < Sequel::Model
+    validates_presence_of :name
+  end
+
+  my_item = Item.new
+  my_item.valid? #=> false
+  my_item.errors.full_messages #=> ["name is not present"]
+
+The Model#save method has been changed to check for validity before
+saving. If
+the model instance is not valid, the #save method returns false
+without saving
+the instance. You can also bypass the validity test by calling
+Model#save!
+instead.
+
+Model classes also now support virtual attributes, letting you assign
+values to
+any attribute (virtual or persistent) at initialization time:
+
+  class User < Sequel::Model
+    attr_accessor :password
+  end
+
+  u = User.new(:password => 'blah', ...)
+  u.password #=> 'blah'
+
+Also, virtual attributes can be validated just like persistent
+attributes.
+
+=== Other changes (long list!)
+
+* Added Model#reload as alias to Model#refresh.
+
+* Changed Model.create to accept a block (#126).
+
+* Fixed Model#initialize to accept nil values (#115).
+
+* Added Model#update_with_params method with support for virtual
+attributes and auto-filtering of unrelated parameters, and changed
+Model.create_with_params to support virtual attributes (#128).
+
+* Fixed Model.dataset to correctly set the dataset if using implicit
+naming or inheriting the superclass dataset (thanks celldee).
+
+* Finalized support for virtual attributes.
+
+* Fixed Model#set to work with string keys (#143).
+
+* Fixed Model.create to correctly initialize instances marked as new
+(#135).
+
+* Fixed Model#initialize to convert string keys into symbol keys. This
+also fixes problem with validating objects initialized with string
+keys (#136).
+
+* Added Dataset#table_exists? convenience method.
+
+* Changed Dataset#group_and_count to accept multiple columns (#134).
+
+* Added Dataset#select_all method.
+
+* Added Dataset#select_more, Dataset#order_more methods (#129).
+
+* Fixed Dataset#count to work correctly for grouped datasets (#144).
+
+* Fixed joining datasets using aliased tables (#140).
+
+* Added support for UNSIGNED constraint, used in MySQL? (#127).
+
+* Implemented constraint definitions inside Database#create_table.
+
+* Enhanced Database.connect to accept options with string keys, so it
+can now accept options loaded from YAML files. Database.connect also
+automatically converts :username option into :user for compatibility
+with existing YAML configuration files for AR and DataMapper.
+
+* Changed ODBC::Database to support connection using driver and
+database name, also added support for untitled columns in
+ODBC::Dataset (thanks Leonid Borisenko).
+
+* Changed MySQL adapter to support specifying socket option.
+
+* Fixed MySQL adapter to correctly format foreign key definitions
+(#123).
+
+* Changed MySQL::Dataset to allow HAVING clause on ungrouped datasets,
+and put HAVING clause before ORDER BY clause (#133).
+
+* Changed mysql adapter to default to localhost if :host option is not
+specified (#114).
+
+* Added String#to_date. Updated mysql adapter to use String#to_date
+for mysql date types (thanks drfreeze).
+
+* Fixed postgres adapter to define PGconn#async_exec as alias to #exec
+if not defined (for pure-ruby postgres driver).
+
+* Changed postgres adapter to quote column references using double
+quotes.
+
+* Applied patch for oracle adapter: fix behavior of limit and offset,
+transactions, #table_exists?, #tables and additional specs (thanks
+Liming Lian #122).
+
+* Added support additional field types in postgresql adapter (#146).
+
+* Added support for date field types in postgresql adapter (#145).
+
+* Added support for limiting and paginating datasets with fixed SQL,
+e.g. using Database#fetch.
+
+* Added new Dataset#from_self method that returns a dataset selecting
+from the original dataset.
+
+* Allow for additional filters on a grouped dataset (#119 and #120)
+
+* Refactored Sequelizer to use Proc#to_sexp (method provided by r2r).
+
+* Fixed bin/sequel to require sequel_model if available.
+

data/doc/release_notes/1.3.txt

@@ -0,0 +1,101 @@
+=== Better model associations
+
+The latest release of sequel_model includes a new associations
+functionality written by Jeremy Evans which replaces the old relations
+code in previous versions. Please note that this version is not
+completely backward-compatible and you should therefore upgrade with
+caution.
+
+The new implementation supports three kinds of relations: one_to_many,
+many_to_one and many_to_many, which correspond to has_many, belongs_to
+and has_and_belongs_to_many relations in ActiveRecord. In fact, the
+new implementation includes aliases for ActiveRecord assocation macros
+and is basically compatible with ActiveRecord conventions. It also
+supports DRY implicit class name references. Here's a simple example:
+
+  class Author < Sequel::Model
+    has_many :books # equivalent to one_to_many
+  end
+
+  class Book < Sequel::Model
+    belongs_to :author # equivalent to many_to_one
+    has_and_belongs_to_many :categories # equivalent to many_to_many
+  end
+
+  class Category < Sequel::Model
+    has_and_belongs_to_many :books
+  end
+
+These macros will create the following methods:
+
+* Author#books, Author#add_book, Author#remove_book
+* Book#author, Book#categories, Book#add_category,
+Book#remove_category
+* Category#books, Category#add_book, Category#remove_book
+
+Unlike ActiveRecord, one_to_many and many_to_many association methods
+return a dataset:
+
+  a = Author[1234]
+  a.books.sql #=> 'SELECT * FROM books WHERE (author_id = 1234)'
+
+You can also tell Sequel to cache the association result set and
+return it as an array:
+
+  class Author < Sequel::Model
+    has_many :books, :cache => true
+  end
+
+  Author[1234].books.class #=> Array
+
+You can of course bypass the defaults and specify class names and key
+names:
+
+  class Node < Sequel::Model
+    belongs_to :parent, :class => Node
+    belongs_to :session, :key => :producer_id
+  end
+
+Another useful option is :order, which sets the order for the
+association dataset:
+
+  class Author < Sequel::Model
+    has_many :books, :order => :title
+  end
+
+  Author[1234].books.sql #=> 'SELECT * FROM books WHERE (author_id =
+1234) ORDER BY title'
+
+More information about associations can be found in the Sequel
+documentation.
+
+=== Other changes
+
+* Added configuration file for running specs (#186).
+
+* Changed Database#drop_index to accept fixed arity (#173).
+
+* Changed column definition sql to put UNSIGNED constraint before
+unique in order to satisfy MySQL (#171).
+
+* Enhanced MySQL adapter to support load data local infile_, added
+compress option for mysql connection by default (#172).
+
+* Fixed bug when inserting hashes in array tuples mode.
+
+* Changed SQLite adapter to catch RuntimeError raised when executing a
+statement and raise Error::InvalidStatement with the offending SQL and
+error message (#188).
+
+* Fixed Dataset#reverse to not raise for unordered dataset (#189).
+
+* Added Dataset#unordered method and changed #order to remove order if
+nil is specified (#190).
+
+* Fixed reversing order of ASC expression (#164).
+
+* Added support for :null => true option when defining table columns
+(#192).
+
+* Fixed Symbol#method_missing to accept variable arity (#185).
+

data/doc/release_notes/1.4.0.txt

@@ -0,0 +1,53 @@
+Eager loading for all types of associations:
+
+  Artist.eager(:albums).all
+  Album.eager(:artist, :genre, :tracks).all
+  Album.eager(:artist).eager(:genre).eager(:tracks).all
+  Album.filter(:year=>2008).eager(:artist).all
+
+Eager loading supports cascading to an unlimited depth, and doesn't have
+any aliasing issues:
+
+  Artist.eager(:albums=>:tracks).all
+  Artist.eager(:albums=>{:tracks=>:genre}).all
+
+Unfortunately, eager loading comes at the expense of a small amount of
+backward compatibility.  If you were using uncached associations (the
+default in sequel_model 0.5), they no longer work the same way.  Now,
+all associations act as if :cache=>true (which is now set for all
+associations, so if you wrote a tool that worked with both cached and
+uncached associations, it should still work).
+
+One to many associations now populate the corresponding many to one
+instance variable (even when eagerly loaded):
+
+  # Assuming: Album.one_to_many :tracks
+  album = Album.first
+  # This following code is only one query,
+  # not a query for the album and one for each track
+  album.tracks.each{|t| puts t.album.name}
+
+ActiveRecord style has_many :through associations are now supported via
+many_to_many.  many_to_many will no longer select the entire result set,
+just the columns of the associated table (and not the join table), so it
+works for both has_and_belongs_to_many (simple join table) and has_many
+:through (join table model) scenarios.  If you want to include all or
+part of the join table attributes, see the :select option for
+many_to_many associations.
+
+We reduced the number of gems from three (sequel, sequel_core,
+sequel_model) to two (sequel, sequel_core).  Basically, sequel_model is
+now just sequel, and the old sequel gem metapackage is no longer.  There
+isn't a reason to have a gem metapackage for two gems when one
+(sequel_model) depends on the other (sequel_core).  This required a
+version bump for the model part of sequel from 0.5.0.2 to 1.4.0 (since
+the previous sequel gem version was 1.3).
+
+Sequel 1.4.0 has fixes for 11 trackers issues, including fixes to the
+MySQL and PostgreSQL adapters.
+
+We have switched the source control repository for Sequel from Google
+Code (which uses subversion) to github (which uses git).  If you would
+like to contribute to Sequel, please fork the github repository, make
+your changes, and send a pull request.  As before, posting patches on
+the Google Code issue tracker is fine as well.

data/doc/release_notes/1.5.0.txt

@@ -0,0 +1,155 @@
+You can now graph a dataset and have the result split into component
+tables:
+
+  DB[:artists].graph(:albums, :artist_id=>:id).first
+  # => {:artists=>{:id=>artists.id, :name=>artists.name}, \
+  # :albums=>{:id=>albums.id, :name=>albums.name,
+:artist_id=>albums.artist_id}}
+
+This aliases columns if necessary so they don't stomp on each other,
+which
+is what usually happens if you just join the tables:
+
+  DB[:artists].left_outer_join(:albums, :artist_id=>:id).first
+  # => {:id=>(albums.id||artists.id),
+:name=>(albums.name||artist.names), \
+        :artist_id=>albums.artist_id}
+
+Models can use graph as well, in which case the values will be model
+objects:
+
+  Artist.graph(Album, :artist_id=>:id)
+  # => {:artists=>#<Artist...>, :albums=>#<Album...>}
+
+Models can now eager load via .eager_graph, which will load all the
+results
+and all associations in a single query.  This is necessary if you want
+to
+filter on columns in associated tables.  It works exactly the same way
+as
+.eager, and supports cascading of associations as well:
+
+  # Artist.one_to_many :albums
+  # Album.one_to_many :tracks
+  # Track.many_to_one :genre
+  Artist.eager_graph(:albums=>{:tracks=>:genre}).filter( \
+    :tracks_name=>"Firewire").all
+
+This will give you all artists have have an album with a track named
+"Firewire", and calling .albums on one of those artists will only return
+albums that have a track named "Firewire", and calling .tracks on one of
+those albums will return only the track(s) named "Firewire".
+
+You can use set_graph_aliases to select specific columns:
+
+  DB[:artists].graph(:albums, :artist_id=>:id).set_graph_aliases( \
+    :artist_name=>[:artists, :name], :album_name=>[:albums,
+:name]).first
+  # => {:artists=>{:name=>artists.name}, :albums=>{:name=>albums.name}}
+
+You can use eager_graph with set_graph_aliases to have eager loading
+with
+control over the SELECT clause.
+
+All associations now update their reciprocal associations whenever the
+association methods are used, so you don't need to refresh the
+association or model to have the reciprocal association updated:
+
+  Album.many_to_one :band
+  Band.one_to_many :albums
+
+  # Note that all of these associations are cached,
+  # so after the first access there are no additional
+  # database queries to fetch associated records.
+
+  # many_to_one setter adds to reciprocal association
+  band1.albums # => []
+  album1.band = band1
+  band1.albums # => [album1]
+  band2.albums # => []
+  album1.band = band2
+  band1.albums # => []
+  band2.albums # => [album1]
+  album1.band = band2
+  band2.albums # => [album1]
+  album1.band = nil
+  band2.albums # => []
+
+  # one_to_many add_* method sets reciprocal association
+  # one_to_many remove_* method removes reciprocal association
+  album1.band # => nil
+  band1.add_album(album1)
+  album1.band # => band1
+  band2.add_album(album1)
+  album1.band # => band2
+  band2.remove_album(album1)
+  album1.band # => nil
+
+  Post.many_to_many :tags
+  Tag.many_to_many :posts
+
+  # many_to_many add_* method adds to reciprocal association
+  # many_to_many remove_* method removes from reciprocal association
+  post1.tags # => []
+  tag1.posts # => []
+  tag1.add_post(post1)
+  post1.tags # => [tag1]
+  tag1.posts # => [post1]
+  tag1.remove_post(post1)
+  post1.tags # => []
+  tag1.posts # => []
+  post1.add_tag(tag1)
+  post1.tags # => [tag1]
+  tag1.posts # => [post1]
+  post1.remove_tag(tag1)
+  post1.tags # => []
+  tag1.posts # => []
+
+The MySQL and PostgreSQL adapters now support index types:
+
+  index :some_column, :type => :hash # or :spatial, :full_text, :rtree,
+etc.
+
+Starting in Sequel 1.5.0, some methods are deprecated.  These methods
+will be
+removed in Sequel 2.0.0.  The deprecation framework is fairly flexible.
+You
+can choose where the messages get sent:
+
+  Sequel::Deprecation.deprecation_message_stream = STDERR # the default
+  Sequel::Deprecation.deprecation_message_stream = \
+    File.new('deprecation.txt', 'wb') # A file
+  Sequel::Deprecation.deprecation_message_stream = nil # ignore the
+messages
+
+You can even have all deprecation messages accompanied by a traceback,
+so you
+can see exactly where in your code you are using a deprecated method:
+
+  Sequel::Deprecation.print_tracebacks = true
+
+All deprecation methods come with an message telling you what
+alternative code
+will work.
+
+In addition to deprecating some methods, we removed the ability to have
+arrays returned instead of hashes.  The array code still had debugging
+messages
+left it in, and we are not aware of anyone using it.  Hashes have been
+returned
+by default since Sequel 0.3.
+
+We have also removed the Numeric date/time extensions (e.g. 3.days.ago).
+The
+existing extensions were incomplete, better ones are provided elsewhere,
+and the extensions were not really related to Sequel's purpose.
+
+Sequel no longer depends on ParseTree, RubyInline, or ruby2ruby.  They
+are
+still required to use the block filters.  Sequel's only gem dependency
+is on
+the tiny metaid.
+
+Sequel 1.5.0 has fixes for 12 tracker issues, including fixes to the
+Informix,
+MySQL, ODBC, ADO, JDBC, Postgres, and SQLite adapters.