epugh-sequel 0.0.0

data/lib/sequel/database/schema_sql.rb

@@ -0,0 +1,324 @@
+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
+
+    # 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 instead 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
+
+    # Proxy the literal call to the dataset, used for default values.
+    def literal(v)
+      schema_utility_dataset.literal(v)
+    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
+
+    # Parse the schema from the database.
+    # If the table_name is not given, returns the schema for all tables as a hash.
+    # If the table_name is given, returns the schema for a single table as an
+    # array with all members being arrays of length 2.  Available options are:
+    #
+    # * :reload - Get fresh information from the database, instead of using
+    #   cached information.  If table_name is blank, :reload should be used
+    #   unless you are sure that schema has not been called before with a
+    #   table_name, otherwise you may only getting the schemas for tables
+    #   that have been requested explicitly.
+    # * :schema - An explicit schema to use.  It may also be implicitly provided
+    #   via the table name.
+    def schema(table = nil, opts={})
+      Deprecation.deprecate('Calling Database#schema without a table argument', 'Use database.tables.inject({}){|h, m| h[m] = database.schema(m); h}') unless table
+      raise(Error, 'schema parsing is not implemented on this database') unless respond_to?(:schema_parse_table, true)
+
+      if table
+        sch, table_name = schema_and_table(table)
+        quoted_name = quote_schema_table(table)
+      end
+      opts = opts.merge(:schema=>sch) if sch && !opts.include?(:schema)
+      if opts[:reload] && @schemas
+        if table_name
+          @schemas.delete(quoted_name)
+        else
+          @schemas = nil
+        end
+      end
+
+      if @schemas
+        if table_name
+          return @schemas[quoted_name] if @schemas[quoted_name]
+        else
+          return @schemas
+        end
+      end
+      
+      raise(Error, '#tables does not exist, you must provide a specific table to #schema') if table.nil? && !respond_to?(:tables, true)
+
+      @schemas ||= Hash.new do |h,k|
+        quote_name = quote_schema_table(k)
+        h[quote_name] if h.include?(quote_name)
+      end
+
+      if table_name
+        cols = schema_parse_table(table_name, opts)
+        raise(Error, 'schema parsing returned no columns, table probably doesn\'t exist') if cols.nil? || cols.empty?
+        @schemas[quoted_name] = cols
+      else
+        tables.each{|t| @schemas[quote_schema_table(t)] = schema_parse_table(t.to_s, opts)}
+        @schemas
+      end
+    end
+    
+    # The dataset to use for proxying certain schema methods.
+    def schema_utility_dataset
+      @schema_utility_dataset ||= dataset
+    end
+    
+    private
+
+    # Remove the cached schema for the given schema name
+    def remove_cached_schema(table)
+      @schemas.delete(quote_schema_table(table)) if @schemas
+    end
+    
+    # Remove the cached schema_utility_dataset, because the identifier
+    # quoting has changed.
+    def reset_schema_utility_dataset
+      @schema_utility_dataset = nil
+    end
+
+    # Match the database's column type to a ruby type via a
+    # regular expression.  The following ruby types are supported:
+    # integer, string, date, datetime, boolean, and float.
+    def schema_column_type(db_type)
+      case db_type
+      when /\Atinyint/io
+        Sequel.convert_tinyint_to_bool ? :boolean : :integer
+      when /\Ainterval\z/io
+        :interval
+      when /\A(character( varying)?|varchar|text)/io
+        :string
+      when /\A(int(eger)?|bigint|smallint)/io
+        :integer
+      when /\Adate\z/io
+        :date
+      when /\A(datetime|timestamp( with(out)? time zone)?)\z/io
+        :datetime
+      when /\Atime( with(out)? time zone)?\z/io
+        :time
+      when /\Aboolean\z/io
+        :boolean
+      when /\A(real|float|double( precision)?)\z/io
+        :float
+      when /\A(numeric(\(\d+,\d+\))?|decimal|money)\z/io
+        :decimal
+      when /bytea|blob/io
+        :blob
+      end
+    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/dataset.rb

@@ -0,0 +1,422 @@
+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
+  # 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:
+  #
+  #   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
+  #
+  # 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:
+  #
+  #   posts = DB[:posts]
+  #   davids_posts = posts.filter(:author => 'david')
+  #   old_posts = 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.
+  #
+  # === Methods added via metaprogramming
+  #
+  # Some methods are added via metaprogramming:
+  #
+  # * ! methods - These methods are the same as their non-! counterparts,
+  #   but they modify the receiver instead of returning a modified copy
+  #   of the dataset.
+  # * inner_join, full_outer_join, right_outer_join, left_outer_join - 
+  #   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
+
+    # All methods that should have a ! method added that modifies
+    # the receiver.
+    MUTATION_METHODS = %w'add_graph_aliases and distinct exclude exists
+    filter from from_self full_outer_join graph
+    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_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
+    
+    # Set the method to call on identifiers going into the database for this dataset
+    attr_accessor :identifier_input_method
+    
+    # Set the method to call on identifiers coming the database for this dataset
+    attr_accessor :identifier_output_method
+
+    # The hash of options for this dataset, keys are symbols.
+    attr_accessor :opts
+
+    # Whether to quote identifiers for this dataset
+    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.
+    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:
+    #
+    #   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.
+    def initialize(db, opts = nil)
+      @db = db
+      @quote_identifiers = db.quote_identifiers? if db.respond_to?(:quote_identifiers?)
+      @identifier_input_method = db.identifier_input_method if db.respond_to?(:identifier_input_method)
+      @identifier_output_method = db.identifier_output_method if db.respond_to?(:identifier_output_method)
+      @opts = opts || {}
+      @row_proc = nil
+      @transform = nil
+    end
+    
+    ### Class Methods ###
+
+    # 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.
+    def self.def_mutation_method(*meths)
+      meths.each do |meth|
+        class_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
+    end
+
+    ### Instance Methods ###
+
+    # Alias for insert, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def <<(*args)
+      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.
+    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 = (defarg=true;nil), &block)
+      Deprecation.deprecate("Calling Dataset#all with an argument is deprecated and will raise an error in a future version.  Use dataset.clone(opts).all.") unless defarg
+      a = []
+      defarg ? each{|r| a << r} : each(opts){|r| a << r}
+      post_load(a)
+      a.each(&block) if block
+      a
+    end
+  
+    # Returns a new clone of the dataset with with the given options merged.
+    # If the options changed include options in COLUMN_CHANGE_OPTS, the cached
+    # columns are deleted.
+    def clone(opts = {})
+      c = super()
+      c.opts = @opts.merge(opts)
+      c.instance_variable_set(:@columns, nil) if opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
+      c
+    end
+    
+    # Returns the columns in the result set in their true 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 Database#schema.
+    def columns
+      return @columns if @columns
+      ds = unfiltered.unordered.clone(:distinct => nil, :limit => 1)
+      ds.each{break}
+      @columns = ds.instance_variable_get(:@columns)
+      @columns || []
+    end
+    
+    # Remove the cached list of columns and do a SELECT query to find
+    # the columns.
+    def columns!
+      @columns = nil
+      columns
+    end
+    
+    # Add a mutation method to this dataset instance.
+    def def_mutation_method(*meths)
+      meths.each do |meth|
+        instance_eval("def #{meth}!(*args, &block); mutation_method(:#{meth}, *args, &block) end")
+      end
+    end
+
+    # Deletes the records in the dataset.  The returned value is generally the
+    # number of records deleted, but that is adapter dependent.
+    def delete(opts=(defarg=true;nil))
+      Deprecation.deprecate("Calling Dataset#delete with an argument is deprecated and will raise an error in a future version.  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 = (defarg=true;nil), &block)
+      Deprecation.deprecate("Calling Dataset#each with an argument is deprecated and will raise an error in a future version.  Use dataset.clone(opts).each.") unless defarg
+      if opts && opts.keys.any?{|o| COLUMN_CHANGE_OPTS.include?(o)}
+        prev_columns = @columns
+        begin
+          defarg ? _each(&block) : _each(opts, &block)
+        ensure
+          @columns = prev_columns
+        end
+      else
+        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.
+    def fetch_rows(sql, &block)
+      raise NotImplementedError, NOTIMPL_MSG
+    end
+  
+    # Inserts values into the associated table.  The returned value is generally
+    # the value of the primary key for the inserted row, but that is adapter dependent.
+    def insert(*values)
+      execute_insert(insert_sql(*values))
+    end
+  
+    # Returns a string representation of the dataset including the class name 
+    # and the corresponding SQL select statement.
+    def inspect
+      "#<#{self.class}: #{sql.inspect}>"
+    end
+
+    # Returns a naked dataset clone - i.e. a dataset that returns records as
+    # hashes instead of calling the row proc.
+    def naked
+      ds = clone
+      ds.row_proc = nil
+      ds
+    end
+    
+    # Whether this dataset quotes identifiers.
+    def quote_identifiers?
+      @quote_identifiers
+    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.
+    def server(servr)
+      clone(:server=>servr)
+    end
+
+    # Alias for set, but not aliased directly so subclasses
+    # don't have to override both methods.
+    def set(*args)
+      update(*args)
+    end
+
+    # Set the default values for insert and update statements.  The values passed
+    # to insert or update are merged into this hash.
+    def set_defaults(hash)
+      clone(:defaults=>(@opts[:defaults]||{}).merge(hash))
+    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
+    
+    # Updates values for the dataset.  The returned value is generally the
+    # number of rows updated, but that is adapter dependent.
+    def update(values={}, opts=(defarg=true;nil))
+      Deprecation.deprecate("Calling Dataset#update with an argument is deprecated and will raise an error in a future version.  Use dataset.clone(opts).update.") unless defarg
+      execute_dui(defarg ? update_sql(values) : update_sql(value, opts))
+    end
+  
+    # Add the mutation methods via metaprogramming
+    def_mutation_method(*MUTATION_METHODS)
+
+    protected
+
+    # Return true if the dataset has a non-nil value for any key in opts.
+    def options_overlap(opts)
+      !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
+    end
+
+    private
+    
+    # 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=(defarg=true;nil), &block)
+      if @opts[:graph] and !(opts && opts[:graph] == false)
+        defarg ? graph_each(&block) : graph_each(opts, &block)
+      else
+        row_proc = @row_proc unless opts && opts[:naked]
+        transform = @transform
+        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
+        end
+      end
+    end
+
+    # Set the server to use to :default unless it is already set in the passed opts
+    def default_server_opts(opts)
+      {:server=>@opts[:server] || :default}.merge(opts)
+    end
+
+    # Execute the given SQL on the database using execute.
+    def execute(sql, opts={}, &block)
+      @db.execute(sql, {:server=>@opts[:server] || :read_only}.merge(opts), &block)
+    end
+    
+    # Execute the given SQL on the database using execute_dui.
+    def execute_dui(sql, opts={}, &block)
+      @db.execute_dui(sql, default_server_opts(opts), &block)
+    end
+    
+    # Execute the given SQL on the database using execute_insert.
+    def execute_insert(sql, opts={}, &block)
+      @db.execute_insert(sql, default_server_opts(opts), &block)
+    end
+    
+    # Modify the identifier returned from the database based on the
+    # identifier_output_method.
+    def input_identifier(v)
+      (i = identifier_input_method) ? v.to_s.send(i) : v.to_s
+    end
+
+    # Modify the receiver with the results of sending the meth, args, and block
+    # to the receiver and merging the options of the resulting dataset into
+    # the receiver's options.
+    def mutation_method(meth, *args, &block)
+      copy = send(meth, *args, &block)
+      @opts.merge!(copy.opts)
+      self
+    end
+    
+    # Modify the identifier returned from the database based on the
+    # identifier_output_method.
+    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 a future version.  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