includes/db/DatabaseMssql.php

   1 <?php
   2 /**
   3  * This is the MS SQL Server Native database abstraction layer.
   4  *
   5  * @file
   6  * @ingroup Database
   7  * @author Joel Penner <a-joelpe at microsoft dot com>
   8  * @author Chris Pucci <a-cpucci at microsoft dot com>
   9  * @author Ryan Biesemeyer <v-ryanbi at microsoft dot com>
  10  */
  11
  12 /**
  13  * @ingroup Database
  14  */
  15 class DatabaseMssql extends DatabaseBase {
  16         var $mInsertId = NULL;
  17         var $mLastResult = NULL;
  18         var $mAffectedRows = NULL;
  19
  20         var $mPort;
  21
  22         function cascadingDeletes() {
  23                 return true;
  24         }
  25         function cleanupTriggers() {
  26                 return true;
  27         }
  28         function strictIPs() {
  29                 return true;
  30         }
  31         function realTimestamps() {
  32                 return true;
  33         }
  34         function implicitGroupby() {
  35                 return false;
  36         }
  37         function implicitOrderby() {
  38                 return false;
  39         }
  40         function functionalIndexes() {
  41                 return true;
  42         }
  43         function unionSupportsOrderAndLimit() {
  44                 return false;
  45         }
  46
  47         /**
  48          * Usually aborts on failure
  49          */
  50         function open( $server, $user, $password, $dbName ) {
  51                 # Test for driver support, to avoid suppressed fatal error
  52                 if ( !function_exists( 'sqlsrv_connect' ) ) {
  53                         throw new DBConnectionError( $this, "MS Sql Server Native (sqlsrv) functions missing. You can download the driver from: http://go.microsoft.com/fwlink/?LinkId=123470\n" );
  54                 }
  55
  56                 global $wgDBport;
  57
  58                 if ( !strlen( $user ) ) { # e.g. the class is being loaded
  59                         return;
  60                 }
  61
  62                 $this->close();
  63                 $this->mServer = $server;
  64                 $this->mPort = $wgDBport;
  65                 $this->mUser = $user;
  66                 $this->mPassword = $password;
  67                 $this->mDBname = $dbName;
  68
  69                 $connectionInfo = array();
  70
  71                 if( $dbName ) {
  72                         $connectionInfo['Database'] = $dbName;
  73                 }
  74
  75                 // Start NT Auth Hack
  76                 // Quick and dirty work around to provide NT Auth designation support.
  77                 // Current solution requires installer to know to input 'ntauth' for both username and password
  78                 // to trigger connection via NT Auth. - ugly, ugly, ugly
  79                 // TO-DO: Make this better and add NT Auth choice to MW installer when SQL Server option is chosen.
  80                 $ntAuthUserTest = strtolower( $user );
  81                 $ntAuthPassTest = strtolower( $password );
  82
  83                 // Decide which auth scenerio to use
  84                 if( $ntAuthPassTest == 'ntauth' && $ntAuthUserTest == 'ntauth' ){
  85                         // Don't add credentials to $connectionInfo
  86                 } else {
  87                         $connectionInfo['UID'] = $user;
  88                         $connectionInfo['PWD'] = $password;
  89                 }
  90                 // End NT Auth Hack
  91
  92                 wfSuppressWarnings();
  93                 $this->mConn = sqlsrv_connect( $server, $connectionInfo );
  94                 wfRestoreWarnings();
  95
  96                 if ( $this->mConn === false ) {
  97                         wfDebug( "DB connection error\n" );
  98                         wfDebug( "Server: $server, Database: $dbName, User: $user, Password: " . substr( $password, 0, 3 ) . "...\n" );
  99                         wfDebug( $this->lastError() . "\n" );
 100                         return false;
 101                 }
 102
 103                 $this->mOpened = true;
 104                 return $this->mConn;
 105         }
 106
 107         /**
 108          * Closes a database connection, if it is open
 109          * Returns success, true if already closed
 110          */
 111         function close() {
 112                 $this->mOpened = false;
 113                 if ( $this->mConn ) {
 114                         return sqlsrv_close( $this->mConn );
 115                 } else {
 116                         return true;
 117                 }
 118         }
 119
 120         protected function doQuery( $sql ) {
 121                 wfDebug( "SQL: [$sql]\n" );
 122                 $this->offset = 0;
 123
 124                 // several extensions seem to think that all databases support limits via LIMIT N after the WHERE clause
 125                 // well, MSSQL uses SELECT TOP N, so to catch any of those extensions we'll do a quick check for a LIMIT
 126                 // clause and pass $sql through $this->LimitToTopN() which parses the limit clause and passes the result to
 127                 // $this->limitResult();
 128                 if ( preg_match( '/\bLIMIT\s*/i', $sql ) ) {
 129                         // massage LIMIT -> TopN
 130                         $sql = $this->LimitToTopN( $sql ) ;
 131                 }
 132
 133                 // MSSQL doesn't have EXTRACT(epoch FROM XXX)
 134                 if ( preg_match('#\bEXTRACT\s*?\(\s*?EPOCH\s+FROM\b#i', $sql, $matches ) ) {
 135                         // This is same as UNIX_TIMESTAMP, we need to calc # of seconds from 1970
 136                         $sql = str_replace( $matches[0], "DATEDIFF(s,CONVERT(datetime,'1/1/1970'),", $sql );
 137                 }
 138
 139                 // perform query
 140                 $stmt = sqlsrv_query( $this->mConn, $sql );
 141                 if ( $stmt == false ) {
 142                         $message = "A database error has occurred.  Did you forget to run maintenance/update.php after upgrading?  See: http://www.mediawiki.org/wiki/Manual:Upgrading#Run_the_update_script\n" .
 143                                 "Query: " . htmlentities( $sql ) . "\n" .
 144                                 "Function: " . __METHOD__ . "\n";
 145                         // process each error (our driver will give us an array of errors unlike other providers)
 146                         foreach ( sqlsrv_errors() as $error ) {
 147                                 $message .= $message . "ERROR[" . $error['code'] . "] " . $error['message'] . "\n";
 148                         }
 149
 150                         throw new DBUnexpectedError( $this, $message );
 151                 }
 152                 // remember number of rows affected
 153                 $this->mAffectedRows = sqlsrv_rows_affected( $stmt );
 154
 155                 // if it is a SELECT statement, or an insert with a request to output something we want to return a row.
 156                 if ( ( preg_match( '#\bSELECT\s#i', $sql ) ) ||
 157                         ( preg_match( '#\bINSERT\s#i', $sql ) && preg_match( '#\bOUTPUT\s+INSERTED\b#i', $sql ) ) ) {
 158                         // this is essentially a rowset, but Mediawiki calls these 'result'
 159                         // the rowset owns freeing the statement
 160                         $res = new MssqlResult( $stmt );
 161                 } else {
 162                         // otherwise we simply return it was successful, failure throws an exception
 163                         $res = true;
 164                 }
 165                 return $res;
 166         }
 167
 168         function freeResult( $res ) {
 169                 if ( $res instanceof ResultWrapper ) {
 170                         $res = $res->result;
 171                 }
 172                 $res->free();
 173         }
 174
 175         function fetchObject( $res ) {
 176                 if ( $res instanceof ResultWrapper ) {
 177                         $res = $res->result;
 178                 }
 179                 $row = $res->fetch( 'OBJECT' );
 180                 return $row;
 181         }
 182
 183         function getErrors() {
 184                 $strRet = '';
 185                 $retErrors = sqlsrv_errors( SQLSRV_ERR_ALL );
 186                 if ( $retErrors != null ) {
 187                         foreach ( $retErrors as $arrError ) {
 188                                 $strRet .= "SQLState: " . $arrError[ 'SQLSTATE'] . "\n";
 189                                 $strRet .= "Error Code: " . $arrError[ 'code'] . "\n";
 190                                 $strRet .= "Message: " . $arrError[ 'message'] . "\n";
 191                         }
 192                 } else {
 193                         $strRet = "No errors found";
 194                 }
 195                 return $strRet;
 196         }
 197
 198         function fetchRow( $res ) {
 199                 if ( $res instanceof ResultWrapper ) {
 200                         $res = $res->result;
 201                 }
 202                 $row = $res->fetch( SQLSRV_FETCH_BOTH );
 203                 return $row;
 204         }
 205
 206         function numRows( $res ) {
 207                 if ( $res instanceof ResultWrapper ) {
 208                         $res = $res->result;
 209                 }
 210                 return ( $res ) ? $res->numrows() : 0;
 211         }
 212
 213         function numFields( $res ) {
 214                 if ( $res instanceof ResultWrapper ) {
 215                         $res = $res->result;
 216                 }
 217                 return ( $res ) ? $res->numfields() : 0;
 218         }
 219
 220         function fieldName( $res, $n ) {
 221                 if ( $res instanceof ResultWrapper ) {
 222                         $res = $res->result;
 223                 }
 224                 return ( $res ) ? $res->fieldname( $n ) : 0;
 225         }
 226
 227         /**
 228          * This must be called after nextSequenceVal
 229          */
 230         function insertId() {
 231                 return $this->mInsertId;
 232         }
 233
 234         function dataSeek( $res, $row ) {
 235                 if ( $res instanceof ResultWrapper ) {
 236                         $res = $res->result;
 237                 }
 238                 return ( $res ) ? $res->seek( $row ) : false;
 239         }
 240
 241         function lastError() {
 242                 if ( $this->mConn ) {
 243                         return $this->getErrors();
 244                 } else {
 245                         return "No database connection";
 246                 }
 247         }
 248
 249         function lastErrno() {
 250                 $err = sqlsrv_errors( SQLSRV_ERR_ALL );
 251                 if ( $err[0] ) {
 252                         return $err[0]['code'];
 253                 } else {
 254                         return 0;
 255                 }
 256         }
 257
 258         function affectedRows() {
 259                 return $this->mAffectedRows;
 260         }
 261
 262         /**
 263          * SELECT wrapper
 264          *
 265          * @param $table   Mixed: array or string, table name(s) (prefix auto-added)
 266          * @param $vars    Mixed: array or string, field name(s) to be retrieved
 267          * @param $conds   Mixed: array or string, condition(s) for WHERE
 268          * @param $fname   String: calling function name (use __METHOD__) for logs/profiling
 269          * @param $options Array: associative array of options (e.g. array('GROUP BY' => 'page_title')),
 270          *                 see Database::makeSelectOptions code for list of supported stuff
 271          * @param $join_conds Array: Associative array of table join conditions (optional)
 272          *                                                 (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
 273          * @return Mixed: database result resource (feed to Database::fetchObject or whatever), or false on failure
 274          */
 275         function select( $table, $vars, $conds = '', $fname = 'DatabaseMssql::select', $options = array(), $join_conds = array() )
 276         {
 277                 $sql = $this->selectSQLText( $table, $vars, $conds, $fname, $options, $join_conds );
 278                 if ( isset( $options['EXPLAIN'] ) ) {
 279                         sqlsrv_query( $this->mConn, "SET SHOWPLAN_ALL ON;" );
 280                         $ret = $this->query( $sql, $fname );
 281                         sqlsrv_query( $this->mConn, "SET SHOWPLAN_ALL OFF;" );
 282                         return $ret;
 283                 }
 284                 return $this->query( $sql, $fname );
 285         }
 286
 287         /**
 288          * SELECT wrapper
 289          *
 290          * @param $table   Mixed:  Array or string, table name(s) (prefix auto-added)
 291          * @param $vars    Mixed:  Array or string, field name(s) to be retrieved
 292          * @param $conds   Mixed:  Array or string, condition(s) for WHERE
 293          * @param $fname   String: Calling function name (use __METHOD__) for logs/profiling
 294          * @param $options Array:  Associative array of options (e.g. array('GROUP BY' => 'page_title')),
 295          *                 see Database::makeSelectOptions code for list of supported stuff
 296          * @param $join_conds Array: Associative array of table join conditions (optional)
 297          *                    (e.g. array( 'page' => array('LEFT JOIN','page_latest=rev_id') )
 298          * @return string, the SQL text
 299          */
 300         function selectSQLText( $table, $vars, $conds = '', $fname = 'DatabaseMssql::select', $options = array(), $join_conds = array() ) {
 301                 if ( isset( $options['EXPLAIN'] ) ) {
 302                         unset( $options['EXPLAIN'] );
 303                 }
 304                 return parent::selectSQLText(  $table, $vars, $conds, $fname, $options, $join_conds );
 305         }
 306
 307         /**
 308          * Estimate rows in dataset
 309          * Returns estimated count, based on SHOWPLAN_ALL output
 310          * This is not necessarily an accurate estimate, so use sparingly
 311          * Returns -1 if count cannot be found
 312          * Takes same arguments as Database::select()
 313          */
 314         function estimateRowCount( $table, $vars = '*', $conds = '', $fname = 'DatabaseMssql::estimateRowCount', $options = array() ) {
 315                 $options['EXPLAIN'] = true;// http://msdn2.microsoft.com/en-us/library/aa259203.aspx
 316                 $res = $this->select( $table, $vars, $conds, $fname, $options );
 317
 318                 $rows = -1;
 319                 if ( $res ) {
 320                         $row = $this->fetchRow( $res );
 321                         if ( isset( $row['EstimateRows'] ) ) $rows = $row['EstimateRows'];
 322                 }
 323                 return $rows;
 324         }
 325
 326         /**
 327          * Returns information about an index
 328          * If errors are explicitly ignored, returns NULL on failure
 329          */
 330         function indexInfo( $table, $index, $fname = 'DatabaseMssql::indexExists' ) {
 331                 # This does not return the same info as MYSQL would, but that's OK because MediaWiki never uses the
 332                 # returned value except to check for the existance of indexes.
 333                 $sql = "sp_helpindex '" . $table . "'";
 334                 $res = $this->query( $sql, $fname );
 335                 if ( !$res ) {
 336                         return NULL;
 337                 }
 338
 339                 $result = array();
 340                 foreach ( $res as $row ) {
 341                         if ( $row->index_name == $index ) {
 342                                 $row->Non_unique = !stristr( $row->index_description, "unique" );
 343                                 $cols = explode( ", ", $row->index_keys );
 344                                 foreach ( $cols as $col ) {
 345                                         $row->Column_name = trim( $col );
 346                                         $result[] = clone $row;
 347                                 }
 348                         } elseif ( $index == 'PRIMARY' && stristr( $row->index_description, 'PRIMARY' ) ) {
 349                                 $row->Non_unique = 0;
 350                                 $cols = explode( ", ", $row->index_keys );
 351                                 foreach ( $cols as $col ) {
 352                                         $row->Column_name = trim( $col );
 353                                         $result[] = clone $row;
 354                                 }
 355                         }
 356                 }
 357                 return empty( $result ) ? false : $result;
 358         }
 359
 360         /**
 361          * INSERT wrapper, inserts an array into a table
 362          *
 363          * $arrToInsert may be a single associative array, or an array of these with numeric keys, for
 364          * multi-row insert.
 365          *
 366          * Usually aborts on failure
 367          * If errors are explicitly ignored, returns success
 368          */
 369         function insert( $table, $arrToInsert, $fname = 'DatabaseMssql::insert', $options = array() ) {
 370                 # No rows to insert, easy just return now
 371                 if ( !count( $arrToInsert ) ) {
 372                         return true;
 373                 }
 374
 375                 if ( !is_array( $options ) ) {
 376                         $options = array( $options );
 377                 }
 378
 379                 $table = $this->tableName( $table );
 380
 381                 if ( !( isset( $arrToInsert[0] ) && is_array( $arrToInsert[0] ) ) ) {// Not multi row
 382                         $arrToInsert = array( 0 => $arrToInsert );// make everything multi row compatible
 383                 }
 384
 385                 $allOk = true;
 386
 387                 // We know the table we're inserting into, get its identity column
 388                 $identity = null;
 389                 $tableRaw = preg_replace( '#\[([^\]]*)\]#', '$1', $table ); // strip matching square brackets from table name
 390                 $res = $this->doQuery( "SELECT NAME AS idColumn FROM SYS.IDENTITY_COLUMNS WHERE OBJECT_NAME(OBJECT_ID)='{$tableRaw}'" );
 391                 if( $res && $res->numrows() ){
 392                         // There is an identity for this table.
 393                         $identity = array_pop( $res->fetch( SQLSRV_FETCH_ASSOC ) );
 394                 }
 395                 unset( $res );
 396
 397                 foreach ( $arrToInsert as $a ) {
 398                         // start out with empty identity column, this is so we can return it as a result of the insert logic
 399                         $sqlPre = '';
 400                         $sqlPost = '';
 401                         $identityClause = '';
 402
 403                         // if we have an identity column
 404                         if( $identity ) {
 405                                 // iterate through
 406                                 foreach ($a as $k => $v ) {
 407                                         if ( $k == $identity ) {
 408                                                 if( !is_null($v) ){
 409                                                         // there is a value being passed to us, we need to turn on and off inserted identity
 410                                                         $sqlPre = "SET IDENTITY_INSERT $table ON;" ;
 411                                                         $sqlPost = ";SET IDENTITY_INSERT $table OFF;";
 412
 413                                                 } else {
 414                                                         // we can't insert NULL into an identity column, so remove the column from the insert.
 415                                                         unset( $a[$k] );
 416                                                 }
 417                                         }
 418                                 }
 419                                 $identityClause = "OUTPUT INSERTED.$identity "; // we want to output an identity column as result
 420                         }
 421
 422                         $keys = array_keys( $a );
 423
 424                         // INSERT IGNORE is not supported by SQL Server
 425                         // remove IGNORE from options list and set ignore flag to true
 426                         $ignoreClause = false;
 427                         foreach ( $options as $k => $v ) {
 428                                 if ( strtoupper( $v ) == "IGNORE" ) {
 429                                         unset( $options[$k] );
 430                                         $ignoreClause = true;
 431                                 }
 432                         }
 433
 434                         // translate MySQL INSERT IGNORE to something SQL Server can use
 435                         // example:
 436                         // MySQL: INSERT IGNORE INTO user_groups (ug_user,ug_group) VALUES ('1','sysop')
 437                         // MSSQL: IF NOT EXISTS (SELECT * FROM user_groups WHERE ug_user = '1') INSERT INTO user_groups (ug_user,ug_group) VALUES ('1','sysop')
 438                         if ( $ignoreClause ) {
 439                                 $prival = $a[$keys[0]];
 440                                 $sqlPre .= "IF NOT EXISTS (SELECT * FROM $table WHERE $keys[0] = '$prival')";
 441                         }
 442
 443                         // Build the actual query
 444                         $sql = $sqlPre . 'INSERT ' . implode( ' ', $options ) .
 445                                 " INTO $table (" . implode( ',', $keys ) . ") $identityClause VALUES (";
 446
 447                         $first = true;
 448                         foreach ( $a as $value ) {
 449                                 if ( $first ) {
 450                                         $first = false;
 451                                 } else {
 452                                         $sql .= ',';
 453                                 }
 454                                 if ( is_string( $value ) ) {
 455                                         $sql .= $this->addQuotes( $value );
 456                                 } elseif ( is_null( $value ) ) {
 457                                         $sql .= 'null';
 458                                 } elseif ( is_array( $value ) || is_object( $value ) ) {
 459                                         if ( is_object( $value ) && strtolower( get_class( $value ) ) == 'blob' ) {
 460                                                 $sql .= $this->addQuotes( $value );
 461                                         }  else {
 462                                                 $sql .= $this->addQuotes( serialize( $value ) );
 463                                         }
 464                                 } else {
 465                                         $sql .= $value;
 466                                 }
 467                         }
 468                         $sql .= ')' . $sqlPost;
 469
 470                         // Run the query
 471                         $ret = sqlsrv_query( $this->mConn, $sql );
 472
 473                         if ( $ret === false ) {
 474                                 throw new DBQueryError( $this, $this->getErrors(), $this->lastErrno(), $sql, $fname );
 475                         } elseif ( $ret != NULL ) {
 476                                 // remember number of rows affected
 477                                 $this->mAffectedRows = sqlsrv_rows_affected( $ret );
 478                                 if ( !is_null($identity) ) {
 479                                         // then we want to get the identity column value we were assigned and save it off
 480                                         $row = sqlsrv_fetch_object( $ret );
 481                                         $this->mInsertId = $row->$identity;
 482                                 }
 483                                 sqlsrv_free_stmt( $ret );
 484                                 continue;
 485                         }
 486                         $allOk = false;
 487                 }
 488                 return $allOk;
 489         }
 490
 491         /**
 492          * INSERT SELECT wrapper
 493          * $varMap must be an associative array of the form array( 'dest1' => 'source1', ...)
 494          * Source items may be literals rather than field names, but strings should be quoted with Database::addQuotes()
 495          * $conds may be "*" to copy the whole table
 496          * srcTable may be an array of tables.
 497          */
 498         function insertSelect( $destTable, $srcTable, $varMap, $conds, $fname = 'DatabaseMssql::insertSelect',
 499                 $insertOptions = array(), $selectOptions = array() ) {
 500                 $ret = parent::insertSelect( $destTable, $srcTable, $varMap, $conds, $fname, $insertOptions, $selectOptions );
 501
 502                 if ( $ret === false ) {
 503                         throw new DBQueryError( $this, $this->getErrors(), $this->lastErrno(), /*$sql*/ '', $fname );
 504                 } elseif ( $ret != NULL ) {
 505                         // remember number of rows affected
 506                         $this->mAffectedRows = sqlsrv_rows_affected( $ret );
 507                         return $ret;
 508                 }
 509                 return NULL;
 510         }
 511
 512         /**
 513          * Return the next in a sequence, save the value for retrieval via insertId()
 514          */
 515         function nextSequenceValue( $seqName ) {
 516                 if ( !$this->tableExists( 'sequence_' . $seqName ) ) {
 517                         sqlsrv_query( $this->mConn, "CREATE TABLE [sequence_$seqName] (id INT NOT NULL IDENTITY PRIMARY KEY, junk varchar(10) NULL)" );
 518                 }
 519                 sqlsrv_query( $this->mConn, "INSERT INTO [sequence_$seqName] (junk) VALUES ('')" );
 520                 $ret = sqlsrv_query( $this->mConn, "SELECT TOP 1 id FROM [sequence_$seqName] ORDER BY id DESC" );
 521                 $row = sqlsrv_fetch_array( $ret, SQLSRV_FETCH_ASSOC );// KEEP ASSOC THERE, weird weird bug dealing with the return value if you don't
 522
 523                 sqlsrv_free_stmt( $ret );
 524                 $this->mInsertId = $row['id'];
 525                 return $row['id'];
 526         }
 527
 528         /**
 529          * Return the current value of a sequence. Assumes it has ben nextval'ed in this session.
 530          */
 531         function currentSequenceValue( $seqName ) {
 532                 $ret = sqlsrv_query( $this->mConn, "SELECT TOP 1 id FROM [sequence_$seqName] ORDER BY id DESC" );
 533                 if ( $ret !== false ) {
 534                         $row = sqlsrv_fetch_array( $ret );
 535                         sqlsrv_free_stmt( $ret );
 536                         return $row['id'];
 537                 } else {
 538                         return $this->nextSequenceValue( $seqName );
 539                 }
 540         }
 541
 542
 543         # REPLACE query wrapper
 544         # MSSQL simulates this with a DELETE followed by INSERT
 545         # $row is the row to insert, an associative array
 546         # $uniqueIndexes is an array of indexes. Each element may be either a
 547         # field name or an array of field names
 548         #
 549         # It may be more efficient to leave off unique indexes which are unlikely to collide.
 550         # However if you do this, you run the risk of encountering errors which wouldn't have
 551         # occurred in MySQL
 552         function replace( $table, $uniqueIndexes, $rows, $fname = 'DatabaseMssql::replace' ) {
 553                 $table = $this->tableName( $table );
 554
 555                 if ( count( $rows ) == 0 ) {
 556                         return;
 557                 }
 558
 559                 # Single row case
 560                 if ( !is_array( reset( $rows ) ) ) {
 561                         $rows = array( $rows );
 562                 }
 563
 564                 foreach ( $rows as $row ) {
 565                         # Delete rows which collide
 566                         if ( $uniqueIndexes ) {
 567                                 $sql = "DELETE FROM $table WHERE ";
 568                                 $first = true;
 569                                 foreach ( $uniqueIndexes as $index ) {
 570                                         if ( $first ) {
 571                                                 $first = false;
 572                                                 $sql .= "(";
 573                                         } else {
 574                                                 $sql .= ') OR (';
 575                                         }
 576                                         if ( is_array( $index ) ) {
 577                                                 $first2 = true;
 578                                                 foreach ( $index as $col ) {
 579                                                         if ( $first2 ) {
 580                                                                 $first2 = false;
 581                                                         } else {
 582                                                                 $sql .= ' AND ';
 583                                                         }
 584                                                         $sql .= $col . '=' . $this->addQuotes( $row[$col] );
 585                                                 }
 586                                         } else {
 587                                                 $sql .= $index . '=' . $this->addQuotes( $row[$index] );
 588                                         }
 589                                 }
 590                                 $sql .= ')';
 591                                 $this->query( $sql, $fname );
 592                         }
 593
 594                         # Now insert the row
 595                         $sql = "INSERT INTO $table (" . $this->makeList( array_keys( $row ), LIST_NAMES ) . ') VALUES (' .
 596                                 $this->makeList( $row, LIST_COMMA ) . ')';
 597                         $this->query( $sql, $fname );
 598                 }
 599         }
 600
 601         # Returns the size of a text field, or -1 for "unlimited"
 602         function textFieldSize( $table, $field ) {
 603                 $table = $this->tableName( $table );
 604                 $sql = "SELECT CHARACTER_MAXIMUM_LENGTH,DATA_TYPE FROM INFORMATION_SCHEMA.Columns
 605                         WHERE TABLE_NAME = '$table' AND COLUMN_NAME = '$field'";
 606                 $res = $this->query( $sql );
 607                 $row = $this->fetchRow( $res );
 608                 $size = -1;
 609                 if ( strtolower( $row['DATA_TYPE'] ) != 'text' ) {
 610                         $size = $row['CHARACTER_MAXIMUM_LENGTH'];
 611                 }
 612                 return $size;
 613         }
 614
 615         /**
 616          * Construct a LIMIT query with optional offset
 617          * This is used for query pages
 618          * $sql string SQL query we will append the limit too
 619          * $limit integer the SQL limit
 620          * $offset integer the SQL offset (default false)
 621          */
 622         function limitResult( $sql, $limit, $offset = false ) {
 623                 if ( $offset === false || $offset == 0 ) {
 624                         if ( strpos( $sql, "SELECT" ) === false ) {
 625                                 return "TOP {$limit} " . $sql;
 626                         } else {
 627                                 return preg_replace( '/\bSELECT(\s*DISTINCT)?\b/Dsi', 'SELECT$1 TOP ' . $limit, $sql, 1 );
 628                         }
 629                 } else {
 630                         $sql = '
 631                                 SELECT * FROM (
 632                                   SELECT sub2.*, ROW_NUMBER() OVER(ORDER BY sub2.line2) AS line3 FROM (
 633                                         SELECT 1 AS line2, sub1.* FROM (' . $sql . ') AS sub1
 634                                   ) as sub2
 635                                 ) AS sub3
 636                                 WHERE line3 BETWEEN ' . ( $offset + 1 ) . ' AND ' . ( $offset + $limit );
 637                         return $sql;
 638                 }
 639         }
 640
 641         // If there is a limit clause, parse it, strip it, and pass the remaining sql through limitResult()
 642         // with the appropriate parameters. Not the prettiest solution, but better than building a whole new parser.
 643         // This exists becase there are still too many extensions that don't use dynamic sql generation.
 644         function LimitToTopN( $sql ) {
 645                 // Matches: LIMIT {[offset,] row_count | row_count OFFSET offset}
 646                 $pattern = '/\bLIMIT\s+((([0-9]+)\s*,\s*)?([0-9]+)(\s+OFFSET\s+([0-9]+))?)/i';
 647                 if ( preg_match( $pattern, $sql, $matches ) ) {
 648                         // row_count = $matches[4]
 649                         $row_count = $matches[4];
 650                         // offset = $matches[3] OR $matches[6]
 651                         $offset = $matches[3] or
 652                                 $offset = $matches[6] or
 653                                 $offset = false;
 654
 655                         // strip the matching LIMIT clause out
 656                         $sql = str_replace( $matches[0], '', $sql );
 657                         return $this->limitResult( $sql, $row_count, $offset );
 658                 }
 659                 return $sql;
 660         }
 661
 662         // MSSQL does support this, but documentation is too thin to make a generalized
 663         // function for this. Apparently UPDATE TOP (N) works, but the sort order
 664         // may not be what we're expecting so the top n results may be a random selection.
 665         // TODO: Implement properly.
 666         function limitResultForUpdate( $sql, $num ) {
 667                 return $sql;
 668         }
 669
 670         function timestamp( $ts = 0 ) {
 671                 return wfTimestamp( TS_ISO_8601, $ts );
 672         }
 673
 674         /**
 675          * @return string wikitext of a link to the server software's web site
 676          */
 677         public static function getSoftwareLink() {
 678                 return "[http://www.microsoft.com/sql/ MS SQL Server]";
 679         }
 680
 681         /**
 682          * @return string Version information from the database
 683          */
 684         function getServerVersion() {
 685                 $server_info = sqlsrv_server_info( $this->mConn );
 686                 $version = 'Error';
 687                 if ( isset( $server_info['SQLServerVersion'] ) ) {
 688                         $version = $server_info['SQLServerVersion'];
 689                 }
 690                 return $version;
 691         }
 692
 693         function tableExists ( $table, $schema = false ) {
 694                 $res = sqlsrv_query( $this->mConn, "SELECT * FROM information_schema.tables
 695                         WHERE table_type='BASE TABLE' AND table_name = '$table'" );
 696                 if ( $res === false ) {
 697                         print( "Error in tableExists query: " . $this->getErrors() );
 698                         return false;
 699                 }
 700                 if ( sqlsrv_fetch( $res ) ) {
 701                         return true;
 702                 } else {
 703                         return false;
 704                 }
 705         }
 706
 707         /**
 708          * Query whether a given column exists in the mediawiki schema
 709          */
 710         function fieldExists( $table, $field, $fname = 'DatabaseMssql::fieldExists' ) {
 711                 $table = $this->tableName( $table );
 712                 $res = sqlsrv_query( $this->mConn, "SELECT DATA_TYPE FROM INFORMATION_SCHEMA.Columns
 713                         WHERE TABLE_NAME = '$table' AND COLUMN_NAME = '$field'" );
 714                 if ( $res === false ) {
 715                         print( "Error in fieldExists query: " . $this->getErrors() );
 716                         return false;
 717                 }
 718                 if ( sqlsrv_fetch( $res ) ) {
 719                         return true;
 720                 } else {
 721                         return false;
 722                 }
 723         }
 724
 725         function fieldInfo( $table, $field ) {
 726                 $table = $this->tableName( $table );
 727                 $res = sqlsrv_query( $this->mConn, "SELECT * FROM INFORMATION_SCHEMA.Columns
 728                         WHERE TABLE_NAME = '$table' AND COLUMN_NAME = '$field'" );
 729                 if ( $res === false ) {
 730                         print( "Error in fieldInfo query: " . $this->getErrors() );
 731                         return false;
 732                 }
 733                 $meta = $this->fetchRow( $res );
 734                 if ( $meta ) {
 735                         return new MssqlField( $meta );
 736                 }
 737                 return false;
 738         }
 739
 740         /**
 741          * Begin a transaction, committing any previously open transaction
 742          */
 743         function begin( $fname = 'DatabaseMssql::begin' ) {
 744                 sqlsrv_begin_transaction( $this->mConn );
 745                 $this->mTrxLevel = 1;
 746         }
 747
 748         /**
 749          * End a transaction
 750          */
 751         function commit( $fname = 'DatabaseMssql::commit' ) {
 752                 sqlsrv_commit( $this->mConn );
 753                 $this->mTrxLevel = 0;
 754         }
 755
 756         /**
 757          * Rollback a transaction.
 758          * No-op on non-transactional databases.
 759          */
 760         function rollback( $fname = 'DatabaseMssql::rollback' ) {
 761                 sqlsrv_rollback( $this->mConn );
 762                 $this->mTrxLevel = 0;
 763         }
 764
 765         function setup_database() {
 766                 global $wgDBuser;
 767
 768                 // Make sure that we can write to the correct schema
 769                 $ctest = "mediawiki_test_table";
 770                 if ( $this->tableExists( $ctest ) ) {
 771                         $this->doQuery( "DROP TABLE $ctest" );
 772                 }
 773                 $SQL = "CREATE TABLE $ctest (a int)";
 774                 $res = $this->doQuery( $SQL );
 775                 if ( !$res ) {
 776                         print "<b>FAILED</b>. Make sure that the user " . htmlspecialchars( $wgDBuser ) . " can write to the database</li>\n";
 777                         die();
 778                 }
 779                 $this->doQuery( "DROP TABLE $ctest" );
 780
 781                 $res = $this->sourceFile( "../maintenance/mssql/tables.sql" );
 782                 if ( $res !== true ) {
 783                         echo " <b>FAILED</b></li>";
 784                         die( htmlspecialchars( $res ) );
 785                 }
 786
 787                 # Avoid the non-standard "REPLACE INTO" syntax
 788                 $f = fopen( "../maintenance/interwiki.sql", 'r' );
 789                 if ( $f == false ) {
 790                         die( "<li>Could not find the interwiki.sql file" );
 791                 }
 792                 # We simply assume it is already empty as we have just created it
 793                 $SQL = "INSERT INTO interwiki(iw_prefix,iw_url,iw_local) VALUES ";
 794                 while ( ! feof( $f ) ) {
 795                         $line = fgets( $f, 1024 );
 796                         $matches = array();
 797                         if ( !preg_match( '/^\s*(\(.+?),(\d)\)/', $line, $matches ) ) {
 798                                 continue;
 799                         }
 800                         $this->query( "$SQL $matches[1],$matches[2])" );
 801                 }
 802                 print " (table interwiki successfully populated)...\n";
 803
 804                 $this->commit();
 805         }
 806
 807         /**
 808          * Escapes a identifier for use inm SQL.
 809          * Throws an exception if it is invalid.
 810          * Reference: http://msdn.microsoft.com/en-us/library/aa224033%28v=SQL.80%29.aspx
 811          */
 812         private function escapeIdentifier( $identifier ) {
 813                 if ( strlen( $identifier ) == 0 ) {
 814                         throw new MWException( "An identifier must not be empty" );
 815                 }
 816                 if ( strlen( $identifier ) > 128 ) {
 817                         throw new MWException( "The identifier '$identifier' is too long (max. 128)" );
 818                 }
 819                 if ( ( strpos( $identifier, '[' ) !== false ) || ( strpos( $identifier, ']' ) !== false ) ) {
 820                         // It may be allowed if you quoted with double quotation marks, but that would break if QUOTED_IDENTIFIER is OFF
 821                         throw new MWException( "You can't use square brackers in the identifier '$identifier'" );
 822                 }
 823                 return "[$identifier]";
 824         }
 825
 826         /**
 827          * Initial setup.
 828          * Precondition: This object is connected as the superuser.
 829          * Creates the database, schema, user and login.
 830          */
 831         function initial_setup( $dbName, $newUser, $loginPassword ) {
 832                 $dbName = $this->escapeIdentifier( $dbName );
 833
 834                 // It is not clear what can be used as a login,
 835                 // From http://msdn.microsoft.com/en-us/library/ms173463.aspx
 836                 // a sysname may be the same as an identifier.
 837                 $newUser = $this->escapeIdentifier( $newUser );
 838                 $loginPassword = $this->addQuotes( $loginPassword );
 839
 840                 $this->doQuery("CREATE DATABASE $dbName;");
 841                 $this->doQuery("USE $dbName;");
 842                 $this->doQuery("CREATE SCHEMA $dbName;");
 843                 $this->doQuery("
 844                                                 CREATE
 845                                                         LOGIN $newUser
 846                                                 WITH
 847                                                         PASSWORD=$loginPassword
 848                                                 ;
 849                                         ");
 850                 $this->doQuery("
 851                                                 CREATE
 852                                                         USER $newUser
 853                                                 FOR
 854                                                         LOGIN $newUser
 855                                                 WITH
 856                                                         DEFAULT_SCHEMA=$dbName
 857                                                 ;
 858                                         ");
 859                 $this->doQuery("
 860                                                 GRANT
 861                                                         BACKUP DATABASE,
 862                                                         BACKUP LOG,
 863                                                         CREATE DEFAULT,
 864                                                         CREATE FUNCTION,
 865                                                         CREATE PROCEDURE,
 866                                                         CREATE RULE,
 867                                                         CREATE TABLE,
 868                                                         CREATE VIEW,
 869                                                         CREATE FULLTEXT CATALOG
 870                                                 ON
 871                                                         DATABASE::$dbName
 872                                                 TO $newUser
 873                                                 ;
 874                                         ");
 875                 $this->doQuery("
 876                                                 GRANT
 877                                                         CONTROL
 878                                                 ON
 879                                                         SCHEMA::$dbName
 880                                                 TO $newUser
 881                                                 ;
 882                                         ");
 883
 884
 885         }
 886
 887         function encodeBlob( $b ) {
 888         // we can't have zero's and such, this is a simple encoding to make sure we don't barf
 889                 return base64_encode( $b );
 890         }
 891
 892         function decodeBlob( $b ) {
 893         // we can't have zero's and such, this is a simple encoding to make sure we don't barf
 894         return base64_decode( $b );
 895         }
 896
 897         /**
 898          * @private
 899          */
 900         function tableNamesWithUseIndexOrJOIN( $tables, $use_index = array(), $join_conds = array() ) {
 901                 $ret = array();
 902                 $retJOIN = array();
 903                 $use_index_safe = is_array( $use_index ) ? $use_index : array();
 904                 $join_conds_safe = is_array( $join_conds ) ? $join_conds : array();
 905                 foreach ( $tables as $table ) {
 906                         // Is there a JOIN and INDEX clause for this table?
 907                         if ( isset( $join_conds_safe[$table] ) && isset( $use_index_safe[$table] ) ) {
 908                                 $tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table );
 909                                 $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$table] ) );
 910                                 $tableClause .= ' ON (' . $this->makeList( (array)$join_conds_safe[$table][1], LIST_AND ) . ')';
 911                                 $retJOIN[] = $tableClause;
 912                         // Is there an INDEX clause?
 913                         } elseif ( isset( $use_index_safe[$table] ) ) {
 914                                 $tableClause = $this->tableName( $table );
 915                                 $tableClause .= ' ' . $this->useIndexClause( implode( ',', (array)$use_index_safe[$table] ) );
 916                                 $ret[] = $tableClause;
 917                         // Is there a JOIN clause?
 918                         } elseif ( isset( $join_conds_safe[$table] ) ) {
 919                                 $tableClause = $join_conds_safe[$table][0] . ' ' . $this->tableName( $table );
 920                                 $tableClause .= ' ON (' . $this->makeList( (array)$join_conds_safe[$table][1], LIST_AND ) . ')';
 921                                 $retJOIN[] = $tableClause;
 922                         } else {
 923                                 $tableClause = $this->tableName( $table );
 924                                 $ret[] = $tableClause;
 925                         }
 926                 }
 927                 // We can't separate explicit JOIN clauses with ',', use ' ' for those
 928                 $straightJoins = !empty( $ret ) ? implode( ',', $ret ) : "";
 929                 $otherJoins = !empty( $retJOIN ) ? implode( ' ', $retJOIN ) : "";
 930                 // Compile our final table clause
 931                 return implode( ' ', array( $straightJoins, $otherJoins ) );
 932         }
 933
 934         function strencode( $s ) { # Should not be called by us
 935                 return str_replace( "'", "''", $s );
 936         }
 937
 938         function addQuotes( $s ) {
 939                 if ( $s instanceof Blob ) {
 940                         return "'" . $s->fetch( $s ) . "'";
 941                 } else {
 942                         return parent::addQuotes( $s );
 943                 }
 944         }
 945
 946         public function addIdentifierQuotes( $s ) {
 947                 // http://msdn.microsoft.com/en-us/library/aa223962.aspx
 948                 return '[' . $s . ']';
 949         }
 950
 951         public function isQuotedIdentifier( $name ) {
 952                 return $name[0] == '[' && substr( $name, -1, 1 ) == ']';
 953         }
 954
 955         function selectDB( $db ) {
 956                 return ( $this->query( "SET DATABASE $db" ) !== false );
 957         }
 958
 959         /**
 960          * @private
 961          *
 962          * @param $options Array: an associative array of options to be turned into
 963          *                 an SQL query, valid keys are listed in the function.
 964          * @return Array
 965          */
 966         function makeSelectOptions( $options ) {
 967                 $tailOpts = '';
 968                 $startOpts = '';
 969
 970                 $noKeyOptions = array();
 971                 foreach ( $options as $key => $option ) {
 972                         if ( is_numeric( $key ) ) {
 973                                 $noKeyOptions[$option] = true;
 974                         }
 975                 }
 976
 977                 if ( isset( $options['GROUP BY'] ) ) {
 978                         $tailOpts .= " GROUP BY {$options['GROUP BY']}";
 979                 }
 980                 if ( isset( $options['HAVING'] ) ) {
 981                         $tailOpts .= " HAVING {$options['GROUP BY']}";
 982                 }
 983                 if ( isset( $options['ORDER BY'] ) ) {
 984                         $tailOpts .= " ORDER BY {$options['ORDER BY']}";
 985                 }
 986
 987                 if ( isset( $noKeyOptions['DISTINCT'] ) && isset( $noKeyOptions['DISTINCTROW'] ) ) {
 988                         $startOpts .= 'DISTINCT';
 989                 }
 990
 991                 // we want this to be compatible with the output of parent::makeSelectOptions()
 992                 return array( $startOpts, '' , $tailOpts, '' );
 993         }
 994
 995         /**
 996          * Get the type of the DBMS, as it appears in $wgDBtype.
 997          */
 998         function getType(){
 999                 return 'mssql';
1000         }
1001
1002         function buildConcat( $stringList ) {
1003                 return implode( ' + ', $stringList );
1004         }
1005
1006         public function getSearchEngine() {
1007                 return "SearchMssql";
1008         }
1009
1010         /**
1011          * Since MSSQL doesn't recognize the infinity keyword, set date manually.
1012          * @todo Remove magic date
1013          */
1014         public function getInfinity() {
1015                 return '3000-01-31 00:00:00.000';
1016         }
1017
1018 } // end DatabaseMssql class
1019
1020 /**
1021  * Utility class.
1022  *
1023  * @ingroup Database
1024  */
1025 class MssqlField implements Field {
1026         private $name, $tablename, $default, $max_length, $nullable, $type;
1027         function __construct ( $info ) {
1028                 $this->name = $info['COLUMN_NAME'];
1029                 $this->tablename = $info['TABLE_NAME'];
1030                 $this->default = $info['COLUMN_DEFAULT'];
1031                 $this->max_length = $info['CHARACTER_MAXIMUM_LENGTH'];
1032                 $this->nullable = !( strtolower( $info['IS_NULLABLE'] ) == 'no' );
1033                 $this->type = $info['DATA_TYPE'];
1034         }
1035
1036         function name() {
1037                 return $this->name;
1038         }
1039
1040         function tableName() {
1041                 return $this->tableName;
1042         }
1043
1044         function defaultValue() {
1045                 return $this->default;
1046         }
1047
1048         function maxLength() {
1049                 return $this->max_length;
1050         }
1051
1052         function isNullable() {
1053                 return $this->nullable;
1054         }
1055
1056         function type() {
1057                 return $this->type;
1058         }
1059 }
1060
1061 /**
1062  * The MSSQL PHP driver doesn't support sqlsrv_num_rows, so we recall all rows into an array and maintain our
1063  * own cursor index into that array...This is similar to the way the Oracle driver handles this same issue
1064  *
1065  * @ingroup Database
1066  */
1067 class MssqlResult {
1068
1069         public function __construct( $queryresult = false ) {
1070                 $this->mCursor = 0;
1071                 $this->mRows = array();
1072                 $this->mNumFields = sqlsrv_num_fields( $queryresult );
1073                 $this->mFieldMeta = sqlsrv_field_metadata( $queryresult );
1074
1075                 $rows = sqlsrv_fetch_array( $queryresult, SQLSRV_FETCH_ASSOC );
1076
1077                 foreach( $rows as $row ) {
1078                         if ( $row !== null ) {
1079                                 foreach ( $row as $k => $v ) {
1080                                         if ( is_object( $v ) && method_exists( $v, 'format' ) ) {// DateTime Object
1081                                                 $row[$k] = $v->format( "Y-m-d\TH:i:s\Z" );
1082                                         }
1083                                 }
1084                                 $this->mRows[] = $row;// read results into memory, cursors are not supported
1085                         }
1086                 }
1087                 $this->mRowCount = count( $this->mRows );
1088                 sqlsrv_free_stmt( $queryresult );
1089         }
1090
1091         private function array_to_obj( $array, &$obj ) {
1092                 foreach ( $array as $key => $value ) {
1093                         if ( is_array( $value ) ) {
1094                                 $obj->$key = new stdClass();
1095                                 $this->array_to_obj( $value, $obj->$key );
1096                         } else {
1097                                 if ( !empty( $key ) ) {
1098                                         $obj->$key = $value;
1099                                 }
1100                         }
1101                 }
1102                 return $obj;
1103         }
1104
1105         public function fetch( $mode = SQLSRV_FETCH_BOTH, $object_class = 'stdClass' ) {
1106                 if ( $this->mCursor >= $this->mRowCount || $this->mRowCount == 0 ) {
1107                         return false;
1108                 }
1109                 $arrNum = array();
1110                 if ( $mode == SQLSRV_FETCH_NUMERIC || $mode == SQLSRV_FETCH_BOTH ) {
1111                         foreach ( $this->mRows[$this->mCursor] as $value ) {
1112                                 $arrNum[] = $value;
1113                         }
1114                 }
1115                 switch( $mode ) {
1116                         case SQLSRV_FETCH_ASSOC:
1117                                 $ret = $this->mRows[$this->mCursor];
1118                                 break;
1119                         case SQLSRV_FETCH_NUMERIC:
1120                                 $ret = $arrNum;
1121                                 break;
1122                         case 'OBJECT':
1123                                 $o = new $object_class;
1124                                 $ret = $this->array_to_obj( $this->mRows[$this->mCursor], $o );
1125                                 break;
1126                         case SQLSRV_FETCH_BOTH:
1127                         default:
1128                                 $ret = $this->mRows[$this->mCursor] + $arrNum;
1129                                 break;
1130                 }
1131
1132                 $this->mCursor++;
1133                 return $ret;
1134         }
1135
1136         public function get( $pos, $fld ) {
1137                 return $this->mRows[$pos][$fld];
1138         }
1139
1140         public function numrows() {
1141                 return $this->mRowCount;
1142         }
1143
1144         public function seek( $iRow ) {
1145                 $this->mCursor = min( $iRow, $this->mRowCount );
1146         }
1147
1148         public function numfields() {
1149                 return $this->mNumFields;
1150         }
1151
1152         public function fieldname( $nr ) {
1153                 $arrKeys = array_keys( $this->mRows[0] );
1154                 return $arrKeys[$nr];
1155         }
1156
1157         public function fieldtype( $nr ) {
1158                 $i = 0;
1159                 $intType = -1;
1160                 foreach ( $this->mFieldMeta as $meta ) {
1161                         if ( $nr == $i ) {
1162                                 $intType = $meta['Type'];
1163                                 break;
1164                         }
1165                         $i++;
1166                 }
1167                 // http://msdn.microsoft.com/en-us/library/cc296183.aspx contains type table
1168                 switch( $intType ) {
1169                         case SQLSRV_SQLTYPE_BIGINT:             $strType = 'bigint'; break;
1170                         case SQLSRV_SQLTYPE_BINARY:             $strType = 'binary'; break;
1171                         case SQLSRV_SQLTYPE_BIT:                        $strType = 'bit'; break;
1172                         case SQLSRV_SQLTYPE_CHAR:                       $strType = 'char'; break;
1173                         case SQLSRV_SQLTYPE_DATETIME:           $strType = 'datetime'; break;
1174                         case SQLSRV_SQLTYPE_DECIMAL/*($precision, $scale)*/: $strType = 'decimal'; break;
1175                         case SQLSRV_SQLTYPE_FLOAT:                      $strType = 'float'; break;
1176                         case SQLSRV_SQLTYPE_IMAGE:                      $strType = 'image'; break;
1177                         case SQLSRV_SQLTYPE_INT:                        $strType = 'int'; break;
1178                         case SQLSRV_SQLTYPE_MONEY:                      $strType = 'money'; break;
1179                         case SQLSRV_SQLTYPE_NCHAR/*($charCount)*/: $strType = 'nchar'; break;
1180                         case SQLSRV_SQLTYPE_NUMERIC/*($precision, $scale)*/: $strType = 'numeric'; break;
1181                         case SQLSRV_SQLTYPE_NVARCHAR/*($charCount)*/: $strType = 'nvarchar'; break;
1182                         // case SQLSRV_SQLTYPE_NVARCHAR('max'): $strType = 'nvarchar(MAX)'; break;
1183                         case SQLSRV_SQLTYPE_NTEXT:                      $strType = 'ntext'; break;
1184                         case SQLSRV_SQLTYPE_REAL:                       $strType = 'real'; break;
1185                         case SQLSRV_SQLTYPE_SMALLDATETIME:      $strType = 'smalldatetime'; break;
1186                         case SQLSRV_SQLTYPE_SMALLINT:           $strType = 'smallint'; break;
1187                         case SQLSRV_SQLTYPE_SMALLMONEY:         $strType = 'smallmoney'; break;
1188                         case SQLSRV_SQLTYPE_TEXT:                       $strType = 'text'; break;
1189                         case SQLSRV_SQLTYPE_TIMESTAMP:          $strType = 'timestamp'; break;
1190                         case SQLSRV_SQLTYPE_TINYINT:            $strType = 'tinyint'; break;
1191                         case SQLSRV_SQLTYPE_UNIQUEIDENTIFIER: $strType = 'uniqueidentifier'; break;
1192                         case SQLSRV_SQLTYPE_UDT:                        $strType = 'UDT'; break;
1193                         case SQLSRV_SQLTYPE_VARBINARY/*($byteCount)*/: $strType = 'varbinary'; break;
1194                         // case SQLSRV_SQLTYPE_VARBINARY('max'): $strType = 'varbinary(MAX)'; break;
1195                         case SQLSRV_SQLTYPE_VARCHAR/*($charCount)*/: $strType = 'varchar'; break;
1196                         // case SQLSRV_SQLTYPE_VARCHAR('max'): $strType = 'varchar(MAX)'; break;
1197                         case SQLSRV_SQLTYPE_XML:                        $strType = 'xml'; break;
1198                         default: $strType = $intType;
1199                 }
1200                 return $strType;
1201         }
1202
1203         public function free() {
1204                 unset( $this->mRows );
1205                 return;
1206         }
1207 }