ydbi 0.5.7 → 0.5.9

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

data/lib/dbd/odbc/statement.rb

@@ -1,137 +0,0 @@
-#
-# See DBI::BaseStatement.
-#
-class DBI::DBD::ODBC::Statement < DBI::BaseStatement
-    def initialize(handle, statement)
-        @statement = statement
-        @handle = handle
-        @params = []
-        @arr = []
-    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 DBI::InterfaceError, "only ? parameters supported" unless param.is_a? Fixnum
-        @params[param-1] = value
-    end
-
-    def execute
-        @handle.execute(*@params)
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def finish
-        @handle.drop
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def cancel
-        @handle.cancel
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    def fetch
-        convert_row(@handle.fetch)
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    #
-    # See DBI::BaseStatement#fetch_scroll.
-    #
-    # ODBC has a native version of this method and the constnats in the ODBC
-    # driver themselves are supported. If you'd prefer to use DBI constants
-    # (recommended), you can use these which map to the ODBC functionality:
-    #
-    # * DBI::SQL_FETCH_FIRST
-    # * DBI::SQL_FETCH_LAST
-    # * DBI::SQL_FETCH_NEXT
-    # * DBI::SQL_FETCH_PRIOR
-    # * DBI::SQL_FETCH_ABSOLUTE
-    # * DBI::SQL_FETCH_RELATIVE
-    #
-    def fetch_scroll(direction, offset)
-        direction = case direction
-                    when DBI::SQL_FETCH_FIRST    then ::ODBC::SQL_FETCH_FIRST
-                    when DBI::SQL_FETCH_LAST     then ::ODBC::SQL_FETCH_LAST
-                    when DBI::SQL_FETCH_NEXT     then ::ODBC::SQL_FETCH_NEXT
-                    when DBI::SQL_FETCH_PRIOR    then ::ODBC::SQL_FETCH_PRIOR
-                    when DBI::SQL_FETCH_ABSOLUTE then ::ODBC::SQL_FETCH_ABSOLUTE
-                    when DBI::SQL_FETCH_RELATIVE then ::ODBC::SQL_FETCH_RELATIVE
-                    else
-                        direction
-                    end
-
-        convert_row(@handle.fetch_scroll(direction, offset))
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    #
-    # See DBI::BaseStatement#column_info. These additional attributes are also
-    # supported:
-    #
-    # * table: the table this column came from, if available.
-    # * nullable: boolean, true if NULL is accepted as a value in this column.
-    # * searchable: FIXME DOCUMENT
-    # * length: FIXME DOCUMENT
-    # * unsigned: For numeric columns, whether or not the result value is signed.
-    #
-    def column_info
-        info = []
-        @handle.columns(true).each do |col|
-            info << {
-                'name'       => col.name, 
-                'table'      => col.table,
-                'nullable'   => col.nullable,
-                'searchable' => col.searchable,
-                'precision'  => col.precision,
-                'scale'      => col.scale,
-                'sql_type'   => col.type,
-                'type_name'  => DBI::SQL_TYPE_NAMES[col.type],
-                'length'     => col.length,
-                'unsigned'   => col.unsigned
-            }
-        end
-        info
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    #
-    # See DBI::BaseStatement#rows.
-    #
-    # For queries which DBI::SQL.query? returns true, will explicitly return 0.
-    # Otherwise, it will return the row processed count.
-    #
-    def rows
-        return 0 if DBI::SQL.query?(@statement)
-        return @handle.nrows
-    rescue DBI::DBD::ODBC::ODBCErr => err
-        raise DBI::DatabaseError.new(err.message)
-    end
-
-    private # -----------------------------------
-
-    # convert the ODBC datatypes to DBI datatypes
-    def convert_row(row)
-        return nil if row.nil?
-        row.collect do |col|
-            case col
-            when nil
-                nil
-            when ODBC::TimeStamp
-                DBI::Type::Timestamp.create col.year, col.month, col.day, col.hour, col.minute, col.second
-            else
-                col.to_s
-            end
-        end
-    end 
-end