Current File : /home/rs/ruby/1.8/lib/ruby/site_ruby/1.8/dbd/mysql/database.rb
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
Mini Shell