ydbi 0.5.7 → 0.5.8

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

data/lib/dbd/mysql/statement.rb

@@ -1,188 +0,0 @@
-module DBI::DBD::Mysql
-    #
-    # Models the DBI::BaseStatement API to create DBI::StatementHandle objects.
-    # 
-    class Statement < DBI::BaseStatement
-        include Util
-
-        def initialize(parent, handle, statement, mutex)
-            super(nil)
-
-            @parent, @handle, @mutex = parent, handle, mutex
-            @params = []
-
-            @prep_stmt = DBI::SQL::PreparedStatement.new(@parent, statement)
-        end
-
-        #
-        # See DBI::BaseStatement#bind_param. This method will also raise
-        # DBI::InterfaceError if +param+ is not a Fixnum, to prevent incorrect
-        # binding.
-        #
-        def bind_param(param, value, attribs)
-            raise InterfaceError, "only ? parameters supported" unless param.is_a? Fixnum
-            @params[param-1] = value 
-        end
-
-        #
-        # See DBI::BaseStatement#execute. If DBI thinks this is a query via DBI::SQL.query?(), 
-        # it will force the row processed count to 0. Otherwise, it will return
-        # what MySQL thinks is the row processed count.
-        #
-        def execute
-            sql = @prep_stmt.bind(@params)
-            @mutex.synchronize {
-                @handle.query_with_result = true
-                @res_handle = @handle.query(sql)
-                @column_info = self.column_info
-                @current_row = 0
-                @rows = DBI::SQL.query?(sql) ? 0 : @handle.affected_rows 
-            }
-        rescue MyError => err
-            error(err)
-        end
-
-        def finish
-            @res_handle.free if @res_handle
-        rescue MyError => err
-            error(err)
-        end
-
-        #
-        # Helper method to aid #fetch. Do not call directly.
-        #
-        def fill_array(rowdata)
-            return nil if rowdata.nil?
-            return rowdata.dup
-        end
-
-        def fetch
-            @current_row += 1
-            fill_array(@res_handle.fetch_row)
-        rescue MyError => err
-            error(err)
-        end
-
-        # 
-        # See DBI::BaseStatement#fetch_scroll. These additional constants are also supported:
-        #
-        # * DBI::SQL_FETCH_PRIOR: Fetch the row previous to the current one.
-        # * DBI::SQL_FETCH_FIRST: Fetch the first row.
-        # * DBI::SQL_FETCH_ABSOLUTE: Fetch the row at the offset provided.
-        # * DBI::SQL_FETCH_RELATIVE: Fetch the row at the current point + offset.
-        #
-        def fetch_scroll(direction, offset)
-            case direction
-            when DBI::SQL_FETCH_NEXT
-                @current_row += 1
-                fill_array(@res_handle.fetch_row)
-            when DBI::SQL_FETCH_PRIOR
-                @res_handle.data_seek(@current_row - 1)
-                fill_array(@res_handle.fetch_row)
-            when DBI::SQL_FETCH_FIRST
-                @current_row = 1
-                @res_handle.data_seek(@current_row - 1)
-                fill_array(@res_handle.fetch_row)
-            when DBI::SQL_FETCH_LAST
-                @current_row = @res_handle.num_rows
-                @res_handle.data_seek(@current_row - 1)
-                fill_array(@res_handle.fetch_row)
-            when DBI::SQL_FETCH_ABSOLUTE
-                @current_row = offset + 1
-                @res_handle.data_seek(@current_row - 1)
-                fill_array(@res_handle.fetch_row)
-            when DBI::SQL_FETCH_RELATIVE
-                @current_row += offset + 1
-                @res_handle.data_seek(@current_row - 1)
-                fill_array(@res_handle.fetch_row)
-            else
-                raise NotSupportedError
-            end
-            #end
-        end
-
-        #
-        # See DBI::BaseStatement#column_info, and DBI::DBD::Mysql::Database#columns.
-        #
-        # This method provides all the attributes the +columns+ method
-        # provides, and a few others:
-        #
-        # * mysql_type: These correspond to constants in the Mysql::Types
-        #   package, in the lower-level 'mysql' package.
-        # * mysql_type_name: A text representation of +mysql_type+. 
-        # * mysql_length: The length of the column.
-        # * mysql_max_length: The max length of the column. FIXME DESCRIBE
-        #   DIFFERENCE
-        # * mysql_flags: Internal MySQL flags on this column.
-        #
-        def column_info
-            retval = []
-
-            return [] if @res_handle.nil?
-
-            unique_key_flag = MysqlField.const_get(:UNIQUE_KEY_FLAG)
-            multiple_key_flag = MysqlField.const_get(:MULTIPLE_KEY_FLAG)
-            indexed = (unique_key_flag | multiple_key_flag)
-
-            # Note: Cannot get 'default' column attribute because MysqlField.def
-            # is set only by mysql_list_fields()
-
-            @res_handle.fetch_fields.each {|col| 
-                mysql_type_name, dbi_type = Database::TYPE_MAP[col.type] rescue [nil, nil]
-                xopen_info = Database::MYSQL_to_XOPEN[mysql_type_name] ||
-                    Database::MYSQL_to_XOPEN[nil]
-                sql_type = xopen_info[0]
-                type_name = DBI::SQL_TYPE_NAMES[sql_type]
-
-                retval << {
-                    # Standard Ruby DBI column attributes
-                    'name'        => col.name,
-                    'sql_type'    => sql_type,
-                    'type_name'   => type_name,
-                    # XXX it seems mysql counts the literal decimal point when weighing in the "length".
-                    'precision'   => type_name == "NUMERIC" ? col.length - 2 : col.length,
-                    'scale'       => col.decimals,
-                    'nullable'    => !col.is_not_null?,
-                    'indexed'     => ((col.flags & indexed) != 0) ||
-                                        col.is_pri_key?,
-                    'primary'     => col.is_pri_key?,
-                    'unique'      => ((col.flags & unique_key_flag) != 0) ||
-                                        col.is_pri_key?,
-                    # MySQL-specific attributes (signified by leading "mysql_")
-                    'mysql_type'       => col.type,
-                    'mysql_type_name'  => mysql_type_name,
-                    'mysql_length'     => col.length,
-                    'mysql_max_length' => col.max_length,
-                    'mysql_flags'      => col.flags
-                }
-
-                if retval[-1]['sql_type'] == DBI::SQL_TINYINT and retval[-1]['precision'] == 1
-                    retval[-1]['dbi_type'] = DBI::Type::Boolean
-                elsif dbi_type
-                    retval[-1]['dbi_type'] = dbi_type
-                end
-            }
-            retval
-        rescue MyError => err
-            error(err)
-        end
-
-        def rows
-            @rows
-        end
-
-#                 def []=(attr, value)
-#                     case attr
-#                     when 'mysql_use_result'
-#                         @attr['mysql_store_result'] = ! value
-#                         @attr['mysql_use_result']   = value
-#                     when 'mysql_store_result'
-#                         @attr['mysql_use_result']   = ! value
-#                         @attr['mysql_store_result'] = value
-#                     else
-#                         raise NotSupportedError
-#                     end
-#                 end
-
-    end # class Statement
-end

data/lib/dbd/odbc/database.rb

@@ -1,128 +0,0 @@
-#
-# See DBI::BaseDatabase.
-#
-class DBI::DBD::ODBC::Database < DBI::BaseDatabase
-    def disconnect
-        @handle.rollback
-        @handle.disconnect 
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def database_name
-        @handle.get_info('SQL_DATABASE_NAME')
-    end
-
-    def ping
-        @handle.connected?
-    end
-
-    #
-    # See DBI::BaseDatabase#columns. Additional Attributes:
-    #
-    # * nullable: boolean, true if NULLs are allowed in this column.
-    #
-    def columns(table)
-        cols = []
-
-        stmt = @handle.columns(table)
-        stmt.ignorecase = true
-
-        stmt.each_hash do |row|
-            info = Hash.new
-            cols << info
-
-            info['name']      = row['COLUMN_NAME']
-            info['type_name'] = row['TYPE_NAME']
-            info['sql_type']  = row['DATA_TYPE']
-            info['nullable']  = 
-                case row['NULLABLE']
-                when 1
-                    true
-                when 0
-                    false
-                else
-                    nil
-                end
-            info['precision'] = row['PRECISION']
-            info['scale']     = row['SCALE']
-        end
-
-        stmt.drop
-        cols
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def tables
-        stmt = @handle.tables
-        stmt.ignorecase = true
-        tabs = [] 
-        stmt.each_hash {|row|
-            tabs << row["TABLE_NAME"]
-        }
-        stmt.drop
-        tabs
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def prepare(statement)
-        DBI::DBD::ODBC::Statement.new(@handle.prepare(statement), statement)
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def do(statement, *bindvars)
-        @handle.do(statement, *bindvars) 
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def execute(statement, *bindvars)
-        stmt = @handle.run(statement, *bindvars) 
-        DBI::DBD::ODBC::Statement.new(stmt, statement)
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    #
-    # Additional Attributes on the DatabaseHandle:
-    #
-    # * AutoCommit: force a commit after each statement execution.
-    # * odbc_ignorecase: Be case-insensitive in operations. 
-    # * odbc_timeout: Return after a certain time regardless of whether the operation returned anything.
-    #
-    def []=(attr, value)
-        case attr
-        when 'AutoCommit'
-            @handle.autocommit(value)
-        when 'odbc_ignorecase'
-            @handle.ignorecase(value)
-        when 'odbc_timeout'
-            @handle.timeout(value)
-        else
-            if attr =~ /^odbc_/ or attr != /_/
-                raise DBI::NotSupportedError, "Option '#{attr}' not supported"
-            else # option for some other driver - quitly ignore
-                return
-            end
-        end
-        @attr[attr] = value
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def commit
-        @handle.commit
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def rollback
-        @handle.rollback
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-end # class Database

data/lib/dbd/odbc/driver.rb

@@ -1,38 +0,0 @@
-#
-# See DBI::BaseDriver
-#
-class DBI::DBD::ODBC::Driver < DBI::BaseDriver
-    def initialize
-        super("0.4.0")
-    end
-
-    def data_sources
-        ::ODBC.datasources.collect {|dsn| "dbi:ODBC:" + dsn.name }
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def connect(dbname, user, auth, attr)
-        driver_attrs = dbname.split(';')
-
-        if driver_attrs.size > 1
-            # DNS-less connection
-            drv = ::ODBC::Driver.new
-            drv.name = 'Driver1'
-            driver_attrs.each do |param|
-                pv = param.split('=')
-                next if pv.size < 2
-                drv.attrs[pv[0]] = pv[1]
-            end
-            db = ::ODBC::Database.new
-            handle = db.drvconnect(drv)
-        else
-            # DNS given
-            handle = ::ODBC.connect(dbname, user, auth)
-        end
-
-        return DBI::DBD::ODBC::Database.new(handle, attr)
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-end