diff options
Diffstat (limited to 'srcs/wordpress/wp-includes/wp-db.php')
| -rw-r--r-- | srcs/wordpress/wp-includes/wp-db.php | 3625 |
1 files changed, 3625 insertions, 0 deletions
diff --git a/srcs/wordpress/wp-includes/wp-db.php b/srcs/wordpress/wp-includes/wp-db.php new file mode 100644 index 0000000..1be0412 --- /dev/null +++ b/srcs/wordpress/wp-includes/wp-db.php @@ -0,0 +1,3625 @@ +<?php +/** + * WordPress DB Class + * + * Original code from {@link http://php.justinvincent.com Justin Vincent (justin@visunet.ie)} + * + * @package WordPress + * @subpackage Database + * @since 0.71 + */ + +/** + * @since 0.71 + */ +define( 'EZSQL_VERSION', 'WP1.25' ); + +/** + * @since 0.71 + */ +define( 'OBJECT', 'OBJECT' ); +// phpcs:ignore Generic.NamingConventions.UpperCaseConstantName.ConstantNotUpperCase +define( 'object', 'OBJECT' ); // Back compat. + +/** + * @since 2.5.0 + */ +define( 'OBJECT_K', 'OBJECT_K' ); + +/** + * @since 0.71 + */ +define( 'ARRAY_A', 'ARRAY_A' ); + +/** + * @since 0.71 + */ +define( 'ARRAY_N', 'ARRAY_N' ); + +/** + * WordPress Database Access Abstraction Object + * + * It is possible to replace this class with your own + * by setting the $wpdb global variable in wp-content/db.php + * file to your class. The wpdb class will still be included, + * so you can extend it or simply use your own. + * + * @link https://codex.wordpress.org/Function_Reference/wpdb_Class + * + * @since 0.71 + */ +class wpdb { + + /** + * Whether to show SQL/DB errors. + * + * Default behavior is to show errors if both WP_DEBUG and WP_DEBUG_DISPLAY + * evaluated to true. + * + * @since 0.71 + * @var bool + */ + var $show_errors = false; + + /** + * Whether to suppress errors during the DB bootstrapping. + * + * @since 2.5.0 + * @var bool + */ + var $suppress_errors = false; + + /** + * The last error during query. + * + * @since 2.5.0 + * @var string + */ + public $last_error = ''; + + /** + * Amount of queries made + * + * @since 1.2.0 + * @var int + */ + public $num_queries = 0; + + /** + * Count of rows returned by previous query + * + * @since 0.71 + * @var int + */ + public $num_rows = 0; + + /** + * Count of affected rows by previous query + * + * @since 0.71 + * @var int + */ + var $rows_affected = 0; + + /** + * The ID generated for an AUTO_INCREMENT column by the previous query (usually INSERT). + * + * @since 0.71 + * @var int + */ + public $insert_id = 0; + + /** + * Last query made + * + * @since 0.71 + * @var string + */ + var $last_query; + + /** + * Results of the last query made + * + * @since 0.71 + * @var array|null + */ + var $last_result; + + /** + * MySQL result, which is either a resource or boolean. + * + * @since 0.71 + * @var mixed + */ + protected $result; + + /** + * Cached column info, for sanity checking data before inserting + * + * @since 4.2.0 + * @var array + */ + protected $col_meta = array(); + + /** + * Calculated character sets on tables + * + * @since 4.2.0 + * @var array + */ + protected $table_charset = array(); + + /** + * Whether text fields in the current query need to be sanity checked. + * + * @since 4.2.0 + * @var bool + */ + protected $check_current_query = true; + + /** + * Flag to ensure we don't run into recursion problems when checking the collation. + * + * @since 4.2.0 + * @see wpdb::check_safe_collation() + * @var bool + */ + private $checking_collation = false; + + /** + * Saved info on the table column + * + * @since 0.71 + * @var array + */ + protected $col_info; + + /** + * Log of queries that were executed, for debugging purposes. + * + * @since 1.5.0 + * @since 2.5.0 The third element in each query log was added to record the calling functions. + * @since 5.1.0 The fourth element in each query log was added to record the start time. + * @since 5.3.0 The fifth element in each query log was added to record custom data. + * + * @var array[] { + * Array of queries that were executed. + * + * @type array ...$0 { + * Data for each query. + * + * @type string $0 The query's SQL. + * @type float $1 Total time spent on the query, in seconds. + * @type string $2 Comma separated list of the calling functions. + * @type float $3 Unix timestamp of the time at the start of the query. + * @type array $4 Custom query data. + * } + * } + */ + var $queries; + + /** + * The number of times to retry reconnecting before dying. + * + * @since 3.9.0 + * @see wpdb::check_connection() + * @var int + */ + protected $reconnect_retries = 5; + + /** + * WordPress table prefix + * + * You can set this to have multiple WordPress installations + * in a single database. The second reason is for possible + * security precautions. + * + * @since 2.5.0 + * @var string + */ + public $prefix = ''; + + /** + * WordPress base table prefix. + * + * @since 3.0.0 + * @var string + */ + public $base_prefix; + + /** + * Whether the database queries are ready to start executing. + * + * @since 2.3.2 + * @var bool + */ + var $ready = false; + + /** + * Blog ID. + * + * @since 3.0.0 + * @var int + */ + public $blogid = 0; + + /** + * Site ID. + * + * @since 3.0.0 + * @var int + */ + public $siteid = 0; + + /** + * List of WordPress per-blog tables + * + * @since 2.5.0 + * @see wpdb::tables() + * @var array + */ + var $tables = array( + 'posts', + 'comments', + 'links', + 'options', + 'postmeta', + 'terms', + 'term_taxonomy', + 'term_relationships', + 'termmeta', + 'commentmeta', + ); + + /** + * List of deprecated WordPress tables + * + * categories, post2cat, and link2cat were deprecated in 2.3.0, db version 5539 + * + * @since 2.9.0 + * @see wpdb::tables() + * @var array + */ + var $old_tables = array( 'categories', 'post2cat', 'link2cat' ); + + /** + * List of WordPress global tables + * + * @since 3.0.0 + * @see wpdb::tables() + * @var array + */ + var $global_tables = array( 'users', 'usermeta' ); + + /** + * List of Multisite global tables + * + * @since 3.0.0 + * @see wpdb::tables() + * @var array + */ + var $ms_global_tables = array( + 'blogs', + 'blogmeta', + 'signups', + 'site', + 'sitemeta', + 'sitecategories', + 'registration_log', + ); + + /** + * WordPress Comments table + * + * @since 1.5.0 + * @var string + */ + public $comments; + + /** + * WordPress Comment Metadata table + * + * @since 2.9.0 + * @var string + */ + public $commentmeta; + + /** + * WordPress Links table + * + * @since 1.5.0 + * @var string + */ + public $links; + + /** + * WordPress Options table + * + * @since 1.5.0 + * @var string + */ + public $options; + + /** + * WordPress Post Metadata table + * + * @since 1.5.0 + * @var string + */ + public $postmeta; + + /** + * WordPress Posts table + * + * @since 1.5.0 + * @var string + */ + public $posts; + + /** + * WordPress Terms table + * + * @since 2.3.0 + * @var string + */ + public $terms; + + /** + * WordPress Term Relationships table + * + * @since 2.3.0 + * @var string + */ + public $term_relationships; + + /** + * WordPress Term Taxonomy table + * + * @since 2.3.0 + * @var string + */ + public $term_taxonomy; + + /** + * WordPress Term Meta table. + * + * @since 4.4.0 + * @var string + */ + public $termmeta; + + // + // Global and Multisite tables + // + + /** + * WordPress User Metadata table + * + * @since 2.3.0 + * @var string + */ + public $usermeta; + + /** + * WordPress Users table + * + * @since 1.5.0 + * @var string + */ + public $users; + + /** + * Multisite Blogs table + * + * @since 3.0.0 + * @var string + */ + public $blogs; + + /** + * Multisite Blog Metadata table + * + * @since 5.1.0 + * @var string + */ + public $blogmeta; + + /** + * Multisite Registration Log table + * + * @since 3.0.0 + * @var string + */ + public $registration_log; + + /** + * Multisite Signups table + * + * @since 3.0.0 + * @var string + */ + public $signups; + + /** + * Multisite Sites table + * + * @since 3.0.0 + * @var string + */ + public $site; + + /** + * Multisite Sitewide Terms table + * + * @since 3.0.0 + * @var string + */ + public $sitecategories; + + /** + * Multisite Site Metadata table + * + * @since 3.0.0 + * @var string + */ + public $sitemeta; + + /** + * Format specifiers for DB columns. Columns not listed here default to %s. Initialized during WP load. + * + * Keys are column names, values are format types: 'ID' => '%d' + * + * @since 2.8.0 + * @see wpdb::prepare() + * @see wpdb::insert() + * @see wpdb::update() + * @see wpdb::delete() + * @see wp_set_wpdb_vars() + * @var array + */ + public $field_types = array(); + + /** + * Database table columns charset + * + * @since 2.2.0 + * @var string + */ + public $charset; + + /** + * Database table columns collate + * + * @since 2.2.0 + * @var string + */ + public $collate; + + /** + * Database Username + * + * @since 2.9.0 + * @var string + */ + protected $dbuser; + + /** + * Database Password + * + * @since 3.1.0 + * @var string + */ + protected $dbpassword; + + /** + * Database Name + * + * @since 3.1.0 + * @var string + */ + protected $dbname; + + /** + * Database Host + * + * @since 3.1.0 + * @var string + */ + protected $dbhost; + + /** + * Database Handle + * + * @since 0.71 + * @var string + */ + protected $dbh; + + /** + * A textual description of the last query/get_row/get_var call + * + * @since 3.0.0 + * @var string + */ + public $func_call; + + /** + * Whether MySQL is used as the database engine. + * + * Set in WPDB::db_connect() to true, by default. This is used when checking + * against the required MySQL version for WordPress. Normally, a replacement + * database drop-in (db.php) will skip these checks, but setting this to true + * will force the checks to occur. + * + * @since 3.3.0 + * @var bool + */ + public $is_mysql = null; + + /** + * A list of incompatible SQL modes. + * + * @since 3.9.0 + * @var array + */ + protected $incompatible_modes = array( + 'NO_ZERO_DATE', + 'ONLY_FULL_GROUP_BY', + 'STRICT_TRANS_TABLES', + 'STRICT_ALL_TABLES', + 'TRADITIONAL', + ); + + /** + * Whether to use mysqli over mysql. + * + * @since 3.9.0 + * @var bool + */ + private $use_mysqli = false; + + /** + * Whether we've managed to successfully connect at some point + * + * @since 3.9.0 + * @var bool + */ + private $has_connected = false; + + /** + * Connects to the database server and selects a database + * + * PHP5 style constructor for compatibility with PHP5. Does + * the actual setting up of the class properties and connection + * to the database. + * + * @link https://core.trac.wordpress.org/ticket/3354 + * @since 2.0.8 + * + * @global string $wp_version + * + * @param string $dbuser MySQL database user + * @param string $dbpassword MySQL database password + * @param string $dbname MySQL database name + * @param string $dbhost MySQL database host + */ + public function __construct( $dbuser, $dbpassword, $dbname, $dbhost ) { + register_shutdown_function( array( $this, '__destruct' ) ); + + if ( WP_DEBUG && WP_DEBUG_DISPLAY ) { + $this->show_errors(); + } + + // Use ext/mysqli if it exists unless WP_USE_EXT_MYSQL is defined as true + if ( function_exists( 'mysqli_connect' ) ) { + $this->use_mysqli = true; + + if ( defined( 'WP_USE_EXT_MYSQL' ) ) { + $this->use_mysqli = ! WP_USE_EXT_MYSQL; + } + } + + $this->dbuser = $dbuser; + $this->dbpassword = $dbpassword; + $this->dbname = $dbname; + $this->dbhost = $dbhost; + + // wp-config.php creation will manually connect when ready. + if ( defined( 'WP_SETUP_CONFIG' ) ) { + return; + } + + $this->db_connect(); + } + + /** + * PHP5 style destructor and will run when database object is destroyed. + * + * @see wpdb::__construct() + * @since 2.0.8 + * @return true + */ + public function __destruct() { + return true; + } + + /** + * Makes private properties readable for backward compatibility. + * + * @since 3.5.0 + * + * @param string $name The private member to get, and optionally process + * @return mixed The private member + */ + public function __get( $name ) { + if ( 'col_info' === $name ) { + $this->load_col_info(); + } + + return $this->$name; + } + + /** + * Makes private properties settable for backward compatibility. + * + * @since 3.5.0 + * + * @param string $name The private member to set + * @param mixed $value The value to set + */ + public function __set( $name, $value ) { + $protected_members = array( + 'col_meta', + 'table_charset', + 'check_current_query', + ); + if ( in_array( $name, $protected_members, true ) ) { + return; + } + $this->$name = $value; + } + + /** + * Makes private properties check-able for backward compatibility. + * + * @since 3.5.0 + * + * @param string $name The private member to check + * + * @return bool If the member is set or not + */ + public function __isset( $name ) { + return isset( $this->$name ); + } + + /** + * Makes private properties un-settable for backward compatibility. + * + * @since 3.5.0 + * + * @param string $name The private member to unset + */ + public function __unset( $name ) { + unset( $this->$name ); + } + + /** + * Set $this->charset and $this->collate + * + * @since 3.1.0 + */ + public function init_charset() { + $charset = ''; + $collate = ''; + + if ( function_exists( 'is_multisite' ) && is_multisite() ) { + $charset = 'utf8'; + if ( defined( 'DB_COLLATE' ) && DB_COLLATE ) { + $collate = DB_COLLATE; + } else { + $collate = 'utf8_general_ci'; + } + } elseif ( defined( 'DB_COLLATE' ) ) { + $collate = DB_COLLATE; + } + + if ( defined( 'DB_CHARSET' ) ) { + $charset = DB_CHARSET; + } + + $charset_collate = $this->determine_charset( $charset, $collate ); + + $this->charset = $charset_collate['charset']; + $this->collate = $charset_collate['collate']; + } + + /** + * Determines the best charset and collation to use given a charset and collation. + * + * For example, when able, utf8mb4 should be used instead of utf8. + * + * @since 4.6.0 + * + * @param string $charset The character set to check. + * @param string $collate The collation to check. + * @return array The most appropriate character set and collation to use. + */ + public function determine_charset( $charset, $collate ) { + if ( ( $this->use_mysqli && ! ( $this->dbh instanceof mysqli ) ) || empty( $this->dbh ) ) { + return compact( 'charset', 'collate' ); + } + + if ( 'utf8' === $charset && $this->has_cap( 'utf8mb4' ) ) { + $charset = 'utf8mb4'; + } + + if ( 'utf8mb4' === $charset && ! $this->has_cap( 'utf8mb4' ) ) { + $charset = 'utf8'; + $collate = str_replace( 'utf8mb4_', 'utf8_', $collate ); + } + + if ( 'utf8mb4' === $charset ) { + // _general_ is outdated, so we can upgrade it to _unicode_, instead. + if ( ! $collate || 'utf8_general_ci' === $collate ) { + $collate = 'utf8mb4_unicode_ci'; + } else { + $collate = str_replace( 'utf8_', 'utf8mb4_', $collate ); + } + } + + // _unicode_520_ is a better collation, we should use that when it's available. + if ( $this->has_cap( 'utf8mb4_520' ) && 'utf8mb4_unicode_ci' === $collate ) { + $collate = 'utf8mb4_unicode_520_ci'; + } + + return compact( 'charset', 'collate' ); + } + + /** + * Sets the connection's character set. + * + * @since 3.1.0 + * + * @param resource $dbh The resource given by mysql_connect + * @param string $charset Optional. The character set. Default null. + * @param string $collate Optional. The collation. Default null. + */ + 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' ) && ! empty( $charset ) ) { + $set_charset_succeeded = true; + + if ( $this->use_mysqli ) { + if ( function_exists( 'mysqli_set_charset' ) && $this->has_cap( 'set_charset' ) ) { + $set_charset_succeeded = mysqli_set_charset( $dbh, $charset ); + } + + if ( $set_charset_succeeded ) { + $query = $this->prepare( 'SET NAMES %s', $charset ); + if ( ! empty( $collate ) ) { + $query .= $this->prepare( ' COLLATE %s', $collate ); + } + mysqli_query( $dbh, $query ); + } + } else { + if ( function_exists( 'mysql_set_charset' ) && $this->has_cap( 'set_charset' ) ) { + $set_charset_succeeded = mysql_set_charset( $charset, $dbh ); + } + if ( $set_charset_succeeded ) { + $query = $this->prepare( 'SET NAMES %s', $charset ); + if ( ! empty( $collate ) ) { + $query .= $this->prepare( ' COLLATE %s', $collate ); + } + mysql_query( $query, $dbh ); + } + } + } + } + + /** + * Change the current SQL mode, and ensure its WordPress compatibility. + * + * If no modes are passed, it will ensure the current MySQL server + * modes are compatible. + * + * @since 3.9.0 + * + * @param array $modes Optional. A list of SQL modes to set. + */ + public function set_sql_mode( $modes = array() ) { + if ( empty( $modes ) ) { + if ( $this->use_mysqli ) { + $res = mysqli_query( $this->dbh, 'SELECT @@SESSION.sql_mode' ); + } else { + $res = mysql_query( 'SELECT @@SESSION.sql_mode', $this->dbh ); + } + + if ( empty( $res ) ) { + return; + } + + if ( $this->use_mysqli ) { + $modes_array = mysqli_fetch_array( $res ); + if ( empty( $modes_array[0] ) ) { + return; + } + $modes_str = $modes_array[0]; + } else { + $modes_str = mysql_result( $res, 0 ); + } + + if ( empty( $modes_str ) ) { + return; + } + + $modes = explode( ',', $modes_str ); + } + + $modes = array_change_key_case( $modes, CASE_UPPER ); + + /** + * Filters the list of incompatible SQL modes to exclude. + * + * @since 3.9.0 + * + * @param array $incompatible_modes An array of incompatible modes. + */ + $incompatible_modes = (array) apply_filters( 'incompatible_sql_modes', $this->incompatible_modes ); + + foreach ( $modes as $i => $mode ) { + if ( in_array( $mode, $incompatible_modes ) ) { + unset( $modes[ $i ] ); + } + } + + $modes_str = implode( ',', $modes ); + + if ( $this->use_mysqli ) { + mysqli_query( $this->dbh, "SET SESSION sql_mode='$modes_str'" ); + } else { + mysql_query( "SET SESSION sql_mode='$modes_str'", $this->dbh ); + } + } + + /** + * Sets the table prefix for the WordPress tables. + * + * @since 2.5.0 + * + * @param string $prefix Alphanumeric name for the new prefix. + * @param bool $set_table_names Optional. Whether the table names, e.g. wpdb::$posts, should be updated or not. + * @return string|WP_Error Old prefix or WP_Error on error + */ + public function set_prefix( $prefix, $set_table_names = true ) { + + if ( preg_match( '|[^a-z0-9_]|i', $prefix ) ) { + return new WP_Error( 'invalid_db_prefix', 'Invalid database prefix' ); + } + + $old_prefix = is_multisite() ? '' : $prefix; + + if ( isset( $this->base_prefix ) ) { + $old_prefix = $this->base_prefix; + } + + $this->base_prefix = $prefix; + + if ( $set_table_names ) { + foreach ( $this->tables( 'global' ) as $table => $prefixed_table ) { + $this->$table = $prefixed_table; + } + + if ( is_multisite() && empty( $this->blogid ) ) { + return $old_prefix; + } + + $this->prefix = $this->get_blog_prefix(); + + foreach ( $this->tables( 'blog' ) as $table => $prefixed_table ) { + $this->$table = $prefixed_table; + } + + foreach ( $this->tables( 'old' ) as $table => $prefixed_table ) { + $this->$table = $prefixed_table; + } + } + return $old_prefix; + } + + /** + * Sets blog id. + * + * @since 3.0.0 + * + * @param int $blog_id + * @param int $network_id Optional. + * @return int previous blog id + */ + public function set_blog_id( $blog_id, $network_id = 0 ) { + if ( ! empty( $network_id ) ) { + $this->siteid = $network_id; + } + + $old_blog_id = $this->blogid; + $this->blogid = $blog_id; + + $this->prefix = $this->get_blog_prefix(); + + foreach ( $this->tables( 'blog' ) as $table => $prefixed_table ) { + $this->$table = $prefixed_table; + } + + foreach ( $this->tables( 'old' ) as $table => $prefixed_table ) { + $this->$table = $prefixed_table; + } + + return $old_blog_id; + } + + /** + * Gets blog prefix. + * + * @since 3.0.0 + * @param int $blog_id Optional. + * @return string Blog prefix. + */ + public function get_blog_prefix( $blog_id = null ) { + if ( is_multisite() ) { + if ( null === $blog_id ) { + $blog_id = $this->blogid; + } + $blog_id = (int) $blog_id; + if ( defined( 'MULTISITE' ) && ( 0 == $blog_id || 1 == $blog_id ) ) { + return $this->base_prefix; + } else { + return $this->base_prefix . $blog_id . '_'; + } + } else { + return $this->base_prefix; + } + } + + /** + * Returns an array of WordPress tables. + * + * Also allows for the CUSTOM_USER_TABLE and CUSTOM_USER_META_TABLE to + * override the WordPress users and usermeta tables that would otherwise + * be determined by the prefix. + * + * The scope argument can take one of the following: + * + * 'all' - returns 'all' and 'global' tables. No old tables are returned. + * 'blog' - returns the blog-level tables for the queried blog. + * 'global' - returns the global tables for the installation, returning multisite tables only if running multisite. + * 'ms_global' - returns the multisite global tables, regardless if current installation is multisite. + * 'old' - returns tables which are deprecated. + * + * @since 3.0.0 + * @uses wpdb::$tables + * @uses wpdb::$old_tables + * @uses wpdb::$global_tables + * @uses wpdb::$ms_global_tables + * + * @param string $scope Optional. Can be all, global, ms_global, blog, or old tables. Defaults to all. + * @param bool $prefix Optional. Whether to include table prefixes. Default true. If blog + * prefix is requested, then the custom users and usermeta tables will be mapped. + * @param int $blog_id Optional. The blog_id to prefix. Defaults to wpdb::$blogid. Used only when prefix is requested. + * @return array Table names. When a prefix is requested, the key is the unprefixed table name. + */ + public function tables( $scope = 'all', $prefix = true, $blog_id = 0 ) { + switch ( $scope ) { + case 'all': + $tables = array_merge( $this->global_tables, $this->tables ); + if ( is_multisite() ) { + $tables = array_merge( $tables, $this->ms_global_tables ); + } + break; + case 'blog': + $tables = $this->tables; + break; + case 'global': + $tables = $this->global_tables; + if ( is_multisite() ) { + $tables = array_merge( $tables, $this->ms_global_tables ); + } + break; + case 'ms_global': + $tables = $this->ms_global_tables; + break; + case 'old': + $tables = $this->old_tables; + break; + default: + return array(); + } + + if ( $prefix ) { + if ( ! $blog_id ) { + $blog_id = $this->blogid; + } + $blog_prefix = $this->get_blog_prefix( $blog_id ); + $base_prefix = $this->base_prefix; + $global_tables = array_merge( $this->global_tables, $this->ms_global_tables ); + foreach ( $tables as $k => $table ) { + if ( in_array( $table, $global_tables ) ) { + $tables[ $table ] = $base_prefix . $table; + } else { + $tables[ $table ] = $blog_prefix . $table; + } + unset( $tables[ $k ] ); + } + + if ( isset( $tables['users'] ) && defined( 'CUSTOM_USER_TABLE' ) ) { + $tables['users'] = CUSTOM_USER_TABLE; + } + + if ( isset( $tables['usermeta'] ) && defined( 'CUSTOM_USER_META_TABLE' ) ) { + $tables['usermeta'] = CUSTOM_USER_META_TABLE; + } + } + + return $tables; + } + + /** + * Selects a database using the current database connection. + * + * The database name will be changed based on the current database + * connection. On failure, the execution will bail and display an DB error. + * + * @since 0.71 + * + * @param string $db MySQL database name + * @param resource|null $dbh Optional link identifier. + */ + public function select( $db, $dbh = null ) { + if ( is_null( $dbh ) ) { + $dbh = $this->dbh; + } + + if ( $this->use_mysqli ) { + $success = mysqli_select_db( $dbh, $db ); + } else { + $success = mysql_select_db( $db, $dbh ); + } + if ( ! $success ) { + $this->ready = false; + if ( ! did_action( 'template_redirect' ) ) { + wp_load_translations_early(); + + $message = '<h1>' . __( 'Can’t select database' ) . "</h1>\n"; + + $message .= '<p>' . sprintf( + /* translators: %s: Database name. */ + __( 'We were able to connect to the database server (which means your username and password is okay) but not able to select the %s database.' ), + '<code>' . htmlspecialchars( $db, ENT_QUOTES ) . '</code>' + ) . "</p>\n"; + + $message .= "<ul>\n"; + $message .= '<li>' . __( 'Are you sure it exists?' ) . "</li>\n"; + + $message .= '<li>' . sprintf( + /* translators: 1: Database user, 2: Database name. */ + __( 'Does the user %1$s have permission to use the %2$s database?' ), + '<code>' . htmlspecialchars( $this->dbuser, ENT_QUOTES ) . '</code>', + '<code>' . htmlspecialchars( $db, ENT_QUOTES ) . '</code>' + ) . "</li>\n"; + + $message .= '<li>' . sprintf( + /* translators: %s: Database name. */ + __( 'On some systems the name of your database is prefixed with your username, so it would be like <code>username_%1$s</code>. Could that be the problem?' ), + htmlspecialchars( $db, ENT_QUOTES ) + ) . "</li>\n"; + + $message .= "</ul>\n"; + + $message .= '<p>' . sprintf( + /* translators: %s: Support forums URL. */ + __( 'If you don’t know how to set up a database you should <strong>contact your host</strong>. If all else fails you may find help at the <a href="%s">WordPress Support Forums</a>.' ), + __( 'https://wordpress.org/support/forums/' ) + ) . "</p>\n"; + + $this->bail( $message, 'db_select_fail' ); + } + } + } + + /** + * Do not use, deprecated. + * + * Use esc_sql() or wpdb::prepare() instead. + * + * @since 2.8.0 + * @deprecated 3.6.0 Use wpdb::prepare() + * @see wpdb::prepare + * @see esc_sql() + * + * @param string $string + * @return string + */ + function _weak_escape( $string ) { + if ( func_num_args() === 1 && function_exists( '_deprecated_function' ) ) { + _deprecated_function( __METHOD__, '3.6.0', 'wpdb::prepare() or esc_sql()' ); + } + return addslashes( $string ); + } + + /** + * Real escape, using mysqli_real_escape_string() or mysql_real_escape_string() + * + * @see mysqli_real_escape_string() + * @see mysql_real_escape_string() + * @since 2.8.0 + * + * @param string $string to escape + * @return string escaped + */ + function _real_escape( $string ) { + if ( $this->dbh ) { + if ( $this->use_mysqli ) { + $escaped = mysqli_real_escape_string( $this->dbh, $string ); + } else { + $escaped = mysql_real_escape_string( $string, $this->dbh ); + } + } else { + $class = get_class( $this ); + if ( function_exists( '__' ) ) { + /* translators: %s: Database access abstraction class, usually wpdb or a class extending wpdb. */ + _doing_it_wrong( $class, sprintf( __( '%s must set a database connection for use with escaping.' ), $class ), '3.6.0' ); + } else { + _doing_it_wrong( $class, sprintf( '%s must set a database connection for use with escaping.', $class ), '3.6.0' ); + } + $escaped = addslashes( $string ); + } + + return $this->add_placeholder_escape( $escaped ); + } + + /** + * Escape data. Works on arrays. + * + * @uses wpdb::_real_escape() + * @since 2.8.0 + * + * @param string|array $data + * @return string|array escaped + */ + public function _escape( $data ) { + if ( is_array( $data ) ) { + foreach ( $data as $k => $v ) { + if ( is_array( $v ) ) { + $data[ $k ] = $this->_escape( $v ); + } else { + $data[ $k ] = $this->_real_escape( $v ); + } + } + } else { + $data = $this->_real_escape( $data ); + } + + return $data; + } + + /** + * Do not use, deprecated. + * + * Use esc_sql() or wpdb::prepare() instead. + * + * @since 0.71 + * @deprecated 3.6.0 Use wpdb::prepare() + * @see wpdb::prepare() + * @see esc_sql() + * + * @param mixed $data + * @return mixed + */ + public function escape( $data ) { + if ( func_num_args() === 1 && function_exists( '_deprecated_function' ) ) { + _deprecated_function( __METHOD__, '3.6.0', 'wpdb::prepare() or esc_sql()' ); + } + if ( is_array( $data ) ) { + foreach ( $data as $k => $v ) { + if ( is_array( $v ) ) { + $data[ $k ] = $this->escape( $v, 'recursive' ); + } else { + $data[ $k ] = $this->_weak_escape( $v, 'internal' ); + } + } + } else { + $data = $this->_weak_escape( $data, 'internal' ); + } + + return $data; + } + + /** + * Escapes content by reference for insertion into the database, for security + * + * @uses wpdb::_real_escape() + * + * @since 2.3.0 + * + * @param string $string to escape + */ + public function escape_by_ref( &$string ) { + if ( ! is_float( $string ) ) { + $string = $this->_real_escape( $string ); + } + } + + /** + * Prepares a SQL query for safe execution. Uses sprintf()-like syntax. + * + * The following placeholders can be used in the query string: + * %d (integer) + * %f (float) + * %s (string) + * + * All placeholders MUST be left unquoted in the query string. A corresponding argument + * MUST be passed for each placeholder. + * + * For compatibility with old behavior, numbered or formatted string placeholders (eg, %1$s, %5s) + * will not have quotes added by this function, so should be passed with appropriate quotes around + * them for your usage. + * + * Literal percentage signs (%) in the query string must be written as %%. Percentage wildcards (for example, + * to use in LIKE syntax) must be passed via a substitution argument containing the complete LIKE string, these + * cannot be inserted directly in the query string. Also see wpdb::esc_like(). + * + * Arguments may be passed as individual arguments to the method, or as a single array containing + * all arguments. A combination of the two is not supported. + * + * Examples: + * $wpdb->prepare( "SELECT * FROM `table` WHERE `column` = %s AND `field` = %d OR `other_field` LIKE %s", array( 'foo', 1337, '%bar' ) ); + * $wpdb->prepare( "SELECT DATE_FORMAT(`field`, '%%c') FROM `table` WHERE `column` = %s", 'fo |