sequel 0.1.7 → 0.1.8

data/CHANGELOG

@@ -1,4 +1,26 @@
-*0.1.7*
+=== 0.1.8 (2007-07-10)
+
+* Implemented Dataset#columns for retrieving the columns in the result set.
+
+* Updated Model with changes to how model-associated datasets work.
+
+* Beefed-up specs. Coverage is now at 95.0%.
+
+* Added support for polymorphic datasets.
+
+* The adapter dataset interface was simplified and standardized. Only four methods need be overriden: fetch_rows, update, insert and delete.
+
+* The Dataset class was refactored. The bulk of the dataset code was moved into separate modules.
+
+* Renamed Dataset#hash_column to Dataset#to_hash.
+
+* Added some common pragmas to sqlite adapter.
+
+* Added Postgres::Dataset#analyze for EXPLAIN ANALYZE queries.
+
+* Fixed broken Postgres::Dataset#explain.
+
+=== 0.1.7
 
 * Removed db.synchronize wrapping calls in sqlite adapter.
 
@@ -20,7 +42,7 @@
 
 * Fixed Symbol#DESC to support qualified notation (thanks Pedro Gutierrez).
 
-*0.1.6*
+=== 0.1.6
 
 * Fixed Model#method_missing to raise for an invalid attribute.
 
@@ -42,11 +64,11 @@
 
 * Added Dataset#or, pretty nifty.
 
-*0.1.5*
+=== 0.1.5
 
 * Fixed Dataset#join to support multiple joins. Added #left_outer_join, #right_outer_join, #full_outer_join, #inner_join methods.
 
-*0.1.4*
+=== 0.1.4
 
 * Added String#split_sql.
 
@@ -61,13 +83,13 @@
 
 * Implemented ODBC adapter.
 
-*0.1.3*
+=== 0.1.3
 
 * Implemented DBI adapter.
 
 * Refactored database connection code. Now handled through Database#connect.
 
-*0.1.2*
+=== 0.1.2
 
 * The first opened database is automatically assigned to to Model.db.
 
@@ -89,7 +111,7 @@
 
 * Refactored and removed deprecated code in postgres adapter.
 
-*0.1.1*
+===0.1.1
 
 * More documentation for Dataset.
 
@@ -105,7 +127,7 @@
 
 * Cleaned up Dataset API.
 
-*0.1.0*
+=== 0.1.0
 
 * Changed Database#create_table to only accept a block. Nobody's gonna use the other way.
 
@@ -127,7 +149,7 @@
 
 * Refactored literalization of Time objects.
 
-*0.0.20*
+=== 0.0.20
 
 * Refactored Dataset where clause construction to use expressions.
 
@@ -139,7 +161,7 @@
 
 * Specs for Database.
 
-*0.0.19*
+=== 0.0.19
 
 * More specs for Dataset.
 
@@ -157,7 +179,7 @@
 
 * Specs for ConnectionPool.
 
-*0.0.18*
+=== 0.0.18
 
 * Implemented SequelError and SequelConnectionError classes. ConnectionPool#hold now catches any connection errors and reraises them SequelConnectionError.
 
@@ -167,7 +189,7 @@
 
 * Fixed Dataset#exclude to work correctly (patch and specs by Alex Bradbury.)
 
-*0.0.17*
+=== 0.0.17
 
 * Fixed Postgres::Database#tables to return table names as symbols (caused problem when using Database#table_exists?).
 
@@ -183,7 +205,7 @@
 
 * Added support for DISTINCT and OFFSET clauses (patches by Alex Bradbury.) Dataset#limit now accepts ranges. Added Dataset#uniq and distinct methods.
 
-*0.0.16*
+=== 0.0.16
 
 * More documentation.
 
@@ -197,7 +219,7 @@
 
 * Changed Dataset#destroy to return the number of deleted records.
 
-*0.0.15*
+=== 0.0.15
 
 * Improved Dataset#insert_sql to allow arrays as well as hashes.
 
@@ -205,7 +227,7 @@
 
 * Added Model#id to to return the id column.
 
-*0.0.14*
+=== 0.0.14
 
 * Fixed Model's attribute accessors (hopefully for the last time).
 
@@ -213,13 +235,13 @@
 
 * Fixed bug in aggregate methods (max, min, etc) for datasets using record classes.
 
-*0.0.13*
+=== 0.0.13
 
 * Fixed Model#method_missing to do both find, filter and attribute accessors. duh.
 
 * Fixed bug in Dataset#literal when quoting arrays of strings (thanks Douglas Koszerek.)
 
-*0.0.12*
+=== 0.0.12
 
 * Model#save now correctly performs an INSERT for new objects.
 
@@ -231,7 +253,7 @@
 
 * Fixed filtering using nil values (e.g. dataset.filter(:parent_id => nil)).
 
-*0.0.11*
+=== 0.0.11
 
 * Renamed Model.schema to Model.set_schema and Model.get_schema to Model.schema.
 
@@ -239,13 +261,13 @@
 
 * Removed require 'postgres' in schema.rb (thanks Douglas Koszerek.)
 
-*0.0.10*
+=== 0.0.10
 
 * Added some examples.
 
 * Added Dataset#print method for pretty-printing tables.
 
-*0.0.9*
+=== 0.0.9
 
 * Fixed Postgres::Database#tables and #locks methods.
 
@@ -257,7 +279,7 @@
 
 * Refactored and DRY'd Dataset#literal and overrides therof. Added support for subqueries in where clause.
 
-*0.0.8*
+=== 0.0.8
 
 * Fixed Dataset#reverse_order to provide chainability. This method can be called without arguments to invert the current order or with arguments to provide a descending order.
 
@@ -265,11 +287,11 @@
 
 * Refactored insert code in Postgres adapter (in preparation for fetching the last insert id for pre-8.1 versions).
 
-*0.0.7*
+=== 0.0.7
 
 * Fixed bug in Model.schema, duh!
 
-*0.0.6*
+=== 0.0.6
 
 * Added Dataset#sql as alias to Dataset#select_sql.
 
@@ -283,7 +305,7 @@
 
 * Implemented SQLite::Database#tables.
 
-*0.0.5*
+=== 0.0.5
 
 * Added Dataset#[] method. Refactored Model#find and Model#[].
 
@@ -291,13 +313,13 @@
 
 * Added automatic require 'sequel' to all adapters for convenience.
 
-*0.0.4*
+=== 0.0.4
 
 * Added preliminary MySQL support.
 
 * Code cleanup.
 
-*0.0.3*
+=== 0.0.3
 
 * Add Dataset#sum method.
 
@@ -307,7 +329,7 @@
 
 * Fixed small bug in Dataset#qualified_field_name for better join support.
 
-*0.0.2*
+=== 0.0.2
 
 * Added Sequel.open as alias to Sequel.connect.
 
@@ -320,7 +342,7 @@ method for saving them.
 
 * Refactored Dataset#first and Dataset#last code. These methods can now accept the number of records to fetch.
 
-*0.0.1*
+=== 0.0.1
 
 * More documentation for Dataset.
 

data/README

@@ -67,7 +67,7 @@ Sequel also offers convenience methods for extracting data from Datasets, such a
   
 Or getting results as a transposed hash, with one column as key and another as value:
 
-  middle_east.hash_column(:name, :area) #=> {'Israel' => 20000, 'Greece' => 120000, ...}
+  middle_east.to_hash(:name, :area) #=> {'Israel' => 20000, 'Greece' => 120000, ...}
 
 Much of Sequel is still undocumented (especially the part relating to model classes). The following section provides examples of common usage. Feel free to explore...
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.7"
+VERS = "0.1.8"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",
@@ -46,8 +46,7 @@ spec = Gem::Specification.new do |s|
   s.add_dependency('metaid')
   s.required_ruby_version = '>= 1.8.2'
 
-#  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
-  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,lib}/**/*")
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
       
   s.require_path = "lib"
   s.bindir = "bin"
@@ -81,6 +80,17 @@ Spec::Rake::SpecTask.new('spec') do |t|
   t.rcov = true
 end
 
+desc "Run adapter specs without coverage"
+Spec::Rake::SpecTask.new('spec_adapters') do |t|
+  t.spec_files = FileList['spec/adapters/*_spec.rb']
+end
+
+desc "Run all specs with coverage"
+Spec::Rake::SpecTask.new('spec_all') do |t|
+  t.spec_files = FileList['spec/*_spec.rb', 'spec/adapters/*_spec.rb']
+  t.rcov = true
+end
+
 ##############################################################################
 # Statistics
 ##############################################################################

data/lib/sequel/database.rb

@@ -24,7 +24,7 @@ module Sequel
     end
     
     def connect
-      true # we can't return nil or false, because then pool will block forever
+      raise NotImplementedError, "#connect should be overriden by adapters"
     end
     
     def uri
@@ -47,7 +47,7 @@ module Sequel
     
     # Returns a blank dataset
     def dataset
-      Dataset.new(self)
+      Sequel::Dataset.new(self)
     end
 
     # Returns a new dataset with the from method invoked.

data/lib/sequel/dataset.rb

@@ -1,6 +1,9 @@
 require 'time'
 require 'date'
 
+require File.join(File.dirname(__FILE__), 'dataset/dataset_sql')
+require File.join(File.dirname(__FILE__), 'dataset/dataset_convenience')
+
 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
@@ -22,11 +25,52 @@ module Sequel
   #
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
+  #
+  # === The Dataset Adapter Interface
+  #
+  # Each adapter should define its own dataset class as a descendant of
+  # Sequel::Dataset. The following methods should be overriden by the adapter
+  # Dataset class (each method with the stock implementation):
+  #
+  #   # Iterate over the results of the SQL query and call the supplied
+  #   # block with each record (as a hash).
+  #   def fetch_rows(sql, &block)
+  #     @db.synchronize do
+  #       r = @db.execute(sql)
+  #       r.each(&block)
+  #     end
+  #   end
+  #
+  #   # Insert records.
+  #   def insert(*values)
+  #     @db.synchronize do
+  #       @db.execute(insert_sql(*values)).last_insert_id
+  #     end
+  #   end
+  #
+  #   # Update records.
+  #   def update(values, opts = nil)
+  #     @db.synchronize do
+  #       @db.execute(update_sql(values, opts)).affected_rows
+  #     end
+  #   end
+  #
+  #   # Delete records.
+  #   def delete(opts = nil)
+  #     @db.synchronize do
+  #       @db.execute(delete_sql(opts)).affected_rows
+  #     end
+  #   end
   class Dataset
     include Enumerable
+    include SQL # in dataset/dataset_sql.rb
+    include Convenience # in dataset/dataset_convenience.rb
+    
+    attr_reader :db
+    attr_accessor :opts
     
-    attr_reader :db, :opts
-    attr_accessor :model_class
+    alias all to_a
+    alias size count
   
     # Constructs a new instance of a dataset with a database instance, initial
     # options and an optional record class. Datasets are usually constructed by
@@ -37,715 +81,177 @@ module Sequel
     #
     # 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, model_class = nil)
+    def initialize(db, opts = nil)
       @db = db
       @opts = opts || {}
-      @model_class = model_class
     end
     
     # Returns a new instance of the dataset with with the give options merged.
-    def dup_merge(opts)
-      self.class.new(@db, @opts.merge(opts), @model_class)
-    end
-    
-    # Returns a dataset that fetches records as hashes (instead of model 
-    # objects). If no record class is defined for the dataset, self is
-    # returned.
-    def naked
-      @model_class ? self.class.new(@db, opts || @opts.dup) : self
-    end
-    
-    # Returns a valid SQL fieldname as a string. Field names specified as 
-    # symbols can include double underscores to denote a dot separator, e.g.
-    # :posts__id will be converted into posts.id.
-    def field_name(field)
-      field.is_a?(Symbol) ? field.to_field_name : field
-    end
-    
-    QUALIFIED_REGEXP = /(.*)\.(.*)/.freeze
-
-    # Returns a qualified field name (including a table name) if the field
-    # name isn't already qualified.
-    def qualified_field_name(field, table)
-      fn = field_name(field)
-      fn =~ QUALIFIED_REGEXP ? fn : "#{table}.#{fn}"
-    end
-    
-    WILDCARD = '*'.freeze
-    COMMA_SEPARATOR = ", ".freeze
-    
-    # Converts an array of field names into a comma seperated string of 
-    # field names. If the array is empty, a wildcard (*) is returned.
-    def field_list(fields)
-      if fields.empty?
-        WILDCARD
-      else
-        fields.map {|i| field_name(i)}.join(COMMA_SEPARATOR)
-      end
-    end
-    
-    # Converts an array of sources names into into a comma separated list.
-    def source_list(source)
-      if source.nil? || source.empty?
-        raise SequelError, 'No source specified for query'
-      end
-      source.map {|i| i.is_a?(Dataset) ? i.to_table_reference : i}.
-        join(COMMA_SEPARATOR)
-    end
-    
-    NULL = "NULL".freeze
-    TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S'".freeze
-    DATE_FORMAT = "DATE '%Y-%m-%d'".freeze
-    
-    # Returns a literal representation of a value to be used as part
-    # of an SQL expression. The stock implementation supports literalization 
-    # of String (with proper escaping to prevent SQL injections), numbers,
-    # Symbol (as field references), Array (as a list of literalized values),
-    # Time (as an SQL TIMESTAMP), Date (as an SQL DATE), Dataset (as a 
-    # subquery) and nil (AS NULL).
-    # 
-    #   dataset.literal("abc'def") #=> "'abc''def'"
-    #   dataset.literal(:items__id) #=> "items.id"
-    #   dataset.literal([1, 2, 3]) => "(1, 2, 3)"
-    #   dataset.literal(DB[:items]) => "(SELECT * FROM items)"
-    #
-    # If an unsupported object is given, an exception is raised.
-    def literal(v)
-      case v
-      when ExpressionString: v
-      when String: "'#{v.gsub(/'/, "''")}'"
-      when Integer, Float: v.to_s
-      when NilClass: NULL
-      when Symbol: v.to_field_name
-      when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
-      when Time: v.strftime(TIMESTAMP_FORMAT)
-      when Date: v.strftime(DATE_FORMAT)
-      when Dataset: "(#{v.sql})"
-      else
-        raise SequelError, "can't express #{v.inspect} as a SQL literal"
-      end
-    end
-
-    AND_SEPARATOR = " AND ".freeze
-    
-    # Formats an equality expression involving a left value and a right value.
-    # Equality expressions differ according to the class of the right value.
-    # The stock implementation supports Range (inclusive and exclusive), Array
-    # (as a list of values to compare against), Dataset (as a subquery to
-    # compare against), or a regular value.
-    #
-    #   dataset.format_eq_expression('id', 1..20) #=>
-    #     "(id >= 1 AND id <= 20)"
-    #   dataset.format_eq_expression('id', [3,6,10]) #=>
-    #     "(id IN (3, 6, 10))"
-    #   dataset.format_eq_expression('id', DB[:items].select(:id)) #=>
-    #     "(id IN (SELECT id FROM items))"
-    #   dataset.format_eq_expression('id', nil) #=>
-    #     "(id IS NULL)"
-    #   dataset.format_eq_expression('id', 3) #=>
-    #     "(id = 3)"
-    def format_eq_expression(left, right)
-      case right
-      when Range:
-        right.exclude_end? ? \
-          "(#{left} >= #{right.begin} AND #{left} < #{right.end})" : \
-          "(#{left} >= #{right.begin} AND #{left} <= #{right.end})"
-      when Array:
-        "(#{left} IN (#{literal(right)}))"
-      when Dataset:
-        "(#{left} IN (#{right.sql}))"
-      when NilClass:
-        "(#{left} IS NULL)"
-      else
-        "(#{left} = #{literal(right)})"
-      end
-    end
-    
-    # Formats an expression comprising a left value, a binary operator and a
-    # right value. The supported operators are :eql (=), :not (!=), :lt (<),
-    # :lte (<=), :gt (>), :gte (>=) and :like (LIKE operator). Examples:
-    #
-    #   dataset.format_expression('price', :gte, 100) #=> "(price >= 100)"
-    #   dataset.format_expression('id', :not, 30) #=> "NOT (id = 30)"
-    #   dataset.format_expression('name', :like, 'abc%') #=>
-    #     "(name LIKE 'abc%')"
-    #
-    # If an unsupported operator is given, an exception is raised.
-    def format_expression(left, op, right)
-      left = field_name(left)
-      case op
-      when :eql:
-        format_eq_expression(left, right)
-      when :not:
-        "NOT #{format_eq_expression(left, right)}"
-      when :lt:
-        "(#{left} < #{literal(right)})"
-      when :lte:
-        "(#{left} <= #{literal(right)})"
-      when :gt:
-        "(#{left} > #{literal(right)})"
-      when :gte:
-        "(#{left} >= #{literal(right)})"
-      when :like:
-        "(#{left} LIKE #{literal(right)})"
-      else
-        raise SequelError, "Invalid operator specified: #{op}"
-      end
-    end
-    
-    QUESTION_MARK = '?'.freeze
-    
-    # Formats a where clause. If parenthesize is true, then the whole 
-    # generated clause will be enclosed in a set of parentheses.
-    def expression_list(where, parenthesize = false)
-      case where
-      when Hash:
-        parenthesize = false if where.size == 1
-        fmt = where.map {|i| format_expression(i[0], :eql, i[1])}.
-          join(AND_SEPARATOR)
-      when Array:
-        fmt = where.shift.gsub(QUESTION_MARK) {literal(where.shift)}
-      when Proc:
-        fmt = where.to_expressions.map {|e| format_expression(e.left, e.op, e.right)}.
-          join(AND_SEPARATOR)
-      else
-        # if the expression is compound, it should be parenthesized in order for 
-        # things to be predictable (when using #or and #and.)
-        parenthesize |= where =~ /\).+\(/
-        fmt = where
-      end
-      parenthesize ? "(#{fmt})" : fmt
-    end
-    
-    # Returns a copy of the dataset with the source changed.
-    def from(*source)
-      dup_merge(:from => source)
-    end
-    
-    # Returns a copy of the dataset with the selected fields changed.
-    def select(*fields)
-      dup_merge(:select => fields)
-    end
-
-    # Returns a copy of the dataset with the distinct option.
-    def uniq
-      dup_merge(:distinct => true)
-    end
-    alias distinct uniq
-
-    # Returns a copy of the dataset with the order changed.
-    def order(*order)
-      dup_merge(:order => order)
+    def clone_merge(opts)
+      new_dataset = clone
+      new_dataset.set_options(@opts.merge(opts))
+      new_dataset
     end
     
-    # Returns a copy of the dataset with the order reversed. If no order is
-    # given, the existing order is inverted.
-    def reverse_order(*order)
-      order(invert_order(order.empty? ? @opts[:order] : order))
+    def set_options(opts)
+      @opts = opts
+      @columns = nil
     end
     
-    DESC_ORDER_REGEXP = /(.*)\sDESC/.freeze
+    NOTIMPL_MSG = "This method must be overriden in Sequel adapters".freeze
     
-    # Inverts the given order by breaking it into a list of field references
-    # and inverting them.
-    #
-    #   dataset.invert_order('id DESC') #=> "id"
-    #   dataset.invert_order('category, price DESC') #=>
-    #     "category DESC, price"
-    def invert_order(order)
-      new_order = []
-      order.each do |f|
-        f.to_s.split(',').map do |p|
-          p.strip!
-          new_order << (p =~ DESC_ORDER_REGEXP ? $1 : p.to_sym.DESC)
-        end
-      end
-      new_order
-    end
-    
-    # Returns a copy of the dataset with the results grouped by the value of 
-    # the given fields
-    def group(*fields)
-      dup_merge(:group => fields)
-    end
-
-    # Returns a copy of the dataset with the given conditions imposed upon it.  
-    # If the query has been grouped, then the conditions are imposed in the 
-    # HAVING clause. If not, then they are imposed in the WHERE clause. Filter
-    # accepts a Hash (formated into a list of equality expressions), an Array
-    # (formatted ala ActiveRecord conditions), a String (taken literally), or
-    # a block that is converted into expressions.
-    #
-    #   dataset.filter(:id => 3).sql #=>
-    #     "SELECT * FROM items WHERE (id = 3)"
-    #   dataset.filter('price < ?', 100).sql #=>
-    #     "SELECT * FROM items WHERE price < 100"
-    #   dataset.filter('price < 100').sql #=>
-    #     "SELECT * FROM items WHERE price < 100"
-    #   dataset.filter {price < 100}.sql #=>
-    #     "SELECT * FROM items WHERE (price < 100)"
-    # 
-    # Multiple filter calls can be chained for scoping:
-    #
-    #   software = dataset.filter(:category => 'software')
-    #   software.filter {price < 100}.sql #=>
-    #     "SELECT * FROM items WHERE (category = 'software') AND (price < 100)"
-    def filter(*cond, &block)
-      clause = (@opts[:group] ? :having : :where)
-      cond = cond.first if cond.size == 1
-      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-      filter = cond.is_a?(Hash) && cond
-      if @opts[clause]
-        if filter && cond.is_a?(Hash)
-          filter
-        end
-        filter = 
-        l = expression_list(@opts[clause])
-        r = expression_list(block || cond, parenthesize)
-        dup_merge(clause => "#{l} AND #{r}")
-      else
-        dup_merge(:filter => cond, clause => expression_list(block || cond))
-      end
+    # Executes a select query and fetches records, passing each record to the
+    # supplied block. Adapters should override this method.
+    def fetch_rows(sql, &block)
+      # @db.synchronize do
+      #   r = @db.execute(sql)
+      #   r.each(&block)
+      # end
+      raise NotImplementedError, NOTIMPL_MSG
     end
-    
-    # Adds an alternate filter to an existing filter using OR. If no filter 
-    # exists an error is raised.
-    def or(*cond, &block)
-      clause = (@opts[:group] ? :having : :where)
-      cond = cond.first if cond.size == 1
-      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-      if @opts[clause]
-        l = expression_list(@opts[clause])
-        r = expression_list(block || cond, parenthesize)
-        dup_merge(clause => "#{l} OR #{r}")
-      else
-        raise SequelError, "No existing filter found."
-      end
-    end
-
-    # Adds an further filter to an existing filter using AND. If no filter 
-    # exists an error is raised. This method is identical to #filter except
-    # it expects an existing filter.
-    def and(*cond, &block)
-      clause = (@opts[:group] ? :having : :where)
-      unless @opts[clause]
-        raise SequelError, "No existing filter found."
-      end
-      filter(*cond, &block)
-    end
-
-    # Performs the inverse of Dataset#filter.
-    #
-    #   dataset.exclude(:category => 'software').sql #=>
-    #     "SELECT * FROM items WHERE NOT (category = 'software')"
-    def exclude(*cond, &block)
-      clause = (@opts[:group] ? :having : :where)
-      cond = cond.first if cond.size == 1
-      parenthesize = !(cond.is_a?(Hash) || cond.is_a?(Array))
-      if @opts[clause]
-        l = expression_list(@opts[clause])
-        r = expression_list(block || cond, parenthesize)
-        cond = "#{l} AND NOT #{r}"
-      else
-        cond = "NOT #{expression_list(block || cond, true)}"
-      end
-      dup_merge(clause => cond)
-    end
-    
-    # Returns a copy of the dataset with the where conditions changed. Raises 
-    # if the dataset has been grouped. See also #filter.
-    def where(*cond, &block)
-      if @opts[:group]
-        raise SequelError, "Can't specify a WHERE clause once the dataset has been grouped"
-      else
-        filter(*cond, &block)
-      end
-    end
-
-    # Returns a copy of the dataset with the having conditions changed. Raises 
-    # if the dataset has not been grouped. See also #filter
-    def having(*cond, &block)
-      unless @opts[:group]
-        raise SequelError, "Can only specify a HAVING clause on a grouped dataset"
-      else
-        filter(*cond, &block)
-      end
-    end
-    
-    # Adds a UNION clause using a second dataset object. If all is true the
-    # clause used is UNION ALL, which may return duplicate rows.
-    def union(dataset, all = false)
-      dup_merge(:union => dataset, :union_all => all)
+  
+    # Inserts values into the associated table. Adapters should override this
+    # method.
+    def insert(*values)
+      # @db.synchronize do
+      #   @db.execute(insert_sql(*values)).last_insert_id
+      # end
+      raise NotImplementedError, NOTIMPL_MSG
     end
-
-    # Adds an INTERSECT clause using a second dataset object. If all is true 
-    # the clause used is INTERSECT ALL, which may return duplicate rows.
-    def intersect(dataset, all = false)
-      dup_merge(:intersect => dataset, :intersect_all => all)
+  
+    # Updates values for the dataset. Adapters should override this method.
+    def update(values, opts = nil)
+      # @db.synchronize do
+      #   @db.execute(update_sql(values, opts)).affected_rows
+      # end
+      raise NotImplementedError, NOTIMPL_MSG
     end
-
-    # Adds an EXCEPT clause using a second dataset object. If all is true the
-    # clause used is EXCEPT ALL, which may return duplicate rows.
-    def except(dataset, all = false)
-      dup_merge(:except => dataset, :except_all => all)
+  
+    # Deletes the records in the dataset. Adapters should override this method.
+    def delete(opts = nil)
+      # @db.synchronize do
+      #   @db.execute(delete_sql(opts)).affected_rows
+      # end
+      raise NotImplementedError, NOTIMPL_MSG
     end
     
-    JOIN_TYPES = {
-      :left_outer => 'LEFT OUTER JOIN'.freeze,
-      :right_outer => 'RIGHT OUTER JOIN'.freeze,
-      :full_outer => 'FULL OUTER JOIN'.freeze,
-      :inner => 'INNER JOIN'.freeze
-    }
-    
-    def join_expr(type, table, expr)
-      join_type = JOIN_TYPES[type || :inner]
-      unless join_type
-        raise SequelError, "Invalid join type: #{type}"
-      end
-      
-      join_expr = expr.map do |k, v|
-        l = qualified_field_name(k, table)
-        r = qualified_field_name(v, @opts[:last_joined_table] || @opts[:from])
-        "(#{l} = #{r})"
-      end.join(AND_SEPARATOR)
-      
-      " #{join_type} #{table} ON #{join_expr}"
+    # Returns the columns in the result set in their true order. The stock 
+    # implementation returns the content of @columns. If @columns is nil,
+    # a query is performed. Adapters are expected to fill @columns with the
+    # column information when a query is performed.
+    def columns
+      first unless @columns
+      @columns || []
     end
     
-    # Returns a joined dataset.
-    def join_table(type, table, expr)
-      unless expr.is_a?(Hash)
-        expr = {expr => :id}
-      end
-      clause = join_expr(type, table, expr)
-      join = @opts[:join] ? @opts[:join] + clause : clause
-      dup_merge(:join => join, :last_joined_table => table)
+    def <<(*args)
+      insert(*args)
     end
     
-    def left_outer_join(table, expr); join_table(:left_outer, table, expr); end
-    def right_outer_join(table, expr); join_table(:right_outer, table, expr); end
-    def full_outer_join(table, expr); join_table(:full_outer, table, expr); end
-    def inner_join(table, expr); join_table(:inner, table, expr); end
-    alias_method :join, :inner_join
-
-    alias_method :all, :to_a
-    
-    # Maps field values for each record in the dataset (if a field name is
-    # given), or performs the stock mapping functionality of Enumerable.
-    def map(field_name = nil, &block)
-      if field_name
-        super() {|r| r[field_name]}
-      else
-        super(&block)
-      end
+    # Iterates over the records in the dataset
+    def each(opts = nil, &block)
+      fetch_rows(select_sql(opts), &block)
     end
     
-    # Returns a hash with one column used as key and another used as value.
-    def hash_column(key_column, value_column)
-      inject({}) do |m, r|
-        m[r[key_column]] = r[value_column]
-        m
-      end
+    # Returns the the model classes associated with the dataset as a hash.
+    def model_classes
+      @opts[:models]
     end
     
-    # Inserts the given values into the table.
-    def <<(values)
-      insert(values)
+    # Returns the column name for the polymorphic key.
+    def polymorphic_key
+      @opts[:polymorphic_key]
     end
     
-    # Inserts multiple values. If a block is given it is invoked for each
-    # item in the given array before inserting it.
-    def insert_multiple(array, &block)
-      if block
-        array.each {|i| insert(block[i])}
+    # Returns a naked dataset clone - i.e. a dataset that returns records as
+    # hashes rather than model objects.
+    def naked
+      d = clone_merge(:naked => true, :models => nil, :polymorphic_key => nil)
+      d.set_model(nil)
+      d
+    end
+    
+    # Associates the dataset with a model. If 
+    def set_model(*args)
+      if args.empty? || (args.first == nil)
+        @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
+        extend_with_stock_each
+      elsif args.size == 1
+        c = args.first
+        @opts.merge!(:naked => nil, :models => {nil => c}, :polymorphic_key => nil)
+        extend_with_model(c)
+        extend_with_destroy
       else
-        array.each {|i| insert(i)}
-      end
-    end
-
-    EMPTY = ''.freeze
-    SPACE = ' '.freeze
-    
-    # Formats a SELECT statement using the given options and the dataset
-    # options.
-    def select_sql(opts = nil)
-      opts = opts ? @opts.merge(opts) : @opts
-
-      fields = opts[:select]
-      select_fields = fields ? field_list(fields) : WILDCARD
-      select_source = source_list(opts[:from])
-      sql = opts[:distinct] ? \
-        "SELECT DISTINCT #{select_fields} FROM #{select_source}" : \
-        "SELECT #{select_fields} FROM #{select_source}"
-      
-      if join = opts[:join]
-        sql << join
-      end
-      
-      if where = opts[:where]
-        sql << " WHERE #{where}"
-      end
-      
-      if group = opts[:group]
-        sql << " GROUP BY #{field_list(group)}"
-      end
-
-      if order = opts[:order]
-        sql << " ORDER BY #{field_list(order)}"
-      end
-      
-      if having = opts[:having]
-        sql << " HAVING #{having}"
-      end
-
-      if limit = opts[:limit]
-        sql << " LIMIT #{limit}"
-        if offset = opts[:offset]
-          sql << " OFFSET #{offset}"
+        key, hash = args
+        @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
+        extend_with_polymorphic_model(key, hash)
+        extend_with_destroy
+      end
+      self
+    end
+    
+    private
+    # Overrides the each method to convert records to model instances.
+    def extend_with_model(c)
+      meta_def(:model_class) {c}
+      m = Module.new do
+        def each(opts = nil, &block)
+          c = model_class
+          if opts && opts[:naked]
+            fetch_rows(select_sql(opts), &block)
+          else
+            fetch_rows(select_sql(opts)) {|r| block.call(c.new(r))}
+          end
         end
       end
-      
-      if union = opts[:union]
-        sql << (opts[:union_all] ? \
-          " UNION ALL #{union.sql}" : " UNION #{union.sql}")
-      elsif intersect = opts[:intersect]
-        sql << (opts[:intersect_all] ? \
-          " INTERSECT ALL #{intersect.sql}" : " INTERSECT #{intersect.sql}")
-      elsif except = opts[:except]
-        sql << (opts[:except_all] ? \
-          " EXCEPT ALL #{except.sql}" : " EXCEPT #{except.sql}")
-      end
-      
-      sql
-    end
-    alias sql select_sql
-
-    # Formats an INSERT statement using the given values. If a hash is given,
-    # the resulting statement includes field names. If no values are given, 
-    # the resulting statement includes a DEFAULT VALUES clause.
-    #
-    #   dataset.insert_sql() #=> 'INSERT INTO items DEFAULT VALUES'
-    #   dataset.insert_sql(1,2,3) #=> 'INSERT INTO items VALUES (1, 2, 3)'
-    #   dataset.insert_sql(:a => 1, :b => 2) #=>
-    #     'INSERT INTO items (a, b) VALUES (1, 2)'
-    def insert_sql(*values)
-      if values.empty?
-        "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
-      elsif (values.size == 1) && values[0].is_a?(Hash)
-        field_list = []
-        value_list = []
-        values[0].each do |k, v|
-          field_list << k
-          value_list << literal(v)
+      extend(m)
+    end
+    
+    # Overrides the each method to convert records to polymorphic model
+    # instances. The model class is determined according to the value in the
+    # key column.
+    def extend_with_polymorphic_model(key, hash)
+      meta_def(:model_class) {|r| hash[r[key]] || hash[nil]}
+      m = Module.new do
+        def each(opts = nil, &block)
+          if opts && opts[:naked]
+            fetch_rows(select_sql(opts), &block)
+          else
+            fetch_rows(select_sql(opts)) do |r|
+              c = model_class(r)
+              if c
+                block.call(c.new(r))
+              else
+                raise SequelError, "No matching model class for record (#{polymorphic_key} = #{r[polymorphic_key].inspect})"
+              end
+            end
+          end
         end
-        fl = field_list.join(COMMA_SEPARATOR)
-        vl = value_list.join(COMMA_SEPARATOR)
-        "INSERT INTO #{@opts[:from]} (#{fl}) VALUES (#{vl})"
-      else
-        "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
-      end
-    end
-    
-    # Formats an UPDATE statement using the given values.
-    #
-    #   dataset.update_sql(:price => 100, :category => 'software') #=>
-    #     "UPDATE items SET price = 100, category = 'software'"
-    def update_sql(values, opts = nil)
-      opts = opts ? @opts.merge(opts) : @opts
-      
-      if opts[:group]
-        raise SequelError, "Can't update a grouped dataset" 
-      elsif (opts[:from].size > 1) or opts[:join]
-        raise SequelError, "Can't update a joined dataset"
-      end
-
-      set_list = values.map {|k, v| "#{k} = #{literal(v)}"}.
-        join(COMMA_SEPARATOR)
-      sql = "UPDATE #{@opts[:from]} SET #{set_list}"
-      
-      if where = opts[:where]
-        sql << " WHERE #{where}"
-      end
-
-      sql
-    end
-    
-    # Formats a DELETE statement using the given options and dataset options.
-    # 
-    #   dataset.filter {price >= 100}.delete_sql #=>
-    #     "DELETE FROM items WHERE (price >= 100)"
-    def delete_sql(opts = nil)
-      opts = opts ? @opts.merge(opts) : @opts
-
-      if opts[:group]
-        raise SequelError, "Can't delete from a grouped dataset"
-      elsif opts[:from].is_a?(Array) && opts[:from].size > 1
-        raise SequelError, "Can't delete from a joined dataset"
-      end
-
-      sql = "DELETE FROM #{opts[:from]}"
-
-      if where = opts[:where]
-        sql << " WHERE #{where}"
-      end
-
-      sql
-    end
-    
-    # Returns the first record in the dataset.
-    def single_record(opts = nil)
-      each(opts) {|r| return r}
-      nil
-    end
-    
-    # Returns the first value of the first reecord in the dataset.
-    def single_value(opts = nil)
-      naked.each(opts) {|r| return r.values.first}
-    end
-    
-    SELECT_COUNT = {:select => ["COUNT(*)"], :order => nil}.freeze
-    
-    # Returns the number of records in the dataset.
-    def count
-      single_value(SELECT_COUNT).to_i
-    end
-    alias size count
-    
-    # returns a paginated dataset. The resulting dataset also provides the
-    # total number of pages (Dataset#page_count) and the current page number
-    # (Dataset#current_page), as well as Dataset#prev_page and Dataset#next_page
-    # for implementing pagination controls.
-    def paginate(page_no, page_size)
-      total_pages = (count / page_size.to_f).ceil
-      paginated = limit(page_size, (page_no - 1) * page_size)
-      paginated.current_page = page_no
-      paginated.page_count = total_pages
-      paginated
-    end
-    
-    attr_accessor :page_count, :current_page
-    
-    # Returns the previous page number or nil if the current page is the first
-    def prev_page
-      current_page > 1 ? (current_page - 1) : nil
-    end
-    
-    # Returns the next page number or nil if the current page is the last page
-    def next_page
-      current_page < page_count ? (current_page + 1) : nil
-    end
-    
-    # Returns a table reference for use in the FROM clause. If the dataset has
-    # only a :from option refering to a single table, only the table name is 
-    # returned. Otherwise a subquery is returned.
-    def to_table_reference
-      if opts.keys == [:from] && opts[:from].size == 1
-        opts[:from].first.to_s
-      else
-        "(#{sql})"
       end
+      extend(m)
     end
     
-    # Returns the minimum value for the given field.
-    def min(field)
-      single_value(:select => [field.MIN])
-    end
-    
-    # Returns the maximum value for the given field.
-    def max(field)
-      single_value(:select => [field.MAX])
-    end
-
-    # Returns the sum for the given field.
-    def sum(field)
-      single_value(:select => [field.SUM])
-    end
-    
-    # Returns the average value for the given field.
-    def avg(field)
-      single_value(:select => [field.AVG])
-    end
-    
-    # Returns an EXISTS clause for the dataset.
-    #
-    #   dataset.exists #=> "EXISTS (SELECT 1 FROM items)"
-    def exists(opts = nil)
-      "EXISTS (#{sql({:select => [1]}.merge(opts || {}))})"
-    end
-    
-    # If given an integer, the dataset will contain only the first l results.
-    # If given a range, it will contain only those at offsets within that
-    # range. If a second argument is given, it is used as an offset.
-    def limit(l, o = nil)
-      if l.is_a? Range
-        lim = (l.exclude_end? ? l.last - l.first : l.last + 1 - l.first)
-        dup_merge(:limit => lim, :offset=>l.first)
-      elsif o
-        dup_merge(:limit => l, :offset => o)
-      else
-        dup_merge(:limit => l)
-      end
-    end
-    
-    # Returns the first record in the dataset. If the num argument is specified,
-    # an array is returned with the first <i>num</i> records.
-    def first(*args)
-      args = args.empty? ? 1 : (args.size == 1) ? args.first : args
-      case args
-      when 1: single_record(:limit => 1)
-      when Fixnum: limit(args).all
-      else
-        filter(args).single_record(:limit => 1)
+    # Extends the dataset with a destroy method, that calls destroy for each
+    # record in the dataset.
+    def extend_with_destroy
+      unless respond_to?(:destroy)
+        meta_def(:destroy) do
+          raise SequelError, 'Dataset not associated with model' unless @opts[:models]
+          count = 0
+          @db.transaction {each {|r| count += 1; r.destroy}}
+          count
+        end
       end
     end
     
-    # Returns the first record matching the condition.
-    def [](*conditions)
-      first(*conditions)
-    end
-    
-    def []=(conditions, values)
-      filter(conditions).update(values)
-    end
-    
-    # Returns the last records in the dataset by inverting the order. If no
-    # order is given, an exception is raised. If num is not given, the last
-    # record is returned. Otherwise an array is returned with the last 
-    # <i>num</i> records.
-    def last(*args)
-      raise SequelError, 'No order specified' unless 
-        @opts[:order] || (opts && opts[:order])
-      
-      args = args.empty? ? 1 : (args.size == 1) ? args.first : args
-      
-      case args
-      when Fixnum:
-        l = {:limit => args}
-        opts = {:order => invert_order(@opts[:order])}. \
-          merge(opts ? opts.merge(l) : l)
-        if args == 1
-          single_record(opts)
-        else
-          dup_merge(opts).all
+    # Restores the stock #each implementation.
+    def extend_with_stock_each
+      m = Module.new do
+        def each(opts = nil, &block)
+          fetch_rows(select_sql(opts), &block)
         end
-      else
-        filter(args).last(1)
       end
-    end
-    
-    # Deletes all records in the dataset one at a time by invoking the destroy
-    # method of the associated model class.
-    def destroy
-      raise SequelError, 'Dataset not associated with model' unless @model_class
-      
-      count = 0
-      @db.transaction {each {|r| count += 1; r.destroy}}
-      count
-    end
-    
-    # Pretty prints the records in the dataset as plain-text table.
-    def print(*columns)
-      Sequel::PrettyTable.print(naked.all, columns.empty? ? nil : columns)
+      extend(m)
     end
   end
 end