// Please use App->getConfigVariable() instead.
//use Friendica\Core\Config;
+use Friendica\Core\Logger;
use Friendica\Core\System;
use Friendica\Util\DateTimeFormat;
use mysqli;
+use mysqli_result;
+use mysqli_stmt;
use PDO;
use PDOException;
use PDOStatement;
*/
class DBA
{
+ /**
+ * Lowest possible date value
+ */
+ const NULL_DATE = '0001-01-01';
+ /**
+ * Lowest possible datetime value
+ */
+ const NULL_DATETIME = '0001-01-01 00:00:00';
+
public static $connected = false;
private static $server_info = '';
- private static $db;
+ private static $connection;
private static $driver;
private static $error = false;
private static $errorno = 0;
public static function connect($serveraddr, $user, $pass, $db, $charset = null)
{
- if (!is_null(self::$db) && self::connected()) {
+ if (!is_null(self::$connection) && self::connected()) {
return true;
}
}
try {
- self::$db = @new PDO($connect, $user, $pass);
- self::$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
+ self::$connection = @new PDO($connect, $user, $pass);
+ self::$connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
self::$connected = true;
} catch (PDOException $e) {
+ /// @TODO At least log exception, don't ignore it!
}
}
self::$driver = 'mysqli';
if ($port > 0) {
- self::$db = @new mysqli($server, $user, $pass, $db, $port);
+ self::$connection = @new mysqli($server, $user, $pass, $db, $port);
} else {
- self::$db = @new mysqli($server, $user, $pass, $db);
+ self::$connection = @new mysqli($server, $user, $pass, $db);
}
if (!mysqli_connect_errno()) {
self::$connected = true;
if ($charset) {
- self::$db->set_charset($charset);
+ self::$connection->set_charset($charset);
}
}
}
// No suitable SQL driver was found.
if (!self::$connected) {
self::$driver = null;
- self::$db = null;
+ self::$connection = null;
}
return self::$connected;
*/
public static function disconnect()
{
- if (is_null(self::$db)) {
+ if (is_null(self::$connection)) {
return;
}
switch (self::$driver) {
case 'pdo':
- self::$db = null;
+ self::$connection = null;
break;
case 'mysqli':
- self::$db->close();
- self::$db = null;
+ self::$connection->close();
+ self::$connection = null;
break;
}
}
* Return the database object.
* @return PDO|mysqli
*/
- public static function get_db()
+ public static function getConnection()
{
- return self::$db;
+ return self::$connection;
}
/**
*
* @return string
*/
- public static function server_info() {
+ public static function serverInfo() {
if (self::$server_info == '') {
switch (self::$driver) {
case 'pdo':
- self::$server_info = self::$db->getAttribute(PDO::ATTR_SERVER_VERSION);
+ self::$server_info = self::$connection->getAttribute(PDO::ATTR_SERVER_VERSION);
break;
case 'mysqli':
- self::$server_info = self::$db->server_info;
+ self::$server_info = self::$connection->server_info;
break;
}
}
* @param string $query The database query that will be analyzed
*/
private static function logIndex($query) {
- $a = get_app();
+ $a = \get_app();
if (!$a->getConfigVariable('system', 'db_log_index')) {
return;
}
$r = self::p("EXPLAIN ".$query);
- if (!DBM::is_result($r)) {
+ if (!self::isResult($r)) {
return;
}
}
public static function escape($str) {
- switch (self::$driver) {
- case 'pdo':
- return substr(@self::$db->quote($str, PDO::PARAM_STR), 1, -1);
- case 'mysqli':
- return @self::$db->real_escape_string($str);
+ if (self::$connected) {
+ switch (self::$driver) {
+ case 'pdo':
+ return substr(@self::$connection->quote($str, PDO::PARAM_STR), 1, -1);
+
+ case 'mysqli':
+ return @self::$connection->real_escape_string($str);
+ }
+ } else {
+ return str_replace("'", "\\'", $str);
}
}
public static function connected() {
$connected = false;
- if (is_null(self::$db)) {
+ if (is_null(self::$connection)) {
return false;
}
switch (self::$driver) {
case 'pdo':
$r = self::p("SELECT 1");
- if (DBM::is_result($r)) {
+ if (self::isResult($r)) {
$row = self::toArray($r);
$connected = ($row[0]['1'] == '1');
}
break;
case 'mysqli':
- $connected = self::$db->ping();
+ $connected = self::$connection->ping();
break;
}
return $connected;
* @return string The input SQL string modified if necessary.
*/
public static function anyValueFallback($sql) {
- $server_info = self::server_info();
+ $server_info = self::serverInfo();
if (version_compare($server_info, '5.7.5', '<') ||
(stripos($server_info, 'MariaDB') !== false)) {
$sql = str_ireplace('ANY_VALUE(', 'MIN(', $sql);
* @usage Example: $r = p("SELECT * FROM `item` WHERE `guid` = ?", $guid);
*
* Please only use it with complicated queries.
- * For all regular queries please use dba::select or dba::exists
+ * For all regular queries please use DBA::select or DBA::exists
*
* @param string $sql SQL statement
* @return bool|object statement object or result object
*/
public static function p($sql) {
- $a = get_app();
+ $a = \get_app();
$stamp1 = microtime(true);
if ((substr_count($sql, '?') != count($args)) && (count($args) > 0)) {
// Question: Should we continue or stop the query here?
- logger('Parameter mismatch. Query "'.$sql.'" - Parameters '.print_r($args, true), LOGGER_DEBUG);
+ Logger::log('Parameter mismatch. Query "'.$sql.'" - Parameters '.print_r($args, true), Logger::DEBUG);
}
$sql = self::cleanQuery($sql);
case 'pdo':
// If there are no arguments we use "query"
if (count($args) == 0) {
- if (!$retval = self::$db->query($sql)) {
- $errorInfo = self::$db->errorInfo();
+ if (!$retval = self::$connection->query($sql)) {
+ $errorInfo = self::$connection->errorInfo();
self::$error = $errorInfo[2];
self::$errorno = $errorInfo[1];
$retval = false;
break;
}
- if (!$stmt = self::$db->prepare($sql)) {
- $errorInfo = self::$db->errorInfo();
+ if (!$stmt = self::$connection->prepare($sql)) {
+ $errorInfo = self::$connection->errorInfo();
self::$error = $errorInfo[2];
self::$errorno = $errorInfo[1];
$retval = false;
// The fallback routine is called as well when there are no arguments
if (!$can_be_prepared || (count($args) == 0)) {
- $retval = self::$db->query(self::replaceParameters($sql, $args));
- if (self::$db->errno) {
- self::$error = self::$db->error;
- self::$errorno = self::$db->errno;
+ $retval = self::$connection->query(self::replaceParameters($sql, $args));
+ if (self::$connection->errno) {
+ self::$error = self::$connection->error;
+ self::$errorno = self::$connection->errno;
$retval = false;
} else {
if (isset($retval->num_rows)) {
self::$affected_rows = $retval->num_rows;
} else {
- self::$affected_rows = self::$db->affected_rows;
+ self::$affected_rows = self::$connection->affected_rows;
}
}
break;
}
- $stmt = self::$db->stmt_init();
+ $stmt = self::$connection->stmt_init();
if (!$stmt->prepare($sql)) {
self::$error = $stmt->error;
}
if (!$stmt->execute()) {
- self::$error = self::$db->error;
- self::$errorno = self::$db->errno;
+ self::$error = self::$connection->error;
+ self::$errorno = self::$connection->errno;
$retval = false;
} else {
$stmt->store_result();
$error = self::$error;
$errorno = self::$errorno;
- logger('DB Error '.self::$errorno.': '.self::$error."\n".
+ Logger::log('DB Error '.self::$errorno.': '.self::$error."\n".
System::callstack(8)."\n".self::replaceParameters($sql, $args));
// On a lost connection we try to reconnect - but only once.
if (self::$in_retrial || !self::reconnect()) {
// It doesn't make sense to continue when the database connection was lost
if (self::$in_retrial) {
- logger('Giving up retrial because of database error '.$errorno.': '.$error);
+ Logger::log('Giving up retrial because of database error '.$errorno.': '.$error);
} else {
- logger("Couldn't reconnect after database error ".$errorno.': '.$error);
+ Logger::log("Couldn't reconnect after database error ".$errorno.': '.$error);
}
exit(1);
} else {
// We try it again
- logger('Reconnected after database error '.$errorno.': '.$error);
+ Logger::log('Reconnected after database error '.$errorno.': '.$error);
self::$in_retrial = true;
$ret = self::p($sql, $args);
self::$in_retrial = false;
self::$errorno = $errorno;
}
- $a->save_timestamp($stamp1, 'database');
+ $a->saveTimestamp($stamp1, 'database');
if ($a->getConfigValue('system', 'db_log')) {
$stamp2 = microtime(true);
/**
* @brief Executes a prepared statement like UPDATE or INSERT that doesn't return data
*
- * Please use dba::delete, dba::insert, dba::update, ... instead
+ * Please use DBA::delete, DBA::insert, DBA::update, ... instead
*
* @param string $sql SQL statement
* @return boolean Was the query successfull? False is returned only if an error occurred
*/
public static function e($sql) {
- $a = get_app();
+ $a = \get_app();
$stamp = microtime(true);
$error = self::$error;
$errorno = self::$errorno;
- logger('DB Error '.self::$errorno.': '.self::$error."\n".
+ Logger::log('DB Error '.self::$errorno.': '.self::$error."\n".
System::callstack(8)."\n".self::replaceParameters($sql, $params));
// On a lost connection we simply quit.
// A reconnect like in self::p could be dangerous with modifications
if ($errorno == 2006) {
- logger('Giving up because of database error '.$errorno.': '.$error);
+ Logger::log('Giving up because of database error '.$errorno.': '.$error);
exit(1);
}
self::$errorno = $errorno;
}
- $a->save_timestamp($stamp, "database_write");
+ $a->saveTimestamp($stamp, "database_write");
return $retval;
}
if (is_bool($stmt)) {
$retval = $stmt;
} else {
- $retval = (self::num_rows($stmt) > 0);
+ $retval = (self::numRows($stmt) > 0);
}
self::close($stmt);
/**
* Fetches the first row
*
- * Please use dba::selectFirst or dba::exists whenever this is possible.
+ * Please use DBA::selectFirst or DBA::exists whenever this is possible.
*
* @brief Fetches the first row
* @param string $sql SQL statement
* @param PDOStatement|mysqli_result|mysqli_stmt Statement object
* @return int Number of rows
*/
- public static function num_rows($stmt) {
+ public static function numRows($stmt) {
if (!is_object($stmt)) {
return 0;
}
* @return array current row
*/
public static function fetch($stmt) {
- $a = get_app();
+ $a = \get_app();
$stamp1 = microtime(true);
}
}
- $a->save_timestamp($stamp1, 'database');
+ $a->saveTimestamp($stamp1, 'database');
return $columns;
}
* @param array $param parameter array
* @param bool $on_duplicate_update Do an update on a duplicate entry
*
- * @return boolean was the insert successfull?
+ * @return boolean was the insert successful?
*/
public static function insert($table, $param, $on_duplicate_update = false) {
if (empty($table) || empty($param)) {
- logger('Table and fields have to be set');
+ Logger::log('Table and fields have to be set');
return false;
}
public static function lastInsertId() {
switch (self::$driver) {
case 'pdo':
- $id = self::$db->lastInsertId();
+ $id = self::$connection->lastInsertId();
break;
case 'mysqli':
- $id = self::$db->insert_id;
+ $id = self::$connection->insert_id;
break;
}
return $id;
// See here: https://dev.mysql.com/doc/refman/5.7/en/lock-tables-and-transactions.html
if (self::$driver == 'pdo') {
self::e("SET autocommit=0");
- self::$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
+ self::$connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
} else {
- self::$db->autocommit(false);
+ self::$connection->autocommit(false);
}
$success = self::e("LOCK TABLES `".self::escape($table)."` WRITE");
if (self::$driver == 'pdo') {
- self::$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
+ self::$connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
}
if (!$success) {
if (self::$driver == 'pdo') {
self::e("SET autocommit=1");
} else {
- self::$db->autocommit(true);
+ self::$connection->autocommit(true);
}
} else {
self::$in_transaction = true;
self::performCommit();
if (self::$driver == 'pdo') {
- self::$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
+ self::$connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, true);
}
$success = self::e("UNLOCK TABLES");
if (self::$driver == 'pdo') {
- self::$db->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
+ self::$connection->setAttribute(PDO::ATTR_EMULATE_PREPARES, false);
self::e("SET autocommit=1");
} else {
- self::$db->autocommit(true);
+ self::$connection->autocommit(true);
}
self::$in_transaction = false;
switch (self::$driver) {
case 'pdo':
- if (self::$db->inTransaction()) {
- break;
- }
- if (!self::$db->beginTransaction()) {
+ if (!self::$connection->inTransaction() && !self::$connection->beginTransaction()) {
return false;
}
break;
+
case 'mysqli':
- if (!self::$db->begin_transaction()) {
+ if (!self::$connection->begin_transaction()) {
return false;
}
break;
{
switch (self::$driver) {
case 'pdo':
- if (!self::$db->inTransaction()) {
+ if (!self::$connection->inTransaction()) {
return true;
}
- return self::$db->commit();
+
+ return self::$connection->commit();
+
case 'mysqli':
- return self::$db->commit();
+ return self::$connection->commit();
}
+
return true;
}
switch (self::$driver) {
case 'pdo':
- if (!self::$db->inTransaction()) {
+ if (!self::$connection->inTransaction()) {
$ret = true;
break;
}
- $ret = self::$db->rollBack();
+ $ret = self::$connection->rollBack();
break;
+
case 'mysqli':
- $ret = self::$db->rollback();
+ $ret = self::$connection->rollback();
break;
}
self::$in_transaction = false;
* @param array $options
* - cascade: If true we delete records in other tables that depend on the one we're deleting through
* relations (default: true)
- * @param boolean $in_process Internal use: Only do a commit after the last delete
* @param array $callstack Internal use: prevent endless loops
*
- * @return boolean|array was the delete successful? When $in_process is set: deletion data
+ * @return boolean was the delete successful?
*/
- public static function delete($table, array $conditions, array $options = [], $in_process = false, array &$callstack = [])
+ public static function delete($table, array $conditions, array $options = [], array &$callstack = [])
{
if (empty($table) || empty($conditions)) {
- logger('Table and conditions have to be set');
+ Logger::log('Table and conditions have to be set');
return false;
}
$commands[$key] = ['table' => $table, 'conditions' => $conditions];
- $cascade = defaults($options, 'cascade', true);
+ // Don't use "defaults" here, since it would set "false" to "true"
+ if (isset($options['cascade'])) {
+ $cascade = $options['cascade'];
+ } else {
+ $cascade = true;
+ }
// To speed up the whole process we cache the table relations
if ($cascade && count(self::$relation) == 0) {
if ((count($conditions) == 1) && ($field == array_keys($conditions)[0])) {
foreach ($rel_def AS $rel_table => $rel_fields) {
foreach ($rel_fields AS $rel_field) {
- $retval = self::delete($rel_table, [$rel_field => array_values($conditions)[0]], $options, true, $callstack);
- $commands = array_merge($commands, $retval);
+ $retval = self::delete($rel_table, [$rel_field => array_values($conditions)[0]], $options, $callstack);
}
}
// We quit when this key already exists in the callstack.
} elseif (!isset($callstack[$qkey])) {
-
$callstack[$qkey] = true;
// Fetch all rows that are to be deleted
$data = self::select($table, [$field], $conditions);
while ($row = self::fetch($data)) {
- // Now we accumulate the delete commands
- $retval = self::delete($table, [$field => $row[$field]], $options, true, $callstack);
- $commands = array_merge($commands, $retval);
+ self::delete($table, [$field => $row[$field]], $options, $callstack);
}
self::close($data);
}
}
- if (!$in_process) {
- // Now we finalize the process
- $do_transaction = !self::$in_transaction;
+ // Now we finalize the process
+ $do_transaction = !self::$in_transaction;
- if ($do_transaction) {
- self::transaction();
- }
+ if ($do_transaction) {
+ self::transaction();
+ }
- $compacted = [];
- $counter = [];
+ $compacted = [];
+ $counter = [];
- foreach ($commands AS $command) {
- $conditions = $command['conditions'];
- reset($conditions);
- $first_key = key($conditions);
+ foreach ($commands AS $command) {
+ $conditions = $command['conditions'];
+ reset($conditions);
+ $first_key = key($conditions);
- $condition_string = self::buildCondition($conditions);
+ $condition_string = self::buildCondition($conditions);
- if ((count($command['conditions']) > 1) || is_int($first_key)) {
- $sql = "DELETE FROM `" . $command['table'] . "`" . $condition_string;
- logger(self::replaceParameters($sql, $conditions), LOGGER_DATA);
+ if ((count($command['conditions']) > 1) || is_int($first_key)) {
+ $sql = "DELETE FROM `" . $command['table'] . "`" . $condition_string;
+ Logger::log(self::replaceParameters($sql, $conditions), Logger::DATA);
- if (!self::e($sql, $conditions)) {
- if ($do_transaction) {
- self::rollback();
- }
- return false;
- }
- } else {
- $key_table = $command['table'];
- $key_condition = array_keys($command['conditions'])[0];
- $value = array_values($command['conditions'])[0];
-
- // Split the SQL queries in chunks of 100 values
- // We do the $i stuff here to make the code better readable
- $i = isset($counter[$key_table][$key_condition]) ? $counter[$key_table][$key_condition] : 0;
- if (isset($compacted[$key_table][$key_condition][$i]) && count($compacted[$key_table][$key_condition][$i]) > 100) {
- ++$i;
+ if (!self::e($sql, $conditions)) {
+ if ($do_transaction) {
+ self::rollback();
}
-
- $compacted[$key_table][$key_condition][$i][$value] = $value;
- $counter[$key_table][$key_condition] = $i;
+ return false;
}
+ } else {
+ $key_table = $command['table'];
+ $key_condition = array_keys($command['conditions'])[0];
+ $value = array_values($command['conditions'])[0];
+
+ // Split the SQL queries in chunks of 100 values
+ // We do the $i stuff here to make the code better readable
+ $i = isset($counter[$key_table][$key_condition]) ? $counter[$key_table][$key_condition] : 0;
+ if (isset($compacted[$key_table][$key_condition][$i]) && count($compacted[$key_table][$key_condition][$i]) > 100) {
+ ++$i;
+ }
+
+ $compacted[$key_table][$key_condition][$i][$value] = $value;
+ $counter[$key_table][$key_condition] = $i;
}
- foreach ($compacted AS $table => $values) {
- foreach ($values AS $field => $field_value_list) {
- foreach ($field_value_list AS $field_values) {
- $sql = "DELETE FROM `" . $table . "` WHERE `" . $field . "` IN (" .
- substr(str_repeat("?, ", count($field_values)), 0, -2) . ");";
+ }
+ foreach ($compacted AS $table => $values) {
+ foreach ($values AS $field => $field_value_list) {
+ foreach ($field_value_list AS $field_values) {
+ $sql = "DELETE FROM `" . $table . "` WHERE `" . $field . "` IN (" .
+ substr(str_repeat("?, ", count($field_values)), 0, -2) . ");";
- logger(self::replaceParameters($sql, $field_values), LOGGER_DATA);
+ Logger::log(self::replaceParameters($sql, $field_values), Logger::DATA);
- if (!self::e($sql, $field_values)) {
- if ($do_transaction) {
- self::rollback();
- }
- return false;
+ if (!self::e($sql, $field_values)) {
+ if ($do_transaction) {
+ self::rollback();
}
+ return false;
}
}
}
- if ($do_transaction) {
- self::commit();
- }
- return true;
}
-
- return $commands;
+ if ($do_transaction) {
+ self::commit();
+ }
+ return true;
}
/**
public static function update($table, $fields, $condition, $old_fields = []) {
if (empty($table) || empty($fields) || empty($condition)) {
- logger('Table, fields and condition have to be set');
+ Logger::log('Table, fields and condition have to be set');
return false;
}
foreach ($old_fields AS $fieldname => $content) {
if (isset($fields[$fieldname])) {
- if ($fields[$fieldname] == $content) {
+ if (($fields[$fieldname] == $content) && !is_null($content)) {
unset($fields[$fieldname]);
} else {
$do_update = true;
*
* $params = array("order" => array("id", "received" => true), "limit" => 10);
*
- * $data = dba::select($table, $fields, $condition, $params);
+ * $data = DBA::select($table, $fields, $condition, $params);
*/
public static function select($table, array $fields = [], array $condition = [], array $params = [])
{
* or:
* $condition = ["`uid` = ? AND `network` IN (?, ?)", 1, 'dfrn', 'dspr'];
*
- * $count = dba::count($table, $condition);
+ * $count = DBA::count($table, $condition);
*/
public static function count($table, array $condition = [])
{
/* 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.
+ * Logic needs to be consistent with DBA::p() data types.
*/
$is_int = false;
$is_alpha = false;
$limit_string = '';
if (isset($params['limit']) && is_int($params['limit'])) {
- $limit_string = " LIMIT " . $params['limit'];
+ $limit_string = " LIMIT " . intval($params['limit']);
}
if (isset($params['limit']) && is_array($params['limit'])) {
* @return boolean was the close successful?
*/
public static function close($stmt) {
- $a = get_app();
+ $a = \get_app();
$stamp1 = microtime(true);
case 'mysqli':
// MySQLi offers both a mysqli_stmt and a mysqli_result class.
// We should be careful not to assume the object type of $stmt
- // because dba::p() has been able to return both types.
+ // because DBA::p() has been able to return both types.
if ($stmt instanceof mysqli_stmt) {
$stmt->free_result();
$ret = $stmt->close();
break;
}
- $a->save_timestamp($stamp1, 'database');
+ $a->saveTimestamp($stamp1, 'database');
return $ret;
}
+
+ /**
+ * @brief Return a list of database processes
+ *
+ * @return array
+ * 'list' => List of processes, separated in their different states
+ * 'amount' => Number of concurrent database processes
+ */
+ public static function processlist()
+ {
+ $ret = self::p("SHOW PROCESSLIST");
+ $data = self::toArray($ret);
+
+ $s = [];
+
+ $processes = 0;
+ $states = [];
+ foreach ($data as $process) {
+ $state = trim($process["State"]);
+
+ // Filter out all non blocking processes
+ if (!in_array($state, ["", "init", "statistics", "updating"])) {
+ ++$states[$state];
+ ++$processes;
+ }
+ }
+
+ $statelist = "";
+ foreach ($states as $state => $usage) {
+ if ($statelist != "") {
+ $statelist .= ", ";
+ }
+ $statelist .= $state.": ".$usage;
+ }
+ return(["list" => $statelist, "amount" => $processes]);
+ }
+
+ /**
+ * 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
+ */
+ public static function isResult($array)
+ {
+ // It could be a return value from an update statement
+ if (is_bool($array)) {
+ return $array;
+ }
+
+ if (is_object($array)) {
+ return self::numRows($array) > 0;
+ }
+
+ return (is_array($array) && (count($array) > 0));
+ }
+
+ /**
+ * @brief Callback function for "esc_array"
+ *
+ * @param mixed $value Array value
+ * @param string $key Array key
+ * @param boolean $add_quotation add quotation marks for string values
+ * @return void
+ */
+ private static function escapeArrayCallback(&$value, $key, $add_quotation)
+ {
+ if (!$add_quotation) {
+ if (is_bool($value)) {
+ $value = ($value ? '1' : '0');
+ } else {
+ $value = self::escape($value);
+ }
+ return;
+ }
+
+ if (is_bool($value)) {
+ $value = ($value ? 'true' : 'false');
+ } elseif (is_float($value) || is_integer($value)) {
+ $value = (string) $value;
+ } else {
+ $value = "'" . self::escape($value) . "'";
+ }
+ }
+
+ /**
+ * @brief 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)
+ {
+ array_walk($arr, 'self::escapeArrayCallback', $add_quotation);
+ }
}
projects / friendica.git / blobdiff