X-Git-Url: https://git.mxchange.org/?a=blobdiff_plain;ds=sidebyside;f=include%2Fdba.php;h=b1b689fdf77def7090d8b5bd54059e1fc9c1cd24;hb=491a1373e07ac356eac8f0c40f7841416ef5c2a4;hp=3a72d596491741a6b3928ffbfb1c7fe74d488780;hpb=da60893590a302bf94dfd86f5586f26509160d34;p=friendica.git

diff --git a/include/dba.php b/include/dba.php
index 3a72d59649..b1b689fdf7 100644
--- a/include/dba.php
+++ b/include/dba.php
@@ -21,7 +21,7 @@ class dba {
 	private static $errorno = 0;
 	private static $affected_rows = 0;
 	private static $in_transaction = false;
-	private static $relation = array();
+	private static $relation = [];
 
 	public static function connect($serveraddr, $user, $pass, $db, $install = false) {
 		if (!is_null(self::$db)) {
@@ -157,7 +157,7 @@ class dba {
 		}
 
 		// Only do the explain on "select", "update" and "delete"
-		if (!in_array(strtolower(substr($query, 0, 6)), array("select", "update", "delete"))) {
+		if (!in_array(strtolower(substr($query, 0, 6)), ["select", "update", "delete"])) {
 			return;
 		}
 
@@ -253,8 +253,8 @@ class dba {
 	 * @return string The input SQL string modified if necessary.
 	 */
 	public static function clean_query($sql) {
-		$search = array("\t", "\n", "\r", "  ");
-		$replace = array(' ', ' ', ' ', ' ');
+		$search = ["\t", "\n", "\r", "  "];
+		$replace = [' ', ' ', ' ', ' '];
 		do {
 			$oldsql = $sql;
 			$sql = str_replace($search, $replace, $sql);
@@ -313,7 +313,7 @@ class dba {
 	 * For all regular queries please use dba::select or dba::exists
 	 *
 	 * @param string $sql SQL statement
-	 * @return object statement object
+	 * @return bool|object statement object
 	 */
 	public static function p($sql) {
 		$a = get_app();
@@ -324,7 +324,7 @@ class dba {
 
 		// Renumber the array keys to be sure that they fit
 		$i = 0;
-		$args = array();
+		$args = [];
 		foreach ($params AS $param) {
 			// Avoid problems with some MySQL servers and boolean values. See issue #3645
 			if (is_bool($param)) {
@@ -408,7 +408,7 @@ class dba {
 				// There are SQL statements that cannot be executed with a prepared statement
 				$parts = explode(' ', $orig_sql);
 				$command = strtolower($parts[0]);
-				$can_be_prepared = in_array($command, array('select', 'update', 'insert', 'delete'));
+				$can_be_prepared = in_array($command, ['select', 'update', 'insert', 'delete']);
 
 				// The fallback routine is called as well when there are no arguments
 				if (!$can_be_prepared || (count($args) == 0)) {
@@ -437,7 +437,7 @@ class dba {
 				}
 
 				$params = '';
-				$values = array();
+				$values = [];
 				foreach ($args AS $param => $value) {
 					if (is_int($args[$param])) {
 						$params .= 'i';
@@ -453,7 +453,7 @@ class dba {
 
 				if (count($values) > 0) {
 					array_unshift($values, $params);
-					call_user_func_array(array($stmt, 'bind_param'), $values);
+					call_user_func_array([$stmt, 'bind_param'], $values);
 				}
 
 				if (!$stmt->execute()) {
@@ -564,12 +564,12 @@ class dba {
 			return false;
 		}
 
-		$fields = array();
+		$fields = [];
 
 		$array_element = each($condition);
 		$array_key = $array_element['key'];
 		if (!is_int($array_key)) {
-			$fields = array($array_key);
+			$fields = [$array_key];
 		}
 
 		$stmt = self::select($table, $fields, $condition, ['limit' => 1]);
@@ -586,10 +586,11 @@ class dba {
 	}
 
 	/**
-	 * @brief Fetches the first row
+	 * Fetches the first row
 	 *
-	 * Please use dba::select 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
 	 * @return array first row of query
 	 */
@@ -639,7 +640,7 @@ class dba {
 	/**
 	 * @brief Returns the number of rows of a statement
 	 *
-	 * @param object Statement object
+	 * @param PDOStatement|mysqli_result|mysqli_stmt Statement object
 	 * @return int Number of rows
 	 */
 	public static function num_rows($stmt) {
@@ -658,7 +659,7 @@ class dba {
 	/**
 	 * @brief Fetch a single row
 	 *
-	 * @param object $stmt statement object
+	 * @param mixed $stmt statement object
 	 * @return array current row
 	 */
 	public static function fetch($stmt) {
@@ -677,14 +678,14 @@ class dba {
 				// This code works, but is slow
 
 				// Bind the result to a result array
-				$cols = array();
+				$cols = [];
 
-				$cols_num = array();
+				$cols_num = [];
 				for ($x = 0; $x < $stmt->field_count; $x++) {
 					$cols[] = &$cols_num[$x];
 				}
 
-				call_user_func_array(array($stmt, 'bind_result'), $cols);
+				call_user_func_array([$stmt, 'bind_result'], $cols);
 
 				if (!$stmt->fetch()) {
 					return false;
@@ -696,7 +697,7 @@ class dba {
 				$result = $stmt->result_metadata();
 				$fields = $result->fetch_fields();
 
-				$columns = array();
+				$columns = [];
 				foreach ($cols_num AS $param => $col) {
 					$columns[$fields[$param]->name] = $col;
 				}
@@ -851,24 +852,24 @@ class dba {
 	/**
 	 * @brief Delete a row from a table
 	 *
-	 * @param string $table Table name
-	 * @param array $param parameter array
-	 * @param boolean $in_process Internal use: Only do a commit after the last delete
-	 * @param array $callstack Internal use: prevent endless loops
+	 * @param string  $table       Table name
+	 * @param array   $conditions  Field condition(s)
+	 * @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 successfull? When $in_process is set: deletion data
+	 * @return boolean|array was the delete successful? When $in_process is set: deletion data
 	 */
-	public static function delete($table, $param, $in_process = false, &$callstack = array()) {
-
-		if (empty($table) || empty($param)) {
-			logger('Table and condition have to be set');
+	public static function delete($table, array $conditions, $in_process = false, array &$callstack = [])
+	{
+		if (empty($table) || empty($conditions)) {
+			logger('Table and conditions have to be set');
 			return false;
 		}
 
-		$commands = array();
+		$commands = [];
 
 		// Create a key for the loop prevention
-		$key = $table.':'.implode(':', array_keys($param)).':'.implode(':', $param);
+		$key = $table . ':' . implode(':', array_keys($conditions)) . ':' . implode(':', $conditions);
 
 		// We quit when this key already exists in the callstack.
 		if (isset($callstack[$key])) {
@@ -879,7 +880,7 @@ class dba {
 
 		$table = self::escape($table);
 
-		$commands[$key] = array('table' => $table, 'param' => $param);
+		$commands[$key] = ['table' => $table, 'conditions' => $conditions];
 
 		// To speed up the whole process we cache the table relations
 		if (count(self::$relation) == 0) {
@@ -893,28 +894,28 @@ class dba {
 			$rel_def = array_values(self::$relation[$table])[0];
 
 			// Create a key for preventing double queries
-			$qkey = $field.'-'.$table.':'.implode(':', array_keys($param)).':'.implode(':', $param);
+			$qkey = $field . '-' . $table . ':' . implode(':', array_keys($conditions)) . ':' . implode(':', $conditions);
 
 			// When the search field is the relation field, we don't need to fetch the rows
 			// This is useful when the leading record is already deleted in the frontend but the rest is done in the backend
-			if ((count($param) == 1) && ($field == array_keys($param)[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, array($rel_field => array_values($param)[0]), true, $callstack);
+						$retval = self::delete($rel_table, [$rel_field => array_values($conditions)[0]], true, $callstack);
 						$commands = array_merge($commands, $retval);
 					}
 				}
-			// We quit when this key already exists in the 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, array($field), $param);
+				$data = self::select($table, [$field], $conditions);
 
 				while ($row = self::fetch($data)) {
 					// Now we accumulate the delete commands
-					$retval = self::delete($table, array($field => $row[$field]), true, $callstack);
+					$retval = self::delete($table, [$field => $row[$field]], true, $callstack);
 					$commands = array_merge($commands, $retval);
 				}
 
@@ -933,24 +934,24 @@ class dba {
 				self::transaction();
 			}
 
-			$compacted = array();
-			$counter = array();
+			$compacted = [];
+			$counter = [];
 
 			foreach ($commands AS $command) {
-				$condition = $command['param'];
-				$array_element = each($condition);
+				$conditions = $command['conditions'];
+				$array_element = each($conditions);
 				$array_key = $array_element['key'];
 				if (is_int($array_key)) {
-					$condition_string = " WHERE ".array_shift($condition);
+					$condition_string = " WHERE " . array_shift($conditions);
 				} else {
-					$condition_string = " WHERE `".implode("` = ? AND `", array_keys($condition))."` = ?";
+					$condition_string = " WHERE `" . implode("` = ? AND `", array_keys($conditions)) . "` = ?";
 				}
 
-				if ((count($command['param']) > 1) || is_int($array_key)) {
-					$sql = "DELETE FROM `".$command['table']."`".$condition_string;
-					logger(self::replace_parameters($sql, $condition), LOGGER_DATA);
+				if ((count($command['conditions']) > 1) || is_int($array_key)) {
+					$sql = "DELETE FROM `" . $command['table'] . "`" . $condition_string;
+					logger(self::replace_parameters($sql, $conditions), LOGGER_DATA);
 
-					if (!self::e($sql, $condition)) {
+					if (!self::e($sql, $conditions)) {
 						if ($do_transaction) {
 							self::rollback();
 						}
@@ -958,25 +959,25 @@ class dba {
 					}
 				} else {
 					$key_table = $command['table'];
-					$key_param = array_keys($command['param'])[0];
-					$value = array_values($command['param'])[0];
+					$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 = $counter[$key_table][$key_param];
-					if (count($compacted[$key_table][$key_param][$i]) > 100) {
+					$i = $counter[$key_table][$key_condition];
+					if (count($compacted[$key_table][$key_condition][$i]) > 100) {
 						++$i;
 					}
 
-					$compacted[$key_table][$key_param][$i][$value] = $value;
-					$counter[$key_table][$key_param] = $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).");";
+						$sql = "DELETE FROM `" . $table . "` WHERE `" . $field . "` IN (" .
+							substr(str_repeat("?, ", count($field_values)), 0, -2) . ");";
 
 						logger(self::replace_parameters($sql, $field_values), LOGGER_DATA);
 
@@ -1026,7 +1027,7 @@ class dba {
 	 *
 	 * @return boolean was the update successfull?
 	 */
-	public static function update($table, $fields, $condition, $old_fields = array()) {
+	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');
@@ -1046,14 +1047,14 @@ class dba {
 		if (is_bool($old_fields)) {
 			$do_insert = $old_fields;
 
-			$old_fields = self::selectOne($table, [], $condition);
+			$old_fields = self::selectFirst($table, [], $condition);
 
 			if (is_bool($old_fields)) {
 				if ($do_insert) {
 					$values = array_merge($condition, $fields);
 					return self::insert($table, $values, $do_insert);
 				}
-				$old_fields = array();
+				$old_fields = [];
 			}
 		}
 
@@ -1085,7 +1086,7 @@ class dba {
 
 	/**
 	 * Retrieve a single record from a table and returns it in an associative array
-	 * 
+	 *
 	 * @brief Retrieve a single record from a table
 	 * @param string $table
 	 * @param array  $fields
@@ -1094,7 +1095,7 @@ class dba {
 	 * @return bool|array
 	 * @see dba::select
 	 */
-	public static function selectOne($table, array $fields = [], array $condition = [], $params = [])
+	public static function selectFirst($table, array $fields = [], array $condition = [], $params = [])
 	{
 		$params['limit'] = 1;
 		$result = self::select($table, $fields, $condition, $params);
@@ -1111,12 +1112,12 @@ class dba {
 	/**
 	 * @brief Select rows from a table
 	 *
-	 * @param string $table Table name
-	 * @param array $fields array of selected fields
-	 * @param array $condition array of fields for condition
-	 * @param array $params array of several parameters
+	 * @param string $table     Table name
+	 * @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 boolean|object If "limit" is equal "1" only a single row is returned, else a query object is returned
+	 * @return boolean|object
 	 *
 	 * Example:
 	 * $table = "item";
@@ -1126,7 +1127,7 @@ class dba {
 	 * or:
 	 * $condition = array("`uid` = ? AND `network` IN (?, ?)", 1, 'dfrn', 'dspr');
 	 *
-	 * $params = array("order" => array("id", "received" => true), "limit" => 1);
+	 * $params = array("order" => array("id", "received" => true), "limit" => 10);
 	 *
 	 * $data = dba::select($table, $fields, $condition, $params);
 	 */
@@ -1248,7 +1249,7 @@ class dba {
 			return $stmt;
 		}
 
-		$data = array();
+		$data = [];
 		while ($row = self::fetch($stmt)) {
 			$data[] = $row;
 		}
@@ -1280,7 +1281,7 @@ class dba {
 	 * @brief Closes the current statement
 	 *
 	 * @param object $stmt statement object
-	 * @return boolean was the close successfull?
+	 * @return boolean was the close successful?
 	 */
 	public static function close($stmt) {
 		if (!is_object($stmt)) {