Add pg4wp plugin and update wordpress.yaml

pg4wp/core.php

@@ -0,0 +1,39 @@
+<?php
+/**
+ * @package PostgreSQL_For_Wordpress
+ * @version $Id$
+ * @author	Hawk__, www.hawkix.net
+ */
+
+/**
+* This file does all the initialisation tasks
+*/
+
+// This is required by class-wpdb so we must load it first
+require_once ABSPATH . '/wp-includes/version.php';
+require_once ABSPATH . '/wp-includes/cache.php';
+require_once ABSPATH . '/wp-includes/l10n.php';
+
+// Load the driver defined in 'db.php'
+require_once(PG4WP_ROOT . '/driver_' . DB_DRIVER . '.php');
+
+// This loads up the wpdb class applying appropriate changes to it
+$replaces = array(
+    'define( '	=> '// define( ',
+    'class wpdb'	=> 'class wpdb2',
+    'new wpdb'	=> 'new wpdb2',
+    'instanceof mysqli_result' => 'instanceof \PgSql\Result',
+    'instanceof mysqli' => 'instanceof \PgSql\Connection',
+    '$this->dbh->connect_errno' => 'wpsqli_connect_error()',
+    'mysqli_'	=> 'wpsqli_',
+    'is_resource'	=> 'wpsqli_is_resource',
+    '<?php'		=> '',
+    '?>'		=> '',
+);
+
+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
+if (!isset($wpdb) && defined('DB_USER')) {
+    $wpdb = new wpdb2(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST);
+}

pg4wp/db.php

@@ -0,0 +1,54 @@
+<?php
+/*
+Plugin Name: PostgreSQL for WordPress (PG4WP)
+Plugin URI: https://github.com/PostgreSQL-For-Wordpress/postgresql-for-wordpress
+Description: PG4WP is a special plugin enabling WordPress to use a PostgreSQL database.
+Version: v3.0.0
+Author: PostgreSQL-For-Wordpress
+Author URI: https://github.com/PostgreSQL-For-Wordpress
+License: GPLv2 or newer.
+*/
+
+// Ensure we only load this config once
+if(!defined('PG4WP_ROOT')) {
+
+    // You can choose the driver to load here
+    if (!defined('DB_DRIVER')) {
+        define('DB_DRIVER', 'pgsql');
+    }
+
+    // Set this to 'true' and check that `pg4wp` is writable if you want debug logs to be written
+    if (!defined('PG4WP_DEBUG')) {
+        define('PG4WP_DEBUG', false);
+    }
+
+    if (!defined('PG4WP_LOG_ERRORS')) {
+        // If you just want to log queries that generate errors, leave PG4WP_DEBUG to "false"
+        // and set this to true
+        define('PG4WP_LOG_ERRORS', true);
+    }
+
+    // This defines the directory where PG4WP files are loaded from
+    //   3 places checked : wp-content, wp-content/plugins and the base directory
+    if(file_exists(ABSPATH . 'wp-content/pg4wp')) {
+        define('PG4WP_ROOT', ABSPATH . 'wp-content/pg4wp');
+    } elseif(file_exists(ABSPATH . 'wp-content/plugins/pg4wp')) {
+        define('PG4WP_ROOT', ABSPATH . 'wp-content/plugins/pg4wp');
+    } elseif(file_exists(ABSPATH . 'pg4wp')) {
+        define('PG4WP_ROOT', ABSPATH . 'pg4wp');
+    } else {
+        die('PG4WP file directory not found');
+    }
+
+    // Logs are put in the pg4wp directory
+    if (!defined('PG4WP_LOG')) {
+        define('PG4WP_LOG', PG4WP_ROOT . '/logs/');
+    }
+    // Check if the logs directory is needed and exists or create it if possible
+    if((PG4WP_DEBUG || PG4WP_LOG_ERRORS) && !file_exists(PG4WP_LOG) && is_writable(dirname(PG4WP_LOG))) {
+        mkdir(PG4WP_LOG);
+    }
+
+    // Here happens all the magic
+    require_once(PG4WP_ROOT . '/core.php');
+} // Protection against multiple loading

pg4wp/driver_mysql.php

@@ -0,0 +1,986 @@
+<?php
+
+/**
+* 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
+*/
+
+/**
+* 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 mysqli_init();
+}
+
+/**
+ * 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 mysqli_real_connect($connection, $hostname, $username, $password, $database, $port, $socket, $flags);
+}
+
+/**
+ * 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 mysqli_close($connection);
+}
+
+/**
+ * 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 mysqli_ssl_set($connection, $key, $cert, $ca, $capath, $cipher);
+}
+
+/**
+ * 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 mysqli_get_client_info();
+}
+
+/**
+ * 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 mysqli_get_server_info($connection);
+}
+
+/**
+ * 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 mysqli_get_host_info($connection);
+}
+
+/**
+ * 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 mysqli_ping($connection);
+}
+
+/**
+ * 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 mysqli_thread_id($connection);
+}
+
+/**
+ * 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 mysqli_thread_safe();
+}
+
+/**
+ * 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 mysqli_stat($connection);
+}
+
+/**
+ * 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 mysqli_options($connection, $option, $value);
+}
+
+/**
+ * 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 mysqli_connect_errno();
+}
+
+/**
+ * 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 mysqli_connect_error();
+}
+
+/**
+* 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 mysqli_autocommit($connection, $mode);
+}
+
+/**
+ * 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 mysqli_begin_transaction($connection, $flags, $name);
+}
+
+/**
+ * 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 mysqli_commit($connection, $flags, $name);
+}
+
+/**
+ * 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 mysqli_rollback($connection, $flags, $name);
+}
+
+/**
+* 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 mysqli_select_db($connection, $database);
+}
+
+/**
+ * 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 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);
+}

pg4wp/driver_pgsql_rewrite.php

@@ -0,0 +1,193 @@
+<?php
+
+// Autoload function to automatically require rewriter classes from the "rewriters" folder
+spl_autoload_register(function ($className) {
+    $filePath = PG4WP_ROOT . '/rewriters/' . $className . '.php';
+    if (file_exists($filePath)) {
+        require_once $filePath;
+    }
+});
+
+
+function createSQLRewriter(string $sql): AbstractSQLRewriter
+{
+    $sql = trim($sql);
+    if (preg_match('/^(SELECT|INSERT|REPLACE INTO|UPDATE|DELETE|DESCRIBE|ALTER TABLE|CREATE TABLE|DROP TABLE|SHOW INDEX|SHOW VARIABLES|SHOW TABLES|OPTIMIZE TABLE|SET NAMES|SHOW FULL COLUMNS|SHOW TABLE STATUS)\b/i', $sql, $matches)) {
+        // Convert to a format suitable for class names (e.g., "SHOW TABLES" becomes "ShowTables")
+        $type = str_replace(' ', '', ucwords(str_replace('_', ' ', strtolower($matches[1]))));
+        $className = $type . 'SQLRewriter';
+
+        if (class_exists($className)) {
+            return new $className($sql);
+        } else {
+            throw new Exception("No class defined to handle SQL type: " . $type);
+        }
+    }
+    throw new Exception("Invalid or unsupported SQL statement.");
+}
+
+
+function pg4wp_rewrite($sql)
+{
+    // Note:  Can be called from constructor before $wpdb is set
+    global $wpdb;
+
+    $initial = $sql;
+    $logto = 'queries';
+    // The end of the query may be protected against changes
+    $end = '';
+
+    $rewriter = createSQLRewriter(trim($sql));
+    $sql = $rewriter->rewrite();
+    $logto = strtoupper($rewriter->type());
+    switch ($rewriter->type()) {
+        case 'Update':
+            // This will avoid modifications to anything following ' SET '
+            list($sql, $end) = explode(' SET ', $sql, 2);
+            $end = ' SET ' . $end;
+            break;
+        case 'Insert':
+            // This will avoid modifications to anything following ' VALUES'
+            list($sql, $end) = explode(' VALUES', $sql, 2);
+            $end = ' VALUES' . $end;
+
+            // When installing, the sequence for table terms has to be updated
+            if(defined('WP_INSTALLING') && WP_INSTALLING && false !== strpos($sql, 'INSERT INTO `' . $wpdb->terms . '`')) {
+                $end .= ';SELECT setval(\'' . $wpdb->terms . '_term_id_seq\', (SELECT MAX(term_id) FROM ' . $wpdb->terms . ')+1);';
+            }
+            break;
+        case 'Insert':
+            break;
+        default:
+    }
+
+    $sql = correctMetaValue($sql);
+    $sql = handleInterval($sql);
+    $sql = cleanAndCapitalize($sql);
+    $sql = correctEmptyInStatements($sql);
+    $sql = correctQuoting($sql);
+
+    // Put back the end of the query if it was separated
+    $sql .= $end;
+
+    // For insert ID caching
+    if($logto == 'INSERT') {
+        $pattern = '/INSERT INTO "?([\w_]+)"? \(([^)]+)\)/i';
+        preg_match($pattern, $sql, $matches);
+
+        if (isset($matches[1])) {
+            $GLOBALS['pg4wp_ins_table'] = $matches[1];
+        }
+
+        if (isset($matches[2])) {
+            $columns_str = $matches[2];
+            $columns = explode(',', $columns_str);
+            $columns = array_map(function ($column) {
+                return trim(trim($column), '"');
+            }, $columns);
+            if (isset($columns[0])) {
+                $GLOBALS['pg4wp_ins_field'] = $columns[0];
+            }
+        }
+
+        $GLOBALS['pg4wp_last_insert'] = $sql;
+    } elseif(isset($GLOBALS['pg4wp_queued_query'])) {
+        pg_query($GLOBALS['pg4wp_queued_query']);
+        unset($GLOBALS['pg4wp_queued_query']);
+    }
+
+    if(PG4WP_DEBUG) {
+        if($initial != $sql) {
+            error_log('[' . microtime(true) . "] Converting :\n$initial\n---- to ----\n$sql\n---------------------\n", 3, PG4WP_LOG . 'pg4wp_' . $logto . '.log');
+        } else {
+            error_log('[' . microtime(true) . "] $sql\n---------------------\n", 3, PG4WP_LOG . 'pg4wp_unmodified.log');
+        }
+    }
+    return $sql;
+}
+
+/**
+ * Correct the meta_value field for WP 2.9.1 and add type cast.
+ *
+ * @param string $sql SQL query string
+ * @return string Modified SQL query string
+ */
+function correctMetaValue($sql)
+{
+    // WP 2.9.1 uses a comparison where text data is not quoted
+    $sql = preg_replace('/AND meta_value = (-?\d+)/', 'AND meta_value = \'$1\'', $sql);
+    // Add type cast for meta_value field when it's compared to number
+    $sql = preg_replace('/AND meta_value < (\d+)/', 'AND meta_value::bigint < $1', $sql);
+    return $sql;
+}
+
+/**
+ * Handle interval expressions in SQL query.
+ *
+ * @param string $sql SQL query string
+ * @return string Modified SQL query string
+ */
+function handleInterval($sql)
+{
+    // Generic "INTERVAL xx YEAR|MONTH|DAY|HOUR|MINUTE|SECOND" handler
+    $sql = preg_replace('/INTERVAL[ ]+(\d+)[ ]+(YEAR|MONTH|DAY|HOUR|MINUTE|SECOND)/', "'\$1 \$2'::interval", $sql);
+    // DATE_SUB handling
+    $sql = preg_replace('/DATE_SUB[ ]*\(([^,]+),([^\)]+)\)/', '($1::timestamp - $2)', $sql);
+    return $sql;
+}
+
+/**
+ * Clean SQL query from illegal characters and handle capitalization.
+ *
+ * @param string $sql SQL query string
+ * @return string Modified SQL query string
+ */
+function cleanAndCapitalize($sql)
+{
+    // Remove illegal characters
+    $sql = str_replace('`', '', $sql);
+    // Field names with CAPITALS need special handling
+    if (false !== strpos($sql, 'ID')) {
+        $patterns = [
+            '/ID([^ ])/' => 'ID $1',
+            '/ID$/' => 'ID ',
+            '/\(ID/' => '( ID',
+            '/,ID/' => ', ID',
+            '/[0-9a-zA-Z_]+ID/' => '"$0"',
+            '/\.ID/' => '."ID"',
+            '/[\s]ID /' => ' "ID" ',
+            '/"ID "/' => ' "ID" '
+        ];
+        foreach ($patterns as $pattern => $replacement) {
+            $sql = preg_replace($pattern, $replacement, $sql);
+        }
+    }
+    return $sql;
+}
+
+/**
+ * Correct empty IN statements in SQL query.
+ *
+ * @param string $sql SQL query string
+ * @return string Modified SQL query string
+ */
+function correctEmptyInStatements($sql)
+{
+    $search = ['IN (\'\')', 'IN ( \'\' )', 'IN ()'];
+    $replace = 'IN (NULL)';
+    $sql = str_replace($search, $replace, $sql);
+    return $sql;
+}
+
+/**
+ * Correct quoting for PostgreSQL 9.1+ compatibility.
+ *
+ * @param string $sql SQL query string
+ * @return string Modified SQL query string
+ */
+function correctQuoting($sql)
+{
+    $sql = str_replace("\\'", "''", $sql);
+    $sql = str_replace('\"', '"', $sql);
+    return $sql;
+}

pg4wp/rewriters/AbstractSQLRewriter.php

@@ -0,0 +1,26 @@
+<?php
+
+abstract class AbstractSQLRewriter
+{
+    protected string $originalSQL;
+
+    public function __construct(string $sql)
+    {
+        $this->originalSQL = $sql;
+    }
+
+    abstract public function rewrite(): string;
+
+    public function original(): string
+    {
+        return $this->originalSQL;
+    }
+
+    public function type(): string
+    {
+        // Get the called class name and remove the "SQLRewriter" suffix to get the SQL type
+        $className = get_called_class();
+        $type = str_replace('SQLRewriter', '', $className);
+        return $type;
+    }
+}

pg4wp/rewriters/AlterTableSQLRewriter.php

@@ -0,0 +1,290 @@
+<?php
+
+class AlterTableSQLRewriter extends AbstractSQLRewriter
+{
+    private $stringReplacements = [
+        ' tinytext'		=> ' text',
+        ' mediumtext'	=> ' text',
+        ' longtext'		=> ' text',
+        ' unsigned'		=> ' ',
+        'gmt datetime NOT NULL default \'0000-00-00 00:00:00\''	=> 'gmt timestamp NOT NULL DEFAULT timezone(\'gmt\'::text, now())',
+        'default \'0000-00-00 00:00:00\''	=> 'DEFAULT now()',
+        '\'0000-00-00 00:00:00\''	=> 'now()',
+        ' datetime'		=> ' timestamp',
+        ' DEFAULT CHARACTER SET utf8mb4' => '',
+        ' DEFAULT CHARACTER SET utf8'	=> '',
+
+        // For WPMU (starting with WP 3.2)
+        " enum('0','1')"	=> ' smallint',
+        ' COLLATE utf8mb4_unicode_520_ci'	=> '',
+        ' COLLATE utf8_general_ci'	=> '',
+        ' CHARACTER SET utf8' => '',
+        ' DEFAULT CHARSET=utf8' => '',
+
+        // For flash-album-gallery plugin
+        ' tinyint'		=> ' smallint'
+    ];
+
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        
+        $sql = $this->rewrite_numeric_type($sql);
+        $sql = $this->rewrite_columns_with_protected_names($sql);
+
+        if (str_contains($sql, 'ADD INDEX') || str_contains($sql, 'ADD UNIQUE INDEX')) {
+            $sql = $this->rewriteAddIndex($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'CHANGE COLUMN')) {
+            $sql = $this->rewriteChangeColumn($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'ALTER COLUMN')) {
+            $sql = $this->rewriteAlterColumn($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'ADD COLUMN')) {
+            $sql = $this->rewriteAddColumn($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'ADD KEY') || str_contains($sql, 'ADD UNIQUE KEY')) {
+            $sql = $this->rewriteAddKey($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'DROP INDEX')) {
+            $sql = $this->rewriteDropIndex($sql);
+            return $sql;
+        }
+        if (str_contains($sql, 'DROP PRIMARY KEY')) {
+            $sql = $this->rewriteDropPrimaryKey($sql);
+            return $sql;
+        }
+
+        return $sql;
+    }
+
+    private function rewriteAddIndex(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+ADD (UNIQUE |)INDEX\s+([^\s]+)\s+\(((?:[^\(\)]+|\([^\(\)]+\))+)\)/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $unique = $matches[2];
+            $index = $matches[3];
+            $columns = $matches[4];
+
+            // Remove prefix indexing
+            // Rarely used and apparently unnecessary for current uses
+            $columns = preg_replace('/\([^\)]*\)/', '', $columns);
+
+            // Workaround for index name duplicate
+            $index = $table . '_' . $index;
+
+            // Add backticks around index name and column name, and include IF NOT EXISTS clause
+            $sql = "CREATE {$unique}INDEX IF NOT EXISTS `{$index}` ON `{$table}` (`{$columns}`)";
+        }
+
+        return $sql;
+    }
+
+    private function rewriteChangeColumn(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+CHANGE COLUMN\s+([^\s]+)\s+([^\s]+)\s+([^ ]+)( unsigned|)\s*(NOT NULL|)\s*(default (.+)|)/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $col = $matches[2];
+            $newname = $matches[3];
+            $type = strtolower($matches[4]);
+            if(isset($this->stringReplacements[$type])) {
+                $type = $this->stringReplacements[$type];
+            }
+            $unsigned = $matches[5];
+            $notnull = $matches[6];
+            $default = $matches[7];
+            $defval = $matches[8];
+            if(isset($this->stringReplacements[$defval])) {
+                $defval = $this->stringReplacements[$defval];
+            }
+            $newq = "ALTER TABLE $table ALTER COLUMN $col TYPE $type";
+            if(!empty($notnull)) {
+                $newq .= ", ALTER COLUMN $col SET NOT NULL";
+            }
+            if(!empty($default)) {
+                $newq .= ", ALTER COLUMN $col SET DEFAULT $defval";
+            }
+            if($col != $newname) {
+                $newq .= ";ALTER TABLE $table RENAME COLUMN $col TO $newcol;";
+            }
+            $sql = $newq;
+        }
+
+        return $sql;
+    }
+
+    private function rewriteAlterColumn(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+ALTER COLUMN\s+/';
+
+        if(1 === preg_match($pattern, $sql)) {
+            // Translate default values
+            $sql = str_replace(
+                array_keys($this->stringReplacements),
+                array_values($this->stringReplacements),
+                $sql
+            );
+        }
+
+        return $sql;
+    }
+
+    private function rewriteAddColumn(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+ADD COLUMN\s+([^\s]+)\s+([^ ]+)( unsigned|)\s+(NOT NULL|)\s*(default (.+)|)/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $col = $matches[2];
+            $type = strtolower($matches[3]);
+            if(isset($this->stringReplacements[$type])) {
+                $type = $this->stringReplacements[$type];
+            }
+            $unsigned = $matches[4];
+            $notnull = $matches[5];
+            $default = $matches[6];
+            $defval = $matches[7];
+            if(isset($this->stringReplacements[$defval])) {
+                $defval = $this->stringReplacements[$defval];
+            }
+            $newq = "ALTER TABLE $table ADD COLUMN $col $type";
+            if(!empty($default)) {
+                $newq .= " DEFAULT $defval";
+            }
+            if(!empty($notnull)) {
+                $newq .= " NOT NULL";
+            }
+            $sql = $newq;
+        }
+
+        return $sql;
+    }
+
+    private function rewriteAddKey(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+ADD (UNIQUE |)KEY\s+([^\s]+)\s+\(((?:[^\(\)]+|\([^\(\)]+\))+)\)/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $unique = $matches[2];
+            $index = $matches[3];
+            $columns = $matches[4];
+
+            // Remove prefix indexing
+            // Rarely used and apparently unnecessary for current uses
+            $columns = preg_replace('/\([^\)]*\)/', '', $columns);
+
+            // Workaround for index name duplicate
+            $index = $table . '_' . $index;
+            $sql = "CREATE {$unique}INDEX $index ON $table ($columns)";
+        }
+
+        return $sql;
+    }
+
+    private function rewriteDropIndex(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+DROP INDEX\s+([^\s]+)/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $index = $matches[2];
+            $sql = "DROP INDEX {$table}_{$index}";
+        }
+
+        return $sql;
+    }
+
+    private function rewriteDropPrimaryKey(string $sql): string
+    {
+        $pattern = '/ALTER TABLE\s+(\w+)\s+DROP PRIMARY KEY/';
+
+        if(1 === preg_match($pattern, $sql, $matches)) {
+            $table = $matches[1];
+            $sql = "ALTER TABLE {$table} DROP CONSTRAINT {$table}_pkey";
+        }
+
+        return $sql;
+    }
+
+    private function rewrite_numeric_type($sql)
+    {
+        // Numeric types in MySQL which need to be rewritten
+        $numeric_types = ["bigint", "int", "integer", "smallint", "mediumint", "tinyint", "double", "decimal"];
+        $numeric_types_imploded = implode('|', $numeric_types);
+
+        // Prepare regex pattern to match 'type(x)'
+        $pattern = "/(" . $numeric_types_imploded . ")\(\d+\)/";
+
+        // Execute type find & replace
+        $sql = preg_replace_callback($pattern, function ($matches) {
+            return $matches[1];
+        }, $sql);
+
+        // bigint
+        $pattern = '/bigint(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'bigserial', $sql);
+        }
+
+        // int
+        $pattern = '/int(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'serial', $sql);
+        }
+
+        // smallint
+        $pattern = '/smallint(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'smallserial', $sql);
+        }
+
+        // Handle for numeric and decimal -- being replaced with serial
+        $numeric_patterns = ['/numeric(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i', '/decimal(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i'];
+        foreach($numeric_patterns as $pattern) {
+            preg_match($pattern, $sql, $matches);
+            if($matches) {
+                $sql = preg_replace($pattern, 'serial', $sql);
+            }
+        }
+
+        return $sql;
+    }
+
+    private function rewrite_columns_with_protected_names($sql) 
+    {
+        // Splitting the SQL statement into parts before "(", inside "(", and after ")"
+        if (preg_match('/^(CREATE TABLE IF NOT EXISTS|CREATE TABLE|ALTER TABLE)\s+([^\s]+)\s*\((.*)\)(.*)$/is', $sql, $matches)) {
+            $prefix = $matches[1] . ' ' . $matches[2] . ' (';
+            $columnsAndKeys = $matches[3];
+            $suffix = ')' . $matches[4];
+    
+            $regex = '/(?:^|\s*,\s*)(\b(?:timestamp|date|time|default)\b)\s*(?=\s+\w+)/i'; 
+
+            // Callback function to add quotes around protected column names
+            $callback = function($matches) {
+                $whitespace = str_replace($matches[1], "", $matches[0]);
+                return $whitespace . '"' . $matches[1] . '"';
+            };
+
+            // Replace protected column names with quoted versions within columns and keys part
+            $columnsAndKeys = preg_replace_callback($regex, $callback, $columnsAndKeys);
+            return $prefix . $columnsAndKeys . $suffix;
+        }
+
+        return $sql;
+    }
+}

pg4wp/rewriters/CreateTableSQLRewriter.php

@@ -0,0 +1,168 @@
+<?php
+
+class CreateTableSQLRewriter extends AbstractSQLRewriter
+{
+    private $stringReplacements = [
+        ' tinytext'		=> ' text',
+        ' mediumtext'	=> ' text',
+        ' longtext'		=> ' text',
+        ' unsigned'		=> ' ',
+        'gmt datetime NOT NULL default \'0000-00-00 00:00:00\''	=> 'gmt timestamp NOT NULL DEFAULT timezone(\'gmt\'::text, now())',
+        'default \'0000-00-00 00:00:00\''	=> 'DEFAULT now()',
+        '\'0000-00-00 00:00:00\''	=> 'now()',
+        ' datetime'		=> ' timestamp',
+        ' DEFAULT CHARACTER SET utf8mb4' => '',
+        ' DEFAULT CHARACTER SET utf8'	=> '',
+
+        // For WPMU (starting with WP 3.2)
+        " enum('0','1')"	=> ' smallint',
+        ' COLLATE utf8mb4_unicode_520_ci'	=> '',
+        ' COLLATE utf8_general_ci'	=> '',
+        ' CHARACTER SET utf8' => '',
+        ' DEFAULT CHARSET=utf8' => '',
+
+        ' tinyint'		=> ' smallint',
+        ' mediumint'    => ' integer'
+    ];
+
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+
+        $tableSQL = str_replace('CREATE TABLE IF NOT EXISTS ', 'CREATE TABLE ', $sql);
+        $pattern = '/CREATE TABLE [`]?(\w+)[`]?/';
+        preg_match($pattern, $tableSQL, $matches);
+        $table = $matches[1];
+
+        // change all creates into create if not exists
+        $pattern = "/CREATE TABLE (IF NOT EXISTS )?(\w+)\s*\(/i";
+        $replacement = 'CREATE TABLE IF NOT EXISTS $2 (';
+        $sql = preg_replace($pattern, $replacement, $sql);
+
+        // Remove trailing spaces
+        $sql = trim($sql);
+
+        // Add a slash if needed
+        if (substr($sql, strlen($sql) - 1, 1) != ";") {
+            $sql = $sql . ";";
+        }
+
+        // Translate types and some other replacements
+        $sql = str_ireplace(
+            array_keys($this->stringReplacements),
+            array_values($this->stringReplacements),
+            $sql
+        );
+
+        $sql = $this->rewrite_numeric_type($sql);
+        $sql = $this->rewrite_columns_with_protected_names($sql);
+
+        // Support for UNIQUE INDEX creation
+        $pattern = '/,\s*(UNIQUE |)KEY\s+(`[^`]+`|\w+)\s+\(((?:[^()]|\([^)]*\))*)\)/';
+        if(preg_match_all($pattern, $sql, $matches, PREG_SET_ORDER)) {
+            foreach($matches as $match) {
+                $unique = $match[1];
+                $index = $match[2];
+                $columns = $match[3];
+
+                // Removing backticks from the index names
+                $index = str_replace('`', '', $index);
+
+                // Removing backticks and key length constraints from the columns
+                $columns = preg_replace(["/`/", "/\(\d+\)/"], '', $columns);
+
+                // Creating a unique index name
+                $indexName = $table . '_' . $index;
+
+                // Appending the CREATE INDEX statement to SQL
+                $sql .= "\nCREATE {$unique}INDEX IF NOT EXISTS $indexName ON $table ($columns);";
+            }
+        }
+        // Now remove handled indexes
+        $sql = preg_replace($pattern, '', $sql);
+
+
+        // Rewrite unique keys to just be UNIQUE without a key name
+        $pattern = "/(,\s*)?UNIQUE KEY\s+[a-zA-Z0-9_]+\s+(\([a-zA-Z0-9_,\s]+\))/";
+        $replacement = "$1UNIQUE $2";
+        $sql = preg_replace($pattern, $replacement, $sql);
+
+        // Rewrite Primary keys to not have a key name
+        $pattern = '/PRIMARY KEY\s+\w+\s*\((.*?)\)/';
+        $replacement = 'PRIMARY KEY ($1)';
+        $sql = preg_replace($pattern, $replacement, $sql);
+
+        return $sql;
+    }
+
+    private function rewrite_numeric_type($sql)
+    {
+        // Numeric types in MySQL which need to be rewritten
+        $numeric_types = ["bigint", "int", "integer", "smallint", "mediumint", "tinyint", "double", "decimal"];
+        $numeric_types_imploded = implode('|', $numeric_types);
+
+        // Prepare regex pattern to match 'type(x)'
+        $pattern = "/(" . $numeric_types_imploded . ")\(\d+\)/i";
+
+        // Execute type find & replace
+        $sql = preg_replace_callback($pattern, function ($matches) {
+            return $matches[1];
+        }, $sql);
+
+        // bigint
+        $pattern = '/bigint(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'bigserial', $sql);
+        }
+
+        // int
+        $pattern = '/int(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'serial', $sql);
+        }
+
+        // smallint
+        $pattern = '/smallint(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i';
+        preg_match($pattern, $sql, $matches);
+        if($matches) {
+            $sql = preg_replace($pattern, 'smallserial', $sql);
+        }
+
+        // Handle for numeric and decimal -- being replaced with serial
+        $numeric_patterns = ['/numeric(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i', '/decimal(\(\d+\))?([ ]*NOT NULL)?[ ]*auto_increment/i'];
+        foreach($numeric_patterns as $pattern) {
+            preg_match($pattern, $sql, $matches);
+            if($matches) {
+                $sql = preg_replace($pattern, 'serial', $sql);
+            }
+        }
+
+        return $sql;
+    }
+
+    private function rewrite_columns_with_protected_names($sql) 
+    {
+        // Splitting the SQL statement into parts before "(", inside "(", and after ")"
+        if (preg_match('/^(CREATE TABLE IF NOT EXISTS|CREATE TABLE|ALTER TABLE)\s+([^\s]+)\s*\((.*)\)(.*)$/is', $sql, $matches)) {
+            $prefix = $matches[1] . ' ' . $matches[2] . ' (';
+            $columnsAndKeys = $matches[3];
+            $suffix = ')' . $matches[4];
+    
+            $regex = '/(?:^|\s*,\s*)(\b(?:timestamp|date|time|default|end)\b)\s*(?=\s+\w+)/i'; 
+
+            // Callback function to add quotes around protected column names
+            $callback = function($matches) {
+                $whitespace = str_replace($matches[1], "", $matches[0]);
+                return $whitespace . '"' . $matches[1] . '"';
+            };
+
+            // Replace protected column names with quoted versions within columns and keys part
+            $columnsAndKeys = preg_replace_callback($regex, $callback, $columnsAndKeys);
+            return $prefix . $columnsAndKeys . $suffix;
+        }
+
+        return $sql;
+    }
+}

pg4wp/rewriters/DeleteSQLRewriter.php

@@ -0,0 +1,104 @@
+<?php
+
+class DeleteSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        global $wpdb;
+
+        $sql = $this->original();
+
+        // ORDER BY is not supported in DELETE queries, and not required
+        // when LIMIT is not present
+        if(false !== strpos($sql, 'ORDER BY') && false === strpos($sql, 'LIMIT')) {
+            $pattern = '/ORDER BY \S+ (ASC|DESC)?/';
+            $sql = preg_replace($pattern, '', $sql);
+        }
+
+        // LIMIT is not allowed in DELETE queries
+        $sql = str_replace('LIMIT 1', '', $sql);
+        $sql = str_replace(' REGEXP ', ' ~ ', $sql);
+
+        // Get the WordPress table prefix
+        $prefix = $wpdb->prefix;
+
+        // This handles removal of duplicate entries in table options
+        if(false !== strpos($sql, 'DELETE o1 FROM ')) {
+            $sql = "DELETE FROM $wpdb->options WHERE option_id IN " .
+                "(SELECT o1.option_id FROM $wpdb->options AS o1, $wpdb->options AS o2 " .
+                "WHERE o1.option_name = o2.option_name " .
+                "AND o1.option_id < o2.option_id)";
+        }
+        // Rewrite _transient_timeout multi-table delete query with dynamic prefix for options table
+        elseif(preg_match('/DELETE a, b FROM ' . preg_quote($prefix, '/') . 'options a, ' . preg_quote($prefix, '/') . 'options b/', $sql)) {
+            $where = substr($sql, strpos($sql, 'WHERE ') + 6);
+            $where = rtrim($where, " \t\n\r;");
+            // Fix string/number comparison by adding check and cast
+            $where = str_replace('AND b.option_value', 'AND b.option_value ~ \'^[0-9]+$\' AND CAST(b.option_value AS BIGINT)', $where);
+            // Mirror WHERE clause to delete both sides of self-join.
+            $where2 = strtr($where, array('a.' => 'b.', 'b.' => 'a.'));
+            $sql = "DELETE FROM {$wpdb->options} a USING {$wpdb->options} b WHERE " .
+                '(' . $where . ') OR (' . $where2 . ');';
+        }
+
+        // Rewrite _transient_timeout multi-table delete query with dynamic prefix for sitemeta table
+        elseif(preg_match('/DELETE a, b FROM ' . preg_quote($prefix, '/') . 'sitemeta a, ' . preg_quote($prefix, '/') . 'sitemeta b/', $sql)) {
+            $where = substr($sql, strpos($sql, 'WHERE ') + 6);
+            $where = rtrim($where, " \t\n\r;");
+            // Fix string/number comparison by adding check and cast
+            $where = str_replace('AND b.meta_value', 'AND b.meta_value ~ \'^[0-9]+$\' AND CAST(b.meta_value AS BIGINT)', $where);
+            // Mirror WHERE clause to delete both sides of self-join.
+            $where2 = strtr($where, array('a.' => 'b.', 'b.' => 'a.'));
+            // Use $wpdb's sitemeta table name which should already have the correct prefix
+            if(isset($wpdb->sitemeta)) {
+                $sql = "DELETE FROM {$wpdb->sitemeta} a USING {$wpdb->sitemeta} b WHERE " .
+                    '(' . $where . ') OR (' . $where2 . ');';
+            } else {
+                // Fallback if $wpdb->sitemeta is not available
+                $sql = "DELETE FROM {$prefix}sitemeta a USING {$prefix}sitemeta b WHERE " .
+                    '(' . $where . ') OR (' . $where2 . ');';
+            }
+        }
+        
+        // Add a more general pattern to handle multi-table DELETE with aliases and dynamic table names
+        elseif(preg_match('/DELETE\s+([a-zA-Z0-9_]+),\s*([a-zA-Z0-9_]+)\s+FROM\s+([a-zA-Z0-9_' . preg_quote($prefix, '/') . ']+)\s+([a-zA-Z0-9_]+),\s*([a-zA-Z0-9_' . preg_quote($prefix, '/') . ']+)\s+([a-zA-Z0-9_]+)\s+WHERE/i', $sql, $matches)) {
+            // Extract aliases and table names
+            $firstAlias = $matches[1];
+            $secondAlias = $matches[2];
+            $firstTable = $matches[3];
+            $firstTableAlias = $matches[4];
+            $secondTable = $matches[5];
+            $secondTableAlias = $matches[6];
+            
+            // Extract WHERE clause
+            $where = substr($sql, strpos($sql, 'WHERE ') + 6);
+            $where = rtrim($where, " \t\n\r;");
+            
+            // Check if the table names are known WordPress tables and replace with dynamic property references
+            foreach([$firstTable, $secondTable] as $index => $tableName) {
+                // Strip prefix if it exists to get the base table name
+                $baseTableName = preg_replace('/^' . preg_quote($prefix, '/') . '/', '', $tableName);
+                
+                // Check if $wpdb has a property for this table
+                if(isset($wpdb->$baseTableName)) {
+                    // Replace the hardcoded table name with the dynamic property
+                    if($index === 0) {
+                        $firstTable = $wpdb->$baseTableName;
+                    } else {
+                        $secondTable = $wpdb->$baseTableName;
+                    }
+                }
+            }
+            
+            // Generate PostgreSQL DELETE...USING syntax
+            $sql = "DELETE FROM $firstTable $firstTableAlias USING $secondTable $secondTableAlias WHERE $where;";
+        }
+
+        // Akismet sometimes doesn't write 'comment_ID' with 'ID' in capitals where needed ...
+        if(false !== strpos($sql, $wpdb->comments)) {
+            $sql = str_replace(' comment_id ', ' comment_ID ', $sql);
+        }
+
+        return $sql;
+    }
+}

pg4wp/rewriters/DescribeSQLRewriter.php

@@ -0,0 +1,81 @@
+<?php
+
+class DescribeSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        $table = $this->extractTableName($sql);
+        return $this->generatePostgresDescribeTable($table);
+    }
+
+    /**
+     * Extracts table name from a "DESCRIBE" SQL statement.
+     *
+     * @param string $sql The SQL statement
+     * @return string|null The table name if found, or null otherwise
+     */
+    protected function extractTableName($sql)
+    {
+        $pattern = "/DESCRIBE ['\"`]?([^'\"`]+)['\"`]?/i";
+        if (preg_match($pattern, $sql, $matches)) {
+            return $matches[1];
+        }
+        return null;
+    }
+
+    /**
+     * Generates a PostgreSQL-compatible SQL query to mimic MySQL's "DESCRIBE".
+     *
+     * @param string $tableName The table name
+     * @param string $schema The schema name
+     * @return string The generated SQL query
+     */
+    public function generatePostgresDescribeTable($tableName, $schema = "public")
+    {
+        $sql = <<<SQL
+            SELECT  
+                f.attnum AS number,  
+                f.attname AS name,  
+                f.attnum,  
+                f.attnotnull AS notnull,  
+                pg_catalog.format_type(f.atttypid,f.atttypmod) AS type,  
+                CASE  
+                    WHEN p.contype = 'p' THEN 't'  
+                    ELSE 'f'  
+                END AS primarykey,  
+                CASE  
+                    WHEN p.contype = 'u' THEN 't'  
+                    ELSE 'f'
+                END AS uniquekey,
+                CASE
+                    WHEN p.contype = 'f' THEN g.relname
+                END AS foreignkey,
+                CASE
+                    WHEN p.contype = 'f' THEN p.confkey
+                END AS foreignkey_fieldnum,
+                CASE
+                    WHEN p.contype = 'f' THEN g.relname
+                END AS foreignkey,
+                CASE
+                    WHEN p.contype = 'f' THEN p.conkey
+                END AS foreignkey_connnum,
+                CASE
+                    WHEN f.atthasdef = 't' THEN pg_get_expr(d.adbin, d.adrelid)
+                END AS default
+            FROM pg_attribute f  
+                JOIN pg_class c ON c.oid = f.attrelid  
+                JOIN pg_type t ON t.oid = f.atttypid  
+                LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = f.attnum  
+                LEFT JOIN pg_namespace n ON n.oid = c.relnamespace  
+                LEFT JOIN pg_constraint p ON p.conrelid = c.oid AND f.attnum = ANY (p.conkey)  
+                LEFT JOIN pg_class AS g ON p.confrelid = g.oid  
+            WHERE c.relkind = 'r'::char  
+                AND n.nspname = '$schema' 
+                AND c.relname = '$tableName'
+                AND f.attnum > 0 ORDER BY number
+        SQL;
+
+        return $sql;
+    }
+}

pg4wp/rewriters/DropTableSQLRewriter.php

@@ -0,0 +1,17 @@
+<?php
+
+class DropTableSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+
+        $pattern = '/DROP TABLE.+ [`]?(\w+)[`]?$/';
+        preg_match($pattern, $sql, $matches);
+        $table = $matches[1];
+        $seq = $table . '_seq';
+        $sql .= ";\nDROP SEQUENCE IF EXISTS $seq;";
+
+        return $sql;
+    }
+}

pg4wp/rewriters/InsertSQLRewriter.php

@@ -0,0 +1,153 @@
+<?php
+
+class InsertSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        global $wpdb;
+
+        $sql = $this->original();
+
+        // Those are used when we need to set the date to now() in gmt time
+        $sql = str_replace("'0000-00-00 00:00:00'", 'now() AT TIME ZONE \'gmt\'', $sql);
+
+        $sql = str_replace("utc_timestamp()", "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'", $sql);
+
+        // Multiple values group when calling INSERT INTO don't always work
+        if(false !== strpos($sql, $wpdb->options) && false !== strpos($sql, '), (')) {
+            $pattern = '/INSERT INTO.+VALUES/';
+            preg_match($pattern, $sql, $matches);
+            $insert = $matches[0];
+            $sql = str_replace('), (', ');' . $insert . '(', $sql);
+        }
+
+        // Swap ON DUPLICATE KEY SYNTAX
+        if(false !== $pos = strpos($sql, 'ON DUPLICATE KEY UPDATE')) {
+            $splitStatements = function (string $sql): array {
+                $statements = [];
+                $buffer = '';
+                $quote = null;
+
+                for ($i = 0, $len = strlen($sql); $i < $len; $i++) {
+                    $char = $sql[$i];
+
+                    if ($quote) {
+                        if ($char === $quote && $sql[$i - 1] !== '\\') {
+                            $quote = null;
+                        }
+                    } elseif ($char === '"' || $char === "'") {
+                        $quote = $char;
+                    } elseif ($char === ';') {
+                        $statements[] = $buffer . ';';
+                        $buffer = '';
+                        continue;
+                    }
+
+                    $buffer .= $char;
+                }
+
+                if (!empty($buffer)) {
+                    $statements[] = $buffer;
+                }
+
+                return $statements;
+            };
+
+            $statements = $splitStatements($sql);
+
+            foreach ($statements as $statement) {
+                $statement = trim($statement);
+
+                // Skip empty statements
+                if (empty($statement)) {
+                    continue;
+                }
+
+                // Replace backticks with double quotes for PostgreSQL compatibility
+                $statement = str_replace('`', '"', $statement);
+
+                // Find index positions for the SQL components
+                $insertIndex = strpos($statement, 'INSERT INTO');
+                $valuesIndex = strpos($statement, 'VALUES');
+                $onDuplicateKeyIndex = strpos($statement, 'ON DUPLICATE KEY UPDATE');
+
+                // Extract SQL components
+                $tableSection = trim(substr($statement, $insertIndex, $valuesIndex - $insertIndex));
+                $valuesSection = trim(substr($statement, $valuesIndex, $onDuplicateKeyIndex - $valuesIndex));
+                $updateSection = trim(str_replace('ON DUPLICATE KEY UPDATE', '', substr($statement, $onDuplicateKeyIndex)));
+
+                // Extract and clean up column names from the update section
+                $updateCols = explode(',', $updateSection);
+                $updateCols = array_map(function ($col) {
+                    return trim(explode('=', $col)[0]);
+                }, $updateCols);
+
+                // Choose a primary key for ON CONFLICT
+                $primaryKey = 'option_name';
+                if (!in_array($primaryKey, $updateCols)) {
+                    $primaryKey = 'meta_name';
+                    if (!in_array($primaryKey, $updateCols)) {
+                        $primaryKey = $updateCols[0] ?? '';
+                    }
+                }
+
+                // Construct the PostgreSQL ON CONFLICT DO UPDATE section
+                $updateSection = implode(', ', array_map(fn ($col) => "$col = EXCLUDED.$col", $updateCols));
+
+                // Construct the PostgreSQL query
+                $postgresSQL = sprintf('%s %s ON CONFLICT (%s) DO UPDATE SET %s', $tableSection, $valuesSection, $primaryKey, $updateSection);
+
+                // Append to the converted statements list
+                $convertedStatements[] = $postgresSQL;
+            }
+
+            $sql = implode('; ', $convertedStatements);
+        } elseif(0 === strpos($sql, 'INSERT IGNORE')) {
+            // Note: Requires PostgreSQL 9.5
+            $sql = 'INSERT' . substr($sql, 13) . ' ON CONFLICT DO NOTHING';
+        }
+
+        // To avoid Encoding errors when inserting data coming from outside
+        if(preg_match('/^.{1}/us', $sql, $ar) != 1) {
+            $sql = utf8_encode($sql);
+        }
+
+        if(false === strpos($sql, 'RETURNING')) {
+            $end_of_statement = $this->findSemicolon($sql);
+            if ($end_of_statement !== false) {
+                // Create the substrings up to and after the semicolon
+                $sql_before_semicolon = substr($sql, 0, $end_of_statement);
+                $sql_after_semicolon = substr($sql, $end_of_statement, strlen($sql));
+
+                // Splice the SQL string together with 'RETURNING *'
+                $sql = $sql_before_semicolon . ' RETURNING *' . $sql_after_semicolon;
+
+            } else {
+                $sql = $sql .= " RETURNING *";
+            }
+        }
+
+        return $sql;
+    }
+
+    // finds semicolons that aren't in variables
+    private function findSemicolon($sql)
+    {
+        $quoteOpened = false;
+        $parenthesisDepth = 0;
+
+        $sqlAsArray = str_split($sql);
+        for($i = 0; $i < count($sqlAsArray); $i++) {
+            if(($sqlAsArray[$i] == '"' || $sqlAsArray[$i] == "'") && ($i == 0 || $sqlAsArray[$i - 1] != '\\')) {
+                $quoteOpened = !$quoteOpened;
+            } elseif($sqlAsArray[$i] == '(' && !$quoteOpened) {
+                $parenthesisDepth++;
+            } elseif($sqlAsArray[$i] == ')' && !$quoteOpened) {
+                $parenthesisDepth--;
+            } elseif($sqlAsArray[$i] == ';' && !$quoteOpened && $parenthesisDepth == 0) {
+                return $i;
+            }
+        }
+        return false;
+    }
+}

pg4wp/rewriters/OptimizeTableSQLRewriter.php

@@ -0,0 +1,10 @@
+<?php
+
+class OptimizeTableSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        return str_replace('OPTIMIZE TABLE', 'VACUUM', $sql);
+    }
+}

pg4wp/rewriters/ReplaceIntoSQLRewriter.php

@@ -0,0 +1,143 @@
+<?php
+
+class ReplaceIntoSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        global $wpdb;
+
+        $sql = $this->original();
+
+        $splitStatements = function (string $sql): array {
+            $statements = [];
+            $buffer = '';
+            $quote = null;
+
+            for ($i = 0, $len = strlen($sql); $i < $len; $i++) {
+                $char = $sql[$i];
+
+                if ($quote) {
+                    if ($char === $quote && $sql[$i - 1] !== '\\') {
+                        $quote = null;
+                    }
+                } elseif ($char === '"' || $char === "'") {
+                    $quote = $char;
+                } elseif ($char === ';') {
+                    $statements[] = $buffer . ';';
+                    $buffer = '';
+                    continue;
+                }
+
+                $buffer .= $char;
+            }
+
+            if (!empty($buffer)) {
+                $statements[] = $buffer;
+            }
+
+            return $statements;
+        };
+
+        $statements = $splitStatements($sql);
+
+        foreach ($statements as $statement) {
+            $statement = trim($statement);
+
+            // Skip empty statements
+            if (empty($statement)) {
+                continue;
+            }
+
+            // Replace backticks with double quotes for PostgreSQL compatibility
+            $statement = str_replace('`', '"', $statement);
+
+            // Find index positions for the SQL components
+            $insertIndex = strpos($statement, 'REPLACE INTO');
+            $columnsStartIndex = strpos($statement, "(");
+            $columnsEndIndex = strpos($statement, ")");
+            $valuesIndex = strpos($statement, 'VALUES');
+            $onDuplicateKeyIndex = strpos($statement, 'ON DUPLICATE KEY UPDATE');
+
+            // Extract SQL components
+            $tableSection = trim(substr($statement, $insertIndex, $columnsStartIndex - $insertIndex));
+            $valuesSection = trim(substr($statement, $valuesIndex, strlen($statement) - $valuesIndex));
+            $columnsSection = trim(substr($statement, $columnsStartIndex, $columnsEndIndex - $columnsStartIndex + 1));
+
+            // Extract and clean up column names from the update section
+            $updateCols = explode(',', substr($columnsSection, 1, strlen($columnsSection) - 2));
+            $updateCols = array_map(function ($col) {
+                return  trim($col);
+            }, $updateCols);
+
+            // Choose a primary key for ON CONFLICT
+            $primaryKey = 'option_name';
+            if (!in_array($primaryKey, $updateCols)) {
+                $primaryKey = 'meta_name';
+                if (!in_array($primaryKey, $updateCols)) {
+                    $primaryKey = $updateCols[0] ?? '';
+                }
+            }
+
+            // SWAP REPLACE INTO for INSERT INTO
+            $tableSection = str_replace("REPLACE INTO", "INSERT INTO", $tableSection);
+
+            // Construct the PostgreSQL ON CONFLICT DO UPDATE section
+            $updateSection = "";
+            foreach($updateCols as $col) {
+                if ($col !== $primaryKey) {
+                    $updateSection .= ", ";
+                    $updateSection .= "$col = EXCLUDED.$col";
+                }
+            }
+
+            // trim any preceding commas
+            $updateSection = ltrim($updateSection, ", ");
+
+            // Construct the PostgreSQL query
+            $postgresSQL = sprintf('%s %s %s ON CONFLICT (%s) DO UPDATE SET %s', $tableSection, $columnsSection, $valuesSection, $primaryKey, $updateSection);
+
+            if(false === strpos($postgresSQL, 'RETURNING')) {
+                $end_of_statement = $this->findSemicolon($postgresSQL);
+                if ($end_of_statement !== false) {
+                    // Create the substrings up to and after the semicolon
+                    $sql_before_semicolon = substr($postgresSQL, 0, $end_of_statement);
+                    $sql_after_semicolon = substr($postgresSQL, $end_of_statement, strlen($postgresSQL));
+    
+                    // Splice the SQL string together with 'RETURNING *'
+                    $postgresSQL = $sql_before_semicolon . ' RETURNING *' . $sql_after_semicolon;
+    
+                } else {
+                    $postgresSQL = $postgresSQL .= " RETURNING *";
+                }
+            }
+
+            // Append to the converted statements list
+            $convertedStatements[] = $postgresSQL;
+        }
+
+        $sql = implode('; ', $convertedStatements);
+
+        return $sql;
+    }
+
+      // finds semicolons that aren't in variables
+      private function findSemicolon($sql)
+      {
+          $quoteOpened = false;
+          $parenthesisDepth = 0;
+  
+          $sqlAsArray = str_split($sql);
+          for($i = 0; $i < count($sqlAsArray); $i++) {
+              if(($sqlAsArray[$i] == '"' || $sqlAsArray[$i] == "'") && ($i == 0 || $sqlAsArray[$i - 1] != '\\')) {
+                  $quoteOpened = !$quoteOpened;
+              } elseif($sqlAsArray[$i] == '(' && !$quoteOpened) {
+                  $parenthesisDepth++;
+              } elseif($sqlAsArray[$i] == ')' && !$quoteOpened) {
+                  $parenthesisDepth--;
+              } elseif($sqlAsArray[$i] == ';' && !$quoteOpened && $parenthesisDepth == 0) {
+                  return $i;
+              }
+          }
+          return false;
+      }
+}

pg4wp/rewriters/SelectSQLRewriter.php

@@ -0,0 +1,400 @@
+<?php
+
+class SelectSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        global $wpdb;
+
+        $sql = $this->original();
+
+        // SQL_CALC_FOUND_ROWS doesn't exist in PostgreSQL but it's needed for correct paging
+        if(false !== strpos($sql, 'SQL_CALC_FOUND_ROWS')) {
+            $sql = str_replace('SQL_CALC_FOUND_ROWS', '', $sql);
+            $GLOBALS['pg4wp_numrows_query'] = $sql;
+            if(PG4WP_DEBUG) {
+                error_log('[' . microtime(true) . "] Number of rows required for :\n$sql\n---------------------\n", 3, PG4WP_LOG . 'pg4wp_NUMROWS.log');
+            }
+        }
+
+        if(false !== strpos($sql, 'FOUND_ROWS()')) {
+            // Here we convert the latest query into a COUNT query
+            $sql = $GLOBALS['pg4wp_numrows_query'];
+
+            // Remove the LIMIT clause if it exists
+            $sql = preg_replace('/\s+LIMIT\s+\d+(\s*,\s*\d+)?/i', '', $sql);
+
+            // Remove the ORDER BY containing case / end clause if it exists
+            $sql = preg_replace('/\s+ORDER\s+BY\s+.+END\),[^)]+/is', '', $sql);
+
+            // Remove the ORDER BY clause if it exists
+            $sql = preg_replace('/\s+ORDER\s+BY\s+[^)]+/i', '', $sql);
+
+            // Replace the fields in the SELECT clause with COUNT(*)
+            $sql = preg_replace('/SELECT\s+.*?\s+FROM\s+/is', 'SELECT COUNT(*) FROM ', $sql, 1);
+        }
+
+        if(false !== strpos($sql, 'information_schema')) {
+            // WP Site Health rewrites
+            if (false !== strpos($sql, "SELECT TABLE_NAME AS 'table', TABLE_ROWS AS 'rows', SUM(data_length + index_length)")) {
+                $sql = $this->postgresTableSizeRewrite();
+                return $sql;
+            }
+
+            throw new Exception("Unsupported call to information_schema, this probably won't work correctly and needs to be specifically handled, open a github issue with the SQL");
+        }
+
+        $sql = $this->ensureOrderByInSelect($sql);
+
+        // Handle +0 casting in order by
+        // Regular expression to match the "ORDER BY" pattern
+        $pattern = '/ORDER BY\s+([a-zA-Z0-9_]+)\.meta_value\s*\+\s*0/i';
+        $replacement = 'ORDER BY CAST($1.meta_value AS SIGNED)';
+        $sql = preg_replace($pattern, $replacement, $sql);
+
+        // Convert CONVERT to CAST
+        $pattern = '/CONVERT\(([^()]*(\(((?>[^()]+)|(?-2))*\))?[^()]*),\s*([^\s]+)\)/x';
+        $sql = preg_replace($pattern, 'CAST($1 AS $4)', $sql);
+
+        // Handle CAST( ... AS CHAR)
+        $sql = preg_replace('/CAST\((.+) AS CHAR\)/', 'CAST($1 AS TEXT)', $sql);
+
+        // Handle CAST( ... AS SIGNED)
+        $sql = preg_replace('/CAST\((.+) AS SIGNED\)/', 'CAST($1 AS INTEGER)', $sql);
+
+        // Handle COUNT(*)...ORDER BY...
+        $sql = preg_replace('/COUNT(.+)ORDER BY.+/s', 'COUNT$1', $sql);
+
+        // HANDLE REGEXP
+        $sql = preg_replace('/REGEXP/', '~', $sql);
+
+        $sql = str_replace("utc_timestamp()", "CURRENT_TIMESTAMP AT TIME ZONE 'UTC'", $sql);
+
+        // In order for users counting to work...
+        $matches = array();
+        if(preg_match_all('/COUNT[^C]+\),/', $sql, $matches)) {
+            foreach($matches[0] as $num => $one) {
+                $sub = substr($one, 0, -1);
+                $sql = str_replace($sub, $sub . ' AS count' . $num, $sql);
+            }
+        }
+
+        $sql = $this->convertToPostgresLimitSyntax($sql);
+        $sql = $this->ensureGroupByOrAggregate($sql);
+
+        $pattern = '/DATE_ADD[ ]*\(([^,]+),([^\)]+)\)/';
+        $sql = preg_replace($pattern, '($1 + $2)', $sql);
+
+        // Convert MySQL FIELD function to CASE statement
+        $pattern = '/FIELD[ ]*\(([^\),]+),([^\)]+)\)/';
+        // https://dev.mysql.com/doc/refman/5.7/en/string-functions.html#function_field
+        // Other implementations:  https://stackoverflow.com/q/1309624
+        $sql = preg_replace_callback($pattern, function ($matches) {
+            $case = 'CASE ' . trim($matches[1]);
+            $comparands = explode(',', $matches[2]);
+            foreach($comparands as $i => $comparand) {
+                $case .= ' WHEN ' . trim($comparand) . ' THEN ' . ($i + 1);
+            }
+            $case .= ' ELSE 0 END';
+            return $case;
+        }, $sql);
+
+        $pattern = '/GROUP_CONCAT\(([^()]*(\(((?>[^()]+)|(?-2))*\))?[^()]*)\)/x';
+        $sql = preg_replace($pattern, "string_agg($1, ',')", $sql);
+
+        // Convert MySQL RAND function to PostgreSQL RANDOM function
+        $pattern = '/RAND[ ]*\([ ]*\)/';
+        $sql = preg_replace($pattern, 'RANDOM()', $sql);
+
+        // UNIX_TIMESTAMP in MYSQL returns an integer
+        $pattern = '/UNIX_TIMESTAMP\(([^\)]+)\)/';
+        $sql = preg_replace($pattern, 'ROUND(DATE_PART(\'epoch\',$1))', $sql);
+
+        $date_funcs = array(
+            'DAYOFMONTH('	=> 'EXTRACT(DAY FROM ',
+            'YEAR('			=> 'EXTRACT(YEAR FROM ',
+            'MONTH('		=> 'EXTRACT(MONTH FROM ',
+            'DAY('			=> 'EXTRACT(DAY FROM ',
+        );
+
+        $sql = str_replace('ORDER BY post_date DESC', 'ORDER BY YEAR(post_date) DESC, MONTH(post_date) DESC', $sql);
+        $sql = str_replace('ORDER BY post_date ASC', 'ORDER BY YEAR(post_date) ASC, MONTH(post_date) ASC', $sql);
+        $sql = str_replace(array_keys($date_funcs), array_values($date_funcs), $sql);
+        $curryear = date('Y');
+        $sql = str_replace('FROM \'' . $curryear, 'FROM TIMESTAMP \'' . $curryear, $sql);
+
+        // MySQL 'IF' conversion - Note : NULLIF doesn't need to be corrected
+        $pattern = '/ (?<!NULL)IF[ ]*\(([^,]+),([^,]+),([^\)]+)\)/';
+        $sql = preg_replace($pattern, ' CASE WHEN $1 THEN $2 ELSE $3 END', $sql);
+
+        // Act like MySQL default configuration, where sql_mode is ""
+        $pattern = '/@@SESSION.sql_mode/';
+        $sql = preg_replace($pattern, "''", $sql);
+
+
+        // TODO: this seems wrong but if we remove it we get failures with XYZ is not part of the group By
+        if(isset($wpdb)) {
+            $sql = str_replace('GROUP BY ' . $wpdb->prefix . 'posts.ID', '', $sql);
+        }
+
+        // MySQL 'LIKE' is case insensitive by default, whereas PostgreSQL 'LIKE' is
+        $sql = str_replace(' LIKE ', ' ILIKE ', $sql);
+
+        // INDEXES are not yet supported
+        if(false !== strpos($sql, 'USE INDEX (comment_date_gmt)')) {
+            $sql = str_replace('USE INDEX (comment_date_gmt)', '', $sql);
+        }
+
+        // HB : timestamp fix for permalinks
+        $sql = str_replace('post_date_gmt > 1970', 'post_date_gmt > to_timestamp (\'1970\')', $sql);
+
+        // Akismet sometimes doesn't write 'comment_ID' with 'ID' in capitals where needed ...
+        if(isset($wpdb) && $wpdb->comments && false !== strpos($sql, $wpdb->comments)) {
+            $sql = str_replace(' comment_id ', ' comment_ID ', $sql);
+        }
+
+        // MySQL treats a HAVING clause without GROUP BY like WHERE
+        if(false !== strpos($sql, 'HAVING') && false === strpos($sql, 'GROUP BY')) {
+            if(false === strpos($sql, 'WHERE')) {
+                $sql = str_replace('HAVING', 'WHERE', $sql);
+            } else {
+                $pattern = '/WHERE\s+(.*?)\s+HAVING\s+(.*?)(\s*(?:ORDER|LIMIT|PROCEDURE|INTO|FOR|LOCK|$))/';
+                $sql = preg_replace($pattern, 'WHERE ($1) AND ($2) $3', $sql);
+            }
+        }
+
+        // MySQL allows integers to be used as boolean expressions
+        // where 0 is false and all other values are true.
+        //
+        // Although this could occur anywhere with any number, so far it
+        // has only been observed as top-level expressions in the WHERE
+        // clause and only with 0.  For performance, limit current
+        // replacements to that.
+        $pattern_after_where = '(?:\s*$|\s+(GROUP|HAVING|ORDER|LIMIT|PROCEDURE|INTO|FOR|LOCK))';
+        $pattern = '/(WHERE\s+)0(\s+AND|\s+OR|' . $pattern_after_where . ')/';
+        $sql = preg_replace($pattern, '$1false$2', $sql);
+
+        $pattern = '/(AND\s+|OR\s+)0(' . $pattern_after_where . ')/';
+        $sql = preg_replace($pattern, '$1false$2', $sql);
+
+        // MySQL supports strings as names, PostgreSQL needs identifiers.
+        // Limit to after closing parenthesis to reduce false-positives
+        // Currently only an issue for nextgen-gallery plugin
+        $pattern = '/\) AS \'([^\']+)\'/';
+        $sql = preg_replace($pattern, ') AS "$1"', $sql);
+
+        return $sql;
+    }
+
+    /**
+     * Ensure the columns used in the ORDER BY clause are also present in the SELECT clause.
+     *
+     * @param string $sql Original SQL query string.
+     * @return string Modified SQL query string.
+     */
+    protected function ensureOrderByInSelect(string $sql): string
+    {
+        // Extract the SELECT and ORDER BY clauses
+        preg_match('/SELECT\s+(.*?)\s+FROM/si', $sql, $selectMatches);
+        preg_match('/ORDER BY(.*?)(ASC|DESC|$)/si', $sql, $orderMatches);
+        preg_match('/GROUP BY(.*?)(ASC|DESC|$)/si', $sql, $groupMatches);
+
+        // If the SELECT clause is missing, return the original query
+        if (!$selectMatches) {
+            return $sql;
+        }
+
+        // If both ORDER BY and GROUP BY clauses are missing, return the original query
+        if (!$orderMatches && !$groupMatches) {
+            return $sql;
+        }
+
+        $selectClause = trim($selectMatches[1]);
+        $orderByClause = $orderMatches ? trim($orderMatches[1]) : null;
+        $groupClause = $groupMatches ? trim($groupMatches[1]) : null;
+        $modified = false;
+
+        // Check for wildcard in SELECT
+        if (strpos($selectClause, '*') !== false) {
+            return $sql; // Cannot handle wildcards, return original query
+        }
+
+        // Handle ORDER BY columns
+        if ($orderByClause) {
+            $orderByColumns = explode(',', $orderByClause);
+            foreach ($orderByColumns as $col) {
+                $col = trim($col);
+                if (strpos($selectClause, $col) === false) {
+                    $selectClause .= ', ' . $col;
+                    $modified = true;
+                }
+            }
+        }
+
+        // Handle GROUP BY columns
+        if ($groupClause && !$modified) {
+            $groupColumns = explode(',', $groupClause);
+            foreach ($groupColumns as $col) {
+                $col = trim($col);
+                if (strpos($selectClause, $col) === false) {
+                    $selectClause .= ', ' . $col;
+                    $modified = true;
+                }
+            }
+        }
+
+        if (!$modified) {
+            return $sql;
+        }
+
+        // Find the exact position for the replacement
+        $selectStartPos = strpos($sql, $selectMatches[1]);
+        if ($selectStartPos === false) {
+            return $sql; // If for some reason the exact match is not found, return the original query
+        }
+        $postgresSql = substr_replace($sql, $selectClause, $selectStartPos, strlen($selectMatches[1]));
+
+        return $postgresSql;
+    }
+
+    /**
+     * Transforms a given SQL query to include a GROUP BY clause if the SELECT statement has both aggregate
+     * and non-aggregate columns. This function is specifically designed to work with PostgreSQL.
+     *
+     * In PostgreSQL, a query that uses aggregate functions must group by all columns in the SELECT list that
+     * are not part of the aggregate functions. Failing to do so results in a syntax error. This function
+     * automatically adds a GROUP BY clause to meet this PostgreSQL requirement when both aggregate (COUNT, SUM,
+     * AVG, MIN, MAX) and non-aggregate columns are present.
+     *
+     * @param string $sql The SQL query string to be transformed.
+     *
+     * @return string The transformed SQL query string with appropriate GROUP BY clause if required.
+     *
+     * @throws Exception If the SQL query cannot be parsed or modified.
+     *
+     * @example
+     * Input:  SELECT COUNT(id), username FROM users;
+     * Output: SELECT COUNT(id), username FROM users GROUP BY username;
+     *
+     */
+    protected function ensureGroupByOrAggregate(string $sql): string
+    {
+        // Check for system or session variables
+        if (preg_match('/@@[a-zA-Z0-9_]+/', $sql)) {
+            return $sql;
+        }
+
+        // Regular expression to capture main SQL components.
+        $regex = '/(SELECT\s+)(.*?)(\s+FROM\s+)([^ ]+)(\s+WHERE\s+.*?(?= ORDER BY | GROUP BY | LIMIT |$))?(ORDER BY.*?(?= LIMIT |$))?(LIMIT.*?$)?/is';
+
+        // Capture main SQL components using regex
+        if (!preg_match($regex, $sql, $matches)) {
+            return $sql;
+        }
+
+        $selectClause = trim($matches[2] ?? '');
+        $fromClause = trim($matches[4] ?? '');
+        $whereClause = trim($matches[5] ?? '');
+        $orderClause = trim($matches[6] ?? '');
+        $limitClause = trim($matches[7] ?? '');
+
+        if (empty($selectClause) || empty($fromClause)) {
+            return $sql;
+        }
+
+        // Regular expression to match commas not within parentheses
+        $pattern = '/,(?![^\(]*\))/';
+        // Split columns using a comma, and then trim each element
+        $columns = array_map('trim', preg_split($pattern, $selectClause));
+
+        $aggregateColumns = [];
+        $nonAggregateColumns = [];
+
+        foreach ($columns as $col) {
+            // Check for aggregate functions in the column
+            if (preg_match('/(COUNT|SUM|AVG|MIN|MAX)\s*?\(/i', $col)) {
+                $aggregateColumns[] = $col;
+            } else {
+                $nonAggregateColumns[] = $col;
+            }
+        }
+
+        // Only add a GROUP BY clause if there are both aggregate and non-aggregate columns in SELECT
+        if (empty($aggregateColumns) || empty($nonAggregateColumns)) {
+            return $sql;
+        }
+
+
+        // Assemble new SQL query
+        $postgresSql = "SELECT $selectClause FROM $fromClause";
+
+        if (!empty($whereClause)) {
+            $postgresSql .= ' ' . $whereClause;
+        }
+
+        $groupByClause = "GROUP BY " . implode(", ", $nonAggregateColumns);
+        if (!empty($groupByClause)) {
+            $postgresSql .= ' ' . $groupByClause;
+        }
+
+        if (!empty($orderClause)) {
+            $postgresSql .= ' ' . $orderClause;
+        }
+
+        if (!empty($limitClause)) {
+            $postgresSql .= ' ' . $limitClause;
+        }
+
+        return $postgresSql;
+    }
+
+    /**
+     * Convert MySQL LIMIT syntax to PostgreSQL LIMIT syntax
+     *
+     * @param string $sql MySQL query string
+     * @return string PostgreSQL query string
+     */
+    protected function convertToPostgresLimitSyntax($sql)
+    {
+        // Use regex to find "LIMIT m, n" syntax in query
+        if (preg_match('/LIMIT\s+(\d+),\s*(\d+)/i', $sql, $matches)) {
+            $offset = $matches[1];
+            $limit = $matches[2];
+
+            // Replace MySQL LIMIT syntax with PostgreSQL LIMIT syntax
+            $postgresLimitSyntax = "LIMIT $limit OFFSET $offset";
+            $postgresSql = preg_replace('/LIMIT\s+\d+,\s*\d+/i', $postgresLimitSyntax, $sql);
+
+            return $postgresSql;
+        }
+
+        // Return original query if no MySQL LIMIT syntax is found
+        return $sql;
+    }
+
+    // This method is specifically to handle should_suggest_persistent_object_cache in wp site health
+    protected function postgresTableSizeRewrite($schema = 'public')
+    {
+
+        $sql = <<<SQL
+        SELECT 
+            C.relname AS "table", 
+            S.n_live_tup AS "rows", 
+            pg_total_relation_size(C.oid) AS "bytes"
+        FROM 
+            pg_class C 
+        LEFT JOIN 
+            pg_namespace N ON (N.oid = C.relnamespace) 
+        INNER JOIN 
+            pg_stat_user_tables S ON (S.relid = C.oid) 
+        WHERE 
+            N.nspname = '$schema' AND 
+            C.relname IN ('wp_comments','wp_options','wp_posts','wp_terms','wp_users')
+        GROUP BY 
+            C.relname, pg_total_relation_size(C.oid), S.n_live_tup;
+        SQL;
+
+        return $sql;
+    }
+
+}

pg4wp/rewriters/SetNamesSQLRewriter.php

@@ -0,0 +1,9 @@
+<?php
+
+class SetNamesSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        return "SET NAMES 'utf8'";
+    }
+}

pg4wp/rewriters/ShowFullColumnsSQLRewriter.php

@@ -0,0 +1,74 @@
+<?php
+
+class ShowFullColumnsSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        $table = $this->extractTableNameFromShowColumns($sql);
+        return $this->generatePostgresShowColumns($table);
+    }
+
+    /**
+     * Extracts table name from a "SHOW FULL COLUMNS" SQL statement.
+     *
+     * @param string $sql The SQL statement
+     * @return string|null The table name if found, or null otherwise
+     */
+    protected function extractTableNameFromShowColumns($sql)
+    {
+        $pattern = "/SHOW FULL COLUMNS FROM ['\"`]?([^'\"`]+)['\"`]?/i";
+        if (preg_match($pattern, $sql, $matches)) {
+            return $matches[1];
+        }
+        return null;
+    }
+
+    /**
+     * Generates a PostgreSQL-compatible SQL query to mimic MySQL's "SHOW FULL COLUMNS".
+     *
+     * @param string $tableName The table name
+     * @param string $schema The schema name
+     * @return string The generated SQL query
+     */
+    public function generatePostgresShowColumns($tableName, $schema = "public")
+    {
+        $sql = <<<SQL
+            SELECT 
+                a.attname AS "Field",
+                pg_catalog.format_type(a.atttypid, a.atttypmod) AS "Type",
+                (CASE 
+                    WHEN a.attnotnull THEN 'NO' 
+                    ELSE 'YES' 
+                END) AS "Null",
+                (CASE 
+                    WHEN i.indisprimary THEN 'PRI'
+                    WHEN i.indisunique THEN 'UNI'
+                    ELSE '' 
+                END) AS "Key",
+                pg_catalog.pg_get_expr(ad.adbin, ad.adrelid) AS "Default",
+                '' AS "Extra",
+                'select,insert,update,references' AS "Privileges",
+                d.description AS "Comment"
+            FROM 
+                pg_catalog.pg_attribute a
+                LEFT JOIN pg_catalog.pg_description d ON (a.attrelid = d.objoid AND a.attnum = d.objsubid)
+                LEFT JOIN pg_catalog.pg_attrdef ad ON (a.attrelid = ad.adrelid AND a.attnum = ad.adnum)
+                LEFT JOIN pg_catalog.pg_index i ON (a.attrelid = i.indrelid AND a.attnum = ANY(i.indkey))
+            WHERE 
+                a.attnum > 0 
+                AND NOT a.attisdropped
+                AND a.attrelid = (
+                    SELECT c.oid
+                    FROM pg_catalog.pg_class c
+                    LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+                    WHERE c.relname = '$tableName'
+                    AND n.nspname = '$schema'
+                )
+            ORDER BY 
+                a.attnum;
+        SQL;
+
+        return $sql;
+    }
+}

pg4wp/rewriters/ShowIndexSQLRewriter.php

@@ -0,0 +1,62 @@
+<?php
+
+class ShowIndexSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        $table = $this->extractTableNameFromShowIndex($sql);
+        return $this->generatePostgresShowIndexFrom($table);
+    }
+
+    /**
+     * Extracts table name from a "SHOW FULL COLUMNS" SQL statement.
+     *
+     * @param string $sql The SQL statement
+     * @return string|null The table name if found, or null otherwise
+     */
+    protected function extractVariableName($sql)
+    {
+        $pattern = "/SHOW INDEX FROM ['\"`]?([^'\"`]+)['\"`]?/i";
+        if (preg_match($pattern, $sql, $matches)) {
+            return $matches[1];
+        }
+        return null;
+    }
+
+    /**
+     * Generates a PostgreSQL-compatible SQL query to mimic MySQL's "SHOW INDEX FROM".
+     *
+     * @param string $tableName The table name
+     * @return string The generated SQL query
+     */
+    public function generatePostgresShowIndexFrom($tableName)
+    {
+        $sql = <<<SQL
+        SELECT bc.relname AS "Table",
+            CASE WHEN i.indisunique THEN '0' ELSE '1' END AS "Non_unique",
+            CASE WHEN i.indisprimary THEN 'PRIMARY' WHEN bc.relname LIKE '%usermeta' AND ic.relname = 'umeta_key'
+                THEN 'meta_key' ELSE REPLACE( ic.relname, '' . $table . '_', '') END AS "Key_name",
+            a.attname AS "Column_name",
+            NULL AS "Sub_part"
+        FROM pg_class bc, pg_class ic, pg_index i, pg_attribute a
+        WHERE bc.oid = i.indrelid
+            AND ic.oid = i.indexrelid
+            AND (i.indkey[0] = a.attnum OR i.indkey[1] = a.attnum OR i.indkey[2] = a.attnum OR i.indkey[3] = a.attnum OR i.indkey[4] = a.attnum OR i.indkey[5] = a.attnum OR i.indkey[6] = a.attnum OR i.indkey[7] = a.attnum)
+            AND a.attrelid = bc.oid
+            AND bc.relname = '' . $tableName . ''
+            ORDER BY "Key_name", CASE a.attnum
+                WHEN i.indkey[0] THEN 0
+                WHEN i.indkey[1] THEN 1
+                WHEN i.indkey[2] THEN 2
+                WHEN i.indkey[3] THEN 3
+                WHEN i.indkey[4] THEN 4
+                WHEN i.indkey[5] THEN 5
+                WHEN i.indkey[6] THEN 6
+                WHEN i.indkey[7] THEN 7
+            END
+        SQL;
+
+        return $sql;
+    }
+}

pg4wp/rewriters/ShowTableStatusSQLRewriter.php

@@ -0,0 +1,54 @@
+<?php
+
+class ShowTableStatusSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        return $this->generatePostgresShowTableStatus();
+    }
+
+
+    /**
+     * Generates a PostgreSQL-compatible SQL query to mimic MySQL's "SHOW TABLE STATUS".
+     *
+     * @return string The generated SQL query
+     */
+    public function generatePostgresShowTableStatus($schema = "public")
+    {
+        $sql = <<<SQL
+        SELECT 
+            'Postgres' AS Engine,
+            cls.relname AS TableName, 
+            NULL AS Version,
+            NULL AS Row_format,
+            cls.reltuples AS Rows,
+            NULL AS Avg_row_length,
+            pg_size_pretty(pg_relation_size(cls.oid)) AS Data_length,
+            NULL AS Max_data_length,
+            pg_size_pretty(pg_indexes_size(cls.oid)) AS Index_length, 
+            NULL AS Data_free,
+            NULL AS Auto_increment,
+            NULL AS Create_time,
+            NULL AS Update_time,
+            NULL AS Check_time,
+            'UTF8' AS Table_collation,
+            NULL AS Checksum,
+            NULL AS Create_options,
+            obj_description(cls.oid) AS Comment
+        FROM
+            pg_class cls
+        JOIN 
+            pg_namespace nsp ON cls.relnamespace = nsp.oid
+        WHERE 
+            cls.relkind = 'r' 
+            AND nsp.nspname NOT LIKE 'pg_%' 
+            AND nsp.nspname != 'information_schema' 
+            AND nsp.nspname = '$schema' 
+        ORDER BY 
+            cls.relname ASC;
+        SQL;
+
+        return $sql;
+    }
+}

pg4wp/rewriters/ShowTablesSQLRewriter.php

@@ -0,0 +1,10 @@
+<?php
+
+class ShowTablesSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $schema = "public";
+        return 'SELECT tablename FROM pg_tables WHERE schemaname = \'$schema\';';
+    }
+}

pg4wp/rewriters/ShowVariablesSQLRewriter.php

@@ -0,0 +1,47 @@
+<?php
+
+class ShowVariablesSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        $sql = $this->original();
+        $variableName = $this->extractVariableName($sql);
+        return $this->generatePostgres($sql, $variableName);
+    }
+
+    /**
+     * Extracts Variable name from a "SHOW VARIABLES LIKE " SQL statement.
+     *
+     * @param string $sql The SQL statement
+     * @return string|null The table name if found, or null otherwise
+     */
+    protected function extractVariableName($sql)
+    {
+        $pattern = "/SHOW VARIABLES LIKE ['\"`]?([^'\"`]+)['\"`]?/i";
+        if (preg_match($pattern, $sql, $matches)) {
+            return $matches[1];
+        }
+        return null;
+    }
+
+    /**
+     * Generates a PostgreSQL-compatible SQL query to mimic MySQL's "SHOW VARIABLES".
+     *
+     * @param string $tableName The table name
+     * @return string The generated SQL query
+     */
+    public function generatePostgres($sql, $variableName)
+    {
+        if ($variableName == "sql_mode") {
+            // Act like MySQL default configuration, where sql_mode is ""
+            return "SELECT '$variableName' AS \"Variable_name\", '' AS \"Value\";";
+        }
+
+        if ($variableName == "max_allowed_packet") {
+            // Act like 1GB packet size, in practice this limit doesn't actually exist for postgres, we just want to fool WP
+            return "SELECT '$variableName' AS \"Variable_name\", '1073741824' AS \"Value\";";
+        }
+
+        return "SELECT name as \"Variable_name\", setting as \"Value\" FROM pg_settings WHERE name = '$variableName';";
+    }
+}

pg4wp/rewriters/UpdateSQLRewriter.php

@@ -0,0 +1,32 @@
+<?php
+
+class UpdateSQLRewriter extends AbstractSQLRewriter
+{
+    public function rewrite(): string
+    {
+        global $wpdb;
+
+        $sql = $this->original();
+
+        $pattern = '/LIMIT[ ]+\d+/';
+        $sql = preg_replace($pattern, '', $sql);
+
+        // Fix update wp_options
+        $pattern = "/UPDATE `wp_options` SET `option_value` = NULL WHERE `option_name` = '(.+)'/";
+        $match = "UPDATE `wp_options` SET `option_value` = '' WHERE `option_name` = '$1'";
+        $sql = preg_replace($pattern, $match, $sql);
+
+        // For correct bactick removal
+        $pattern = '/[ ]*`([^` ]+)`[ ]*=/';
+        $sql = preg_replace($pattern, ' $1 =', $sql);
+
+        // Those are used when we need to set the date to now() in gmt time
+        $sql = str_replace("'0000-00-00 00:00:00'", 'now() AT TIME ZONE \'gmt\'', $sql);
+
+        // For correct ID quoting
+        $pattern = '/(,|\s)[ ]*([^ \']*ID[^ \']*)[ ]*=/';
+        $sql = preg_replace($pattern, '$1 "$2" =', $sql);
+
+        return $sql;
+    }
+}

wordpress.yaml

@@ -15,15 +15,16 @@ spec:
     spec:
       initContainers:
       - name: init-pg4wp
-        image: hub.hamdocker.ir/library/busybox:latest
+        image: hub.hamdocker.ir/library/alpine:latest
         command:
         - sh
         - -c
         - |
-          wget -O /tmp/pg4wp.zip https://github.com/kevinoid/postgresql-for-wordpress/archive/refs/heads/master.zip
+          apk add --no-cache git
-          unzip /tmp/pg4wp.zip -d /var/www/html/wp-content/plugins/
+          git clone http://gitea-http.gitea.svc.cluster.local:3000/gitea_admin/apps.git /tmp/repo
-          mv /var/www/html/wp-content/plugins/postgresql-for-wordpress-master /var/www/html/wp-content/plugins/pg4wp
+          mkdir -p /var/www/html/wp-content/plugins/pg4wp
-          cp /var/www/html/wp-content/plugins/pg4wp/db.php /var/www/html/wp-content/db.php
+          cp -r /tmp/repo/pg4wp/* /var/www/html/wp-content/plugins/pg4wp/
+          cp /tmp/repo/pg4wp/db.php /var/www/html/wp-content/db.php
         volumeMounts:
         - name: wordpress-data
           mountPath: /var/www/html
@@ -83,4 +84,4 @@ spec:
           service:
             name: wordpress
             port:
-              number: 80
+              number: 80