sequel 3.47.0 → 3.48.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 145949fd1421f21d5a6f4c980bb3c68ad9d79cbc
-  data.tar.gz: 26ae6dfbcb667675caa5b2de7d89a63472fc1c62
+  metadata.gz: 339910a226e23b822c21d4ed5c0ec1b656e02c42
+  data.tar.gz: 62b3fc6e7c75d5edb560b97e9cccd4824c59fe3d
 SHA512:
-  metadata.gz: 05bf4a0d1b5ec9b9870a7544e56971ddfbba7c244f909a8fb1acdd035463ba4b05a587f81a492c8f38adb53bc2c8e6b9d5faac7194de563fa29e0ecf2482ea93
-  data.tar.gz: 456c3859c61bba059d5ff24dcb0dc3ea79984c919ec1f0e38ef0f7f63a2b94e86d2fd6ab15ed0e7283860509ba081beb2a0f5322bf650f18277ff67b9d720c7a
+  metadata.gz: a594024cffd3c08ef06a75e249faf27d86296164f882e56d9f01969078ac918362112422df36af749d35c05cc6b93de0555d282f5a3d2ac1ae2336c89d3cb475
+  data.tar.gz: 4f500ea855dc1bb0cc2733e17a5016deeaeafa353a067bebe6dfd2601a0822da4e5f71673d13e69eebd0daed5186d20a9caa4f35feb608aac0c8a2a379b76867

data/CHANGELOG

@@ -1,3 +1,233 @@
+=== 3.48.0 (2013-06-01)
+
+* Make named_timezones extension usable by databases allowing timezone strings to be given to Database#timezone= (jeremyevans)
+
+* Make Dataset#or just clone if given an empty argument (jeremyevans)
+
+* Deprecated using a mismatched number of placeholders and arguments in a placeholder literal string (jeremyevans)
+
+* Add Dataset#qualify_to and #qualify_to_first_source to sequel_3_dataset_methods extension (jeremyevans)
+
+* Add scissors plugin for Model.update, .delete, and .destroy (jeremyevans)
+
+* Validate against explicit nil values in NOT NULL columns with default values in the auto_validations plugin (jeremyevans)
+
+* Support :not_null=>:presence option for auto_validations plugin, for using presence validation for not null columns (jeremyevans)
+
+* Rename auto_validate_presence_columns to auto_validate_not_null_columns (jeremyevans)
+
+* Make pg_hstore_ops extension integrate with pg_array, pg_hstore, and pg_array_ops extensions (jeremyevans)
+
+* Add Sequel.json_parser_error_class and Sequel.object_to_json to allow the use of alternative JSON implementations (jeremyevans) (#662)
+
+* Deprecate JSON.create_id usage in the json_serializer plugin (jeremyevans)
+
+* Emulate offsets on Microsoft Access using reverse orders and total counts (jeremyevans) (#661)
+
+* Make ado adapter handle disconnecting an already disconnected connection (jeremyevans)
+
+* Deprecate parsing columns for the same table name in multiple schemas on jdbc (jeremyevans)
+
+* Allow association_proxies plugin to accept a block to give user control over which methods are proxied to the dataset (jeremyevans) (#660)
+
+* Deprecate calling Dataset#add_graph_aliases before #graph or #set_graph_aliases (jeremyevans)
+
+* Deprecate Model.add_graph_aliases, .insert_multiple, .query, .set_overrides, .set_defaults, .to_csv, and .paginate (jeremyevans)
+
+* Add guide for ordering code with Sequel (jeremyevans)
+
+* Deprecate Database#transaction :disconnect=>:retry option (jeremyevans)
+
+* Deprecate Model.set, .update, .delete, and .destroy (jeremyevans)
+
+* Deprecate Dataset#set (jeremyevans)
+
+* Add specs for bin/sequel (jeremyevans)
+
+* Make constraint_validations plugin reflect validations by column (jeremyevans)
+
+* Allow for per-model/per-validation type customization of validation options in constraint_validations plugin (jeremyevans)
+
+* Make Database#constraint_validations in the constraint_validations plugin have raw row values (jeremyevans)
+
+* Fix statement freeing in the ibmdb adapter (jeremyevans)
+
+* Make single and class table inheritance plugins handle usage of set_dataset in a subclass (jeremyevans)
+
+* Allow validates_schema_types in validation_helpers plugin accept an options hash (jeremyevans)
+
+* Deprecate Model.set_primary_key taking multiple arguments (jeremyevans)
+
+* Make auto_validations plugin work with databases that don't support index parsing (jeremyevans)
+
+* Model classes will no longer call Database#schema if it isn't supported (jeremyevans)
+
+* Speed up Model.with_pk and with_pk! class methods (jeremyevans)
+
+* Speed up Dataset#clone when called without an argument (jeremyevans)
+
+* Deprecate Postgres::PGRangeOp#{starts_before,ends_after} (jeremyevans)
+
+* Deprecate global use of null_dataset, pagination, pretty_table, query, select_remove, schema_caching, schema_dumper, and to_dot extensions (jeremyevans)
+
+* Deprecate Dataset.introspect_all_columns in the columns_introspection extension (jeremyevans)
+
+* Add empty_array_ignore_nulls extension for ignoring null handling for IN/NOT with an empty array (jeremyevans)
+
+* Deprecate Sequel.empty_array_handle_nulls accessor (jeremyevans)
+
+* Deprecate Sequel.{k,ts,tsk}_require and Sequel.check_requiring_thread (jeremyevans)
+
+* Discontinue use of manual thread-safe requiring (jeremyevans)
+
+* Deprecate using an unsupported client_min_messages setting on PostgreSQL (jeremyevans)
+
+* Deprecate passing non-hash 4th argument to Dataset#join_table (jeremyevans)
+
+* Deprecate passing non-hash 2nd argument to Dataset#union/intersect/except (jeremyevans)
+
+* Deprecate one_to_many with :one_to_one option raising an error (jeremyevans)
+
+* Automatically typecast hash and array to string for string columns in the looser_typecasting extension (jeremyevans)
+
+* Deprecate automatic typecasting of hash and array to string for string columns (jeremyevans)
+
+* Deprecate :eager_loader and :eager_grapher association options getting passed 3 separate arguments (jeremyevans)
+
+* Deprecate validates_not_string (jeremyevans)
+
+* Deprecate casting via __type suffix for prepared type placeholders in the postgres adapter (jeremyevans)
+
+* Deprecate json_serializer's Model.json_create (jeremyevans)
+
+* Deprecate json_serializer from_json and xml_serializer from_xml :all_columns and :all_associations options (jeremyevans)
+
+* Deprecate passing an unsupported lock mode to Dataset#lock on PostgreSQL (jeremyevans)
+
+* Deprecate Model::InstanceMethods.class_attr_{overridable,reader} (jeremyevans)
+
+* Deprecate all methods in Dataset::PUBLIC_APPEND_METHODS except for literal, quote_identifier, quote_schema_table (jeremyevans)
+
+* Deprecate all methods in Dataset::PRIVATE_APPEND_METHODS (jeremyevans)
+
+* Deprecate Dataset.def_append_methods (jeremyevans)
+
+* Deprecate Dataset#table_ref_append (jeremyevans)
+
+* Deprecate SQL::Expression#to_s taking an argument and returning a literal SQL string (jeremyevans)
+
+* Deprecate creating Model class methods automatically from plugin public dataset methods (jeremyevans)
+
+* Add Sequel.cache_anonymous_models accessor (jeremyevans)
+
+* Deprecate Sequel::Model.cache_anonymous_models accessor (jeremyevans)
+
+* Deprecate identity_map plugin (jeremyevans)
+
+* Deprecate Model#set_values (jeremyevans)
+
+* Deprecate pg_auto_parameterize and pg_statement_cache extensions (jeremyevans)
+
+* Deprecate Model#pk_or_nil (jeremyevans)
+
+* Deprecate Model.print and Model.each_page (jeremyevans)
+
+* Deprecate Dataset checking that the Database implements the identifier mangling methods (jeremyevans)
+
+* Deprecate Database#reset_schema_utility_dataset private method (jeremyevans)
+
+* Speed up Database#fetch, #from, #select, and #get by using a cached dataset (jeremyevans)
+
+* Make sure adapters with subadapters have fully initialized database instances before calling Database.after_initialize (jeremyevans)
+
+* Set identifier mangling methods on Database initialization (jeremyevans)
+
+* Switch internal use of class variables to instance variables (jeremyevans)
+
+* Deprecate passing an options hash to Database#dataset or Dataset.new (jeremyevans)
+
+* Speed up Dataset#clone (jeremyevans)
+
+* Add sequel_3_dataset_methods extension for Dataset#[]=, #insert_multiple, #set, #to_csv, #db=, and #opts= (jeremyevans)
+
+* Deprecate Dataset#[]=, #insert_multiple, #to_csv, #db=, and #opts= (jeremyevans)
+
+* Add blacklist_security plugin for Model.restricted_columns, Model.set_restricted_columns, Model#set_except, and Model#update_except (jeremyevans)
+
+* Deprecate Model.restricted_columns, Model.set_restricted_columns, Model#set_except, and Model#update_except (jeremyevans)
+
+* Deprecate Database#default_schema (jeremyevans)
+
+* Deprecate Sequel::NotImplemented and defining methods that raise it (jeremyevans)
+
+* Add Database#supports_{index_parsing,foreign_key_parsing,table_listing,view_listing}? (jeremyevans)
+
+* Deprecate Sequel.virtual_row_instance_eval accessor (jeremyevans)
+
+* Deprecate sequel_core.rb and sequel_model.rb (jeremyevans)
+
+* Add graph_each extension for Dataset#graph_each (jeremyevans)
+
+* Deprecate Dataset#graph_each (jeremyevans)
+
+* Add set_overrides extension for Dataset#set_overrides and #set_defaults (jeremyevans)
+
+* Deprecate Dataset#set_overrides and #set_defaults (jeremyevans)
+
+* Deprecate Database#query in the informix adapter (jeremyevans)
+
+* Deprecate Database#do as an alias to execute/execute_dui in some adapters (jeremyevans)
+
+* Deprecate modifying initial Dataset hash if the hash wasn't provided as an argument (jeremyevans)
+
+* Make active_model plugin use an errors class with autovivification (jeremyevans)
+
+* Deprecate Model::Errors#[] autovivification (returning empty array when missing) (jeremyevans)
+
+* Add Model#errors_class private method for choosing the errors class on a per-model basis (jeremyevans)
+
+* Add after_initialize plugin for the after_initialize hook (jeremyevans)
+
+* Deprecate Model after_initialize hook (jeremyevans)
+
+* Deprecate passing two arguments to Model.new (jeremyevans)
+
+* Deprecate choosing reciprocal associations with conditions, blocks, or differing primary keys (jeremyevans)
+
+* Deprecate choosing first from ambiguous reciprocal associations (jeremyevans)
+
+* Deprecate validates_type allowing nil values by default (jeremyevans)
+
+* Deprecate the correlated_subquery eager limit strategy (jeremyevans)
+
+* Add hash_aliases extension for making Dataset#select and #from treat hashes as alias specifiers (jeremyevans)
+
+* Deprecate having Dataset#select and #from treat hashes as alias specifiers (jeremyevans)
+
+* Do not automatically convert virtual row block return values to arrays by some Dataset methods (jeremyevans)
+
+* Add filter_having extension for making Dataset#{and,filter,exclude,or} affect the HAVING clause if present (jeremyevans)
+
+* Deprecate Dataset#select_more meaning Dataset#select when called without an existing selection (jeremyevans)
+
+* Deprecate Dataset#and, #or, and #invert raising exceptions for no existing filter (jeremyevans)
+
+* Deprecate Dataset#{and,filter,exclude,or} affecting the HAVING clause (jeremyevans)
+
+* Deprecate passing explicit columns to update as separate arguments to Model#save (jeremyevans)
+
+* Allow specifying explicit columns to update in Model#save via the :columns option (jeremyevans)
+
+* Add ability set the default for join_table's :qualify option via Dataset#default_join_table_qualification (jeremyevans)
+
+* Deprecated :root=>true meaning :root=>:both in the json_serializer (jeremyevans)
+
+* Deprecate core extension usage if the core_extensions have not been explicitly loaded (jeremyevans)
+
+* Deprecate Symbol#{[],<,<=,>,>=} methods when using the core_extensions (jeremyevans)
+
+* Add ruby18_symbol_extensions extension for the Symbol#{[],<,<=,>,>=} methods (jeremyevans)
+
 === 3.47.0 (2013-05-01)
 
 * Don't fail for missing conversion proc in pg_typecast_on_load plugin (jeremyevans)

data/README.rdoc

@@ -39,7 +39,6 @@ If you have any comments or suggestions please post to the Google group.
   
 == A Short Example
 
-  require 'rubygems'
   require 'sequel'
   
   DB = Sequel.sqlite # memory database
@@ -122,6 +121,15 @@ You can specify a block to connect, which will disconnect from the database afte
 
   Sequel.connect('postgres://user:password@host:port/database_name'){|db| db[:posts].delete}
 
+=== The DB convention
+
+Throughout Sequel's documentation, you will see the +DB+ constant used to refer to the Sequel::Database instance you create.
+This reflects the recommendation that for an app with a single Sequel::Database instance, the Sequel convention is to store
+the instance in the +DB+ constant.  This is just a convention, it's not required, but it is recommended.
+
+Note that some frameworks that use Sequel may create the Sequel::Database instance for you, and you might not know
+how to access it.  In most cases, you can access the Sequel::Database instance through <tt>Sequel::Model.db</tt>.
+
 === Arbitrary SQL queries
 
 You can execute arbitrary SQL code using <tt>Database#run</tt>:
@@ -363,7 +371,7 @@ Updating records in the table is done with +update+:
 
 You can reference table columns when choosing what values to set:
 
-  posts.where{|o| o.stamp < Date.today - 7}.update(:backup_number => :backup_number + 1)
+  posts.where{|o| o.stamp < Date.today - 7}.update(:backup_number => Sequel.+(:backup_number, 1))
   # UPDATE posts SET backup_number = backup_number + 1 WHERE stamp < '2010-07-07'
 
 As with +delete+, +update+ affects all rows in the dataset, so +where+ first,
@@ -417,18 +425,6 @@ You can then do anything you like with the dataset:
   # ON order_items.item_id = items.id
   # WHERE order_items.order_id = 1234
   
-=== Graphing Datasets
-
-When retrieving records from joined datasets, you get the results in a single hash, which is subject to clobbering if you have columns with the same name in multiple tables:
-
-  DB[:items].join(:order_items, :item_id => :id).first
-  => {:id=>order_items.id, :item_id=>order_items.item_id}
-
-Using +graph+, you can split the result hashes into subhashes, one per join:
-
-  DB[:items].graph(:order_items, :item_id => :id).first
-  => {:items=>{:id=>items.id}, :order_items=>{:id=>order_items.id, :item_id=>order_items.item_id}}
-
 == Column references in Sequel
 
 Sequel expects column names to be specified using symbols. In addition, returned hashes always use symbols as their keys. This allows you to freely mix literal values and column references in many cases. For example, the two following lines produce equivalent SQL:
@@ -491,6 +487,10 @@ Model classes are defined as regular Ruby classes inheriting from <tt>Sequel::Mo
   class Post < Sequel::Model
   end
 
+When a model class is created, it parses the schema in the table from the database, and
+automatically sets up accessor methods for all of the columns in the table (Sequel::Model
+implements the active record pattern).
+
 Sequel model classes assume that the table name is an underscored plural of the class name:
 
   Post.table_name #=> :posts
@@ -535,9 +535,9 @@ A single model instance can also be fetched by specifying a condition:
   post = Post[:title => 'hello world']
   post = Post.first{num_comments < 10}
 
-=== Iterating over records
+=== Acts like a dataset
 
-A model class lets you iterate over subsets of records by proxying many methods to the underlying dataset. This means that you can use most of the +Dataset+ API to create customized queries that return model instances, e.g.:
+A model class forwards many methods to the underlying dataset. This means that you can use most of the +Dataset+ API to create customized queries that return model instances, e.g.:
 
   Post.where(:category => 'ruby').each{|post| p post}
 
@@ -562,21 +562,25 @@ If the record's attributes names are not valid columns in the model's dataset (m
   post[:id] #=> 123
   post[:title] #=> 'hello world'
 
-You can also modify record values using attribute setters, the <tt>[]=</tt> method, or the +set+ method:
+You can also modify record values using attribute setters or the <tt>[]=</tt> method.
+
 
   post.title = 'hey there'
-  # or 
   post[:title] = 'hey there'
-  # or 
-  post.set(:title=>'hey there')
 
 That will just change the value for the object, it will not update the row in the database.  To update the database row, call the +save+ method:
 
   post.save
 
-You can modify record values and save the changes to the object in a single method call using the +update+ method:
+=== Mass assignment
+
+You can also set the values for multiple columns in a single method call, using one of the mass-assignment methods.  See the {mass assignment guide}[link:files/doc/mass_assignment_rdoc.html] for details.  For example +set+ updates the model's column values without saving:
 
-  post.update(:title => 'hey there')
+  post.set(:title=>'hey there', :updated_by=>'foo')
+
+and +update+ updates the model's column values and then saves the changes to the database:
+
+  post.update(:title => 'hey there', :updated_by=>'foo')
 
 === Creating new records
 
@@ -625,13 +629,13 @@ You can delete individual records by calling +delete+ or +destroy+. The only dif
   post.delete # => bypasses hooks
   post.destroy # => runs hooks
 
-Records can also be deleted en-masse by calling <tt>Model.delete</tt> and <tt>Model.destroy</tt>. As stated above, you can specify filters for the deleted records:
+Records can also be deleted en-masse by calling <tt>delete</tt> and <tt>destroy</tt> on the model's dataset. As stated above, you can specify filters for the deleted records:
 
   Post.where(:category => 32).delete # => bypasses hooks
   Post.where(:category => 32).destroy # => runs hooks
 
-Please note that if <tt>Model.destroy</tt> is called, each record is deleted 
-separately, but <tt>Model.delete</tt> deletes all matching records with a single 
+Please note that if <tt>destroy</tt> is called, each record is deleted 
+separately, but <tt>delete</tt> deletes all matching records with a single 
 SQL query.
 
 === Associations
@@ -744,19 +748,7 @@ You can dynamically customize eager loads for both +eager+ and +eager_graph+ whi
 
 === Extending the underlying dataset
 
-The obvious way to add table-wide logic is to define class methods to the model class definition. That way you can define subsets of the underlying dataset, change the ordering, or perform actions on multiple records:
-
-  class Post < Sequel::Model
-    def self.posts_with_few_comments
-      where{num_comments < 30}
-    end
-
-    def self.clean_posts_with_few_comments
-      posts_with_few_comments.delete
-    end
-  end
-
-You can also implement table-wide logic by defining methods on the dataset using +dataset_module+:
+The recommended way to implement table-wide logic by defining methods on the dataset using +dataset_module+:
 
   class Post < Sequel::Model
     dataset_module do
@@ -770,7 +762,7 @@ You can also implement table-wide logic by defining methods on the dataset using
     end
   end
 
-This is the recommended way of implementing table-wide operations, and allows you to have access to your model API from filtered datasets as well:
+This allows you to have access to your model API from filtered datasets as well:
 
   Post.where(:category => 'ruby').clean_posts_with_few_comments
 
@@ -798,4 +790,3 @@ raise an error or return false depending on how it is configured
       errors.add(:written_on, "should be in the past") if written_on >= Time.now
     end
   end
-

data/Rakefile

@@ -162,6 +162,7 @@ begin
 
   task :default => [:spec]
   spec_with_cov.call("spec", Dir["spec/{core,model}/*_spec.rb"], "Run core and model specs"){|t| t.rcov_opts.concat(%w'--exclude "lib/sequel/(adapters/([a-ln-z]|m[a-np-z])|extensions/core_extensions)"')}
+  spec.call("spec_bin", ["spec/bin_spec.rb"], "Run bin/sequel specs")
   spec.call("spec_core", Dir["spec/core/*_spec.rb"], "Run core specs")
   spec.call("spec_model", Dir["spec/model/*_spec.rb"], "Run model specs")
   spec.call("_spec_model_no_assoc", Dir["spec/model/*_spec.rb"].delete_if{|f| f =~ /association|eager_loading/}, '')
@@ -197,20 +198,6 @@ rescue LoadError
   end
 end
 
-desc "check documentation coverage"
-task :dcov do
-  sh %{find lib -name '*.rb' | xargs dcov}
-end
-
-### Statistics
-
-desc "Report code statistics (KLOCs, etc) from the application"
-task :stats do
-  STATS_DIRECTORIES = [%w(Code lib/), %w(Spec spec)].map{|name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir)}
-  require "./extra/stats"
-  CodeStatistics.new(*STATS_DIRECTORIES).to_s
-end
-
 desc "Print Sequel version"
 task :version do
   puts VERS.call

data/doc/active_record.rdoc

@@ -1,7 +1,6 @@
 = Sequel for ActiveRecord Users
 
-This guide is aimed at helping ActiveRecord users transition to Sequel.  It assumes the user is familiar with ActiveRecord 2, but if you are familiar with ActiveRecord 3, the transition should be even easier.
-
+This guide is aimed at helping ActiveRecord users transition to Sequel.  It assumes the user is familiar with ActiveRecord 2, but if you are familiar with a newer ActiveRecord version, the transition should be even easier.
 
 == Introduction
 
@@ -164,7 +163,7 @@ By now, you should have the idea that Sequel supports most things that ActiveRec
 
 === Method Chaining
 
-Unlike ActiveRecord 2, Sequel uses method chains on datasets for retrieving objects, so instead of:
+Unlike ActiveRecord 2 (and similar to ActiveRecord 3+), Sequel uses method chains on datasets for retrieving objects, so instead of:
 
   Album.find(:all, :conditions=>['name > ? AND artist_id = ?', 'RF', 1],
     :order=>'copies_sold', :select=>'id, name')
@@ -423,8 +422,8 @@ ActiveRecord option :: Sequel option
 <tt>:foreign_key</tt> :: <tt>:left_key</tt>
 <tt>:association_foreign_key</tt> :: <tt>:right_key</tt>
 <tt>:join_table</tt> :: <tt>:join_table</tt>
-<tt>:delete_sql</tt> :: Override the _remove_association method for the association
-<tt>:insert_sql</tt> :: Override the _add_association method for the association
+<tt>:delete_sql</tt> :: <tt>:remover</tt>
+<tt>:insert_sql</tt> :: <tt>:adder</tt>
 
 == Validation Errors
 
@@ -499,15 +498,7 @@ Sequel only uses connections for the minimum amount of time necessary, checking
     ...
   end
 
-Note that the connection is yielded to the block, and the block ensures it is returned to the pool.  Sequel doesn't have a method that returns a connection, since that would check it out with no ability to ensure it is returned to the pool
-
-==== +count+
-
-Without arguments, +count+ works the same in Sequel as in ActiveRecord.  For a single column:
-
-  Album.get{count(column)}
-
-For options, you should use method chaining to build your query and execute it.
+Note that the connection is yielded to the block, and the block ensures it is returned to the pool.  Sequel doesn't have a method that returns a connection, since that would check it out with no ability to ensure it is returned to the pool.
 
 ==== +count_by_sql+
 
@@ -517,11 +508,15 @@ You can call +with_sql+ to set the SQL to use, and the +single_value+ to retriev
 
 ==== +delete+, +delete_all+
 
-Calling +delete+ directly on the class will probably delete all rows in the table.  You want to filter first, then call +delete+:
+You probably want to filter first, then call +delete+:
 
   Album.where(:id=>id).delete
   Album.where("artist_id = ?", 5).delete
 
+If you really want to delete all rows in the table,call +delete+ on the Model's dataset:
+
+  Album.dataset.delete
+
 ==== +destroy+, +destroy_all+
 
 Similar to +delete+, you filter first, then +destroy+:
@@ -529,6 +524,10 @@ Similar to +delete+, you filter first, then +destroy+:
   Album.where(:id=>id).destroy
   Album.where("artist_id = ?", 5).destroy
 
+If you really want to destroy all rows in the table,call +destroy+ on the Model's dataset:
+
+  Album.dataset.destroy
+
 ==== +establish_connection+
 
 If you want to use a specific <tt>Sequel::Database</tt> object, you can use <tt>db=</tt>:
@@ -553,7 +552,10 @@ ActiveRecord's +find+ can be used for a lot of different things.  If you are try
 
   Album[1]
 
-Note that Sequel returns nil if no record is found, it doesn't raise an exception.
+Note that Sequel returns nil if no record is found, it doesn't raise an exception.  To raise an exception if no record
+is found:
+
+  Album.with_pk!(1)
 
 If you want to find multiple objects using an array of primary keys:
 
@@ -578,8 +580,8 @@ Here's a mapping of ActiveRecord +find+ options to <tt>Sequel::Dataset</tt> meth
 :conditions :: filter, where
 :order :: order
 :group :: group
-:limit :: limit # first argument
-:offset :: limit # second argument
+:limit :: limit
+:offset :: limit # second entry in limit array
 :joins :: join, left_join, etc. # many other join methods
 :include :: eager, eager_graph # eager does preloading, eager_graph does JOINs
 :select :: select
@@ -628,6 +630,7 @@ For anything more complex, you can use +dataset_module+:
 
 If you want to completely reload the schema for the table:
 
+  Album.instance_variable_set(:@db_schema, nil)
   Album.send(:get_db_schema, true)
 
 ==== +serialize+, +seralized_attributes+
@@ -679,6 +682,10 @@ Just like +delete+ and +destroy+, you filter first, then +update+:
   Album.where(:id=>id).update(:name=>'RF')
   Album.where("artist_id = ?", 5).update(:copies_sold=>0)
 
+Likewise, to update all rows in the model:
+
+  Album.dataset.update(:name=>'RF')
+
 Note that +update+ in that case will operate on a dataset, so it won't run model validations or hooks.  If you want those run:
 
   Album[id].update(:name=>'RF')
@@ -698,6 +705,7 @@ ActiveRecord Method :: Sequel Method
 +average+ :: +avg+
 +belongs_to+ :: +many_to_one+
 +columns_hash+ :: +db_schema+
++count+ :: +count+
 +changed+ :: +changed_columns+
 +create+ :: +create+
 +has_and_belongs_to_many+ :: +many_to_many+
@@ -772,14 +780,6 @@ If it is a new record:
   album = Album.new
   album.send(:set_values, gold_album.values)
 
-==== +clone+
-
-You probably have to use +set_values+, a private method:
-
-  album = Album[1]
-  cloned_album = Album.new
-  cloned_album.send(:set_values, album.values.dup)
-
 ==== +column_for_attribute+
 
 You can access this through the +db_schema+ hash:
@@ -806,7 +806,7 @@ Assuming you want the full behavior of saving just one column without validating
 
   album.values[:column] ||= 0
   album.values[:column] -= 1 # or += 1 for increment!
-  album.save(:column, :validate=>false)
+  album.save(:columns=>[:column], :validate=>false)
 
 ==== <tt>has_attribute?</tt>
 
@@ -837,7 +837,7 @@ No equivalent, but very easy to add:
 
 If you want to save just that column:
 
-  album.save(:column, :validate=>false)
+  album.save(:columns=>[:column], :validate=>false)
 
 ==== +transaction+
 
@@ -850,7 +850,7 @@ Just like in the class, you can access the transaction method through the +db+:
 To only set and save a specific column:
 
   album.set(:column => value)
-  album.save(:column, :validate=>false)
+  album.save(:columns=>[:column], :validate=>false)
 
 ==== +update_attributes+, <tt>update_attributes!</tt>