/**

public $last_table;

/**

public $last_found_rows_result;

/**

public $save_queries = false;

/**

protected $dbh;

/**

public $dbhs;

/**

public $hyper_servers = array();

/**

public $hyper_tables = array();

/**

public $hyper_callbacks = array();

/**

public $save_query_callback = null;

/**

public $persistent = false;

/**

public $max_connections = 10;

/**

public $check_tcp_responsiveness = true;

/**

public $min_tries = 3;

/**

public $srtm = array();

/**

public $db_connections = array();

/**

public $open_connections = array();

/**

public $last_used_server;

/**

public $used_servers = array();

/**

public $unique_servers = array();

/**

public $read_only_servers = array();

/**

public $servers_state = array();

/**

public $save_backtrace = true;

/**

public $default_lag_threshold = null;

/**

public $dbh2host = array();

/**

public $dbhname_heartbeats = array();

/**

public $num_failed_queries = 0;

/**

public function __construct( $args = null ) {

if ( is_array( $args ) ) {

foreach ( get_class_vars( __CLASS__ ) as $var => $value ) {

if ( isset( $args[ $var ] ) ) {

$this->$var = $args[ $var ];

}

}

}

$this->use_mysqli = $this->should_use_mysqli();

if ( $this->use_mysqli ) {

mysqli_report( MYSQLI_REPORT_OFF );

}

$this->init_charset();

}

/**

public function add_database( $db ) {

extract( $db, EXTR_SKIP );

if ( ! isset( $dataset ) ) {

$dataset = 'global';

}

if ( ! isset( $read ) ) {

$read = 1;

}

if ( ! isset( $write ) ) {

$write = 1;

}

unset( $db['dataset'] );

if ( $read ) {

$this->hyper_servers[ $dataset ]['read'][ $read ][] = $db;

}

if ( $write ) {

$this->hyper_servers[ $dataset ]['write'][ $write ][] = $db;

}

}

/**

public function add_table( $dataset, $table ) {

$this->hyper_tables[ $table ] = $dataset;

}

/**

public function add_callback( $callback, $group = 'dataset' ) {

$this->hyper_callbacks[ $group ][] = $callback;

}

/**

public function get_table_from_query( $q ) {

// Remove characters that can legally trail the table name

$q = rtrim( $q, ';/-#' );

// allow (select...) union [...] style queries. Use the first queries table name.

$q = ltrim( $q, "\t (" );

// Strip everything between parentheses except nested

// selects and use only 1500 chars of the query

$q = preg_replace( '/\((?!\s*select)[^(]*?\)/is', '()', substr( $q, 0, 1500 ) );

// SELECT FOUND_ROWS() refers to the previous SELECT query

if ( preg_match( '/^\s*SELECT.*?\s+FOUND_ROWS\(\)/is', $q ) ) {

return $this->last_table;

}

// SELECT FROM information_schema.* WHERE TABLE_NAME = 'wp_12345_foo'

if ( preg_match('/^\s*'

. 'SELECT.*?\s+FROM\s+`?information_schema`?\.'

. '.*\s+TABLE_NAME\s*=\s*["\']([\w-]+)["\']/is', $q, $maybe) ) {

return $maybe[1];

}

// Transaction support, requires a table hint via comment: IN_TABLE=table_name

if ( preg_match('/^\s*'

. '(?:START\s+TRANSACTION|COMMIT|ROLLBACK)\s*\/[*]\s*IN_TABLE\s*=\s*'

. "'?([\w-]+)'?/is", $q, $maybe) ) {

return $maybe[1];

}

$this->last_table = parent::get_table_from_query( $q );

return $this->last_table;

}

/**

public function is_write_query( $q ) {

// Quick and dirty: only SELECT statements are considered read-only.

$q = ltrim( $q, "\r\n\t (" );

return ! preg_match( '/^(?:SELECT|SHOW|DESCRIBE|DESC|EXPLAIN)\s/i', $q );

}

/**

public function send_reads_to_masters() {

$this->srtm = true;

}

/**

public function run_callbacks( $group, $args = null ) {

if ( ! isset( $this->hyper_callbacks[ $group ] ) || ! is_array( $this->hyper_callbacks[ $group ] ) ) {

return null;

}

if ( ! isset( $args ) ) {

$args = array( $this );

} elseif ( is_array( $args ) ) {

// 8.0+ changed the behavior of call_user_func_array(), associative arrays would turn into named attributes

// Here we discard the keys and hope for the best

$args = array_values( $args );

$args[] = $this;

} else {

$args = array( $args, $this );

}

foreach ( $this->hyper_callbacks[ $group ] as $func ) {

$result = call_user_func_array( $func, $args );

if ( isset( $result ) ) {

return $result;

}

}

}

/**

public function db_connect( $query = '' ) {

if ( empty( $query ) ) {

return false;

}

$this->table = $this->get_table_from_query( $query );

if ( isset( $this->hyper_tables[ $this->table ] ) ) {

$dataset = $this->hyper_tables[ $this->table ];

$this->callback_result = null;

} else {

$this->callback_result = $this->run_callbacks( 'dataset', $query );

if ( null !== $this->callback_result ) {

if ( is_array( $this->callback_result ) ) {

extract( $this->callback_result, EXTR_OVERWRITE );

} else {

$dataset = $this->callback_result;

}

}

}

if ( ! isset( $dataset ) ) {

$dataset = 'global';

}

if ( ! $dataset ) {

return $this->log_and_bail( "Unable to determine dataset (for table: $this->table)" );

} else {

$this->dataset = $dataset;

}

$this->run_callbacks( 'dataset_found', $dataset );

if ( empty( $this->hyper_servers ) ) {

if ( $this->is_mysql_connection( $this->dbh ) ) {

return $this->dbh;

}

if (

! defined( 'DB_HOST' )

|| ! defined( 'DB_USER' )

|| ! defined( 'DB_PASSWORD' )

|| ! defined( 'DB_NAME' ) ) {

return $this->log_and_bail( 'We were unable to query because there was no database defined' );

}

$this->dbh = $this->ex_mysql_connect( DB_HOST, DB_USER, DB_PASSWORD, $this->persistent );

if ( ! $this->is_mysql_connection( $this->dbh ) ) {

return $this->log_and_bail( 'We were unable to connect to the database. (DB_HOST)' );

}

if ( ! $this->ex_mysql_select_db( DB_NAME, $this->dbh ) ) {

return $this->log_and_bail( 'We were unable to select the database' );

}

if ( ! empty( $this->charset ) ) {

$collation_query = "SET NAMES '$this->charset'";

if ( ! empty( $this->collate ) ) {

$collation_query .= " COLLATE '$this->collate'";

}

$this->ex_mysql_query( $collation_query, $this->dbh );

}

return $this->dbh;

}

// Determine whether the query must be sent to the master (a writable server)

if ( ! empty( $use_master ) || true === $this->srtm || isset( $this->srtm[ $this->table ] ) ) {

$use_master = true;

} elseif ( $this->is_write_query( $query ) ) {

$use_master = true;

if ( is_array( $this->srtm ) ) {

$this->srtm[ $this->table ] = true;

}

} elseif ( ! isset( $use_master ) && is_array( $this->srtm ) && ! empty( $this->srtm ) ) {

// Detect queries that have a join in the srtm array.

$use_master = false;

$query_match = substr( $query, 0, 1000 );

foreach ( $this->srtm as $key => $value ) {

if ( false !== stripos( $query_match, $key ) ) {

$use_master = true;

break;

}

}

} else {

$use_master = false;

}

if ( $use_master ) {

$dbhname = $dataset . '__w';

$this->dbhname = $dbhname;

$operation = 'write';

} else {

$dbhname = $dataset . '__r';

$this->dbhname = $dbhname;

$operation = 'read';

}

// Try to reuse an existing connection

while ( isset( $this->dbhs[ $dbhname ] ) && $this->is_mysql_connection( $this->dbhs[ $dbhname ] ) ) {

// Find the connection for incrementing counters

foreach ( array_keys( $this->db_connections ) as $i ) {

if ( $this->db_connections[ $i ]['dbhname'] == $dbhname ) {

$conn =& $this->db_connections[ $i ];

}

}

if ( isset( $server['name'] ) ) {

$name = $server['name'];

// A callback has specified a database name so it's possible the existing connection selected a different one.

if ( $name != $this->used_servers[ $dbhname ]['name'] ) {

if ( ! $this->ex_mysql_select_db( $name, $this->dbhs[ $dbhname ] ) ) {

// this can happen when the user varies and lacks permission on the $name database

if ( isset( $conn['disconnect (select failed)'] ) ) {

++$conn['disconnect (select failed)'];

} else {

$conn['disconnect (select failed)'] = 1;

}

$this->disconnect( $dbhname );

break;

}

$this->used_servers[ $dbhname ]['name'] = $name;

}

} else {

$name = $this->used_servers[ $dbhname ]['name'];

}

$this->current_host = $this->dbh2host[ $dbhname ];

// Keep this connection at the top of the stack to prevent disconnecting frequently-used connections

$k = array_search( $dbhname, $this->open_connections );

if ( $k ) {

unset( $this->open_connections[ $k ] );

$this->open_connections[] = $dbhname;

}

$this->last_used_server = $this->used_servers[ $dbhname ];

$this->last_connection = compact( 'dbhname', 'name' );

if ( $this->should_mysql_ping() && ! $this->ex_mysql_ping( $this->dbhs[ $dbhname ] ) ) {

if ( isset( $conn['disconnect (ping failed)'] ) ) {

++$conn['disconnect (ping failed)'];

} else {

$conn['disconnect (ping failed)'] = 1;

}

$this->disconnect( $dbhname );

break;

}

if ( isset( $conn['queries'] ) ) {

++$conn['queries'];

} else {

$conn['queries'] = 1;

}

return $this->dbhs[ $dbhname ];

}

if ( $use_master && defined( 'MASTER_DB_DEAD' ) ) {

return $this->bail( "We're updating the database, please try back in 5 minutes. If you are posting to your blog please hit the refresh button on your browser in a few minutes to post the data again. It will be posted as soon as the database is back online again." );

}

if ( empty( $this->hyper_servers[ $dataset ][ $operation ] ) ) {

return $this->log_and_bail( "No databases available with $this->table ($dataset)" );

}

// Put the groups in order by priority

ksort( $this->hyper_servers[ $dataset ][ $operation ] );

// Make a list of at least $this->min_tries connections to try, repeating as necessary.

$servers = array();

$this->unique_servers[ $dbhname ] = array();

do {

foreach ( $this->hyper_servers[ $dataset ][ $operation ] as $group => $items ) {

$keys = array_keys( $items );

shuffle( $keys );

foreach ( $keys as $key ) {

$servers[] = compact( 'group', 'key' );

if ( ! isset( $this->unique_servers[ $dbhname ][ $items[ $key ]['host'] ] ) ) {

$this->unique_servers[ $dbhname ][ $items[ $key ]['host'] ] = true;

}

}

}

if ( 0 === count( $this->unique_servers[ $dbhname ] ) ) {

return $this->log_and_bail( "No database servers were found to match the query ($this->table, $dataset)" );

}

} while ( count( $servers ) < $this->min_tries ); // phpcs:ignore Squiz.PHP.DisallowSizeFunctionsInLoops.Found

// Connect to a database server

do {

$unique_lagged_slaves = array();

$unique_readonly_masters = array();

$success = false;

$tries_remaining = count( $servers );

foreach ( $servers as $group_key ) {

--$tries_remaining;

// Variables: $group, $key

extract( $group_key, EXTR_OVERWRITE );

// Variables: $host, $user, $password, $name, $read, $write [, $lag_threshold, $timeout ]

extract( $this->hyper_servers[ $dataset ][ $operation ][ $group ][ $key ], EXTR_OVERWRITE );

$port = null;

// Split host:port into $host and $port

if ( strpos( $host, ':' ) ) {

list($host, $port) = explode( ':', $host );

}

// Overlay $server if it was extracted from a callback

if ( isset( $server ) && is_array( $server ) ) {

extract( $server, EXTR_OVERWRITE );

}

// Split again in case $server had host:port

if ( strpos( $host, ':' ) ) {

list($host, $port) = explode( ':', $host );

}

// Make sure there's always a port number

if ( empty( $port ) ) {

$port = 3306;

}

// Use a default timeout of 200ms

if ( ! isset( $timeout ) ) {

$timeout = 0.2;

}

// Get the minimum group here, in case $server rewrites it

if ( ! isset( $min_group ) || $min_group > $group ) {

$min_group = $group;

}

// If a master is read-only and we have others which might not be RO, go to the next one

if ( $use_master && $this->unique_servers[ $dbhname ] > 1 && empty( $ignore_server_read_only ) ) {

if ( count( $unique_readonly_masters ) == count( $this->unique_servers[ $dbhname ] ) ) {

$ignore_server_read_only = true; // All are read-only, ignore RO and retry

continue 2;

}

if ( $this->is_server_marked_read_only( $host, $port ) ) {

$unique_readonly_masters[ "$host:$port" ] = true;

continue;

}

}

// Can be used by the lag callbacks

$this->lag_cache_key = "$host:$port";

$this->lag_threshold = isset( $lag_threshold ) ? $lag_threshold : $this->default_lag_threshold;

// Check for a lagged slave, if applicable

if ( ! $use_master && ! $write && ! isset( $ignore_slave_lag )

&& isset( $this->lag_threshold ) && ! isset( $server['host'] )

// phpcs:ignore Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure

&& ( $lagged_status = $this->get_lag_cache() ) === HYPERDB_LAG_BEHIND

) {

// If it is the last lagged slave and it is with the best preference we will ignore its lag

if ( ! isset( $unique_lagged_slaves[ "$host:$port" ] )

&& count( $unique_lagged_slaves ) + 1 == count( $this->unique_servers[ $dbhname ] )

&& $group == $min_group ) {

$this->lag_threshold = null;

} else {

$unique_lagged_slaves[ "$host:$port" ] = $this->lag;

continue;

}

}

$this->timer_start();

// Connect if necessary or possible

$server_state = null;

if ( $use_master || ! $tries_remaining ||

// phpcs:ignore Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure

'up' === ( $server_state = $this->get_server_state( $host, $port, $dbhname, $timeout ) ) ) {

$this->set_connect_timeout( 'pre_connect', $use_master, $tries_remaining );

$this->dbhs[ $dbhname ] = $this->ex_mysql_connect( "$host:$port", $user, $password, $this->persistent );

$this->set_connect_timeout( 'post_connect', $use_master, $tries_remaining );

} else {

$this->dbhs[ $dbhname ] = false;

}

$elapsed = $this->timer_stop();

if ( $this->is_mysql_connection( $this->dbhs[ $dbhname ] ) ) {

/**

if ( ! $use_master && ! $write && ! isset( $ignore_slave_lag )

&& isset( $this->lag_threshold ) && ! isset( $server['host'] )

&& HYPERDB_LAG_OK !== $lagged_status

&& ( $lagged_status = $this->get_lag() ) === HYPERDB_LAG_BEHIND // phpcs:ignore Squiz.PHP.DisallowMultipleAssignments.FoundInControlStructure

&& ! (

! isset( $unique_lagged_slaves[ "$host:$port" ] )

&& count( $unique_lagged_slaves ) + 1 === count( $this->unique_servers[ $dbhname ] )

&& $group == $min_group

)

) {

$success = false;

$unique_lagged_slaves[ "$host:$port" ] = $this->lag;

$this->disconnect( $dbhname );

$this->dbhs[ $dbhname ] = false;

$msg = "Replication lag of {$this->lag}s on $host:$port ($dbhname)";

$this->print_error( $msg );

continue;

} elseif ( $this->ex_mysql_select_db( $name, $this->dbhs[ $dbhname ] ) ) {

$success = true;

$this->current_host = "$host:$port";

$this->dbh2host[ $dbhname ] = "$host:$port";

$queries = 1;

$lag = isset( $this->lag ) ? $this->lag : 0;

$this->last_connection = compact( 'dbhname', 'host', 'port', 'user', 'name', 'server_state', 'elapsed', 'success', 'queries', 'lag' );

$this->db_connections[] = $this->last_connection;

$this->open_connections[] = $dbhname;

break;

}

}

if ( 'down' == $server_state ) {

continue; // don't flood the logs if already down

}

$errno = $this->ex_mysql_errno();

if ( ( HYPERDB_CONN_HOST_ERROR == $errno || HYPERDB_CONNNECTION_ERROR == $errno ) &&

( 'up' == $server_state || ! $tries_remaining ) ) {

$this->mark_server_as_down( $host, $port );

$server_state = 'down';

}

$referrer = '';

if ( ! empty( $_SERVER['HTTP_HOST'] ) ) {

// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- print_error() will sanitize the entire message

$referrer .= (string) $_SERVER['HTTP_HOST'];

}

if ( ! empty( $_SERVER['REQUEST_URI'] ) ) {

// phpcs:ignore WordPress.Security.ValidatedSanitizedInput.InputNotSanitized -- print_error() will sanitize the entire message

$referrer .= (string) $_SERVER['REQUEST_URI'];

}

if ( ! isset( $tcp ) ) {

$tcp = '';

}

if ( ! isset( $server ) ) {

$server = '';

}

$success = false;

$this->last_connection = compact( 'dbhname', 'host', 'port', 'user', 'name', 'tcp', 'elapsed', 'success' );

$this->db_connections[] = $this->last_connection;

$msg = date( 'Y-m-d H:i:s' ) . " Can't select $dbhname - \n"; // phpcs:ignore WordPress.DateTime.RestrictedFunctions.date_date

$msg .= "'referrer' => '{$referrer}',\n";

$msg .= "'server' => {$server},\n";

$msg .= "'host' => {$host},\n";

$msg .= "'error' => " . $this->ex_mysql_error() . ",\n";

$msg .= "'errno' => " . $this->ex_mysql_errno() . ",\n";

$msg .= "'server_state' => $server_state\n";

$msg .= "'lagged_status' => " . ( isset( $lagged_status ) ? $lagged_status : HYPERDB_LAG_UNKNOWN );

$this->print_error( $msg );

}

if ( ! $success || ! isset( $this->dbhs[ $dbhname ] ) || ! $this->is_mysql_connection( $this->dbhs[ $dbhname ] ) ) {

if ( ! isset( $ignore_slave_lag ) && count( $unique_lagged_slaves ) ) {

// Lagged slaves were not used. Ignore the lag for this connection attempt and retry.

$ignore_slave_lag = true;

continue;

}

$error_details = array(

'host' => $host,

'port' => $port,

'operation' => $operation,

'table' => $this->table,

'dataset' => $dataset,

'dbhname' => $dbhname,

);

$this->run_callbacks( 'db_connection_error', $error_details );

return $this->bail( "Unable to connect to $host:$port to $operation table '$this->table' ($dataset)" );

}

break;

} while ( true );

if ( ! isset( $charset ) ) {

$charset = null;

}

if ( ! isset( $collate ) ) {

$collate = null;

}

$this->set_charset( $this->dbhs[ $dbhname ], $charset, $collate );

$this->dbh = $this->dbhs[ $dbhname ]; // needed by $wpdb->_real_escape()

$this->last_used_server = compact( 'host', 'user', 'name', 'read', 'write' );

$this->used_servers[ $dbhname ] = $this->last_used_server;

// phpcs:ignore Squiz.PHP.DisallowSizeFunctionsInLoops.Found

while ( ! $this->persistent && count( $this->open_connections ) > $this->max_connections ) {

$oldest_connection = array_shift( $this->open_connections );

if ( $this->dbhs[ $oldest_connection ] != $this->dbhs[ $dbhname ] ) {

$this->disconnect( $oldest_connection );

}

}

return $this->dbhs[ $dbhname ];

}

/**

public function set_charset( $dbh, $charset = null, $collate = null ) {

if ( ! isset( $charset ) ) {

$charset = $this->charset;

}

if ( ! isset( $collate ) ) {

$collate = $this->collate;

}

if ( ! $this->has_cap( 'collation', $dbh ) || empty( $charset ) ) {

return;

}

if ( ! in_array( strtolower( $charset ), array( 'utf8', 'utf8mb4', 'latin1' ) ) ) {

// phpcs:ignore WordPress.Security.EscapeOutput.OutputNotEscaped

wp_die( sprintf( "%s charset isn't supported in HyperDB for security reasons", htmlspecialchars( $charset ) ) );

}

if ( $this->is_mysql_set_charset_callable() && $this->has_cap( 'set_charset', $dbh ) ) {

$this->ex_mysql_set_charset( $charset, $dbh );

$this->real_escape = true;

} else {

$query = $this->prepare( 'SET NAMES %s', $charset );

if ( ! empty( $collate ) ) {

$query .= $this->prepare( ' COLLATE %s', $collate );

}

$this->ex_mysql_query( $query, $dbh );

}

}

/**

public function _real_escape( $string ) { // phpcs:ignore PSR2.Methods.MethodDeclaration.Underscore

$escaped = addslashes( (string) $string );

if ( method_exists( get_parent_class( $this ), 'add_placeholder_escape' ) ) {

$escaped = $this->add_placeholder_escape( $escaped );

}

return $escaped;

}

/**

public function disconnect( $dbhname ) {

$k = array_search( $dbhname, $this->open_connections );

if ( false !== $k ) {

unset( $this->open_connections[ $k ] );

}

foreach ( array_keys( $this->db_connections ) as $i ) {

if ( $this->db_connections[ $i ]['dbhname'] == $dbhname ) {

unset( $this->db_connections[ $i ] );

}

}

if ( $this->is_mysql_connection( $this->dbhs[ $dbhname ] ) ) {

$this->ex_mysql_close( $this->dbhs[ $dbhname ] );

}

unset( $this->dbhs[ $dbhname ] );

}

/**

public function flush() {

$this->last_error = '';

$this->last_errno = 0;

$this->num_rows = 0;

parent::flush();

}

/**

public function query( $query ) {

// some queries are made before the plugins have been loaded, and thus cannot be filtered with this method

if ( function_exists( 'apply_filters' ) ) {

$query = apply_filters( 'query', $query );

}

// initialise return

$return_val = 0;

$this->flush();

// Log how the function was called

$this->func_call = "\$db->query(\"$query\")";

// Keep track of the last query for debug..

$this->last_query = $query;

if ( preg_match( '/^\s*SELECT\s+FOUND_ROWS(\s*)/i', $query ) ) {

if ( $this->is_mysql_result( $this->last_found_rows_result ) ) {

$this->result = $this->last_found_rows_result;

$this->last_found_rows_result = null;

$elapsed = 0;

} else {

$this->print_error( 'Attempted SELECT FOUND_ROWS() without prior SQL_CALC_FOUND_ROWS.' );

return false;

}

} else {

$this->dbh = $this->db_connect( $query );

if ( ! $this->is_mysql_connection( $this->dbh ) ) {

$this->check_current_query = true;

$this->last_error = 'Database connection failed';

$this->num_failed_queries++;

if ( function_exists( 'do_action' ) ) {

do_action( 'sql_query_log', $query, false, $this->last_error );

}

return false;

}

$query_comment = $this->run_callbacks( 'get_query_comment', $query );

if ( ! empty( $query_comment ) ) {

$query = rtrim( $query, ";\t \n\r" ) . ' /* ' . $query_comment . ' */';

}

// If we're writing to the database, make sure the query will write safely.

if ( $this->check_current_query && method_exists( $this, 'check_ascii' ) && ! $this->check_ascii( $query ) ) {

$stripped_query = $this->strip_invalid_text_from_query( $query );

if ( $stripped_query !== $query ) {

$this->insert_id = 0;

$this->last_error = 'Invalid query';

$this->num_failed_queries++;

if ( function_exists( 'do_action' ) ) {

do_action( 'sql_query_log', $query, false, $this->last_error );

}

return false;

}

}

$this->check_current_query = true;

// Inject setup and teardown statements

$statement_before_query = $this->run_callbacks( 'statement_before_query' );

$statement_after_query = $this->run_callbacks( 'statement_after_query' );

$query_for_log = $query;

$this->timer_start();

if ( $statement_before_query ) {

$query_for_log = "$statement_before_query; $query_for_log";

$this->ex_mysql_query( $statement_before_query, $this->dbh );

}

$this->result = $this->ex_mysql_query( $query, $this->dbh );

$this->last_error = $this->ex_mysql_error( $this->dbh );

if ( $statement_after_query ) {

$query_for_log = "$query_for_log; $statement_after_query";

$this->ex_mysql_query( $statement_after_query, $this->dbh );

}

$elapsed = $this->timer_stop();

++$this->num_queries;

if ( preg_match( '/^\s*SELECT\s+SQL_CALC_FOUND_ROWS\s/i', $query ) && false !== $this->result ) {

if ( false === strpos( $query, 'NO_SELECT_FOUND_ROWS' ) ) {

$this->timer_start();

$this->last_found_rows_result = $this->ex_mysql_query( 'SELECT FOUND_ROWS()', $this->dbh );

$elapsed += $this->timer_stop();

$this->last_error = $this->ex_mysql_error( $this->dbh );

++$this->num_queries;

$query .= '; SELECT FOUND_ROWS()';

}

} else {

$this->last_found_rows_result = null;

}

$this->dbhname_heartbeats[ $this->dbhname ]['last_used'] = microtime( true );

if ( $this->save_queries ) {

if ( is_callable( $this->save_query_callback ) ) {

// phpcs:ignore WordPress.PHP.DevelopmentFunctions.error_log_debug_backtrace

$saved_query = call_user_func_array( $this->save_query_callback, array( $query_for_log, $elapsed, $this->save_backtrace ? debug_backtrace( DEBUG_BACKTRACE_IGNORE_ARGS ) : null, $this ) );

if ( null !== $saved_query ) {

$this->queries[] = $saved_query;

}

} else {

$this->queries[] = array( $query_for_log, $elapsed, $this->get_caller() );

}

}

}