WeizenSpr.eu

Php
/ **
* Classe DB WordPress
*
* Code original (@ link http://php.justinvincent.com Justin Vincent (justin@visunet.ie))
*
Paquet WordPress @ *
Sous-paquetage de base de données * @
* @ Since 0,71
* /

/ **
* @ Since 0,71
* /
'EZSQL_VERSION' , 'WP1.25' ) ; define ('EZSQL_VERSION', 'WP1.25');

/ **
* @ Since 0,71
* /
'OBJECT' , 'OBJECT' , true ) ; define ('Objet', 'objet', true);

/ **
* @ Since (@ internes version inconnue))
* /
'OBJECT_K' , 'OBJECT_K' , false ) ; define ('OBJECT_K', 'OBJECT_K', false);

/ **
* @ Since 0,71
* /
'ARRAY_A' , 'ARRAY_A' , false ) ; define ('ARRAY_A', 'ARRAY_A', false);

/ **
* @ Since 0,71
* /
'ARRAY_N' , 'ARRAY_N' , false ) ; define ('ARRAY_N', 'ARRAY_N', false);

/ **
* Base de données WordPress Abstraction Access Object
*
* Il est possible de remplacer cette classe avec vos propres
* En définissant la variable $ wpdb mondial dans wp-content/db.php
* Fichier avec votre classe. Vous pouvez nommer ce wpdb puis, depuis
* Ce fichier ne sera pas inclus, si le fichier est d'autres
* Disponible.
*
Lien http://codex.wordpress.org/Function_Reference/wpdb_Class @ *
*
Paquet WordPress @ *
Sous-paquetage de base de données * @
* @ Since 0,71
* @ Final
* /
wpdb classe (

/ **
SQL * Que ce soit pour afficher / erreurs DB
*
* @ Since 0,71
* @ Accès privé
* @ Var bool
* /
= false ; var $ show_errors = false;

/ **
* Que ce soit pour supprimer les erreurs au cours de la DB d'amorçage.
*
* @ Accès privé
* @ Since (@ internes version inconnue))
* @ Var bool
* /
= false ; var $ suppress_errors = false;

/ **
* La dernière erreur lors de la requête.
*
* @ Since (@ internes version inconnue))
* @ Var string
* /
= '' ; $ Last_Error var ='';

/ **
* Montant de requêtes effectuées
*
@ * Depuis 1.2.0
* @ Accès privé
Var int @ *
* /
= 0 ; var $ num_queries = 0;

/ **
* Résultats enregistrés de la dernière requête faite
*
* @ Depuis 1.2.0
* @ Accès privé
* @ Var array
* /
; var $ last_query;

/ **
* Info sauvegardées sur la table la colonne
*
* @ Depuis 1.2.0
* @ Accès privé
* @ Var array
* /
; var $ col_info;

/ **
* Les requêtes enregistrées qui ont été exécutés
*
* @ Depuis 1.5.0
* @ Accès privé
* @ Var array
* /
; var $ requêtes;

/ **
* Préfixe de table WordPress
*
* Vous pouvez définir cette d'avoir plusieurs installations de WordPress
* Dans une base de données unique. La deuxième raison est possible pour les
* Les précautions de sécurité.
*
* @ Since 0,71
* @ Accès privé
* @ Var string
* /
= '' ; = $ Var prefix'';

/ **
* Si les requêtes de bases de données sont prêtes à commencer à exécuter.
*
* @ Depuis 2.5.0
* @ Accès privé
* @ Var bool
* /
= false ; var $ prête = false;

/ **
WordPress Posts table *
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ posts;

/ **
* WordPress utilisateur table
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ utilisateurs;

/ **
* WordPress Catégories table
*
* @ Depuis 1.5.0
@ Accessibles au public *
* @ Var string
* /
; var $ catégories;

/ **
* WordPress Post à la catégorie table
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ post2cat;

/ **
* WordPress Commentaires table
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ commentaires;

/ **
WordPress liens de la table *
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ liens;

/ **
WordPress Options table *
*
* @ Depuis 1.5.0
* @ Access public
* @ Var string
* /
; var $ options;

/ **
* WordPress Post métadonnées de la table
*
* @ Since (@ internes version inconnue))
* @ Access public
* @ Var string
* /
; var $ postmeta;

/ **
* WordPress utilisateur métadonnées de la table
*
* @ Depuis 2.3.0
* @ Access public
* @ Var string
* /
; var $ usermeta;

/ **
* WordPress Conditions table
*
* @ Depuis 2.3.0
* @ Access public
* @ Var string
* /
; var $ termes;

/ **
* WordPress terme de taxonomie table
*
* @ Depuis 2.3.0
* @ Access public
* @ Var string
* /
; var $ term_taxonomy;

/ **
* WordPress terme les relations entre tables
*
* @ Depuis 2.3.0
* @ Access public
* @ Var string
* /
; var $ term_relationships;

/ **
* Liste des tableaux WordPress
*
* @ Since (@ internes version inconnue))
* @ Accès privé
* @ Var array
* /
var $tables = array ( 'users' , 'usermeta' , 'posts' , 'categories' , 'post2cat' , 'comments' , 'links' , 'link2cat' , 'options' ,
'postmeta' , 'terms' , 'term_taxonomy' , 'term_relationships' ) ;

/ **
* Database table columns charset
*
* @since 2.2.0
* @access public
* @var string
*/
var $charset ;

/ **
* Database table columns collate
*
* @since 2.2.0
* @access public
* @var string
*/
var $collate ;

/ **
* Connects to the database server and selects a database
*
* PHP4 compatibility layer for calling the PHP5 constructor.
*
* @uses wpdb::__construct() Passes parameters and returns result
* @since 0.71
*
* @param string $dbuser MySQL database user
* @param string $dbpassword MySQL database password
* @param string $dbname MySQL database name
* @param string $dbhost MySQL database host
*/
function wpdb ( $dbuser , $dbpassword , $dbname , $dbhost ) {
return $this -> __construct ( $dbuser , $dbpassword , $dbname , $dbhost ) ;
}

/ **
* 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.
*
* @since 2.0.8
*
* @param string $dbuser MySQL database user
* @param string $dbpassword MySQL database password
* @param string $dbname MySQL database name
* @param string $dbhost MySQL database host
*/
function __construct ( $dbuser , $dbpassword , $dbname , $dbhost ) {
register_shutdown_function ( array ( & $this , "__destruct" ) ) ;

if ( defined ( 'WP_DEBUG' ) and WP_DEBUG == true )
$this -> show_errors ( ) ;

// which database to select
$selectedName = '' ;
$sync_selectedName = '' ;

// get array values
$dbuser = unserialize ( $dbuser ) ;
$dbpassword = unserialize ( $dbpassword ) ;
$dbname = unserialize ( $dbname ) ;
$dbhost = unserialize ( $dbhost ) ;

$dbssl = null ;
if ( defined ( 'DB_SSL' ) ) {
$dbssl = unserialize ( DB_SSL ) ;
}
$dbtimeout = null ;
if ( defined ( 'DB_TIMEOUT' ) ) {
$dbtimeout = unserialize ( DB_TIMEOUT ) ;
}
$dbcharset = null ;
if ( defined ( 'DB_CHARSET' ) ) {
$dbcharset = unserialize ( DB_CHARSET ) ;
}
$dbcollate = null ;
if ( defined ( 'DB_COLLATE' ) ) {
$dbcollate = unserialize ( DB_COLLATE ) ;
}

$this -> dbh = false ;
$this -> sync_dbh = false ;

$this -> maindb = - 1 ;
$this -> syncdb = - 1 ;

$this -> transcount = 0 ;
$this -> sync_transcount = 0 ;
$this -> insync = true ;
$this -> syncing = false ;

$this -> synclevel = 'none' ;
if ( defined ( 'SYNC_LEVEL' ) ) {
$this -> synclevel = SYNC_LEVEL ;
}

$this -> ignoreresult = 'true' ;
if ( defined ( 'SYNC_IGNORE_RESULT' ) ) {
$this -> ignoreresult = SYNC_IGNORE_RESULT ;
}

$this -> translog = 'translog' ;

// get number of available complete config sets
$minCount = count ( $dbuser ) ;
if ( count ( $dbpassword ) < $minCount ) { $minCount = count ( $dbpassword ) ; }
if ( count ( $dbname ) < $minCount ) { $minCount = count ( $dbname ) ; }
if ( count ( $dbhost ) < $minCount ) { $minCount = count ( $dbhost ) ; }
if ( $dbssl != null ) { if ( count ( $dbssl ) < $minCount ) { $minCount = count ( $dbssl ) ; } }
if ( $dbtimeout != null ) { if ( count ( $dbtimeout ) < $minCount ) { $minCount = count ( $dbtimeout ) ; } }
if ( $dbcharset != null ) { if ( count ( $dbcharset ) < $minCount ) { $minCount = count ( $dbcharset ) ; } }
if ( $dbcollate != null ) { if ( count ( $dbcollate ) < $minCount ) { $minCount = count ( $dbcollate ) ; } }

// find first working config set
if ( $minCount > 0 ) {
$index = 0 ;

// allow manual selection of used config set
$dbid = null ;
if ( ( defined ( 'ENABLE_DB_SELECT' ) ) && ( ENABLE_DB_SELECT == 'true' ) ) {
if ( isset ( $_GET [ 'dbid' ] ) ) {
$dbid = $_GET [ 'dbid' ] ;
} else {
if ( isset ( $_COOKIE [ 'dbid' ] ) ) {
$dbid = $_COOKIE [ 'dbid' ] ;
}
}

if ( $dbid != null ) {
if ( isset ( $_SERVER [ 'HTTP_HOST' ] ) ) {
$domain = $_SERVER [ 'HTTP_HOST' ] ;
} else {
$domain = $_SERVER [ 'SERVER_NAME' ] ;
}

if ( ( ! empty ( $dbid ) ) && ( is_numeric ( $dbid ) ) ) {
$dbid = intval ( $dbid ) ;

if ( $minCount > $dbid ) {
$index = $dbid ;
$minCount = $dbid + 1 ;
}

setcookie ( 'dbid' , $dbid , time ( ) + 300000 , '/' , $domain ) ;
} else {
setcookie ( 'dbid' , '' , time ( ) , '/' , $domain ) ;
}
}
}

if ( ( $this -> synclevel != 'none' ) && ( ( $dbid == null ) || ( $this -> synclevel != 'sync' ) ) ) {
if ( ( defined ( 'SYNC_BACKUP_DB' ) ) && ( SYNC_BACKUP_DB > 0 ) ) {
$this -> syncdb = SYNC_BACKUP_DB ;

if ( defined ( 'SYNC_TRANSLOG_TABLE' ) ) {
$sync_translog_table = SYNC_TRANSLOG_TABLE ;
if ( ! empty ( $sync_translog_table ) ) {
$this -> translog = $sync_translog_table ;
}
}
}
}

do {
$selectedName = $dbname [ $index ] ;

if ( $dbtimeout != null ) {
ini_set ( 'mysql.connect_timeout' , $dbtimeout [ $index ] ) ; // set connect timeout
}

if ( ( $dbssl != null ) && ( $dbssl [ $index ] == 'true' ) ) {
$this -> dbh = @ mysql_connect ( $dbhost [ $index ] , $dbuser [ $index ] , $dbpassword [ $index ] , true , CLIENT_SSL ) ;
} else {
$this -> dbh = @ mysql_connect ( $dbhost [ $index ] , $dbuser [ $index ] , $dbpassword [ $index ] , true ) ;
}

if ( $dbcharset != null ) {
$this -> charset = $dbcharset [ $index ] ;
}
if ( $dbcollate != null ) {
$this -> collate = $dbcollate [ $index ] ;
}

$index ++;
} while ( ( ! $this -> dbh ) && ( $index < $minCount ) ) ;

// set currently selected db index
if ( $this -> dbh != false ) {
$this -> maindb = $index - 1 ;
}

// open sync database
if ( $this -> synclevel != 'none' ) {
if ( ( $this -> maindb == 0 ) && ( $this -> syncdb > 0 ) && ( $this -> syncdb < $minCount ) ) {
$sync_selectedName = $dbname [ $this -> syncdb ] ;

if ( $dbtimeout != null ) {
ini_set ( 'mysql.connect_timeout' , $dbtimeout [ $this -> syncdb ] ) ; // set connect timeout
}

if ( ( $dbssl != null ) && ( $dbssl [ $this -> syncdb ] == 'true' ) ) {
$this -> sync_dbh = @ mysql_connect ( $dbhost [ $this -> syncdb ] , $dbuser [ $this -> syncdb ] , $dbpassword [ $this -> syncdb ] , true , CLIENT_SSL ) ;
} else {
$this -> sync_dbh = @ mysql_connect ( $dbhost [ $this -> syncdb ] , $dbuser [ $this -> syncdb ] , $dbpassword [ $this -> syncdb ] , true ) ;
}

if ( $dbcharset != null ) {
$this -> sync_charset = $dbcharset [ $this -> syncdb ] ;
}
if ( $dbcollate != null ) {
$this -> sync_collate = $dbcollate [ $this -> syncdb ] ;
}
}
}
}

if ( ! $this -> dbh ) {
$this -> bail ( sprintf ( /*WP_I18N_DB_CONN_ERROR*/ '
<h1>Fehler beim Aufbau einer Datenbank-Verbindung.</h1><p>Das bedeutet, dass entweder Benutzername/Passwort in Ihrer <code>wp-config.php</code> falsch sind, oder dass der Datenbanksserver <code>$dbhost</code> nicht erreichbar ist.</p><ul>  <li>Sind Sie sicher, dass Ihr Benutzername und Ihr Passwort korrekt sind?</li>  <li>Sind Sie sicher, dass Sie den richtigen Hostnamen eingegeben haben?</li>    <li>Sind Sie sicher, dass der Datenbankserver läuft und erreichbar ist?</li></ul><p>Falls Sie nicht wissen, was die obigen Begriffe bedeuten, sollten Sie sich an Ihren Hoster wenden. Falls Sie sonst Hilfe benötigen, wenden Sie sich bitte an das <a href=\'http://wordpress.org/support/\'>WordPress-Supportforum</a>.</p>
' /*/WP_I18N_DB_CONN_ERROR*/ , $dbhost ) ) ;
return ;
}

$this -> ready = true ;

// set main db and create translog table if needed
if ( $this -> dbh != false ) {
if ( $this -> has_cap ( 'collation' , $this -> dbh ) ) {
$collation_query = '' ;
if ( ! empty ( $this -> charset ) ) {
$collation_query = "SET NAMES ' {$this->charset} '" ;
if ( ! empty ( $this -> collate ) )
$collation_query .= " COLLATE ' {$this->collate} '" ;
}

if ( ! empty ( $collation_query ) )
$this -> query ( $collation_query , $this -> dbh , false ) ;
}
$this -> select ( $selectedName , $this -> dbh ) ;

if ( $this -> synclevel != 'none' ) {
if ( $this -> syncdb > 0 ) {
$this -> query ( 'CREATE TABLE IF NOT EXISTS ' . $this -> translog . ' (id INT NOT NULL AUTO_INCREMENT, time INT NOT NULL, query LONGTEXT NOT NULL, affected INT NOT NULL DEFAULT 0, executed BOOL NOT NULL DEFAULT 0, done BOOL NOT NULL DEFAULT 0, PRIMARY KEY (id));' , $this -> dbh , false ) ;
}
}
}

// set sync db and create translog table if needed
if ( $this -> sync_dbh != false ) {
if ( $this -> has_cap ( 'collation' , $this -> sync_dbh ) ) {
$collation_query = '' ;
if ( ! empty ( $this -> sync_charset ) ) {
$collation_query = "SET NAMES ' {$this->sync_charset} '" ;
if ( ! empty ( $this -> sync_collate ) )
$collation_query .= " COLLATE ' {$this->sync_collate} '" ;
}

if ( ! empty ( $collation_query ) )
$this -> query ( $collation_query , $this -> sync_dbh , false ) ;

}
$this -> select ( $sync_selectedName , $this -> sync_dbh ) ;

if ( $this -> synclevel == 'sync' ) {
if ( $this -> syncdb > 0 ) {
$this -> query ( 'CREATE TABLE IF NOT EXISTS ' . $this -> translog . ' (id INT NOT NULL AUTO_INCREMENT, time INT NOT NULL, query LONGTEXT NOT NULL, affected INT NOT NULL DEFAULT 0, executed BOOL NOT NULL DEFAULT 0, done BOOL NOT NULL DEFAULT 0, PRIMARY KEY (id));' , $this -> sync_dbh , false ) ;
}
}
}

// initiate synchronization
if ( $this -> synclevel != 'none' ) {
if ( ( $this -> dbh != false ) && ( $this -> sync_dbh != false ) ) {
$dbtrans = $this -> get_results ( 'SELECT * FROM ' . $this -> translog . ' ORDER BY id;' , ARRAY_A , $this -> dbh , false ) ;
$this -> transcount = count ( $dbtrans ) ;

if ( $this -> synclevel == 'sync' ) {
$sync_dbtrans = $this -> get_results ( 'SELECT * FROM ' . $this -> translog . ' ORDER BY id;' , ARRAY_A , $this -> sync_dbh , false ) ;
$this -> sync_transcount = count ( $sync_dbtrans ) ;
}

// check if databases are in sync
$this -> insync = ( ( $this -> transcount == 0 ) && ( $this -> sync_transcount == 0 ) ) ;
if ( ! $this -> insync ) {
$syncmain = false ;
$syncsync = false ;

// reset result arrays
if ( $this -> transcount > 0 ) {
reset ( $dbtrans ) ;
$syncmain = true ;
}
if ( $this -> sync_transcount > 0 ) {
reset ( $sync_transcount ) ;
$syncsync = true ;
}

// start sync status
$this -> syncing = true ;

do {
$selection = null ;
$trans = null ;
$sync_trans = null ;

if ( $this -> transcount > 0 ) {
$trans = each ( $dbtrans ) ;
$selection = $trans [ 'value' ] ;
}
if ( $this -> sync_transcount > 0 ) {
$sync_trans = each ( $sync_dbtrans ) ;
if ( $selection == null ) {
$selection = $sync_trans [ 'value' ] ;
} else {
if ( $sync_trans [ 'value' ] [ 'time' ] < $trans [ 'value' ] [ 'time' ] ) {
$selection = $sync_trans [ 'value' ] ;
prev ( $dbtrans ) ;
} else {
prev ( $sync_dbtrans ) ;
}
}
}

$affected = - 1 ;
if ( ! $selection [ 'executed' ] ) {
if ( $selection == $trans [ 'value' ] ) {
$affected = $this -> query ( $selection [ 'query' ] , $this -> sync_dbh , false ) ;
} else {
$affected = $this -> query ( $selection [ 'query' ] , $this -> dbh , false ) ;
}

// set $updatedentry
$updatedentry = array ( ) ;
$updatedentry [ 'id' ] = $selection [ 'id' ] ;

// update translog table
$newdata = array ( ) ;
$newdata [ 'done' ] = ( $affected == $selection [ 'affected' ] ) ; // query has been successful
if ( ! $newdata [ 'done' ] ) {
$newdata [ 'done' ] = ( $this -> ignoreresult == 'true' ) ;
}
$newdata [ 'executed' ] = true ; // query has been executed

// update translog table
if ( $selection == $trans [ 'value' ] ) {
$this -> update ( $this -> translog , $newdata , $updatedentry , $this -> dbh , false ) ;
} else {
$this -> update ( $this -> translog , $newdata , $updatedentry , $this -> sync_dbh , false ) ;
}

if ( $newdata [ 'done' ] ) {
if ( $selection == $trans [ 'value' ] ) {
$this -> transcount --;
} else {
$this -> sync_transcount --;
}
}
}

// exit if something went wrong
if ( ( $selection [ 'executed' ] ) || ( ( $affected != $selection [ 'affected' ] ) && ( $this -> ignoreresult != 'true' ) ) ) {
break ;
}

// do final check
$this -> insync = ( ( $this -> transcount == 0 ) && ( $this -> sync_transcount == 0 ) ) ;
} while ( ! $this -> insync ) ;

// clear translog tables
if ( $this -> insync ) {
if ( $syncmain ) {
foreach ( $dbtrans as $transitem ) {
$this -> query ( 'DELETE FROM ' . $this -> translog . ' WHERE id = ' . $transitem [ 'id' ] . ';' , $this -> dbh , false ) ;
}
}
if ( $syncmain ) {
foreach ( $sync_dbtrans as $transitem ) {
$this -> query ( 'DELETE FROM ' . $this -> translog . ' WHERE id = ' . $transitem [ 'id' ] . ';' , $this -> sync_dbh , false ) ;
}
}
}

// stop sync statis
$this -> syncing = false ;
}
}
}
}

/ **
* PHP5 style destructor and will run when database object is destroyed.
*
* @since 2.0.8
*
* @return bool Always true
*/
function __destruct ( ) {
/*
if ($this->dbh != false) {
mysql_close($this->dbh);
}

if ($this->sync_dbh != false) {
mysql_close($this->sync_dbh);
}
*/

return true ;
}

/ **
* Sets the table prefix for the WordPress tables.
*
* Also allows for the CUSTOM_USER_TABLE and CUSTOM_USER_META_TABLE to
* override the WordPress users and usersmeta tables.
*
* @since 2.5.0
*
* @param string $prefix Alphanumeric name for the new prefix.
* @return string Old prefix
*/
function set_prefix ( $prefix ) {

if ( preg_match ( '|[^a-z0-9_]|i' , $prefix ) )
return new WP_Error ( 'invalid_db_prefix' , /*WP_I18N_DB_BAD_PREFIX*/ 'Ungültiges Tabellenpräfix' /*/WP_I18N_DB_BAD_PREFIX*/ ) ;

$old_prefix = $this -> prefix ;
$this -> prefix = $prefix ;

foreach ( ( array ) $this -> tables as $table )
$this -> $table = $this -> prefix . $table ;

if ( defined ( 'CUSTOM_USER_TABLE' ) )
$this -> users = CUSTOM_USER_TABLE ;

if ( defined ( 'CUSTOM_USER_META_TABLE' ) )
$this -> usermeta = CUSTOM_USER_META_TABLE ;

return $old_prefix ;
}

/ **
* 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
* @return null Always null.
*/
function select ( $db , $dblink = null ) {
if ( $dblink == null ) {
$dblink = $this -> dbh ;
}
if ( !@ mysql_select_db ( $db , $dblink ) ) {
$this -> ready = false ;
$this -> bail ( sprintf ( /*WP_I18N_DB_SELECT_DB*/ '
<h1>Auf die Datenbank kann nicht zugegriffen werden.</h1><p>Es konnte zwar eine Verbindung zum Datenbankserver aufgebaut werden, was bedeutet, dass Ihr Benutzername und Ihr Passwort korrekt sind. Allerdings konnte nicht auf die Datenbank <code>%1$s</code> zugegriffen werden.</p><ul><li>Sind sie sicher, dass Sie existiert?</li><li>Auf manchen Systemen hat die Datenbank Ihren Benutzernamen als Präfix, dh der Name wäre dann <code>benutzername_%1$s</code>. Könnte das das Problem sein?</li></ul><p>Falls Sie nicht wissen, wie man eine Datenbank einrichtet, sollten Sie sich an Ihren Hoster wenden. Falls es partout nicht klappt, wenden Sie sich bitte an das <a href=\'http://wordpress.org/support/\'>WordPress-Supportforum</a>.</p>' /*/WP_I18N_DB_SELECT_DB*/ , $db , DB_USER ) ) ;
return ;
}
}

/ **
* Escapes content for insertion into the database, for security
*
* @since 0.71
*
* @param string $string
* @return string query safe string
*/
function escape ( $string ) {
return addslashes ( $string ) ;
// Disable rest for now, causing problems
/*
if( !$this->dbh || version_compare( phpversion(), '4.3.0' ) == '-1' )
return mysql_escape_string( $string );
else
return mysql_real_escape_string( $string, $this->dbh );
*/
}

/ **
* Escapes content by reference for insertion into the database, for security
*
* @since 2.3.0
*
* @param string $s
*/
function escape_by_ref ( & $s ) {
$s = $this -> escape ( $s ) ;
}

/ **
* Prepares a SQL query for safe use, using sprintf() syntax.
*
* @link http://php.net/sprintf See for syntax to use for query string.
* @since 2.3.0
*
* @param null|string $args If string, first parameter must be query statement
* @param mixed $args,... If additional parameters, they will be set inserted into the query.
* @return null|string Sanitized query string
*/
function prepare ( $args = null ) {
if ( is_null ( $args ) )
return ;
$args = func_get_args ( ) ;
$query = array_shift ( $args ) ;
$query = str_replace ( "' %s '" , '%s' , $query ) ; // in case someone mistakenly already singlequoted it
$query = str_replace ( '"%s"' , '%s' , $query ) ; // doublequote unquoting
$query = str_replace ( '%s' , "' %s '" , $query ) ; // quote the strings
array_walk ( $args , array ( & $this , 'escape_by_ref' ) ) ;
return @ vsprintf ( $query , $args ) ;
}

/ **
* Print SQL/DB error.
*
* @since 0.71
* @global array $EZSQL_ERROR Stores error information of query and error string
*
* @param string $str The error to display
* @return bool False if the showing of errors is disabled.
*/
function print_error ( $str = '' ) {
global $EZSQL_ERROR ;

if ( ! $str ) $str = mysql_error ( $this -> dbh ) ;
$EZSQL_ERROR [ ] = array ( 'query' => $this -> last_query , 'error_str' => $str ) ;

if ( $this -> suppress_errors )
return false ;

if ( $caller = $this -> get_caller ( ) )
$error_str = sprintf ( /*WP_I18N_DB_QUERY_ERROR_FULL*/ 'WordPress-Datenbankfehler %1$s für die Abfrage %2$s in %3$s' /*/WP_I18N_DB_QUERY_ERROR_FULL*/ , $str , $this -> last_query , $caller ) ;
else
$error_str = sprintf ( /*WP_I18N_DB_QUERY_ERROR*/ 'WordPress-Datenbankfehler %1$s für die Abfrage %2$s' /*/WP_I18N_DB_QUERY_ERROR*/ , $str , $this -> last_query ) ;

$log_error = true ;
if ( ! function_exists ( 'error_log' ) )
$log_error = false ;

$log_file = @ ini_get ( 'error_log' ) ;
if ( ! empty ( $log_file ) && ( 'syslog' != $log_file ) && !@ is_writable ( $log_file ) )
$log_error = false ;

if ( $log_error )
@ error_log ( $error_str , 0 ) ;

// Is error output turned on or not..
if ( ! $this -> show_errors )
return false ;

$str = htmlspecialchars ( $str , ENT_QUOTES ) ;
$query = htmlspecialchars ( $this -> last_query , ENT_QUOTES ) ;

// If there is an error then take note of it
print "<div id='error'>
<p class='wpdberror'><strong>WordPress database error:</strong> [ $str ]<br />
<code> $query </code></p>
</div>" ;
}

/ **
* Enables showing of database errors.
*
* This function should be used only to enable showing of errors.
* wpdb::hide_errors() should be used instead for hiding of errors. However,
* this function can be used to enable and disable showing of database
* errors.
*
* @since 0.71
*
* @param bool $show Whether to show or hide errors
* @return bool Old value for showing errors.
*/
function show_errors ( $show = true ) {
$errors = $this -> show_errors ;
$this -> show_errors = $show ;
return $errors ;
}

/ **
* Disables showing of database errors.
*
* @since 0.71
*
* @return bool Whether showing of errors was active or not
*/
function hide_errors ( ) {
$show = $this -> show_errors ;
$this -> show_errors = false ;
return $show ;
}

/ **
* Whether to suppress database errors.
*
* @param unknown_type $suppress
* @return unknown
*/
function suppress_errors ( $suppress = true ) {
$errors = $this -> suppress_errors ;
$this -> suppress_errors = $suppress ;
return $errors ;
}

/ **
* Kill cached query results.
*
* @since 0.71
*/
function flush ( ) {
$this -> last_result = array ( ) ;
$this -> col_info = null ;
$this -> last_query = null ;
}

/ **
* Perform a MySQL database query, using current database connection.
*
* More information can be found on the codex page.
*
* @since 0.71
*
* @param string $query
* @return unknown
*/
function query ( $query , $dblink = null , $sync = true ) {
if ( $dblink == null ) {
$dblink = $this -> dbh ;
}

if ( ! $this -> ready )
return false ;

// filter the query, if filters are available
// NOTE: 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 , $dblink , $sync \" )" ;

// Keep track of the last query for debug..
$this -> last_query = $query ;

// Perform the query via std mysql_query function..
if ( defined ( 'SAVEQUERIES' ) && SAVEQUERIES )
$this -> timer_start ( ) ;

// check if execution is allowed
$execute = ( ! preg_match ( "/^ \\ s*(alter|create|delete|drop|insert|replace|update) /i" , $query ) ) ;
if ( ! $execute ) {
$execute = ( ( $this -> synclevel == 'sync' ) || ( $this -> maindb == 0 ) ) ;
if ( ! $execute ) {
$execute = ( ( $this -> synclevel != 'none' ) && ( $this -> syncing ) ) ;
}
}
if ( $execute ) {
$this -> result = @ mysql_query ( $query , $dblink ) ;
}
++ $this -> num_queries ;

if ( defined ( 'SAVEQUERIES' ) && SAVEQUERIES )
$this -> queries [ ] = array ( $query , $this -> timer_stop ( ) , $this -> get_caller ( ) ) ;

// If there is an error then take note of it..
if ( $this -> last_error = mysql_error ( $dblink ) ) {
$this -> print_error ( ) ;
return false ;
}

if ( preg_match ( "/^ \\ s*(alter|create|delete|drop|insert|merge|replace|truncate|update) /i" , $query ) ) {
$this -> rows_affected = mysql_affected_rows ( $dblink ) ;
// Take note of the insert_id
if ( preg_match ( "/^ \\ s*(insert|replace) /i" , $query ) ) {
$this -> insert_id = mysql_insert_id ( $dblink ) ;
}
// Return number of rows affected
$return_val = $this -> rows_affected ;
} else {
$i = 0 ;
while ( $i < @ mysql_num_fields ( $this -> result ) ) {
$this -> col_info [ $i ] = @ mysql_fetch_field ( $this -> result ) ;
$i ++;
}
$num_rows = 0 ;
while ( $row = @ mysql_fetch_object ( $this -> result ) ) {
$this -> last_result [ $num_rows ] = $row ;
$num_rows ++;
}

@ mysql_free_result ( $this -> result ) ;

// Log number of rows the query returned
$this -> num_rows = $num_rows ;

// Return number of rows selected
$return_val = $this -> num_rows ;
}

// execute the synchronization
if ( ( $this -> synclevel != 'none' ) && ( $sync == true ) && ( $this -> syncdb > 0 ) && ( $dblink == $this -> dbh ) ) {
if ( ( $this -> synclevel == 'sync' ) || ( $this -> maindb == 0 ) ) {
if ( preg_match ( "/^ \\ s*(alter|create|delete|drop|insert|merge|replace|truncate|update) /i" , $query ) ) {
if ( ( $this -> sync_dbh != false ) && ( $this -> insync ) ) {
$this -> query ( $query , $this -> sync_dbh , false ) ;
} else {
$newentry = array ( ) ;
$newentry [ 'time' ] = time ( ) ;
$newentry [ 'query' ] = $query ;
$newentry [ 'affected' ] = $return_val ;
$newentry [ 'executed' ] = false ;
$newentry [ 'done' ] = false ;
$this -> insert ( $this -> translog , $newentry , $this -> dbh , false ) ;
}
}
}
}

return $return_val ;
}

/ **
* Insert an array of data into a table.
*
* @since 2.5.0
*
* @param string $table WARNING: not sanitized!
* @param array $data Should not already be SQL-escaped
* @return mixed Results of $this->query()
*/
function insert ( $table , $data , $dblink = null , $sync = true ) {
if ( function_exists ( 'add_magic_quotes' ) ) {
$data = add_magic_quotes ( $data ) ;
} else {
$data = $this -> add_magic_quotes ( $data ) ;
}
$fields = array_keys ( $data ) ;
return $this -> query ( "INSERT INTO $table (`" . implode ( '`,`' , $fields ) . "`) VALUES ('" . implode ( "','" , $data ) . "')" , $dblink , $sync ) ;
}

/ **
* Update a row in the table with an array of data.
*
* @since 2.5.0
*
* @param string $table WARNING: not sanitized!
* @param array $data Should not already be SQL-escaped
* @param array $where A named array of WHERE column => value relationships. Multiple member pairs will be joined with ANDs. WARNING: the column names are not currently sanitized!
* @return mixed Results of $this->query()
*/
function update ( $table , $data , $where , $dblink = null , $sync = true ) {
if ( function_exists ( 'add_magic_quotes' ) ) {
$data = add_magic_quotes ( $data ) ;
} else {
$data = $this -> add_magic_quotes ( $data ) ;
}
$bits = $wheres = array ( ) ;
foreach ( ( array ) array_keys ( $data ) as $k )
$bits [ ] = "` $k ` = ' $data [ $k ]'" ;

if ( is_array ( $where ) )
foreach ( $where as $c => $v )
$wheres [ ] = " $c = '" . $this -> escape ( $v ) . "'" ;
else
return false ;

return $this -> query ( "UPDATE $table SET " . implode ( ', ' , $bits ) . ' WHERE ' . implode ( ' AND ' , $wheres ) , $dblink , $sync ) ;
}

/ **
* Retrieve one variable from the database.
*
* This combines the functionality of wpdb::get_row() and wpdb::get_col(),
* so both the column and row can be picked.
*
* It is possible to use this function without executing more queries. If
* you already made a query, you can set the $query to 'null' value and just
* retrieve either the column and row of the last query result.
*
* @since 0.71
*
* @param string $query Can be null as well, for caching
* @param int $x Column num to return
* @param int $y Row num to return
* @return mixed Database query results
*/
function get_var ( $query = null , $x = 0 , $y = 0 , $dblink = null , $sync = true ) {
$this -> func_call = " \$ db->get_var( \" $query \" , $x , $y , $dblink , $sync )" ;
if ( $query )
$this -> query ( $query , $dblink , $sync ) ;

// Extract var out of cached results based x,y vals
if ( ! empty ( $this -> last_result [ $y ] ) ) {
$values = array_values ( get_object_vars ( $this -> last_result [ $y ] ) ) ;
}

// If there is a value return it else return null
return ( isset ( $values [ $x ] ) && $values [ $x ] !== '' ) ? $values [ $x ] : null ;
}

/ **
* Retrieve one row from the database.
*
* @since 0.71
*
* @param string $query SQL query
* @param string $output ARRAY_A | ARRAY_N | OBJECT
* @param int $y Row num to return
* @return mixed Database query results
*/
function get_row ( $query = null , $output = OBJECT , $y = 0 , $dblink = null , $sync = true ) {
$this -> func_call = " \$ db->get_row( \" $query \" , $output , $y , $dblink , $sync )" ;
if ( $query )
$this -> query ( $query , $dblink , $sync ) ;
else
return null ;

if ( ! isset ( $this -> last_result [ $y ] ) )
return null ;

if ( $output == OBJECT ) {
return $this -> last_result [ $y ] ? $this -> last_result [ $y ] : null ;
} elseif ( $output == ARRAY_A ) {
return $this -> last_result [ $y ] ? get_object_vars ( $this -> last_result [ $y ] ) : null ;
} elseif ( $output == ARRAY_N ) {
return $this -> last_result [ $y ] ? array_values ( get_object_vars ( $this -> last_result [ $y ] ) ) : null ;
} else {
$this -> print_error ( /*WP_I18N_DB_GETROW_ERROR*/ ' $db->get_row(string query, output type, int offset) -- Ausgabetyp muss sein: OBJECT, ARRAY_A oder ARRAY_N' /*/WP_I18N_DB_GETROW_ERROR*/ ) ;
}
}

/ **
* Retrieve one column from the database.
*
* @since 0.71
*
* @param string $query Can be null as well, for caching
* @param int $x Col num to return. Starts from 0.
* @return array Column results
*/
function get_col ( $query = null , $x = 0 , $dblink = null , $sync = true ) {
if ( $query )
$this -> query ( $query , $dblink , $sync ) ;

$new_array = array ( ) ;
// Extract the column values
for ( $i = 0 ; $i < count ( $this -> last_result ) ; $i ++ ) {
$new_array [ $i ] = $this -> get_var ( null , $x , $i ) ;
}
return $new_array ;
}

/ **
* Retrieve an entire result set from the database.
*
* @since 0.71
*
* @param string|null $query Can also be null to pull from the cache
* @param string $output ARRAY_A | ARRAY_N | OBJECT_K | OBJECT
* @return mixed Database query results
*/
function get_results ( $query = null , $output = OBJECT , $dblink = null , $sync = true ) {
$this -> func_call = " \$ db->get_results( \" $query \" , $output , $dblink , $sync )" ;

if ( $query )
$this -> query ( $query , $dblink , $sync ) ;
else
return null ;

if ( $output == OBJECT ) {
// Return an integer-keyed array of row objects
return $this -> last_result ;
} elseif ( $output == OBJECT_K ) {
// Return an array of row objects with keys from column 1
// (Duplicates are discarded)
foreach ( $this -> last_result as $row ) {
$key = array_shift ( get_object_vars ( $row ) ) ;
if ( ! isset ( $new_array [ $key ] ) )
$new_array [ $key ] = $row ;
}
return $new_array ;
} elseif ( $output == ARRAY_A || $output == ARRAY_N ) {
// Return an integer-keyed array of...
if ( $this -> last_result ) {
$i = 0 ;
foreach ( ( array ) $this -> last_result as $row ) {
if ( $output == ARRAY_N ) {
// ...integer-keyed row arrays
$new_array [ $i ] = array_values ( get_object_vars ( $row ) ) ;
} else {
// ...column name-keyed row arrays
$new_array [ $i ] = get_object_vars ( $row ) ;
}
++ $i ;
}
return $new_array ;
}
}
}

/ **
* Retrieve column metadata from the last query.
*
* @since 0.71
*
* @param string $info_type one of name, table, def, max_length, not_null, primary_key, multiple_key, unique_key, numeric, blob, type, unsigned, zerofill
* @param int $col_offset 0: col name. 1: which table the col's in. 2: col's max length. 3: if the col is numeric. 4: col's type
* @return mixed Column Results
*/
function get_col_info ( $info_type = 'name' , $col_offset = - 1 ) {
if ( $this -> col_info ) {
if ( $col_offset == - 1 ) {
$i = 0 ;
foreach ( ( array ) $this -> col_info as $col ) {
$new_array [ $i ] = $col -> { $info_type } ;
$i ++;
}
return $new_array ;
} else {
return $this -> col_info [ $col_offset ] -> { $info_type } ;
}
}
}

/ **
* Starts the timer, for debugging purposes.
*
* @since 1.5.0
*
* @return bool Always returns true
*/
function timer_start ( ) {
$mtime = microtime ( ) ;
$mtime = explode ( ' ' , $mtime ) ;
$this -> time_start = $mtime [ 1 ] + $mtime [ 0 ] ;
return true ;
}

/ **
* Stops the debugging timer.
*
* @since 1.5.0
*
* @return int Total time spent on the query, in milliseconds
*/
function timer_stop ( ) {
$mtime = microtime ( ) ;
$mtime = explode ( ' ' , $mtime ) ;
$time_end = $mtime [ 1 ] + $mtime [ 0 ] ;
$time_total = $time_end - $this -> time_start ;
return $time_total ;
}

/ **
* Wraps fatal errors in a nice header and footer and dies.
*
* @since 1.5.0
*
* @param string $message
* @return unknown
*/
function bail ( $message ) {
if ( ! $this -> show_errors ) {
if ( class_exists ( 'WP_Error' ) )
$this -> error = new WP_Error ( '500' , $message ) ;
else
$this -> error = $message ;
return false ;
}
wp_die ( $message ) ;
}

/ **
* Whether or not MySQL database is minimal required version.
*
* @since 2.5.0
* @uses $wp_version
*
* @return WP_Error
*/
function check_database_version ( $dblink = null )
{
global $wp_version ;
// Make sure the server has MySQL 4.0
if ( version_compare ( $this -> db_version ( $dblink ) , '4.0.0' , '<' ) )
return new WP_Error ( 'database_version' , sprintf ( __ ( '<strong>ERROR</strong>: WordPress %s requires MySQL 4.0.0 or higher' ) , $wp_version ) ) ;
}

/ **
* Whether of not the database version supports collation.
*
* Called when WordPress is generating the table scheme.
*
* @since 2.5.0
*
* @return bool True if collation is supported, false if version does not
*/
function supports_collation ( $dblink = null )
{
return $this -> has_cap ( 'collation' , $dblink ) ;
}

/ **
* Generic function to determine if a database supports a particular feature
* @param string $db_cap the feature
* @param false|string|resource $dbh_or_table the databaese (the current database, the database housing the specified table, or the database of the mysql resource)
* @return bool
*/
function has_cap ( $db_cap , $dblink = null ) {
$version = $this -> db_version ( $dblink ) ;

switch ( strtolower ( $db_cap ) ) :
case 'collation' : // @since 2.5.0
case 'group_concat' : // @since 2.7
case 'subqueries' : // @since 2.7
return version_compare ( $version , '4.1' , '>=' ) ;
break ;
endswitch ;

return false ;
}

/ **
* Retrieve the name of the function that called wpdb.
*
* Requires PHP 4.3 and searches up the list of functions until it reaches
* the one that would most logically had called this method.
*
* @since 2.5.0
*
* @return string The name of the calling function
*/
function get_caller ( ) {
// requires PHP 4.3+
if ( ! is_callable ( 'debug_backtrace' ) )
return '' ;

$bt = debug_backtrace ( ) ;
$caller = array ( ) ;

$bt = array_reverse ( $bt ) ;
foreach ( ( array ) $bt as $call ) {
if ( @ $call [ 'class' ] == __CLASS__ )
continue ;
$function = $call [ 'function' ] ;
if ( isset ( $call [ 'class' ] ) )
$function = $call [ 'class' ] . "-> $function " ;
$caller [ ] = $function ;
}
$caller = join ( ', ' , $caller ) ;

return $caller ;
}

/ **
* The database version number
* @return false|string false on failure, version number on success
*/
function db_version ( $dblink = null ) {
if ( $dblink == null ) {
$dblink = $this -> dbh ;
}
return preg_replace ( '/[^0-9.].*/' , '' , mysql_get_server_info ( $dblink ) ) ;
}

/ **
* Walks the array while sanitizing the contents.
* TAKEN FROM functions.php
*
* @uses $wpdb Used to sanitize values
* @since 0.71
*
* @param array $array Array to used to walk while sanitizing contents.
* @return array Sanitized $array.
*/
function add_magic_quotes ( $array ) {

foreach ( ( array ) $array as $k => $v ) {
if ( is_array ( $v ) ) {
$array [ $k ] = $this -> add_magic_quotes ( $v ) ;
} else {
$array [ $k ] = $this -> escape ( $v ) ;
}
}
return $array ;
}
}

if ( ! isset ( $wpdb ) ) {
/ **
* WordPress Database Object, if it isn't set already in wp-content/db.php
* @global object $wpdb Creates a new wpdb object based on wp-config.php Constants for the database
* @since 0.71
*/
$wpdb = new wpdb ( DB_USER , DB_PASSWORD , DB_NAME , DB_HOST ) ;
}
?>