Code Coverage
 
Lines
Functions and Methods
Classes and Traits
Total
5.32% covered (danger)
5.32%
19 / 357
2.56% covered (danger)
2.56%
1 / 39
CRAP
0.00% covered (danger)
0.00%
0 / 1
DatabaseMySQL
5.32% covered (danger)
5.32%
19 / 357
2.56% covered (danger)
2.56%
1 / 39
12341.03
0.00% covered (danger)
0.00%
0 / 1
 __construct
0.00% covered (danger)
0.00%
0 / 20
0.00% covered (danger)
0.00%
0 / 1
12
 getType
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 open
0.00% covered (danger)
0.00%
0 / 33
0.00% covered (danger)
0.00%
0 / 1
182
 doSelectDomain
0.00% covered (danger)
0.00%
0 / 24
0.00% covered (danger)
0.00%
0 / 1
30
 lastError
0.00% covered (danger)
0.00%
0 / 6
0.00% covered (danger)
0.00%
0 / 1
20
 isInsertSelectSafe
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
20
 checkInsertWarnings
0.00% covered (danger)
0.00%
0 / 20
0.00% covered (danger)
0.00%
0 / 1
30
 estimateRowCount
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
56
 tableExists
0.00% covered (danger)
0.00%
0 / 12
0.00% covered (danger)
0.00%
0 / 1
6
 fieldInfo
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
6
 indexInfo
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 1
12
 strencode
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 serverIsReadOnly
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
6
 getSoftwareLink
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 getMySqlServerVariant
87.50% covered (warning)
87.50%
7 / 8
0.00% covered (danger)
0.00%
0 / 1
3.02
 getServerVersion
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
20
 setSessionOptions
0.00% covered (danger)
0.00%
0 / 15
0.00% covered (danger)
0.00%
0 / 1
20
 streamStatementEnd
100.00% covered (success)
100.00%
4 / 4
100.00% covered (success)
100.00%
1 / 1
2
 doLockIsFree
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
2
 doLock
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 doUnlock
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
2
 doFlushSession
0.00% covered (danger)
0.00%
0 / 11
0.00% covered (danger)
0.00%
0 / 1
20
 upsert
0.00% covered (danger)
0.00%
0 / 14
0.00% covered (danger)
0.00%
0 / 1
6
 replace
0.00% covered (danger)
0.00%
0 / 9
0.00% covered (danger)
0.00%
0 / 1
6
 isConnectionError
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 isQueryTimeoutError
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 isKnownStatementRollbackError
0.00% covered (danger)
0.00%
0 / 5
0.00% covered (danger)
0.00%
0 / 1
2
 duplicateTableStructure
0.00% covered (danger)
0.00%
0 / 10
0.00% covered (danger)
0.00%
0 / 1
12
 listTables
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
12
 selectSQLText
57.14% covered (warning)
57.14%
8 / 14
0.00% covered (danger)
0.00%
0 / 1
8.83
 doSingleStatementQuery
0.00% covered (danger)
0.00%
0 / 13
0.00% covered (danger)
0.00%
0 / 1
12
 mysqlConnect
0.00% covered (danger)
0.00%
0 / 38
0.00% covered (danger)
0.00%
0 / 1
156
 closeConnection
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
6
 lastInsertId
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 doHandleSessionLossPreconnect
0.00% covered (danger)
0.00%
0 / 1
0.00% covered (danger)
0.00%
0 / 1
2
 insertId
0.00% covered (danger)
0.00%
0 / 4
0.00% covered (danger)
0.00%
0 / 1
6
 lastErrno
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 mysqlError
0.00% covered (danger)
0.00%
0 / 3
0.00% covered (danger)
0.00%
0 / 1
6
 mysqlRealEscapeString
0.00% covered (danger)
0.00%
0 / 2
0.00% covered (danger)
0.00%
0 / 1
2
1<?php
2/**
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License as published by
5 * the Free Software Foundation; either version 2 of the License, or
6 * (at your option) any later version.
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 *
13 * You should have received a copy of the GNU General Public License along
14 * with this program; if not, write to the Free Software Foundation, Inc.,
15 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
16 * http://www.gnu.org/copyleft/gpl.html
17 *
18 * @file
19 */
20namespace Wikimedia\Rdbms;
21
22use mysqli;
23use mysqli_result;
24use RuntimeException;
25use Wikimedia\AtEase\AtEase;
26use Wikimedia\IPUtils;
27use Wikimedia\Rdbms\Platform\MySQLPlatform;
28use Wikimedia\Rdbms\Platform\SQLPlatform;
29use Wikimedia\Rdbms\Replication\MysqlReplicationReporter;
30
31/**
32 * MySQL database abstraction layer.
33 *
34 * Defines methods independent of the used MySQL extension.
35 *
36 * @property mysqli|null $conn
37 *
38 * @ingroup Database
39 * @since 1.22
40 * @see Database
41 */
42class DatabaseMySQL extends Database {
43    /** @var string|null */
44    private $sslKeyPath;
45    /** @var string|null */
46    private $sslCertPath;
47    /** @var string|null */
48    private $sslCAFile;
49    /** @var string|null */
50    private $sslCAPath;
51    /**
52     * Open SSL cipher list string
53     * @see https://www.openssl.org/docs/man1.0.2/man1/ciphers.html
54     * @var string|null
55     */
56    private $sslCiphers;
57    /** @var bool Use experimental UTF-8 transmission encoding */
58    private $utf8Mode;
59
60    /** @var SQLPlatform */
61    protected $platform;
62
63    /** @var MysqlReplicationReporter */
64    protected $replicationReporter;
65    /** @var int Last implicit row ID for the session (0 if none) */
66    private $sessionLastAutoRowId;
67
68    /**
69     * Additional $params include:
70     *   - lagDetectionMethod : set to one of (Seconds_Behind_Master,pt-heartbeat).
71     *       pt-heartbeat assumes the table is at heartbeat.heartbeat
72     *       and uses UTC timestamps in the heartbeat.ts column.
73     *       (https://www.percona.com/doc/percona-toolkit/2.2/pt-heartbeat.html)
74     *   - lagDetectionOptions : if using pt-heartbeat, this can be set to an array map.
75     *       The "conds" key overrides the WHERE clause used to find the relevant row in the
76     *       `heartbeat` table, e.g. ['shard' => 's1']. By default, the row used is the newest
77     *       row having a server_id matching that of the immediate replication source server
78     *       for the given replica.
79     *   - useGTIDs : use GTID methods like MASTER_GTID_WAIT() when possible.
80     *   - sslKeyPath : path to key file [default: null]
81     *   - sslCertPath : path to certificate file [default: null]
82     *   - sslCAFile: path to a single certificate authority PEM file [default: null]
83     *   - sslCAPath : parth to certificate authority PEM directory [default: null]
84     *   - sslCiphers : array list of allowable ciphers [default: null]
85     * @param array $params
86     */
87    public function __construct( array $params ) {
88        foreach ( [ 'KeyPath', 'CertPath', 'CAFile', 'CAPath', 'Ciphers' ] as $name ) {
89            $var = "ssl{$name}";
90            if ( isset( $params[$var] ) ) {
91                $this->$var = $params[$var];
92            }
93        }
94        $this->utf8Mode = !empty( $params['utf8Mode'] );
95        parent::__construct( $params );
96        $this->platform = new MySQLPlatform(
97            $this,
98            $this->logger,
99            $this->currentDomain,
100            $this->errorLogger
101        );
102        $this->replicationReporter = new MysqlReplicationReporter(
103            $params['topologyRole'],
104            $this->logger,
105            $params['srvCache'],
106            $params['lagDetectionMethod'] ?? 'Seconds_Behind_Master',
107            $params['lagDetectionOptions'] ?? [],
108            !empty( $params['useGTIDs' ] )
109        );
110    }
111
112    /**
113     * @return string
114     */
115    public function getType() {
116        return 'mysql';
117    }
118
119    protected function open( $server, $user, $password, $db, $schema, $tablePrefix ) {
120        $this->close( __METHOD__ );
121
122        if ( $schema !== null ) {
123            throw $this->newExceptionAfterConnectError( "Got schema '$schema'; not supported." );
124        }
125
126        $this->installErrorHandler();
127        try {
128            $this->conn = $this->mysqlConnect( $server, $user, $password, $db );
129        } catch ( RuntimeException $e ) {
130            $this->restoreErrorHandler();
131            throw $this->newExceptionAfterConnectError( $e->getMessage() );
132        }
133        $error = $this->restoreErrorHandler();
134
135        if ( !$this->conn ) {
136            throw $this->newExceptionAfterConnectError( $error ?: $this->lastError() );
137        }
138
139        try {
140            $this->currentDomain = new DatabaseDomain(
141                ( $db !== '' ) ? $db : null,
142                null,
143                $tablePrefix
144            );
145            $this->platform->setCurrentDomain( $this->currentDomain );
146
147            $set = [];
148            if ( !$this->flagsHolder->getFlag( self::DBO_GAUGE ) ) {
149                // Abstract over any excessive MySQL defaults
150                $set[] = 'group_concat_max_len = 262144';
151                // Set any custom settings defined by site config
152                // https://dev.mysql.com/doc/refman/5.7/en/innodb-parameters.html
153                foreach ( $this->connectionVariables as $var => $val ) {
154                    // Escape strings but not numbers to avoid MySQL complaining
155                    if ( !is_int( $val ) && !is_float( $val ) ) {
156                        $val = $this->addQuotes( $val );
157                    }
158                    $set[] = $this->platform->addIdentifierQuotes( $var ) . ' = ' . $val;
159                }
160            }
161
162            if ( $set ) {
163                $sql = 'SET ' . implode( ', ', $set );
164                $flags = self::QUERY_NO_RETRY | self::QUERY_CHANGE_TRX;
165                $query = new Query( $sql, $flags, 'SET' );
166                // Avoid using query() so that replaceLostConnection() does not throw
167                // errors if the transaction status is STATUS_TRX_ERROR
168                $qs = $this->executeQuery( $query, __METHOD__, $flags );
169                if ( $qs->res === false ) {
170                    $this->reportQueryError( $qs->message, $qs->code, $sql, __METHOD__ );
171                }
172            }
173        } catch ( RuntimeException $e ) {
174            throw $this->newExceptionAfterConnectError( $e->getMessage() );
175        }
176    }
177
178    protected function doSelectDomain( DatabaseDomain $domain ) {
179        if ( $domain->getSchema() !== null ) {
180            throw new DBExpectedError(
181                $this,
182                __CLASS__ . ": domain '{$domain->getId()}' has a schema component"
183            );
184        }
185
186        $database = $domain->getDatabase();
187        // A null database means "don't care" so leave it as is and update the table prefix
188        if ( $database === null ) {
189            $this->currentDomain = new DatabaseDomain(
190                $this->currentDomain->getDatabase(),
191                null,
192                $domain->getTablePrefix()
193            );
194            $this->platform->setCurrentDomain( $this->currentDomain );
195
196            return true;
197        }
198
199        if ( $database !== $this->getDBname() ) {
200            $sql = 'USE ' . $this->addIdentifierQuotes( $database );
201            $query = new Query( $sql, self::QUERY_CHANGE_TRX, 'USE' );
202            $qs = $this->executeQuery( $query, __METHOD__, self::QUERY_CHANGE_TRX );
203            if ( $qs->res === false ) {
204                $this->reportQueryError( $qs->message, $qs->code, $sql, __METHOD__ );
205                return false; // unreachable
206            }
207        }
208
209        // Update that domain fields on success (no exception thrown)
210        $this->currentDomain = $domain;
211        $this->platform->setCurrentDomain( $domain );
212
213        return true;
214    }
215
216    /**
217     * @return string
218     */
219    public function lastError() {
220        if ( $this->conn ) {
221            // Even if it's non-zero, it can still be invalid
222            $error = $this->mysqlError( $this->conn );
223            if ( !$error ) {
224                $error = $this->mysqlError();
225            }
226        } else {
227            $error = $this->mysqlError() ?: $this->lastConnectError;
228        }
229
230        return $error;
231    }
232
233    protected function isInsertSelectSafe( array $insertOptions, array $selectOptions, $fname = __METHOD__ ) {
234        $row = $this->replicationReporter->getReplicationSafetyInfo( $this, $fname );
235        // For row-based-replication, the resulting changes will be relayed, not the query
236        if ( $row->binlog_format === 'ROW' ) {
237            return true;
238        }
239        // LIMIT requires ORDER BY on a unique key or it is non-deterministic
240        if ( isset( $selectOptions['LIMIT'] ) ) {
241            return false;
242        }
243        // In MySQL, an INSERT SELECT is only replication safe with row-based
244        // replication or if innodb_autoinc_lock_mode is 0. When those
245        // conditions aren't met, use non-native mode.
246        // While we could try to determine if the insert is safe anyway by
247        // checking if the target table has an auto-increment column that
248        // isn't set in $varMap, that seems unlikely to be worth the extra
249        // complexity.
250        return (
251            in_array( 'NO_AUTO_COLUMNS', $insertOptions ) ||
252            (int)$row->innodb_autoinc_lock_mode === 0
253        );
254    }
255
256    protected function checkInsertWarnings( Query $query, $fname ) {
257        if ( $this->conn && $this->conn->warning_count ) {
258            // Yeah it's weird. It's not iterable.
259            $warnings = $this->conn->get_warnings();
260            $done = $warnings === false;
261            while ( !$done ) {
262                if ( in_array( $warnings->errno, [
263                    // List based on https://dev.mysql.com/doc/refman/8.0/en/sql-mode.html#ignore-effect-on-execution
264                    1048, /* ER_BAD_NULL_ERROR */
265                    1526, /* ER_NO_PARTITION_FOR_GIVEN_VALUE */
266                    1748, /* ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET */
267                    1242, /* ER_SUBQUERY_NO_1_ROW */
268                    1369, /* ER_VIEW_CHECK_FAILED */
269                    // Truncation and overflow per T108255
270                    1264, /* ER_WARN_DATA_OUT_OF_RANGE */
271                    1265, /* WARN_DATA_TRUNCATED */
272                ] ) ) {
273                    $this->reportQueryError(
274                        'Insert returned unacceptable warning: ' . $warnings->message,
275                        $warnings->errno,
276                        $query->getSQL(),
277                        $fname
278                    );
279                }
280                $done = !$warnings->next();
281            }
282        }
283    }
284
285    public function estimateRowCount(
286        $tables,
287        $var = '*',
288        $conds = '',
289        $fname = __METHOD__,
290        $options = [],
291        $join_conds = []
292    ): int {
293        $conds = $this->platform->normalizeConditions( $conds, $fname );
294        $column = $this->platform->extractSingleFieldFromList( $var );
295        if ( is_string( $column ) && !in_array( $column, [ '*', '1' ] ) ) {
296            $conds[] = "$column IS NOT NULL";
297        }
298
299        $options['EXPLAIN'] = true;
300        $res = $this->select( $tables, $var, $conds, $fname, $options, $join_conds );
301        if ( $res === false ) {
302            return -1;
303        }
304        if ( !$res->numRows() ) {
305            return 0;
306        }
307
308        $rows = 1;
309        foreach ( $res as $plan ) {
310            $rows *= $plan->rows > 0 ? $plan->rows : 1; // avoid resetting to zero
311        }
312
313        return (int)$rows;
314    }
315
316    public function tableExists( $table, $fname = __METHOD__ ) {
317        [ $db, $pt ] = $this->platform->getDatabaseAndTableIdentifier( $table );
318        if ( isset( $this->sessionTempTables[$db][$pt] ) ) {
319            return true; // already known to exist and won't be found in the query anyway
320        }
321
322        return (bool)$this->newSelectQueryBuilder()
323            ->select( '1' )
324            ->from( 'information_schema.tables' )
325            ->where( [
326                'table_schema' => $db,
327                'table_name' => $pt,
328            ] )
329            ->caller( $fname )
330            ->fetchField();
331    }
332
333    /**
334     * @param string $table
335     * @param string $field
336     * @return MySQLField|false
337     */
338    public function fieldInfo( $table, $field ) {
339        $query = new Query(
340            "SELECT * FROM " . $this->tableName( $table ) . " LIMIT 1",
341            self::QUERY_SILENCE_ERRORS | self::QUERY_IGNORE_DBO_TRX | self::QUERY_CHANGE_NONE,
342            'SELECT'
343        );
344        $res = $this->query( $query, __METHOD__ );
345        if ( !$res ) {
346            return false;
347        }
348        /** @var MysqliResultWrapper $res */
349        '@phan-var MysqliResultWrapper $res';
350        return $res->getInternalFieldInfo( $field );
351    }
352
353    public function indexInfo( $table, $index, $fname = __METHOD__ ) {
354        # https://dev.mysql.com/doc/mysql/en/SHOW_INDEX.html
355        $index = $this->platform->indexName( $index );
356        $query = new Query(
357            'SHOW INDEX FROM ' . $this->tableName( $table ),
358            self::QUERY_IGNORE_DBO_TRX | self::QUERY_CHANGE_NONE,
359            'SHOW'
360        );
361        $res = $this->query( $query, $fname );
362
363        foreach ( $res as $row ) {
364            if ( $row->Key_name === $index ) {
365                return [ 'unique' => !$row->Non_unique ];
366            }
367        }
368
369        return false;
370    }
371
372    /**
373     * @param string $s
374     * @return string
375     */
376    public function strencode( $s ) {
377        return $this->mysqlRealEscapeString( $s );
378    }
379
380    public function serverIsReadOnly() {
381        // Avoid SHOW to avoid internal temporary tables
382        $flags = self::QUERY_IGNORE_DBO_TRX | self::QUERY_CHANGE_NONE;
383        $query = new Query( "SELECT @@GLOBAL.read_only AS Value", $flags, 'SELECT' );
384        $res = $this->query( $query, __METHOD__ );
385        $row = $res->fetchObject();
386
387        return $row && (bool)$row->Value;
388    }
389
390    /**
391     * @return string
392     */
393    public function getSoftwareLink() {
394        [ $variant ] = $this->getMySqlServerVariant();
395        if ( $variant === 'MariaDB' ) {
396            return '[{{int:version-db-mariadb-url}} MariaDB]';
397        }
398
399        return '[{{int:version-db-mysql-url}} MySQL]';
400    }
401
402    /**
403     * @return string[] (one of ("MariaDB","MySQL"), x.y.z version string)
404     */
405    private function getMySqlServerVariant() {
406        $version = $this->getServerVersion();
407
408        // MariaDB includes its name in its version string; this is how MariaDB's version of
409        // the mysql command-line client identifies MariaDB servers.
410        // https://dev.mysql.com/doc/refman/8.0/en/information-functions.html#function_version
411        // https://mariadb.com/kb/en/version/
412        $parts = explode( '-', $version, 2 );
413        $number = $parts[0];
414        $suffix = $parts[1] ?? '';
415        if ( strpos( $suffix, 'MariaDB' ) !== false || strpos( $suffix, '-maria-' ) !== false ) {
416            $vendor = 'MariaDB';
417        } else {
418            $vendor = 'MySQL';
419        }
420
421        return [ $vendor, $number ];
422    }
423
424    /**
425     * @return string
426     */
427    public function getServerVersion() {
428        // MariaDB 10 adds the prefix "5.5.5-", and only some newer client libraries strip
429        // it off (see RPL_VERSION_HACK in include/mysql_com.h).
430        $version = $this->conn->server_info;
431        if (
432            str_starts_with( $version, '5.5.5-' ) &&
433            ( str_contains( $version, 'MariaDB' ) || str_contains( $version, '-maria-' ) )
434        ) {
435            $version = substr( $version, strlen( '5.5.5-' ) );
436        }
437        return $version;
438    }
439
440    /**
441     * @param array $options
442     */
443    public function setSessionOptions( array $options ) {
444        $sqlAssignments = [];
445
446        if ( isset( $options['connTimeout'] ) ) {
447            $encTimeout = (int)$options['connTimeout'];
448            $sqlAssignments[] = "net_read_timeout=$encTimeout";
449            $sqlAssignments[] = "net_write_timeout=$encTimeout";
450        }
451        if ( isset( $options['groupConcatMaxLen'] ) ) {
452            $maxLength = (int)$options['groupConcatMaxLen'];
453            $sqlAssignments[] = "group_concat_max_len=$maxLength";
454        }
455
456        if ( $sqlAssignments ) {
457            $query = new Query(
458                'SET ' . implode( ', ', $sqlAssignments ),
459                self::QUERY_CHANGE_TRX | self::QUERY_CHANGE_NONE,
460                'SET'
461            );
462            $this->query( $query, __METHOD__ );
463        }
464    }
465
466    /**
467     * @param string &$sql
468     * @param string &$newLine
469     * @return bool
470     */
471    public function streamStatementEnd( &$sql, &$newLine ) {
472        if ( preg_match( '/^DELIMITER\s+(\S+)/i', $newLine, $m ) ) {
473            $this->delimiter = $m[1];
474            $newLine = '';
475        }
476
477        return parent::streamStatementEnd( $sql, $newLine );
478    }
479
480    public function doLockIsFree( string $lockName, string $method ) {
481        $query = new Query( $this->platform->lockIsFreeSQLText( $lockName ), self::QUERY_CHANGE_LOCKS, 'SELECT' );
482        $res = $this->query( $query, $method );
483        $row = $res->fetchObject();
484
485        return ( $row->unlocked == 1 );
486    }
487
488    public function doLock( string $lockName, string $method, int $timeout ) {
489        $query = new Query( $this->platform->lockSQLText( $lockName, $timeout ), self::QUERY_CHANGE_LOCKS, 'SELECT' );
490        $res = $this->query( $query, $method );
491        $row = $res->fetchObject();
492
493        return ( $row->acquired !== null ) ? (float)$row->acquired : null;
494    }
495
496    public function doUnlock( string $lockName, string $method ) {
497        $query = new Query( $this->platform->unlockSQLText( $lockName ), self::QUERY_CHANGE_LOCKS, 'SELECT' );
498        $res = $this->query( $query, $method );
499        $row = $res->fetchObject();
500
501        return ( $row->released == 1 );
502    }
503
504    protected function doFlushSession( $fname ) {
505        // Note that RELEASE_ALL_LOCKS() is not supported well enough to use here.
506        // https://mariadb.com/kb/en/release_all_locks/
507        $releaseLockFields = [];
508        foreach ( $this->sessionNamedLocks as $name => $info ) {
509            $encName = $this->addQuotes( $this->platform->makeLockName( $name ) );
510            $releaseLockFields[] = "RELEASE_LOCK($encName)";
511        }
512        if ( $releaseLockFields ) {
513            $sql = 'SELECT ' . implode( ',', $releaseLockFields );
514            $flags = self::QUERY_CHANGE_LOCKS | self::QUERY_NO_RETRY;
515            $query = new Query( $sql, $flags, 'SELECT' );
516            $qs = $this->executeQuery( $query, __METHOD__, $flags );
517            if ( $qs->res === false ) {
518                $this->reportQueryError( $qs->message, $qs->code, $sql, $fname, true );
519            }
520        }
521    }
522
523    public function upsert( $table, array $rows, $uniqueKeys, array $set, $fname = __METHOD__ ) {
524        $identityKey = $this->platform->normalizeUpsertParams( $uniqueKeys, $rows );
525        if ( !$rows ) {
526            return;
527        }
528        $this->platform->assertValidUpsertSetArray( $set, $identityKey, $rows );
529
530        $encTable = $this->tableName( $table );
531        [ $sqlColumns, $sqlTuples ] = $this->platform->makeInsertLists( $rows );
532        $sqlColumnAssignments = $this->makeList( $set, self::LIST_SET );
533        // No need to expose __NEW.* since buildExcludedValue() uses VALUES(column)
534
535        // https://mariadb.com/kb/en/insert-on-duplicate-key-update/
536        // https://dev.mysql.com/doc/refman/8.0/en/insert-on-duplicate.html
537        $sql =
538            "INSERT INTO $encTable " .
539            "($sqlColumns) VALUES $sqlTuples " .
540            "ON DUPLICATE KEY UPDATE $sqlColumnAssignments";
541        $query = new Query( $sql, self::QUERY_CHANGE_ROWS, 'INSERT', $table );
542        $this->query( $query, $fname );
543        // Count updates of conflicting rows and row inserts equally toward the change count
544        $this->lastQueryAffectedRows = min( $this->lastQueryAffectedRows, count( $rows ) );
545    }
546
547    public function replace( $table, $uniqueKeys, $rows, $fname = __METHOD__ ) {
548        $this->platform->normalizeUpsertParams( $uniqueKeys, $rows );
549        if ( !$rows ) {
550            return;
551        }
552        $encTable = $this->tableName( $table );
553        [ $sqlColumns, $sqlTuples ] = $this->platform->makeInsertLists( $rows );
554        // https://dev.mysql.com/doc/refman/8.0/en/replace.html
555        $sql = "REPLACE INTO $encTable ($sqlColumns) VALUES $sqlTuples";
556        // Note that any auto-increment columns on conflicting rows will be reassigned
557        // due to combined DELETE+INSERT semantics. This will be reflected in insertId().
558        $query = new Query( $sql, self::QUERY_CHANGE_ROWS, 'REPLACE', $table );
559        $this->query( $query, $fname );
560        // Do not count deletions of conflicting rows toward the change count
561        $this->lastQueryAffectedRows = min( $this->lastQueryAffectedRows, count( $rows ) );
562    }
563
564    protected function isConnectionError( $errno ) {
565        // https://mariadb.com/kb/en/mariadb-error-codes/
566        // https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html
567        // https://dev.mysql.com/doc/mysql-errors/8.0/en/client-error-reference.html
568        return in_array( $errno, [ 2013, 2006, 2003, 1927, 1053 ], true );
569    }
570
571    protected function isQueryTimeoutError( $errno ) {
572        // https://mariadb.com/kb/en/mariadb-error-codes/
573        // https://dev.mysql.com/doc/refman/8.0/en/client-error-reference.html
574        // https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html
575        return in_array( $errno, [ 3024, 2062, 1969, 1028 ], true );
576    }
577
578    protected function isKnownStatementRollbackError( $errno ) {
579        // https://mariadb.com/kb/en/mariadb-error-codes/
580        // https://dev.mysql.com/doc/mysql-errors/8.0/en/server-error-reference.html
581        return in_array(
582            $errno,
583            [ 3024, 1969, 1022, 1062, 1216, 1217, 1137, 1146, 1051, 1054 ],
584            true
585        );
586    }
587
588    /**
589     * @param string $oldName
590     * @param string $newName
591     * @param bool $temporary
592     * @param string $fname
593     * @return bool
594     */
595    public function duplicateTableStructure(
596        $oldName, $newName, $temporary = false, $fname = __METHOD__
597    ) {
598        $tmp = $temporary ? 'TEMPORARY ' : '';
599        $newNameQuoted = $this->addIdentifierQuotes( $newName );
600        $oldNameQuoted = $this->addIdentifierQuotes( $oldName );
601
602        $query = new Query(
603            "CREATE $tmp TABLE $newNameQuoted (LIKE $oldNameQuoted)",
604            self::QUERY_PSEUDO_PERMANENT | self::QUERY_CHANGE_SCHEMA,
605            $temporary ? 'CREATE TEMPORARY' : 'CREATE',
606            // Use a dot to avoid double-prefixing in Database::getTempTableWrites()
607            '.' . $newName
608        );
609        return $this->query( $query, $fname );
610    }
611
612    /**
613     * List all tables on the database
614     *
615     * @param string|null $prefix Only show tables with this prefix, e.g. mw_
616     * @param string $fname Calling function name
617     * @return array
618     */
619    public function listTables( $prefix = null, $fname = __METHOD__ ) {
620        $qb = $this->newSelectQueryBuilder()
621            ->select( 'table_name' )
622            ->from( 'information_schema.tables' )
623            ->where( [
624                'table_schema' => $this->currentDomain->getDatabase(),
625                'table_type' => 'BASE TABLE'
626            ] )
627            ->caller( $fname );
628        if ( $prefix !== null && $prefix !== '' ) {
629            $qb->andWhere( $this->expr(
630                'table_name', IExpression::LIKE, new LikeValue( $prefix, $this->anyString() )
631            ) );
632        }
633        return $qb->fetchFieldValues();
634    }
635
636    public function selectSQLText(
637        $tables,
638        $vars,
639        $conds = '',
640        $fname = __METHOD__,
641        $options = [],
642        $join_conds = []
643    ) {
644        $sql = parent::selectSQLText( $tables, $vars, $conds, $fname, $options, $join_conds );
645        // https://dev.mysql.com/doc/refman/5.7/en/optimizer-hints.html
646        // https://mariadb.com/kb/en/library/aborting-statements/
647        $timeoutMsec = intval( $options['MAX_EXECUTION_TIME'] ?? 0 );
648        if ( $timeoutMsec > 0 ) {
649            [ $vendor, $number ] = $this->getMySqlServerVariant();
650            if ( $vendor === 'MariaDB' && version_compare( $number, '10.1.2', '>=' ) ) {
651                $timeoutSec = $timeoutMsec / 1000;
652                $sql = "SET STATEMENT max_statement_time=$timeoutSec FOR $sql";
653            } elseif ( $vendor === 'MySQL' && version_compare( $number, '5.7.0', '>=' ) ) {
654                $sql = preg_replace(
655                    '/^SELECT(?=\s)/',
656                    "SELECT /*+ MAX_EXECUTION_TIME($timeoutMsec)*/",
657                    $sql
658                );
659            }
660        }
661
662        return $sql;
663    }
664
665    protected function doSingleStatementQuery( string $sql ): QueryStatus {
666        $conn = $this->getBindingHandle();
667
668        // Hide packet warnings caused by things like dropped connections
669        AtEase::suppressWarnings();
670        $res = $conn->query( $sql );
671        AtEase::restoreWarnings();
672        // Note that mysqli::insert_id only reflects the last query statement
673        $insertId = (int)$conn->insert_id;
674        $this->lastQueryInsertId = $insertId;
675        $this->sessionLastAutoRowId = $insertId ?: $this->sessionLastAutoRowId;
676
677        return new QueryStatus(
678            $res instanceof mysqli_result ? new MysqliResultWrapper( $this, $res ) : $res,
679            $conn->affected_rows,
680            $conn->error,
681            $conn->errno
682        );
683    }
684
685    /**
686     * @param string|null $server
687     * @param string|null $user
688     * @param string|null $password
689     * @param string|null $db
690     * @return mysqli|null
691     * @throws DBConnectionError
692     */
693    private function mysqlConnect( $server, $user, $password, $db ) {
694        if ( !function_exists( 'mysqli_init' ) ) {
695            throw $this->newExceptionAfterConnectError(
696                "MySQLi functions missing, have you compiled PHP with the --with-mysqli option?"
697            );
698        }
699
700        // PHP 8.1.0+ throws exceptions by default. Turn that off for consistency.
701        mysqli_report( MYSQLI_REPORT_OFF );
702
703        // Other than mysql_connect, mysqli_real_connect expects an explicit port number
704        // e.g. "localhost:1234" or "127.0.0.1:1234"
705        // or Unix domain socket path
706        // e.g. "localhost:/socket_path" or "localhost:/foo/bar:bar:bar"
707        // colons are known to be used by Google AppEngine,
708        // see <https://cloud.google.com/sql/docs/mysql/connect-app-engine>
709        //
710        // We need to parse the port or socket path out of $realServer
711        $port = null;
712        $socket = null;
713        $hostAndPort = IPUtils::splitHostAndPort( $server );
714        if ( $hostAndPort ) {
715            $realServer = $hostAndPort[0];
716            if ( $hostAndPort[1] ) {
717                $port = $hostAndPort[1];
718            }
719        } elseif ( substr_count( $server, ':/' ) == 1 ) {
720            // If we have a colon slash instead of a colon and a port number
721            // after the ip or hostname, assume it's the Unix domain socket path
722            [ $realServer, $socket ] = explode( ':', $server, 2 );
723        } else {
724            $realServer = $server;
725        }
726
727        $mysqli = mysqli_init();
728        // Make affectedRows() for UPDATE reflect the number of matching rows, regardless
729        // of whether any column values changed. This is what callers want to know and is
730        // consistent with what Postgres and SQLite return.
731        $flags = MYSQLI_CLIENT_FOUND_ROWS;
732        if ( $this->ssl ) {
733            $flags |= MYSQLI_CLIENT_SSL;
734            $mysqli->ssl_set(
735                $this->sslKeyPath,
736                $this->sslCertPath,
737                $this->sslCAFile,
738                $this->sslCAPath,
739                $this->sslCiphers
740            );
741        }
742        if ( $this->getFlag( self::DBO_COMPRESS ) ) {
743            $flags |= MYSQLI_CLIENT_COMPRESS;
744        }
745        if ( $this->getFlag( self::DBO_PERSISTENT ) ) {
746            $realServer = 'p:' . $realServer;
747        }
748
749        if ( $this->utf8Mode ) {
750            // Tell the server we're communicating with it in UTF-8.
751            // This may engage various charset conversions.
752            $mysqli->options( MYSQLI_SET_CHARSET_NAME, 'utf8' );
753        } else {
754            $mysqli->options( MYSQLI_SET_CHARSET_NAME, 'binary' );
755        }
756
757        $mysqli->options( MYSQLI_OPT_CONNECT_TIMEOUT, $this->connectTimeout ?: 3 );
758        if ( $this->receiveTimeout ) {
759            $mysqli->options( MYSQLI_OPT_READ_TIMEOUT, $this->receiveTimeout );
760        }
761
762        // @phan-suppress-next-line PhanTypeMismatchArgumentNullableInternal socket seems set when used
763        $ok = $mysqli->real_connect( $realServer, $user, $password, $db, $port, $socket, $flags );
764
765        return $ok ? $mysqli : null;
766    }
767
768    protected function closeConnection() {
769        return ( $this->conn instanceof mysqli ) ? mysqli_close( $this->conn ) : true;
770    }
771
772    protected function lastInsertId() {
773        return $this->sessionLastAutoRowId;
774    }
775
776    protected function doHandleSessionLossPreconnect() {
777        // https://mariadb.com/kb/en/last_insert_id/
778        $this->sessionLastAutoRowId = 0;
779    }
780
781    public function insertId() {
782        if ( $this->lastEmulatedInsertId === null ) {
783            $conn = $this->getBindingHandle();
784            // Note that mysqli::insert_id only reflects the last query statement
785            $this->lastEmulatedInsertId = (int)$conn->insert_id;
786        }
787
788        return $this->lastEmulatedInsertId;
789    }
790
791    /**
792     * @return int
793     */
794    public function lastErrno() {
795        if ( $this->conn instanceof mysqli ) {
796            return $this->conn->errno;
797        } else {
798            return mysqli_connect_errno();
799        }
800    }
801
802    /**
803     * @param mysqli|null $conn Optional connection object
804     * @return string
805     */
806    private function mysqlError( $conn = null ) {
807        if ( $conn === null ) {
808            return (string)mysqli_connect_error();
809        } else {
810            return $conn->error;
811        }
812    }
813
814    private function mysqlRealEscapeString( $s ) {
815        $conn = $this->getBindingHandle();
816
817        return $conn->real_escape_string( (string)$s );
818    }
819}