sequel 2.11.0 → 2.12.0

data/lib/{sequel_core/schema/generator.rb → sequel/database/schema_generator.rb}

@@ -62,12 +62,12 @@ module Sequel
       #   or not allowing NULL values (if false).  If unspecified, will default
       #   to whatever the database default is.
       # * :on_delete - Specify the behavior of this column when being deleted.
-      #   See Schema::SQL#on_delete_clause for options.
+      #   See Dataset#on_delete_clause for options.
       # * :on_update - Specify the behavior of this column when being updated.
       #   See Schema::SQL#on_delete_clause for options.
       # * :size - The size of the column, generally used with string
       #   columns to specify the maximum number of characters the column will hold.
-      # * :unique - Mark the column is unique, generally has the same effect as
+      # * :unique - Mark the column as unique, generally has the same effect as
       #   creating a unique index on the column.
       # * :unsigned - Make the column type unsigned, only useful for integer
       #   columns.
@@ -177,12 +177,14 @@ module Sequel
 
       private
 
+      # Add a composite primary key constraint
       def composite_primary_key(columns, *args)
         opts = args.pop || {}
         @columns << {:type => :check, :constraint_type => :primary_key,
                      :name => nil, :columns => columns}.merge(opts)
       end
 
+      # Add a composite foreign key constraint
       def composite_foreign_key(columns, opts)
         @columns << {:type => :check, :constraint_type => :foreign_key,
                      :name => nil, :columns => columns }.merge(opts)
@@ -304,11 +306,13 @@ module Sequel
 
       private
 
+      # Add a composite primary key constraint
       def add_composite_primary_key(columns, opts)
         @operations << {:op => :add_constraint, :type => :check,
           :constraint_type => :primary_key, :columns => columns}.merge(opts)
       end
 
+      # Add a composite foreign key constraint
       def add_composite_foreign_key(columns, table, opts)
         @operations << {:op => :add_constraint, :type => :check,
           :constraint_type => :foreign_key, :columns => columns,

data/lib/{sequel_core/database/schema.rb → sequel/database/schema_methods.rb}

@@ -21,8 +21,7 @@ module Sequel
       alter_table(table) {add_index(*args)}
     end
     
-    # Alters the given table with the specified block. Here are the currently
-    # available operations:
+    # Alters the given table with the specified block. Example:
     #
     #   DB.alter_table :items do
     #     add_column :category, :text, :default => 'ruby'
@@ -48,9 +47,9 @@ module Sequel
     # Creates a table with the columns given in the provided block:
     #
     #   DB.create_table :posts do
-    #     primary_key :id, :serial
+    #     primary_key :id
     #     column :title, :text
-    #     column :content, :text
+    #     String :content
     #     index :title
     #   end
     #
@@ -60,7 +59,7 @@ module Sequel
       create_table_sql_list(name, *((options[:generator] || Schema::Generator.new(self, &block)).create_info << options)).flatten.each {|sql| execute_ddl(sql)}
     end
     
-    # Forcibly creates a table. If the table already exists it is dropped.
+    # Forcibly creates a table, attempting to drop it unconditionally (and catching any errors), then creating it.
     def create_table!(name, options={}, &block)
       drop_table(name) rescue nil
       create_table(name, options, &block)
@@ -73,7 +72,7 @@ module Sequel
     def create_or_replace_view(name, source)
       remove_cached_schema(name)
       source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE OR REPLACE VIEW #{quote_identifier(name)} AS #{source}")
+      execute_ddl("CREATE OR REPLACE VIEW #{quote_schema_table(name)} AS #{source}")
     end
     
     # Creates a view based on a dataset or an SQL string:
@@ -82,7 +81,7 @@ module Sequel
     #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_view(name, source)
       source = source.sql if source.is_a?(Dataset)
-      execute_ddl("CREATE VIEW #{quote_identifier(name)} AS #{source}")
+      execute_ddl("CREATE VIEW #{quote_schema_table(name)} AS #{source}")
     end
     
     # Removes a column from the specified table:
@@ -104,7 +103,7 @@ module Sequel
       alter_table(table) {drop_index(columns)}
     end
     
-    # Drops one or more tables corresponding to the given table names:
+    # Drops one or more tables corresponding to the given names:
     #
     #   DB.drop_table(:posts, :comments)
     def drop_table(*names)
@@ -114,13 +113,13 @@ module Sequel
       end
     end
     
-    # Drops a view:
+    # Drops one or more views corresponding to the given names:
     #
     #   DB.drop_view(:cheap_items)
     def drop_view(*names)
       names.each do |n|
         remove_cached_schema(n)
-        execute_ddl("DROP VIEW #{quote_identifier(n)}")
+        execute_ddl("DROP VIEW #{quote_schema_table(n)}")
       end
     end
 
@@ -129,8 +128,9 @@ module Sequel
     #   DB.tables #=> [:items]
     #   DB.rename_table :items, :old_items
     #   DB.tables #=> [:old_items]
-    def rename_table(*args)
-      execute_ddl(rename_table_sql(*args))
+    def rename_table(name, new_name)
+      remove_cached_schema(name)
+      execute_ddl(rename_table_sql(name, new_name))
     end
     
     # Renames a column in the specified table. This method expects the current

data/lib/sequel/database/schema_sql.rb

@@ -0,0 +1,224 @@
+module Sequel
+  class Database
+    AUTOINCREMENT = 'AUTOINCREMENT'.freeze
+    CASCADE = 'CASCADE'.freeze
+    COMMA_SEPARATOR = ', '.freeze
+    NO_ACTION = 'NO ACTION'.freeze
+    NOT_NULL = ' NOT NULL'.freeze
+    NULL = ' NULL'.freeze
+    PRIMARY_KEY = ' PRIMARY KEY'.freeze
+    RESTRICT = 'RESTRICT'.freeze
+    SET_DEFAULT = 'SET DEFAULT'.freeze
+    SET_NULL = 'SET NULL'.freeze
+    TYPES = Hash.new {|h, k| k}
+    TYPES.merge!(:double=>'double precision', String=>'varchar(255)',
+      Integer=>'integer', Fixnum=>'integer', Bignum=>'bigint',
+      Float=>'double precision', BigDecimal=>'numeric', Numeric=>'numeric',
+      Date=>'date', DateTime=>'timestamp', Time=>'timestamp', File=>'blob',
+      TrueClass=>'boolean', FalseClass=>'boolean')
+    UNDERSCORE = '_'.freeze
+    UNIQUE = ' UNIQUE'.freeze
+    UNSIGNED = ' UNSIGNED'.freeze
+
+    # Default serial primary key options.
+    def serial_primary_key_options
+      {:primary_key => true, :type => Integer, :auto_increment => true}
+    end
+
+    private
+
+    # The SQL to execute to modify the DDL for the given table name.  op
+    # should be one of the operations returned by the AlterTableGenerator.
+    def alter_table_sql(table, op)
+      quoted_name = quote_identifier(op[:name]) if op[:name]
+      alter_table_op = case op[:op]
+      when :add_column
+        "ADD COLUMN #{column_definition_sql(op)}"
+      when :drop_column
+        "DROP COLUMN #{quoted_name}"
+      when :rename_column
+        "RENAME COLUMN #{quoted_name} TO #{quote_identifier(op[:new_name])}"
+      when :set_column_type
+        "ALTER COLUMN #{quoted_name} TYPE #{type_literal(op)}"
+      when :set_column_default
+        "ALTER COLUMN #{quoted_name} SET DEFAULT #{literal(op[:default])}"
+      when :set_column_null
+        "ALTER COLUMN #{quoted_name} #{op[:null] ? 'DROP' : 'SET'} NOT NULL"
+      when :add_index
+        return index_definition_sql(table, op)
+      when :drop_index
+        return drop_index_sql(table, op)
+      when :add_constraint
+        "ADD #{constraint_definition_sql(op)}"
+      when :drop_constraint
+        "DROP CONSTRAINT #{quoted_name}"
+      else
+        raise Error, "Unsupported ALTER TABLE operation"
+      end
+      "ALTER TABLE #{quote_schema_table(table)} #{alter_table_op}"
+    end
+
+    # Array of SQL DDL modification statements for the given table,
+    # corresponding to the DDL changes specified by the operations.
+    def alter_table_sql_list(table, operations)
+      operations.map{|op| alter_table_sql(table, op)}
+    end
+    
+    # The SQL string specify the autoincrement property, generally used by
+    # primary keys.
+    def auto_increment_sql
+      AUTOINCREMENT
+    end
+    
+    # SQL DDL fragment containing the column creation SQL for the given column.
+    def column_definition_sql(column)
+      return constraint_definition_sql(column) if column[:type] == :check
+      sql = "#{quote_identifier(column[:name])} #{type_literal(column)}"
+      sql << UNIQUE if column[:unique]
+      sql << NOT_NULL if column[:null] == false
+      sql << NULL if column[:null] == true
+      sql << " DEFAULT #{literal(column[:default])}" if column.include?(:default)
+      sql << PRIMARY_KEY if column[:primary_key]
+      sql << " #{auto_increment_sql}" if column[:auto_increment]
+      sql << column_references_sql(column) if column[:table]
+      sql
+    end
+    
+    # SQL DDL fragment containing the column creation
+    # SQL for all given columns, used inside a CREATE TABLE block.
+    def column_list_sql(columns)
+      columns.map{|c| column_definition_sql(c)}.join(COMMA_SEPARATOR)
+    end
+
+    # SQL DDL fragment for column foreign key references
+    def column_references_sql(column)
+      sql = " REFERENCES #{quote_schema_table(column[:table])}"
+      sql << "(#{Array(column[:key]).map{|x| quote_identifier(x)}.join(COMMA_SEPARATOR)})" if column[:key]
+      sql << " ON DELETE #{on_delete_clause(column[:on_delete])}" if column[:on_delete]
+      sql << " ON UPDATE #{on_delete_clause(column[:on_update])}" if column[:on_update]
+      sql
+    end
+  
+    # SQL DDL fragment specifying a constraint on a table.
+    def constraint_definition_sql(constraint)
+      sql = constraint[:name] ? "CONSTRAINT #{quote_identifier(constraint[:name])} " : ""
+      case constraint[:constraint_type]
+      when :primary_key
+        sql << "PRIMARY KEY #{literal(constraint[:columns])}"
+      when :foreign_key
+        sql << "FOREIGN KEY #{literal(constraint[:columns])}"
+        sql << column_references_sql(constraint)
+      when :unique
+        sql << "UNIQUE #{literal(constraint[:columns])}"
+      else
+        check = constraint[:check]
+        sql << "CHECK #{filter_expr((check.is_a?(Array) && check.length == 1) ? check.first : check)}"
+      end
+      sql
+    end
+
+    # Array of SQL DDL statements, the first for creating a table with the given
+    # name and column specifications, and the others for specifying indexes on
+    # the table.
+    def create_table_sql_list(name, columns, indexes = nil, options = {})
+      sql = ["CREATE TABLE #{quote_schema_table(name)} (#{column_list_sql(columns)})"]
+      sql.concat(index_list_sql_list(name, indexes)) if indexes && !indexes.empty?
+      sql
+    end
+    
+    # Default index name for the table and columns, may be too long
+    # for certain databases.
+    def default_index_name(table_name, columns)
+      schema, table = schema_and_table(table_name)
+      "#{"#{schema}_" if schema and schema != default_schema}#{table}_#{columns.map{|c| [String, Symbol].any?{|cl| c.is_a?(cl)} ? c : literal(c).gsub(/\W/, '_')}.join(UNDERSCORE)}_index"
+    end
+  
+    # The SQL to drop an index for the table.
+    def drop_index_sql(table, op)
+      "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))}"
+    end
+
+    # SQL DDL statement to drop the table with the given name.
+    def drop_table_sql(name)
+      "DROP TABLE #{quote_schema_table(name)}"
+    end
+    
+    # Proxy the filter_expr call to the dataset, used for creating constraints.
+    def filter_expr(*args, &block)
+      schema_utility_dataset.literal(schema_utility_dataset.send(:filter_expr, *args, &block))
+    end
+
+    # SQL DDL statement for creating an index for the table with the given name
+    # and index specifications.
+    def index_definition_sql(table_name, index)
+      index_name = index[:name] || default_index_name(table_name, index[:columns])
+      if index[:type]
+        raise Error, "Index types are not supported for this database"
+      elsif index[:where]
+        raise Error, "Partial indexes are not supported for this database"
+      else
+        "CREATE #{'UNIQUE ' if index[:unique]}INDEX #{quote_identifier(index_name)} ON #{quote_identifier(table_name)} #{literal(index[:columns])}"
+      end
+    end
+  
+    # Array of SQL DDL statements, one for each index specification,
+    # for the given table.
+    def index_list_sql_list(table_name, indexes)
+      indexes.map{|i| index_definition_sql(table_name, i)}
+    end
+
+    # SQL DDL ON DELETE fragment to use, based on the given action.
+    # The following actions are recognized:
+    # 
+    # * :cascade - Delete rows referencing this row.
+    # * :no_action (default) - Raise an error if other rows reference this
+    #   row, allow deferring of the integrity check.
+    # * :restrict - Raise an error if other rows reference this row,
+    #   but do not allow deferring the integrity check.
+    # * :set_default - Set columns referencing this row to their default value.
+    # * :set_null - Set columns referencing this row to NULL.
+    def on_delete_clause(action)
+      case action
+      when :restrict
+        RESTRICT
+      when :cascade
+        CASCADE
+      when :set_null
+        SET_NULL
+      when :set_default
+        SET_DEFAULT
+      else
+        NO_ACTION
+      end
+    end
+    
+    # Proxy the quote_schema_table method to the dataset
+    def quote_schema_table(table)
+      schema_utility_dataset.quote_schema_table(table)
+    end
+    
+    # Proxy the quote_identifier method to the dataset, used for quoting tables and columns.
+    def quote_identifier(v)
+      schema_utility_dataset.quote_identifier(v)
+    end
+    
+    # SQL DDL statement for renaming a table.
+    def rename_table_sql(name, new_name)
+      "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_schema_table(new_name)}"
+    end
+
+    # SQL fragment specifying the type of a given column.
+    def type_literal(column)
+      type = type_literal_base(column)
+      column[:size] ||= 255 if type.to_s == 'varchar'
+      elements = column[:size] || column[:elements]
+      "#{type}#{literal(Array(elements)) if elements}#{UNSIGNED if column[:unsigned]}"
+    end
+
+    # SQL fragment specifying the base type of a given column,
+    # without the size or elements.
+    def type_literal_base(column)
+      TYPES[column[:type]]
+    end
+  end
+end

data/lib/{sequel_core → sequel}/dataset.rb

@@ -1,27 +1,22 @@
-%w'callback convenience pagination prepared_statements query schema sql'.each do |f|
-  require "sequel_core/dataset/#{f}"
-end
-
 module Sequel
-  # A Dataset represents a view of a the data in a database, constrained by
-  # specific parameters such as filtering conditions, order, etc. Datasets
+  # A dataset represents an SQL query, or more generally, an abstract
+  # set of rows in the database.  Datasets
   # can be used to create, retrieve, update and delete records.
   # 
   # Query results are always retrieved on demand, so a dataset can be kept
-  # around and reused indefinitely:
+  # around and reused indefinitely (datasets never cache results):
   #
   #   my_posts = DB[:posts].filter(:author => 'david') # no records are retrieved
-  #   p my_posts.all # records are now retrieved
-  #   ...
-  #   p my_posts.all # records are retrieved again
+  #   my_posts.all # records are retrieved
+  #   my_posts.all # records are retrieved again
   #
-  # In order to provide this functionality, dataset methods such as where, 
-  # select, order, etc. return modified copies of the dataset, so you can
-  # use different datasets to access data:
+  # Most dataset methods return modified copies of the dataset (functional style), so you can
+  # reuse different datasets to access data:
   #
   #   posts = DB[:posts]
   #   davids_posts = posts.filter(:author => 'david')
   #   old_posts = posts.filter('stamp < ?', Date.today - 7)
+  #   davids_old_posts = davids_posts.filter('stamp < ?', Date.today - 7)
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
@@ -37,15 +32,14 @@ module Sequel
   #   This methods are shortcuts to join_table with the join type
   #   already specified.
   class Dataset
+    extend Metaprogramming
+    include Metaprogramming
     include Enumerable
     
     # The dataset options that require the removal of cached columns
     # if changed.
     COLUMN_CHANGE_OPTS = [:select, :sql, :from, :join].freeze
 
-    # Array of all subclasses of Dataset
-    DATASET_CLASSES = []
-
     # All methods that should have a ! method added that modifies
     # the receiver.
     MUTATION_METHODS = %w'add_graph_aliases and distinct exclude exists
@@ -53,21 +47,10 @@ module Sequel
     group group_and_count group_by having inner_join intersect invert join
     left_outer_join limit naked or order order_by order_more paginate query reject
     reverse reverse_order right_outer_join select select_all select_more
-    set_defaults set_graph_aliases set_model set_overrides sort sort_by
+    set_defaults set_graph_aliases set_overrides sort sort_by
     unfiltered union unordered where with_sql'.collect{|x| x.to_sym}
 
     NOTIMPL_MSG = "This method must be overridden in Sequel adapters".freeze
-    STOCK_TRANSFORMS = {
-      :marshal => [
-        # for backwards-compatibility we support also non-base64-encoded values.
-        proc {|v| Marshal.load(v.unpack('m')[0]) rescue Marshal.load(v)}, 
-        proc {|v| [Marshal.dump(v)].pack('m')}
-      ],
-      :yaml => [
-        proc {|v| YAML.load v if v}, 
-        proc {|v| v.to_yaml}
-      ]
-    }
 
     # The database that corresponds to this dataset
     attr_accessor :db
@@ -85,21 +68,18 @@ module Sequel
     attr_writer :quote_identifiers
     
     # The row_proc for this database, should be a Proc that takes
-    # a single hash argument and returns the object you want to
-    # fetch_rows to return.
+    # a single hash argument and returns the object you want
+    # each to return.
     attr_accessor :row_proc
 
-    # Constructs a new instance of a dataset with an associated database and 
-    # options. Datasets are usually constructed by invoking Database methods:
+    # Constructs a new Dataset instance with an associated database and 
+    # options. Datasets are usually constructed by invoking the Database#[] method:
     #
     #   DB[:posts]
     #
-    # Or:
-    #
-    #   DB.dataset # the returned dataset is blank
-    #
     # Sequel::Dataset is an abstract class that is not useful by itself. Each
-    # database adaptor should provide a descendant class of Sequel::Dataset.
+    # database adaptor should provide a subclass of Sequel::Dataset, and have
+    # the Database#dataset method return an instance of that class.
     def initialize(db, opts = nil)
       @db = db
       @quote_identifiers = db.quote_identifiers? if db.respond_to?(:quote_identifiers?)
@@ -112,11 +92,6 @@ module Sequel
     
     ### Class Methods ###
 
-    # The array of dataset subclasses.
-    def self.dataset_classes
-      DATASET_CLASSES
-    end
-
     # Setup mutation (e.g. filter!) methods.  These operate the same as the
     # non-! methods, but replace the options of the current dataset with the
     # options of the resulting dataset.
@@ -126,11 +101,6 @@ module Sequel
       end
     end
 
-    # Add the subclass to the array of subclasses.
-    def self.inherited(c)
-      DATASET_CLASSES << c
-    end
-    
     ### Instance Methods ###
 
     # Alias for insert, but not aliased directly so subclasses
@@ -139,17 +109,19 @@ module Sequel
       insert(*args)
     end
 
-    # Return the dataset as a column with the given alias, so it can be used in the
-    # SELECT clause. This dataset should result in a single row and a single column.
+    # Return the dataset as an aliased expression with the given alias. You can
+    # use this as a FROM or JOIN dataset, or as a column if this dataset
+    # returns a single row and column.
     def as(aliaz)
       ::Sequel::SQL::AliasedExpression.new(self, aliaz)
     end
 
     # Returns an array with all records in the dataset. If a block is given,
     # the array is iterated over after all items have been loaded.
-    def all(opts = nil, &block)
+    def all(opts = (defarg=true;nil), &block)
+      Deprecation.deprecate("Calling Dataset#all with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).all.") unless defarg
       a = []
-      each(opts) {|r| a << r}
+      defarg ? each{|r| a << r} : each(opts){|r| a << r}
       post_load(a)
       a.each(&block) if block
       a
@@ -165,16 +137,19 @@ module Sequel
       c
     end
     
-    # Returns the columns in the result set in their true order.
+    # Returns the columns in the result set in order.
     # If the columns are currently cached, returns the cached value. Otherwise,
     # a SELECT query is performed to get a single row. Adapters are expected
     # to fill the columns cache with the column information when a query is performed.
-    # If the dataset does not have any rows, this will be an empty array.
-    # If you are looking for all columns for a single table, see Schema::SQL#schema.
+    # If the dataset does not have any rows, this may be an empty array depending on how
+    # the adapter is programmed.
+    #
+    # If you are looking for all columns for a single table and maybe some information about
+    # each column (e.g. type), see Database#schema.
     def columns
       return @columns if @columns
-      ds = unfiltered.unordered.clone(:distinct => nil)
-      ds.single_record
+      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1)
+      ds.each{break}
       @columns = ds.instance_variable_get(:@columns)
       @columns || []
     end
@@ -195,29 +170,30 @@ module Sequel
 
     # Deletes the records in the dataset.  The returned value is generally the
     # number of records deleted, but that is adapter dependent.
-    def delete(*args)
-      execute_dui(delete_sql(*args))
+    def delete(opts=(defarg=true;nil))
+      Deprecation.deprecate("Calling Dataset#delete with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).delete.") unless defarg
+      execute_dui(defarg ? delete_sql : delete_sql(opts))
     end
     
-    # Iterates over the records in the dataset and returns set.  If opts
-    # have been passed that modify the columns, reset the column information.
-    def each(opts = nil, &block)
+    # Iterates over the records in the dataset as they are yielded from the
+    # database adapter, and returns self.
+    def each(opts = (defarg=true;nil), &block)
+      Deprecation.deprecate("Calling Dataset#each with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).each.") unless defarg
       if opts && opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
         prev_columns = @columns
         begin
-          _each(opts, &block)
+          defarg ? _each(&block) : _each(opts, &block)
         ensure
           @columns = prev_columns
         end
       else
-        _each(opts, &block)
+        defarg ? _each(&block) : _each(opts, &block)
       end
       self
     end
 
     # Executes a select query and fetches records, passing each record to the
-    # supplied block.  The yielded records are generally hashes with symbol keys,
-    # but that is adapter dependent.
+    # supplied block.  The yielded records should be hashes with symbol keys.
     def fetch_rows(sql, &block)
       raise NotImplementedError, NOTIMPL_MSG
     end
@@ -234,24 +210,12 @@ module Sequel
       "#<#{self.class}: #{sql.inspect}>"
     end
 
-    # Returns the the model classes associated with the dataset as a hash.
-    # If the dataset is associated with a single model class, a key of nil
-    # is used.  For datasets with polymorphic models, the keys are
-    # values of the polymorphic column and the values are the corresponding
-    # model classes to which they map.
-    def model_classes
-      @opts[:models]
-    end
-    
     # Returns a naked dataset clone - i.e. a dataset that returns records as
-    # hashes rather than model objects.
+    # hashes instead of calling the row proc.
     def naked
-      clone.set_model(nil)
-    end
-    
-    # Returns the column name for the polymorphic key.
-    def polymorphic_key
-      @opts[:polymorphic_key]
+      ds = clone
+      ds.row_proc = nil
+      ds
     end
     
     # Whether this dataset quotes identifiers.
@@ -260,8 +224,8 @@ module Sequel
     end
     
     # Set the server for this dataset to use.  Used to pick a specific database
-    # shard to run a query against, or to override the default SELECT uses
-    # :read_only database and all other queries use the :default database.
+    # shard to run a query against, or to override the default (which is SELECT uses
+    # :read_only database and all other queries use the :default database).
     def server(servr)
       clone(:server=>servr)
     end
@@ -278,164 +242,17 @@ module Sequel
       clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
     end
 
-    # Associates or disassociates the dataset with a model(s). If
-    # nil is specified, the dataset is turned into a naked dataset and returns
-    # records as hashes. If a model class specified, the dataset is modified
-    # to return records as instances of the model class, e.g:
-    #
-    #   class MyModel
-    #     def initialize(values)
-    #       @values = values
-    #       ...
-    #     end
-    #   end
-    # 
-    #   dataset.set_model(MyModel)
-    #
-    # You can also provide additional arguments to be passed to the model's
-    # initialize method:
-    #
-    #   class MyModel
-    #     def initialize(values, options)
-    #       @values = values
-    #       ...
-    #     end
-    #   end
-    # 
-    #   dataset.set_model(MyModel, :allow_delete => false)
-    #  
-    # The dataset can be made polymorphic by specifying a column name as the
-    # polymorphic key and a hash mapping column values to model classes.
-    #
-    #   dataset.set_model(:kind, {1 => Person, 2 => Business})
-    #
-    # You can also set a default model class to fall back on by specifying a
-    # class corresponding to nil:
-    #
-    #   dataset.set_model(:kind, {nil => DefaultClass, 1 => Person, 2 => Business})
-    #
-    # To make sure that there is always a default model class, the hash provided
-    # should have a default value.  To make the dataset map string values to
-    # model classes, and keep a good default, try:
-    #
-    #   dataset.set_model(:kind, Hash.new{|h,k| h[k] = (k.constantize rescue DefaultClass)})
-    def set_model(key, *args)
-      # This code is more verbose then necessary for performance reasons
-      case key
-      when nil # set_model(nil) => no argument provided, so the dataset is denuded
-        @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
-        self.row_proc = nil
-      when Class
-        # isomorphic model
-        @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
-        if key.respond_to?(:load)
-          # the class has a values setter method, so we use it
-          self.row_proc = proc{|h| key.load(h, *args)}
-        else
-          # otherwise we just pass the hash to the constructor
-          self.row_proc = proc{|h| key.new(h, *args)}
-        end
-      when Symbol
-        # polymorphic model
-        hash = args.shift || raise(ArgumentError, "No class hash supplied for polymorphic model")
-        @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
-        if (hash.empty? ? (hash[nil] rescue nil) : hash.values.first).respond_to?(:load)
-          # the class has a values setter method, so we use it
-          self.row_proc = proc do |h|
-            c = hash[h[key]] || hash[nil] || \
-              raise(Error, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
-            c.load(h, *args)
-          end
-        else
-          # otherwise we just pass the hash to the constructor
-          self.row_proc = proc do |h|
-            c = hash[h[key]] || hash[nil] || \
-              raise(Error, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
-            c.new(h, *args)
-          end
-        end
-      else
-        raise ArgumentError, "Invalid model specified"
-      end
-      self
-    end
-    
     # Set values that override hash arguments given to insert and update statements.
     # This hash is merged into the hash provided to insert or update.
     def set_overrides(hash)
       clone(:overrides=>hash.merge(@opts[:overrides]||{}))
     end
 
-    # Sets a value transform which is used to convert values loaded and saved
-    # to/from the database. The transform should be supplied as a hash. Each
-    # value in the hash should be an array containing two proc objects - one
-    # for transforming loaded values, and one for transforming saved values.
-    # The following example demonstrates how to store Ruby objects in a dataset
-    # using Marshal serialization:
-    #
-    #   dataset.transform(:obj => [
-    #     proc {|v| Marshal.load(v)},
-    #     proc {|v| Marshal.dump(v)}
-    #   ])
-    #
-    #   dataset.insert_sql(:obj => 1234) #=>
-    #   "INSERT INTO items (obj) VALUES ('\004\bi\002\322\004')"
-    #
-    # Another form of using transform is by specifying stock transforms:
-    # 
-    #   dataset.transform(:obj => :marshal)
-    #
-    # The currently supported stock transforms are :marshal and :yaml.
-    def transform(t)
-      @transform = t
-      t.each do |k, v|
-        case v
-        when Array
-          if (v.size != 2) || !v.first.is_a?(Proc) && !v.last.is_a?(Proc)
-            raise Error::InvalidTransform, "Invalid transform specified"
-          end
-        else
-          unless v = STOCK_TRANSFORMS[v]
-            raise Error::InvalidTransform, "Invalid transform specified"
-          else
-            t[k] = v
-          end
-        end
-      end
-      self
-    end
-    
-    # Applies the value transform for data loaded from the database.
-    def transform_load(r)
-      r.inject({}) do |m, kv|
-        k, v = *kv
-        m[k] = (tt = @transform[k]) ? tt[0][v] : v
-        m
-      end
-    end
-    
-    # Applies the value transform for data saved to the database.
-    def transform_save(r)
-      r.inject({}) do |m, kv|
-        k, v = *kv
-        m[k] = (tt = @transform[k]) ? tt[1][v] : v
-        m
-      end
-    end
-    
-    def upcase_identifiers=(v)
-      @identifier_input_method = v ? :upcase : nil
-    end
-    
-    # Whether this dataset upcases identifiers.
-    def upcase_identifiers?
-      @identifier_input_method == :upcase
-    end
-    
     # Updates values for the dataset.  The returned value is generally the
     # number of rows updated, but that is adapter dependent.
-    def update(*args)
-      execute_dui(update_sql(*args))
+    def update(values={}, opts=(defarg=true;nil))
+      Deprecation.deprecate("Calling Dataset#update with an argument is deprecated and will raise an error in Sequel 3.0.  Use dataset.clone(opts).update.") unless defarg
+      execute_dui(defarg ? update_sql(values) : update_sql(value, opts))
     end
   
     # Add the mutation methods via metaprogramming
@@ -453,13 +270,13 @@ module Sequel
     # Runs #graph_each if graphing.  Otherwise, iterates through the records
     # yielded by #fetch_rows, applying any row_proc or transform if necessary,
     # and yielding the result.
-    def _each(opts, &block)
+    def _each(opts=(defarg=true;nil), &block)
       if @opts[:graph] and !(opts && opts[:graph] == false)
-        graph_each(opts, &block)
+        defarg ? graph_each(&block) : graph_each(opts, &block)
       else
         row_proc = @row_proc unless opts && opts[:naked]
         transform = @transform
-        fetch_rows(select_sql(opts)) do |r|
+        fetch_rows(defarg ? select_sql : select_sql(opts)) do |r|
           r = transform_load(r) if transform
           r = row_proc[r] if row_proc
           yield r
@@ -507,5 +324,30 @@ module Sequel
     def output_identifier(v)
       (i = identifier_output_method) ? v.to_s.send(i).to_sym : v.to_sym
     end
+
+    # This is run inside .all, after all of the records have been loaded
+    # via .each, but before any block passed to all is called.  It is called with
+    # a single argument, an array of all returned records.  Does nothing by
+    # default, added to make the model eager loading code simpler.
+    def post_load(all_records)
+    end
+
+    # If a block argument is passed to a method that uses a VirtualRow,
+    # yield a new VirtualRow instance to the block if it accepts a single
+    # argument.  Otherwise, evaluate the block in the context of a new
+    # VirtualRow instance.
+    def virtual_row_block_call(block)
+      return unless block
+      unless Sequel.virtual_row_instance_eval
+        Deprecation.deprecate('Using a VirtualRow block without an argument is deprecated, and its meaning will change in Sequel 3.0.  Add a block argument to keep the old semantics, or set Sequel.virtual_row_instance_eval = true to use instance_eval for VirtualRow blocks without arguments.') unless block.arity == 1
+        return block.call(SQL::VirtualRow.new)
+      end
+      case block.arity
+      when -1, 0
+        SQL::VirtualRow.new.instance_eval(&block)
+      else
+        block.call(SQL::VirtualRow.new)
+      end
+    end
   end
 end