PHP: When to release the result from DB? - php

Question

I assume this will be a rather basic question for most of you PHP guys out there. Let's assume I have this file to work with a DB:
<?php
define("DB_HOST", "localhost");
define("DB_NAME", "dbname");
define("DB_USER", "admin");
define("DB_PASSWORD", "abcdefg");
$connection;
$result;
function connectDatabase() {
global $connection;
if(isset($connection)) return;
$connection = mysqli_connect(DB_HOST, DB_USER, DB_PASSWORD, DB_NAME);
if(mysqli_connect_errno()) {
die("Database connection failed: " . mysqli_connect_error() . " (" . mysqli_connect_errno() . ")");
}
}
function queryDatabase($query) {
global $connection, $result;
$result = mysqli_query($connection, $query);
if(!$result) {
die("Database query failed");
}
else {
return $result;
}
}
function releaseResult() {
global $result;
mysqli_free_result($result);
}
function closeConnection() {
global $connection;
mysqli_close($connection);
}
?>
And let's say it I call it like this:
<?php
require_once("db_connection.php");
function createNavigation() {
connectDatabase();
$query = "SELECT * ";
$query .= "FROM subjects ";
$query .= "ORDER BY position ASC";
$result = queryDatabase($query);
while($subject = mysqli_fetch_assoc($result)) {
//do something
}
releaseResult();
}
?>
The question is - do I actually have to release the local $result in the createNavigation function too or that is not necessary?
What is the mysqli_free_result good for anyway? Coming from other OOP languages I understand releasing/destroying/disabling/nulling objects, GC, memory management, etc. but I am kind of confused what it is good for in PHP considering the script runs only once, returns something and it is done. Thank you!

Answer 1

It's about helping php manage resources effectively. If you don't call it, then the resource will get cleaned up by php, but it's better to call it yourself and get rid of it straight away when you know it's no longer required.
Take an extreme example of a script which takes a second to run, where a database connection is opened at the beginning and only needed very briefly. Once the script finishes, resources (database connections etc) will be freed, but the connection could have been open for, say 0.8secs longer than needed. Now add multiple users hitting the page in parallel and you have ended up with lots of instances of this connection being open at any given time, whereas if yo had cleaned up the connection straight away, fewer instances would be needed.

Answer 2

In practice, it's not particularly necessary. Most PHP scripts are written to be accessed over HTTP, which means they run briefly, then they stop, and memory is freed up at that point. The only practical reason I could see this being important is if you're running a persistent script, such as one you've built as a daemon that you kick off and it continues to run until you stop it. Releasing your results at that point would prevent the memory footprint from bloating up.
For security, future compatibility, and because you said that you've come from an OOP background, you should probably be using PDO instead of the mysqli_* functions. To establish a MySQL connection, you create a new PDO object. To free up the resources, you simply unset of the object (or the result, as the case may be).