ydbi 0.5.0

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

data/lib/dbd/mysql/driver.rb

@@ -0,0 +1,125 @@
+module DBI::DBD::Mysql
+    #
+    # Models the DBI::BaseDriver API to create DBI::DriverHandle objects.
+    #
+    class Driver < DBI::BaseDriver
+        include Util
+
+        def initialize
+            super("0.4.0")
+        end
+
+        def default_user
+            ['', nil]
+        end
+
+        #
+        # Parameters in the dbname as follows:
+        #
+        # * host: host to connect to
+        # * port: port to connect to
+        # * socket: connect to a specific unix socket instead of a TCP socket.
+        # * flag: an OR'd collection of flags to pass to the lower-level
+        #   connection attempt.
+        # * mysql_read_default_file: FIXME
+        # * mysql_read_default_group: FIXME
+        # * mysql_compression: FIXME
+        # * mysql_local_infile: FIXME
+        # * mysql_client_found_rows: FIXME boolean, modifies the 'flag'
+        #   setting above.
+        def connect(dbname, user, auth, attr)
+            # connect to database server
+            hash = DBI::Utils.parse_params(dbname)
+
+            hash['host'] ||= 'localhost'
+
+            # these two connection parameters should be passed as numbers
+            hash['port'] = hash['port'].to_i unless hash['port'].nil?
+            hash['flag'] = hash['flag'].nil? ? 0 : hash['flag'] = hash['flag'].to_i
+
+            handle = ::Mysql.init
+
+            # Look for options in connect string to be handled
+            # through mysql_options() before connecting
+            !hash['mysql_read_default_file'].nil? and
+            handle.options(::Mysql::READ_DEFAULT_FILE,
+                           hash['mysql_read_default_file'])
+            !hash['mysql_read_default_group'].nil? and
+            handle.options(::Mysql::READ_DEFAULT_GROUP,
+                           hash['mysql_read_default_group'])
+            # The following options can be handled either using mysql_options()
+            # or in the flag argument to connect().
+            hash['mysql_compression'].to_i != 0 and
+            handle.options(::Mysql::OPT_COMPRESS, nil)
+            hash['mysql_local_infile'].to_i != 0 and
+            handle.options(::Mysql::OPT_LOCAL_INFILE, true)
+
+            # Look for options to be handled in the flags argument to connect()
+            if !hash['mysql_client_found_rows'].nil?
+                if hash['mysql_client_found_rows'].to_i != 0
+                    hash['flag'] |= ::Mysql::CLIENT_FOUND_ROWS
+                else
+                    hash['flag'] &= ~::Mysql::CLIENT_FOUND_ROWS
+                end
+            end
+
+            handle.connect(hash['host'], user, auth, hash['database'], hash['port'], hash['socket'], hash['flag'])
+
+            return Database.new(handle, attr)
+        rescue MyError => err
+            error(err)
+        end
+
+        def data_sources
+            handle = ::Mysql.new
+            res = handle.list_dbs.collect {|db| "dbi:Mysql:database=#{db}" }
+            handle.close
+            return res
+        rescue MyError => err
+            error(err)
+        end
+
+        #--
+        # Driver-specific functions ------------------------------------------------
+        #++
+
+        public
+
+        def __createdb(db, host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.create_db(db)
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __dropdb(db, host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.drop_db(db)
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __shutdown(host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.shutdown
+            ensure
+                handle.close if handle
+            end
+        end
+
+        def __reload(host, user, password, port=nil, sock=nil, flag=nil)
+            handle = ::Mysql.connect(host, user, password, nil, port, sock, flag)
+            begin
+                handle.reload
+            ensure
+                handle.close if handle
+            end
+        end
+
+    end # class Driver
+end