349 lines
8.6 KiB
PHP
349 lines
8.6 KiB
PHP
<?php
|
|
|
|
namespace Database\Mysql;
|
|
|
|
use Exception;
|
|
use Kiri;
|
|
use Kiri\Events\EventProvider;
|
|
use Kiri\Pool\StopHeartbeatCheck;
|
|
use Kiri\Server\Events\OnWorkerExit;
|
|
use PDOStatement;
|
|
use Kiri\Server\WorkerStatus;
|
|
use Kiri\Server\Abstracts\StatusEnum;
|
|
use Swoole\Timer;
|
|
|
|
/**
|
|
*
|
|
*/
|
|
class PDO implements StopHeartbeatCheck
|
|
{
|
|
|
|
const DB_ERROR_MESSAGE = 'The system is busy, please try again later.';
|
|
|
|
|
|
private ?\PDO $pdo = null;
|
|
|
|
|
|
private int $_transaction = 0;
|
|
|
|
private int $_last = 0;
|
|
|
|
public string $dbname;
|
|
public string $cds;
|
|
public string $username;
|
|
public string $password;
|
|
public string $charset;
|
|
public int $connect_timeout;
|
|
public int $read_timeout;
|
|
|
|
private int $_timerId = -1;
|
|
|
|
|
|
public array $attributes = [];
|
|
|
|
|
|
/**
|
|
* @param array $config
|
|
*/
|
|
public function __construct(array $config)
|
|
{
|
|
$this->dbname = $config['dbname'];
|
|
$this->cds = $config['cds'];
|
|
$this->username = $config['username'];
|
|
$this->password = $config['password'];
|
|
$this->connect_timeout = $config['connect_timeout'] ?? 30;
|
|
$this->read_timeout = $config['read_timeout'] ?? 10;
|
|
$this->charset = $config['charset'] ?? 'utf8mb4';
|
|
$this->attributes = $config['attributes'] ?? [];
|
|
}
|
|
|
|
|
|
/**
|
|
* @return void
|
|
* @throws Exception
|
|
*/
|
|
public function init(): void
|
|
{
|
|
$eventProvider = Kiri::getDi()->get(EventProvider::class);
|
|
$eventProvider->on(OnWorkerExit::class, [$this, 'onWorkerExit']);
|
|
$this->_timerId = Timer::tick(60000, [$this, 'check']);
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function inTransaction(): bool
|
|
{
|
|
return $this->_transaction > 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param Kiri\Server\Events\OnWorkerExit $exit
|
|
* @return void
|
|
*/
|
|
public function onWorkerExit(OnWorkerExit $exit): void
|
|
{
|
|
$this->stopHeartbeatCheck();
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function stopHeartbeatCheck(): void
|
|
{
|
|
$this->pdo = null;
|
|
if ($this->_timerId > -1) {
|
|
Timer::clear($this->_timerId);
|
|
$this->_timerId = -1;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function beginTransaction()
|
|
{
|
|
if ($this->_transaction == 0) {
|
|
$this->_pdo()->beginTransaction();
|
|
}
|
|
$this->_transaction++;
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function commit()
|
|
{
|
|
$this->_transaction--;
|
|
if ($this->_transaction == 0) {
|
|
$this->_pdo()->commit();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
*
|
|
*/
|
|
public function rollback()
|
|
{
|
|
$this->_transaction--;
|
|
if ($this->_transaction == 0) {
|
|
$this->_pdo()->rollBack();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return bool|array|null
|
|
* @throws Exception
|
|
*/
|
|
public function fetchAll(string $sql, array $params = []): bool|null|array
|
|
{
|
|
$pdo = $this->queryPrev($sql, $params);
|
|
|
|
$result = $pdo->fetchAll(\PDO::FETCH_ASSOC);
|
|
$pdo->closeCursor();
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return bool|array|null
|
|
* @throws Exception
|
|
*/
|
|
public function fetch(string $sql, array $params = []): bool|null|array
|
|
{
|
|
$pdo = $this->queryPrev($sql, $params);
|
|
|
|
$result = $pdo->fetch(\PDO::FETCH_ASSOC);
|
|
$pdo->closeCursor();
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return bool|array|null
|
|
* @throws \Exception
|
|
*/
|
|
public function fetchColumn(string $sql, array $params = []): bool|null|array
|
|
{
|
|
$pdo = $this->queryPrev($sql, $params);
|
|
|
|
$result = $pdo->fetchColumn(\PDO::FETCH_ASSOC);
|
|
$pdo->closeCursor();
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return int
|
|
* @throws Exception
|
|
*/
|
|
public function count(string $sql, array $params = []): int
|
|
{
|
|
$pdo = $this->queryPrev($sql, $params);
|
|
|
|
$result = $pdo->rowCount();
|
|
$pdo->closeCursor();
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return PDOStatement
|
|
* @throws Exception
|
|
*/
|
|
private function queryPrev(string $sql, array $params = []): PDOStatement
|
|
{
|
|
try {
|
|
if ($this->_timerId === -1) {
|
|
$this->_timerId = Timer::tick(6000, [$this, 'check']);
|
|
}
|
|
$this->_last = time();
|
|
if (($statement = $this->_pdo()->query($sql)) === false) {
|
|
throw new Exception($this->_pdo()->errorInfo()[1]);
|
|
}
|
|
return $this->bindValue($statement, $params);
|
|
} catch (\PDOException|\Throwable $throwable) {
|
|
if (str_contains($throwable->getMessage(), 'MySQL server has gone away')) {
|
|
$this->pdo = null;
|
|
|
|
return $this->queryPrev($sql, $params);
|
|
}
|
|
throw new Exception($throwable->getMessage());
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @return bool
|
|
*/
|
|
public function check(): bool
|
|
{
|
|
try {
|
|
if ($this->_last == 0) $this->_last = time();
|
|
if (time() - $this->_last >= 600) {
|
|
return $result = false;
|
|
} else if (!($this->pdo instanceof \PDO)) {
|
|
return $result = false;
|
|
}
|
|
$this->pdo->getAttribute(\PDO::ATTR_SERVER_INFO);
|
|
$result = true;
|
|
} catch (\Throwable $throwable) {
|
|
if (!str_contains($throwable->getMessage(), 'Idle dis')) {
|
|
Kiri::getLogger()->error($throwable->getMessage());
|
|
}
|
|
$result = false;
|
|
} finally {
|
|
return $this->afterCheck($result);
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @param bool $result
|
|
* @return bool
|
|
*/
|
|
private function afterCheck(bool $result): bool
|
|
{
|
|
$container = Kiri::getDi()->get(WorkerStatus::class);
|
|
if (!$result || $container->is(StatusEnum::EXIT)) {
|
|
$this->pdo = null;
|
|
$result = Timer::clear($this->_timerId);
|
|
$this->_timerId = -1;
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param PDOStatement $statement
|
|
* @param array $params
|
|
* @return PDOStatement
|
|
*/
|
|
private function bindValue(PDOStatement $statement, array $params = []): PDOStatement
|
|
{
|
|
if (empty($params)) return $statement;
|
|
foreach ($params as $key => $param) {
|
|
$statement->bindValue($key, $param);
|
|
}
|
|
return $statement;
|
|
}
|
|
|
|
|
|
/**
|
|
* @param string $sql
|
|
* @param array $params
|
|
* @return int
|
|
* @throws Exception
|
|
*/
|
|
public function execute(string $sql, array $params = []): int
|
|
{
|
|
$pdo = $this->_pdo();
|
|
if ($this->_timerId === -1) {
|
|
$this->_timerId = Timer::tick(6000, [$this, 'check']);
|
|
}
|
|
$this->_last = time();
|
|
if (!(($prepare = $pdo->prepare($sql)) instanceof PDOStatement)) {
|
|
throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
|
|
}
|
|
if ($prepare->execute($params) === false) {
|
|
throw new Exception($prepare->errorInfo()[2] ?? static::DB_ERROR_MESSAGE);
|
|
}
|
|
|
|
$result = (int)$pdo->lastInsertId();
|
|
$prepare->closeCursor();
|
|
|
|
return $result == 0 ? true : $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return \PDO
|
|
*/
|
|
public function _pdo(): \PDO
|
|
{
|
|
if (!($this->pdo instanceof \PDO)) {
|
|
$this->pdo = $this->newClient();
|
|
}
|
|
return $this->pdo;
|
|
}
|
|
|
|
|
|
/**
|
|
* @return \PDO
|
|
*/
|
|
private function newClient(): \PDO
|
|
{
|
|
$link = new \PDO('mysql:dbname=' . $this->dbname . ';host=' . $this->cds, $this->username, $this->password, [
|
|
\PDO::ATTR_EMULATE_PREPARES => false,
|
|
\PDO::ATTR_CASE => \PDO::CASE_NATURAL,
|
|
\PDO::ATTR_TIMEOUT => $this->connect_timeout,
|
|
\PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES ' . $this->charset
|
|
]);
|
|
$link->setAttribute(\PDO::ATTR_ERRMODE, \PDO::ERRMODE_EXCEPTION);
|
|
$link->setAttribute(\PDO::ATTR_STRINGIFY_FETCHES, false);
|
|
$link->setAttribute(\PDO::ATTR_ORACLE_NULLS, \PDO::NULL_EMPTY_STRING);
|
|
foreach ($this->attributes as $key => $attribute) {
|
|
$link->setAttribute($key, $attribute);
|
|
}
|
|
return $link;
|
|
}
|
|
|
|
}
|