akitaonrails-activerecord-sqlserver-adapter 1.1.0 → 1.1.1

data/README

@@ -0,0 +1,31 @@
+activerecord-sqlserver-adapter
+==============================
+
+Originally forked from http://svn.rubyonrails.org/rails/adapters/sqlserver/ 
+revision 9250
+
+Incorporates changes from: 
+
+- Redmine's fixes:
+http://www.redmine.org/attachments/817/sqlserver_adapter.rb
+
+- Github's jrafanie:
+http://github.com/jrafanie/rails-sqlserver-adapter/tree/master/sqlserver_adapter_rails.rb
+
+- Github's adzap:
+http://github.com/adzap/sqlserver_adapter_mods/tree/master/lib/sqlserver_adapter_mods
+
+This gem should support SQL Server 2005 but not 2000 because of type changes.
+
+Included ruby-dbi 0.2.2:
+- http://rubyforge.org/frs/download.php/41304/dbi-0.2.2.zip
+
+INSTALL
+=======
+
+gem install akitaonrails-activerecord-sqlserver-adapter --source=http://gems.github.com
+
+Contact:
+========
+
+Fabio Akita (fabioakita@gmail.com)

data/RUNNING_UNIT_TESTS

@@ -0,0 +1,44 @@
+== Creating the test database
+
+The default names for the test databases are "activerecord_unittest" and 
+"activerecord_unittest2". If you want to use another database name then be sure 
+to update the connection adapter setups you want to test with in 
+test/connections/<your database>/connection.rb. 
+
+
+== Requirements
+
+The tests of this adapter depend on the existence of rails edge. All the tests
+defined by rails edge are re-used. For this to work the following directory 
+structure is assumed to exist:
+
+#{RAILS_ROOT}/vendor/plugins/adapters/sqlserver
+#{RAILS_ROOT}/vendor/rails/activerecord/test
+
+Define a user named 'rails' in SQL Server with all privileges granted. Use an empty 
+password for user 'rails', or alternatively use the OSQLPASSWORD environment variable
+which allows you to set a default password for the current session.
+
+Then run "rake create_databases".
+
+
+== Running with Rake
+
+The easiest way to run the unit tests is through Rake. Either run "rake test_sqlserver" 
+or "rake test_sqlserver_odbc". For more information, checkout the full array 
+of rake tasks with "rake -T"
+
+Rake can be found at http://rake.rubyforge.org
+
+
+== Running by hand
+
+Unit tests are located in test directory. If you only want to run a single test suite, 
+you can do so with:
+
+   rake test_sqlserver TEST=base_test.rb
+   
+That'll run the base suite using the SQLServer-Ruby adapter.
+
+
+

data/Rakefile

@@ -0,0 +1,89 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+PKG_NAME = 'activerecord-sqlserver-adapter'
+PKG_BUILD = (".#{ENV['PKG_BUILD']}" if ENV['PKG_BUILD'])
+PKG_VERSION = "1.0.0#{PKG_BUILD}"
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.summary = 'SQL Server adapter for Active Record'
+  s.version = PKG_VERSION
+
+  s.add_dependency 'activerecord', '>= 1.15.5.7843'
+  s.require_path = 'lib'
+
+  s.files = %w(lib/active_record/connection_adapters/sqlserver_adapter.rb)
+
+  s.author = 'Tom Ward'
+  s.email = 'tom@popdog.net'
+  s.homepage = 'http://wiki.rubyonrails.org/rails/pages/SQL+Server'
+  s.rubyforge_project = 'activerecord'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc "Publish the beta gem"
+task :pgem => :package do
+  Rake::SshFilePublisher.new("davidhh@wrath.rubyonrails.org", "public_html/gems/gems", "pkg", "#{PKG_NAME}-#{PKG_VERSION}.gem").upload
+  `ssh davidhh@wrath.rubyonrails.org './gemupdate.sh'`
+end
+
+desc "Publish the release files to RubyForge."
+task :release => :package do
+  require 'rubyforge'
+
+  packages = %w(gem tgz zip).collect{ |ext| "pkg/#{PKG_NAME}-#{PKG_VERSION}.#{ext}" }
+
+  rubyforge = RubyForge.new
+  rubyforge.login
+  rubyforge.add_release(PKG_NAME, PKG_NAME, "REL #{PKG_VERSION}", *packages)
+end
+
+
+SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
+
+desc 'Create the SQL Server test databases'
+task :create_databases do
+  # Define a user named 'rails' in SQL Server with all privileges granted
+  # Use an empty password for user 'rails', or alternatively use the OSQLPASSWORD environment variable
+  # which allows you to set a default password for the current session.
+  %x( osql -S localhost -U rails -Q "create database activerecord_unittest" -P )
+  %x( osql -S localhost -U rails -Q "create database activerecord_unittest2" -P )
+  %x( osql -S localhost -U rails -d activerecord_unittest -Q "exec sp_grantdbaccess 'rails'" -P )
+  %x( osql -S localhost -U rails -d activerecord_unittest2 -Q "exec sp_grantdbaccess 'rails'" -P ) 
+  %x( osql -S localhost -U rails -d activerecord_unittest -Q "grant BACKUP DATABASE, BACKUP LOG, CREATE DEFAULT, CREATE FUNCTION, CREATE PROCEDURE, CREATE RULE, CREATE TABLE, CREATE VIEW to 'rails';" -P )
+  %x( osql -S localhost -U rails -d activerecord_unittest2 -Q "grant BACKUP DATABASE, BACKUP LOG, CREATE DEFAULT, CREATE FUNCTION, CREATE PROCEDURE, CREATE RULE, CREATE TABLE, CREATE VIEW to 'rails';" -P )
+end
+
+desc 'Drop the SQL Server test databases'
+task :drop_databases do
+  %x( osql -S localhost -U rails -Q "drop database activerecord_unittest" -P )
+  %x( osql -S localhost -U rails -Q "drop database activerecord_unittest2" -P )
+end
+
+desc 'Recreate the SQL Server test databases'
+task :recreate_databases => [:drop_databases, :create_databases]
+
+
+for adapter in %w( sqlserver sqlserver_odbc )
+  Rake::TestTask.new("test_#{adapter}") { |t|
+    t.libs << "test" 
+    t.libs << "test/connections/native_#{adapter}"
+    t.libs << "../../../rails/activerecord/test/"
+    t.pattern = ["test/**/*_test_sqlserver.rb", "../../../rails/activerecord/test/**/*_test.rb"]
+    t.verbose = true
+  }
+
+  namespace adapter do
+    task :test => "test_#{adapter}"
+  end
+end

data/activerecord-sqlserver-adapter.gemspec

@@ -0,0 +1,15 @@
+spec = Gem::Specification.new do |s|
+  s.name = "activerecord-sqlserver-adapter"
+  s.summary = 'SQL Server adapter for Active Record'
+  s.version = "1.1.1"
+
+  s.add_dependency 'activerecord', '>= 1.15.5.7843'
+  s.require_path = 'lib'
+
+  s.files = ["activerecord-sqlserver-adapter.gemspec", "lib", "lib/active_record", "lib/active_record/connection_adapters", "lib/active_record/connection_adapters/sqlserver_adapter.rb", "lib/activerecord-sqlserver-adapter.rb", "lib/dbd", "lib/dbd/ADO.rb", "lib/dbi", "lib/dbi/columninfo.rb", "lib/dbi/row.rb", "lib/dbi/sql.rb", "lib/dbi/trace.rb", "lib/dbi/utils.rb", "lib/dbi/version.rb", "lib/dbi.rb", "lib/rails_fcgi", "lib/rails_fcgi/fixes.rb", "lib/rails_fcgi.rb", "Rakefile", "README", "RUNNING_UNIT_TESTS", "test", "test/aaaa_create_tables_test_sqlserver.rb", "test/affected_rows_test_sqlserver.rb", "test/connections", "test/connections/native_sqlserver", "test/connections/native_sqlserver/connection.rb", "test/connections/native_sqlserver_odbc", "test/connections/native_sqlserver_odbc/connection.rb", "test/fixtures", "test/fixtures/db_definitions", "test/fixtures/db_definitions/sqlserver.drop.sql", "test/fixtures/db_definitions/sqlserver.sql", "test/fixtures/db_definitions/sqlserver2.drop.sql", "test/fixtures/db_definitions/sqlserver2.sql"]
+
+  s.author = 'Tom Ward'
+  s.email = 'tom@popdog.net'
+  s.homepage = 'http://wiki.rubyonrails.org/rails/pages/SQL+Server'
+  s.rubyforge_project = 'activerecord'
+end

data/lib/activerecord-sqlserver-adapter.rb

@@ -0,0 +1,3 @@
+require 'dbi.rb'
+require "dbd/ADO.rb"
+require "active_record/connection_adapters/sqlserver_adapter.rb"

data/lib/dbd/ADO.rb

@@ -0,0 +1,229 @@
+#
+# DBD::ADO
+#
+# Copyright (c) 2001, 2002 Michael Neumann <neumann@s-direktnet.de>
+# 
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions 
+# are met:
+# 1. Redistributions of source code must retain the above copyright 
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright 
+#    notice, this list of conditions and the following disclaimer in the 
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+# THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# $Id$
+#
+
+require "win32ole"
+
+module DBI
+module DBD
+module ADO
+
+VERSION          = "0.1"
+USED_DBD_VERSION = "0.1"
+
+class Driver < DBI::BaseDriver
+
+  def initialize
+    super(USED_DBD_VERSION)
+  end
+
+  def connect(dbname, user, auth, attr)
+    # connect to database
+
+    handle = WIN32OLE.new('ADODB.Connection')
+    handle.Open(dbname)
+    handle.BeginTrans()  # start new Transaction
+
+    return Database.new(handle, attr)
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+end
+
+class Database < DBI::BaseDatabase
+ 
+  def disconnect
+    @handle.RollbackTrans()
+    @handle.Close()
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def prepare(statement)
+    # TODO: create Command instead?
+    Statement.new(@handle, statement, self)
+  end
+
+  def commit
+    # TODO: raise error if AutoCommit on => better in DBI?
+    @handle.CommitTrans()
+    @handle.BeginTrans()
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def rollback
+    # TODO: raise error if AutoCommit on => better in DBI?
+    @handle.RollbackTrans()
+    @handle.BeginTrans()
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def []=(attr, value)
+    if attr == 'AutoCommit' then
+      # TODO: commit current transaction?
+      @attr[attr] = value
+    else
+      super
+    end
+  end
+
+
+end # class Database
+
+
+class Statement < DBI::BaseStatement
+  include SQL::BasicBind
+  include SQL::BasicQuote
+
+  def initialize(handle, statement, db)
+    @handle = handle
+    @statement = statement
+    @params = []
+    @db = db
+  end
+
+  def bind_param(param, value, attribs)
+    raise InterfaceError, "only ? parameters supported" unless param.is_a? Fixnum
+
+    @params[param-1] = value 
+  end
+
+  def execute
+    # TODO: use Command and Parameter
+    # TODO: substitute all ? by the parametes
+    sql = bind(self, @statement, @params)
+    @res_handle = @handle.Execute(sql) 
+
+    # TODO: SELECT and AutoCommit finishes the result-set
+    #       what to do?
+    if @db['AutoCommit'] == true and not SQL.query?(@statement) then
+      @db.commit
+    end
+
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def finish
+    # if DCL, DDL or INSERT UPDATE and DELETE, this gives an Error
+    # because no Result-Set is available
+    if @res_handle.Fields.Count() != 0 then
+      @res_handle.Close()
+    end
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def fetch        
+    retval = fetch_currentrow
+    @res_handle.MoveNext() unless retval.nil?
+    retval
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+
+
+  def fetch_scroll(direction, offset)
+    case direction
+    when DBI::SQL_FETCH_NEXT
+      return fetch
+    when DBI::SQL_FETCH_PRIOR
+      # TODO: check if already the first?
+      #return nil if @res_handle.AbsolutePosition()
+      @res_handle.MovePrevious()
+      return fetch_currentrow
+    when DBI::SQL_FETCH_FIRST
+      @res_handle.MoveFirst()
+      return fetch_currentrow
+    when DBI::SQL_FETCH_LAST
+      @res_handle.MoveLast()
+      return fetch_currentrow
+    when DBI::SQL_FETCH_RELATIVE
+      @res_handle.Move(offset)
+      return fetch_currentrow
+    when DBI::SQL_FETCH_ABSOLUTE
+      ap = @res_handle.AbsolutePositon()      
+      @res_handle.Move(offset-ap)
+      return fetch_currentrow      
+    else
+      raise DBI::InterfaceError
+    end    
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def column_info
+    num_cols = @res_handle.Fields().Count()
+    retval = Array.new(num_cols)
+
+    for i in 0...num_cols do
+      retval[i] = {'name' => @res_handle.Fields(i).Name()}
+    end
+
+    retval
+  rescue RuntimeError => err
+    raise DBI::DatabaseError.new(err.message)
+  end
+
+  def rows
+    # TODO: how to get the RPC in ADO? 
+    nil
+  end
+
+  
+  private
+
+  def fetch_currentrow    
+    return nil if @res_handle.EOF() or @res_handle.BOF()
+      
+    # TODO: don't create new Array each time
+    num_cols = @res_handle.Fields().Count()
+    retval = Array.new(num_cols)
+
+    for i in 0...num_cols do
+      retval[i] = @res_handle.Fields(i).Value()
+    end
+  
+    retval
+  end
+  
+
+end
+
+
+end # module ADO
+end # module DBD
+end # module DBI
+

data/lib/dbi.rb

@@ -0,0 +1,1043 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+#
+# Ruby/DBI
+#
+# Copyright (c) 2001, 2002, 2003 Michael Neumann <mneumann@ntecs.de>
+# 
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without 
+# modification, are permitted provided that the following conditions 
+# are met:
+# 1. Redistributions of source code must retain the above copyright 
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright 
+#    notice, this list of conditions and the following disclaimer in the 
+#    documentation and/or other materials provided with the distribution.
+# 3. The name of the author may not be used to endorse or promote products
+#    derived from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+# THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+# $Id: dbi.rb,v 1.8 2006/09/03 04:05:29 pdubois Exp $
+#
+
+require "find"
+require "dbi/row"
+require "dbi/utils"
+require "dbi/sql"
+require "dbi/columninfo"
+require "date"
+require "thread"
+require 'monitor'
+
+module DBI
+   VERSION = "0.2.2"
+   
+   module DBD
+      DIR         = "DBD"
+      API_VERSION = "0.3"
+   end
+   
+   #  Constants
+   
+   # Constants for fetch_scroll
+   #
+   SQL_FETCH_NEXT     = 1
+   SQL_FETCH_PRIOR    = 2
+   SQL_FETCH_FIRST    = 3
+   SQL_FETCH_LAST     = 4
+   SQL_FETCH_ABSOLUTE = 5
+   SQL_FETCH_RELATIVE = 6
+   
+   # SQL type constants
+   # 
+   SQL_CHAR       = 1
+   SQL_NUMERIC    = 2
+   SQL_DECIMAL    = 3
+   SQL_INTEGER    = 4
+   SQL_SMALLINT   = 5
+   SQL_FLOAT      = 6
+   SQL_REAL       = 7
+   SQL_DOUBLE     = 8
+   SQL_DATE       = 9  # 91
+   SQL_TIME       = 10 # 92 
+   SQL_TIMESTAMP  = 11 # 93 
+   SQL_VARCHAR    = 12
+   SQL_BOOLEAN    = 13
+   
+   SQL_LONGVARCHAR   = -1
+   SQL_BINARY        = -2
+   SQL_VARBINARY     = -3
+   SQL_LONGVARBINARY = -4
+   SQL_BIGINT        = -5
+   SQL_TINYINT       = -6
+   SQL_BIT           = -7
+   
+   # TODO
+   # Find types for these (XOPEN?)
+   #SQL_ARRAY = 
+   SQL_BLOB = -10   # TODO
+   SQL_CLOB = -11   # TODO
+   #SQL_DISTINCT = 
+   #SQL_OBJECT = 
+   #SQL_NULL = 
+   SQL_OTHER = 100
+   #SQL_REF = 
+   #SQL_STRUCT = 
+   
+   SQL_TYPE_NAMES = {
+      SQL_BIT               => 'BIT',
+      SQL_TINYINT           => 'TINYINT',
+      SQL_SMALLINT          => 'SMALLINT',
+      SQL_INTEGER           => 'INTEGER',
+      SQL_BIGINT            => 'BIGINT',
+      SQL_FLOAT             => 'FLOAT',
+      SQL_REAL              => 'REAL',
+      SQL_DOUBLE            => 'DOUBLE',
+      SQL_NUMERIC           => 'NUMERIC',
+      SQL_DECIMAL           => 'DECIMAL',
+      SQL_CHAR              => 'CHAR',
+      SQL_VARCHAR           => 'VARCHAR',
+      SQL_LONGVARCHAR       => 'LONG VARCHAR',
+      SQL_DATE              => 'DATE',
+      SQL_TIME              => 'TIME',
+      SQL_TIMESTAMP         => 'TIMESTAMP',
+      SQL_BINARY            => 'BINARY',
+      SQL_VARBINARY         => 'VARBINARY',
+      SQL_LONGVARBINARY     => 'LONG VARBINARY',
+      SQL_BLOB              => 'BLOB',
+      SQL_CLOB              => 'CLOB',
+      SQL_OTHER             => nil,
+      SQL_BOOLEAN           => 'BOOLEAN',
+
+   }
+   
+   #  Exceptions (borrowed by Python API 2.0)
+   
+   # Base class of all other error exceptions.  Use this to catch all DBI
+   # errors.
+   class Error < RuntimeError
+   end
+   
+   # For important warnings like data truncation, etc.
+   class Warning < RuntimeError
+   end
+   
+   # Exception for errors related to the DBI interface rather than the
+   # database itself.
+   class InterfaceError < Error
+   end
+   
+   # Exception raised if the DBD driver has not specified a mandatory method.
+   class NotImplementedError < InterfaceError
+   end
+   
+   # Exception for errors related to the database.
+   class DatabaseError < Error
+      attr_reader :err, :errstr, :state
+      
+      def initialize(errstr="", err=nil, state=nil)
+         super(errstr)
+         @err, @errstr, @state = err, errstr, state
+      end
+   end
+   
+   # Exception for errors due to problems with the processed 
+   # data such as division by zero, numeric value out of range, etc.
+   class DataError < DatabaseError
+   end
+   
+   # Exception for errors related to the database's operation which are not
+   # necessarily under the control of the programmer.  This includes such
+   # things as unexpected disconnect, datasource name not found, transaction
+   # could not be processed, a memory allocation error occured during
+   # processing, etc.
+   class OperationalError < DatabaseError
+   end
+   
+   # Exception raised when the relational integrity of the database
+   # is affected, e.g. a foreign key check fails.
+   class IntegrityError < DatabaseError
+   end
+   
+   # Exception raised when the database encounters an internal error, 
+   # e.g. the cursor is not valid anymore, the transaction is out of sync.
+   class InternalError < DatabaseError
+   end
+   
+   # Exception raised for programming errors, e.g. table not found
+   # or already exists, syntax error in SQL statement, wrong number
+   # of parameters specified, etc.
+   class ProgrammingError < DatabaseError
+   end
+   
+   # Exception raised if e.g. commit() is called for a database which do not
+   # support transactions.
+   class NotSupportedError < DatabaseError
+   end
+   
+   #  Datatypes
+   
+   # TODO: do we need Binary?
+   # perhaps easier to call #bind_param(1, binary_string, 'type' => SQL_BLOB)
+   class Binary
+      attr_accessor :data
+      def initialize(data)
+         @data = data
+      end
+      
+      def to_s
+         @data
+      end
+   end
+   
+   #  Module functions (of DBI)
+   DEFAULT_TRACE_MODE = 2
+   DEFAULT_TRACE_OUTPUT = STDERR
+   
+   # TODO: Is using class variables within a module such a wise idea? - Dan B.
+   @@driver_map     = Hash.new
+   @@driver_monitor = ::Monitor.new()
+   @@trace_mode     = DEFAULT_TRACE_MODE
+   @@trace_output   = DEFAULT_TRACE_OUTPUT
+   
+   class << self
+      
+      # Establish a database connection.  This is mostly a facade for the
+      # DBD's connect method.
+      def connect(driver_url, user=nil, auth=nil, params=nil, &p)
+         dr, db_args = _get_full_driver(driver_url)
+         dh = dr[0] # driver-handle
+         dh.connect(db_args, user, auth, params, &p)
+      end
+      
+      # Load a DBD and returns the DriverHandle object
+      def get_driver(driver_url)
+         _get_full_driver(driver_url)[0][0]  # return DriverHandle
+      end
+      
+      # Extracts the db_args from driver_url and returns the correspondeing
+      # entry of the @@driver_map.
+      def _get_full_driver(driver_url)
+         db_driver, db_args = parse_url(driver_url)
+         db_driver = load_driver(db_driver)
+         dr = @@driver_map[db_driver]
+         [dr, db_args]
+      end
+      
+      def trace(mode=nil, output=nil)
+         @@trace_mode   = mode   || @@trace_mode   || DBI::DEFAULT_TRACE_MODE
+         @@trace_output = output || @@trace_output || DBI::DEFAULT_TRACE_OUTPUT
+      end
+      
+      # Returns a list of the currently available drivers on your system in
+      # 'dbi:driver:' format.
+      def available_drivers
+         drivers = []
+         #path = File.dirname(File.dirname(__FILE__)) + "/" + DBD::DIR
+         path = File.dirname(__FILE__) + "/" + DBD::DIR
+         Find.find(path){ |f|
+            if File.file?(f)
+               driver = File.basename(f, ".rb")
+               drivers.push("dbi:#{driver}:")
+            end
+         }
+         drivers
+      end
+      
+      def data_sources(driver)
+         db_driver, = parse_url(driver)
+         db_driver = load_driver(db_driver)
+         dh = @@driver_map[db_driver][0]
+         dh.data_sources
+      end
+      
+      def disconnect_all( driver = nil )
+         if driver.nil?
+            @@driver_map.each {|k,v| v[0].disconnect_all}
+         else
+            db_driver, = parse_url(driver)
+            @@driver_map[db_driver][0].disconnect_all
+         end
+      end
+      
+      
+      private
+      
+      ##
+      # extended by John Gorman <jgorman@webbysoft.com> for
+      # case insensitive DBD names
+      # 
+      def load_driver(driver_name)
+          @@driver_monitor.synchronize do
+              if @@driver_map[driver_name].nil?
+
+                  dc = driver_name.downcase
+
+                  # caseless look for drivers already loaded
+                  found = @@driver_map.keys.find {|key| key.downcase == dc}
+                  return found if found
+
+                  if $SAFE >= 1
+                      # case-sensitive in safe mode
+                      require "#{DBD::DIR}/#{driver_name}/#{driver_name}"
+                  else
+                      # FIXME this whole require scheme is so horribly stupid I
+                      # can't even begin to think about how much I'd enjoy what
+                      # was smoked when this was thought up.
+                      #
+                      # Here's a hack to get tests to work.
+                      # try a quick load and then a caseless scan
+                      begin
+                          begin
+                              require "dbd/#{driver_name}"
+                          rescue LoadError 
+                              require "#{DBD::DIR}/#{driver_name}/#{driver_name}"
+                          end
+                      rescue LoadError
+                          $LOAD_PATH.each do |dir|
+                              path = "#{dir}/dbd"
+                              if FileTest.directory?(path)
+                                  require "#{path}/#{driver_name}"
+                                  break
+                              end
+
+                              path = "#{dir}/#{DBD::DIR}"
+                              next unless FileTest.directory?(path)
+                              found = Dir.entries(path).find {|e| e.downcase == dc}
+                              next unless found
+
+                              require "#{path}/#{found}/#{found}"
+                              break
+                          end
+                      end
+                  end
+
+                  found ||= driver_name
+
+                  # On a filesystem that is not case-sensitive (e.g., HFS+ on Mac OS X),
+                  # the initial require attempt that loads the driver may succeed even
+                  # though the lettercase of driver_name doesn't match the actual
+                  # filename. If that happens, const_get will fail and it become
+                  # necessary to look though the list of constants and look for a
+                  # caseless match.  The result of this match provides the constant
+                  # with the proper lettercase -- which can be used to generate the
+                  # driver handle.
+
+                  dr = nil
+                  begin
+                      dr = DBI::DBD.const_get(found.intern)
+                  rescue NameError
+                      # caseless look for constants to find actual constant
+                      found = found.downcase
+                      found = DBI::DBD.constants.find { |e| e.downcase == found }
+                      dr = DBI::DBD.const_get(found.intern) unless found.nil?
+                  end
+
+                  # If dr is nil at this point, it means the underlying driver
+                  # failed to load.  This usually means it's not installed, but
+                  # can fail for other reasons.
+                  if dr.nil?
+                      err = "Unable to load driver '#{driver_name}'"
+                      raise DBI::InterfaceError, err
+                  end
+
+                  dbd_dr = dr::Driver.new
+                  drh = DBI::DriverHandle.new(dbd_dr)
+                  drh.trace(@@trace_mode, @@trace_output)
+                  @@driver_map[found] = [drh, dbd_dr]
+                  return found
+              else
+                  return driver_name
+              end
+          end
+      rescue LoadError, NameError
+          if $SAFE >= 1
+              raise InterfaceError, "Could not load driver (#{$!.message}). Note that in SAFE mode >= 1, driver URLs have to be case sensitive!"
+          else
+              raise InterfaceError, "Could not load driver (#{$!.message})"
+          end
+      end
+      
+      # Splits a DBI URL into two components - the database driver name
+      # and the datasource (along with any options, if any) and returns
+      # a two element array, e.g. 'dbi:foo:bar' would return ['foo','bar'].
+      #
+      # A regular expression is used instead of a simple split to validate
+      # the proper format for the URL.  If it isn't correct, an Interface
+      # error is raised.
+      def parse_url(driver_url)
+         if driver_url =~ /^(DBI|dbi):([^:]+)(:(.*))$/ 
+            [$2, $4]
+         else
+            raise InterfaceError, "Invalid Data Source Name"
+         end
+      end
+      
+   end # self
+   
+   
+   
+   #----------------------------------------------------
+   #  Dispatch classes
+   #----------------------------------------------------
+   
+   
+   ##
+   # Dispatch classes (Handle, DriverHandle, DatabaseHandle and StatementHandle)
+   #
+   
+   class Handle
+      attr_reader :trace_mode, :trace_output
+      attr_reader :handle 
+      
+      def initialize(handle)
+         @handle = handle
+         @trace_mode = @trace_output = nil
+      end
+      
+      def trace(mode=nil, output=nil)
+         @trace_mode   = mode   || @trace_mode   || DBI::DEFAULT_TRACE_MODE
+         @trace_output = output || @trace_output || DBI::DEFAULT_TRACE_OUTPUT
+      end
+      
+      
+      ##
+      # call a driver specific function
+      #
+      def func(function, *values)
+         if @handle.respond_to?("__" + function.to_s) then
+            @handle.send("__" + function.to_s, *values)  
+         else
+            raise InterfaceError, "Driver specific function <#{function}> not available."
+         end
+      rescue ArgumentError
+         raise InterfaceError, "Wrong # of arguments for driver specific function"
+      end
+      
+      # error functions?
+   end
+   
+   class DriverHandle < Handle
+      
+      def connect(db_args, user, auth, params)
+         
+         user = @handle.default_user[0] if user.nil?
+         auth = @handle.default_user[1] if auth.nil?
+         
+         # TODO: what if only one of them is nil?
+         #if user.nil? and auth.nil? then
+         #  user, auth = @handle.default_user
+         #end
+         
+         params ||= {}
+         new_params = @handle.default_attributes
+         params.each {|k,v| new_params[k] = v} 
+         
+         
+         db = @handle.connect(db_args, user, auth, new_params)
+         dbh = DatabaseHandle.new(db)
+         dbh.trace(@trace_mode, @trace_output)
+         
+         if block_given?
+            begin
+               yield dbh
+            ensure  
+               dbh.disconnect if dbh.connected?
+            end  
+         else
+            return dbh
+         end
+      end
+      
+      def data_sources
+         @handle.data_sources
+      end
+      
+      def disconnect_all
+         @handle.disconnect_all
+      end
+   end
+   
+   class DatabaseHandle < Handle
+      
+      include DBI::Utils::ConvParam
+      
+      def connected?
+         not @handle.nil?
+      end
+      
+      def disconnect
+         raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+         @handle.disconnect
+         @handle = nil
+      end
+      
+      def prepare(stmt)
+         raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+         sth = StatementHandle.new(@handle.prepare(stmt), false)
+         sth.trace(@trace_mode, @trace_output)
+         
+         if block_given?
+            begin
+               yield sth
+            ensure
+               sth.finish unless sth.finished?
+            end
+         else
+            return sth
+         end 
+      end
+      
+      def execute(stmt, *bindvars)
+         raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+         sth = StatementHandle.new(@handle.execute(stmt, *conv_param(*bindvars)), true, false)
+         sth.trace(@trace_mode, @trace_output)
+         
+         if block_given?
+            begin
+               yield sth
+            ensure
+               sth.finish unless sth.finished?
+            end
+         else
+            return sth
+         end 
+      end
+      
+      def do(stmt, *bindvars)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.do(stmt, *conv_param(*bindvars))
+         end
+         
+         def select_one(stmt, *bindvars)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            row = nil
+            execute(stmt, *bindvars) do |sth|
+               row = sth.fetch 
+            end
+            row
+         end
+         
+         def select_all(stmt, *bindvars, &p)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            rows = nil
+            execute(stmt, *bindvars) do |sth|
+               if block_given?
+                  sth.each(&p)
+               else
+                  rows = sth.fetch_all 
+               end
+            end
+            return rows
+         end
+         
+         def tables
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.tables
+         end
+         
+         def columns( table )
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.columns( table ).collect {|col| ColumnInfo.new(col) }
+         end
+         
+         def ping
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.ping
+         end
+         
+         def quote(value)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.quote(value)
+         end
+         
+         def commit
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.commit
+         end
+         
+         def rollback
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle.rollback
+         end
+         
+         def transaction
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            raise InterfaceError, "No block given" unless block_given?
+            
+            commit
+            begin
+               yield self
+               commit
+            rescue Exception
+               rollback
+               raise
+            end
+         end
+         
+         
+         def [] (attr)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle[attr]
+         end
+         
+         def []= (attr, val)
+            raise InterfaceError, "Database connection was already closed!" if @handle.nil?
+            @handle[attr] = val
+         end
+         
+      end
+      
+      class StatementHandle < Handle
+         
+         include Enumerable
+         include DBI::Utils::ConvParam
+         
+         def initialize(handle, fetchable=false, prepared=true)
+            super(handle)
+            @fetchable = fetchable
+            @prepared  = prepared     # only false if immediate execute was used
+            @cols = nil
+            
+            # TODO: problems with other DB's?
+            #@row = DBI::Row.new(column_names,nil)
+            if @fetchable
+               @row = DBI::Row.new(column_names,nil)
+            else
+               @row = nil
+            end
+         end
+         
+         def finished?
+            @handle.nil?
+         end
+         
+         def fetchable?
+            @fetchable
+         end
+         
+         def bind_param(param, value, attribs=nil)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement wasn't prepared before." unless @prepared
+            @handle.bind_param(param, conv_param(value)[0], attribs)
+         end
+         
+         def execute(*bindvars)
+            cancel     # cancel before 
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement wasn't prepared before." unless @prepared
+            @handle.bind_params(*conv_param(*bindvars))
+            @handle.execute
+            @fetchable = true
+            
+            # TODO:?
+            #if @row.nil?
+            @row = DBI::Row.new(column_names,nil)
+            #end
+            return nil
+         end
+         
+         def finish
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle.finish
+            @handle = nil
+         end
+         
+         def cancel
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle.cancel if @fetchable
+            @fetchable = false
+         end
+         
+         def column_names
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            return @cols unless @cols.nil?
+            @cols = @handle.column_info.collect {|col| col['name'] }
+         end
+         
+         def column_info
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle.column_info.collect {|col| ColumnInfo.new(col) }
+         end
+         
+         def rows
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle.rows
+         end
+         
+         
+         def fetch(&p)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            
+            if block_given? 
+               while (res = @handle.fetch) != nil
+                  @row.set_values(res)
+                  yield @row
+               end
+               @handle.cancel
+               @fetchable = false
+               return nil
+            else
+               res = @handle.fetch
+               if res.nil?
+                  @handle.cancel
+                  @fetchable = false
+               else
+                  @row.set_values(res)
+                  res = @row
+               end
+               return res
+            end
+         end
+         
+         def each(&p)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            raise InterfaceError, "No block given" unless block_given?
+            
+            fetch(&p)
+         end
+         
+         def fetch_array
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            
+            if block_given? 
+               while (res = @handle.fetch) != nil
+                  yield res
+               end
+               @handle.cancel
+               @fetchable = false
+               return nil
+            else
+               res = @handle.fetch
+               if res.nil?
+                  @handle.cancel
+                  @fetchable = false
+               end
+               return res
+            end
+         end
+         
+         def fetch_hash
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            
+            cols = column_names
+            
+            if block_given? 
+               while (row = @handle.fetch) != nil
+                  hash = {}
+                  row.each_with_index {|v,i| hash[cols[i]] = v} 
+                  yield hash
+               end
+               @handle.cancel
+               @fetchable = false
+               return nil
+            else
+               row = @handle.fetch
+               if row.nil?
+                  @handle.cancel
+                  @fetchable = false
+                  return nil
+               else
+                  hash = {}
+                  row.each_with_index {|v,i| hash[cols[i]] = v} 
+                  return hash
+               end
+            end
+         end
+         
+         def fetch_many(cnt)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            
+            cols = column_names
+            rows = @handle.fetch_many(cnt)
+            if rows.nil?
+               @handle.cancel
+               @fetchable = false
+               return []
+            else
+               return rows.collect{|r| Row.new(cols, r)}
+            end
+         end
+         
+         def fetch_all
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            
+            cols = column_names
+            rows = @handle.fetch_all
+            if rows.nil?
+               @handle.cancel
+               @fetchable = false
+               return []
+            else
+               return rows.collect{|r| Row.new(cols, r)}
+            end
+         end
+         
+         def fetch_scroll(direction, offset=1)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            raise InterfaceError, "Statement must first be executed" unless @fetchable
+            
+            row = @handle.fetch_scroll(direction, offset)
+            if row.nil?
+               #@handle.cancel
+               #@fetchable = false
+               return nil
+            else
+               @row.set_values(row)
+               return @row
+            end
+         end
+         
+         def [] (attr)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle[attr]
+         end
+         
+         def []= (attr, val)
+            raise InterfaceError, "Statement was already closed!" if @handle.nil?
+            @handle[attr] = val
+         end
+         
+      end # class StatementHandle
+      
+      
+      
+      
+      
+      #----------------------------------------------------
+      #  Fallback classes
+      #----------------------------------------------------
+      
+      
+      ##
+      # Fallback classes for default behavior of DBD driver
+      # must be inherited by the DBD driver classes
+      #
+      
+      class Base
+      end
+      
+      
+      class BaseDriver < Base
+         
+         def initialize(dbd_version)
+            major, minor = dbd_version.split(".")
+            unless major.to_i == DBD::API_VERSION.split(".")[0].to_i
+               raise InterfaceError, "Wrong DBD API version used"
+            end
+         end
+         
+         def connect(dbname, user, auth, attr)
+            raise NotImplementedError
+         end
+         
+         def default_user
+            ['', '']
+         end
+         
+         def default_attributes
+            {}
+         end
+         
+         def data_sources
+            []
+         end
+         
+         def disconnect_all
+            raise NotImplementedError
+         end
+         
+      end # class BaseDriver
+      
+      class BaseDatabase < Base
+         
+         def initialize(handle, attr)
+            @handle = handle
+            @attr   = {}
+            attr.each {|k,v| self[k] = v} 
+         end
+         
+         def disconnect
+            raise NotImplementedError
+         end
+         
+         def ping
+            raise NotImplementedError
+         end
+         
+         def prepare(statement)
+            raise NotImplementedError
+         end
+         
+         #============================================
+         # OPTIONAL
+         #============================================
+         
+         def commit
+            raise NotSupportedError
+         end
+         
+         def rollback
+            raise NotSupportedError
+         end
+         
+         def tables
+            []
+         end
+         
+         def columns(table)
+            []
+         end
+         
+         
+         def execute(statement, *bindvars)
+            stmt = prepare(statement)
+            stmt.bind_params(*bindvars)
+            stmt.execute
+            stmt
+         end
+         
+         def do(statement, *bindvars)
+               stmt = execute(statement, *bindvars)
+               res = stmt.rows
+               stmt.finish
+               return res
+            end
+            
+            # includes quote
+            include DBI::SQL::BasicQuote
+            
+            def [](attr)
+               @attr[attr]
+            end
+            
+            def []=(attr, value)
+               raise NotSupportedError
+            end
+            
+         end # class BaseDatabase
+         
+         
+         class BaseStatement < Base
+            
+            def initialize(attr=nil)
+               @attr = attr || {}
+            end
+            
+            
+            
+            def bind_param(param, value, attribs)
+               raise NotImplementedError
+            end
+            
+            def execute
+               raise NotImplementedError
+            end
+            
+            def finish
+               raise NotImplementedError
+            end
+            
+            def fetch
+               raise NotImplementedError
+            end
+            
+            ##
+            # returns result-set column information as array
+            # of hashs, where each hash represents one column
+            def column_info
+               raise NotImplementedError
+            end
+            
+            #============================================
+            # OPTIONAL
+            #============================================
+            
+            def bind_params(*bindvars)
+               bindvars.each_with_index {|val,i| bind_param(i+1, val, nil) }
+               self
+            end
+            
+            def cancel
+            end
+            
+            def fetch_scroll(direction, offset)
+               case direction
+               when SQL_FETCH_NEXT
+                  return fetch
+               when SQL_FETCH_LAST
+                  last_row = nil
+                  while (row=fetch) != nil
+                     last_row = row
+                  end
+                  return last_row
+               when SQL_FETCH_RELATIVE
+                  raise NotSupportedError if offset <= 0
+                  row = nil
+                  offset.times { row = fetch; break if row.nil? }
+                  return row
+               else
+                  raise NotSupportedError
+               end
+            end
+            
+            def fetch_many(cnt)
+               rows = []
+               cnt.times do
+                  row = fetch
+                  break if row.nil?
+                  rows << row.dup
+               end
+               
+               if rows.empty?
+                  nil
+               else
+                  rows
+               end
+            end
+            
+            def fetch_all
+               rows = []
+               loop do
+                  row = fetch
+                  break if row.nil?
+                  rows << row.dup
+               end
+               
+               if rows.empty?
+                  nil
+               else
+                  rows
+               end
+            end
+            
+            def [](attr)
+               @attr[attr]
+            end
+            
+            def []=(attr, value)
+               raise NotSupportedError
+            end
+            
+         end # class BaseStatement
+         
+         
+      end # module DBI
+      
+