Merge "jquery.accessKeyLabel: make modifier info public"
[lhc/web/wiklou.git] / includes / db / DatabaseMysqlBase.php
1 <?php
2 /**
3 * This is the MySQL database abstraction layer.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 * http://www.gnu.org/copyleft/gpl.html
19 *
20 * @file
21 * @ingroup Database
22 */
23
24 /**
25 * Database abstraction object for MySQL.
26 * Defines methods independent on used MySQL extension.
27 *
28 * @ingroup Database
29 * @since 1.22
30 * @see Database
31 */
32 abstract class DatabaseMysqlBase extends Database {
33 /** @var MysqlMasterPos */
34 protected $lastKnownSlavePos;
35 /** @var string Method to detect slave lag */
36 protected $lagDetectionMethod;
37
38 /** @var string|null */
39 private $serverVersion = null;
40
41 /**
42 * Additional $params include:
43 * - lagDetectionMethod : set to one of (Seconds_Behind_Master,pt-heartbeat).
44 * pt-heartbeat assumes the table is at heartbeat.heartbeat
45 * and uses UTC timestamps in the heartbeat.ts column.
46 * (https://www.percona.com/doc/percona-toolkit/2.2/pt-heartbeat.html)
47 * @param array $params
48 */
49 function __construct( array $params ) {
50 parent::__construct( $params );
51
52 $this->lagDetectionMethod = isset( $params['lagDetectionMethod'] )
53 ? $params['lagDetectionMethod']
54 : 'Seconds_Behind_Master';
55 }
56
57 /**
58 * @return string
59 */
60 function getType() {
61 return 'mysql';
62 }
63
64 /**
65 * @param string $server
66 * @param string $user
67 * @param string $password
68 * @param string $dbName
69 * @throws Exception|DBConnectionError
70 * @return bool
71 */
72 function open( $server, $user, $password, $dbName ) {
73 global $wgAllDBsAreLocalhost, $wgSQLMode;
74
75 # Close/unset connection handle
76 $this->close();
77
78 # Debugging hack -- fake cluster
79 $realServer = $wgAllDBsAreLocalhost ? 'localhost' : $server;
80 $this->mServer = $server;
81 $this->mUser = $user;
82 $this->mPassword = $password;
83 $this->mDBname = $dbName;
84
85 $this->installErrorHandler();
86 try {
87 $this->mConn = $this->mysqlConnect( $realServer );
88 } catch ( Exception $ex ) {
89 $this->restoreErrorHandler();
90 throw $ex;
91 }
92 $error = $this->restoreErrorHandler();
93
94 # Always log connection errors
95 if ( !$this->mConn ) {
96 if ( !$error ) {
97 $error = $this->lastError();
98 }
99 wfLogDBError(
100 "Error connecting to {db_server}: {error}",
101 $this->getLogContext( array(
102 'method' => __METHOD__,
103 'error' => $error,
104 ) )
105 );
106 wfDebug( "DB connection error\n" .
107 "Server: $server, User: $user, Password: " .
108 substr( $password, 0, 3 ) . "..., error: " . $error . "\n" );
109
110 $this->reportConnectionError( $error );
111 }
112
113 if ( $dbName != '' ) {
114 MediaWiki\suppressWarnings();
115 $success = $this->selectDB( $dbName );
116 MediaWiki\restoreWarnings();
117 if ( !$success ) {
118 wfLogDBError(
119 "Error selecting database {db_name} on server {db_server}",
120 $this->getLogContext( array(
121 'method' => __METHOD__,
122 ) )
123 );
124 wfDebug( "Error selecting database $dbName on server {$this->mServer} " .
125 "from client host " . wfHostname() . "\n" );
126
127 $this->reportConnectionError( "Error selecting database $dbName" );
128 }
129 }
130
131 // Tell the server what we're communicating with
132 if ( !$this->connectInitCharset() ) {
133 $this->reportConnectionError( "Error setting character set" );
134 }
135
136 // Abstract over any insane MySQL defaults
137 $set = array( 'group_concat_max_len = 262144' );
138 // Set SQL mode, default is turning them all off, can be overridden or skipped with null
139 if ( is_string( $wgSQLMode ) ) {
140 $set[] = 'sql_mode = ' . $this->addQuotes( $wgSQLMode );
141 }
142 // Set any custom settings defined by site config
143 // (e.g. https://dev.mysql.com/doc/refman/4.1/en/innodb-parameters.html)
144 foreach ( $this->mSessionVars as $var => $val ) {
145 // Escape strings but not numbers to avoid MySQL complaining
146 if ( !is_int( $val ) && !is_float( $val ) ) {
147 $val = $this->addQuotes( $val );
148 }
149 $set[] = $this->addIdentifierQuotes( $var ) . ' = ' . $val;
150 }
151
152 if ( $set ) {
153 // Use doQuery() to avoid opening implicit transactions (DBO_TRX)
154 $success = $this->doQuery( 'SET ' . implode( ', ', $set ) );
155 if ( !$success ) {
156 wfLogDBError(
157 'Error setting MySQL variables on server {db_server} (check $wgSQLMode)',
158 $this->getLogContext( array(
159 'method' => __METHOD__,
160 ) )
161 );
162 $this->reportConnectionError(
163 'Error setting MySQL variables on server {db_server} (check $wgSQLMode)' );
164 }
165 }
166
167 $this->mOpened = true;
168
169 return true;
170 }
171
172 /**
173 * Set the character set information right after connection
174 * @return bool
175 */
176 protected function connectInitCharset() {
177 global $wgDBmysql5;
178
179 if ( $wgDBmysql5 ) {
180 // Tell the server we're communicating with it in UTF-8.
181 // This may engage various charset conversions.
182 return $this->mysqlSetCharset( 'utf8' );
183 } else {
184 return $this->mysqlSetCharset( 'binary' );
185 }
186 }
187
188 /**
189 * Open a connection to a MySQL server
190 *
191 * @param string $realServer
192 * @return mixed Raw connection
193 * @throws DBConnectionError
194 */
195 abstract protected function mysqlConnect( $realServer );
196
197 /**
198 * Set the character set of the MySQL link
199 *
200 * @param string $charset
201 * @return bool
202 */
203 abstract protected function mysqlSetCharset( $charset );
204
205 /**
206 * @param ResultWrapper|resource $res
207 * @throws DBUnexpectedError
208 */
209 function freeResult( $res ) {
210 if ( $res instanceof ResultWrapper ) {
211 $res = $res->result;
212 }
213 MediaWiki\suppressWarnings();
214 $ok = $this->mysqlFreeResult( $res );
215 MediaWiki\restoreWarnings();
216 if ( !$ok ) {
217 throw new DBUnexpectedError( $this, "Unable to free MySQL result" );
218 }
219 }
220
221 /**
222 * Free result memory
223 *
224 * @param resource $res Raw result
225 * @return bool
226 */
227 abstract protected function mysqlFreeResult( $res );
228
229 /**
230 * @param ResultWrapper|resource $res
231 * @return stdClass|bool
232 * @throws DBUnexpectedError
233 */
234 function fetchObject( $res ) {
235 if ( $res instanceof ResultWrapper ) {
236 $res = $res->result;
237 }
238 MediaWiki\suppressWarnings();
239 $row = $this->mysqlFetchObject( $res );
240 MediaWiki\restoreWarnings();
241
242 $errno = $this->lastErrno();
243 // Unfortunately, mysql_fetch_object does not reset the last errno.
244 // Only check for CR_SERVER_LOST and CR_UNKNOWN_ERROR, as
245 // these are the only errors mysql_fetch_object can cause.
246 // See http://dev.mysql.com/doc/refman/5.0/en/mysql-fetch-row.html.
247 if ( $errno == 2000 || $errno == 2013 ) {
248 throw new DBUnexpectedError(
249 $this,
250 'Error in fetchObject(): ' . htmlspecialchars( $this->lastError() )
251 );
252 }
253
254 return $row;
255 }
256
257 /**
258 * Fetch a result row as an object
259 *
260 * @param resource $res Raw result
261 * @return stdClass
262 */
263 abstract protected function mysqlFetchObject( $res );
264
265 /**
266 * @param ResultWrapper|resource $res
267 * @return array|bool
268 * @throws DBUnexpectedError
269 */
270 function fetchRow( $res ) {
271 if ( $res instanceof ResultWrapper ) {
272 $res = $res->result;
273 }
274 MediaWiki\suppressWarnings();
275 $row = $this->mysqlFetchArray( $res );
276 MediaWiki\restoreWarnings();
277
278 $errno = $this->lastErrno();
279 // Unfortunately, mysql_fetch_array does not reset the last errno.
280 // Only check for CR_SERVER_LOST and CR_UNKNOWN_ERROR, as
281 // these are the only errors mysql_fetch_array can cause.
282 // See http://dev.mysql.com/doc/refman/5.0/en/mysql-fetch-row.html.
283 if ( $errno == 2000 || $errno == 2013 ) {
284 throw new DBUnexpectedError(
285 $this,
286 'Error in fetchRow(): ' . htmlspecialchars( $this->lastError() )
287 );
288 }
289
290 return $row;
291 }
292
293 /**
294 * Fetch a result row as an associative and numeric array
295 *
296 * @param resource $res Raw result
297 * @return array
298 */
299 abstract protected function mysqlFetchArray( $res );
300
301 /**
302 * @throws DBUnexpectedError
303 * @param ResultWrapper|resource $res
304 * @return int
305 */
306 function numRows( $res ) {
307 if ( $res instanceof ResultWrapper ) {
308 $res = $res->result;
309 }
310 MediaWiki\suppressWarnings();
311 $n = $this->mysqlNumRows( $res );
312 MediaWiki\restoreWarnings();
313
314 // Unfortunately, mysql_num_rows does not reset the last errno.
315 // We are not checking for any errors here, since
316 // these are no errors mysql_num_rows can cause.
317 // See http://dev.mysql.com/doc/refman/5.0/en/mysql-fetch-row.html.
318 // See https://phabricator.wikimedia.org/T44430
319 return $n;
320 }
321
322 /**
323 * Get number of rows in result
324 *
325 * @param resource $res Raw result
326 * @return int
327 */
328 abstract protected function mysqlNumRows( $res );
329
330 /**
331 * @param ResultWrapper|resource $res
332 * @return int
333 */
334 function numFields( $res ) {
335 if ( $res instanceof ResultWrapper ) {
336 $res = $res->result;
337 }
338
339 return $this->mysqlNumFields( $res );
340 }
341
342 /**
343 * Get number of fields in result
344 *
345 * @param resource $res Raw result
346 * @return int
347 */
348 abstract protected function mysqlNumFields( $res );
349
350 /**
351 * @param ResultWrapper|resource $res
352 * @param int $n
353 * @return string
354 */
355 function fieldName( $res, $n ) {
356 if ( $res instanceof ResultWrapper ) {
357 $res = $res->result;
358 }
359
360 return $this->mysqlFieldName( $res, $n );
361 }
362
363 /**
364 * Get the name of the specified field in a result
365 *
366 * @param ResultWrapper|resource $res
367 * @param int $n
368 * @return string
369 */
370 abstract protected function mysqlFieldName( $res, $n );
371
372 /**
373 * mysql_field_type() wrapper
374 * @param ResultWrapper|resource $res
375 * @param int $n
376 * @return string
377 */
378 public function fieldType( $res, $n ) {
379 if ( $res instanceof ResultWrapper ) {
380 $res = $res->result;
381 }
382
383 return $this->mysqlFieldType( $res, $n );
384 }
385
386 /**
387 * Get the type of the specified field in a result
388 *
389 * @param ResultWrapper|resource $res
390 * @param int $n
391 * @return string
392 */
393 abstract protected function mysqlFieldType( $res, $n );
394
395 /**
396 * @param ResultWrapper|resource $res
397 * @param int $row
398 * @return bool
399 */
400 function dataSeek( $res, $row ) {
401 if ( $res instanceof ResultWrapper ) {
402 $res = $res->result;
403 }
404
405 return $this->mysqlDataSeek( $res, $row );
406 }
407
408 /**
409 * Move internal result pointer
410 *
411 * @param ResultWrapper|resource $res
412 * @param int $row
413 * @return bool
414 */
415 abstract protected function mysqlDataSeek( $res, $row );
416
417 /**
418 * @return string
419 */
420 function lastError() {
421 if ( $this->mConn ) {
422 # Even if it's non-zero, it can still be invalid
423 MediaWiki\suppressWarnings();
424 $error = $this->mysqlError( $this->mConn );
425 if ( !$error ) {
426 $error = $this->mysqlError();
427 }
428 MediaWiki\restoreWarnings();
429 } else {
430 $error = $this->mysqlError();
431 }
432 if ( $error ) {
433 $error .= ' (' . $this->mServer . ')';
434 }
435
436 return $error;
437 }
438
439 /**
440 * Returns the text of the error message from previous MySQL operation
441 *
442 * @param resource $conn Raw connection
443 * @return string
444 */
445 abstract protected function mysqlError( $conn = null );
446
447 /**
448 * @param string $table
449 * @param array $uniqueIndexes
450 * @param array $rows
451 * @param string $fname
452 * @return ResultWrapper
453 */
454 function replace( $table, $uniqueIndexes, $rows, $fname = __METHOD__ ) {
455 return $this->nativeReplace( $table, $rows, $fname );
456 }
457
458 /**
459 * Estimate rows in dataset
460 * Returns estimated count, based on EXPLAIN output
461 * Takes same arguments as Database::select()
462 *
463 * @param string|array $table
464 * @param string|array $vars
465 * @param string|array $conds
466 * @param string $fname
467 * @param string|array $options
468 * @return bool|int
469 */
470 public function estimateRowCount( $table, $vars = '*', $conds = '',
471 $fname = __METHOD__, $options = array()
472 ) {
473 $options['EXPLAIN'] = true;
474 $res = $this->select( $table, $vars, $conds, $fname, $options );
475 if ( $res === false ) {
476 return false;
477 }
478 if ( !$this->numRows( $res ) ) {
479 return 0;
480 }
481
482 $rows = 1;
483 foreach ( $res as $plan ) {
484 $rows *= $plan->rows > 0 ? $plan->rows : 1; // avoid resetting to zero
485 }
486
487 return (int)$rows;
488 }
489
490 /**
491 * @param string $table
492 * @param string $field
493 * @return bool|MySQLField
494 */
495 function fieldInfo( $table, $field ) {
496 $table = $this->tableName( $table );
497 $res = $this->query( "SELECT * FROM $table LIMIT 1", __METHOD__, true );
498 if ( !$res ) {
499 return false;
500 }
501 $n = $this->mysqlNumFields( $res->result );
502 for ( $i = 0; $i < $n; $i++ ) {
503 $meta = $this->mysqlFetchField( $res->result, $i );
504 if ( $field == $meta->name ) {
505 return new MySQLField( $meta );
506 }
507 }
508
509 return false;
510 }
511
512 /**
513 * Get column information from a result
514 *
515 * @param resource $res Raw result
516 * @param int $n
517 * @return stdClass
518 */
519 abstract protected function mysqlFetchField( $res, $n );
520
521 /**
522 * Get information about an index into an object
523 * Returns false if the index does not exist
524 *
525 * @param string $table
526 * @param string $index
527 * @param string $fname
528 * @return bool|array|null False or null on failure
529 */
530 function indexInfo( $table, $index, $fname = __METHOD__ ) {
531 # SHOW INDEX works in MySQL 3.23.58, but SHOW INDEXES does not.
532 # SHOW INDEX should work for 3.x and up:
533 # http://dev.mysql.com/doc/mysql/en/SHOW_INDEX.html
534 $table = $this->tableName( $table );
535 $index = $this->indexName( $index );
536
537 $sql = 'SHOW INDEX FROM ' . $table;
538 $res = $this->query( $sql, $fname );
539
540 if ( !$res ) {
541 return null;
542 }
543
544 $result = array();
545
546 foreach ( $res as $row ) {
547 if ( $row->Key_name == $index ) {
548 $result[] = $row;
549 }
550 }
551
552 return empty( $result ) ? false : $result;
553 }
554
555 /**
556 * @param string $s
557 * @return string
558 */
559 function strencode( $s ) {
560 $sQuoted = $this->mysqlRealEscapeString( $s );
561
562 if ( $sQuoted === false ) {
563 $this->ping();
564 $sQuoted = $this->mysqlRealEscapeString( $s );
565 }
566
567 return $sQuoted;
568 }
569
570 /**
571 * @param string $s
572 * @return mixed
573 */
574 abstract protected function mysqlRealEscapeString( $s );
575
576 /**
577 * MySQL uses `backticks` for identifier quoting instead of the sql standard "double quotes".
578 *
579 * @param string $s
580 * @return string
581 */
582 public function addIdentifierQuotes( $s ) {
583 // Characters in the range \u0001-\uFFFF are valid in a quoted identifier
584 // Remove NUL bytes and escape backticks by doubling
585 return '`' . str_replace( array( "\0", '`' ), array( '', '``' ), $s ) . '`';
586 }
587
588 /**
589 * @param string $name
590 * @return bool
591 */
592 public function isQuotedIdentifier( $name ) {
593 return strlen( $name ) && $name[0] == '`' && substr( $name, -1, 1 ) == '`';
594 }
595
596 /**
597 * @return bool
598 */
599 function ping() {
600 $ping = $this->mysqlPing();
601 if ( $ping ) {
602 // Connection was good or lost but reconnected...
603 // @note: mysqlnd (php 5.6+) does not support this (PHP bug 52561)
604 return true;
605 }
606
607 // Try a full disconnect/reconnect cycle if ping() failed
608 $this->closeConnection();
609 $this->mOpened = false;
610 $this->mConn = false;
611 $this->open( $this->mServer, $this->mUser, $this->mPassword, $this->mDBname );
612
613 return true;
614 }
615
616 /**
617 * Ping a server connection or reconnect if there is no connection
618 *
619 * @return bool
620 */
621 abstract protected function mysqlPing();
622
623 function getLag() {
624 if ( $this->getLagDetectionMethod() === 'pt-heartbeat' ) {
625 return $this->getLagFromPtHeartbeat();
626 } else {
627 return $this->getLagFromSlaveStatus();
628 }
629 }
630
631 /**
632 * @return string
633 */
634 protected function getLagDetectionMethod() {
635 return $this->lagDetectionMethod;
636 }
637
638 /**
639 * @return bool|int
640 */
641 protected function getLagFromSlaveStatus() {
642 $res = $this->query( 'SHOW SLAVE STATUS', __METHOD__ );
643 $row = $res ? $res->fetchObject() : false;
644 if ( $row && strval( $row->Seconds_Behind_Master ) !== '' ) {
645 return intval( $row->Seconds_Behind_Master );
646 }
647
648 return false;
649 }
650
651 /**
652 * @return bool|float
653 */
654 protected function getLagFromPtHeartbeat() {
655 $masterInfo = $this->getMasterServerInfo();
656 if ( !$masterInfo ) {
657 return false; // could not get master server ID
658 }
659
660 list( $time, $nowUnix ) = $this->getHeartbeatData( $masterInfo['serverId'] );
661 if ( $time !== null ) {
662 // @time is in ISO format like "2015-09-25T16:48:10.000510"
663 $dateTime = new DateTime( $time, new DateTimeZone( 'UTC' ) );
664 $timeUnix = (int)$dateTime->format( 'U' ) + $dateTime->format( 'u' ) / 1e6;
665
666 return max( $nowUnix - $timeUnix, 0.0 );
667 }
668
669 return false;
670 }
671
672 protected function getMasterServerInfo() {
673 $cache = $this->srvCache;
674 $key = $cache->makeGlobalKey(
675 'mysql',
676 'master-info',
677 // Using one key for all cluster slaves is preferable
678 $this->getLBInfo( 'clusterMasterHost' ) ?: $this->getServer()
679 );
680
681 $that = $this;
682 return $cache->getWithSetCallback(
683 $key,
684 $cache::TTL_INDEFINITE,
685 function () use ( $that, $cache, $key ) {
686 // Get and leave a lock key in place for a short period
687 if ( !$cache->lock( $key, 0, 10 ) ) {
688 return false; // avoid master connection spike slams
689 }
690
691 $conn = $that->getLazyMasterHandle();
692 if ( !$conn ) {
693 return false; // something is misconfigured
694 }
695
696 // Connect to and query the master; catch errors to avoid outages
697 try {
698 $res = $conn->query( 'SELECT @@server_id AS id', __METHOD__ );
699 $row = $res ? $res->fetchObject() : false;
700 $id = $row ? (int)$row->id : 0;
701 } catch ( DBError $e ) {
702 $id = 0;
703 }
704
705 // Cache the ID if it was retrieved
706 return $id ? array( 'serverId' => $id, 'asOf' => time() ) : false;
707 }
708 );
709 }
710
711 /**
712 * @param string $masterId Server ID
713 * @return array (heartbeat `ts` column value or null, UNIX timestamp)
714 * @see https://www.percona.com/doc/percona-toolkit/2.1/pt-heartbeat.html
715 */
716 protected function getHeartbeatData( $masterId ) {
717 // Get the status row for this master; use the oldest for sanity in case the master
718 // has entries listed under different server IDs (which should really not happen).
719 // Note: this would use "MAX(TIMESTAMPDIFF(MICROSECOND,ts,UTC_TIMESTAMP(6)))" but the
720 // percision field is not supported in MySQL <= 5.5.
721 $res = $this->query(
722 "SELECT ts FROM heartbeat.heartbeat WHERE server_id=" . intval( $masterId )
723 );
724 $row = $res ? $res->fetchObject() : false;
725
726 return array( $row ? $row->ts : null, microtime( true ) );
727 }
728
729 public function getApproximateLagStatus() {
730 if ( $this->getLagDetectionMethod() === 'pt-heartbeat' ) {
731 // Disable caching since this is fast enough and we don't wan't
732 // to be *too* pessimistic by having both the cache TTL and the
733 // pt-heartbeat interval count as lag in getSessionLagStatus()
734 return parent::getApproximateLagStatus();
735 }
736
737 $key = $this->srvCache->makeGlobalKey( 'mysql-lag', $this->getServer() );
738 $approxLag = $this->srvCache->get( $key );
739 if ( !$approxLag ) {
740 $approxLag = parent::getApproximateLagStatus();
741 $this->srvCache->set( $key, $approxLag, 1 );
742 }
743
744 return $approxLag;
745 }
746
747 /**
748 * Wait for the slave to catch up to a given master position.
749 * @todo Return values for this and base class are rubbish
750 *
751 * @param DBMasterPos|MySQLMasterPos $pos
752 * @param int $timeout The maximum number of seconds to wait for synchronisation
753 * @return int Zero if the slave was past that position already,
754 * greater than zero if we waited for some period of time, less than
755 * zero if we timed out.
756 */
757 function masterPosWait( DBMasterPos $pos, $timeout ) {
758 if ( $this->lastKnownSlavePos && $this->lastKnownSlavePos->hasReached( $pos ) ) {
759 return '0'; // http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html
760 }
761
762 # Commit any open transactions
763 $this->commit( __METHOD__, 'flush' );
764
765 # Call doQuery() directly, to avoid opening a transaction if DBO_TRX is set
766 $encFile = $this->addQuotes( $pos->file );
767 $encPos = intval( $pos->pos );
768 $sql = "SELECT MASTER_POS_WAIT($encFile, $encPos, $timeout)";
769 $res = $this->doQuery( $sql );
770
771 $status = false;
772 if ( $res ) {
773 $row = $this->fetchRow( $res );
774 if ( $row ) {
775 $status = $row[0]; // can be NULL, -1, or 0+ per the MySQL manual
776 if ( ctype_digit( $status ) ) { // success
777 $this->lastKnownSlavePos = $pos;
778 }
779 }
780 }
781
782 return $status;
783 }
784
785 /**
786 * Get the position of the master from SHOW SLAVE STATUS
787 *
788 * @return MySQLMasterPos|bool
789 */
790 function getSlavePos() {
791 $res = $this->query( 'SHOW SLAVE STATUS', 'DatabaseBase::getSlavePos' );
792 $row = $this->fetchObject( $res );
793
794 if ( $row ) {
795 $pos = isset( $row->Exec_master_log_pos )
796 ? $row->Exec_master_log_pos
797 : $row->Exec_Master_Log_Pos;
798
799 return new MySQLMasterPos( $row->Relay_Master_Log_File, $pos );
800 } else {
801 return false;
802 }
803 }
804
805 /**
806 * Get the position of the master from SHOW MASTER STATUS
807 *
808 * @return MySQLMasterPos|bool
809 */
810 function getMasterPos() {
811 $res = $this->query( 'SHOW MASTER STATUS', 'DatabaseBase::getMasterPos' );
812 $row = $this->fetchObject( $res );
813
814 if ( $row ) {
815 return new MySQLMasterPos( $row->File, $row->Position );
816 } else {
817 return false;
818 }
819 }
820
821 /**
822 * @param string $index
823 * @return string
824 */
825 function useIndexClause( $index ) {
826 return "FORCE INDEX (" . $this->indexName( $index ) . ")";
827 }
828
829 /**
830 * @return string
831 */
832 function lowPriorityOption() {
833 return 'LOW_PRIORITY';
834 }
835
836 /**
837 * @return string
838 */
839 public function getSoftwareLink() {
840 // MariaDB includes its name in its version string; this is how MariaDB's version of
841 // the mysql command-line client identifies MariaDB servers (see mariadb_connection()
842 // in libmysql/libmysql.c).
843 $version = $this->getServerVersion();
844 if ( strpos( $version, 'MariaDB' ) !== false || strpos( $version, '-maria-' ) !== false ) {
845 return '[{{int:version-db-mariadb-url}} MariaDB]';
846 }
847
848 // Percona Server's version suffix is not very distinctive, and @@version_comment
849 // doesn't give the necessary info for source builds, so assume the server is MySQL.
850 // (Even Percona's version of mysql doesn't try to make the distinction.)
851 return '[{{int:version-db-mysql-url}} MySQL]';
852 }
853
854 /**
855 * @return string
856 */
857 public function getServerVersion() {
858 // Not using mysql_get_server_info() or similar for consistency: in the handshake,
859 // MariaDB 10 adds the prefix "5.5.5-", and only some newer client libraries strip
860 // it off (see RPL_VERSION_HACK in include/mysql_com.h).
861 if ( $this->serverVersion === null ) {
862 $this->serverVersion = $this->selectField( '', 'VERSION()', '', __METHOD__ );
863 }
864 return $this->serverVersion;
865 }
866
867 /**
868 * @param array $options
869 */
870 public function setSessionOptions( array $options ) {
871 if ( isset( $options['connTimeout'] ) ) {
872 $timeout = (int)$options['connTimeout'];
873 $this->query( "SET net_read_timeout=$timeout" );
874 $this->query( "SET net_write_timeout=$timeout" );
875 }
876 }
877
878 /**
879 * @param string $sql
880 * @param string $newLine
881 * @return bool
882 */
883 public function streamStatementEnd( &$sql, &$newLine ) {
884 if ( strtoupper( substr( $newLine, 0, 9 ) ) == 'DELIMITER' ) {
885 preg_match( '/^DELIMITER\s+(\S+)/', $newLine, $m );
886 $this->delimiter = $m[1];
887 $newLine = '';
888 }
889
890 return parent::streamStatementEnd( $sql, $newLine );
891 }
892
893 /**
894 * Check to see if a named lock is available. This is non-blocking.
895 *
896 * @param string $lockName Name of lock to poll
897 * @param string $method Name of method calling us
898 * @return bool
899 * @since 1.20
900 */
901 public function lockIsFree( $lockName, $method ) {
902 $lockName = $this->addQuotes( $this->makeLockName( $lockName ) );
903 $result = $this->query( "SELECT IS_FREE_LOCK($lockName) AS lockstatus", $method );
904 $row = $this->fetchObject( $result );
905
906 return ( $row->lockstatus == 1 );
907 }
908
909 /**
910 * @param string $lockName
911 * @param string $method
912 * @param int $timeout
913 * @return bool
914 */
915 public function lock( $lockName, $method, $timeout = 5 ) {
916 $lockName = $this->addQuotes( $this->makeLockName( $lockName ) );
917 $result = $this->query( "SELECT GET_LOCK($lockName, $timeout) AS lockstatus", $method );
918 $row = $this->fetchObject( $result );
919
920 if ( $row->lockstatus == 1 ) {
921 return true;
922 } else {
923 wfDebug( __METHOD__ . " failed to acquire lock\n" );
924
925 return false;
926 }
927 }
928
929 /**
930 * FROM MYSQL DOCS:
931 * http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_release-lock
932 * @param string $lockName
933 * @param string $method
934 * @return bool
935 */
936 public function unlock( $lockName, $method ) {
937 $lockName = $this->addQuotes( $this->makeLockName( $lockName ) );
938 $result = $this->query( "SELECT RELEASE_LOCK($lockName) as lockstatus", $method );
939 $row = $this->fetchObject( $result );
940
941 return ( $row->lockstatus == 1 );
942 }
943
944 private function makeLockName( $lockName ) {
945 // http://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
946 // Newer version enforce a 64 char length limit.
947 return ( strlen( $lockName ) > 64 ) ? sha1( $lockName ) : $lockName;
948 }
949
950 public function namedLocksEnqueue() {
951 return true;
952 }
953
954 /**
955 * @param array $read
956 * @param array $write
957 * @param string $method
958 * @param bool $lowPriority
959 * @return bool
960 */
961 public function lockTables( $read, $write, $method, $lowPriority = true ) {
962 $items = array();
963
964 foreach ( $write as $table ) {
965 $tbl = $this->tableName( $table ) .
966 ( $lowPriority ? ' LOW_PRIORITY' : '' ) .
967 ' WRITE';
968 $items[] = $tbl;
969 }
970 foreach ( $read as $table ) {
971 $items[] = $this->tableName( $table ) . ' READ';
972 }
973 $sql = "LOCK TABLES " . implode( ',', $items );
974 $this->query( $sql, $method );
975
976 return true;
977 }
978
979 /**
980 * @param string $method
981 * @return bool
982 */
983 public function unlockTables( $method ) {
984 $this->query( "UNLOCK TABLES", $method );
985
986 return true;
987 }
988
989 /**
990 * Get search engine class. All subclasses of this
991 * need to implement this if they wish to use searching.
992 *
993 * @return string
994 */
995 public function getSearchEngine() {
996 return 'SearchMySQL';
997 }
998
999 /**
1000 * @param bool $value
1001 */
1002 public function setBigSelects( $value = true ) {
1003 if ( $value === 'default' ) {
1004 if ( $this->mDefaultBigSelects === null ) {
1005 # Function hasn't been called before so it must already be set to the default
1006 return;
1007 } else {
1008 $value = $this->mDefaultBigSelects;
1009 }
1010 } elseif ( $this->mDefaultBigSelects === null ) {
1011 $this->mDefaultBigSelects =
1012 (bool)$this->selectField( false, '@@sql_big_selects', '', __METHOD__ );
1013 }
1014 $encValue = $value ? '1' : '0';
1015 $this->query( "SET sql_big_selects=$encValue", __METHOD__ );
1016 }
1017
1018 /**
1019 * DELETE where the condition is a join. MySql uses multi-table deletes.
1020 * @param string $delTable
1021 * @param string $joinTable
1022 * @param string $delVar
1023 * @param string $joinVar
1024 * @param array|string $conds
1025 * @param bool|string $fname
1026 * @throws DBUnexpectedError
1027 * @return bool|ResultWrapper
1028 */
1029 function deleteJoin( $delTable, $joinTable, $delVar, $joinVar, $conds, $fname = __METHOD__ ) {
1030 if ( !$conds ) {
1031 throw new DBUnexpectedError( $this, 'DatabaseBase::deleteJoin() called with empty $conds' );
1032 }
1033
1034 $delTable = $this->tableName( $delTable );
1035 $joinTable = $this->tableName( $joinTable );
1036 $sql = "DELETE $delTable FROM $delTable, $joinTable WHERE $delVar=$joinVar ";
1037
1038 if ( $conds != '*' ) {
1039 $sql .= ' AND ' . $this->makeList( $conds, LIST_AND );
1040 }
1041
1042 return $this->query( $sql, $fname );
1043 }
1044
1045 /**
1046 * @param string $table
1047 * @param array $rows
1048 * @param array $uniqueIndexes
1049 * @param array $set
1050 * @param string $fname
1051 * @return bool
1052 */
1053 public function upsert( $table, array $rows, array $uniqueIndexes,
1054 array $set, $fname = __METHOD__
1055 ) {
1056 if ( !count( $rows ) ) {
1057 return true; // nothing to do
1058 }
1059
1060 if ( !is_array( reset( $rows ) ) ) {
1061 $rows = array( $rows );
1062 }
1063
1064 $table = $this->tableName( $table );
1065 $columns = array_keys( $rows[0] );
1066
1067 $sql = "INSERT INTO $table (" . implode( ',', $columns ) . ') VALUES ';
1068 $rowTuples = array();
1069 foreach ( $rows as $row ) {
1070 $rowTuples[] = '(' . $this->makeList( $row ) . ')';
1071 }
1072 $sql .= implode( ',', $rowTuples );
1073 $sql .= " ON DUPLICATE KEY UPDATE " . $this->makeList( $set, LIST_SET );
1074
1075 return (bool)$this->query( $sql, $fname );
1076 }
1077
1078 /**
1079 * Determines how long the server has been up
1080 *
1081 * @return int
1082 */
1083 function getServerUptime() {
1084 $vars = $this->getMysqlStatus( 'Uptime' );
1085
1086 return (int)$vars['Uptime'];
1087 }
1088
1089 /**
1090 * Determines if the last failure was due to a deadlock
1091 *
1092 * @return bool
1093 */
1094 function wasDeadlock() {
1095 return $this->lastErrno() == 1213;
1096 }
1097
1098 /**
1099 * Determines if the last failure was due to a lock timeout
1100 *
1101 * @return bool
1102 */
1103 function wasLockTimeout() {
1104 return $this->lastErrno() == 1205;
1105 }
1106
1107 /**
1108 * Determines if the last query error was something that should be dealt
1109 * with by pinging the connection and reissuing the query
1110 *
1111 * @return bool
1112 */
1113 function wasErrorReissuable() {
1114 return $this->lastErrno() == 2013 || $this->lastErrno() == 2006;
1115 }
1116
1117 /**
1118 * Determines if the last failure was due to the database being read-only.
1119 *
1120 * @return bool
1121 */
1122 function wasReadOnlyError() {
1123 return $this->lastErrno() == 1223 ||
1124 ( $this->lastErrno() == 1290 && strpos( $this->lastError(), '--read-only' ) !== false );
1125 }
1126
1127 function wasConnectionError( $errno ) {
1128 return $errno == 2013 || $errno == 2006;
1129 }
1130
1131 /**
1132 * Get the underlying binding handle, mConn
1133 *
1134 * Makes sure that mConn is set (disconnects and ping() failure can unset it).
1135 * This catches broken callers than catch and ignore disconnection exceptions.
1136 * Unlike checking isOpen(), this is safe to call inside of open().
1137 *
1138 * @return resource|object
1139 * @throws DBUnexpectedError
1140 * @since 1.26
1141 */
1142 protected function getBindingHandle() {
1143 if ( !$this->mConn ) {
1144 throw new DBUnexpectedError(
1145 $this,
1146 'DB connection was already closed or the connection dropped.'
1147 );
1148 }
1149
1150 return $this->mConn;
1151 }
1152
1153 /**
1154 * @param string $oldName
1155 * @param string $newName
1156 * @param bool $temporary
1157 * @param string $fname
1158 * @return bool
1159 */
1160 function duplicateTableStructure( $oldName, $newName, $temporary = false, $fname = __METHOD__ ) {
1161 $tmp = $temporary ? 'TEMPORARY ' : '';
1162 $newName = $this->addIdentifierQuotes( $newName );
1163 $oldName = $this->addIdentifierQuotes( $oldName );
1164 $query = "CREATE $tmp TABLE $newName (LIKE $oldName)";
1165
1166 return $this->query( $query, $fname );
1167 }
1168
1169 /**
1170 * List all tables on the database
1171 *
1172 * @param string $prefix Only show tables with this prefix, e.g. mw_
1173 * @param string $fname Calling function name
1174 * @return array
1175 */
1176 function listTables( $prefix = null, $fname = __METHOD__ ) {
1177 $result = $this->query( "SHOW TABLES", $fname );
1178
1179 $endArray = array();
1180
1181 foreach ( $result as $table ) {
1182 $vars = get_object_vars( $table );
1183 $table = array_pop( $vars );
1184
1185 if ( !$prefix || strpos( $table, $prefix ) === 0 ) {
1186 $endArray[] = $table;
1187 }
1188 }
1189
1190 return $endArray;
1191 }
1192
1193 /**
1194 * @param string $tableName
1195 * @param string $fName
1196 * @return bool|ResultWrapper
1197 */
1198 public function dropTable( $tableName, $fName = __METHOD__ ) {
1199 if ( !$this->tableExists( $tableName, $fName ) ) {
1200 return false;
1201 }
1202
1203 return $this->query( "DROP TABLE IF EXISTS " . $this->tableName( $tableName ), $fName );
1204 }
1205
1206 /**
1207 * @return array
1208 */
1209 protected function getDefaultSchemaVars() {
1210 $vars = parent::getDefaultSchemaVars();
1211 $vars['wgDBTableOptions'] = str_replace( 'TYPE', 'ENGINE', $GLOBALS['wgDBTableOptions'] );
1212 $vars['wgDBTableOptions'] = str_replace(
1213 'CHARSET=mysql4',
1214 'CHARSET=binary',
1215 $vars['wgDBTableOptions']
1216 );
1217
1218 return $vars;
1219 }
1220
1221 /**
1222 * Get status information from SHOW STATUS in an associative array
1223 *
1224 * @param string $which
1225 * @return array
1226 */
1227 function getMysqlStatus( $which = "%" ) {
1228 $res = $this->query( "SHOW STATUS LIKE '{$which}'" );
1229 $status = array();
1230
1231 foreach ( $res as $row ) {
1232 $status[$row->Variable_name] = $row->Value;
1233 }
1234
1235 return $status;
1236 }
1237
1238 /**
1239 * Lists VIEWs in the database
1240 *
1241 * @param string $prefix Only show VIEWs with this prefix, eg.
1242 * unit_test_, or $wgDBprefix. Default: null, would return all views.
1243 * @param string $fname Name of calling function
1244 * @return array
1245 * @since 1.22
1246 */
1247 public function listViews( $prefix = null, $fname = __METHOD__ ) {
1248
1249 if ( !isset( $this->allViews ) ) {
1250
1251 // The name of the column containing the name of the VIEW
1252 $propertyName = 'Tables_in_' . $this->mDBname;
1253
1254 // Query for the VIEWS
1255 $result = $this->query( 'SHOW FULL TABLES WHERE TABLE_TYPE = "VIEW"' );
1256 $this->allViews = array();
1257 while ( ( $row = $this->fetchRow( $result ) ) !== false ) {
1258 array_push( $this->allViews, $row[$propertyName] );
1259 }
1260 }
1261
1262 if ( is_null( $prefix ) || $prefix === '' ) {
1263 return $this->allViews;
1264 }
1265
1266 $filteredViews = array();
1267 foreach ( $this->allViews as $viewName ) {
1268 // Does the name of this VIEW start with the table-prefix?
1269 if ( strpos( $viewName, $prefix ) === 0 ) {
1270 array_push( $filteredViews, $viewName );
1271 }
1272 }
1273
1274 return $filteredViews;
1275 }
1276
1277 /**
1278 * Differentiates between a TABLE and a VIEW.
1279 *
1280 * @param string $name Name of the TABLE/VIEW to test
1281 * @param string $prefix
1282 * @return bool
1283 * @since 1.22
1284 */
1285 public function isView( $name, $prefix = null ) {
1286 return in_array( $name, $this->listViews( $prefix ) );
1287 }
1288 }
1289
1290 /**
1291 * Utility class.
1292 * @ingroup Database
1293 */
1294 class MySQLField implements Field {
1295 private $name, $tablename, $default, $max_length, $nullable,
1296 $is_pk, $is_unique, $is_multiple, $is_key, $type, $binary,
1297 $is_numeric, $is_blob, $is_unsigned, $is_zerofill;
1298
1299 function __construct( $info ) {
1300 $this->name = $info->name;
1301 $this->tablename = $info->table;
1302 $this->default = $info->def;
1303 $this->max_length = $info->max_length;
1304 $this->nullable = !$info->not_null;
1305 $this->is_pk = $info->primary_key;
1306 $this->is_unique = $info->unique_key;
1307 $this->is_multiple = $info->multiple_key;
1308 $this->is_key = ( $this->is_pk || $this->is_unique || $this->is_multiple );
1309 $this->type = $info->type;
1310 $this->binary = isset( $info->binary ) ? $info->binary : false;
1311 $this->is_numeric = isset( $info->numeric ) ? $info->numeric : false;
1312 $this->is_blob = isset( $info->blob ) ? $info->blob : false;
1313 $this->is_unsigned = isset( $info->unsigned ) ? $info->unsigned : false;
1314 $this->is_zerofill = isset( $info->zerofill ) ? $info->zerofill : false;
1315 }
1316
1317 /**
1318 * @return string
1319 */
1320 function name() {
1321 return $this->name;
1322 }
1323
1324 /**
1325 * @return string
1326 */
1327 function tableName() {
1328 return $this->tablename;
1329 }
1330
1331 /**
1332 * @return string
1333 */
1334 function type() {
1335 return $this->type;
1336 }
1337
1338 /**
1339 * @return bool
1340 */
1341 function isNullable() {
1342 return $this->nullable;
1343 }
1344
1345 function defaultValue() {
1346 return $this->default;
1347 }
1348
1349 /**
1350 * @return bool
1351 */
1352 function isKey() {
1353 return $this->is_key;
1354 }
1355
1356 /**
1357 * @return bool
1358 */
1359 function isMultipleKey() {
1360 return $this->is_multiple;
1361 }
1362
1363 /**
1364 * @return bool
1365 */
1366 function isBinary() {
1367 return $this->binary;
1368 }
1369
1370 /**
1371 * @return bool
1372 */
1373 function isNumeric() {
1374 return $this->is_numeric;
1375 }
1376
1377 /**
1378 * @return bool
1379 */
1380 function isBlob() {
1381 return $this->is_blob;
1382 }
1383
1384 /**
1385 * @return bool
1386 */
1387 function isUnsigned() {
1388 return $this->is_unsigned;
1389 }
1390
1391 /**
1392 * @return bool
1393 */
1394 function isZerofill() {
1395 return $this->is_zerofill;
1396 }
1397 }
1398
1399 class MySQLMasterPos implements DBMasterPos {
1400 /** @var string */
1401 public $file;
1402 /** @var int Position */
1403 public $pos;
1404 /** @var float UNIX timestamp */
1405 public $asOfTime = 0.0;
1406
1407 function __construct( $file, $pos ) {
1408 $this->file = $file;
1409 $this->pos = $pos;
1410 $this->asOfTime = microtime( true );
1411 }
1412
1413 function asOfTime() {
1414 return $this->asOfTime;
1415 }
1416
1417 function hasReached( DBMasterPos $pos ) {
1418 if ( !( $pos instanceof self ) ) {
1419 throw new InvalidArgumentException( "Position not an instance of " . __CLASS__ );
1420 }
1421
1422 $thisPos = $this->getCoordinates();
1423 $thatPos = $pos->getCoordinates();
1424
1425 return ( $thisPos && $thatPos && $thisPos >= $thatPos );
1426 }
1427
1428 function __toString() {
1429 // e.g db1034-bin.000976/843431247
1430 return "{$this->file}/{$this->pos}";
1431 }
1432
1433 /**
1434 * @return array|bool (int, int)
1435 */
1436 protected function getCoordinates() {
1437 $m = array();
1438 if ( preg_match( '!\.(\d+)/(\d+)$!', (string)$this, $m ) ) {
1439 return array( (int)$m[1], (int)$m[2] );
1440 }
1441
1442 return false;
1443 }
1444 }