sequel 2.10.0 → 2.11.0

data/CHANGELOG

@@ -1,3 +1,53 @@
+=== 2.11.0 (2009-03-02)
+
+* Optimize Model.[] by using static sql when possible, for a 30-40% speed increase (jeremyevans)
+
+* Add Dataset#with_sql, which returns a clone of the datatset with static SQL (jeremyevans)
+
+* Refactor Dataset#literal so it doesn't need to be overridden in subadapters, for a 20-25% performance increase (jeremyevans)
+
+* Remove SQL::IrregularFunction, no longer used internally (jeremyevans)
+
+* Allow String#lit to take arguments and return a SQL::PlaceholderLiteralString (jeremyevans)
+
+* Add Model#set_associated_object, used by the many_to_one setter method, for easier overriding (jeremyevans)
+
+* Allow use of database independent types when casting (jeremyevans)
+
+* Give association datasets knowledge of the model object that created them and the related association reflection (jeremyevans)
+
+* Make Dataset#select, #select_more, #order, #order_more, and #get take a block that yields a SQL::VirtualRow, similar to #filter (jeremyevans)
+
+* Fix stored procedures in MySQL adapter when multiple arguments are used (clivecrous)
+
+* Add :conditions association option, for easier filtering of associated objects (jeremyevans)
+
+* Add :clone association option, for making clones of existing associations (jeremyevans)
+
+* Handle typecasting invalid date strings (and possible other types) correctly (jeremyevans)
+
+* Add :compress=>false option to MySQL adapter to turn off compression of client-server connection (tmm1)
+
+* Set SQL_AUTO_IS_NULL=0 on MySQL connections, disable with :auto_is_null=>false (tmm1)
+
+* Add :timeout option to MySQL adapter, default to 30 days (tmm1)
+
+* Set MySQL encoding using Mysql#options so it works across reconnects (tmm1)
+
+* Fully support blobs on SQLite (jeremyevans)
+
+* Add String#to_sequel_blob, alias String#to_blob to that (jeremyevans)
+
+* Fix default index names when a non-String or Symbol column is used (jeremyevans)
+
+* Fix some ruby -w warnings (jeremyevans) (#259)
+
+* Fix issues with default column values, table names, and quoting in the rename_column and drop_column support in shared SQLite adapter (jeremyevans)
+
+* Add rename_column support to SQLite shared adapter (jmhodges)
+
+* Add validates_inclusion_of validation (jdunphy)
+
 === 2.10.0 (2009-02-03)
 
 * Don't use a default schema any longer in the shared PostgreSQL adapter (jeremyevans)
@@ -68,7 +118,7 @@
 
 * Fix add_foreign_key for MySQL (jeremyevans, aphyr)
 
-* Correctly literalize BigDecimal NaN and (+-)Infinity values (#256) (jeremyevans)
+* Correctly literalize BigDecimal NaN and (+-)Infinity values (jeremyevans) (#256)
 
 * Make Sequel raise an Error if you attempt to subclass Sequel::Model before setting up a database connection (jeremyevans)
 

data/README.rdoc

@@ -228,7 +228,7 @@ You can also specify a custom WHERE clause using a string:
 You can use parameters in your string, as well (ActiveRecord style):
 
   posts.filter('(stamp < ?) AND (author != ?)', Date.today - 3, author_name)
-  posts.filter{|o| (o.stamp < Date.today + 3) & ~{:author => author_name}} # same as above
+  posts.filter{|o| (o.stamp < Date.today - 3) & ~{:author => author_name}} # same as above
 
 Datasets can also be used as subqueries:
 
@@ -369,7 +369,7 @@ Models in Sequel are based on the Active Record pattern described by Martin Fowl
 
 Model classes are defined as regular Ruby classes:
 
-  DB = Sequel.connect('sqlite:/blog.db')
+  DB = Sequel.connect('sqlite://blog.db')
   class Post < Sequel::Model
   end
 

data/Rakefile

@@ -28,7 +28,7 @@ spec = Gem::Specification.new do |s|
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"]
+  s.extra_rdoc_files = ["README.rdoc", "CHANGELOG", "COPYING"] + Dir["doc/*.rdoc"] + Dir['doc/release_notes/*.txt']
   s.rdoc_options += RDOC_OPTS
   s.summary = "The Database Toolkit for Ruby"
   s.description = s.summary
@@ -73,7 +73,7 @@ end
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = "rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/**/*.rb doc/*.rdoc"
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/**/*.rb doc/*.rdoc doc/release_notes/*.txt"
 end
 
 ### Website

data/doc/advanced_associations.rdoc

@@ -152,11 +152,15 @@ otherwise modified:
   end
   Author.first.authorships_dataset.filter{|o| o.number < 10}.first
  
-You can extend a dataset with a module easily with :extend:
+You can extend a dataset with a module easily with :extend.  You can reference
+the model object that created the association dataset via the dataset's
+model_object method, and the related association reflection via the dataset's
+association_reflection method:
 
   module FindOrCreate
     def find_or_create(vals)
-      first(vals) || @opts[:models][nil].create(vals)
+      first(vals) || association_reflection.associated_class. \
+        create(vals.merge(association_reflection[:key]=>model_object.id))
     end
   end
   class Author < Sequel::Model
@@ -164,22 +168,6 @@ You can extend a dataset with a module easily with :extend:
   end
   Author.first.authorships_dataset.find_or_create(:name=>'Blah', :number=>10)
 
-However, note that the dataset doesn't have any knowledge of the model object
-that created it via the association, so if you want to use attributes of the
-model object, you'll have to use a closure:
-
-  class Author < Sequel::Model
-    one_to_many :authorships, :dataset=>(proc do
-      key = pk
-      ds = Authorship.filter(:author_id=>key)
-      ds.meta_def(:find_or_create_by_name) do |name|
-        first(:name=>name) || Authorship.create(:name=>name, :author_id=>key)
-      end 
-      ds  
-    end)
-  end
-  Author.first.authorships_dataset.find_or_create_by_name('Bob')
-
 ===has_many :through associations
 
 many_to_many handles the usual case of a has_many :through with a belongs_to in

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.