ydbi 0.5.0 → 0.5.1

data/lib/dbd/mysql/database.rb

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

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