friendica/src/Database/DBA.php

839 lines
21 KiB
PHP
Raw Normal View History

2018-07-20 04:06:13 +02:00
<?php
2020-02-09 15:45:36 +01:00
/**
* @copyright Copyright (C) 2020, Friendica
*
* @license GNU AGPL version 3 or any later version
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*
*/
2018-07-20 04:06:13 +02:00
namespace Friendica\Database;
use Friendica\DI;
use mysqli;
use mysqli_result;
use mysqli_stmt;
use PDO;
use PDOStatement;
2018-07-20 04:06:13 +02:00
/**
* This class is for the low level database stuff that does driver specific things.
*/
class DBA
2018-07-20 04:06:13 +02:00
{
2018-10-21 13:53:16 +02:00
/**
* Lowest possible date value
*/
const NULL_DATE = '0001-01-01';
2018-10-21 13:53:16 +02:00
/**
* Lowest possible datetime value
*/
const NULL_DATETIME = '0001-01-01 00:00:00';
2019-06-07 00:10:45 +02:00
public static function connect()
2019-04-13 20:46:58 +02:00
{
return DI::dba()->connect();
2019-04-13 20:46:58 +02:00
}
2018-07-20 04:06:13 +02:00
/**
* Disconnects the current database connection
*/
public static function disconnect()
{
DI::dba()->disconnect();
2018-07-20 04:06:13 +02:00
}
/**
* Perform a reconnect of an existing database connection
*/
2019-06-07 00:10:45 +02:00
public static function reconnect()
{
return DI::dba()->reconnect();
2018-07-20 04:06:13 +02:00
}
/**
* Return the database object.
* @return PDO|mysqli
*/
public static function getConnection()
2018-07-20 04:06:13 +02:00
{
return DI::dba()->getConnection();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the MySQL server version string
2018-07-20 04:06:13 +02:00
*
* This function discriminate between the deprecated mysql API and the current
* object-oriented mysqli API. Example of returned string: 5.5.46-0+deb8u1
*
* @return string
*/
2019-06-07 00:10:45 +02:00
public static function serverInfo()
{
return DI::dba()->serverInfo();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the selected database name
2018-07-20 04:06:13 +02:00
*
* @return string
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function databaseName()
{
return DI::dba()->databaseName();
}
2020-01-18 21:33:20 +01:00
/**
* Escape all SQL unsafe data
*
* @param string $str
* @return string escaped string
*/
2019-06-07 00:10:45 +02:00
public static function escape($str)
{
return DI::dba()->escape($str);
2018-07-20 04:06:13 +02:00
}
2020-01-18 21:33:20 +01:00
/**
* Checks if the database is connected
*
* @return boolean is the database connected?
*/
2019-06-07 00:10:45 +02:00
public static function connected()
{
return DI::dba()->connected();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Replaces ANY_VALUE() function by MIN() function,
* if the database server does not support ANY_VALUE().
2018-07-20 04:06:13 +02:00
*
* Considerations for Standard SQL, or MySQL with ONLY_FULL_GROUP_BY (default since 5.7.5).
* ANY_VALUE() is available from MySQL 5.7.5 https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html
* A standard fall-back is to use MIN().
*
* @param string $sql An SQL string without the values
* @return string The input SQL string modified if necessary.
*/
2019-06-07 00:10:45 +02:00
public static function anyValueFallback($sql)
{
return DI::dba()->anyValueFallback($sql);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* beautifies the query - useful for "SHOW PROCESSLIST"
2018-07-20 04:06:13 +02:00
*
* This is safe when we bind the parameters later.
* The parameter values aren't part of the SQL.
*
* @param string $sql An SQL string without the values
* @return string The input SQL string modified if necessary.
*/
2019-06-07 00:10:45 +02:00
public static function cleanQuery($sql)
{
2018-07-20 04:06:13 +02:00
$search = ["\t", "\n", "\r", " "];
$replace = [' ', ' ', ' ', ' '];
do {
$oldsql = $sql;
$sql = str_replace($search, $replace, $sql);
} while ($oldsql != $sql);
return $sql;
}
/**
2020-01-18 21:33:20 +01:00
* Convert parameter array to an universal form
2018-07-20 04:06:13 +02:00
* @param array $args Parameter array
* @return array universalized parameter array
*/
2019-06-07 00:10:45 +02:00
public static function getParam($args)
{
2018-07-20 04:06:13 +02:00
unset($args[0]);
// When the second function parameter is an array then use this as the parameter array
if ((count($args) > 0) && (is_array($args[1]))) {
return $args[1];
} else {
return $args;
}
}
/**
2020-01-18 21:33:20 +01:00
* Executes a prepared statement that returns data
* Example: $r = p("SELECT * FROM `item` WHERE `guid` = ?", $guid);
2018-07-20 04:06:13 +02:00
*
* Please only use it with complicated queries.
* For all regular queries please use DBA::select or DBA::exists
2018-07-20 04:06:13 +02:00
*
* @param string $sql SQL statement
* @return bool|object statement object or result object
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function p($sql)
{
2018-07-20 04:06:13 +02:00
$params = self::getParam(func_get_args());
return DI::dba()->p($sql, $params);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Executes a prepared statement like UPDATE or INSERT that doesn't return data
2018-07-20 04:06:13 +02:00
*
* Please use DBA::delete, DBA::insert, DBA::update, ... instead
2018-07-20 04:06:13 +02:00
*
* @param string $sql SQL statement
* @return boolean Was the query successfull? False is returned only if an error occurred
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
public static function e($sql) {
$params = self::getParam(func_get_args());
return DI::dba()->e($sql, $params);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Check if data exists
2018-07-20 04:06:13 +02:00
*
* @param string|array $table Table name or array [schema => table]
* @param array $condition array of fields for condition
2018-07-20 04:06:13 +02:00
*
* @return boolean Are there rows for that condition?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function exists($table, $condition)
{
return DI::dba()->exists($table, $condition);
2018-07-20 04:06:13 +02:00
}
/**
* Fetches the first row
*
* Please use DBA::selectFirst or DBA::exists whenever this is possible.
2018-07-20 04:06:13 +02:00
*
* @param string $sql SQL statement
* @return array first row of query
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function fetchFirst($sql)
{
2018-07-20 04:06:13 +02:00
$params = self::getParam(func_get_args());
return DI::dba()->fetchFirst($sql, $params);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the number of affected rows of the last statement
2018-07-20 04:06:13 +02:00
*
* @return int Number of rows
*/
2019-06-07 00:10:45 +02:00
public static function affectedRows()
{
return DI::dba()->affectedRows();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the number of columns of a statement
2018-07-20 04:06:13 +02:00
*
* @param object Statement object
* @return int Number of columns
*/
2019-06-07 00:10:45 +02:00
public static function columnCount($stmt)
{
return DI::dba()->columnCount($stmt);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the number of rows of a statement
2018-07-20 04:06:13 +02:00
*
* @param PDOStatement|mysqli_result|mysqli_stmt Statement object
* @return int Number of rows
*/
2019-06-07 00:10:45 +02:00
public static function numRows($stmt)
{
return DI::dba()->numRows($stmt);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Fetch a single row
2018-07-20 04:06:13 +02:00
*
* @param mixed $stmt statement object
* @return array current row
*/
2019-06-07 00:10:45 +02:00
public static function fetch($stmt)
{
return DI::dba()->fetch($stmt);
}
2018-07-20 04:06:13 +02:00
/**
2020-01-18 21:33:20 +01:00
* Insert a row into a table
2018-07-20 04:06:13 +02:00
*
* @param string|array $table Table name or array [schema => table]
* @param array $param parameter array
* @param bool $on_duplicate_update Do an update on a duplicate entry
2018-07-20 04:06:13 +02:00
*
2018-10-14 17:32:54 +02:00
* @return boolean was the insert successful?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function insert($table, $param, $on_duplicate_update = false)
{
return DI::dba()->insert($table, $param, $on_duplicate_update);
2018-07-20 04:06:13 +02:00
}
/**
* Replace a row of a table
*
* @param string|array $table Table name or array [schema => table]
* @param array $param parameter array
*
* @return boolean was the insert successful?
* @throws \Exception
*/
public static function replace($table, $param)
{
return DI::dba()->replace($table, $param);
}
2018-07-20 04:06:13 +02:00
/**
2020-01-18 21:33:20 +01:00
* Fetch the id of the last insert command
2018-07-20 04:06:13 +02:00
*
* @return integer Last inserted id
*/
2019-06-07 00:10:45 +02:00
public static function lastInsertId()
{
return DI::dba()->lastInsertId();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Locks a table for exclusive write access
2018-07-20 04:06:13 +02:00
*
* This function can be extended in the future to accept a table array as well.
*
* @param string|array $table Table name or array [schema => table]
2018-07-20 04:06:13 +02:00
*
* @return boolean was the lock successful?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function lock($table)
{
return DI::dba()->lock($table);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Unlocks all locked tables
2018-07-20 04:06:13 +02:00
*
* @return boolean was the unlock successful?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function unlock()
{
return DI::dba()->unlock();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Starts a transaction
2018-07-20 04:06:13 +02:00
*
* @return boolean Was the command executed successfully?
*/
2019-06-07 00:10:45 +02:00
public static function transaction()
2018-07-20 04:06:13 +02:00
{
return DI::dba()->transaction();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Does a commit
2018-07-20 04:06:13 +02:00
*
* @return boolean Was the command executed successfully?
*/
2019-06-07 00:10:45 +02:00
public static function commit()
{
return DI::dba()->commit();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Does a rollback
2018-07-20 04:06:13 +02:00
*
* @return boolean Was the command executed successfully?
*/
2019-06-07 00:10:45 +02:00
public static function rollback()
{
return DI::dba()->rollback();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Delete a row from a table
2018-07-20 04:06:13 +02:00
*
* @param string|array $table Table name
* @param array $conditions Field condition(s)
* @param array $options
2019-01-06 22:06:53 +01:00
* - cascade: If true we delete records in other tables that depend on the one we're deleting through
2018-07-20 04:06:13 +02:00
* relations (default: true)
*
* @return boolean was the delete successful?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function delete($table, array $conditions, array $options = [])
2018-07-20 04:06:13 +02:00
{
return DI::dba()->delete($table, $conditions, $options);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-19 07:05:23 +01:00
* Updates rows in the database.
*
* When $old_fields is set to an array,
2018-07-20 04:06:13 +02:00
* the system will only do an update if the fields in that array changed.
*
* Attention:
* Only the values in $old_fields are compared.
* This is an intentional behaviour.
*
* Example:
* We include the timestamp field in $fields but not in $old_fields.
* Then the row will only get the new timestamp when the other fields had changed.
*
* When $old_fields is set to a boolean value the system will do this compare itself.
* When $old_fields is set to "true" the system will do an insert if the row doesn't exists.
*
* Attention:
* Only set $old_fields to a boolean value when you are sure that you will update a single row.
* When you set $old_fields to "true" then $fields must contain all relevant fields!
*
* @param string|array $table Table name or array [schema => table]
2019-01-06 22:06:53 +01:00
* @param array $fields contains the fields that are updated
* @param array $condition condition array with the key values
2018-07-20 04:06:13 +02:00
* @param array|boolean $old_fields array with the old field values that are about to be replaced (true = update on duplicate)
*
* @return boolean was the update successfull?
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
2019-06-07 00:10:45 +02:00
public static function update($table, $fields, $condition, $old_fields = [])
{
return DI::dba()->update($table, $fields, $condition, $old_fields);
2018-07-20 04:06:13 +02:00
}
/**
* Retrieve a single record from a table and returns it in an associative array
*
* @param string|array $table Table name or array [schema => table]
* @param array $fields
* @param array $condition
* @param array $params
2018-07-20 04:06:13 +02:00
* @return bool|array
2019-01-06 22:06:53 +01:00
* @throws \Exception
* @see self::select
2018-07-20 04:06:13 +02:00
*/
public static function selectFirst($table, array $fields = [], array $condition = [], $params = [])
{
return DI::dba()->selectFirst($table, $fields, $condition, $params);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Select rows from a table and fills an array with the data
*
* @param string|array $table Table name or array [schema => table]
* @param array $fields Array of selected fields, empty for all
* @param array $condition Array of fields for condition
* @param array $params Array of several parameters
*
* @return array Data array
* @throws \Exception
* @see self::select
*/
public static function selectToArray($table, array $fields = [], array $condition = [], array $params = [])
{
return DI::dba()->selectToArray($table, $fields, $condition, $params);
}
2018-07-20 04:06:13 +02:00
/**
2020-01-18 21:33:20 +01:00
* Select rows from a table
2018-07-20 04:06:13 +02:00
*
* @param string|array $table Table name or array [schema => table]
* @param array $fields Array of selected fields, empty for all
* @param array $condition Array of fields for condition
* @param array $params Array of several parameters
2018-07-20 04:06:13 +02:00
*
* @return boolean|object
*
* Example:
* $table = "item";
* $fields = array("id", "uri", "uid", "network");
*
* $condition = array("uid" => 1, "network" => 'dspr');
* or:
* $condition = array("`uid` = ? AND `network` IN (?, ?)", 1, 'dfrn', 'dspr');
*
* $params = array("order" => array("id", "received" => true), "limit" => 10);
*
* $data = DBA::select($table, $fields, $condition, $params);
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
public static function select($table, array $fields = [], array $condition = [], array $params = [])
{
return DI::dba()->select($table, $fields, $condition, $params);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Counts the rows from a table satisfying the provided condition
2018-07-20 04:06:13 +02:00
*
* @param string|array $table Table name or array [schema => table]
* @param array $condition array of fields for condition
* @param array $params Array of several parameters
2018-07-20 04:06:13 +02:00
*
* @return int
*
* Example:
* $table = "item";
*
* $condition = ["uid" => 1, "network" => 'dspr'];
* or:
* $condition = ["`uid` = ? AND `network` IN (?, ?)", 1, 'dfrn', 'dspr'];
*
* $count = DBA::count($table, $condition);
2019-01-06 22:06:53 +01:00
* @throws \Exception
2018-07-20 04:06:13 +02:00
*/
public static function count($table, array $condition = [], array $params = [])
2018-07-20 04:06:13 +02:00
{
return DI::dba()->count($table, $condition, $params);
2018-07-20 04:06:13 +02:00
}
/**
* Build the table query substring from one or more tables, with or without a schema.
*
* Expected formats:
* - table
* - [table1, table2, ...]
* - [schema1 => table1, schema2 => table2, table3, ...]
*
* @param string|array $tables
* @return string
*/
public static function buildTableString($tables)
{
if (is_string($tables)) {
$tables = [$tables];
}
$quotedTables = [];
foreach ($tables as $schema => $table) {
if (is_numeric($schema)) {
$quotedTables[] = self::quoteIdentifier($table);
} else {
$quotedTables[] = self::quoteIdentifier($schema) . '.' . self::quoteIdentifier($table);
}
}
return implode(', ', $quotedTables);
}
/**
* Escape an identifier (table or field name)
*
* @param $identifier
* @return string
*/
public static function quoteIdentifier($identifier)
{
return '`' . str_replace('`', '``', $identifier) . '`';
}
2018-07-20 04:06:13 +02:00
/**
2020-01-18 21:33:20 +01:00
* Returns the SQL condition string built from the provided condition array
2018-07-20 04:06:13 +02:00
*
* This function operates with two modes.
* - Supplied with a field/value associative array, it builds simple strict
2018-07-20 04:06:13 +02:00
* equality conditions linked by AND.
* - Supplied with a flat list, the first element is the condition string and
* the following arguments are the values to be interpolated
*
* $condition = ["uid" => 1, "network" => 'dspr'];
* or:
* $condition = ["`uid` = ? AND `network` IN (?, ?)", 1, 'dfrn', 'dspr'];
*
* In either case, the provided array is left with the parameters only
*
* @param array $condition
* @return string
*/
public static function buildCondition(array &$condition = [])
{
$condition = self::collapseCondition($condition);
2018-07-20 04:06:13 +02:00
$condition_string = '';
if (count($condition) > 0) {
$condition_string = " WHERE (" . array_shift($condition) . ")";
}
2018-07-20 04:06:13 +02:00
return $condition_string;
}
2018-07-20 04:06:13 +02:00
/**
* Collapse an associative array condition into a SQL string + parameters condition array.
*
* ['uid' => 1, 'network' => ['dspr', 'apub']]
*
* gets transformed into
*
* ["`uid` = ? AND `network` IN (?, ?)", 1, 'dspr', 'apub']
*
* @param array $condition
* @return array
*/
public static function collapseCondition(array $condition)
{
// Ensures an always true condition is returned
if (count($condition) < 1) {
return ['1'];
}
reset($condition);
$first_key = key($condition);
if (is_int($first_key)) {
// Already collapsed
return $condition;
}
$values = [];
$condition_string = "";
foreach ($condition as $field => $value) {
if ($condition_string != "") {
$condition_string .= " AND ";
}
if (is_array($value)) {
if (count($value)) {
/* Workaround for MySQL Bug #64791.
* Never mix data types inside any IN() condition.
* In case of mixed types, cast all as string.
* Logic needs to be consistent with DBA::p() data types.
*/
$is_int = false;
$is_alpha = false;
foreach ($value as $single_value) {
if (is_int($single_value)) {
$is_int = true;
} else {
$is_alpha = true;
}
2018-07-20 04:06:13 +02:00
}
if ($is_int && $is_alpha) {
foreach ($value as &$ref) {
if (is_int($ref)) {
$ref = (string)$ref;
}
}
unset($ref); //Prevent accidental re-use.
}
$values = array_merge($values, array_values($value));
$placeholders = substr(str_repeat("?, ", count($value)), 0, -2);
$condition_string .= self::quoteIdentifier($field) . " IN (" . $placeholders . ")";
} else {
// Empty value array isn't supported by IN and is logically equivalent to no match
$condition_string .= "FALSE";
2018-07-20 04:06:13 +02:00
}
} elseif (is_null($value)) {
$condition_string .= self::quoteIdentifier($field) . " IS NULL";
} else {
$values[$field] = $value;
$condition_string .= self::quoteIdentifier($field) . " = ?";
2018-07-20 04:06:13 +02:00
}
}
$condition = array_merge([$condition_string], array_values($values));
return $condition;
2018-07-20 04:06:13 +02:00
}
/**
* Merges the provided conditions into a single collapsed one
*
* @param array ...$conditions One or more condition arrays
* @return array A collapsed condition
* @see DBA::collapseCondition() for the condition array formats
*/
public static function mergeConditions(array ...$conditions)
{
$conditionStrings = [];
$result = [];
foreach ($conditions as $key => $condition) {
$condition = self::collapseCondition($condition);
$conditionStrings[] = array_shift($condition);
// The result array holds the eventual parameter values
$result = array_merge($result, $condition);
}
if (count($conditionStrings)) {
// We prepend the condition string at the end to form a collapsed condition array again
array_unshift($result, implode(' AND ', $conditionStrings));
}
return $result;
}
2018-07-20 04:06:13 +02:00
/**
2020-01-18 21:33:20 +01:00
* Returns the SQL parameter string built from the provided parameter array
2018-07-20 04:06:13 +02:00
*
* Expected format for each key:
*
* group_by:
* - list of column names
*
* order:
* - numeric keyed column name => ASC
* - associative element with boolean value => DESC (true), ASC (false)
* - associative element with string value => 'ASC' or 'DESC' literally
*
* limit:
* - single numeric value => count
* - list with two numeric values => offset, count
*
2018-07-20 04:06:13 +02:00
* @param array $params
* @return string
*/
public static function buildParameter(array $params = [])
{
2019-05-19 02:50:14 +02:00
$groupby_string = '';
if (!empty($params['group_by'])) {
$groupby_string = " GROUP BY " . implode(', ', array_map(['self', 'quoteIdentifier'], $params['group_by']));
2019-05-19 02:50:14 +02:00
}
2018-07-20 04:06:13 +02:00
$order_string = '';
if (isset($params['order'])) {
$order_string = " ORDER BY ";
foreach ($params['order'] AS $fields => $order) {
if ($order === 'RAND()') {
$order_string .= "RAND(), ";
} elseif (!is_int($fields)) {
if ($order !== 'DESC' && $order !== 'ASC') {
$order = $order ? 'DESC' : 'ASC';
}
$order_string .= self::quoteIdentifier($fields) . " " . $order . ", ";
2018-07-20 04:06:13 +02:00
} else {
$order_string .= self::quoteIdentifier($order) . ", ";
2018-07-20 04:06:13 +02:00
}
}
$order_string = substr($order_string, 0, -2);
}
$limit_string = '';
if (isset($params['limit']) && is_numeric($params['limit'])) {
$limit_string = " LIMIT " . intval($params['limit']);
2018-07-20 04:06:13 +02:00
}
if (isset($params['limit']) && is_array($params['limit'])) {
$limit_string = " LIMIT " . intval($params['limit'][0]) . ", " . intval($params['limit'][1]);
}
2019-05-19 05:13:06 +02:00
return $groupby_string . $order_string . $limit_string;
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Fills an array with data from a query
2018-07-20 04:06:13 +02:00
*
* @param object $stmt statement object
2019-01-06 22:06:53 +01:00
* @param bool $do_close
2018-07-20 04:06:13 +02:00
* @return array Data array
*/
2019-06-07 00:10:45 +02:00
public static function toArray($stmt, $do_close = true)
{
return DI::dba()->toArray($stmt, $do_close);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the error number of the last query
2018-07-20 04:06:13 +02:00
*
* @return string Error number (0 if no error)
*/
2019-06-07 00:10:45 +02:00
public static function errorNo()
{
return DI::dba()->errorNo();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Returns the error message of the last query
2018-07-20 04:06:13 +02:00
*
* @return string Error message ('' if no error)
*/
2019-06-07 00:10:45 +02:00
public static function errorMessage()
{
return DI::dba()->errorMessage();
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Closes the current statement
2018-07-20 04:06:13 +02:00
*
* @param object $stmt statement object
* @return boolean was the close successful?
*/
2019-06-07 00:10:45 +02:00
public static function close($stmt)
{
return DI::dba()->close($stmt);
2018-07-20 04:06:13 +02:00
}
/**
2020-01-18 21:33:20 +01:00
* Return a list of database processes
*
* @return array
* 'list' => List of processes, separated in their different states
* 'amount' => Number of concurrent database processes
2019-01-06 22:06:53 +01:00
* @throws \Exception
*/
public static function processlist()
{
return DI::dba()->processlist();
}
/**
* Fetch a database variable
*
* @param string $name
* @return string content
*/
public static function getVariable(string $name)
{
return DI::dba()->getVariable($name);
}
/**
* Checks if $array is a filled array with at least one entry.
*
* @param mixed $array A filled array with at least one entry
*
* @return boolean Whether $array is a filled array or an object with rows
*/
2018-07-21 14:46:04 +02:00
public static function isResult($array)
{
return DI::dba()->isResult($array);
}
/**
2020-01-18 21:33:20 +01:00
* Escapes a whole array
*
* @param mixed $arr Array with values to be escaped
* @param boolean $add_quotation add quotation marks for string values
* @return void
*/
public static function escapeArray(&$arr, $add_quotation = false)
{
DI::dba()->escapeArray($arr, $add_quotation);
}
2018-07-20 04:06:13 +02:00
}