rails-dbd-mysql 0.1.0

data/LICENSE

@@ -0,0 +1,25 @@
+(C) 2008 Erik Hollensbe <erik@hollensbe.org>. All rights reserved.
+
+Please see "README" for earlier copyrights.
+
+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.

data/README

@@ -0,0 +1,271 @@
+= Description
+    The DBI package is a vendor independent interface for accessing databases.
+    It is similar, but not identical to, Perl's DBI module.
+
+= Synopsis
+
+    require 'dbi'
+    
+    # Connect to a database, old style
+    dbh = DBI.connect('DBI:Mysql:test', 'testuser', 'testpwd')
+    
+    # Insert some rows, use placeholders
+    1.upto(13) do |i|
+        sql = "insert into simple01 (SongName, SongLength_s) VALUES (?, ?)"
+        dbh.do(sql, "Song #{i}", "#{i*10}")
+    end 
+    
+    # Select all rows from simple01
+    sth = dbh.prepare('select * from simple01')
+    sth.execute
+    
+    # Print out each row
+    while row=sth.fetch do
+        p row
+    end
+    
+    # Close the statement handle when done
+    sth.finish
+    
+    # Don't prepare, just do it!
+    dbh.do('delete from simple01 where internal_id > 10')
+      
+    # And finally, disconnect
+    dbh.disconnect
+        
+    # Same example, but a little more Ruby-ish
+    DBI.connect('DBI:Mysql:test', 'testuser', 'testpwd') do | dbh |
+      
+        sql = "insert into simple01 (SongName, SongLength_s) VALUES (?, ?)"
+        
+        dbh.prepare(sql) do | sth | 
+            1.upto(13) { |i| sth.execute("Song #{i}", "#{i*10}") }
+        end 
+        
+        dbh.select_all('select * from simple01') do | row |
+            p row
+        end
+        
+        dbh.do('delete from simple01 where internal_id > 10')
+      
+    end
+
+= Prerequisites
+    Ruby 1.8.6 or later is the test target, however you may have success with
+    earlier 1.8.x versions of Ruby.
+
+= RubyForge Project
+    General information: http://ruby-dbi.rubyforge.org
+    Project information: http://rubyforge.org/projects/ruby-dbi/
+    Downloads: http://rubyforge.org/frs/?group_id=234
+
+= Installation
+    There are many database drivers (DBDs) available.  You only need to install
+    the DBDs for the database software that you will be using.
+
+== Gem setup:
+
+    gem install dbi
+    # One or more of:
+    gem install dbd-mysql
+    gem install dbd-pg
+    gem install dbd-sqlite3
+    gem install dbd-sqlite
+
+== Without rubygems:
+
+    ruby setup.rb config
+    ruby setup.rb setup
+    ruby setup.rb install
+
+== The bleeding edge:
+
+    git clone git://hollensbe.org/git/ruby-dbi.git
+    git checkout -b development origin/development
+    
+    Also available at
+    
+    git clone git://github.com/erikh/ruby-dbi.git
+      
+= Available Database Drivers (DBDs)
+
+== DBD::MySQL
+    MySQL
+    Depends on the mysql-ruby package from http://www.tmtm.org/mysql or
+    available from the RAA.
+
+== DBD::ODBC
+    ODBC
+    Depends on the ruby-odbc package (0.5 or later, 0.9.3 or later recommended) at
+    http://www.ch-werner.de/rubyodbc or available from the RAA.  Works together
+    with unix-odbc.
+
+== DBD::OCI8
+    OCI8 (Oracle)
+    Depends on the the ruby-oci8 package, available on the RAA and RubyForge.
+
+== DBD::Pg
+    PostgreSQL
+    Depends on the pg package, available on RubyForge.
+
+== DBD::SQLite
+    SQLite (versions 2.x and earlier)
+    Depends on the sqlite-ruby package, available on rubyforge.
+
+== DBD::SQLite3
+    SQLite 3.x
+    Depends on the sqlite3-ruby package, available on rubyforge.
+
+= Additional Documentation
+    See the directories doc/* for DBI and DBD specific information.
+    The DBI specification is at doc/DBI_SPEC.rdoc.
+    The DBD specification is at doc/DBD_SPEC.rdoc.
+
+= Articles
+== Tutorial: Using the Ruby DBI Module
+    http://www.kitebird.com/articles/ruby-dbi.html
+   
+= Applications
+== dbi
+    The SQL command line interpreter dbi is available in directory
+    bin/. It gets installed by default.
+
+= License
+
+   Copyright (c) 2008 Erik Hollensbe
+
+   Copyright (c) 2005-2006 Kirk Haines, Francis Hwang, Patrick May and Daniel
+   Berger.
+
+   Copyright (c) 2001, 2002, 2003, 2004 Michael Neumann <mneumann@ntecs.de>
+   and others (see the beginning of each file for copyright holder information).
+
+   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.
+
+   This is the BSD license which is less restrictive than GNU's GPL
+   (General Public License).
+
+= Contributors
+   
+   Pistos
+      Too much to specify. Infinite patience and help.
+
+   Christopher Maujean
+      Lots of initial help when reviving the project.
+
+   Jun Mukai <mukai@jmuk.org>
+      Contributed initial SQLite3 DBD.
+
+   John J. Fox IV
+      Lots of help testing on multiple platforms.
+
+   Kirk Haines
+      One of the authors of the rewrite effort (January 2006).
+
+   Francis Hwang
+      One of the authors of the rewrite effort (January 2006).
+
+   Patrick May
+      One of the authors of the rewrite effort (January 2006).
+
+   Daniel Berger
+      One of the authors of the rewrite effort (January 2006).
+
+   Michael Neumann
+      Original author of Ruby/DBI; wrote the DBI and most of the DBDs.
+
+   Rainer Perl
+      Author of Ruby/DBI 0.0.4 from which many good ideas were taken.
+
+   Jim Weirich
+      Original author of DBD::Pg.  Wrote additional code (e.g. sql.rb,
+      testcases).  Gave many helpful hints and comments. 
+
+   Eli Green
+      Implemented DatabaseHandle#columns for Mysql and Pg. 
+
+   Masatoshi SEKI
+      For his version of module BasicQuote in sql.rb. 
+
+   John Gorman
+      For his case insensitive load_driver patch and parameter parser. 
+
+   David Muse
+      For testing the DBD::SQLRelay and for his initial DBD. 
+
+   Jim Menard
+      Extended DBD::Oracle for method columns. 
+
+   Joseph McDonald
+      Fixed bug in DBD::Pg (default values in method columns). 
+
+   Norbert Gawor
+      Fixed bug in DBD::ODBC (method columns) and proxyserver. 
+
+   James F. Hranicky
+      Patch for DBD::Pg (cache PGResult#result in Tuples) which increased
+      performance by a factor around 100. 
+
+   Stephen Davies
+      Added method Statement#fetch_scroll for DBD::Pg. 
+
+   Dave Thomas
+      Several enhancements. 
+
+   Brad Hilton
+      Column coercing patch for DBD::Mysql. 
+
+   Sean Chittenden
+      Originally a co-owner of the project.  Submitted several patches
+      and helped with lots of comments.
+
+   MoonWolf
+      Provided the quote/escape_byte patch for DBD::Pg, DBD::SQLite patch and
+      Database#columns implementation. Further patches. 
+
+   Paul DuBois
+      Fixed typos and formatting. Maintains DBD::Mysql. 
+
+   Tim Bates
+      Bug fixes for Mysql and DBI.
+
+   Brian Candler
+      Zero-padding date/time/timestamps fix. 
+
+   Florian G. Pflug
+      Discussion and helpful comments/benchmarks about DBD::Pg async_exec vs.
+      exec. 
+   
+   Oliver M. Bolzer
+      Patches to support Postgres arrays for DBD::Pg. 
+
+   Stephen R. Veit
+      ruby-db2 and DBD::DB2 enhancements. 
+
+   Dennis Vshivkov
+      DBD::Pg patches 
+
+   Cail Borrell from frontbase.com
+      For the Frontbase DBD and C interface. 

data/lib/dbd/Mysql.rb

@@ -0,0 +1,137 @@
+#--
+# 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$
+#++
+
+begin
+    require 'rubygems'
+    gem 'mysql'
+    gem 'dbi'
+rescue LoadError => e
+end
+
+require 'dbi'
+require "mysql"
+require "thread"   # for Mutex
+
+module DBI
+    module DBD
+        #
+        # DBD::Mysql - Database Driver for the MySQL database system.
+        #
+        # Requires DBI and the 'mysql' gem or package to work.
+        #
+        # Only things that extend DBI's results are documented.
+        #
+        module Mysql
+            VERSION          = "0.4.4"
+            DESCRIPTION      = "MySQL DBI DBD, Leverages 'mysql' low-level driver"
+
+            MyError = ::MysqlError
+
+            #
+            # returns 'Mysql'
+            # 
+            # See DBI::TypeUtil#convert for more information.
+            #
+            def self.driver_name
+                "Mysql"
+            end
+
+            DBI::TypeUtil.register_conversion(driver_name) do |obj|
+                newobj = case obj
+                         when ::DBI::Binary
+                             obj = obj.to_s.gsub(/\\/) { "\\\\" }
+                             obj = obj.to_s.gsub(/'/) { "''" }
+                             "'#{obj}'"
+                         when ::DateTime
+                             "'#{obj.strftime("%Y-%m-%d %H:%M:%S")}'"
+                         when ::Time
+                             "'#{obj.strftime("%H:%M:%S")}'"
+                         when ::Date
+                             "'#{obj.strftime("%Y-%m-%d")}'"
+                         when ::NilClass
+                             "NULL"
+                         else
+                             obj
+                         end
+
+                if newobj.object_id == obj.object_id
+                    [newobj, true]
+                else
+                    [newobj, false]
+                end
+            end
+        end
+    end
+end
+
+#
+# Utility Methods for the MySQL DBD.
+#
+
+module DBI::DBD::Mysql::Util
+    private
+
+    # Raise exception using information from MysqlError object e.
+    # For state value, use SQLSTATE value if mysql-ruby defines
+    # sqlstate method, otherwise nil.
+    def error(e)
+        sqlstate = e.respond_to?("sqlstate") ? e.sqlstate : nil
+        raise DBI::DatabaseError.new(e.message, e.errno, sqlstate)
+    end
+
+end # module Util
+
+module DBI::DBD::Mysql::Type
+    #
+    # Custom handling for DATE types in MySQL. See DBI::Type for more
+    # information.
+    #
+    class Date < DBI::Type::Null
+        def self.parse(obj)
+            obj = super
+            return obj unless obj
+
+            case obj.class
+            when ::Date
+                return obj
+            when ::String
+                return ::Date.strptime(obj, "%Y-%m-%d")
+            else
+                return ::Date.parse(obj.to_s)   if obj.respond_to? :to_s
+                return ::Date.parse(obj.to_str) if obj.respond_to? :to_str
+                return obj
+            end
+        end
+    end
+end
+
+require 'dbd/mysql/driver'
+require 'dbd/mysql/database'
+require 'dbd/mysql/statement'

data/lib/dbd/mysql/database.rb

@@ -0,0 +1,405 @@
+module DBI::DBD::Mysql
+    #
+    # Models the DBI::BaseDatabase API to create DBI::DatabaseHandle objects.
+    #
+    class Database < DBI::BaseDatabase
+        include Util
+
+        #
+        # Hash to translate MySQL type names to DBI SQL type constants
+        #
+        # Only used in #mysql_type_info.
+        #
+        #--
+        # Eli Green:
+        #   The hope is that we don't ever need to just assume the default values.
+        #   However, in some cases (notably floats and doubles), I have seen
+        #   "show fields from table" return absolutely zero information about size
+        #   and precision. Sigh. I probably should have made a struct to store
+        #   this info in ... but I didn't.
+        #++
+        MYSQL_to_XOPEN = {
+                    "TINYINT"    => [DBI::SQL_TINYINT, 1, nil],
+                    "SMALLINT"   => [DBI::SQL_SMALLINT, 6, nil],
+                    "MEDIUMINT"  => [DBI::SQL_SMALLINT, 6, nil],
+                    "INT"        => [DBI::SQL_INTEGER, 11, nil],
+                    "INTEGER"    => [DBI::SQL_INTEGER, 11, nil],
+                    "BIGINT"     => [DBI::SQL_BIGINT, 25, nil],
+                    "INT24"      => [DBI::SQL_BIGINT, 25, nil],
+                    "REAL"       => [DBI::SQL_REAL, 12, nil],
+                    "FLOAT"      => [DBI::SQL_FLOAT, 12, nil],
+                    "DECIMAL"    => [DBI::SQL_DECIMAL, 12, nil],
+                    "NUMERIC"    => [DBI::SQL_NUMERIC, 12, nil],
+                    "DOUBLE"     => [DBI::SQL_DOUBLE, 22, nil],
+                    "CHAR"       => [DBI::SQL_CHAR, 1, nil],
+                    "VARCHAR"    => [DBI::SQL_VARCHAR, 255, nil],
+                    "DATE"       => [DBI::SQL_DATE, 10, nil],
+                    "TIME"       => [DBI::SQL_TIME, 8, nil],
+                    "TIMESTAMP"  => [DBI::SQL_TIMESTAMP, 19, nil],
+                    "DATETIME"   => [DBI::SQL_TIMESTAMP, 19, nil],
+                    "TINYBLOB"   => [DBI::SQL_BINARY, 255, nil],
+                    "BLOB"       => [DBI::SQL_VARBINARY, 65535, nil],
+                    "MEDIUMBLOB" => [DBI::SQL_VARBINARY, 16277215, nil],
+                    "LONGBLOB"   => [DBI::SQL_LONGVARBINARY, 2147483657, nil],
+                    "TINYTEXT"   => [DBI::SQL_VARCHAR, 255, nil],
+                    "TEXT"       => [DBI::SQL_LONGVARCHAR, 65535, nil],
+                    "MEDIUMTEXT" => [DBI::SQL_LONGVARCHAR, 16277215, nil],
+                    "LONGTEXT"   => [DBI::SQL_LONGVARCHAR, 2147483657, nil],
+                    "ENUM"       => [DBI::SQL_CHAR, 255, nil],
+                    "SET"        => [DBI::SQL_CHAR, 255, nil],
+                    "BIT"        => [DBI::SQL_BIT, 8, nil],
+                    nil          => [DBI::SQL_OTHER, nil, nil]
+        }
+
+
+        #
+        # This maps type names to DBI Types.
+        #
+        TYPE_MAP = {}
+
+        ::Mysql::Field.constants.grep(/^TYPE_/).each do |const|
+            mysql_type = MysqlField.const_get(const)  # numeric type code
+            coercion_method = DBI::Type::Varchar                 # default coercion method
+            case const.to_s
+            when 'TYPE_TINY'
+                mysql_type_name = 'TINYINT'
+                coercion_method = DBI::Type::Integer
+            when 'TYPE_SHORT'
+                mysql_type_name = 'SMALLINT'
+                coercion_method = DBI::Type::Integer
+            when 'TYPE_INT24'
+                mysql_type_name = 'MEDIUMINT'
+                coercion_method = DBI::Type::Integer
+            when 'TYPE_LONG'
+                mysql_type_name = 'INT'
+                coercion_method = DBI::Type::Integer
+            when 'TYPE_LONGLONG'
+                mysql_type_name = 'BIGINT'
+                coercion_method = DBI::Type::Integer
+            when 'TYPE_FLOAT'
+                mysql_type_name = 'FLOAT'
+                coercion_method = DBI::Type::Float
+            when 'TYPE_DOUBLE'
+                mysql_type_name = 'DOUBLE'
+                coercion_method = DBI::Type::Float
+            when 'TYPE_VAR_STRING', 'TYPE_STRING'
+                mysql_type_name = 'VARCHAR'    # questionable?
+                coercion_method = DBI::Type::Varchar
+            when 'TYPE_DATE'
+                mysql_type_name = 'DATE'
+                coercion_method = DBI::DBD::Mysql::Type::Date
+            when 'TYPE_TIME'
+                mysql_type_name = 'TIME'
+                coercion_method = DBI::Type::Timestamp
+            when 'TYPE_DATETIME', 'TYPE_TIMESTAMP'
+                mysql_type_name = 'DATETIME'
+                coercion_method = DBI::Type::Timestamp
+            when 'TYPE_CHAR'
+                mysql_type_name = 'TINYINT'    # questionable?
+            when 'TYPE_TINY_BLOB'
+                mysql_type_name = 'TINYBLOB'   # questionable?
+            when 'TYPE_MEDIUM_BLOB'
+                mysql_type_name = 'MEDIUMBLOB' # questionable?
+            when 'TYPE_LONG_BLOB'
+                mysql_type_name = 'LONGBLOB'   # questionable?
+            when 'TYPE_GEOMETRY'
+                mysql_type_name = 'BLOB'       # questionable?
+            when 'TYPE_YEAR',
+                 'TYPE_DECIMAL',                                     # questionable?
+                 'TYPE_BLOB',                                        # questionable?
+                 'TYPE_ENUM',
+                 'TYPE_SET',
+                 'TYPE_BIT',
+                 'TYPE_NULL'
+                mysql_type_name = const.to_s.sub(/^TYPE_/, '')
+            else
+                mysql_type_name = 'UNKNOWN'
+            end
+            TYPE_MAP[mysql_type] = [mysql_type_name, coercion_method]
+        end
+        TYPE_MAP[nil] = ['UNKNOWN', DBI::Type::Varchar]
+        TYPE_MAP[246] = ['NUMERIC', DBI::Type::Decimal]
+
+        #
+        # Constructor. Attributes supported:
+        #
+        # * AutoCommit: Commit after each executed statement. This will raise
+        #   a DBI::NotSupportedError if the backend does not support
+        #   transactions.
+        #
+        def initialize(handle, attr)
+            super
+            # check server version to determine transaction capability
+            ver_str = @handle.get_server_info
+            major, minor, teeny = ver_str.split(".")
+            teeny.sub!(/\D*$/, "")  # strip any non-numeric suffix if present
+            server_version = major.to_i*10000 + minor.to_i*100 + teeny.to_i
+            # It's not until 3.23.17 that SET AUTOCOMMIT,
+            # BEGIN, COMMIT, and ROLLBACK all are available
+            @have_transactions = (server_version >= 32317)
+            # assume that the connection begins in AutoCommit mode
+            @attr['AutoCommit'] = true
+            @mutex = Mutex.new
+        end
+
+        def disconnect
+            self.rollback unless @attr['AutoCommit']
+            @handle.close
+        rescue MyError => err
+            error(err)
+        end
+
+        def database_name
+            sth = Statement.new(self, @handle, "select DATABASE()", @mutex)
+            sth.execute
+            res = sth.fetch
+            sth.finish
+            return res[0]
+        end
+
+        def ping
+            begin
+                @handle.ping
+                return true
+            rescue MyError
+                return false
+            end
+        end
+
+        def tables
+            @handle.list_tables
+        rescue MyError => err
+            error(err)
+        end
+
+        #
+        # See DBI::BaseDatabase#columns.
+        #
+        # Extra attributes:
+        #
+        # * sql_type: XOPEN integer constant relating to type.
+        # * nullable: true if the column allows NULL as a value.
+        # * indexed: true if the column belongs to an index.
+        # * primary: true if the column is a part of a primary key.
+        # * unique: true if the values in this column are unique.
+        # * default: the default value if this column is not explicitly set.
+        #
+        def columns(table)
+            dbh = DBI::DatabaseHandle.new(self)
+            uniques = []
+            dbh.execute("SHOW INDEX FROM #{table}") do |sth|
+                sth.each do |row|
+                    uniques << row[4] if row[1] == 0
+                end
+            end
+
+            ret = nil
+            dbh.execute("SHOW FIELDS FROM #{table}") do |sth|
+                ret = sth.collect do |row|
+                    name, type, nullable, key, default, extra = row
+                    #type = row[1]
+                    #size = type[type.index('(')+1..type.index(')')-1]
+                    #size = 0
+                    #type = type[0..type.index('(')-1]
+
+                    sqltype, type, size, decimal = mysql_type_info(row[1])
+                    col = Hash.new
+                    col['name']           = name
+                    col['sql_type']       = sqltype
+                    col['type_name']      = type
+                    col['nullable']       = nullable == "YES"
+                    col['indexed']        = key != ""
+                    col['primary']        = key == "PRI"
+                    col['unique']         = uniques.index(name) != nil
+                    col['precision']      = size
+                    col['scale']          = decimal
+                    col['default']        = row[4]
+
+                    case col['type_name']
+                    when 'timestamp'
+                        col['dbi_type'] = DBI::Type::Timestamp
+                    end
+
+                    col
+                end # collect
+            end # execute
+
+            ret
+        end
+
+        def do(stmt, *bindvars)
+            st = Statement.new(self, @handle, stmt, @mutex)
+            st.bind_params(*bindvars)
+            res = st.execute
+            st.finish
+            return res
+        rescue MyError => err
+            error(err)
+        end
+
+
+        def prepare(statement)
+            Statement.new(self, @handle, statement, @mutex)
+        end
+
+        #
+        # MySQL has several backends, some of which may not support commits.
+        # If the backend this database uses doesn't, calling this method will
+        # raise a DBI::NotSupportedError.
+        #
+        def commit
+            if @have_transactions
+                self.do("COMMIT")
+            else
+                raise NotSupportedError
+            end
+        rescue MyError => err
+            error(err)
+        end
+
+        #
+        # See #commit for information regarding transactionless database
+        # backends.
+        #
+        def rollback
+            if @have_transactions
+                self.do("ROLLBACK")
+            else
+                raise NotSupportedError
+            end
+        rescue MyError => err
+            error(err)
+        end
+
+
+#                 def quote(value)
+#                     case value
+#                     when String
+#                       "'#{@handle.quote(value)}'"
+#                     when DBI::Binary
+#                       "'#{@handle.quote(value.to_s)}'"
+#                     when TrueClass
+#                       "'1'"
+#                     when FalseClass
+#                       "'0'"
+#                     else
+#                         super
+#                     end
+#                 end
+
+        #
+        # See DBI::DBD::MySQL::Database.new for supported attributes and usage.
+        #
+        def []=(attr, value)
+            case attr
+            when 'AutoCommit'
+                if @have_transactions
+                    self.do("SET AUTOCOMMIT=" + (value ? "1" : "0"))
+                else
+                    raise NotSupportedError
+                end
+            else
+                raise NotSupportedError
+            end
+
+            @attr[attr] = value
+        end
+
+        private # -------------------------------------------------
+
+        #
+        # Given a type name, weans some basic information from that and returns
+        # it in a format similar to columns.
+        #
+        # Return is an array of +sqltype+, +type+, +size+, and +decimal+.
+        # +sqltype+ is the XOPEN type, and +type+ is the string with the
+        # parameters removed.
+        #
+        # +size+ and +decimal+ refer to +precision+ and +scale+ in most cases,
+        # but not always for all types. Please consult the documentation for
+        # your MySQL version.
+        #
+        #
+        def mysql_type_info(typedef)
+            sqltype, type, size, decimal = nil, nil, nil, nil
+
+            pos = typedef.index('(')
+            if not pos.nil?
+                type = typedef[0..pos-1]
+                size = typedef[pos+1..-2]
+                pos = size.index(',')
+                if not pos.nil?
+                    size, decimal = size.split(',', 2)
+                    decimal = decimal.to_i
+                end
+                size = size.to_i
+            else
+                type = typedef
+            end
+
+            type_info = MYSQL_to_XOPEN[type.upcase] || MYSQL_to_XOPEN[nil]
+            sqltype = type_info[0]
+            if size.nil? then size = type_info[1] end
+            if decimal.nil? then decimal = type_info[2] end
+            return sqltype, type, size, decimal
+        end
+
+        #--
+        # Driver-specific functions ------------------------------------------------
+        #++
+
+        public
+
+        def __createdb(db)
+            @handle.create_db(db)
+        end
+
+        def __dropdb(db)
+            @handle.drop_db(db)
+        end
+
+        def __shutdown
+            @handle.shutdown
+        end
+
+        def __reload
+            @handle.reload
+        end
+
+        def __insert_id
+            @handle.insert_id
+        end
+
+        def __thread_id
+            @handle.thread_id
+        end
+
+        def __info
+            @handle.info
+        end
+
+        def __host_info
+            @handle.host_info
+        end
+
+        def __proto_info
+            @handle.proto_info
+        end
+
+        def __server_info
+            @handle.server_info
+        end
+
+        def __client_info
+            @handle.client_info
+        end
+
+        def __client_version
+            @handle.client_version
+        end
+
+        def __stat
+            @handle.stat
+        end
+    end # class Database
+end