sequel_model 0.1

data/CHANGELOG

@@ -0,0 +1,3 @@
+=== 0.1 (2007-12-30)
+
+* Moved model code from sequel into separate model sub-project.

data/COPYING

@@ -0,0 +1,18 @@
+Copyright (c) 2006-2007 Sharon Rosner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+  
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+   
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER 
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,251 @@
+== Sequel: Concise ORM for Ruby
+
+Sequel is an ORM framework for Ruby. Sequel provides thread safety, connection pooling, and a concise DSL for constructing queries and table schemas.
+
+Sequel makes it easy to deal with multiple records without having to break your teeth on SQL.
+
+== Resources
+
+* {Project page}[http://code.google.com/p/ruby-sequel/]
+* {Source code}[http://ruby-sequel.googlecode.com/svn/]
+* {Bug tracking}[http://code.google.com/p/ruby-sequel/issues/list]
+* {Google group}[http://groups.google.com/group/sequel-talk]
+* {RubyForge page}[http://rubyforge.org/projects/sequel/]
+
+To check out the source code:
+  
+  svn co http://ruby-sequel.googlecode.com/svn/trunk
+  
+=== Contact
+
+If you have any comments or suggestions please send an email to ciconia at gmail.com and I'll get back to you.
+
+== Installation
+
+  sudo gem install sequel
+  
+== Supported Databases
+
+Sequel currently supports:
+
+* ADO (on Windows)
+* DBI
+* Informix
+* MySQL
+* ODBC
+* Oracle
+* PostgreSQL
+* SQLite 3
+
+There are also experimental adapters for DB2, OpenBase and JDBC (on JRuby).
+
+== The Sequel Console
+
+Sequel includes an IRB console for quick'n'dirty access to databases. You can use it like this:
+
+  sequel sqlite:///test.db
+
+You get an IRB session with the database object stored in DB.
+
+== An Introduction
+
+Sequel was designed to take the hassle away from connecting to databases and manipulating them. Sequel deals with all the boring stuff like maintaining connections, formatting SQL correctly and fetching records so you can concentrate on your application.
+
+Sequel uses the concept of datasets to retrieve data. A Dataset object encapsulates an SQL query and supports chainability, letting you fetch data using a convenient Ruby DSL that is both concise and infinitely flexible.
+
+For example, the following one-liner returns the average GDP for the five biggest countries in the middle east region:
+
+  DB[:countries].filter(:region => 'Middle East').reverse_order(:area).limit(5).avg(:GDP)
+  
+Which is equivalent to:
+
+  SELECT avg(GDP) FROM countries WHERE region = 'Middle East' ORDER BY area DESC LIMIT 5
+
+Since datasets retrieve records only when needed, they can be stored and later reused. Records are fetched as hashes (they can also be fetched as custom model objects), and are accessed using an Enumerable interface:
+
+  middle_east = DB[:countries].filter(:region => 'Middle East')
+  middle_east.order(:name).each {|r| puts r[:name]}
+  
+Sequel also offers convenience methods for extracting data from Datasets, such as an extended map method:
+
+  middle_east.map(:name) #=> ['Egypt', 'Greece', 'Israel', ...]
+  
+Or getting results as a transposed hash, with one column as key and another as value:
+
+  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...
+
+== Getting Started
+
+=== Connecting to a database
+
+To connect to a database you simply provide Sequel with a URL:
+
+  require 'sequel'
+  DB = Sequel.open 'sqlite:///blog.db'
+  
+The connection URL can also include such stuff as the user name and password:
+
+  DB = Sequel.open 'postgres://cico:12345@localhost:5432/mydb'
+
+You can also specify optional parameters, such as the connection pool size, or a logger for logging SQL queries:
+
+  DB = Sequel.open("postgres://postgres:postgres@localhost/my_db",
+    :max_connections => 10, :logger => Logger.new('log/db.log'))
+
+=== Arbitrary SQL queries
+
+  DB.execute("create table t (a text, b text)")
+  DB.execute("insert into t values ('a', 'b')")
+
+Or more succinctly:
+
+  DB << "create table t (a text, b text)"
+  DB << "insert into t values ('a', 'b')"
+
+=== Getting Dataset Instances
+
+Dataset is the primary means through which records are retrieved and manipulated. You can create an blank dataset by using the dataset method:
+
+  dataset = DB.dataset
+
+Or by using the from methods:
+
+  posts = DB.from(:posts)
+
+You can also use the equivalent shorthand:
+
+  posts = DB[:posts]
+
+Note: the dataset will only fetch records when you explicitly ask for them, as will be shown below. Datasets can be manipulated to filter through records, change record order and even join tables, as will also be shown below.
+
+=== Retrieving Records
+
+You can retrieve records by using the all method:
+
+  posts.all
+
+The all method returns an array of hashes, where each hash corresponds to a record.
+
+You can also iterate through records one at a time:
+
+  posts.each {|row| p row}
+
+Or perform more advanced stuff:
+
+  posts.map(:id)
+  posts.inject({}) {|h, r| h[r[:id]] = r[:name]}
+  
+You can also retrieve the first record in a dataset:
+
+  posts.first
+  
+Or retrieve a single record with a specific value:
+
+  posts[:id => 1]
+  
+If the dataset is ordered, you can also ask for the last record:
+
+  posts.order(:stamp).last
+  
+=== Filtering Records
+
+The simplest way to filter records is to provide a hash of values to match:
+
+  my_posts = posts.filter(:category => 'ruby', :author => 'david')
+  
+You can also specify ranges:
+
+  my_posts = posts.filter(:stamp => (2.weeks.ago)..(1.week.ago))
+  
+Or lists of values:
+
+  my_posts = posts.filter(:category => ['ruby', 'postgres', 'linux'])
+  
+Sequel now also accepts expressions as closures, AKA block filters:
+
+  my_posts = posts.filter {:category == ['ruby', 'postgres', 'linux']}
+  
+Which also lets you do stuff like:
+
+  my_posts = posts.filter {:stamp > 1.month.ago}
+  
+Some adapters (like postgresql) will also let you specify Regexps:
+
+  my_posts = posts.filter(:category => /ruby/i)
+  
+You can also use an inverse filter:
+
+  my_posts = posts.exclude(:category => /ruby/i)
+
+You can then retrieve the records by using any of the retrieval methods:
+
+  my_posts.each {|row| p row}
+  
+You can also specify a custom WHERE clause:
+
+  posts.filter('(stamp < ?) AND (author <> ?)', 3.days.ago, author_name)
+
+Datasets can also be used as subqueries:
+
+  DB[:items].filter('price > ?', DB[:items].select('AVG(price) + 100'))
+
+=== Summarizing Records
+
+Counting records is easy:
+  posts.filter(:category => /ruby/i).count
+
+And you can also query maximum/minimum values:
+  max_value = DB[:history].max(:value)
+  
+Or calculate a sum:
+  total = DB[:items].sum(:price)
+  
+=== Ordering Records
+
+  posts.order(:stamp)
+  
+You can also specify descending order
+
+  posts.order(:stamp.DESC)
+
+=== Deleting Records
+
+  posts.filter('stamp < ?', 3.days.ago).delete
+  
+=== Inserting Records
+
+  posts.insert(:category => 'ruby', :author => 'david')
+  
+Or alternatively:
+
+  posts << {:category => 'ruby', :author => 'david'}
+  
+=== Updating Records
+
+  posts.filter('stamp < ?', 3.days.ago).update(:state => 'archived')
+
+=== Joining Tables
+
+Joining is very useful in a variety of scenarios, for example many-to-many relationships. With Sequel it's really easy:
+
+  order_items = DB[:items].join(:order_items, :item_id => :id).
+    filter(:order_items__order_id => 1234)
+  
+This is equivalent to the SQL:
+
+  SELECT * FROM items LEFT OUTER JOIN order_items
+  ON order_items.item_id = items.id 
+  WHERE order_items.order_id = 1234
+
+You can then do anything you like with the dataset:
+
+  order_total = order_items.sum(:price)
+  
+Which is equivalent to the SQL:
+
+  SELECT sum(price) FROM items LEFT OUTER JOIN order_items
+  ON order_items.item_id = items.id
+  WHERE order_items.order_id = 1234
+  

data/Rakefile

@@ -0,0 +1,146 @@
+require "rake"
+require "rake/clean"
+require "rake/gempackagetask"
+require "rake/rdoctask"
+require "fileutils"
+include FileUtils
+
+##############################################################################
+# Configuration
+##############################################################################
+NAME = "sequel_model"
+VERS = "0.1"
+CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
+RDOC_OPTS = [
+  "--quiet", 
+  "--title", "Sequel Model: Lightweight ORM for Ruby",
+  "--opname", "index.html",
+  "--line-numbers", 
+  "--main", "README",
+  "--inline-source"
+]
+
+##############################################################################
+# RDoc
+##############################################################################
+task :doc => [:rdoc]
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = "doc/rdoc"
+  rdoc.options += RDOC_OPTS
+  rdoc.main = "README"
+  rdoc.title = "Sequel: Lightweight ORM for Ruby"
+  rdoc.rdoc_files.add ["README", "COPYING", "lib/sequel.rb", "lib/**/*.rb"]
+end
+
+##############################################################################
+# Gem packaging
+##############################################################################
+desc "Packages up Sequel."
+task :default => [:package]
+task :package => [:clean]
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.rubyforge_project = NAME
+  s.version = VERS
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.rdoc_options += RDOC_OPTS + 
+    ["--exclude", "^(examples|extras)\/", "--exclude", "lib/sequel.rb"]
+  s.summary = "Lightweight ORM for Ruby"
+  s.description = s.summary
+  s.author = "Sharon Rosner"
+  s.email = "ciconia@gmail.com"
+  s.homepage = "http://sequel.rubyforge.org"
+  s.required_ruby_version = ">= 1.8.4"
+
+  case RUBY_PLATFORM
+  when /mswin/
+    s.platform = Gem::Platform::CURRENT
+  when /java/
+    s.platform = "jruby"
+  else
+    s.platform = Gem::Platform::RUBY
+  end
+
+  s.add_dependency("sequel", '>= 0.5')
+  s.add_dependency("validatable")
+  
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
+
+  s.require_path = "lib"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.need_tar = true
+  p.gem_spec = spec
+end
+
+##############################################################################
+# installation & removal
+##############################################################################
+task :install do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS}}
+end
+
+task :install_no_docs do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS} --no-rdoc --no-ri}
+end
+
+task :uninstall => [:clean] do
+  sh %{sudo gem uninstall #{NAME}}
+end
+
+task :tag do
+  cwd = FileUtils.pwd
+  sh %{cd ../.. && svn copy #{cwd} tags/#{NAME}-#{VERS} && svn commit -m "#{NAME}-#{VERS} tag." tags}
+end
+
+##############################################################################
+# gem and rdoc release
+##############################################################################
+task :release => [:package] do
+  sh %{rubyforge login}
+  sh %{rubyforge add_release sequel #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.tgz}
+  sh %{rubyforge add_file sequel #{NAME} #{VERS} pkg/#{NAME}-#{VERS}.gem}
+end
+
+##############################################################################
+# specs
+##############################################################################
+require "spec/rake/spectask"
+
+desc "Run specs with coverage"
+Spec::Rake::SpecTask.new("spec") do |t|
+  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
+  t.rcov = true
+end
+
+desc "Run specs without coverage"
+Spec::Rake::SpecTask.new("spec_no_cov") do |t|
+  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+end
+
+##############################################################################
+# Statistics
+##############################################################################
+
+STATS_DIRECTORIES = [
+  %w(Code   lib/),
+  %w(Spec   spec/)
+].collect { |name, dir| [ name, "./#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require "extra/stats"
+  verbose = true
+  CodeStatistics.new(*STATS_DIRECTORIES).to_s
+end
+

data/lib/sequel_model.rb

@@ -0,0 +1,326 @@
+gem 'sequel', '>= 0.5'
+require 'sequel'
+
+module Sequel
+  # == Sequel Models
+  # 
+  # Models in Sequel are based on the Active Record pattern described by Martin Fowler (http://www.martinfowler.com/eaaCatalog/activeRecord.html). A model class corresponds to a table or a dataset, and an instance of that class wraps a single record in the model's underlying dataset.
+  # 
+  # Model classes are defined as regular Ruby classes:
+  # 
+  #   DB = Sequel('sqlite:/blog.db')
+  #   class Post < Sequel::Model
+  #     set_dataset DB[:posts]
+  #   end
+  # 
+  # You can also use the shorthand form:
+  # 
+  #   DB = Sequel('sqlite:/blog.db')
+  #   class Post < Sequel::Model(:posts)
+  #   end
+  # 
+  # === Model instances
+  # 
+  # Model instance are identified by a primary key. By default, Sequel assumes the primary key column to be :id. The Model#[] method can be used to fetch records by their primary key:
+  # 
+  #   post = Post[123]
+  # 
+  # The Model#pk method is used to retrieve the record's primary key value:
+  # 
+  #   post.pk #=> 123
+  # 
+  # Sequel models allow you to use any column as a primary key, and even composite keys made from multiple columns:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     set_primary_key [:category, :title]
+  #   end
+  # 
+  #   post = Post['ruby', 'hello world']
+  #   post.pk #=> ['ruby', 'hello world']
+  # 
+  # You can also define a model class that does not have a primary key, but then you lose the ability to update records.
+  # 
+  # A model instance can also be fetched by specifying a condition:
+  # 
+  #   post = Post[:title => 'hello world']
+  #   post = Post.find {:stamp < 10.days.ago}
+  # 
+  # === Iterating over records
+  # 
+  # A model class lets you iterate over specific records by acting as a proxy to the underlying dataset. This means that you can use the entire Dataset API to create customized queries that return model instances, e.g.:
+  # 
+  #   Post.filter(:category => 'ruby').each {|post| p post}
+  # 
+  # You can also manipulate the records in the dataset:
+  # 
+  #   Post.filter {:stamp < 7.days.ago}.delete
+  #   Post.filter {:title =~ /ruby/}.update(:category => 'ruby')
+  # 
+  # === Accessing record values
+  # 
+  # A model instances stores its values as a hash:
+  # 
+  #   post.values #=> {:id => 123, :category => 'ruby', :title => 'hello world'}
+  # 
+  # You can read the record values as object attributes:
+  # 
+  #   post.id #=> 123
+  #   post.title #=> 'hello world'
+  # 
+  # You can also change record values:
+  # 
+  #   post.title = 'hey there'
+  #   post.save
+  # 
+  # Another way to change values by using the #set method:
+  # 
+  #   post.set(:title => 'hey there')
+  # 
+  # === Creating new records
+  # 
+  # New records can be created by calling Model.create:
+  # 
+  #   post = Post.create(:title => 'hello world')
+  # 
+  # Another way is to construct a new instance and save it:
+  # 
+  #   post = Post.new
+  #   post.title = 'hello world'
+  #   post.save
+  # 
+  # You can also supply a block to Model.new and Model.create:
+  # 
+  #   post = Post.create {|p| p.title = 'hello world'}
+  # 
+  #   post = Post.new do |p|
+  #     p.title = 'hello world'
+  #     p.save
+  #   end
+  # 
+  # === Hooks
+  # 
+  # You can execute custom code when creating, updating, or deleting records by using hooks. The before_create and after_create hooks wrap record creation. The before_update and after_update wrap record updating. The before_save and after_save wrap record creation and updating. The before_destroy and after_destroy wrap destruction.
+  # 
+  # Hooks are defined by supplying a block:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     after_create do
+  #       set(:created_at => Time.now)
+  #     end
+  # 
+  #     after_destroy
+  #       author.update_post_count
+  #     end
+  #   end
+  # 
+  # === Deleting records
+  # 
+  # You can delete individual records by calling #delete or #destroy. The only difference between the two methods is that #destroy invokes before_destroy and after_destroy hooks, while #delete does not:
+  # 
+  #   post.delete #=> bypasses hooks
+  #   post.destroy #=> runs hooks
+  # 
+  # Records can also be deleted en-masse by invoking Model.delete and Model.destroy. As stated above, you can specify filters for the deleted records:
+  # 
+  #   Post.filter(:category => 32).delete #=> bypasses hooks
+  #   Post.filter(:category => 32).destroy #=> runs hooks
+  # 
+  # Please note that if Model.destroy is called, each record is deleted separately, but Model.delete deletes all relevant records with a single SQL statement.
+  # 
+  # === Associations
+  # 
+  # The most straightforward way to define an association in a Sequel model is as a regular instance method:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     def author; Author[author_id]; end
+  #   end
+  # 
+  #   class Author < Sequel::Model(:authors)
+  #     def posts; Post.filter(:author_id => pk); end
+  #   end
+  # 
+  # Sequel also provides two macros to assist with common types of associations. The one_to_one macro is roughly equivalent to ActiveRecord?'s belongs_to macro. It defines both getter and setter methods for the association:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     one_to_one :author, :from => Author
+  #   end
+  #
+  #   post = Post.create(:name => 'hi!')
+  #   post.author = Author[:name => 'Sharon']
+  # 
+  # The one_to_many macro is roughly equivalent to ActiveRecord's has_many macro:
+  # 
+  #   class Author < Sequel::Model(:authors)
+  #     one_to_many :posts, :from => Post, :key => :author_id
+  #   end
+  # 
+  # You will have noticed that in some cases the association macros are actually more verbose than hand-coding instance methods. The one_to_one and one_to_many macros also make assumptions (just like ActiveRecord macros) about the database schema which may not be relevant in many cases.
+  # 
+  # === Caching model instances with memcached
+  # 
+  # Sequel models can be cached using memcached based on their primary keys. The use of memcached can significantly reduce database load by keeping model instances in memory. The set_cache method is used to specify caching:
+  # 
+  #   require 'memcache'
+  #   CACHE = MemCache.new 'localhost:11211', :namespace => 'blog'
+  # 
+  #   class Author < Sequel::Model(:authors)
+  #     set_cache CACHE, :ttl => 3600
+  #   end
+  # 
+  #   Author[333] # database hit
+  #   Author[333] # cache hit
+  # 
+  # === Extending the underlying dataset
+  # 
+  # The obvious way to add table-wide logic is to define class methods to the model class definition. That way you can define subsets of the underlying dataset, change the ordering, or perform actions on multiple records:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     def self.old_posts
+  #       filter {:stamp < 30.days.ago}
+  #     end
+  # 
+  #     def self.clean_old_posts
+  #       old_posts.delete
+  #     end
+  #   end
+  # 
+  # You can also implement table-wide logic by defining methods on the dataset:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     def dataset.old_posts
+  #       filter {:stamp < 30.days.ago}
+  #     end
+  # 
+  #     def dataset.clean_old_posts
+  #       old_posts.delete
+  #     end
+  #   end
+  # 
+  # This is the recommended way of implementing table-wide operations, and allows you to have access to your model API from filtered datasets as well:
+  # 
+  #   Post.filter(:category => 'ruby').clean_old_posts
+  # 
+  # Sequel models also provide a short hand notation for filters:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     subset(:old_posts) {:stamp < 30.days.ago}
+  #     subset :invisible, :visible => false
+  #   end
+  # 
+  # === Defining the underlying schema
+  # 
+  # Model classes can also be used as a place to define your table schema and control it. The schema DSL is exactly the same provided by Sequel::Schema::Generator:
+  # 
+  #   class Post < Sequel::Model(:posts)
+  #     set_schema do
+  #       primary_key :id
+  #       text :title
+  #       text :category
+  #       foreign_key :author_id, :table => authors
+  #     end
+  #   end
+  # 
+  # You can then create the underlying table, drop it, or recreate it:
+  # 
+  #   Post.table_exists?
+  #   Post.create_table
+  #   Post.drop_table
+  #   Post.create_table! # drops the table if it exists and then recreates it
+  # 
+  class Model
+    alias_method :model, :class
+  end
+
+end
+
+files = %w[
+  base hooks record schema relations
+  caching plugins validations
+]
+dir = File.join(File.dirname(__FILE__), "sequel_model")
+files.each {|f| require(File.join(dir, f))}
+
+module Sequel
+  
+  class Model
+    
+    # Defines a method that returns a filtered dataset.
+    def self.subset(name, *args, &block)
+      dataset.meta_def(name) {filter(*args, &block)}
+    end
+    
+    # Finds a single record according to the supplied filter, e.g.:
+    #
+    #   Ticket.find :author => 'Sharon' # => record
+    #   Ticket.find {:price == 17} # => Dataset
+    #
+    def self.find(*args, &block)
+      dataset.filter(*args, &block).first
+    end
+    
+    # TODO: doc
+    def self.[](*args)
+      args = args.first if (args.size == 1)
+      if args === true || args === false
+        raise Error::InvalidFilter, "Did you mean to supply a hash?"
+      end
+      dataset[(Hash === args) ? args : primary_key_hash(args)]
+    end
+    
+    # TODO: doc
+    def self.fetch(*args)
+      db.fetch(*args).set_model(self)
+    end
+
+    # Like find but invokes create with given conditions when record does not
+    # exists.
+    def self.find_or_create(cond)
+      find(cond) || create(cond)
+    end
+
+    ############################################################################
+
+    # Deletes all records in the model's table.
+    def self.delete_all
+      dataset.delete
+    end
+
+    # Like delete_all, but invokes before_destroy and after_destroy hooks if used.
+    def self.destroy_all
+      if has_hooks?(:before_destroy) || has_hooks?(:after_destroy)
+        dataset.destroy
+      else
+        dataset.delete
+      end
+    end
+        
+    def self.is_dataset_magic_method?(m)
+      method_name = m.to_s
+      Sequel::Dataset::MAGIC_METHODS.each_key do |r|
+        return true if method_name =~ r
+      end
+      false
+    end
+    
+    def self.method_missing(m, *args, &block) #:nodoc:
+      Thread.exclusive do
+        if dataset.respond_to?(m) || is_dataset_magic_method?(m)
+          instance_eval("def #{m}(*args, &block); dataset.#{m}(*args, &block); end")
+        end
+      end
+      respond_to?(m) ? send(m, *args, &block) : super(m, *args)
+    end
+
+    # TODO: Comprehensive description goes here!
+    def self.join(*args)
+      table_name = dataset.opts[:from].first
+      dataset.join(*args).select(table_name.to_sym.ALL)
+    end
+    
+    # Returns an array containing all of the models records.
+    def self.all
+      dataset.all
+    end
+  end
+
+end