sequel 3.9.0 → 3.10.0

data/CHANGELOG

@@ -1,3 +1,59 @@
+=== 3.10.0 (2010-04-02)
+
+* Make one_to_one setter and *_to_many remove_all methods apply the association options (jeremyevans)
+
+* Make nested_attributes plugin handle invalid many_to_one associations better (john_firebaugh)
+
+* Remove private methods from Sequel::BasicObject on ruby 1.8 (i.e. most Kernel methods) (jeremyevans)
+
+* Add Sequel::BasicObject.remove_methods!, useful on 1.8 if libraries required after Sequel add methods to Object (jeremyevans)
+
+* Change Sequel.connect with a block to return the block's value (jonas11235)
+
+* Add an rcte_tree plugin, which uses recursive common table expressions for loading trees stored as adjacency lists (jeremyevans)
+
+* Make typecast_on_load plugin also typecast when refreshing the object (either explicitly or implicitly after creation) (jeremyevans)
+
+* Fix schema parsing and dumping of tinyint columns when connecting to MySQL via the do adapter (ricardochimal)
+
+* Fix transactions when connecting to Oracle via JDBC (jeremyevans)
+
+* Fix plugin loading when plugin module name is the same as an already defined top level constant (jeremyevans)
+
+* Add an AS400 JDBC subadapter (need jt400.jar in classpath) (jeremyevans, bhauff)
+
+* Fix the emulated MSSQL offset support when core extensions are not used (jeremyevans)
+
+* Make Sequel::BasicObject work correctly on Rubinius (kronos)
+
+* Add the :eager_loader_key option to associations, useful for custom eager loaders (jeremyevans)
+
+* Dataset#group_and_count no longer orders by the count (jeremyevans)
+
+* Fix Dataset#limit on MSSQL 2000 (jeremyevans)
+
+* Support eagerly load nested associations when lazily loading *_to_one associations using the :eager option (jeremyevans)
+
+* Fix the one_to_one setter to work with a nil argument (jeremyevans)
+
+* Cache one_to_one associations like many_to_one associations instead of one_to_many associations (jeremyevans)
+
+* Use the singular form for one_to_one association names instead of the plural form (john_firebaugh)
+
+* Add real one_to_one associations, using the :one_to_one option of one_to_many is now an error (jeremyevans)
+
+* Add Model#lock! which uses Dataset#for_update to lock model rows (jeremyevans)
+
+* Add Dataset#for_update as a standard dataset method (jeremyevans)
+
+* Add composition plugin, simlar to ActiveRecord's composed_of (jeremyevans)
+
+* Combine multiple complex expressions for simpler SQL and object tree (jeremyevans)
+
+* Add Dataset#first_source_table, for the unaliased version of the table for the first source (jeremyevans)
+
+* Raise a more explicit error if attempting to use the sqlite adapter with sqlite3 instead of sqlite3-ruby (jeremyevans)
+
 === 3.9.0 (2010-03-04)
 
 * Allow loading adapters and extensions from outside of the Sequel lib directory (jeremyevans)

data/README.rdoc

@@ -112,7 +112,7 @@ The connection URL can also include such stuff as the user name and password:
 You can also specify optional parameters, such as the connection pool size, or loggers for logging SQL queries:
 
   DB = Sequel.connect("postgres://postgres:postgres@localhost/my_db",
-    :max_connections => 10, :loggers => [Logger.new('log/db.log']))
+    :max_connections => 10, :logger => Logger.new('log/db.log'))
 
 You can specify a block to connect, which will disconnect from the database after it completes:
 

data/Rakefile

@@ -59,7 +59,7 @@ task :website_rdoc=>[:website_rdoc_main, :website_rdoc_adapters, :website_rdoc_p
 Rake::RDocTask.new(:website_rdoc_main) do |rdoc|
   rdoc.rdoc_dir = "www/public/rdoc"
   rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/*.rb lib/sequel/*.rb lib/sequel/{dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt"
+  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG COPYING lib/*.rb lib/sequel/*.rb lib/sequel/{connection_pool,dataset,database,model}/*.rb doc/*.rdoc doc/release_notes/*.txt"
 end
 
 Rake::RDocTask.new(:website_rdoc_adapters) do |rdoc|

data/doc/advanced_associations.rdoc

@@ -114,10 +114,13 @@ a swiss army chainsaw.
 
 === Association callbacks
 
-Sequel supports the same callbacks that ActiveRecord does: :before_add,
-:before_remove, :after_add, and :after_remove. It also supports a
-callback that ActiveRecord does not, :after_load, which is called
-after the association has been loaded.
+Sequel supports the same callbacks that ActiveRecord does on one_to_many and
+many_to_many associations: :before_add, :before_remove, :after_add, and
+:after_remove. One many_to_one associations and one_to_one associations
+(which are one_to_many associations with the :one_to_one option), Sequel
+supports the :before_set and :after_set callbacks.  On all associations,
+Sequel supports :after_load, which is called after the association has been
+loaded.
 
 Each of these options can be a Symbol specifying an instance method
 that takes one argument (the associated object), or a Proc that takes
@@ -129,12 +132,6 @@ If any of the before callbacks return false, the adding/removing
 does not happen and it either raises an error (the default), or
 returns nil (if raise_on_save_failure is false).
 
-All callbacks are also run on many_to_one associations.  If there
-was already an existing object for the association, it calls the
-remove callbacks on the existing object and the add callbacks on the
-new object.  The remove callback calls are placed around the add
-callback calls.
-
 === Association extensions
 
 All associations come with an association_dataset method that can be further filtered or

data/doc/release_notes/3.10.0.txt

@@ -0,0 +1,286 @@
+New Features
+------------
+
+* A real one_to_one association was added to Sequel, replacing the
+  previous :one_to_one option of the one_to_many association.
+  
+  This is a fully backwards incompatible change, any code that uses
+  the :one_to_one option of one_to_many will be broken in Sequel
+  3.10.0, as that option now raises an exception.  Keeping backwards
+  compatibility was not possible, as even the name of the association
+  needs to be changed.  Here are the code changes you need to make:
+  
+  * The association definition needs to change from one_to_many to
+    one_to_one, with no :one_to_one option, and with the association
+    name changed from the plural form to the singular form:
+    
+      # Before
+      Lyric.one_to_many :songs, :one_to_one=>true
+      # After
+      Lyric.one_to_one :song
+      
+  * All usage of the association when eager loading or when getting
+    reflections need to use the new singular association name:
+    
+      # Before
+      Lyric.eager(:songs).all
+      Lyric.eager_graph(:songs).all
+      Lyric.association_reflection(:songs)
+      # After
+      Lyric.eager(:song).all
+      Lyric.eager_graph(:song).all
+      Lyric.association_reflection(:song)
+      
+  Any Sequel plugins or extensions that deal with the internals of
+  associations need to be made aware of the one_to_one association,
+  and how it is different than one_to_many's previous :one_to_one
+  option.  Here are some internal changes that may affect you:
+  
+  * one_to_one associations are now cached like many_to_one
+    associations instead of like one_to_many associations.  So the
+    cache includes the associated object or nil, instead of an array.
+    Note that this change means that all custom :eager_loader options
+    for one_to_one associations need to change to use this new
+    caching scheme.
+    
+  * The one_to_one association setter method is now handled similarly
+    to the many_to_one setter method, instead of using the internal
+    one_to_many association add method.
+    
+  * Instead of raising an error when multiple rows are returned,
+    one_to_one associations now use limit(1) to only return a single
+    row.
+    
+  There were some other fixes made during these changes:
+  
+  * The one_to_one setter now accepts nil to disassociate the record.
+    Previously, this raised an error.
+    
+  * If the one_to_one association already had a separate object
+    associated, and you assigned a different object in the setter
+    method, Sequel now disassociates the old object before
+    associating the new object, fixing some potential issues if there
+    is a UNIQUE constraint on the foreign key column.
+    
+  * Using the many_to_one association setter where the reciprocal
+    association is a one_to_one association with a currently
+    different cached associated object no longer raises an exception.
+  
+  * The nested_attributes and association_dependencies plugins
+    both now correctly handle one_to_one associations.
+
+  If you need any help migrating, please post on the Sequel Google
+  Group or ask in the #sequel IRC channel.
+
+* Both many_to_one and one_to_one associations now use before_set
+  and after_set callbacks instead of trying to make the one_to_many
+  and many_to_many associations' (before|after)_(add|remove)
+  callbacks work.
+  
+  This change makes the code simpler, makes writing callbacks easier,
+  and no longer requires Sequel to send a query to the database to
+  get the currently associated object in the many_to_one association
+  setter method (you can still do so manually in a before_set
+  callback if you want to).
+  
+* Dataset#for_update was added as a default dataset method.
+  Previously, it was only supported on PostgreSQL.  It has been
+  tested to work on PostgreSQL, MySQL, SQLite (where it is ignored),
+  H2, and MSSQL.
+  
+* Dataset#lock_style was added as a backbone for Dataset#for_update,
+  but allowing you to specify custom lock styles.  These can either
+  be symbols recognized by the adapters, or strings which are treated
+  as literal SQL.
+
+* Model#lock! was added, which uses Dataset#for_update to lock model
+  rows for specific instances.  Combined with the Dataset#for_update,
+  Sequel now has an equivalent to ActiveRecord's pessimistic locking
+  support.
+
+* A composition plugin was added, given similar functionality as
+  ActiveRecord's composed_of.
+  
+  The composition plugin allows you to easily define getter and
+  setter instance methods for a class where the backing data is
+  composed of other getters and decomposed to other setters.
+
+  A simple example of this is when you have a database table with
+  separate columns for year, month, and day, but where you want to
+  deal with Date objects in your ruby code.  This can be handled
+  with:
+
+    Model.composition :date, :mapping=>[:year, :month, :day]
+
+  The :mapping option is optional, but if not used, you need define
+  custom composition and decomposition procs via the :composer and
+  :decomposer options.
+
+  Note that when using the composition object, you should not modify
+  the underlying columns if you are also instantiating the
+  composition, as otherwise the composition object values will
+  override any underlying columns when the object is saved.
+
+* An rcte_tree plugin was added, which uses recursive common table
+  expressions to load all ancestors and descendants in a single
+  query.  If your database supports recursive common table
+  expressions (PostgreSQL 8.4+, MSSQL 2005+, newer versions of
+  Firebird), using recursive common table expressions to load
+  all ancestors and descendants is significantly faster than storing
+  trees as nested sets and using nested set queries.  Usage:
+  
+    Model.plugin :rcte_tree
+   
+    # Lazy loading
+    model = Model.first
+    model.parent
+    model.children
+    model.ancestors # Populates :parent association as well
+    model.descendants # Populates :children association as well
+   
+    # Eager loading - also populates the :parent and children 
+    # associations for all ancestors and descendants
+    Model.filter(:id=>[1, 2]).eager(:ancestors, :descendants).all
+   
+    # Eager loading children and grandchildren
+    Model.filter(:id=>[1, 2]).eager(:descendants=>2).all
+    # Eager loading children, grandchildren, and great grandchildren
+    Model.filter(:id=>[1, 2]).eager(:descendants=>3).all
+
+* Dataset#first_source_table was added, giving you the unaliased
+  version of the table for the first source.
+
+* Add Sequel::BasicObject.remove_methods!, useful on ruby 1.8 if you
+  require other libraries after Sequel that add methods to Object.
+  For example, if YAML is required after sequel, then the following
+  will raise an error:
+  
+    DB[:a].filter{x > y}
+    
+  because YAML adds the y method to all objects.  Now, you can call
+  Sequel::BasicObject.remove_methods!, which will remove those
+  methods from Sequel::BasicObject, allowing them to be used as
+  intended in the above DSL.
+
+* Sequel associations now accept an :eager_loader_key option, which
+  can be useful for associations to specify the column to use for the
+  key_hash for custom :eager_loaders.
+
+* A JDBC subadapter for the AS400 database was added.
+
+Other Improvements
+------------------
+
+* The one_to_one setter method and the one_to_many and many_to_many
+  remove_all methods now apply the association options (such as
+  filters) on the appropriate dataset:
+  
+    Artist.one_to_many :good_albums, :class=>:Album,
+     :conditions=>{:good=>true}
+    a = Artist[10]
+    a.remove_all_good_albums
+    # Before: WHERE artist_id = 10
+    # After:  WHERE artist_id = 10 AND good IS TRUE
+
+* Plugin loading now works correctly when the plugin module name
+  is the same name as an already defined top level constant.  This
+  means that the active_model plugin should now work correctly if
+  you require active_model before loading the Sequel plugin.
+
+* The nested_attributes plugin now preserves nested attributes for
+  *_to_one associations on validation failures.
+
+* Transactions now work correctly on Oracle when using the JDBC
+  adapter.
+  
+* Dataset#limit once again works correctly on MSSQL 2000.  It was
+  broken in Sequel 3.9.0.
+
+* many_to_one associations now use limit(1) to ensure only one
+  record is returned.  If you don't want this (because maybe you
+  are using the :eager_graph association option), you need to
+  set the :key option to nil and use a custom :dataset option.
+  
+* many_to_one and one_to_many associations now work correctly
+  with the association :eager option to eagerly load associations
+  specified by :eager when lazy loading the association.
+
+* The typecast_on_load plugin now correctly handles
+  reloading/refreshing the object, both explicitly and implicitly
+  on object creation.
+
+* The schema parser and dumper now return tinyint columns as
+  booleans when connecting to mysql using the do adapter, since
+  DataObjects now returns the columns as booleans.
+  
+* The schema dumper now deals better with unusual or database
+  specific primary key types when using the :same_db option.
+
+* On ruby 1.8, Sequel::BasicObject now undefs private methods in
+  addition to public and protected methods.  So the following
+  code now works as expected:
+  
+    DB[:a].filter{x > p} # WHERE x > p
+    
+* Sequel.connect with a block now returns the value of the block:
+
+    max_price = Sequel.connect('sqlite://items.db') do |db|
+      db[:items].max(:price)
+    end
+    
+* MSSQL emulated offset support now works correctly when Sequel's
+  core extensions are not loaded.
+  
+* Sequel::BasicObject now works correctly on rubinius, and almost
+  all Sequel specs now pass on rubinius.
+  
+* The nested_attributes plugin now uses a better exception message
+  no matching associated object is found.
+  
+* Sequel now raises a more informative error if you attempt to use
+  the native sqlite adapter with the sqlite3 gem instead of the
+  sqlite3-ruby gem.
+  
+* Multiple complex expressions with the same operator are now
+  combined for simpler SQL:
+  
+    DB[:a].filter(:a=>1, :b=>2).filter(:c=>3)
+    # Before: (((a = 1) AND (b = 2)) AND (c = 3))
+    # After:  ((a = 1) AND (b = 2) AND (c = 3))
+  
+* The Sequel::Model dataset methods (class methods proxied to the
+  model's dataset) and the Sequel::Dataset mutation methods
+  (methods that have a ! counterpart to modify the object in place)
+  have both been updated to use new dataset methods added in recent
+  versions.
+
+Backwards Compatibility
+-----------------------
+
+* The :one_to_one option of the one_to_many associations now raises
+  an exception.  Please see the section above about the new real
+  one_to_one association.
+
+* The change to apply the association options to the one_to_many and
+  many_to_many remove_all methods has the potential to break some
+  code that uses the remove_all method on associations that use
+  association options. This is especially true for many_to_many
+  associations, as filters in many_to_many associations will often
+  reference columns in the associated table, while the dataset
+  used in the remove_all method only contains the join table.  Such
+  cases should be handled by manually overriding the _remove_all
+  association instance method in the class.  It was determined that
+  it was better to issue possibly invalid queries than to issue
+  queries that make unexpected modifications.
+
+* Dataset#group_and_count now longer orders the dataset by the count.
+  Since it returns a modified dataset, if you want to order the
+  dataset, just call order on the returned dataset.
+
+* many_to_one associations now require a working :class option.
+  Previously, if you provided a custom :dataset option, a working
+  :class option was not required in some cases.
+
+* The MSSQL shared adapter dataset methods switched from using
+  the :table_options internal option key to using the :lock internal
+  option key.

data/lib/sequel/adapters/do/mysql.rb

@@ -22,6 +22,10 @@ module Sequel
         def database_name
           (m = /\/(.*)/.match(URI.parse(uri).path)) && m[1]
         end
+
+        def schema_column_type(db_type)
+          db_type == 'tinyint(1)' ? :boolean : super
+        end
       end
       
       # Dataset class for MySQL datasets accessed via DataObjects.

data/lib/sequel/adapters/jdbc.rb

@@ -67,6 +67,11 @@ module Sequel
         db.extend(Sequel::JDBC::H2::DatabaseMethods)
         JDBC.load_gem('h2')
         org.h2.Driver
+      end,
+      :as400=>proc do |db|
+        Sequel.ts_require 'adapters/jdbc/as400'
+        db.extend(Sequel::JDBC::AS400::DatabaseMethods)
+        com.ibm.as400.access.AS400JDBCDriver
       end
     }
     

data/lib/sequel/adapters/jdbc/as400.rb

@@ -0,0 +1,58 @@
+module Sequel
+  module JDBC
+    # Database and Dataset support for AS400 databases accessed via JDBC.
+    module AS400
+      # Instance methods for AS400 Database objects accessed via JDBC.
+      module DatabaseMethods
+        # AS400 uses the :as400 database type.
+        def database_type
+          :as400
+        end
+
+        # Return Sequel::JDBC::AS400::Dataset object with the given opts.
+        def dataset(opts=nil)
+          Sequel::JDBC::AS400::Dataset.new(self, opts)
+        end
+
+        # TODO: Fix for AS400
+        def last_insert_id(conn, opts={})
+          nil
+        end
+      end
+      
+      # Dataset class for AS400 datasets accessed via JDBC.
+      class Dataset < JDBC::Dataset
+        WILDCARD = Sequel::LiteralString.new('*').freeze
+        
+        # AS400 needs to use a couple of subselects for all limits and offsets.
+        def select_sql
+          return super unless l = @opts[:limit]
+          o = @opts[:offset] || 0
+          order = @opts[:order]
+          dsa1 = dataset_alias(1)
+          dsa2 = dataset_alias(2)
+          rn = row_number_column
+          irn = Sequel::SQL::Identifier.new(rn).qualify(dsa2)
+          subselect_sql(unlimited.
+            from_self(:alias=>dsa1).
+            select_more(Sequel::SQL::QualifiedIdentifier.new(dsa1, WILDCARD),
+              Sequel::SQL::WindowFunction.new(SQL::Function.new(:ROW_NUMBER), Sequel::SQL::Window.new(:order=>order)).as(rn)).
+            from_self(:alias=>dsa2).
+            select(Sequel::SQL::QualifiedIdentifier.new(dsa2, WILDCARD)).
+            where((irn > o) & (irn <= l + o)))
+        end
+          
+        def supports_window_functions?
+          true
+        end
+          
+        private
+        
+        # The alias to use for the row_number column when emulating LIMIT and OFFSET
+        def row_number_column
+          :x_sequel_row_number_x
+        end
+      end
+    end
+  end
+end