sequel_core 1.0

data/lib/sequel_core/connection_pool.rb

@@ -0,0 +1,152 @@
+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/core_ext.rb

@@ -0,0 +1,59 @@
+# 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/core_sql.rb

@@ -0,0 +1,191 @@
+# 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_core/database.rb

@@ -0,0 +1,433 @@
+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
+