DatabaseMssql.php

Go to the documentation of this file.

<?php
class DatabaseMssql extends DatabaseBase {
    protected $mInsertId = null;
    protected $mLastResult = null;
    protected $mAffectedRows = null;
    protected $mSubqueryId = 0;
    protected $mScrollableCursor = true;
    protected $mPrepareStatements = true;
    protected $mBinaryColumnCache = null;
    protected $mBitColumnCache = null;
    protected $mIgnoreDupKeyErrors = false;

    protected $mPort;

    public function cascadingDeletes() {
        return true;
    }

    public function cleanupTriggers() {
        return false;
    }

    public function strictIPs() {
        return false;
    }

    public function realTimestamps() {
        return false;
    }

    public function implicitGroupby() {
        return false;
    }

    public function implicitOrderby() {
        return false;
    }

    public function functionalIndexes() {
        return true;
    }

    public function unionSupportsOrderAndLimit() {
        return false;
    }

    public function open( $server, $user, $password, $dbName ) {
        # Test for driver support, to avoid suppressed fatal error
        if ( !function_exists( 'sqlsrv_connect' ) ) {
            throw new DBConnectionError(
                $this,
                "Microsoft SQL Server Native (sqlsrv) functions missing.
                You can download the driver from: http://go.microsoft.com/fwlink/?LinkId=123470\n"
            );
        }

        global $wgDBport, $wgDBWindowsAuthentication;

        # e.g. the class is being loaded
        if ( !strlen( $user ) ) {
            return null;
        }

        $this->close();
        $this->mServer = $server;
        $this->mPort = $wgDBport;
        $this->mUser = $user;
        $this->mPassword = $password;
        $this->mDBname = $dbName;

        $connectionInfo = array();

        if ( $dbName ) {
            $connectionInfo['Database'] = $dbName;
        }

        // Decide which auth scenerio to use
        // if we are using Windows auth, don't add credentials to $connectionInfo
        if ( !$wgDBWindowsAuthentication ) {
            $connectionInfo['UID'] = $user;
            $connectionInfo['PWD'] = $password;
        }

        wfSuppressWarnings();
        $this->mConn = sqlsrv_connect( $server, $connectionInfo );
        wfRestoreWarnings();

        if ( $this->mConn === false ) {
            throw new DBConnectionError( $this, $this->lastError() );
        }

        $this->mOpened = true;

        return $this->mConn;
    }

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

    public function resultObject( $result ) {
        if ( empty( $result ) ) {
            return false;
        } elseif ( $result instanceof MssqlResultWrapper ) {
            return $result;
        } elseif ( $result === true ) {
            // Successful write query
            return $result;
        } else {
            return new MssqlResultWrapper( $this, $result );
        }
    }

    protected function doQuery( $sql ) {
        if ( $this->debug() ) {
            wfDebug( "SQL: [$sql]\n" );
        }
        $this->offset = 0;

        // several extensions seem to think that all databases support limits
        // via LIMIT N after the WHERE clause well, MSSQL uses SELECT TOP N,
        // so to catch any of those extensions we'll do a quick check for a
        // LIMIT clause and pass $sql through $this->LimitToTopN() which parses
        // the limit clause and passes the result to $this->limitResult();
        if ( preg_match( '/\bLIMIT\s*/i', $sql ) ) {
            // massage LIMIT -> TopN
            $sql = $this->LimitToTopN( $sql );
        }

        // MSSQL doesn't have EXTRACT(epoch FROM XXX)
        if ( preg_match( '#\bEXTRACT\s*?\(\s*?EPOCH\s+FROM\b#i', $sql, $matches ) ) {
            // This is same as UNIX_TIMESTAMP, we need to calc # of seconds from 1970
            $sql = str_replace( $matches[0], "DATEDIFF(s,CONVERT(datetime,'1/1/1970'),", $sql );
        }

        // perform query

        // SQLSRV_CURSOR_STATIC is slower than SQLSRV_CURSOR_CLIENT_BUFFERED (one of the two is
        // needed if we want to be able to seek around the result set), however CLIENT_BUFFERED
        // has a bug in the sqlsrv driver where wchar_t types (such as nvarchar) that are empty
        // strings make php throw a fatal error "Severe error translating Unicode"
        if ( $this->mScrollableCursor ) {
            $scrollArr = array( 'Scrollable' => SQLSRV_CURSOR_STATIC );
        } else {
            $scrollArr = array();
        }

        if ( $this->mPrepareStatements ) {
            // we do prepare + execute so we can get its field metadata for later usage if desired
            $stmt = sqlsrv_prepare( $this->mConn, $sql, array(), $scrollArr );
            $success = sqlsrv_execute( $stmt );
        } else {
            $stmt = sqlsrv_query( $this->mConn, $sql, array(), $scrollArr );
            $success = (bool)$stmt;
        }

        if ( $this->mIgnoreDupKeyErrors ) {
            // ignore duplicate key errors, but nothing else
            // this emulates INSERT IGNORE in MySQL
            if ( $success === false ) {
                $errors = sqlsrv_errors( SQLSRV_ERR_ERRORS );
                $success = true;

                foreach ( $errors as $err ) {
                    if ( $err['SQLSTATE'] == '23000' && $err['code'] == '2601' ) {
                        continue; // duplicate key error caused by unique index
                    } elseif ( $err['SQLSTATE'] == '23000' && $err['code'] == '2627' ) {
                        continue; // duplicate key error caused by primary key
                    } elseif ( $err['SQLSTATE'] == '01000' && $err['code'] == '3621' ) {
                        continue; // generic "the statement has been terminated" error
                    }

                    $success = false; // getting here means we got an error we weren't expecting
                    break;
                }

                if ( $success ) {
                    $this->mAffectedRows = 0;
                    return $stmt;
                }
            }
        }

        if ( $success === false ) {
            return false;
        }
        // remember number of rows affected
        $this->mAffectedRows = sqlsrv_rows_affected( $stmt );

        return $stmt;
    }

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

        sqlsrv_free_stmt( $res );
    }

    public function fetchObject( $res ) {
        // $res is expected to be an instance of MssqlResultWrapper here
        return $res->fetchObject();
    }

    public function fetchRow( $res ) {
        return $res->fetchRow();
    }

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

        return sqlsrv_num_rows( $res );
    }

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

        return sqlsrv_num_fields( $res );
    }

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

        $metadata = sqlsrv_field_metadata( $res );
        return $metadata[$n]['Name'];
    }

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

    public function dataSeek( $res, $row ) {
        return $res->seek( $row );
    }

    public function lastError() {
        $strRet = '';
        $retErrors = sqlsrv_errors( SQLSRV_ERR_ALL );
        if ( $retErrors != null ) {
            foreach ( $retErrors as $arrError ) {
                $strRet .= $this->formatError( $arrError ) . "\n";
            }
        } else {
            $strRet = "No errors found";
        }

        return $strRet;
    }

    private function formatError( $err ) {
        return '[SQLSTATE ' . $err['SQLSTATE'] . '][Error Code ' . $err['code'] . ']' . $err['message'];
    }

    public function lastErrno() {
        $err = sqlsrv_errors( SQLSRV_ERR_ALL );
        if ( $err !== null && isset( $err[0] ) ) {
            return $err[0]['code'];
        } else {
            return 0;
        }
    }

    public function affectedRows() {
        return $this->mAffectedRows;
    }

    public function select( $table, $vars, $conds = '', $fname = __METHOD__,
        $options = array(), $join_conds = array()
    ) {
        $sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
        if ( isset( $options['EXPLAIN'] ) ) {
            try {
                $this->mScrollableCursor = false;
                $this->mPrepareStatements = false;
                $this->query( "SET SHOWPLAN_ALL ON" );
                $ret = $this->query( $sql, $fname );
                $this->query( "SET SHOWPLAN_ALL OFF" );
            } catch ( DBQueryError $dqe ) {
                if ( isset( $options['FOR COUNT'] ) ) {
                    // likely don't have privs for SHOWPLAN, so run a select count instead
                    $this->query( "SET SHOWPLAN_ALL OFF" );
                    unset( $options['EXPLAIN'] );
                    $ret = $this->select(
                        $table,
                        'COUNT(*) AS EstimateRows',
                        $conds,
                        $fname,
                        $options,
                        $join_conds
                    );
                } else {
                    // someone actually wanted the query plan instead of an est row count
                    // let them know of the error
                    $this->mScrollableCursor = true;
                    $this->mPrepareStatements = true;
                    throw $dqe;
                }
            }
            $this->mScrollableCursor = true;
            $this->mPrepareStatements = true;
            return $ret;
        }
        return $this->query( $sql, $fname );
    }

    public function selectSQLText( $table, $vars, $conds = '', $fname = __METHOD__,
        $options = array(), $join_conds = array()
    ) {
        if ( isset( $options['EXPLAIN'] ) ) {
            unset( $options['EXPLAIN'] );
        }

        $sql = parent::selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );

        // try to rewrite aggregations of bit columns (currently MAX and MIN)
        if ( strpos( $sql, 'MAX(' ) !== false || strpos( $sql, 'MIN(' ) !== false ) {
            $bitColumns = array();
            if ( is_array( $table ) ) {
                foreach ( $table as $t ) {
                    $bitColumns += $this->getBitColumns( $this->tableName( $t ) );
                }
            } else {
                $bitColumns = $this->getBitColumns( $this->tableName( $table ) );
            }

            foreach ( $bitColumns as $col => $info ) {
                $replace = array(
                    "MAX({$col})" => "MAX(CAST({$col} AS tinyint))",
                    "MIN({$col})" => "MIN(CAST({$col} AS tinyint))",
                );
                $sql = str_replace( array_keys( $replace ), array_values( $replace ), $sql );
            }
        }

        return $sql;
    }

    public function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds,
        $fname = __METHOD__
    ) {
        $this->mScrollableCursor = false;
        try {
            parent::deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname );
        } catch ( Exception $e ) {
            $this->mScrollableCursor = true;
            throw $e;
        }
        $this->mScrollableCursor = true;
    }

    public function delete( $table, $conds, $fname = __METHOD__ ) {
        $this->mScrollableCursor = false;
        try {
            parent::delete( $table, $conds, $fname );
        } catch ( Exception $e ) {
            $this->mScrollableCursor = true;
            throw $e;
        }
        $this->mScrollableCursor = true;
    }

    public function estimateRowCount( $table, $vars = '*', $conds = '',
        $fname = __METHOD__, $options = array()
    ) {
        // http://msdn2.microsoft.com/en-us/library/aa259203.aspx
        $options['EXPLAIN'] = true;
        $options['FOR COUNT'] = true;
        $res = $this->select( $table, $vars, $conds, $fname, $options );

        $rows = -1;
        if ( $res ) {
            $row = $this->fetchRow( $res );

            if ( isset( $row['EstimateRows'] ) ) {
                $rows = $row['EstimateRows'];
            }
        }

        return $rows;
    }

    public function indexInfo( $table, $index, $fname = __METHOD__ ) {
        # This does not return the same info as MYSQL would, but that's OK
        # because MediaWiki never uses the returned value except to check for
        # the existance of indexes.
        $sql = "sp_helpindex '" . $table . "'";
        $res = $this->query( $sql, $fname );
        if ( !$res ) {
            return null;
        }

        $result = array();
        foreach ( $res as $row ) {
            if ( $row->index_name == $index ) {
                $row->Non_unique = !stristr( $row->index_description, "unique" );
                $cols = explode( ", ", $row->index_keys );
                foreach ( $cols as $col ) {
                    $row->Column_name = trim( $col );
                    $result[] = clone $row;
                }
            } elseif ( $index == 'PRIMARY' && stristr( $row->index_description, 'PRIMARY' ) ) {
                $row->Non_unique = 0;
                $cols = explode( ", ", $row->index_keys );
                foreach ( $cols as $col ) {
                    $row->Column_name = trim( $col );
                    $result[] = clone $row;
                }
            }
        }

        return empty( $result ) ? false : $result;
    }

    public function insert( $table, $arrToInsert, $fname = __METHOD__, $options = array() ) {
        # No rows to insert, easy just return now
        if ( !count( $arrToInsert ) ) {
            return true;
        }

        if ( !is_array( $options ) ) {
            $options = array( $options );
        }

        $table = $this->tableName( $table );

        if ( !( isset( $arrToInsert[0] ) && is_array( $arrToInsert[0] ) ) ) { // Not multi row
            $arrToInsert = array( 0 => $arrToInsert ); // make everything multi row compatible
        }

        // We know the table we're inserting into, get its identity column
        $identity = null;
        // strip matching square brackets and the db/schema from table name
        $tableRawArr = explode( '.', preg_replace( '#\[([^\]]*)\]#', '$1', $table ) );
        $tableRaw = array_pop( $tableRawArr );
        $res = $this->doQuery(
            "SELECT NAME AS idColumn FROM SYS.IDENTITY_COLUMNS " .
                "WHERE OBJECT_NAME(OBJECT_ID)='{$tableRaw}'"
        );
        if ( $res && sqlsrv_has_rows( $res ) ) {
            // There is an identity for this table.
            $identityArr = sqlsrv_fetch_array( $res, SQLSRV_FETCH_ASSOC );
            $identity = array_pop( $identityArr );
        }
        sqlsrv_free_stmt( $res );

        // Determine binary/varbinary fields so we can encode data as a hex string like 0xABCDEF
        $binaryColumns = $this->getBinaryColumns( $table );

        // INSERT IGNORE is not supported by SQL Server
        // remove IGNORE from options list and set ignore flag to true
        if ( in_array( 'IGNORE', $options ) ) {
            $options = array_diff( $options, array( 'IGNORE' ) );
            $this->mIgnoreDupKeyErrors = true;
        }

        foreach ( $arrToInsert as $a ) {
            // start out with empty identity column, this is so we can return
            // it as a result of the insert logic
            $sqlPre = '';
            $sqlPost = '';
            $identityClause = '';

            // if we have an identity column
            if ( $identity ) {
                // iterate through
                foreach ( $a as $k => $v ) {
                    if ( $k == $identity ) {
                        if ( !is_null( $v ) ) {
                            // there is a value being passed to us,
                            // we need to turn on and off inserted identity
                            $sqlPre = "SET IDENTITY_INSERT $table ON;";
                            $sqlPost = ";SET IDENTITY_INSERT $table OFF;";
                        } else {
                            // we can't insert NULL into an identity column,
                            // so remove the column from the insert.
                            unset( $a[$k] );
                        }
                    }
                }

                // we want to output an identity column as result
                $identityClause = "OUTPUT INSERTED.$identity ";
            }

            $keys = array_keys( $a );

            // Build the actual query
            $sql = $sqlPre . 'INSERT ' . implode( ' ', $options ) .
                " INTO $table (" . implode( ',', $keys ) . ") $identityClause VALUES (";

            $first = true;
            foreach ( $a as $key => $value ) {
                if ( isset( $binaryColumns[$key] ) ) {
                    $value = new MssqlBlob( $value );
                }
                if ( $first ) {
                    $first = false;
                } else {
                    $sql .= ',';
                }
                if ( is_null( $value ) ) {
                    $sql .= 'null';
                } elseif ( is_array( $value ) || is_object( $value ) ) {
                    if ( is_object( $value ) && $value instanceof Blob ) {
                        $sql .= $this->addQuotes( $value );
                    } else {
                        $sql .= $this->addQuotes( serialize( $value ) );
                    }
                } else {
                    $sql .= $this->addQuotes( $value );
                }
            }
            $sql .= ')' . $sqlPost;

            // Run the query
            $this->mScrollableCursor = false;
            try {
                $ret = $this->query( $sql );
            } catch ( Exception $e ) {
                $this->mScrollableCursor = true;
                $this->mIgnoreDupKeyErrors = false;
                throw $e;
            }
            $this->mScrollableCursor = true;

            if ( !is_null( $identity ) ) {
                // then we want to get the identity column value we were assigned and save it off
                $row = $ret->fetchObject();
                if( is_object( $row ) ){
                    $this->mInsertId = $row->$identity;
                }
            }
        }
        $this->mIgnoreDupKeyErrors = false;
        return $ret;
    }

    public function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = __METHOD__,
        $insertOptions = array(), $selectOptions = array()
    ) {
        $this->mScrollableCursor = false;
        try {
            $ret = parent::insertSelect(
                $destTable,
                $srcTable,
                $varMap,
                $conds,
                $fname,
                $insertOptions,
                $selectOptions
            );
        } catch ( Exception $e ) {
            $this->mScrollableCursor = true;
            throw $e;
        }
        $this->mScrollableCursor = true;

        return $ret;
    }

    function update( $table, $values, $conds, $fname = __METHOD__, $options = array() ) {
        $table = $this->tableName( $table );
        $binaryColumns = $this->getBinaryColumns( $table );

        $opts = $this->makeUpdateOptions( $options );
        $sql = "UPDATE $opts $table SET " . $this->makeList( $values, LIST_SET, $binaryColumns );

        if ( $conds !== array() && $conds !== '*' ) {
            $sql .= " WHERE " . $this->makeList( $conds, LIST_AND, $binaryColumns );
        }

        $this->mScrollableCursor = false;
        try {
            $ret = $this->query( $sql );
        } catch ( Exception $e ) {
            $this->mScrollableCursor = true;
            throw $e;
        }
        $this->mScrollableCursor = true;
        return true;
    }

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

        $first = true;
        $list = '';

        foreach ( $a as $field => $value ) {
            if ( $mode != LIST_NAMES && isset( $binaryColumns[$field] ) ) {
                if ( is_array( $value ) ) {
                    foreach ( $value as &$v ) {
                        $v = new MssqlBlob( $v );
                    }
                } else {
                    $value = new MssqlBlob( $value );
                }
            }

            if ( !$first ) {
                if ( $mode == LIST_AND ) {
                    $list .= ' AND ';
                } elseif ( $mode == LIST_OR ) {
                    $list .= ' OR ';
                } else {
                    $list .= ',';
                }
            } else {
                $first = false;
            }

            if ( ( $mode == LIST_AND || $mode == LIST_OR ) && is_numeric( $field ) ) {
                $list .= "($value)";
            } elseif ( ( $mode == LIST_SET ) && is_numeric( $field ) ) {
                $list .= "$value";
            } elseif ( ( $mode == LIST_AND || $mode == LIST_OR ) && is_array( $value ) ) {
                if ( count( $value ) == 0 ) {
                    throw new MWException( __METHOD__ . ": empty input for field $field" );
                } elseif ( count( $value ) == 1 ) {
                    // Special-case single values, as IN isn't terribly efficient
                    // Don't necessarily assume the single key is 0; we don't
                    // enforce linear numeric ordering on other arrays here.
                    $value = array_values( $value );
                    $list .= $field . " = " . $this->addQuotes( $value[0] );
                } else {
                    $list .= $field . " IN (" . $this->makeList( $value ) . ") ";
                }
            } elseif ( $value === null ) {
                if ( $mode == LIST_AND || $mode == LIST_OR ) {
                    $list .= "$field IS ";
                } elseif ( $mode == LIST_SET ) {
                    $list .= "$field = ";
                }
                $list .= 'NULL';
            } else {
                if ( $mode == LIST_AND || $mode == LIST_OR || $mode == LIST_SET ) {
                    $list .= "$field = ";
                }
                $list .= $mode == LIST_NAMES ? $value : $this->addQuotes( $value );
            }
        }

        return $list;
    }

    public function textFieldSize( $table, $field ) {
        $table = $this->tableName( $table );
        $sql = "SELECT CHARACTER_MAXIMUM_LENGTH,DATA_TYPE FROM INFORMATION_SCHEMA.Columns
            WHERE TABLE_NAME = '$table' AND COLUMN_NAME = '$field'";
        $res = $this->query( $sql );
        $row = $this->fetchRow( $res );
        $size = -1;
        if ( strtolower( $row['DATA_TYPE'] ) != 'text' ) {
            $size = $row['CHARACTER_MAXIMUM_LENGTH'];
        }

        return $size;
    }

    public function limitResult( $sql, $limit, $offset = false ) {
        if ( $offset === false || $offset == 0 ) {
            if ( strpos( $sql, "SELECT" ) === false ) {
                return "TOP {$limit} " . $sql;
            } else {
                return preg_replace( '/\bSELECT(\s+DISTINCT)?\b/Dsi',
                    'SELECT$1 TOP ' . $limit, $sql, 1 );
            }
        } else {
            // This one is fun, we need to pull out the select list as well as any ORDER BY clause
            $select = $orderby = array();
            $s1 = preg_match( '#SELECT\s+(.+?)\s+FROM#Dis', $sql, $select );
            $s2 = preg_match( '#(ORDER BY\s+.+?)(\s*FOR XML .*)?$#Dis', $sql, $orderby );
            $overOrder = $postOrder = '';
            $first = $offset + 1;
            $last = $offset + $limit;
            $sub1 = 'sub_' . $this->mSubqueryId;
            $sub2 = 'sub_' . ( $this->mSubqueryId + 1 );
            $this->mSubqueryId += 2;
            if ( !$s1 ) {
                // wat
                throw new DBUnexpectedError( $this, "Attempting to LIMIT a non-SELECT query\n" );
            }
            if ( !$s2 ) {
                // no ORDER BY
                $overOrder = 'ORDER BY (SELECT 1)';
            } else {
                if ( !isset( $orderby[2] ) || !$orderby[2] ) {
                    // don't need to strip it out if we're using a FOR XML clause
                    $sql = str_replace( $orderby[1], '', $sql );
                }
                $overOrder = $orderby[1];
                $postOrder = ' ' . $overOrder;
            }
            $sql = "SELECT {$select[1]}
                    FROM (
                        SELECT ROW_NUMBER() OVER({$overOrder}) AS rowNumber, *
                        FROM ({$sql}) {$sub1}
                    ) {$sub2}
                    WHERE rowNumber BETWEEN {$first} AND {$last}{$postOrder}";

            return $sql;
        }
    }

    public function LimitToTopN( $sql ) {
        // Matches: LIMIT {[offset,] row_count | row_count OFFSET offset}
        $pattern = '/\bLIMIT\s+((([0-9]+)\s*,\s*)?([0-9]+)(\s+OFFSET\s+([0-9]+))?)/i';
        if ( preg_match( $pattern, $sql, $matches ) ) {
            // row_count = $matches[4]
            $row_count = $matches[4];
            // offset = $matches[3] OR $matches[6]
            $offset = $matches[3] or
            $offset = $matches[6] or
            $offset = false;

            // strip the matching LIMIT clause out
            $sql = str_replace( $matches[0], '', $sql );

            return $this->limitResult( $sql, $row_count, $offset );
        }

        return $sql;
    }

    public function getSoftwareLink() {
        return "[{{int:version-db-mssql-url}} MS SQL Server]";
    }

    public function getServerVersion() {
        $server_info = sqlsrv_server_info( $this->mConn );
        $version = 'Error';
        if ( isset( $server_info['SQLServerVersion'] ) ) {
            $version = $server_info['SQLServerVersion'];
        }

        return $version;
    }

    public function tableExists( $table, $fname = __METHOD__ ) {
        list( $db, $schema, $table ) = $this->tableName( $table, 'split' );

        if ( $db !== false ) {
            // remote database
            wfDebug( "Attempting to call tableExists on a remote table" );
            return false;
        }

        if ( $schema === false ) {
            global $wgDBmwschema;
            $schema = $wgDBmwschema;
        }

        $res = $this->query( "SELECT 1 FROM INFORMATION_SCHEMA.TABLES
            WHERE TABLE_TYPE = 'BASE TABLE'
            AND TABLE_SCHEMA = '$schema' AND TABLE_NAME = '$table'" );

        if ( $res->numRows() ) {
            return true;
        } else {
            return false;
        }
    }

    public function fieldExists( $table, $field, $fname = __METHOD__ ) {
        list( $db, $schema, $table ) = $this->tableName( $table, 'split' );

        if ( $db !== false ) {
            // remote database
            wfDebug( "Attempting to call fieldExists on a remote table" );
            return false;
        }

        $res = $this->query( "SELECT 1 FROM INFORMATION_SCHEMA.COLUMNS
            WHERE TABLE_SCHEMA = '$schema' AND TABLE_NAME = '$table' AND COLUMN_NAME = '$field'" );

        if ( $res->numRows() ) {
            return true;
        } else {
            return false;
        }
    }

    public function fieldInfo( $table, $field ) {
        list( $db, $schema, $table ) = $this->tableName( $table, 'split' );

        if ( $db !== false ) {
            // remote database
            wfDebug( "Attempting to call fieldInfo on a remote table" );
            return false;
        }

        $res = $this->query( "SELECT * FROM INFORMATION_SCHEMA.COLUMNS
            WHERE TABLE_SCHEMA = '$schema' AND TABLE_NAME = '$table' AND COLUMN_NAME = '$field'" );

        $meta = $res->fetchRow();
        if ( $meta ) {
            return new MssqlField( $meta );
        }

        return false;
    }

    protected function doBegin( $fname = __METHOD__ ) {
        sqlsrv_begin_transaction( $this->mConn );
        $this->mTrxLevel = 1;
    }

    protected function doCommit( $fname = __METHOD__ ) {
        sqlsrv_commit( $this->mConn );
        $this->mTrxLevel = 0;
    }

    protected function doRollback( $fname = __METHOD__ ) {
        sqlsrv_rollback( $this->mConn );
        $this->mTrxLevel = 0;
    }

    private function escapeIdentifier( $identifier ) {
        if ( strlen( $identifier ) == 0 ) {
            throw new MWException( "An identifier must not be empty" );
        }
        if ( strlen( $identifier ) > 128 ) {
            throw new MWException( "The identifier '$identifier' is too long (max. 128)" );
        }
        if ( ( strpos( $identifier, '[' ) !== false )
            || ( strpos( $identifier, ']' ) !== false )
        ) {
            // It may be allowed if you quoted with double quotation marks, but
            // that would break if QUOTED_IDENTIFIER is OFF
            throw new MWException( "Square brackets are not allowed in '$identifier'" );
        }

        return "[$identifier]";
    }

    public function strencode( $s ) { # Should not be called by us
        return str_replace( "'", "''", $s );
    }

    public function addQuotes( $s ) {
        if ( $s instanceof MssqlBlob ) {
            return $s->fetch();
        } elseif ( $s instanceof Blob ) {
            // this shouldn't really ever be called, but it's here if needed
            // (and will quite possibly make the SQL error out)
            $blob = new MssqlBlob( $s->fetch() );
            return $blob->fetch();
        } else {
            if ( is_bool( $s ) ) {
                $s = $s ? 1 : 0;
            }
            return parent::addQuotes( $s );
        }
    }

    public function addIdentifierQuotes( $s ) {
        // http://msdn.microsoft.com/en-us/library/aa223962.aspx
        return '[' . $s . ']';
    }

    public function isQuotedIdentifier( $name ) {
        return strlen( $name ) && $name[0] == '[' && substr( $name, -1, 1 ) == ']';
    }

    public function selectDB( $db ) {
        try {
            $this->mDBname = $db;
            $this->query( "USE $db" );
            return true;
        } catch ( Exception $e ) {
            return false;
        }
    }

    public function makeSelectOptions( $options ) {
        $tailOpts = '';
        $startOpts = '';

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

        $tailOpts .= $this->makeGroupByWithHaving( $options );

        $tailOpts .= $this->makeOrderBy( $options );

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

        if ( isset( $noKeyOptions['FOR XML'] ) ) {
            // used in group concat field emulation
            $tailOpts .= " FOR XML PATH('')";
        }

        // we want this to be compatible with the output of parent::makeSelectOptions()
        return array( $startOpts, '', $tailOpts, '' );
    }

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

    public function buildConcat( $stringList ) {
        return implode( ' + ', $stringList );
    }

    public function buildGroupConcatField( $delim, $table, $field, $conds = '',
        $join_conds = array()
    ) {
        $gcsq = 'gcsq_' . $this->mSubqueryId;
        $this->mSubqueryId++;

        $delimLen = strlen( $delim );
        $fld = "{$field} + {$this->addQuotes( $delim )}";
        $sql = "(SELECT LEFT({$field}, LEN({$field}) - {$delimLen}) FROM ("
            . $this->selectSQLText( $table, $fld, $conds, null, array( 'FOR XML' ), $join_conds )
            . ") {$gcsq} ({$field}))";

        return $sql;
    }

    public function getSearchEngine() {
        return "SearchMssql";
    }

    private function getBinaryColumns( $table ) {
        $tableRawArr = explode( '.', preg_replace( '#\[([^\]]*)\]#', '$1', $table ) );
        $tableRaw = array_pop( $tableRawArr );

        if ( $this->mBinaryColumnCache === null ) {
            $this->populateColumnCaches();
        }

        return isset( $this->mBinaryColumnCache[$tableRaw] )
            ? $this->mBinaryColumnCache[$tableRaw]
            : array();
    }

    private function getBitColumns( $table ) {
        $tableRawArr = explode( '.', preg_replace( '#\[([^\]]*)\]#', '$1', $table ) );
        $tableRaw = array_pop( $tableRawArr );

        if ( $this->mBitColumnCache === null ) {
            $this->populateColumnCaches();
        }

        return isset( $this->mBitColumnCache[$tableRaw] )
            ? $this->mBitColumnCache[$tableRaw]
            : array();
    }

    private function populateColumnCaches() {
        $res = $this->select( 'INFORMATION_SCHEMA.COLUMNS', '*',
            array(
                'TABLE_CATALOG' => $this->mDBname,
                'TABLE_SCHEMA' => $this->mSchema,
                'DATA_TYPE' => array( 'varbinary', 'binary', 'image', 'bit' )
            ) );

        $this->mBinaryColumnCache = array();
        $this->mBitColumnCache = array();
        foreach ( $res as $row ) {
            if ( $row->DATA_TYPE == 'bit' ) {
                $this->mBitColumnCache[$row->TABLE_NAME][$row->COLUMN_NAME] = $row;
            } else {
                $this->mBinaryColumnCache[$row->TABLE_NAME][$row->COLUMN_NAME] = $row;
            }
        }
    }

    function tableName( $name, $format = 'quoted' ) {
        # Replace reserved words with better ones
        switch ( $name ) {
            case 'user':
                return $this->realTableName( 'mwuser', $format );
            default:
                return $this->realTableName( $name, $format );
        }
    }

    function realTableName( $name, $format = 'quoted' ) {
        $table = parent::tableName( $name, $format );
        if ( $format == 'split' ) {
            // Used internally, we want the schema split off from the table name and returned
            // as a list with 3 elements (database, schema, table)
            $table = explode( '.', $table );
            while ( count( $table ) < 3 ) {
                array_unshift( $table, false );
            }
        }
        return $table;
    }

    public function prepareStatements( $value = null ) {
        return wfSetVar( $this->mPrepareStatements, $value );
    }

    public function scrollableCursor( $value = null ) {
        return wfSetVar( $this->mScrollableCursor, $value );
    }
} // end DatabaseMssql class

class MssqlField implements Field {
    private $name, $tableName, $default, $max_length, $nullable, $type;

    function __construct( $info ) {
        $this->name = $info['COLUMN_NAME'];
        $this->tableName = $info['TABLE_NAME'];
        $this->default = $info['COLUMN_DEFAULT'];
        $this->max_length = $info['CHARACTER_MAXIMUM_LENGTH'];
        $this->nullable = !( strtolower( $info['IS_NULLABLE'] ) == 'no' );
        $this->type = $info['DATA_TYPE'];
    }

    function name() {
        return $this->name;
    }

    function tableName() {
        return $this->tableName;
    }

    function defaultValue() {
        return $this->default;
    }

    function maxLength() {
        return $this->max_length;
    }

    function isNullable() {
        return $this->nullable;
    }

    function type() {
        return $this->type;
    }
}

class MssqlBlob extends Blob {
    public function __construct( $data ) {
        if ( $data instanceof MssqlBlob ) {
            return $data;
        } elseif ( $data instanceof Blob ) {
            $this->mData = $data->fetch();
        } elseif ( is_array( $data ) && is_object( $data ) ) {
            $this->mData = serialize( $data );
        } else {
            $this->mData = $data;
        }
    }

    public function fetch() {
        if ( $this->mData === null ) {
            return 'null';
        }

        $ret = '0x';
        $dataLength = strlen( $this->mData );
        for ( $i = 0; $i < $dataLength; $i++ ) {
            $ret .= bin2hex( pack( 'C', ord( $this->mData[$i] ) ) );
        }

        return $ret;
    }
}

class MssqlResultWrapper extends ResultWrapper {
    private $mSeekTo = null;

    public function fetchObject() {
        $res = $this->result;

        if ( $this->mSeekTo !== null ) {
            $result = sqlsrv_fetch_object( $res, 'stdClass', array(),
                SQLSRV_SCROLL_ABSOLUTE, $this->mSeekTo );
            $this->mSeekTo = null;
        } else {
            $result = sqlsrv_fetch_object( $res );
        }

        // MediaWiki expects us to return boolean false when there are no more rows instead of null
        if ( $result === null ) {
            return false;
        }

        return $result;
    }

    public function fetchRow() {
        $res = $this->result;

        if ( $this->mSeekTo !== null ) {
            $result = sqlsrv_fetch_array( $res, SQLSRV_FETCH_BOTH,
                SQLSRV_SCROLL_ABSOLUTE, $this->mSeekTo );
            $this->mSeekTo = null;
        } else {
            $result = sqlsrv_fetch_array( $res );
        }

        // MediaWiki expects us to return boolean false when there are no more rows instead of null
        if ( $result === null ) {
            return false;
        }

        return $result;
    }

    public function seek( $row ) {
        $res = $this->result;

        // check bounds
        $numRows = $this->db->numRows( $res );
        $row = intval( $row );

        if ( $numRows === 0 ) {
            return false;
        } elseif ( $row < 0 || $row > $numRows - 1 ) {
            return false;
        }

        // Unlike MySQL, the seek actually happens on the next access
        $this->mSeekTo = $row;
        return true;
    }
}