HomePhorge
Diffusion Phorge (HEAD -> master) Code

phorge/src/infrastructure/storage/connection/mysql/AphrontMySQLiDatabaseConnection.php
e81eff68e581HEAD -> master

Last Change
Raw File

AphrontMySQLiDatabaseConnection.php
View Options

<?php
/**
* @phutil-external-symbol class mysqli
*/
final class AphrontMySQLiDatabaseConnection
extends AphrontBaseMySQLDatabaseConnection {
private $connectionOpen = false;
public function escapeUTF8String($string) {
$this->validateUTF8String($string);
return $this->escapeBinaryString($string);
}
public function escapeBinaryString($string) {
return $this->requireConnection()->escape_string($string);
}
public function getInsertID() {
return $this->requireConnection()->insert_id;
}
public function getAffectedRows() {
return $this->requireConnection()->affected_rows;
}
protected function closeConnection() {
if ($this->connectionOpen) {
$this->requireConnection()->close();
$this->connectionOpen = false;
}
}
protected function connect() {
if (!class_exists('mysqli', false)) {
throw new Exception(pht(
'About to call new %s, but the PHP MySQLi extension is not available!',
'mysqli()'));
}
$user = $this->getConfiguration('user');
$host = $this->getConfiguration('host');
$port = $this->getConfiguration('port');
$database = $this->getConfiguration('database');
$pass = $this->getConfiguration('pass');
if ($pass instanceof PhutilOpaqueEnvelope) {
$pass = $pass->openEnvelope();
}
// If the host is "localhost", the port is ignored and mysqli attempts to
// connect over a socket.
if ($port) {
if ($host === 'localhost' || $host === null) {
$host = '127.0.0.1';
}
}
// See T13588. In PHP 8.1, the default "report mode" for MySQLi has
// changed, which causes MySQLi to raise exceptions. Disable exceptions
// to align behavior with older default behavior under MySQLi, which
// this code expects. Plausibly, this code could be updated to use
// MySQLi exceptions to handle errors under a wider range of PHP versions.
mysqli_report(MYSQLI_REPORT_OFF);
$conn = mysqli_init();
$timeout = $this->getConfiguration('timeout');
if ($timeout) {
$conn->options(MYSQLI_OPT_CONNECT_TIMEOUT, $timeout);
}
if ($this->getPersistent()) {
$host = 'p:'.$host;
}
$trap = new PhutilErrorTrap();
$ok = @$conn->real_connect(
$host,
$user,
$pass,
$database,
$port);
$call_error = $trap->getErrorsAsString();
$trap->destroy();
$errno = $conn->connect_errno;
if ($errno) {
$error = $conn->connect_error;
$this->throwConnectionException($errno, $error, $user, $host);
}
// See T13403. If the parameters to "real_connect()" are wrong, it may
// fail without setting an error code. In this case, raise a generic
// exception. (One way to reproduce this is to pass a string to the
// "port" parameter.)
if (!$ok) {
if (strlen($call_error)) {
$message = pht(
'mysqli->real_connect() failed: %s',
$call_error);
} else {
$message = pht(
'mysqli->real_connect() failed, but did not set an error code '.
'or emit a message.');
}
$this->throwConnectionException(
self::CALLERROR_CONNECT,
$message,
$user,
$host);
}
// See T13238. Attempt to prevent "LOAD DATA LOCAL INFILE", which allows a
// malicious server to ask the client for any file. At time of writing,
// this option MUST be set after "real_connect()" on all PHP versions.
$conn->options(MYSQLI_OPT_LOCAL_INFILE, 0);
$this->connectionOpen = true;
$ok = @$conn->set_charset('utf8mb4');
if (!$ok) {
$ok = $conn->set_charset('binary');
}
return $conn;
}
protected function rawQuery($raw_query) {
$conn = $this->requireConnection();
$time_limit = $this->getQueryTimeout();
// If we have a query time limit, run this query synchronously but use
// the async API. This allows us to kill queries which take too long
// without requiring any configuration on the server side.
if ($time_limit && $this->supportsAsyncQueries()) {
$conn->query($raw_query, MYSQLI_ASYNC);
$read = array($conn);
$error = array($conn);
$reject = array($conn);
$result = mysqli::poll($read, $error, $reject, $time_limit);
if ($result === false) {
$this->closeConnection();
throw new Exception(
pht('Failed to poll mysqli connection!'));
} else if ($result === 0) {
$this->closeConnection();
throw new AphrontQueryTimeoutQueryException(
pht(
'Query timed out after %s second(s)!',
new PhutilNumber($time_limit)));
}
return @$conn->reap_async_query();
}
$trap = new PhutilErrorTrap();
$result = @$conn->query($raw_query);
$err = $trap->getErrorsAsString();
$trap->destroy();
// See T13238 and PHI1014. Sometimes, the call to "$conn->query()" may fail
// without setting an error code on the connection. One way to reproduce
// this is to use "LOAD DATA LOCAL INFILE" with "mysqli.allow_local_infile"
// disabled.
// If we have no result and no error code, raise a synthetic query error
// with whatever error message was raised as a local PHP warning.
if (!$result) {
$error_code = $this->getErrorCode($conn);
if (!$error_code) {
if (strlen($err)) {
$message = $err;
} else {
$message = pht(
'Call to "mysqli->query()" failed, but did not set an error '.
'code or emit an error message.');
}
$this->throwQueryCodeException(self::CALLERROR_QUERY, $message);
}
}
return $result;
}
protected function rawQueries(array $raw_queries) {
$conn = $this->requireConnection();
$have_result = false;
$results = array();
foreach ($raw_queries as $key => $raw_query) {
if (!$have_result) {
// End line in front of semicolon to allow single line comments at the
// end of queries.
$have_result = $conn->multi_query(implode("\n;\n\n", $raw_queries));
} else {
$have_result = $conn->next_result();
}
array_shift($raw_queries);
$result = $conn->store_result();
if (!$result && !$this->getErrorCode($conn)) {
$result = true;
}
$results[$key] = $this->processResult($result);
}
if ($conn->more_results()) {
throw new Exception(
pht('There are some results left in the result set.'));
}
return $results;
}
protected function freeResult($result) {
$result->free_result();
}
protected function fetchAssoc($result) {
return $result->fetch_assoc();
}
protected function getErrorCode($connection) {
return $connection->errno;
}
protected function getErrorDescription($connection) {
return $connection->error;
}
public function supportsAsyncQueries() {
return defined('MYSQLI_ASYNC');
}
public function asyncQuery($raw_query) {
$this->checkWrite($raw_query);
$async = $this->beginAsyncConnection();
$async->query($raw_query, MYSQLI_ASYNC);
return $async;
}
public static function resolveAsyncQueries(array $conns, array $asyncs) {
assert_instances_of($conns, __CLASS__);
assert_instances_of($asyncs, 'mysqli');
$read = $error = $reject = array();
foreach ($asyncs as $async) {
$read[] = $error[] = $reject[] = $async;
}
if (!mysqli::poll($read, $error, $reject, 0)) {
return array();
}
$results = array();
foreach ($read as $async) {
$key = array_search($async, $asyncs, $strict = true);
$conn = $conns[$key];
$conn->endAsyncConnection($async);
$results[$key] = $conn->processResult($async->reap_async_query());
}
return $results;
}
}

Owner Packages

  • No Owners