From 50db9c8fd828f3c02f7059eb56a52be1e95fb028 Mon Sep 17 00:00:00 2001
From: Matthew Bucci <buccim2@gene.com>
Date: Thu, 9 Nov 2023 09:34:33 -0800
Subject: [PATCH] rewrite mysql driver implementation to replace mysqli instead
 of mysql

---
 pg4wp/core.php         |  19 +-
 pg4wp/driver_mysql.php | 989 +++++++++++++++++++++++++++++++++++++++--
 2 files changed, 944 insertions(+), 64 deletions(-)

diff --git a/pg4wp/core.php b/pg4wp/core.php
index e77cb36..f2f2989 100644
--- a/pg4wp/core.php
+++ b/pg4wp/core.php
@@ -14,13 +14,6 @@ require_once ABSPATH . '/wp-includes/version.php';
 require_once ABSPATH . '/wp-includes/cache.php';
 require_once ABSPATH . '/wp-includes/l10n.php';
 
-if (!function_exists('wpsql_is_resource')) {
-    function wpsql_is_resource($object)
-    {
-        return $object !== false && $object !== null;
-    }
-}
-
 // Load the driver defined in 'db.php'
 require_once(PG4WP_ROOT . '/driver_' . DB_DRIVER . '.php');
 
@@ -29,20 +22,12 @@ $replaces = array(
     'define( '	=> '// define( ',
     'class wpdb'	=> 'class wpdb2',
     'new wpdb'	=> 'new wpdb2',
-    'mysql_'	=> 'wpsql_',
-    'is_resource'	=> 'wpsql_is_resource',
+    'mysqli_'	=> 'wpsqli_',
+    'is_resource'	=> 'wpsqli_is_resource',
     '<?php'		=> '',
     '?>'		=> '',
 );
 
-// Ensure class uses the replaced mysql_ functions rather than mysqli_
-if (!defined('WP_USE_EXT_MYSQL')) {
-    define('WP_USE_EXT_MYSQL', true);
-}
-if (WP_USE_EXT_MYSQL != true) {
-    throw new \Exception("PG4SQL CANNOT BE ENABLED WITH MYSQLI, REMOVE ANY WP_USE_EXT_MYSQL configuration");
-}
-
 eval(str_replace(array_keys($replaces), array_values($replaces), file_get_contents(ABSPATH . '/wp-includes/class-wpdb.php')));
 
 // Create wpdb object if not already done
diff --git a/pg4wp/driver_mysql.php b/pg4wp/driver_mysql.php
index 846a5ef..1a6233c 100644
--- a/pg4wp/driver_mysql.php
+++ b/pg4wp/driver_mysql.php
@@ -1,91 +1,986 @@
 <?php
-/**
- * @package PostgreSQL_For_Wordpress
- * @version $Id$
- * @author	Hawk__, www.hawkix.net
- */
 
 /**
-* Provides a driver for MySQL
-* This file remaps all wpsql_* calls to mysql_* original name
+* This file implements a mysql reference driver
+* This driver should do nothing different vs a standard install
+* This file remaps all wpsqli_* calls to mysqli_* original name
 */
-function wpsql_num_rows($result)
+
+/**
+* Connection Handling
+*/
+
+/**
+ * Initializes MySQLi and returns a resource for use with mysqli_real_connect().
+ *
+ * This function is a wrapper for the mysqli_init function, which initializes and returns
+ * a resource for use with mysqli_real_connect(). It is part of the MySQLi extension's
+ * object-oriented interface and is usually employed to prepare for a secure connection
+ * using settings like mysqli_ssl_set() before establishing a connection to a MySQL server.
+ * The function does not require any parameters and will return a mysqli object on success
+ * or FALSE on failure.
+ *
+ * @return mysqli|false Returns an object which can be used with mysqli_real_connect() or
+ *                      FALSE on failure.
+ */
+function wpsqli_init()
 {
-    return mysql_num_rows($result);
+    return mysqli_init();
 }
-function wpsql_numrows($result)
+
+/**
+ * Opens a connection to a mysql server in a real context.
+ *
+ * This function is a wrapper for the mysqli_real_connect function, which attempts to establish
+ * a connection to a MySQL server. The function takes in parameters for the host name, username,
+ * password, database name, port number, socket, and flags, all of which are optional except the
+ * mysqli object returned by mysqli_init(). The flags parameter can be used to set different
+ * connection options that can affect the behavior of the connection.
+ *
+ * @param mysqli $connection The mysqli object returned by mysqli_init().
+ * @param string|null $hostname The host name or an IP address.
+ * @param string|null $username The MySQL user name.
+ * @param string|null $password The password associated with the username.
+ * @param string|null $database The default database to be used when performing queries.
+ * @param int|null $port The port number to attempt to connect to the MySQL server.
+ * @param string|null $socket The socket or named pipe that should be used.
+ * @param int $flags Client connection flags.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_real_connect($connection, $hostname = null, $username = null, $password = null, $database = null, $port = null, $socket = null, $flags = 0)
 {
-    return mysql_num_rows($result);
+    return mysqli_real_connect($connection, $hostname, $username, $password, $database, $port, $socket, $flags);
 }
-function wpsql_num_fields($result)
+
+/**
+ * Closes a previously opened database connection.
+ *
+ * This function is a wrapper for the mysqli_close function. It is used to close a non-persistent
+ * connection to a MySQL server that was opened with mysqli_connect() or mysqli_real_connect(). It's
+ * important to close connections when they are no longer needed to free up resources on both the web
+ * server and the MySQL server. The function returns TRUE on success or FALSE on failure.
+ *
+ * @param mysqli $connection The mysqli connection resource to be closed.
+ * @return bool Returns TRUE on successful closure, FALSE on failure.
+ */
+function wpsqli_close($connection)
 {
-    return mysql_num_fields($result);
+    return mysqli_close($connection);
 }
-function wpsql_fetch_field($result)
+
+/**
+ * Used to establish secure connections using SSL.
+ *
+ * This function is a wrapper for the mysqli_ssl_set function. It is used to set the SSL
+ * certificates and key files for establishing an encrypted connection between the client
+ * and the MySQL server. This function should be called before mysqli_real_connect(). It's
+ * important for security when the database server and the web server are on different hosts
+ * or when sensitive data is being transferred.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $key The path to the key file.
+ * @param string $cert The path to the certificate file.
+ * @param string $ca The path to the certificate authority file.
+ * @param string $capath The pathname to a directory that contains trusted SSL CA certificates
+ *                       in PEM format.
+ * @param string $cipher A list of allowable ciphers to use for SSL encryption.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_ssl_set($connection, $key, $cert, $ca, $capath, $cipher)
 {
-    return mysql_fetch_field($result);
+    return mysqli_ssl_set($connection, $key, $cert, $ca, $capath, $cipher);
 }
-function wpsql_fetch_object($result)
+
+/**
+ * Returns the MySQL client library version as a string.
+ *
+ * This function is a wrapper for the mysqli_get_client_info function. It is used to retrieve
+ * the version of the client library that is used to compile the MySQLi extension. The function
+ * does not require any parameters and can be called statically. It is helpful for debugging
+ * and ensuring that the PHP environment is using the correct version of the MySQL client library,
+ * which can be important for compatibility and functionality reasons.
+ *
+ * @return string The MySQL client library version.
+ */
+function wpsqli_get_client_info()
 {
-    return mysql_fetch_object($result);
+    return mysqli_get_client_info();
 }
-function wpsql_free_result($result)
+
+/**
+ * Retrieves the version of the MySQL server.
+ *
+ * This function is a wrapper for the mysqli_get_server_info function. It returns a string
+ * representing the version of the MySQL server pointed to by the connection resource. This
+ * information can be used for a variety of purposes, such as conditional behavior for different
+ * MySQL versions or simply for logging and monitoring. Understanding the server version is
+ * essential for ensuring compatibility with specific MySQL features and syntax.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return string The version of the MySQL server.
+ */
+function wpsqli_get_server_info($connection)
 {
-    return mysql_free_result($result);
+    return mysqli_get_server_info($connection);
 }
-function wpsql_affected_rows()
+
+/**
+ * Returns a string representing the type of connection used.
+ *
+ * This function is a wrapper for the mysqli_get_host_info function. It retrieves information about
+ * the type of connection that was established to the MySQL server and the host server information.
+ * This includes the host name and the connection type, such as TCP/IP or a UNIX socket. It's useful
+ * for debugging and for understanding how PHP is communicating with the MySQL server.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return string A string describing the connection type and server host information.
+ */
+function wpsqli_host_info($connection)
 {
-    return mysql_affected_rows();
+    return mysqli_get_host_info($connection);
 }
-function wpsql_fetch_row($result)
+
+/**
+ * Pings a server connection, or tries to reconnect if the connection has gone down.
+ *
+ * This function is a wrapper for the mysqli_ping function, which checks whether the
+ * connection to the server is working. If it has gone down, and the global option
+ * mysqli.reconnect is enabled, it will attempt to reconnect. This is useful to ensure
+ * that a connection is still alive and if not, to re-establish it before proceeding
+ * with further operations. It returns TRUE if the connection is alive or if it was
+ * successfully re-established, and FALSE if the connection is not established and
+ * cannot be re-established.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_ping($connection)
 {
-    return mysql_fetch_row($result);
+    return mysqli_ping($connection);
 }
-function wpsql_data_seek($result, $offset)
+
+/**
+ * Returns the thread ID for the current connection.
+ *
+ * This function is a wrapper for the mysqli_thread_id function. It retrieves the thread ID used by
+ * the current connection to the MySQL server. This ID can be used as an argument to the KILL
+ * statement to terminate a connection. It is useful for debugging and managing MySQL connections
+ * and can be used to uniquely identify the connection within the server's process.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return int The thread ID for the current connection.
+ */
+function wpsqli_thread_id($connection)
 {
-    return mysql_data_seek($result, $offset);
+    return mysqli_thread_id($connection);
 }
-function wpsql_error()
+
+/**
+ * Returns whether the client library is thread-safe.
+ *
+ * This function is a wrapper for the mysqli_thread_safe function. It indicates whether the 
+ * mysqli client library that PHP is using is thread-safe. This is important information when 
+ * running PHP in a multi-threaded environment such as with the worker MPM in Apache or when
+ * using multi-threading extensions in PHP.
+ *
+ * @return bool Returns TRUE if the client library is thread-safe, FALSE otherwise.
+ */
+function wpsqli_thread_safe()
 {
-    return mysql_error();
+    return mysqli_thread_safe();
 }
-function wpsql_fetch_assoc($result)
+
+/**
+ * Gets the current system status of the MySQL server.
+ *
+ * This function is a wrapper for the mysqli_stat function. It returns a string containing
+ * status information about the MySQL server to which it's connected. The information includes
+ * uptime, threads, queries, open tables, and flush tables, among other status indicators.
+ * This can be useful for monitoring the health and performance of the MySQL server, as well
+ * as for debugging purposes.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return string A string describing the server status or FALSE on failure.
+ */
+function wpsqli_stat($connection)
 {
-    return mysql_fetch_assoc($result);
+    return mysqli_stat($connection);
 }
-function wpsql_escape_string($s)
+
+/**
+ * Sets extra connect options and affect behavior for a connection.
+ *
+ * This function is a wrapper for the mysqli_options function. It is used to set extra options
+ * for a connection resource before establishing a connection using mysqli_real_connect(). These
+ * options can be used to control various aspects of the connection's behavior. The function should
+ * be called after mysqli_init() and before mysqli_real_connect(). It returns TRUE on success or
+ * FALSE on failure.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param int $option The specific option that is to be set.
+ * @param mixed $value The value for the specified option.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_options($connection, $option, $value)
 {
-    return mysql_real_escape_string($s);
+    return mysqli_options($connection, $option, $value);
 }
-function wpsql_real_escape_string($s, $c = null)
+
+/**
+ * Returns the error code from the last connection attempt.
+ *
+ * This function is a wrapper for the mysqli_connect_errno function. It returns the error code from
+ * the last call to mysqli_connect() or mysqli_real_connect(). It is useful for error handling after
+ * attempting to establish a connection to a MySQL server, allowing the script to respond appropriately
+ * to specific error conditions. The function does not take any parameters and returns an integer error
+ * code. If no error occurred during the last connection attempt, it will return zero.
+ *
+ * @return int The error code from the last connection attempt.
+ */
+function wpsqli_connect_errno()
 {
-    return mysql_real_escape_string($s, $c);
+    return mysqli_connect_errno();
 }
-function wpsql_get_server_info()
+
+/**
+ * Returns a string description of the last connect error.
+ *
+ * This function is a wrapper for the mysqli_connect_error function. It provides a textual description
+ * of the error from the last connection attempt made by mysqli_connect() or mysqli_real_connect(). 
+ * Unlike mysqli_connect_errno(), which returns an error code, mysqli_connect_error() returns a string
+ * describing the error. This is useful for error handling, providing more detailed context about 
+ * connection problems.
+ *
+ * @return string|null A string that describes the error from the last connection attempt, or NULL
+ *                     if no error occurred.
+ */
+function wpsqli_connect_error()
 {
-    return mysql_get_server_info();
+    return mysqli_connect_error();
 }
-function wpsql_result($result, $i, $fieldname)
+
+/**
+* Transaction Handling
+*/
+
+/**
+ * Turns on or off auto-commit mode on queries for the database connection.
+ *
+ * This function is a wrapper for the mysqli_autocommit function. When turned on, each query
+ * that you execute will automatically commit to the database. When turned off, you will need to
+ * manually commit transactions using mysqli_commit() or rollback using mysqli_rollback(). This
+ * function is particularly useful for transactions that require multiple steps and you don't want
+ * to commit until all steps are successful.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param bool $mode Whether to turn on auto-commit mode or not. Pass TRUE to turn on auto-commit
+ *                   mode and FALSE to turn it off.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_autocommit($connection, $mode)
 {
-    return mysql_result($result, $i, $fieldname);
+    return mysqli_autocommit($connection, $mode);
 }
-function wpsql_connect($dbserver, $dbuser, $dbpass)
+
+/**
+ * Starts a new transaction.
+ *
+ * This function is a wrapper for the mysqli_begin_transaction function. It starts a new transaction
+ * with the provided connection and with the specified flags. Transactions allow multiple changes to
+ * be made to the database atomically - they will all be applied, or none will be, which can be controlled
+ * by committing or rolling back the transaction. This function can also set a name for the transaction,
+ * which can be used for savepoints.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param int $flags Optional flags for defining transaction characteristics. This should be a bitmask
+ *                   of any of the MYSQLI_TRANS_START_* constants.
+ * @param string|null $name Optional name for the transaction, used for savepoint names.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_begin_transaction($connection, $flags = 0, $name = null)
 {
-    return mysql_connect($dbserver, $dbuser, $dbpass);
+    return mysqli_begin_transaction($connection, $flags, $name);
 }
-function wpsql_fetch_array($result)
+
+/**
+ * Commits the current transaction.
+ *
+ * This function is a wrapper for the mysqli_commit function. It is used to commit the current transaction
+ * for the database connection. Committing a transaction means that all the operations performed since the
+ * start of the transaction are permanently saved to the database. This function can also take optional flags
+ * and a name, the latter being used if the commit should be associated with a named savepoint.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param int $flags Optional flags for the commit operation. It should be a bitmask of the MYSQLI_TRANS_COR_* constants.
+ * @param string|null $name Optional name for the savepoint that should be committed.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_commit($connection, $flags = 0, $name = null)
 {
-    return mysql_fetch_array($result);
+    return mysqli_commit($connection, $flags, $name);
 }
-function wpsql_select_db($dbname, $connection_id)
+
+/**
+ * Rolls back the current transaction for the database connection.
+ *
+ * This function is a wrapper for the mysqli_rollback function. It rolls back the current transaction,
+ * undoing all changes made to the database in the current transaction. This is an essential feature
+ * for maintaining data integrity, especially in situations where a series of database operations need
+ * to be treated as an atomic unit. The function can also accept optional flags and a name, which can be
+ * used to rollback to a named savepoint within the transaction rather than rolling back the entire transaction.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param int $flags Optional flags that define how the rollback operation should be handled. It should be
+ *                   a bitmask of the MYSQLI_TRANS_COR_* constants.
+ * @param string|null $name Optional name of the savepoint to which the rollback operation should be directed.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_rollback($connection, $flags = 0, $name = null)
 {
-    return mysql_select_db($dbname, $connection_id);
+    return mysqli_rollback($connection, $flags, $name);
 }
-function wpsql_query($sql)
+
+/**
+* Database Operations
+*/
+
+/**
+ * Selects the default database for database queries.
+ *
+ * This function is a wrapper for the mysqli_select_db function, which is used to change the default
+ * database for the connection. This is useful when performing multiple operations across different
+ * databases without having to establish a new connection for each one. If the function succeeds,
+ * it will return TRUE, indicating the database was successfully selected, or FALSE if it fails.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $database The name of the database to select.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_select_db($connection, $database)
 {
-    return mysql_query($sql);
+    return mysqli_select_db($connection, $database);
 }
-function wpsql_insert_id($table)
+
+/**
+ * Performs a query against the database.
+ *
+ * This function is a wrapper for the mysqli_query function. The mysqli_query function performs
+ * a query against the database and returns a result set for successful SELECT queries, or TRUE
+ * for other successful DML queries such as INSERT, UPDATE, DELETE, etc. It can also be used
+ * to execute multiple queries if the database server supports it. The function can return FALSE
+ * on failure. The optional third parameter defines the result mode - whether to use a resultset
+ * buffering (MYSQLI_STORE_RESULT) or not (MYSQLI_USE_RESULT).
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $query The SQL query to be executed.
+ * @param int $result_mode The optional mode for storing result set.
+ * @return mixed Returns a mysqli_result object for successful SELECT queries, TRUE for other
+ *               successful queries, or FALSE on failure.
+ */
+function wpsqli_query($connection, $query, $result_mode = MYSQLI_STORE_RESULT)
 {
-    return mysql_insert_id($table);
+    return mysqli_query($connection, $query, $result_mode);
 }
+
+/**
+ * Executes one or multiple queries which are concatenated by a semicolon.
+ *
+ * This function is a wrapper for the mysqli_multi_query function. It allows execution of
+ * multiple SQL statements sent to the MySQL server in a single call. This can be useful to
+ * perform a batch of SQL operations such as an atomic transaction that should either complete
+ * entirely or not at all. After calling this function, the results of the queries can be
+ * processed using mysqli_store_result() and mysqli_next_result(). It is important to ensure
+ * that any user input included in the queries is properly sanitized to avoid SQL injection.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $query The queries to execute, concatenated by semicolons.
+ * @return bool Returns TRUE on success or FALSE on the first error that occurred.
+ *              If the first query succeeds, the function will return TRUE even if
+ *              a subsequent query fails.
+ */
+function wpsqli_multi_query($connection, $query)
+{
+    return mysqli_multi_query($connection, $query);
+}
+
+/**
+ * Prepares an SQL statement for execution.
+ *
+ * This function is a wrapper for the mysqli_prepare function. It prepares the SQL statement
+ * and returns a statement object used for further operations on the statement. The statement
+ * preparation is used to efficiently execute repeated queries with high efficiency and to avoid
+ * SQL injection vulnerabilities by separating the query structure from its data. It is especially
+ * useful when the same statement is executed multiple times with different parameters.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $query The SQL query to prepare.
+ * @return mysqli_stmt|false Returns a statement object on success or FALSE on failure.
+ */
+function wpsqli_prepare($connection, $query)
+{
+    return mysqli_prepare($connection, $query);
+}
+
+/**
+ * Executes a prepared Query.
+ *
+ * This function is a wrapper for the mysqli_stmt_execute function. It is used to execute a statement
+ * that was previously prepared using the mysqli_prepare function. The execution will take place with
+ * the current bound parameters in the statement object. This is commonly used in database operations
+ * to execute the same statement repeatedly with high efficiency and to mitigate the risk of SQL injection
+ * by separating SQL logic from the data being input.
+ *
+ * @param mysqli_stmt $stmt The mysqli_stmt statement object.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_stmt_execute($stmt)
+{
+    return mysqli_stmt_execute($stmt);
+}
+
+/**
+ * Binds variables to a prepared statement as parameters.
+ *
+ * This function is a wrapper for the mysqli_stmt_bind_param function. It binds variables to the
+ * placeholders of a prepared statement, which is represented by the `$stmt` parameter. The `$types`
+ * parameter is a string that contains one character for each variable in `$vars`, indicating the type
+ * of the variable. The supported types are 'i' for integer, 'd' for double, 's' for string, and 'b' for
+ * blob. By using this function, the values of the variables are bound to the statement as it is executed,
+ * which can be used to safely execute the statement with user-supplied input.
+ *
+ * @param mysqli_stmt $stmt The prepared statement to which the variables are bound.
+ * @param string $types A string that contains a type specification char for each variable in `$vars`.
+ * @param mixed ...$vars The variables to bind to the prepared statement.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_stmt_bind_param($stmt, $types, ...$vars)
+{
+    return mysqli_stmt_bind_param($stmt, $types, ...$vars);
+}
+
+/**
+ * Binds variables to a prepared statement for result storage.
+ *
+ * This function is a wrapper for the mysqli_stmt_bind_result function. It binds variables to the
+ * prepared statement `$stmt` to store the result of the statement once it is executed. The bound
+ * variables are passed by reference and will be set to the values of the corresponding columns in
+ * the result set. This function is typically used in conjunction with mysqli_stmt_fetch(), which
+ * will populate the variables with data from the next row in the result set each time it is called.
+ *
+ * @param mysqli_stmt $stmt The statement object that executed a query with a result set.
+ * @param mixed &...$vars The variables to which the result set columns will be bound.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_stmt_bind_result($stmt, &...$vars)
+{
+    return mysqli_stmt_bind_result($stmt, ...$vars);
+}
+
+/**
+ * Fetches results from a prepared statement into the bound variables.
+ *
+ * This function is a wrapper for the mysqli_stmt_fetch function. It is used to fetch the data
+ * from the executed prepared statement into the variables that were bound using mysqli_stmt_bind_result().
+ * The function will return TRUE for every row fetched successfully. When there are no more rows to fetch,
+ * it will return NULL, and if there is an error it will return FALSE.
+ *
+ * @param mysqli_stmt $stmt The prepared statement object from which results are to be fetched.
+ * @return bool|null Returns TRUE on success, NULL if there are no more rows to fetch, or FALSE on error.
+ */
+function wpsqli_stmt_fetch($stmt)
+{
+    return mysqli_stmt_fetch($stmt);
+}
+
+/**
+ * Closes a prepared statement.
+ *
+ * This function is a wrapper for the mysqli_stmt_close function. It deallocates the statement
+ * and cleans up the memory associated with the statement object. This is an important step in
+ * resource management, as it frees up server resources and allows other statements to be executed.
+ * It should always be called after all the results have been fetched and the statement is no longer needed.
+ *
+ * @param mysqli_stmt $stmt The prepared statement object to be closed.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_stmt_close($stmt)
+{
+    return mysqli_stmt_close($stmt);
+}
+
+/**
+ * Returns a string description for the last statement error.
+ *
+ * This function is a wrapper for the mysqli_stmt_error function. It returns a string describing
+ * the error for the most recent statement operation that generated an error. This is useful for
+ * debugging and error handling in applications that use prepared statements to interact with the
+ * MySQL database. It allows developers to output or log a descriptive error message when a MySQL
+ * operation on a prepared statement fails.
+ *
+ * @param mysqli_stmt $stmt The mysqli_stmt statement object.
+ * @return string A string that describes the error. An empty string if no error occurred.
+ */
+function wpsqli_stmt_error($stmt)
+{
+    return mysqli_stmt_error($stmt);
+}
+
+/**
+ * Returns the error code for the most recent statement call.
+ *
+ * This function is a wrapper for the mysqli_stmt_errno function. It returns the error code from
+ * the last operation performed on the specified statement. This is useful for error handling,
+ * particularly in database operations where you need to react differently based on the specific
+ * error that occurred. It can be used in conjunction with mysqli_stmt_error() to retrieve both
+ * the error code and the error message for more detailed debugging and logging.
+ *
+ * @param mysqli_stmt $stmt The mysqli_stmt statement object.
+ * @return int An error code value for the last error that occurred, or zero if no error occurred.
+ */
+function wpsqli_stmt_errno($stmt)
+{
+    return mysqli_stmt_errno($stmt);
+}
+
+/**
+* Result Handling
+*/
+
+/**
+ * Fetches a result row as an associative, a numeric array, or both.
+ *
+ * This function is a wrapper for the mysqli_fetch_array function, which is used to fetch a single
+ * row of data from the result set obtained from executing a SELECT query. The data can be fetched
+ * as an associative array, a numeric array, or both, depending on the `mode` specified. By default,
+ * it fetches as both associative and numeric (MYSQLI_BOTH). Using MYSQLI_ASSOC will fetch as an
+ * associative array, and MYSQLI_NUM will fetch as a numeric array. It returns NULL when there are
+ * no more rows to fetch.
+ *
+ * @param mysqli_result $result The result set from a query as returned by mysqli_query.
+ * @param int $mode The type of array that should be produced from the current row data.
+ * @return array|null Returns an array of strings that corresponds to the fetched row or NULL if
+ *                    there are no more rows in result set.
+ */
+function wpsqli_fetch_array($result, $mode = MYSQLI_BOTH)
+{
+    return mysqli_fetch_array($result, $mode);
+}
+
+/**
+ * Fetches a result row as an object.
+ *
+ * This function is a wrapper for the mysqli_fetch_object function. It retrieves the current row
+ * of a result set as an object where the attributes correspond to the fetched row's column names.
+ * This function can instantiate an object of a specified class, and pass parameters to its constructor,
+ * allowing for custom objects based on the rows of the result set. If no class is specified, it defaults
+ * to a stdClass object. If the class does not exist or the specified class's constructor requires more
+ * arguments than are given, an exception is thrown.
+ *
+ * @param mysqli_result $result The result set returned by mysqli_query, mysqli_store_result
+ *                              or mysqli_use_result.
+ * @param string $class The name of the class to instantiate, set the properties of which
+ *                      correspond to the fetched row's column names.
+ * @param array $constructor_args An optional array of parameters to pass to the constructor
+ *                                for the class name defined by the class parameter.
+ * @return object|false An instance of the specified class with property names that correspond
+ *                      to the column names returned in the result set, or FALSE on failure.
+ */
+function wpsqli_fetch_object($result, $class = "stdClass", $constructor_args = [])
+{
+    return mysqli_fetch_object($result, $class, $constructor_args);
+}
+
+/**
+ * Fetches one row of data from the result set and returns it as an enumerated array.
+ * Each call to this function will retrieve the next row in the result set, so it's typically
+ * used in a loop to process multiple rows.
+ * 
+ * This function is particularly useful when you need to retrieve a row as a simple array
+ * where each column is accessed by an integer index starting at 0. It does not include
+ * column names as keys, which can be marginally faster and less memory intensive than
+ * associative arrays if the column names are not required.
+ * 
+ * @param mysqli_result $result The result set returned by a query against the database.
+ * 
+ * @return array|null Returns an enumerated array of strings representing the fetched row,
+ * or NULL if there are no more rows in the result set.
+ */
+function wpsqli_fetch_row(mysqli_result $result): ?array
+{
+    return mysqli_fetch_row($result);
+}
+
+/**
+ * Adjusts the result pointer to an arbitrary row in the result set represented by the
+ * $result object. This function can be used in conjunction with mysqli_fetch_row(),
+ * mysqli_fetch_assoc(), mysqli_fetch_array(), or mysqli_fetch_object() to navigate between
+ * rows in result sets, especially when using buffered result sets.
+ * 
+ * This is an important function for situations where you need to access a specific row
+ * directly without iterating over all preceding rows, which can be useful for pagination
+ * or when looking up specific rows by row number.
+ * 
+ * @param mysqli_result $result The result set returned by a query against the database.
+ * @param int $row_number The desired row number to seek to. Row numbers are zero-indexed.
+ * 
+ * @return bool Returns TRUE on success or FALSE on failure. If the row number is out of range,
+ * it returns FALSE.
+ */
+function wpsqli_data_seek(mysqli_result $result, int $row_number): bool
+{
+    return mysqli_data_seek($result, $row_number);
+}
+
+/**
+ * Returns the next field in the result set.
+ *
+ * This function is a wrapper for the mysqli_fetch_field function, which retrieves information about
+ * the next field in the result set represented by the `$result` parameter. It can be used in a loop
+ * to obtain information about each field in the result set, such as name, table, max length, flags,
+ * and type. This is useful for dynamically generating table structures or processing query results
+ * when the structure of the result set is not known in advance or changes.
+ *
+ * @param mysqli_result $result The result set returned by mysqli_query, mysqli_store_result
+ *                              or mysqli_use_result.
+ * @return object An object which contains field definition information or FALSE if no field information
+ *                is available.
+ */
+function wpsqli_fetch_field($result)
+{
+    return mysqli_fetch_field($result);
+}
+
+/**
+ * Gets the number of fields in a result set.
+ *
+ * This function is a wrapper for the mysqli_num_fields function. It returns the number
+ * of fields (columns) in a result set. This is particularly useful when you need to
+ * dynamically process a query result without knowing the schema of the returned data,
+ * as it allows the script to iterate over all fields in each row of the result set.
+ *
+ * @param mysqli_result $result The result set returned by mysqli_query, mysqli_store_result
+ *                              or mysqli_use_result.
+ * @return int The number of fields in the specified result set.
+ */
+function wpsqli_num_fields($result)
+{
+    return mysqli_num_fields($result);
+}
+
+/**
+ * Returns the number of columns for the most recent query on the connection.
+ *
+ * This function is a wrapper for the mysqli_field_count function. It retrieves the number of
+ * columns obtained from the most recent query executed on the given database connection. This
+ * can be particularly useful when you need to know how many columns will be returned by a
+ * SELECT statement before fetching data, which can help in dynamically processing result sets.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return int An integer representing the number of fields in the result set.
+ */
+function wpsqli_field_count($connection)
+{
+    return mysqli_field_count($connection);
+}
+
+/**
+ * Transfers a result set from the last query.
+ *
+ * This function is a wrapper for the mysqli_store_result function. It is used to transfer the
+ * result set from the last query executed on the given connection, which used the MYSQLI_STORE_RESULT
+ * flag. This function must be called after executing a query that returns a result set (like SELECT).
+ * It allows the complete result set to be transferred to the client and then utilized via the
+ * mysqli_fetch_* functions. It's particularly useful when the result set is expected to be accessed
+ * multiple times.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return mysqli_result|false A buffered result object or FALSE if an error occurred.
+ */
+function wpsqli_store_result($connection)
+{
+    return mysqli_store_result($connection);
+}
+
+/**
+ * Initiates the retrieval of a result set from the last query executed using the MYSQLI_USE_RESULT mode.
+ *
+ * This function is a wrapper for the mysqli_use_result function. It is used to initiate the retrieval
+ * of a result set from the last query executed on the given connection, without storing the entire result
+ * set in the buffer. This is particularly useful for handling large result sets that could potentially
+ * exceed the available PHP memory. The data is fetched row-by-row, reducing the immediate memory footprint.
+ * However, it requires the connection to remain open, and no other operations can be performed on the
+ * connection until the result set is fully processed.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return mysqli_result|false An unbuffered result object or FALSE if an error occurred.
+ */
+function wpsqli_use_result($connection)
+{
+    return mysqli_use_result($connection);
+}
+
+/**
+ * Frees the memory associated with a result.
+ *
+ * This function is a wrapper for the mysqli_free_result function. It's used to free the memory
+ * allocated for a result set obtained from a query. When the result data is not needed anymore,
+ * it's a good practice to free the associated resources, especially when dealing with large
+ * datasets that can consume significant amounts of memory. It is an important aspect of resource
+ * management and helps to keep the application's memory footprint minimal.
+ *
+ * @param mysqli_result $result The result set returned by mysqli_query, mysqli_store_result
+ *                              or mysqli_use_result.
+ * @return void This function doesn't return any value.
+ */
+function wpsqli_free_result($result)
+{
+    return mysqli_free_result($result);
+}
+
+/**
+ * Checks if there are any more result sets from a multi query.
+ *
+ * This function is a wrapper for the mysqli_more_results function. It is used after executing
+ * a multi query with mysqli_multi_query() to check if there are more result sets available.
+ * This is important when processing multiple SQL statements in one call, as it determines
+ * whether the application should keep reading results before sending more statements to the server.
+ * It returns TRUE if one or more result sets are available from the previous calls to
+ * mysqli_multi_query(), otherwise FALSE.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return bool Returns TRUE if there are more result sets from previous multi queries and
+ *              FALSE otherwise.
+ */
+function wpsqli_more_results($connection)
+{
+    return mysqli_more_results($connection);
+}
+
+/**
+ * Moves the internal result pointer to the next result set returned from a multi query.
+ *
+ * This function is a wrapper for the mysqli_next_result function, which is used in a multi query
+ * scenario. After executing mysqli_multi_query(), which can send multiple SQL statements to the
+ * server at once, mysqli_next_result() checks for more result sets and prepares the next one for
+ * reading. This is crucial for handling multiple operations executed with mysqli_multi_query() to
+ * ensure that all result sets are processed sequentially. It returns TRUE if there is another result set,
+ * FALSE if there are no more result sets, or FALSE with an error if there is a problem moving the result pointer.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return bool Returns TRUE on success or FALSE on failure (no more results or an error occurred).
+ */
+function wpsqli_next_result($connection)
+{
+    return mysqli_next_result($connection);
+}
+
+/**
+* Utility Functions
+*/
+
+function wpsqli_is_resource($object)
+{
+    return $object !== false && $object !== null;
+}
+
+/**
+ * Gets the number of affected rows in the previous MySQL operation.
+ *
+ * This function is a wrapper for the mysqli_affected_rows function, which is used to determine
+ * the number of rows affected by the last INSERT, UPDATE, REPLACE or DELETE query executed on
+ * the given connection. It is an important function for understanding the impact of such queries,
+ * allowing the developer to verify that the expected number of rows were altered. It returns an
+ * integer indicating the number of rows affected or -1 if the last query failed.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return int The number of affected rows in the previous operation, or -1 if the last operation failed.
+ */
+function wpsqli_affected_rows($connection)
+{
+    return mysqli_affected_rows($connection);
+}
+
+/**
+ * Retrieves the ID generated by a query on a table with a column having the AUTO_INCREMENT attribute.
+ *
+ * This function is a wrapper for the mysqli_insert_id function, which returns the auto generated id
+ * used in the last query. It is typically used after an INSERT query into a table with an auto-increment
+ * field. The id returned is the one that was automatically generated for the AUTO_INCREMENT column in
+ * the affected table. If the last query wasn't an INSERT or UPDATE statement or didn't affect an
+ * AUTO_INCREMENT column, or if the AUTO_INCREMENT value was set to a non-positive value manually,
+ * this function will return zero.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return int|string The ID generated for an AUTO_INCREMENT column by the previous query on success, 0 if the previous
+ *                    query does not generate an AUTO_INCREMENT value, or FALSE on failure.
+ */
+function wpsqli_insert_id($connection)
+{
+    return mysqli_insert_id($connection);
+}
+
+
+/**
+ * Sets the default character set to be used when sending data from and to the database server.
+ *
+ * This function is a wrapper for the mysqli_set_charset function. The mysqli_set_charset function
+ * is used to set the character set to be used when sending data from and to the database server.
+ * This is particularly important to ensure that data is properly encoded and decoded when stored
+ * and retrieved from the database, avoiding character encoding issues.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $charset The desired character set.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_set_charset($connection, $charset)
+{
+    return mysqli_set_charset($connection, $charset);
+}
+
+/**
+ * Escapes special characters in a string for use in an SQL statement.
+ *
+ * This function serves as a wrapper for the mysqli_real_escape_string function, which is
+ * utilized to escape potentially dangerous special characters within a string. This is a
+ * critical security measure to prevent SQL injection vulnerabilities by ensuring that user
+ * input can be safely used in an SQL query. The function takes a string to be escaped and
+ * the mysqli connection resource, and returns the escaped string which is safe to be included
+ * in SQL statements.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @param string $string The string to be escaped.
+ * @return string Returns the escaped string.
+ */
+function wpsqli_real_escape_string($connection, $string)
+{
+    return mysqli_real_escape_string($connection, $string);
+}
+
+/**
+ * Retrieves the last error description for the most recent MySQLi function call
+ * that can succeed or fail.
+ *
+ * This function is a wrapper for the mysqli_error function, which returns a string
+ * describing the error from the last MySQL operation associated with the provided
+ * connection resource. It's an essential function for debugging and error handling
+ * in MySQL-related operations. When a MySQLi function fails, wpsqli_error can be
+ * used to fetch the corresponding error message to understand what went wrong.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return string Returns a string with the error message for the most recent function call
+ *                if it has failed, or an empty string if no error has occurred.
+ */
+function wpsqli_error($connection)
+{
+    return mysqli_error($connection);
+}
+
+/**
+ * Retrieves the error code for the most recent function call that failed.
+ *
+ * This function is a wrapper for the mysqli_errno function. It returns the error code from
+ * the last error that occurred during a MySQL operation on the given connection. This code
+ * can be used in conjunction with mysqli_error() to provide a detailed explanation of the
+ * error, especially for logging or for generating user-friendly error messages.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return int Returns an error code value representing the error from the last MySQL operation
+ *             on the given connection, or zero if no error occurred.
+ */
+function wpsqli_errno($connection)
+{
+    return mysqli_errno($connection);
+}
+
+/**
+ * Enables or disables internal report functions.
+ *
+ * This function is a wrapper for the mysqli_report function, which is used to set the
+ * reporting mode of mysqli errors. This is useful for defining whether errors should be
+ * reported as exceptions, warnings, or silent (no report). It's important for configuring
+ * the error reporting behavior of the mysqli extension to suit the needs of your application,
+ * particularly in a development environment where more verbose error reporting is beneficial.
+ *
+ * @param int $flags A bit-mask constructed from the MYSQLI_REPORT_* constants.
+ * @return bool Returns TRUE on success or FALSE on failure.
+ */
+function wpsqli_report($flags)
+{
+    return mysqli_report($flags);
+}
+
+/**
+ * Retrieves information about the most recently executed query.
+ *
+ * This function is a wrapper for the mysqli_info function. It provides a string containing
+ * information about the most recently executed query on the given connection resource. This
+ * can include information such as the number of rows affected by an INSERT, UPDATE, REPLACE,
+ * or DELETE query, as well as the number of rows matched and changed. It is valuable for
+ * obtaining detailed insights into the execution of database operations.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return string|null A string representing information about the last query executed,
+ *                     or NULL if no information is available.
+ */
+function wpsqli_info($connection)
+{
+    return mysqli_info($connection);
+}
+
+/**
+ * Initializes a statement and returns an object for use with mysqli_stmt_prepare.
+ *
+ * This function is a wrapper for the mysqli_stmt_init function. It creates and returns a new statement
+ * object associated with the specified database connection. This statement object can then be used
+ * to prepare a SQL statement for execution. It's particularly useful when you need to execute a
+ * prepared statement multiple times with different parameters, providing benefits such as improved
+ * query performance and protection against SQL injection attacks.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return mysqli_stmt A new statement object or FALSE on failure.
+ */
+function wpsqli_stmt_init($connection)
+{
+    return mysqli_stmt_init($connection);
+}
+
+/**
+ * Polls connections for results.
+ *
+ * This function is a wrapper for the mysqli_poll function. It can be used to poll multiple
+ * connections to check if one or more of the connections have results available for client-side
+ * processing. It is useful when you have multiple asynchronous queries running and need to handle
+ * them as soon as their results become available. The function takes variable references for read,
+ * error, and reject arrays, and modifies them to indicate which connections have results, which
+ * have errors, and which were rejected respectively.
+ *
+ * @param array &$read Array of connections to check for outstanding results that can be read.
+ * @param array &$error Array of connections on which an error occurred.
+ * @param array &$reject Array of connections rejected because no asynchronous query
+ *                       has been run on them.
+ * @param int $sec Number of seconds to wait, must be non-negative.
+ * @param int $usec Number of microseconds to wait, must be non-negative.
+ * @return int|false Number of ready connections upon success, FALSE otherwise.
+ */
+function wpsqli_poll(&...$args)
+{
+    return mysqli_poll(...$args);
+}
+
+/**
+ * Gets the result from asynchronous MySQL query.
+ *
+ * This function is a wrapper for the mysqli_reap_async_query function. It is used after initiating
+ * a query with mysqli_query() on a connection with the MYSQLI_ASYNC flag set. It retrieves the result
+ * from the query once it is complete, which can be used with mysqli_poll() to manage multiple
+ * asynchronous queries. It returns a mysqli_result object for successful SELECT queries, or TRUE for
+ * other DML queries (INSERT, UPDATE, DELETE, etc.) if the operation was successful, or FALSE on failure.
+ *
+ * @param mysqli $connection The mysqli connection resource.
+ * @return mysqli_result|bool A mysqli_result object for successful SELECT queries, TRUE for other
+ *                            successful DML queries, or FALSE on failure.
+ */
+function wpsqli_reap_async_query($connection)
+{
+    return mysqli_reap_async_query($connection);
+}
\ No newline at end of file