sequel 0.5.0.2 → 1.0

data/lib/sequel/connection_pool.rb

@@ -1,152 +0,0 @@
-require 'thread'
-
-module Sequel
-  # A ConnectionPool manages access to database connections by keeping
-  # multiple connections and giving threads exclusive access to each
-  # connection.
-  class ConnectionPool
-    attr_reader :mutex
-    
-    # The maximum number of connections.
-    attr_reader :max_size
-    
-    # The proc used to create a new connection.
-    attr_accessor :connection_proc
-    
-    attr_reader :available_connections, :allocated, :created_count
-  
-    # Constructs a new pool with a maximum size. If a block is supplied, it
-    # is used to create new connections as they are needed.
-    #
-    #   pool = ConnectionPool.new(10) {MyConnection.new(opts)}
-    #
-    # The connection creation proc can be changed at any time by assigning a 
-    # Proc to pool#connection_proc.
-    #
-    #   pool = ConnectionPool.new(10)
-    #   pool.connection_proc = proc {MyConnection.new(opts)}
-    def initialize(max_size = 4, &block)
-      @max_size = max_size
-      @mutex = Mutex.new
-      @connection_proc = block
-
-      @available_connections = []
-      @allocated = {}
-      @created_count = 0
-    end
-    
-    # Returns the number of created connections.
-    def size
-      @created_count
-    end
-    
-    # Assigns a connection to the current thread, yielding the connection
-    # to the supplied block.
-    # 
-    #   pool.hold {|conn| conn.execute('DROP TABLE posts')}
-    # 
-    # Pool#hold is re-entrant, meaning it can be called recursively in
-    # the same thread without blocking.
-    #
-    # If no connection is available, Pool#hold will block until a connection
-    # is available.
-    def hold
-      t = Thread.current
-      if (conn = owned_connection(t))
-        return yield(conn)
-      end
-      while !(conn = acquire(t))
-        sleep 0.001
-      end
-      begin
-        yield conn
-      ensure
-        release(t)
-      end
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise e.is_a?(StandardError) ? e : e.message
-    end
-    
-    # Removes all connection currently available, optionally yielding each 
-    # connection to the given block. This method has the effect of 
-    # disconnecting from the database. Once a connection is requested using
-    # #hold, the connection pool creates new connections to the database.
-    def disconnect(&block)
-      @mutex.synchronize do
-        @available_connections.each {|c| block[c]} if block
-        @available_connections = []
-        @created_count = @allocated.size
-      end
-    end
-    
-    private
-      # Returns the connection owned by the supplied thread, if any.
-      def owned_connection(thread)
-        @mutex.synchronize {@allocated[thread]}
-      end
-      
-      # Assigns a connection to the supplied thread, if one is available.
-      def acquire(thread)
-        @mutex.synchronize do
-          if conn = available
-            @allocated[thread] = conn
-          end
-        end
-      end
-      
-      # Returns an available connection. If no connection is available,
-      # tries to create a new connection.
-      def available
-        @available_connections.pop || make_new
-      end
-      
-      # Creates a new connection if the size of the pool is less than the
-      # maximum size.
-      def make_new
-        if @created_count < @max_size
-          @created_count += 1
-          @connection_proc ? @connection_proc.call : \
-            (raise Error, "No connection proc specified")
-        end
-      end
-      
-      # Releases the connection assigned to the supplied thread.
-      def release(thread)
-        @mutex.synchronize do
-          @available_connections << @allocated[thread]
-          @allocated.delete(thread)
-        end
-      end
-  end
-
-  # A SingleThreadedPool acts as a replacement for a ConnectionPool for use
-  # in single-threaded applications. ConnectionPool imposes a substantial
-  # performance penalty, so SingleThreadedPool is used to gain some speed.
-  class SingleThreadedPool
-    attr_reader :conn
-    attr_writer :connection_proc
-    
-    # Initializes the instance with the supplied block as the connection_proc.
-    def initialize(&block)
-      @connection_proc = block
-    end
-    
-    # Yields the connection to the supplied block. This method simulates the
-    # ConnectionPool#hold API.
-    def hold
-      @conn ||= @connection_proc.call
-      yield @conn
-    rescue Exception => e
-      # if the error is not a StandardError it is converted into RuntimeError.
-      raise e.is_a?(StandardError) ? e : e.message
-    end
-    
-    # Disconnects from the database. Once a connection is requested using
-    # #hold, the connection is reestablished.
-    def disconnect(&block)
-      block[@conn] if block && @conn
-      @conn = nil
-    end
-  end
-end

data/lib/sequel/core_ext.rb

@@ -1,59 +0,0 @@
-# Enumerable extensions.
-module Enumerable
-  # Invokes the specified method for each item, along with the supplied
-  # arguments.
-  def send_each(sym, *args)
-    each {|i| i.send(sym, *args)}
-  end
-end
-
-# Range extensions
-class Range
-  # Returns the interval between the beginning and end of the range.
-  def interval
-    last - first
-  end
-end
-
-# Object extensions
-class Object
-  def is_one_of?(*classes)
-    classes.each {|c| return c if is_a?(c)}
-    nil
-  end
-end
-
-module Sequel
-  # Facilitates time calculations by providing methods to convert from larger
-  # time units to seconds, and to convert relative time intervals to absolute
-  # ones. This module duplicates some of the functionality provided by Rails'
-  # ActiveSupport::CoreExtensions::Numeric::Time module.
-  module NumericExtensions
-    MINUTE = 60
-    HOUR = 3600
-    DAY = 86400
-    WEEK = DAY * 7
-  
-    # Converts self from minutes to seconds
-    def minutes;  self * MINUTE;  end; alias_method :minute, :minutes
-    # Converts self from hours to seconds
-    def hours;    self * HOUR;    end; alias_method :hour, :hours
-    # Converts self from days to seconds
-    def days;     self * DAY;     end; alias_method :day, :days
-    # Converts self from weeks to seconds
-    def weeks;    self * WEEK;    end; alias_method :week, :weeks
-  
-    # Returns the time at now - self.
-    def ago(t = Time.now); t - self; end
-    alias_method :before, :ago
-
-    # Returns the time at now + self.
-    def from_now(t = Time.now); t + self; end
-    alias_method :since, :from_now
-    
-    # Extends the Numeric class with numeric extensions.
-    def self.enable
-      Numeric.send(:include, self)
-    end
-  end
-end

data/lib/sequel/core_sql.rb

@@ -1,191 +0,0 @@
-# Array extensions
-class Array
-  # Concatenates an array of strings into an SQL string. ANSI SQL and C-style
-  # comments are removed, as well as excessive white-space.
-  def to_sql
-    map {|l| (l =~ /^(.*)--/ ? $1 : l).chomp}.join(' '). \
-      gsub(/\/\*.*\*\//, '').gsub(/\s+/, ' ').strip
-  end
-end
-
-module Sequel
-  # LiteralString is used to represent literal SQL expressions. An 
-  # LiteralString is copied verbatim into an SQL statement. Instances of
-  # LiteralString can be created by calling String#expr.
-  class LiteralString < ::String
-  end
-end
-
-# String extensions
-class String
-  # Converts a string into an SQL string by removing comments.
-  # See also Array#to_sql.
-  def to_sql
-    split($/).to_sql
-  end
-  
-  # Splits a string into separate SQL statements, removing comments
-  # and excessive white-space.
-  def split_sql
-    to_sql.split(';').map {|s| s.strip}
-  end
-
-  # Converts a string into an LiteralString, in order to override string
-  # literalization, e.g.:
-  #
-  #   DB[:items].filter(:abc => 'def').sql #=>
-  #     "SELECT * FROM items WHERE (abc = 'def')"
-  #
-  #   DB[:items].filter(:abc => 'def'.lit).sql #=>
-  #     "SELECT * FROM items WHERE (abc = def)"
-  #
-  def lit
-    Sequel::LiteralString.new(self)
-  end
-  
-  alias_method :expr, :lit
-  
-  # Converts a string into a Time object.
-  def to_time
-    begin
-      Time.parse(self)
-    rescue Exception => e
-      raise Sequel::Error::InvalidValue, "Invalid time value '#{self}' (#{e.message})"
-    end
-     # Why does Time.parse('0000-00-00') bork and not return nil or some such?
-  end
-end
-
-
-module Sequel
-  module SQL
-    class Expression
-      def lit; self; end
-    end
-    
-    class ColumnExpr < Expression
-      attr_reader :l, :op, :r
-      def initialize(l, op, r = nil); @l, @op, @r = l, op, r; end
-      
-      def to_s(ds)
-        @r ? \
-          "#{ds.literal(@l)} #{@op} #{ds.literal(@r)}" : \
-          "#{ds.literal(@l)} #{@op}"
-      end
-    end
-    
-    class QualifiedColumnRef < Expression
-      def initialize(t, c); @t, @c = t, c; end
-      
-      def to_s(ds)
-        "#{@t}.#{ds.literal(@c)}"
-      end 
-    end
-    
-    class Function < Expression
-      def initialize(f, *args); @f, @args = f, args; end
-
-      def to_s(ds)
-        args = @args.empty? ? '' : ds.literal(@args)
-        "#{@f}(#{args})"
-      end
-    end
-    
-    class Subscript < Expression
-      def initialize(f, sub); @f, @sub = f, sub; end
-      def |(sub)
-        unless Array === sub
-          sub = [sub]
-        end
-        Subscript.new(@f, @sub << sub)
-      end
-      
-      COMMA_SEPARATOR = ", ".freeze
-      
-      def to_s(ds)
-        "#{@f}[#{@sub.join(COMMA_SEPARATOR)}]"
-      end
-    end
-    
-    class ColumnAll < Expression
-      def initialize(t); @t = t; end
-      def to_s(ds); "#{@t}.*"; end
-    end
-    
-    module ColumnMethods
-      AS = 'AS'.freeze
-      DESC = 'DESC'.freeze
-      ASC = 'ASC'.freeze
-      
-      def as(a); ColumnExpr.new(self, AS, a); end
-      alias_method :AS, :as
-      
-      def desc; ColumnExpr.new(self, DESC); end
-      alias_method :DESC, :desc
-      
-      def asc; ColumnExpr.new(self, ASC); end
-      alias_method :ASC, :asc
-
-      def all; Sequel::SQL::ColumnAll.new(self); end
-      alias_method :ALL, :all
-
-      def cast_as(t)
-        if t.is_a?(Symbol)
-          t = t.to_s.lit
-        end
-        Sequel::SQL::Function.new(:cast, self.as(t))
-      end
-    end
-  end
-end
-
-class Object
-  include Sequel::SQL::ColumnMethods
-end
-
-class Symbol
-  def [](*args); Sequel::SQL::Function.new(self, *args); end
-  def |(sub)
-    unless Array === sub
-      sub = [sub]
-    end
-    Sequel::SQL::Subscript.new(self, sub)
-  end
-  
-  COLUMN_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
-  COLUMN_REF_RE2 = /^(\w+)___(\w+)$/.freeze
-  COLUMN_REF_RE3 = /^(\w+)__(\w+)$/.freeze
-
-  # Converts a symbol into a column name. This method supports underscore
-  # notation in order to express qualified (two underscores) and aliased 
-  # (three underscores) columns:
-  #
-  #   ds = DB[:items]
-  #   :abc.to_column_ref(ds) #=> "abc"
-  #   :abc___a.to_column_ref(ds) #=> "abc AS a"
-  #   :items__abc.to_column_ref(ds) #=> "items.abc"
-  #   :items__abc___a.to_column_ref(ds) #=> "items.abc AS a"
-  #
-  def to_column_ref(ds)
-    case s = to_s
-    when COLUMN_REF_RE1
-      "#{$1}.#{ds.quote_column_ref($2)} AS #{ds.quote_column_ref($3)}"
-    when COLUMN_REF_RE2
-      "#{ds.quote_column_ref($1)} AS #{ds.quote_column_ref($2)}"
-    when COLUMN_REF_RE3
-      "#{$1}.#{ds.quote_column_ref($2)}"
-    else
-      ds.quote_column_ref(s)
-    end
-  end
-  
-  # Converts missing method calls into functions on columns, if the
-  # method name is made of all upper case letters.
-  def method_missing(sym)
-    if ((s = sym.to_s) =~ /^([A-Z]+)$/)
-      Sequel::SQL::Function.new(s.downcase, self)
-    else
-      super
-    end
-  end
-end

data/lib/sequel/database.rb

@@ -1,433 +0,0 @@
-require 'uri'
-
-module Sequel
-  # A Database object represents a virtual connection to a database.
-  # The Database class is meant to be subclassed by database adapters in order
-  # to provide the functionality needed for executing queries.
-  class Database
-    attr_reader :opts, :pool
-    attr_accessor :logger
-    
-    # Constructs a new instance of a database connection with the specified
-    # options hash.
-    #
-    # Sequel::Database is an abstract class that is not useful by itself.
-    def initialize(opts = {}, &block)
-      Model.database_opened(self)
-      @opts = opts
-      
-      # Determine if the DB is single threaded or multi threaded
-      @single_threaded = opts[:single_threaded] || @@single_threaded
-      # Construct pool
-      if @single_threaded
-        @pool = SingleThreadedPool.new(&block)
-      else
-        @pool = ConnectionPool.new(opts[:max_connections] || 4, &block)
-      end
-      @pool.connection_proc = block || proc {connect}
-
-      @logger = opts[:logger]
-    end
-    
-    # Connects to the database. This method should be overriden by descendants.
-    def connect
-      raise NotImplementedError, "#connect should be overriden by adapters"
-    end
-    
-    # Disconnects from the database. This method should be overriden by 
-    # descendants.
-    def disconnect
-      raise NotImplementedError, "#disconnect should be overriden by adapters"
-    end
-    
-    # Returns true if the database is using a multi-threaded connection pool.
-    def multi_threaded?
-      !@single_threaded
-    end
-    
-    # Returns true if the database is using a single-threaded connection pool.
-    def single_threaded?
-      @single_threaded
-    end
-    
-    # Returns the URI identifying the database.
-    def uri
-      uri = URI::Generic.new(
-        self.class.adapter_scheme.to_s,
-        nil,
-        @opts[:host],
-        @opts[:port],
-        nil,
-        "/#{@opts[:database]}",
-        nil,
-        nil,
-        nil
-      )
-      uri.user = @opts[:user]
-      uri.password = @opts[:password] if uri.user
-      uri.to_s
-    end
-    alias url uri # Because I don't care much for the semantic difference.
-    
-    # Returns a blank dataset
-    def dataset
-      ds = Sequel::Dataset.new(self)
-    end
-    
-    # Fetches records for an arbitrary SQL statement. If a block is given,
-    # it is used to iterate over the records:
-    #
-    #   DB.fetch('SELECT * FROM items') {|r| p r}
-    #
-    # If a block is not given, the method returns a dataset instance:
-    #
-    #   DB.fetch('SELECT * FROM items').print
-    #
-    # Fetch can also perform parameterized queries for protection against SQL
-    # injection:
-    #
-    #   DB.fetch('SELECT * FROM items WHERE name = ?', my_name).print
-    #
-    # A short-hand form for Database#fetch is Database#[]:
-    #
-    #   DB['SELECT * FROM items'].each {|r| p r}
-    #
-    def fetch(sql, *args, &block)
-      ds = dataset
-      sql = sql.gsub('?') {|m|  ds.literal(args.shift)}
-      if block
-        ds.fetch_rows(sql, &block)
-      else
-        ds.opts[:sql] = sql
-        ds
-      end
-    end
-    alias_method :>>, :fetch
-    
-    # Converts a query block into a dataset. For more information see 
-    # Dataset#query.
-    def query(&block)
-      dataset.query(&block)
-    end
-    
-    # Returns a new dataset with the from method invoked. If a block is given,
-    # it is used as a filter on the dataset.
-    def from(*args, &block)
-      ds = dataset.from(*args)
-      block ? ds.filter(&block) : ds
-    end
-    
-    # Returns a new dataset with the select method invoked.
-    def select(*args); dataset.select(*args); end
-    
-    # Returns a dataset from the database. If the first argument is a string,
-    # the method acts as an alias for Database#fetch, returning a dataset for
-    # arbitrary SQL:
-    #
-    #   DB['SELECT * FROM items WHERE name = ?', my_name].print
-    #
-    # Otherwise, the dataset returned has its from option set to the given
-    # arguments:
-    #
-    #   DB[:items].sql #=> "SELECT * FROM items"
-    #
-    def [](*args)
-      (String === args.first) ? fetch(*args) : from(*args)
-    end
-
-    # Raises a Sequel::Error::NotImplemented. This method is overriden in descendants.
-    def execute(sql)
-      raise NotImplementedError, "#execute should be overriden by adapters"
-    end
-    
-    # Executes the supplied SQL statement. The SQL can be supplied as a string
-    # or as an array of strings. If an array is give, comments and excessive 
-    # white space are removed. See also Array#to_sql.
-    def <<(sql); execute((Array === sql) ? sql.to_sql : sql); end
-    
-    # Acquires a database connection, yielding it to the passed block.
-    def synchronize(&block)
-      @pool.hold(&block)
-    end
-
-    # Returns true if there is a database connection
-    def test_connection
-      @pool.hold {|conn|}
-      true
-    end
-    
-    # include Dataset::SQL
-    include Schema::SQL
-    
-    # default serial primary key definition. this should be overriden for each adapter.
-    def serial_primary_key_options
-      {:primary_key => true, :type => :integer, :auto_increment => true}
-    end
-    
-    # Creates a table. The easiest way to use this method is to provide a
-    # block:
-    #   DB.create_table :posts do
-    #     primary_key :id, :serial
-    #     column :title, :text
-    #     column :content, :text
-    #     index :title
-    #   end
-    def create_table(name, &block)
-      g = Schema::Generator.new(self, &block)
-      create_table_sql_list(name, *g.create_info).each {|sql| execute(sql)}
-    end
-    
-    # Forcibly creates a table. If the table already exists it is dropped.
-    def create_table!(name, &block)
-      drop_table(name) rescue nil
-      create_table(name, &block)
-    end
-    
-    # Drops one or more tables corresponding to the given table names.
-    def drop_table(*names)
-      names.each {|n| execute(drop_table_sql(n))}
-    end
-    
-    # Renames a table:
-    #
-    #   DB.tables #=> [:items]
-    #   DB.rename_table :items, :old_items
-    #   DB.tables #=> [:old_items]
-    def rename_table(*args)
-      execute(rename_table_sql(*args))
-    end
-    
-    # Alters the given table with the specified block. Here are the currently
-    # available operations:
-    #
-    #   DB.alter_table :items do
-    #     add_column :category, :text, :default => 'ruby'
-    #     drop_column :category
-    #     rename_column :cntr, :counter
-    #     set_column_type :value, :float
-    #     set_column_default :value, :float
-    #     add_index [:group, :category]
-    #     drop_index [:group, :category]
-    #   end
-    #
-    # Note that #add_column accepts all the options available for column
-    # definitions using create_table, and #add_index accepts all the options
-    # available for index definition.
-    def alter_table(name, &block)
-      g = Schema::AlterTableGenerator.new(self, &block)
-      alter_table_sql_list(name, g.operations).each {|sql| execute(sql)}
-    end
-    
-    # Adds a column to the specified table. This method expects a column name,
-    # a datatype and optionally a hash with additional constraints and options:
-    #
-    #   DB.add_column :items, :name, :text, :unique => true, :null => false
-    #   DB.add_column :items, :category, :text, :default => 'ruby'
-    def add_column(table, *args)
-      alter_table(table) {add_column(*args)}
-    end
-    
-    # Removes a column from the specified table:
-    #
-    #   DB.drop_column :items, :category
-    def drop_column(table, *args)
-      alter_table(table) {drop_column(*args)}
-    end
-    
-    # Renames a column in the specified table. This method expects the current
-    # column name and the new column name:
-    #
-    #   DB.rename_column :items, :cntr, :counter
-    def rename_column(table, *args)
-      alter_table(table) {rename_column(*args)}
-    end
-    
-    # Set the data type for the given column in the given table:
-    #
-    #   DB.set_column_type :items, :price, :float
-    def set_column_type(table, *args)
-      alter_table(table) {set_column_type(*args)}
-    end
-    
-    # Sets the default value for the given column in the given table:
-    #
-    #   DB.set_column_default :items, :category, 'perl!'
-    def set_column_default(table, *args)
-      alter_table(table) {set_column_default(*args)}
-    end
-    
-    # Adds an index to a table for the given columns:
-    # 
-    #   DB.add_index :posts, :title
-    #   DB.add_index :posts, [:author, :title], :unique => true
-    def add_index(table, *args)
-      alter_table(table) {add_index(*args)}
-    end
-    
-    # Removes an index for the given table and column/s:
-    #
-    #   DB.drop_index :posts, :title
-    #   DB.drop_index :posts, [:author, :title]
-    def drop_index(table, *args)
-      alter_table(table) {drop_index(*args)}
-    end
-    
-    # Returns true if the given table exists.
-    def table_exists?(name)
-      if respond_to?(:tables)
-        tables.include?(name.to_sym)
-      else
-        from(name).first && true
-      end
-    rescue
-      false
-    end
-    
-    # Creates a view based on a dataset or an SQL string:
-    #
-    #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
-    def create_view(name, source)
-      source = source.sql if source.is_a?(Dataset)
-      execute("CREATE VIEW #{name} AS #{source}")
-    end
-    
-    # Creates a view, replacing it if it already exists:
-    #
-    #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
-    #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
-    def create_or_replace_view(name, source)
-      source = source.sql if source.is_a?(Dataset)
-      execute("CREATE OR REPLACE VIEW #{name} AS #{source}")
-    end
-    
-    # Drops a view:
-    #
-    #   DB.drop_view(:cheap_items)
-    def drop_view(name)
-      execute("DROP VIEW #{name}")
-    end
-    
-    SQL_BEGIN = 'BEGIN'.freeze
-    SQL_COMMIT = 'COMMIT'.freeze
-    SQL_ROLLBACK = 'ROLLBACK'.freeze
-
-    # A simple implementation of SQL transactions. Nested transactions are not 
-    # supported - calling #transaction within a transaction will reuse the 
-    # current transaction. May be overridden for databases that support nested 
-    # transactions.
-    def transaction
-      @pool.hold do |conn|
-        @transactions ||= []
-        if @transactions.include? Thread.current
-          return yield(conn)
-        end
-        conn.execute(SQL_BEGIN)
-        begin
-          @transactions << Thread.current
-          result = yield(conn)
-          conn.execute(SQL_COMMIT)
-          result
-        rescue => e
-          conn.execute(SQL_ROLLBACK)
-          raise e unless Error::Rollback === e
-        ensure
-          @transactions.delete(Thread.current)
-        end
-      end
-    end
-
-    @@adapters = Hash.new
-    
-    # Sets the adapter scheme for the Database class. Call this method in
-    # descendnants of Database to allow connection using a URL. For example the
-    # following:
-    #   class DB2::Database < Sequel::Database
-    #     set_adapter_scheme :db2
-    #     ...
-    #   end
-    # would allow connection using:
-    #   Sequel.open('db2://user:password@dbserver/mydb')
-    def self.set_adapter_scheme(scheme)
-      @scheme = scheme
-      @@adapters[scheme.to_sym] = self
-    end
-    
-    # Returns the scheme for the Database class.
-    def self.adapter_scheme
-      @scheme
-    end
-    
-    # Converts a uri to an options hash. These options are then passed
-    # to a newly created database object.
-    def self.uri_to_options(uri)
-      {
-        :user => uri.user,
-        :password => uri.password,
-        :host => uri.host,
-        :port => uri.port,
-        :database => (uri.path =~ /\/(.*)/) && ($1)
-      }
-    end
-    
-    def self.adapter_class(scheme)
-      adapter_name = scheme.to_s =~ /\-/ ? scheme.to_s.gsub('-', '_').to_sym : scheme.to_sym
-      scheme = scheme.to_sym
-      
-      if (klass = @@adapters[scheme]).nil?
-        # attempt to load the adapter file
-        begin
-          require File.join(File.dirname(__FILE__), "adapters/#{scheme}")
-        rescue LoadError => e
-          raise Error::AdapterNotFound, "Could not load #{scheme} adapter:\n  #{e.message}"
-        end
-        
-        # make sure we actually loaded the adapter
-        if (klass = @@adapters[scheme]).nil?
-          raise Error::AdapterNotFound, "Could not load #{scheme} adapter"
-        end
-      end
-      return klass
-    end
-        
-    # call-seq:
-    #   Sequel::Database.connect(conn_string)
-    #   Sequel::Database.connect(opts)
-    #   Sequel.connect(conn_string)
-    #   Sequel.connect(opts)
-    #   Sequel.open(conn_string)
-    #   Sequel.open(opts)
-    #
-    # Creates a new database object based on the supplied connection string
-    # and or options. If a URI is used, the URI scheme determines the database
-    # class used, and the rest of the string specifies the connection options. 
-    # For example:
-    #
-    #   DB = Sequel.open 'sqlite:///blog.db'
-    #
-    # The second form of this method takes an options:
-    #
-    #   DB = Sequel.open :adapter => :sqlite, :database => 'blog.db'
-    def self.connect(conn_string, opts = nil)
-      if conn_string.is_a?(String)
-        uri = URI.parse(conn_string)
-        scheme = uri.scheme
-        scheme = :dbi if scheme =~ /^dbi-(.+)/
-        c = adapter_class(scheme)
-        c.new(c.uri_to_options(uri).merge(opts || {}))
-      else
-        opts = conn_string.merge(opts || {})
-        c = adapter_class(opts[:adapter])
-        c.new(opts)
-      end
-    end
-    
-    @@single_threaded = false
-    
-    # Sets the default single_threaded mode for new databases.
-    def self.single_threaded=(value)
-      @@single_threaded = value
-    end
-  end
-end
-