DatabaseIbm_db2.php

Go to the documentation of this file.

<?php
class IBM_DB2Field implements Field {
        private $name = '';
        private $tablename = '';
        private $type = '';
        private $nullable = false;
        private $max_length = 0;

        static function fromText( $db, $table, $field ) {
                global $wgDBmwschema;

                $q = <<<SQL
SELECT
lcase( coltype ) AS typname,
nulls AS attnotnull, length AS attlen
FROM sysibm.syscolumns
WHERE tbcreator=%s AND tbname=%s AND name=%s;
SQL;
                $res = $db->query(
                        sprintf( $q,
                                $db->addQuotes( $wgDBmwschema ),
                                $db->addQuotes( $table ),
                                $db->addQuotes( $field )
                        )
                );
                $row = $db->fetchObject( $res );
                if ( !$row ) {
                        return null;
                }
                $n = new IBM_DB2Field;
                $n->type = $row->typname;
                $n->nullable = ( $row->attnotnull == 'N' );
                $n->name = $field;
                $n->tablename = $table;
                $n->max_length = $row->attlen;
                return $n;
        }
        function name() { return $this->name; }
        function tableName() { return $this->tablename; }
        function type() { return $this->type; }
        function isNullable() { return $this->nullable; }
        function maxLength() { return $this->max_length; }
}

class IBM_DB2Blob {
        private $mData;

        public function __construct( $data ) {
                $this->mData = $data;
        }

        public function getData() {
                return $this->mData;
        }

        public function __toString() {
                return $this->mData;
        }
}

class IBM_DB2Result{
        private $db;
        private $result;
        private $num_rows;
        private $current_pos;
        private $columns = array();
        private $sql;

        private $resultSet = array();
        private $loadedLines = 0;

        public function __construct( $db, $result, $num_rows, $sql, $columns ){
                $this->db = $db;

                if( $result instanceof ResultWrapper ){
                        $this->result = $result->result;
                }
                else{
                        $this->result = $result;
                }

                $this->num_rows = $num_rows;
                $this->current_pos = 0;
                if ( $this->num_rows > 0 ) {
                        // Make a lower-case list of the column names
                        // By default, DB2 column names are capitalized
                        //  while MySQL column names are lowercase

                        // Is there a reasonable maximum value for $i?
                        // Setting to 2048 to prevent an infinite loop
                        for( $i = 0; $i < 2048; $i++ ) {
                                $name = db2_field_name( $this->result, $i );
                                if ( $name != false ) {
                                        continue;
                                }
                                else {
                                        return false;
                                }

                                $this->columns[$i] = strtolower( $name );
                        }
                }

                $this->sql = $sql;
        }

        public function getResult() {
                if ( $this->result ) {
                        return $this->result;
                }
                else return false;
        }

        public function getNum_rows() {
                return $this->num_rows;
        }

        public function fetchObject() {
                if ( $this->result
                                && $this->num_rows > 0
                                && $this->current_pos >= 0
                                && $this->current_pos < $this->num_rows )
                {
                        $row = $this->fetchRow();
                        $ret = new stdClass();

                        foreach ( $row as $k => $v ) {
                                $lc = $this->columns[$k];
                                $ret->$lc = $v;
                        }
                        return $ret;
                }
                return false;
        }

        public function fetchRow(){
                if ( $this->result
                                && $this->num_rows > 0
                                && $this->current_pos >= 0
                                && $this->current_pos < $this->num_rows )
                {
                        if ( $this->loadedLines <= $this->current_pos ) {
                                $row = db2_fetch_array( $this->result );
                                $this->resultSet[$this->loadedLines++] = $row;
                                if ( $this->db->lastErrno() ) {
                                        throw new DBUnexpectedError( $this->db, 'Error in fetchRow(): '
                                                . htmlspecialchars( $this->db->lastError() ) );
                                }
                        }

                        if ( $this->loadedLines > $this->current_pos ){
                                return $this->resultSet[$this->current_pos++];
                        }

                }
                return false;
        }

        public function freeResult(){
                unset( $this->resultSet );
                if ( !@db2_free_result( $this->result ) ) {
                        throw new DBUnexpectedError( $this, "Unable to free DB2 result\n" );
                }
        }
}

class DatabaseIbm_db2 extends DatabaseBase {
        /*
         * Inherited members
        protected $mLastQuery = '';
        protected $mPHPError = false;

        protected $mServer, $mUser, $mPassword, $mConn = null, $mDBname;
        protected $mOpened = false;

        protected $mTablePrefix;
        protected $mFlags;
        protected $mTrxLevel = 0;
        protected $mErrorCount = 0;
        protected $mLBInfo = array();
        protected $mFakeSlaveLag = null, $mFakeMaster = false;
         *
         */

        protected $mPort = null;
        protected $mSchema = null;
        protected $mSchemaSet = false;
        protected $mLastResult = null;
        protected $mAffectedRows = null;
        protected $mNumRows = null;
        protected $currentRow = 0;

        public $mConnOptions = array();
        public $mStmtOptions = array();

        const USE_GLOBAL = 'get from global';

        const NONE_OPTION = 0x00;
        const CONN_OPTION = 0x01;
        const STMT_OPTION = 0x02;

        const REGULAR_MODE = 'regular';
        const INSTALL_MODE = 'install';

        protected $mMode = self::REGULAR_MODE;

        protected $mInsertId = null;

        ######################################
        # Getters and Setters
        ######################################

        function cascadingDeletes() {
                return true;
        }

        function cleanupTriggers() {
                return true;
        }

        function strictIPs() {
                return true;
        }

        function realTimestamps() {
                return true;
        }

        function implicitGroupby() {
                return false;
        }

        function implicitOrderby() {
                return false;
        }

        function searchableIPs() {
                return true;
        }

        function functionalIndexes() {
                return true;
        }

        public function getWikiID() {
                if( $this->mSchema ) {
                        return "{$this->mDBname}-{$this->mSchema}";
                } else {
                        return $this->mDBname;
                }
        }

        public function getType() {
                return 'ibm_db2';
        }

        public function getDb(){
                return $this->mConn;
        }

        public function __construct( $server = false, $user = false,
                                                        $password = false,
                                                        $dbName = false, $flags = 0,
                                                        $schema = self::USE_GLOBAL )
        {
                global $wgDBmwschema;

                if ( $schema == self::USE_GLOBAL ) {
                        $this->mSchema = $wgDBmwschema;
                } else {
                        $this->mSchema = $schema;
                }

                // configure the connection and statement objects
                $this->setDB2Option( 'db2_attr_case', 'DB2_CASE_LOWER',
                        self::CONN_OPTION | self::STMT_OPTION );
                $this->setDB2Option( 'deferred_prepare', 'DB2_DEFERRED_PREPARE_ON',
                        self::STMT_OPTION );
                $this->setDB2Option( 'rowcount', 'DB2_ROWCOUNT_PREFETCH_ON',
                        self::STMT_OPTION );
                parent::__construct( $server, $user, $password, $dbName, DBO_TRX | $flags );
        }

        private function setDB2Option( $name, $const, $type ) {
                if ( defined( $const ) ) {
                        if ( $type & self::CONN_OPTION ) {
                                $this->mConnOptions[$name] = constant( $const );
                        }
                        if ( $type & self::STMT_OPTION ) {
                                $this->mStmtOptions[$name] = constant( $const );
                        }
                } else {
                        $this->installPrint(
                                "$const is not defined. ibm_db2 version is likely too low." );
                }
        }

        private function installPrint( $string ) {
                wfDebug( "$string\n" );
                if ( $this->mMode == self::INSTALL_MODE ) {
                        print "<li><pre>$string</pre></li>";
                        flush();
                }
        }

        public function open( $server, $user, $password, $dbName ) {
                wfProfileIn( __METHOD__ );

                # Load IBM DB2 driver if missing
                wfDl( 'ibm_db2' );

                # Test for IBM DB2 support, to avoid suppressed fatal error
                if ( !function_exists( 'db2_connect' ) ) {
                        throw new DBConnectionError( $this, "DB2 functions missing, have you enabled the ibm_db2 extension for PHP?" );
                }

                global $wgDBport;

                // Close existing connection
                $this->close();
                // Cache conn info
                $this->mServer = $server;
                $this->mPort = $port = $wgDBport;
                $this->mUser = $user;
                $this->mPassword = $password;
                $this->mDBname = $dbName;

                $this->openUncataloged( $dbName, $user, $password, $server, $port );

                if ( !$this->mConn ) {
                        $this->installPrint( "DB connection error\n" );
                        $this->installPrint(
                                "Server: $server, Database: $dbName, User: $user, Password: "
                                . substr( $password, 0, 3 ) . "...\n" );
                        $this->installPrint( $this->lastError() . "\n" );
                        wfProfileOut( __METHOD__ );
                        wfDebug( "DB connection error\n" );
                        wfDebug( "Server: $server, Database: $dbName, User: $user, Password: " . substr( $password, 0, 3 ) . "...\n" );
                        wfDebug( $this->lastError() . "\n" );
                        throw new DBConnectionError( $this, $this->lastError() );
                }

                // Some MediaWiki code is still transaction-less (?).
                // The strategy is to keep AutoCommit on for that code
                //  but switch it off whenever a transaction is begun.
                db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_ON );

                $this->mOpened = true;
                $this->applySchema();

                wfProfileOut( __METHOD__ );
                return $this->mConn;
        }

        protected function openCataloged( $dbName, $user, $password ) {
                wfSuppressWarnings();
                $this->mConn = db2_pconnect( $dbName, $user, $password );
                wfRestoreWarnings();
        }

        protected function openUncataloged( $dbName, $user, $password, $server, $port )
        {
                $dsn = "DRIVER={IBM DB2 ODBC DRIVER};DATABASE=$dbName;CHARSET=UTF-8;HOSTNAME=$server;PORT=$port;PROTOCOL=TCPIP;UID=$user;PWD=$password;";
                wfSuppressWarnings();
                $this->mConn = db2_pconnect( $dsn, "", "", array() );
                wfRestoreWarnings();
        }

        protected function closeConnection() {
                return db2_close( $this->mConn );
        }

        public function lastError() {
                $connerr = db2_conn_errormsg();
                if ( $connerr ) {
                        //$this->rollback( __METHOD__ );
                        return $connerr;
                }
                $stmterr = db2_stmt_errormsg();
                if ( $stmterr ) {
                        //$this->rollback( __METHOD__ );
                        return $stmterr;
                }

                return false;
        }

        public function lastErrno() {
                $connerr = db2_conn_error();
                if ( $connerr ) {
                        return $connerr;
                }
                $stmterr = db2_stmt_error();
                if ( $stmterr ) {
                        return $stmterr;
                }
                return 0;
        }

        public function isOpen() { return $this->mOpened; }

        protected function doQuery( $sql ) {
                $this->applySchema();

                // Needed to handle any UTF-8 encoding issues in the raw sql
                // Note that we fully support prepared statements for DB2
                // prepare() and execute() should be used instead of doQuery() whenever possible
                $sql = utf8_decode( $sql );

                $ret = db2_exec( $this->mConn, $sql, $this->mStmtOptions );
                if( $ret == false ) {
                        $error = db2_stmt_errormsg();

                        $this->installPrint( "<pre>$sql</pre>" );
                        $this->installPrint( $error );
                        throw new DBUnexpectedError( $this, 'SQL error: '
                                . htmlspecialchars( $error ) );
                }
                $this->mLastResult = $ret;
                $this->mAffectedRows = null; // Not calculated until asked for
                return $ret;
        }

        public function getServerVersion() {
                $info = db2_server_info( $this->mConn );
                return $info->DBMS_VER;
        }

        public function tableExists( $table, $fname = __METHOD__ ) {
                $schema = $this->mSchema;

                $sql = "SELECT COUNT( * ) FROM SYSIBM.SYSTABLES ST WHERE ST.NAME = '" .
                        strtoupper( $table ) .
                        "' AND ST.CREATOR = '" .
                        strtoupper( $schema ) . "'";
                $res = $this->query( $sql );
                if ( !$res ) {
                        return false;
                }

                // If the table exists, there should be one of it
                $row = $this->fetchRow( $res );
                $count = $row[0];
                if ( $count == '1' || $count == 1 ) {
                        return true;
                }

                return false;
        }

        public function fetchObject( $res ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                wfSuppressWarnings();
                $row = db2_fetch_object( $res );
                wfRestoreWarnings();
                if( $this->lastErrno() ) {
                        throw new DBUnexpectedError( $this, 'Error in fetchObject(): '
                                . htmlspecialchars( $this->lastError() ) );
                }
                return $row;
        }

        public function fetchRow( $res ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                if ( db2_num_rows( $res ) > 0) {
                        wfSuppressWarnings();
                        $row = db2_fetch_array( $res );
                        wfRestoreWarnings();
                        if ( $this->lastErrno() ) {
                                throw new DBUnexpectedError( $this, 'Error in fetchRow(): '
                                        . htmlspecialchars( $this->lastError() ) );
                        }
                        return $row;
                }
                return false;
        }

        public function addQuotes( $s ) {
                //$this->installPrint( "DB2::addQuotes( $s )\n" );
                if ( is_null( $s ) ) {
                        return 'NULL';
                } elseif ( $s instanceof Blob ) {
                        return "'" . $s->fetch( $s ) . "'";
                } elseif ( $s instanceof IBM_DB2Blob ) {
                        return "'" . $this->decodeBlob( $s ) . "'";
                }
                $s = $this->strencode( $s );
                if ( is_numeric( $s ) ) {
                        return $s;
                } else {
                        return "'$s'";
                }
        }

        public function is_numeric_type( $type ) {
                switch ( strtoupper( $type ) ) {
                        case 'SMALLINT':
                        case 'INTEGER':
                        case 'INT':
                        case 'BIGINT':
                        case 'DECIMAL':
                        case 'REAL':
                        case 'DOUBLE':
                        case 'DECFLOAT':
                                return true;
                }
                return false;
        }

        public function strencode( $s ) {
                // Bloody useless function
                //  Prepends backslashes to \x00, \n, \r, \, ', " and \x1a.
                //  But also necessary
                $s = db2_escape_string( $s );
                // Wide characters are evil -- some of them look like '
                $s = utf8_encode( $s );
                // Fix its stupidity
                $from = array(  "\\\\", "\\'",  '\\n',  '\\t',  '\\"',  '\\r' );
                $to = array(            "\\",           "''",           "\n",           "\t",           '"',            "\r" );
                $s = str_replace( $from, $to, $s ); // DB2 expects '', not \' escaping
                return $s;
        }

        protected function applySchema() {
                if ( !( $this->mSchemaSet ) ) {
                        $this->mSchemaSet = true;
                        $this->begin( __METHOD__ );
                        $this->doQuery( "SET SCHEMA = $this->mSchema" );
                        $this->commit( __METHOD__ );
                }
        }

        protected function doBegin( $fname = 'DatabaseIbm_db2::begin' ) {
                // BEGIN is implicit for DB2
                // However, it requires that AutoCommit be off.

                // Some MediaWiki code is still transaction-less (?).
                // The strategy is to keep AutoCommit on for that code
                //  but switch it off whenever a transaction is begun.
                db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_OFF );

                $this->mTrxLevel = 1;
        }

        protected function doCommit( $fname = 'DatabaseIbm_db2::commit' ) {
                db2_commit( $this->mConn );

                // Some MediaWiki code is still transaction-less (?).
                // The strategy is to keep AutoCommit on for that code
                //  but switch it off whenever a transaction is begun.
                db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_ON );

                $this->mTrxLevel = 0;
        }

        protected function doRollback( $fname = 'DatabaseIbm_db2::rollback' ) {
                db2_rollback( $this->mConn );
                // turn auto-commit back on
                // not sure if this is appropriate
                db2_autocommit( $this->mConn, DB2_AUTOCOMMIT_ON );
                $this->mTrxLevel = 0;
        }

        function makeList( $a, $mode = LIST_COMMA ) {
                if ( !is_array( $a ) ) {
                        throw new DBUnexpectedError( $this,
                                'DatabaseIbm_db2::makeList called with incorrect parameters' );
                }

                // if this is for a prepared UPDATE statement
                // (this should be promoted to the parent class
                //  once other databases use prepared statements)
                if ( $mode == LIST_SET_PREPARED ) {
                        $first = true;
                        $list = '';
                        foreach ( $a as $field => $value ) {
                                if ( !$first ) {
                                        $list .= ", $field = ?";
                                } else {
                                        $list .= "$field = ?";
                                        $first = false;
                                }
                        }
                        $list .= '';

                        return $list;
                }

                // otherwise, call the usual function
                return parent::makeList( $a, $mode );
        }

        public function limitResult( $sql, $limit, $offset=false ) {
                if( !is_numeric( $limit ) ) {
                        throw new DBUnexpectedError( $this,
                                "Invalid non-numeric limit passed to limitResult()\n" );
                }
                if( $offset ) {
                        if ( stripos( $sql, 'where' ) === false ) {
                                return "$sql AND ( ROWNUM BETWEEN $offset AND $offset+$limit )";
                        } else {
                                return "$sql WHERE ( ROWNUM BETWEEN $offset AND $offset+$limit )";
                        }
                }
                return "$sql FETCH FIRST $limit ROWS ONLY ";
        }

        public function tableName( $name, $format = 'quoted' ) {
                // we want maximum compatibility with MySQL schema
                return $name;
        }

        public function timestamp( $ts = 0 ) {
                // TS_MW cannot be easily distinguished from an integer
                return wfTimestamp( TS_DB2, $ts );
        }

        public function nextSequenceValue( $seqName ) {
                // Not using sequences in the primary schema to allow for easier migration
                //  from MySQL
                // Emulating MySQL behaviour of using NULL to signal that sequences
                // aren't used
                /*
                $safeseq = preg_replace( "/'/", "''", $seqName );
                $res = $this->query( "VALUES NEXTVAL FOR $safeseq" );
                $row = $this->fetchRow( $res );
                $this->mInsertId = $row[0];
                return $this->mInsertId;
                */
                return null;
        }

        public function insertId() {
                return $this->mInsertId;
        }

        private function calcInsertId( $table, $primaryKey, $stmt ) {
                if ( $primaryKey ) {
                        $this->mInsertId = db2_last_insert_id( $this->mConn );
                }
        }

        public function insert( $table, $args, $fname = 'DatabaseIbm_db2::insert',
                $options = array() )
        {
                if ( !count( $args ) ) {
                        return true;
                }
                // get database-specific table name (not used)
                $table = $this->tableName( $table );
                // format options as an array
                $options = IBM_DB2Helper::makeArray( $options );
                // format args as an array of arrays
                if ( !( isset( $args[0] ) && is_array( $args[0] ) ) ) {
                        $args = array( $args );
                }

                // prevent insertion of NULL into primary key columns
                list( $args, $primaryKeys ) = $this->removeNullPrimaryKeys( $table, $args );
                // if there's only one primary key
                // we'll be able to read its value after insertion
                $primaryKey = false;
                if ( count( $primaryKeys ) == 1 ) {
                        $primaryKey = $primaryKeys[0];
                }

                // get column names
                $keys = array_keys( $args[0] );
                $key_count = count( $keys );

                // If IGNORE is set, we use savepoints to emulate mysql's behavior
                $ignore = in_array( 'IGNORE', $options ) ? 'mw' : '';

                // assume success
                $res = true;
                // If we are not in a transaction, we need to be for savepoint trickery
                if ( !$this->mTrxLevel ) {
                        $this->begin( __METHOD__ );
                }

                $sql = "INSERT INTO $table ( " . implode( ',', $keys ) . ' ) VALUES ';
                if ( $key_count == 1 ) {
                        $sql .= '( ? )';
                } else {
                        $sql .= '( ?' . str_repeat( ',?', $key_count-1 ) . ' )';
                }
                $this->installPrint( "Preparing the following SQL:" );
                $this->installPrint( "$sql" );
                $this->installPrint( print_r( $args, true ));
                $stmt = $this->prepare( $sql );

                // start a transaction/enter transaction mode
                $this->begin( __METHOD__ );

                if ( !$ignore ) {
                        //$first = true;
                        foreach ( $args as $row ) {
                                //$this->installPrint( "Inserting " . print_r( $row, true ));
                                // insert each row into the database
                                $res = $res & $this->execute( $stmt, $row );
                                if ( !$res ) {
                                        $this->installPrint( 'Last error:' );
                                        $this->installPrint( $this->lastError() );
                                }
                                // get the last inserted value into a generated column
                                $this->calcInsertId( $table, $primaryKey, $stmt );
                        }
                } else {
                        $olde = error_reporting( 0 );
                        // For future use, we may want to track the number of actual inserts
                        // Right now, insert (all writes) simply return true/false
                        $numrowsinserted = 0;

                        // always return true
                        $res = true;

                        foreach ( $args as $row ) {
                                $overhead = "SAVEPOINT $ignore ON ROLLBACK RETAIN CURSORS";
                                db2_exec( $this->mConn, $overhead, $this->mStmtOptions );

                                $res2 = $this->execute( $stmt, $row );

                                if ( !$res2 ) {
                                        $this->installPrint( 'Last error:' );
                                        $this->installPrint( $this->lastError() );
                                }
                                // get the last inserted value into a generated column
                                $this->calcInsertId( $table, $primaryKey, $stmt );

                                $errNum = $this->lastErrno();
                                if ( $errNum ) {
                                        db2_exec( $this->mConn, "ROLLBACK TO SAVEPOINT $ignore",
                                                $this->mStmtOptions );
                                } else {
                                        db2_exec( $this->mConn, "RELEASE SAVEPOINT $ignore",
                                                $this->mStmtOptions );
                                        $numrowsinserted++;
                                }
                        }

                        $olde = error_reporting( $olde );
                        // Set the affected row count for the whole operation
                        $this->mAffectedRows = $numrowsinserted;
                }
                // commit either way
                $this->commit( __METHOD__ );
                $this->freePrepared( $stmt );

                return $res;
        }

        private function removeNullPrimaryKeys( $table, $args ) {
                $schema = $this->mSchema;

                // find out the primary keys
                $keyres = $this->doQuery( "SELECT NAME FROM SYSIBM.SYSCOLUMNS WHERE TBNAME = '"
                  . strtoupper( $table )
                  . "' AND TBCREATOR = '"
                  . strtoupper( $schema )
                  . "' AND KEYSEQ > 0" );

                $keys = array();
                for (
                        $row = $this->fetchRow( $keyres );
                        $row != null;
                        $row = $this->fetchRow( $keyres )
                )
                {
                        $keys[] = strtolower( $row[0] );
                }
                // remove primary keys
                foreach ( $args as $ai => $row ) {
                        foreach ( $keys as $key ) {
                                if ( $row[$key] == null ) {
                                        unset( $row[$key] );
                                }
                        }
                        $args[$ai] = $row;
                }
                // return modified hash
                return array( $args, $keys );
        }

        public function update( $table, $values, $conds, $fname = 'DatabaseIbm_db2::update',
                $options = array() )
        {
                $table = $this->tableName( $table );
                $opts = $this->makeUpdateOptions( $options );
                $sql = "UPDATE $opts $table SET "
                        . $this->makeList( $values, LIST_SET_PREPARED );
                if ( $conds != '*' ) {
                        $sql .= " WHERE " . $this->makeList( $conds, LIST_AND );
                }
                $stmt = $this->prepare( $sql );
                $this->installPrint( 'UPDATE: ' . print_r( $values, true ) );
                // assuming for now that an array with string keys will work
                // if not, convert to simple array first
                $result = $this->execute( $stmt, $values );
                $this->freePrepared( $stmt );

                return $result;
        }

        public function delete( $table, $conds, $fname = 'DatabaseIbm_db2::delete' ) {
                if ( !$conds ) {
                        throw new DBUnexpectedError( $this,
                                'DatabaseIbm_db2::delete() called with no conditions' );
                }
                $table = $this->tableName( $table );
                $sql = "DELETE FROM $table";
                if ( $conds != '*' ) {
                        $sql .= ' WHERE ' . $this->makeList( $conds, LIST_AND );
                }
                $result = $this->query( $sql, $fname );

                return $result;
        }

        public function affectedRows() {
                if ( !is_null( $this->mAffectedRows ) ) {
                        // Forced result for simulated queries
                        return $this->mAffectedRows;
                }
                if( empty( $this->mLastResult ) ) {
                        return 0;
                }
                return db2_num_rows( $this->mLastResult );
        }

        public function numRows( $res ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }

                if ( $this->mNumRows ) {
                        return $this->mNumRows;
                } else {
                        return 0;
                }
        }

        public function dataSeek( $res, $row ) {
                if ( $res instanceof ResultWrapper ) {
                        return $res = $res->result;
                }
                if ( $res instanceof IBM_DB2Result ) {
                        return $res->dataSeek( $row );
                }
                wfDebug( "dataSeek operation in DB2 database\n" );
                return false;
        }

        ###
        # Fix notices in Block.php
        ###

        public function freeResult( $res ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                wfSuppressWarnings();
                $ok = db2_free_result( $res );
                wfRestoreWarnings();
                if ( !$ok ) {
                        throw new DBUnexpectedError( $this, "Unable to free DB2 result\n" );
                }
        }

        public function numFields( $res ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                if ( $res instanceof IBM_DB2Result ) {
                        $res = $res->getResult();
                }
                return db2_num_fields( $res );
        }

        public function fieldName( $res, $n ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                if ( $res instanceof IBM_DB2Result ) {
                        $res = $res->getResult();
                }
                return db2_field_name( $res, $n );
        }

        public function select( $table, $vars, $conds = '', $fname = 'DatabaseIbm_db2::select', $options = array(), $join_conds = array() )
        {
                $res = parent::select( $table, $vars, $conds, $fname, $options,
                        $join_conds );
                $sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );

                // We must adjust for offset
                if ( isset( $options['LIMIT'] ) && isset ( $options['OFFSET'] ) ) {
                        $limit = $options['LIMIT'];
                        $offset = $options['OFFSET'];
                }

                // DB2 does not have a proper num_rows() function yet, so we must emulate
                // DB2 9.5.4 and the corresponding ibm_db2 driver will introduce
                //  a working one
                // TODO: Yay!

                // we want the count
                $vars2 = array( 'count( * ) as num_rows' );
                // respecting just the limit option
                $options2 = array();
                if ( isset( $options['LIMIT'] ) ) {
                        $options2['LIMIT'] = $options['LIMIT'];
                }
                // but don't try to emulate for GROUP BY
                if ( isset( $options['GROUP BY'] ) ) {
                        return $res;
                }

                $res2 = parent::select( $table, $vars2, $conds, $fname, $options2,
                        $join_conds );

                $obj = $this->fetchObject( $res2 );
                $this->mNumRows = $obj->num_rows;

                return new ResultWrapper( $this, new IBM_DB2Result( $this, $res, $obj->num_rows, $vars, $sql ) );
        }

        function makeSelectOptions( $options ) {
                $preLimitTail = $postLimitTail = '';
                $startOpts = '';

                $noKeyOptions = array();
                foreach ( $options as $key => $option ) {
                        if ( is_numeric( $key ) ) {
                                $noKeyOptions[$option] = true;
                        }
                }

                if ( isset( $options['GROUP BY'] ) ) {
                        $preLimitTail .= " GROUP BY {$options['GROUP BY']}";
                }
                if ( isset( $options['HAVING'] ) ) {
                        $preLimitTail .= " HAVING {$options['HAVING']}";
                }
                if ( isset( $options['ORDER BY'] ) ) {
                        $preLimitTail .= " ORDER BY {$options['ORDER BY']}";
                }

                if ( isset( $noKeyOptions['DISTINCT'] )
                        || isset( $noKeyOptions['DISTINCTROW'] ) )
                {
                        $startOpts .= 'DISTINCT';
                }

                return array( $startOpts, '', $preLimitTail, $postLimitTail );
        }

        public static function getSoftwareLink() {
                return '[http://www.ibm.com/db2/express/ IBM DB2]';
        }

        public function getSearchEngine() {
                return 'SearchIBM_DB2';
        }

        public function wasDeadlock() {
                // get SQLSTATE
                $err = $this->lastErrno();
                switch( $err ) {
                        // This is literal port of the MySQL logic and may be wrong for DB2
                        case '40001':   // sql0911n, Deadlock or timeout, rollback
                        case '57011':   // sql0904n, Resource unavailable, no rollback
                        case '57033':   // sql0913n, Deadlock or timeout, no rollback
                        $this->installPrint( "In a deadlock because of SQLSTATE $err" );
                        return true;
                }
                return false;
        }

        public function ping() {
                // db2_ping() doesn't exist
                // Emulate
                $this->close();
                $this->openUncataloged( $this->mDBName, $this->mUser,
                        $this->mPassword, $this->mServer, $this->mPort );

                return false;
        }
        ######################################
        # Unimplemented and not applicable
        ######################################

        public function fillPreparedArg( $matches ) {
                $this->installPrint( 'Not useful for DB2: fillPreparedArg()' );
                return '';
        }

        ######################################
        # Reflection
        ######################################

        public function indexInfo( $table, $index,
                $fname = 'DatabaseIbm_db2::indexExists' )
        {
                $table = $this->tableName( $table );
                $sql = <<<SQL
SELECT name as indexname
FROM sysibm.sysindexes si
WHERE si.name='$index' AND si.tbname='$table'
AND sc.tbcreator='$this->mSchema'
SQL;
                $res = $this->query( $sql, $fname );
                if ( !$res ) {
                        return null;
                }
                $row = $this->fetchObject( $res );
                if ( $row != null ) {
                        return $row;
                } else {
                        return false;
                }
        }

        public function fieldInfo( $table, $field ) {
                return IBM_DB2Field::fromText( $this, $table, $field );
        }

        public function fieldType( $res, $index ) {
                if ( $res instanceof ResultWrapper ) {
                        $res = $res->result;
                }
                if ( $res instanceof IBM_DB2Result ) {
                        $res = $res->getResult();
                }
                return db2_field_type( $res, $index );
        }

        public function indexUnique ( $table, $index,
                $fname = 'DatabaseIbm_db2::indexUnique' )
        {
                $table = $this->tableName( $table );
                $sql = <<<SQL
SELECT si.name as indexname
FROM sysibm.sysindexes si
WHERE si.name='$index' AND si.tbname='$table'
AND sc.tbcreator='$this->mSchema'
AND si.uniquerule IN ( 'U', 'P' )
SQL;
                $res = $this->query( $sql, $fname );
                if ( !$res ) {
                        return null;
                }
                if ( $this->fetchObject( $res ) ) {
                        return true;
                }
                return false;

        }

        public function textFieldSize( $table, $field ) {
                $table = $this->tableName( $table );
                $sql = <<<SQL
SELECT length as size
FROM sysibm.syscolumns sc
WHERE sc.name='$field' AND sc.tbname='$table'
AND sc.tbcreator='$this->mSchema'
SQL;
                $res = $this->query( $sql );
                $row = $this->fetchObject( $res );
                $size = $row->size;
                return $size;
        }

        public function encodeBlob( $b ) {
                return new IBM_DB2Blob( $b );
        }

        public function decodeBlob( $b ) {
                return "$b";
        }

        public function buildConcat( $stringList ) {
                // || is equivalent to CONCAT
                // Sample query: VALUES 'foo' CONCAT 'bar' CONCAT 'baz'
                return implode( ' || ', $stringList );
        }

        public function extractUnixEpoch( $column ) {
                // TODO
                // see SpecialAncientpages
        }

        ######################################
        # Prepared statements
        ######################################

        public function prepare( $sql, $func = 'DB2::prepare' ) {
                $stmt = db2_prepare( $this->mConn, $sql, $this->mStmtOptions );
                return $stmt;
        }

        public function freePrepared( $prepared ) {
                return db2_free_stmt( $prepared );
        }

        public function execute( $prepared, $args = null ) {
                if( !is_array( $args ) ) {
                        # Pull the var args
                        $args = func_get_args();
                        array_shift( $args );
                }
                $res = db2_execute( $prepared, $args );
                if ( !$res ) {
                        $this->installPrint( db2_stmt_errormsg() );
                }
                return $res;
        }

        public function fillPrepared( $preparedQuery, $args ) {
                reset( $args );
                $this->preparedArgs =& $args;

                foreach ( $args as $i => $arg ) {
                        db2_bind_param( $preparedQuery, $i+1, $args[$i] );
                }

                return $preparedQuery;
        }

        public function setMode( $mode ) {
                $old = $this->mMode;
                $this->mMode = $mode;
                return $old;
        }

        function bitNot( $field ) {
                // expecting bit-fields smaller than 4bytes
                return "BITNOT( $field )";
        }

        function bitAnd( $fieldLeft, $fieldRight ) {
                return "BITAND( $fieldLeft, $fieldRight )";
        }

        function bitOr( $fieldLeft, $fieldRight ) {
                return "BITOR( $fieldLeft, $fieldRight )";
        }
}

class IBM_DB2Helper {
        public static function makeArray( $maybeArray ) {
                if ( !is_array( $maybeArray ) ) {
                        return array( $maybeArray );
                }

                return $maybeArray;
        }
}