lopar/battles
lopar
/
battles
0
0
Fork 0
Code Issues 21 Pull Requests Releases Wiki Activity
battles/classes/Database/Mysql.php

1042 lines
44 KiB
PHP
Raw Normal View History

initial commit
2018-01-28 16:40:49 +00:00
<?php
/**
* @author Vasiliy Makogon, makogon-vs@yandex.ru
* @link https://github.com/Vasiliy-Makogon/Database/
*
* ---------------------------------------------------------------------------------------------------------------------
* Библиотека для удобной и безопасной работы с СУБД MySql на базе расширения PHP mysqli.
* ---------------------------------------------------------------------------------------------------------------------
*
* Библиотека имулирует технологию Prepared statement (или placeholders) - для формирования корректных SQL-запросов
* (т.е. запросов, исключающих SQL-уязвимости), в строке запроса вместо значений пишутся специальные типизированные
* маркеры - т.н. "заполнители", а сами данные передаются "позже", в качестве последующих аргументов основного метода,
* выполняющего SQL-запрос - Mysql::query($sql [, $arg, $...]):
*
* $db->query('SELECT * FROM `table` WHERE `name` = "?s" AND `age` = ?i', $_POST['name'], $_POST['age']);
*
* Аргументы SQL-запроса, прошедшие через систему placeholders данного класса, экранируются специальными функциями
* экранирования, в зависимости от типа заполнителей. Т.е. вам теперь нет необходимости заключать переменные в функции
* экранирования типа mysqli_real_escape_string($value) или приводить их к числовому типу через (int)$value.
*
* Кроме того, данный класс позволяет:
* - получать "подготовленный" SQL-запрос для отладки, т.е. запрос с реальными значениями, что невозможно сделать
* используя "сырые" драйверы PHP типа PDO.
* - получать список всех запросов выполненных в рамках одного подключения к Mysql-серверу.
*
*
* ---------------------------------------------------------------------------------------------------------------------
* Режимы работы.
* ---------------------------------------------------------------------------------------------------------------------
*
* Существует два режима работы класса:
* Mysql::MODE_STRICT - строгий режим соответствия типа заполнителя и типа аргумента.
* Mysql::MODE_TRANSFORM - режим преобразования аргумента к типу заполнителя при несовпадении
* типа заполнителя и типа аргумента.
*
* Режим Mysql::MODE_TRANSFORM установлен по умолчанию и является основным для большинства приложений.
* Если же вам нужна максимальная прозрачность операций над типами данных, производимых библиотекой Datavase,
* установите режим Mysql::MODE_STRICT.
*
*
* MODE_STRICT
*
* В "строгом" режиме MODE_STRICT аргументы, передаваемые в основной метод Mysql::query(),
* должны соответствовать типу заполнителя.
* Например, попытка передать в качестве аргумента значение 55.5 или '55.5' для заполнителя целочисленного типа ?i
* приведет к выбросу исключения:
*
* $db->setTypeMode(Mysql::MODE_STRICT); // устанавливаем строгий режим работы
* $db->query('SELECT ?i', 55.5); // Попытка указать для заполнителя типа int значение типа double в шаблоне запроса SELECT ?i
*
* Это утверждение не относится к числам (целым и с плавающей точкой), заключенным в строки.
* С точки зрения библиотеки, строка '123' и значение 123 являются типом int.
*
*
* MODE_TRANSFORM
*
* Режим MODE_TRANSFORM является "щадящим" режимом и при несоответствии типа заполнителя и типа аргумента не генерирует
* исключение, а пытается преобразовать аргумент к нужному типу заполнителя посредством самого языка PHP.
*
* Допускаются следующие преобразования:
*
* К типу int приводятся (заполнитель ?i):
* - числа с плавающей точкой, представленные как строка или тип double
* - bool
* - null
*
* К типу double приводятся (заполнитель ?d):
* - целые числа, представленные как строка или тип int
* - bool
* - null
*
* К типу string приводятся (заполнитель ?s):
* - значение boolean TRUE преобразуется в строку "1", а значение FALSE преобразуется в "" (пустую строку).
* - значение типа numeric преобразуется в строку согласно правилам преобразования, определенным языком.
* - NULL преобразуется в пустую строку.
*
* К типу null приводятся (заполнитель ?n):
* - любые аргументы
*
* Для массивов, объектов и ресурсов преобразования не допускаются.
*
*
* ---------------------------------------------------------------------------------------------------------------------
* Типы маркеров-заполнителей
* ---------------------------------------------------------------------------------------------------------------------
*
* ?f - заполнитель имени таблицы или поля (первая буква слова field).
* Данный заполнитель предназначен для случаев, когда имя таблицы или поля передается в запроос через аргумент.
*
* ?i - заполнитель целого числа (первая буква слова integer).
* В режиме MODE_TRANSFORM любые скалярные аргументы принудительно приводятся к типу integer
* согласно правилам преобразования к типу integer в PHP.
*
* ?d - заполнитель числа с плавающей точкой (первая буква слова double).
* В режиме MODE_TRANSFORM любые скалярные аргументы принудительно приводятся к типу float
* согласно правилам преобразования к типу float в PHP.
*
* ?s - заполнитель строкового типа (первая буква слова string).
* В режиме MODE_TRANSFORM любые скалярные аргументы принудительно приводятся к типу string
* согласно правилам преобразования к типу string в PHP
* и экранируются с помощью функции PHP mysqli_real_escape_string().
*
* ?S - заполнитель строкового типа для подстановки в SQL-оператор LIKE (первая буква слова string).
* В режиме MODE_TRANSFORM Любые скалярные аргументы принудительно приводятся к типу string
* согласно правилам преобразования к типу string в PHP
* и экранируются с помощью функции PHP mysqli_real_escape_string() + экранирование спецсимволов,
* используемых в операторе LIKE (%_).
*
* ?n - заполнитель NULL типа (первая буква слова null).
* В режиме MODE_TRANSFORM любые аргументы игнорируются, заполнители заменяются на строку `NULL` в SQL запросе.
*
* ?A* - заполнитель ассоциативного множества для ассоциативного массива-аргумента, генерирующий последовательность
* пар ключ => значение.
* Пример: "key_1" = "val_1", "key_2" = "val_2", ...
*
* ?a* - заполнитель множества из простого (или также ассоциативного) массива-аргумента, генерирующий последовательность
* значений.
* Пример: "val_1", "val_2", ...
*
* где * после маркера заполнителя - один из типов:
* - i (int)
* - p (float)
* - s (string)
* правила преобразования и экранирования такие же, как и для одиночных скалярных аргументов (см. выше).
*
* ?A[?n, ?s, ?i, ?d] - заполнитель ассоциативного множества с явным указанием типа и количества аргументов,
* генерирующий последовательность пар ключ => значение.
* Пример: "key_1" = "val_1", "key_2" => "val_2", ...
*
* ?a[?n, ?s, ?i, ?d] - заполнитель множества с явным указанием типа и количества аргументов, генерирующий
* последовательность значений.
* Пример: "val_1", "val_2", ...
*
*
* ---------------------------------------------------------------------------------------------------------------------
* Ограничивающие кавчки
* ---------------------------------------------------------------------------------------------------------------------
*
* Данный класс при формировании SQL-запроса НЕ занимается проставлением ограничивающих кавычек для одиночных
* заполнителей скалярного типа, таких как ?i, ?d и ?s. Это сделано по идеологическим соображениям,
* автоподстановка кавычек может стать ограничением для возможностей SQL.
* Например, выражение
* $db->query('SELECT "Total: ?s"', '200');
* вернёт строку
* 'Total: 200'
* Если бы кавычки, ограничивающие строковой литерал, ставились бы автоматически,
* то вышеприведённое условие вернуло бы строку
* 'Total: "200"'
* что было бы не ожидаемым поведением.
*
* Тем не менее, для перечислений ?as, ?ai, ?ap, ?As, ?Ai и ?Ap ограничивающие кавычки ставятся принудительно, т.к.
* перечисления всегда используются в запросах, где наличие кавчек обязательно или не играет роли (а так ли это?):
*
* $db->query('INSERT INTO `test` SET ?As', array('name' => 'Маша', 'age' => '23', 'adress' => 'Москва'));
* -> INSERT INTO test SET `name` = "Маша", `age` = "23", `adress` = "Москва"
*
* $db->query('SELECT * FROM table WHERE field IN (?as)', array('55', '12', '132'));
* -> SELECT * FROM table WHERE field IN ("55", "12", "132")
*
* Также исключения составляют заполнители типа ?f, предназначенные для передачи в запрос имен таблиц и полей.
* Аргумент заполнителя ?f всегда обрамляется обратными кавычками (`):
*
* $db->query('SELECT ?f FROM ?f', 'my_field', 'my_table');
* -> SELECT `my_field` FROM `my_table`
*/
namespace Krugozor\Database\Mysql;
class Mysql
{
/**
* Строгий режим типизации.
* Если тип заполнителя не совпадает с типом аргумента, то будет выброшено исключение.
* Пример такой ситуации:
*
* $db->query('SELECT * FROM `table` WHERE `id` = ?i', '2+мусор');
*
* - в данной ситуации тип заполнителя ?i - число или числовая строка,
* а в качестве аргумента передаётся строка '2+мусор' не являющаяся ни числом, ни числовой строкой.
*
* @var int
*/
const MODE_STRICT = 1;
/**
* Режим преобразования.
* Если тип заполнителя не совпадает с типом аргумента, аргумент принудительно будет приведён
* к нужному типу - к типу заполнителя.
* Пример такой ситуации:
*
* $db->query('SELECT * FROM `table` WHERE `id` = ?i', '2+мусор');
*
* - в данной ситуации тип заполнителя ?i - число или числовая строка,
* а в качестве аргумента передаётся строка '2+мусор' не являющаяся ни числом, ни числовой строкой.
* Строка '2+мусор' будет принудительно приведена к типу int согласно правилам преобразования типов в PHP.
*
* @var int
*/
const MODE_TRANSFORM = 2;
/**
* Режим работы инстанцированного объекта.
* См. описание констант self::MODE_STRICT и self::MODE_TRANSFORM.
*
* @var int
*/
protected $type_mode = self::MODE_TRANSFORM;
protected $server;
protected $user;
protected $password;
protected $port;
protected $socket;
/**
* Имя текущей БД.
*
* @var string
*/
protected $database_name;
/**
* Стандартный объект соединения сервером MySQL.
*
* @var mysqli
*/
protected $mysqli;
/**
* Строка последнего SQL-запроса до преобразования.
*
* @var string
*/
private $original_query;
/**
* Строка последнего SQL-запроса после преобразования.
*
* @var string
*/
private $query;
/**
* Массив со всеми запросами, которые были выполнены объектом.
* Ключи - SQL после преобразования, значения - SQL до преобразования.
*
* @var array
*/
private $queries = array();
/**
* Накапливать ли в хранилище $this->queries исполненные запросы.
*
* @var bool
*/
private $store_queries = true;
/**
* Создает инстанс данного класса.
*
* @param string $server имя сервера
* @param string $username имя пользователя
* @param string $password пароль
* @param string $port порт
* @param string $socket сокет
*/
public static function create($server, $username, $password, $port=null, $socket=null)
{
return new self($server, $username, $password, $port, $socket);
}
/**
* Задает набор символов по умолчанию.
* Вызов данного метода эквивалентен следующей установки конфигурации MySql-сервера:
* SET character_set_client = charset_name;
* SET character_set_results = charset_name;
* SET character_set_connection = charset_name;
*
* @param string $charset
* @return Mysql
*/
public function setCharset($charset)
{
if (!$this->mysqli->set_charset($charset)) {
throw new Exception(__METHOD__ . ': ' . $this->mysqli->error);
}
return $this;
}
/**
* Возвращает кодировку по умолчанию, установленную для соединения с БД.
*
* @param void
* @return string
*/
public function getCharset()
{
return $this->mysqli->character_set_name();
}
/**
* Устанавливает имя используемой СУБД.
*
* @param string имя базы данных
* @return Mysql
*/
public function setDatabaseName($database_name)
{
if (!$database_name) {
throw new Exception(__METHOD__ . ': Не указано имя базы данных');
}
$this->database_name = $database_name;
if (!$this->mysqli->select_db($this->database_name)) {
throw new Exception(__METHOD__ . ': ' . $this->mysqli->error);
}
return $this;
}
/**
* Возвращает имя текущей БД.
*
* @param void
* @return string
*/
public function getDatabaseName()
{
return $this->database_name;
}
/**
* Устанавливает режим поведения при несовпадении типа заполнителя и типа аргумента.
*
* @param $value int
* @return Mysql
*/
public function setTypeMode($value)
{
if (!in_array($value, array(self::MODE_STRICT, self::MODE_TRANSFORM))) {
throw new Exception(__METHOD__ . ': Указан неизвестный тип режима');
}
$this->type_mode = $value;
return $this;
}
/**
* Устанавливает свойство $this->store_queries, отвечающее за накопление исполненных запросов в
* хранилище $this->queries.
*
* @param bool $value
* @return Mysql
*/
public function setStoreQueries($value)
{
$this->store_queries = (bool) $value;
return $this;
}
/**
* Выполняет SQL-запрос.
* Принимает обязательный параметр - SQL-запрос и, в случае наличия,
* любое количество аргументов - значения заполнителей.
*
* @param string строка SQL-запроса
* @param mixed аргументы для заполнителей
* @return bool|Statement false в случае ошибки, в обратном случае объект результата
Code cleanup
2018-10-31 19:53:21 +00:00
* @throws Exception
initial commit
2018-01-28 16:40:49 +00:00
*/
public function query()
{
if (!func_num_args()) {
return false;
}
$args = func_get_args();
$query = $this->original_query = array_shift($args);
$this->query = $this->parse($query, $args);
$result = $this->mysqli->query($this->query);
if ($this->store_queries) {
$this->queries[$this->query] = $this->original_query;
}
if ($result === false) {
throw new Exception(__METHOD__ . ': ' . $this->mysqli->error . '; SQL: ' . $this->query);
}
if (is_object($result) && $result instanceof \mysqli_result) {
return new Statement($result);
}
return $result;
}
/**
* Поведение аналогично методу self::query(), только метод принимает только два параметра -
* SQL запрос $query и массив аргументов $arguments, которые и будут заменены на заменители в той
* последовательности, в которой они представленны в массиве $arguments.
*
* @param string
* @param array
* @return bool|Mysql_Statement
*/
public function queryArguments($query, array $arguments=array())
{
array_unshift($arguments, $query);
return call_user_func_array(array($this, 'query'), $arguments);
}
/**
* Обёртка над методом $this->parse().
* Применяется для случаев, когда SQL-запрос формируется частями.
*
* Пример:
* $db->prepare('WHERE `name` = "?s" OR `id` IN(?ai)', 'Василий', array(1, 2));
* Результат:
* WHERE `name` = "Василий" OR `id` IN(1, 2)
*
* @param string SQL-запрос или его часть
* @param mixed аргументы заполнителей
* @return boolean|string
*/
public function prepare()
{
if (!func_num_args()) {
return false;
}
$args = func_get_args();
$query = array_shift($args);
return $this->parse($query, $args);
}
/**
* Получает количество рядов, задействованных в предыдущей MySQL-операции.
* Возвращает количество рядов, задействованных в последнем запросе INSERT, UPDATE или DELETE.
* Если последним запросом был DELETE без оператора WHERE,
* все записи таблицы будут удалены, но функция возвратит ноль.
*
* @see mysqli_affected_rows
* @param void
* @return int
*/
public function getAffectedRows()
{
return $this->mysqli->affected_rows;
}
/**
* Возвращает последний оригинальный SQL-запрос до преобразования.
*
* @param void
* @return string
*/
public function getOriginalQueryString()
{
return $this->original_query;
}
/**
* Возвращает последний выполненный MySQL-запрос (после преобразования).
*
* @param void
* @return string
*/
public function getQueryString()
{
return $this->query;
}
/**
* Возвращает массив со всеми исполненными SQL-запросами в рамках текущего объекта.
*
* @param void
* @return array
*/
public function getQueries()
{
return $this->queries;
}
/**
* Возвращает id, сгенерированный предыдущей операцией INSERT.
*
* @param void
* @return int
*/
public function getLastInsertId()
{
return $this->mysqli->insert_id;
}
/**
* Возвращает оригинальный объект mysqli.
*
* @param void
* @return mysqli
*/
public function getMysqli()
{
return $this->mysqli;
}
public function __destruct()
{
$this->close();
}
/**
* @param string $server
* @param string $username
* @param string $password
* @param string $port
* @param string $socket
* @return void
*/
private function __construct($server, $user, $password, $port, $socket)
{
$this->server = $server;
$this->user = $user;
$this->password = $password;
$this->port = $port;
$this->socket = $socket;
$this->connect();
}
/**
* Устанавливает соеденение с базой данных.
*
* @param void
* @return void
*/
private function connect()
{
if (!is_object($this->mysqli) || !$this->mysqli instanceof mysqli) {
$this->mysqli = @new \mysqli($this->server, $this->user, $this->password, null, $this->port, $this->socket);
if ($this->mysqli->connect_error) {
throw new Exception(__METHOD__ . ': ' . $this->mysqli->connect_error);
}
}
}
/**
* Закрывает MySQL-соединение.
*
* @param void
* @return Mysql
*/
private function close()
{
if (is_object($this->mysqli) && $this->mysqli instanceof mysqli) {
@$this->mysqli->close();
}
return $this;
}
/**
* Возвращает экранированную строку для placeholder-а поиска LIKE (?S).
*
* @param string $var строка в которой необходимо экранировать спец. символы
* @param string $chars набор символов, которые так же необходимо экранировать.
* По умолчанию экранируются следующие символы: `'"%_`.
* @return string
*/
private function escapeLike($var, $chars = "%_")
{
$var = str_replace('\\', '\\\\', $var);
$var = $this->mysqlRealEscapeString($var);
if ($chars) {
$var = addCslashes($var, $chars);
}
return $var;
}
/**
* Экранирует специальные символы в строке для использования в SQL выражении,
* используя текущий набор символов соединения.
*
* @see mysqli_real_escape_string
* @param string
* @return string
*/
private function mysqlRealEscapeString($value)
{
return $this->mysqli->real_escape_string($value);
}
/**
* Возвращает строку описания ошибки при несовпадении типов заполнителей и аргументов.
*
* @param string $type тип заполнителя
* @param mixed $value значение аргумента
* @param string $original_query оригинальный SQL-запрос
* @return string
*/
private function createErrorMessage($type, $value, $original_query)
{
return "Попытка указать для заполнителя типа $type значение типа " . gettype($value) . " в шаблоне запроса $original_query";
}
/**
* Парсит запрос $query и подставляет в него аргументы из $args.
*
* @param string $query SQL запрос или его часть (в случае парсинга условия в скобках [])
* @param array $args аргументы заполнителей
* @param string $original_query "оригинальный", полный SQL-запрос
* @return string SQL запрос для исполнения
*/
private function parse($query, array $args, $original_query=null)
{
$original_query = $original_query ? $original_query : $query;
$offset = 0;
while (($posQM = mb_strpos($query, '?', $offset)) !== false) {
$offset = $posQM;
$placeholder_type = mb_substr($query, $posQM + 1, 1);
// Любые ситуации с нахождением знака вопроса, который не явялется заполнителем.
if ($placeholder_type == '' || !in_array($placeholder_type, array('i', 'd', 's', 'S', 'n', 'A', 'a', 'f'))) {
$offset += 1;
continue;
}
if (!$args) {
throw new Exception(
__METHOD__ . ': количество заполнителей в запросе ' . $original_query .
' не соответствует переданному количеству аргументов'
);
}
$value = array_shift($args);
$is_associative_array = false;
switch ($placeholder_type) {
// `LIKE` search escaping
case 'S':
$is_like_escaping = true;
// Simple string escaping
// В случае установки MODE_TRANSFORM режима, преобразование происходит согласно правилам php типизации
// http://php.net/manual/ru/language.types.string.php#language.types.string.casting
// для bool, null и numeric типа.
case 's':
$value = $this->getValueStringType($value, $original_query);
$value = !empty($is_like_escaping) ? $this->escapeLike($value) : $this->mysqlRealEscapeString($value);
$query = mb_substr_replace($query, $value, $posQM, 2);
$offset += mb_strlen($value);
break;
// Integer
// В случае установки MODE_TRANSFORM режима, преобразование происходит согласно правилам php типизации
// http://php.net/manual/ru/language.types.integer.php#language.types.integer.casting
// для bool, null и string типа.
case 'i':
$value = $this->getValueIntType($value, $original_query);
$query = mb_substr_replace($query, $value, $posQM, 2);
$offset += mb_strlen($value);
break;
// double
case 'd':
$value = $this->getValueFloatType($value, $original_query);
$query = mb_substr_replace($query, $value, $posQM, 2);
$offset += mb_strlen($value);
break;
// NULL insert
case 'n':
$value = $this->getValueNullType($value, $original_query);
$query = mb_substr_replace($query, $value, $posQM, 2);
$offset += mb_strlen($value);
break;
// field or table name
case 'f':
$value = $this->escapeFieldName($value, $original_query);
$query = mb_substr_replace($query, $value, $posQM, 2);
$offset += mb_strlen($value);
break;
// Парсинг массивов.
// Associative array
case 'A':
$is_associative_array = true;
// Simple array
case 'a':
$value = $this->getValueArrayType($value, $original_query);
$next_char = mb_substr($query, $posQM + 2, 1);
if ($next_char != '' && preg_match('#[sid\[]#u', $next_char, $matches)) {
// Парсим выражение вида ?a[?i, "?s", "?s"]
if ($next_char == '[' and ($close = mb_strpos($query, ']', $posQM+3)) !== false) {
// Выражение между скобками [ и ]
$array_parse = mb_substr($query, $posQM+3, $close - ($posQM+3));
$array_parse = trim($array_parse);
$placeholders = array_map('trim', explode(',', $array_parse));
if (count($value) != count($placeholders)) {
throw new Exception('Несовпадение количества аргументов и заполнителей в массиве, запрос ' . $original_query);
}
reset($value);
reset($placeholders);
$replacements = array();
foreach ($placeholders as $placeholder) {
list($key, $val) = each($value);
$replacements[$key] = $this->parse($placeholder, array($val), $original_query);
}
if (!empty($is_associative_array)) {
foreach ($replacements as $key => $val) {
$values[] = $this->escapeFieldName($key, $original_query) . ' = ' . $val;
}
$value = implode(',', $values);
} else {
$value = implode(', ', $replacements);
}
$query = mb_substr_replace($query, $value, $posQM, 4 + mb_strlen($array_parse));
$offset += mb_strlen($value);
}
// Выражение вида ?ai, ?as, ?ap
else if (preg_match('#[sid]#u', $next_char, $matches)) {
$sql = '';
$parts = array();
foreach ($value as $key => $val) {
switch ($matches[0]) {
case 's':
$val = $this->getValueStringType($val, $original_query);
$val = $this->mysqlRealEscapeString($val);
break;
case 'i':
$val = $this->getValueIntType($val, $original_query);
break;
case 'd':
$val = $this->getValueFloatType($val, $original_query);
break;
}
if (!empty($is_associative_array)) {
$parts[] = $this->escapeFieldName($key, $original_query) . ' = "' . $val . '"';
} else {
$parts[] = '"' . $val . '"';
}
}
$value = implode(', ', $parts);
$value = $value !== '' ? $value : 'NULL';
$query = mb_substr_replace($query, $value, $posQM, 3);
$offset += mb_strlen($value);
}
} else {
throw new Exception('Попытка воспользоваться заполнителем массива без указания типа данных его элементов');
}
break;
}
}
return $query;
}
/**
* В зависимости от типа режима возвращает либо строковое значение $value,
* либо кидает исключение.
*
* @param mixed $value
* @param string $original_query оригинальный SQL запрос
* @throws Exception
* @return string
*/
private function getValueStringType($value, $original_query)
{
if (!is_string($value) && $this->type_mode == self::MODE_STRICT) {
// Если это числовой string, меняем его тип для вывода в тексте исключения его типа.
if ($this->isInteger($value) || $this->isFloat($value)) {
$value += 0;
}
throw new Exception($this->createErrorMessage('string', $value, $original_query));
}
// меняем поведение PHP в отношении приведения bool к string
if (is_bool($value)) {
return (string) (int) $value;
}
if (!is_string($value) && !(is_numeric($value) || is_null($value))) {
throw new Exception($this->createErrorMessage('string', $value, $original_query));
}
return (string) $value;
}
/**
* В зависимости от типа режима возвращает либо строковое значение числа $value,
* приведенного к типу int, либо кидает исключение.
*
* @param mixed $value
* @param string $original_query оригинальный SQL запрос
* @throws Exception
* @return string
*/
private function getValueIntType($value, $original_query)
{
if ($this->isInteger($value)) {
return $value;
}
switch ($this->type_mode) {
case self::MODE_TRANSFORM:
if ($this->isFloat($value) || is_null($value) || is_bool($value)) {
return (int) $value;
}
case self::MODE_STRICT:
// Если это числовой string, меняем его тип для вывода в тексте исключения его типа.
if ($this->isFloat($value)) {
$value += 0;
}
throw new Exception($this->createErrorMessage('integer', $value, $original_query));
}
}
/**
* В зависимости от типа режима возвращает либо строковое значение числа $value,
* приведенного к типу float, либо кидает исключение.
*
* Внимание! Разделитель целой и дробной части, возвращаемый float, может не совпадать с разделителем СУБД.
* Для установки необходимого разделителя дробной части используйте setlocale().
*
* @param mixed $value
* @param string $original_query оригинальный SQL запрос
* @throws Exception
* @return string
*/
private function getValueFloatType($value, $original_query)
{
if ($this->isFloat($value)) {
return $value;
}
switch ($this->type_mode) {
case self::MODE_TRANSFORM:
if ($this->isInteger($value) || is_null($value) || is_bool($value)) {
return (float) $value;
}
case self::MODE_STRICT:
// Если это числовой string, меняем его тип на int для вывода в тексте исключения.
if ($this->isInteger($value)) {
$value += 0;
}
throw new Exception($this->createErrorMessage('double', $value, $original_query));
}
}
/**
* В зависимости от типа режима возвращает либо строковое значение 'NULL',
* либо кидает исключение.
*
* @param mixed $value
* @param string $original_query оригинальный SQL запрос
* @throws Exception
* @return string
*/
private function getValueNullType($value, $original_query)
{
if ($value !== null && $this->type_mode == self::MODE_STRICT) {
// Если это числовой string, меняем его тип для вывода в тексте исключения его типа.
if ($this->isInteger($value) || $this->isFloat($value)) {
$value += 0;
}
throw new Exception($this->createErrorMessage('NULL', $value, $original_query));
}
return 'NULL';
}
/**
* Всегда генерирует исключение, если $value не является массивом.
* Первоначально была идея в режиме self::MODE_TRANSFORM приводить к типу array
* скалярные данные, но на данный момент я считаю это излишним послаблением для клиентов,
* которые будут использовать данный класс.
*
* @param mixed $value
* @param string $original_query
* @throws Exception
* @return array
*/
private function getValueArrayType($value, $original_query)
{
if (!is_array($value)) {
throw new Exception($this->createErrorMessage('array', $value, $original_query));
}
return $value;
}
/**
* Экранирует имя поля таблицы или столбца.
*
* @param string $value
* @return string $value
*/
private function escapeFieldName($value, $original_query)
{
if (!is_string($value)) {
throw new Exception($this->createErrorMessage('field', $value, $original_query));
}
$new_value = '';
$replace = function($value){
return '`' . str_replace("`", "``", $value) . '`';
};
// Признак обнаружения символа текущей базы данных
$dot = false;
if ($values = explode('.', $value)) {
foreach ($values as $value) {
if ($value === '') {
if (!$dot) {
$dot = true;
$new_value .= '.';
} else {
throw new Exception('Два символа `.` идущие подряд в имени столбца или таблицы');
}
} else {
$new_value .= $replace($value) . '.';
}
}
return rtrim($new_value, '.');
} else {
return $replace($value);
}
}
/**
* Проверяет, является ли значение целым числом, умещающимся в диапазон PHP_INT_MAX.
*
* @param mixed $input
* @return boolean
*/
private function isInteger($val)
{
if (!is_scalar($val) || is_bool($val)) {
return false;
}
return $this->isFloat($val) ? false : preg_match('~^((?:\+|-)?[0-9]+)$~', $val) === 1;
}
/**
* Проверяет, является ли значение числом с плавающей точкой.
*
* @param mixed $input
* @return boolean
*/
private function isFloat($val)
{
if (!is_scalar($val) || is_bool($val)) {
return false;
}
$type = gettype($val);
if ($type === "double") {
return true;
} else {
return preg_match("/^([+-]*\\d+)*\\.(\\d+)*$/", $val) === 1;
}
}
}
/**
* Заменяет часть строки string, начинающуюся с символа с порядковым номером start
* и (необязательной) длиной length, строкой replacement и возвращает результат.
*
* @param string $string
* @param string $replacement
* @param string $start
* @param string $length
* @param string $encoding
* @return string
*/
if (!function_exists("mb_substr_replace"))
{
function mb_substr_replace($string, $replacement, $start, $length=null, $encoding=null)
{
if ($encoding == null) {
$encoding = mb_internal_encoding();
}
if ($length == null) {
return mb_substr($string, 0, $start, $encoding) . $replacement;
} else {
if ($length < 0) {
$length = mb_strlen($string, $encoding) - $start + $length;
}
return
mb_substr($string, 0, $start, $encoding) .
$replacement .
mb_substr($string, $start + $length, mb_strlen($string, $encoding), $encoding);
}
}
}