WordPress.org

Make WordPress Core

Ticket #10918: 10918.diff

File 10918.diff, 65.8 KB (added by westi, 5 years ago)

diff file of changes

  • wp-includes/wp-db.php

     
    11<?php 
    2 /** 
    3  * WordPress DB Class 
    4  * 
    5  * Original code from {@link http://php.justinvincent.com Justin Vincent (justin@visunet.ie)} 
    6  * 
    7  * @package WordPress 
    8  * @subpackage Database 
    9  * @since 0.71 
    10  */ 
     2// help maintain backwards compatibility. 
     3if ( !defined('DB_TYPE') ) { 
     4        define('DB_TYPE', 'mysql'); 
     5} 
    116 
    12 /** 
    13  * @since 0.71 
    14  */ 
    15 define('EZSQL_VERSION', 'WP1.25'); 
     7require_once(dirname(__FILE__) . '/wp-db/' . DB_TYPE . '/' . DB_TYPE . '.php'); 
    168 
    17 /** 
    18  * @since 0.71 
    19  */ 
    20 define('OBJECT', 'OBJECT', true); 
    21  
    22 /** 
    23  * @since {@internal Version Unknown}} 
    24  */ 
    25 define('OBJECT_K', 'OBJECT_K', false); 
    26  
    27 /** 
    28  * @since 0.71 
    29  */ 
    30 define('ARRAY_A', 'ARRAY_A', false); 
    31  
    32 /** 
    33  * @since 0.71 
    34  */ 
    35 define('ARRAY_N', 'ARRAY_N', false); 
    36  
    37 /** 
    38  * WordPress Database Access Abstraction Object 
    39  * 
    40  * It is possible to replace this class with your own 
    41  * by setting the $wpdb global variable in wp-content/db.php 
    42  * file with your class. You can name it wpdb also, since 
    43  * this file will not be included, if the other file is 
    44  * available. 
    45  * 
    46  * @link http://codex.wordpress.org/Function_Reference/wpdb_Class 
    47  * 
    48  * @package WordPress 
    49  * @subpackage Database 
    50  * @since 0.71 
    51  * @final 
    52  */ 
    53 class wpdb { 
    54  
     9if ( !isset($wpdb) ) { 
    5510        /** 
    56          * Whether to show SQL/DB errors 
    57          * 
    58          * @since 0.71 
    59          * @access private 
    60          * @var bool 
    61          */ 
    62         var $show_errors = false; 
    63  
    64         /** 
    65          * Whether to suppress errors during the DB bootstrapping. 
    66          * 
    67          * @access private 
    68          * @since {@internal Version Unknown}} 
    69          * @var bool 
    70          */ 
    71         var $suppress_errors = false; 
    72  
    73         /** 
    74          * The last error during query. 
    75          * 
    76          * @since {@internal Version Unknown}} 
    77          * @var string 
    78          */ 
    79         var $last_error = ''; 
    80  
    81         /** 
    82          * Amount of queries made 
    83          * 
    84          * @since 1.2.0 
    85          * @access private 
    86          * @var int 
    87          */ 
    88         var $num_queries = 0; 
    89  
    90         /** 
    91          * Saved result of the last query made 
    92          * 
    93          * @since 1.2.0 
    94          * @access private 
    95          * @var array 
    96          */ 
    97         var $last_query; 
    98  
    99         /** 
    100          * Saved info on the table column 
    101          * 
    102          * @since 1.2.0 
    103          * @access private 
    104          * @var array 
    105          */ 
    106         var $col_info; 
    107  
    108         /** 
    109          * Saved queries that were executed 
    110          * 
    111          * @since 1.5.0 
    112          * @access private 
    113          * @var array 
    114          */ 
    115         var $queries; 
    116  
    117         /** 
    118          * WordPress table prefix 
    119          * 
    120          * You can set this to have multiple WordPress installations 
    121          * in a single database. The second reason is for possible 
    122          * security precautions. 
    123          * 
    124          * @since 0.71 
    125          * @access private 
    126          * @var string 
    127          */ 
    128         var $prefix = ''; 
    129  
    130         /** 
    131          * Whether the database queries are ready to start executing. 
    132          * 
    133          * @since 2.5.0 
    134          * @access private 
    135          * @var bool 
    136          */ 
    137         var $ready = false; 
    138  
    139         /** 
    140          * WordPress Posts table 
    141          * 
    142          * @since 1.5.0 
    143          * @access public 
    144          * @var string 
    145          */ 
    146         var $posts; 
    147  
    148         /** 
    149          * WordPress Users table 
    150          * 
    151          * @since 1.5.0 
    152          * @access public 
    153          * @var string 
    154          */ 
    155         var $users; 
    156  
    157         /** 
    158          * WordPress Categories table 
    159          * 
    160          * @since 1.5.0 
    161          * @access public 
    162          * @var string 
    163          */ 
    164         var $categories; 
    165  
    166         /** 
    167          * WordPress Post to Category table 
    168          * 
    169          * @since 1.5.0 
    170          * @access public 
    171          * @var string 
    172          */ 
    173         var $post2cat; 
    174  
    175         /** 
    176          * WordPress Comments table 
    177          * 
    178          * @since 1.5.0 
    179          * @access public 
    180          * @var string 
    181          */ 
    182         var $comments; 
    183  
    184         /** 
    185          * WordPress Links table 
    186          * 
    187          * @since 1.5.0 
    188          * @access public 
    189          * @var string 
    190          */ 
    191         var $links; 
    192  
    193         /** 
    194          * WordPress Options table 
    195          * 
    196          * @since 1.5.0 
    197          * @access public 
    198          * @var string 
    199          */ 
    200         var $options; 
    201  
    202         /** 
    203          * WordPress Post Metadata table 
    204          * 
    205          * @since {@internal Version Unknown}} 
    206          * @access public 
    207          * @var string 
    208          */ 
    209         var $postmeta; 
    210  
    211         /** 
    212          * WordPress Comment Metadata table 
    213          * 
    214          * @since 2.9 
    215          * @access public 
    216          * @var string 
    217          */ 
    218         var $commentmeta; 
    219  
    220         /** 
    221          * WordPress User Metadata table 
    222          * 
    223          * @since 2.3.0 
    224          * @access public 
    225          * @var string 
    226          */ 
    227         var $usermeta; 
    228  
    229         /** 
    230          * WordPress Terms table 
    231          * 
    232          * @since 2.3.0 
    233          * @access public 
    234          * @var string 
    235          */ 
    236         var $terms; 
    237  
    238         /** 
    239          * WordPress Term Taxonomy table 
    240          * 
    241          * @since 2.3.0 
    242          * @access public 
    243          * @var string 
    244          */ 
    245         var $term_taxonomy; 
    246  
    247         /** 
    248          * WordPress Term Relationships table 
    249          * 
    250          * @since 2.3.0 
    251          * @access public 
    252          * @var string 
    253          */ 
    254         var $term_relationships; 
    255  
    256         /** 
    257          * List of WordPress tables 
    258          * 
    259          * @since {@internal Version Unknown}} 
    260          * @access private 
    261          * @var array 
    262          */ 
    263         var $tables = array('users', 'usermeta', 'posts', 'categories', 'post2cat', 'comments', 'links', 'link2cat', 'options', 
    264                         'postmeta', 'terms', 'term_taxonomy', 'term_relationships', 'commentmeta'); 
    265  
    266         /** 
    267          * List of deprecated WordPress tables 
    268          * 
    269          * @since 2.9.0 
    270          * @access private 
    271          * @var array 
    272          */ 
    273         var $old_tables = array('categories', 'post2cat', 'link2cat'); 
    274  
    275  
    276         /** 
    277          * Format specifiers for DB columns. Columns not listed here default to %s.  Initialized in wp-settings.php. 
    278          * 
    279          * Keys are colmn names, values are format types: 'ID' => '%d' 
    280          * 
    281          * @since 2.8.0 
    282          * @see wpdb:prepare() 
    283          * @see wpdb:insert() 
    284          * @see wpdb:update() 
    285          * @access public 
    286          * @war array 
    287          */ 
    288         var $field_types = array(); 
    289  
    290         /** 
    291          * Database table columns charset 
    292          * 
    293          * @since 2.2.0 
    294          * @access public 
    295          * @var string 
    296          */ 
    297         var $charset; 
    298  
    299         /** 
    300          * Database table columns collate 
    301          * 
    302          * @since 2.2.0 
    303          * @access public 
    304          * @var string 
    305          */ 
    306         var $collate; 
    307  
    308         /** 
    309          * Whether to use mysql_real_escape_string 
    310          * 
    311          * @since 2.8.0 
    312          * @access public 
    313          * @var bool 
    314          */ 
    315         var $real_escape = false; 
    316  
    317         /** 
    318          * Database Username 
    319          * 
    320          * @since 2.9.0 
    321          * @access private 
    322          * @var string 
    323          */ 
    324         var $dbuser; 
    325  
    326         /** 
    327          * Connects to the database server and selects a database 
    328          * 
    329          * PHP4 compatibility layer for calling the PHP5 constructor. 
    330          * 
    331          * @uses wpdb::__construct() Passes parameters and returns result 
    332          * @since 0.71 
    333          * 
    334          * @param string $dbuser MySQL database user 
    335          * @param string $dbpassword MySQL database password 
    336          * @param string $dbname MySQL database name 
    337          * @param string $dbhost MySQL database host 
    338          */ 
    339         function wpdb($dbuser, $dbpassword, $dbname, $dbhost) { 
    340                 return $this->__construct($dbuser, $dbpassword, $dbname, $dbhost); 
    341         } 
    342  
    343         /** 
    344          * Connects to the database server and selects a database 
    345          * 
    346          * PHP5 style constructor for compatibility with PHP5. Does 
    347          * the actual setting up of the class properties and connection 
    348          * to the database. 
    349          * 
    350          * @since 2.0.8 
    351          * 
    352          * @param string $dbuser MySQL database user 
    353          * @param string $dbpassword MySQL database password 
    354          * @param string $dbname MySQL database name 
    355          * @param string $dbhost MySQL database host 
    356          */ 
    357         function __construct($dbuser, $dbpassword, $dbname, $dbhost) { 
    358                 register_shutdown_function(array(&$this, "__destruct")); 
    359  
    360                 if ( defined('WP_DEBUG') and WP_DEBUG == true ) 
    361                         $this->show_errors(); 
    362  
    363                 if ( defined('DB_CHARSET') ) 
    364                         $this->charset = DB_CHARSET; 
    365  
    366                 if ( defined('DB_COLLATE') ) 
    367                         $this->collate = DB_COLLATE; 
    368  
    369                 $this->dbuser = $dbuser; 
    370  
    371                 $this->dbh = @mysql_connect($dbhost, $dbuser, $dbpassword, true); 
    372                 if (!$this->dbh) { 
    373                         $this->bail(sprintf(/*WP_I18N_DB_CONN_ERROR*/" 
    374 <h1>Error establishing a database connection</h1> 
    375 <p>This either means that the username and password information in your <code>wp-config.php</code> file is incorrect or we can't contact the database server at <code>%s</code>. This could mean your host's database server is down.</p> 
    376 <ul> 
    377         <li>Are you sure you have the correct username and password?</li> 
    378         <li>Are you sure that you have typed the correct hostname?</li> 
    379         <li>Are you sure that the database server is running?</li> 
    380 </ul> 
    381 <p>If you're unsure what these terms mean you should probably contact your host. If you still need help you can always visit the <a href='http://wordpress.org/support/'>WordPress Support Forums</a>.</p> 
    382 "/*/WP_I18N_DB_CONN_ERROR*/, $dbhost), 'db_connect_fail'); 
    383                         return; 
    384                 } 
    385  
    386                 $this->ready = true; 
    387  
    388                 if ( $this->has_cap( 'collation' ) ) { 
    389                         if ( !empty($this->charset) ) { 
    390                                 if ( function_exists('mysql_set_charset') ) { 
    391                                         mysql_set_charset($this->charset, $this->dbh); 
    392                                         $this->real_escape = true; 
    393                                 } else { 
    394                                         $collation_query = "SET NAMES '{$this->charset}'"; 
    395                                         if ( !empty($this->collate) ) 
    396                                                 $collation_query .= " COLLATE '{$this->collate}'"; 
    397                                         $this->query($collation_query); 
    398                                 } 
    399                         } 
    400                 } 
    401  
    402                 $this->select($dbname); 
    403         } 
    404  
    405         /** 
    406          * PHP5 style destructor and will run when database object is destroyed. 
    407          * 
    408          * @since 2.0.8 
    409          * 
    410          * @return bool Always true 
    411          */ 
    412         function __destruct() { 
    413                 return true; 
    414         } 
    415  
    416         /** 
    417          * Sets the table prefix for the WordPress tables. 
    418          * 
    419          * Also allows for the CUSTOM_USER_TABLE and CUSTOM_USER_META_TABLE to 
    420          * override the WordPress users and usersmeta tables that would otherwise be determined by the $prefix. 
    421          * 
    422          * @since 2.5.0 
    423          * 
    424          * @param string $prefix Alphanumeric name for the new prefix. 
    425          * @return string|WP_Error Old prefix or WP_Error on error 
    426          */ 
    427         function set_prefix($prefix) { 
    428  
    429                 if ( preg_match('|[^a-z0-9_]|i', $prefix) ) 
    430                         return new WP_Error('invalid_db_prefix', /*WP_I18N_DB_BAD_PREFIX*/'Invalid database prefix'/*/WP_I18N_DB_BAD_PREFIX*/); 
    431  
    432                 $old_prefix = $this->prefix; 
    433                 $this->prefix = $prefix; 
    434  
    435                 foreach ( (array) $this->tables as $table ) 
    436                         $this->$table = $this->prefix . $table; 
    437  
    438                 if ( defined('CUSTOM_USER_TABLE') ) 
    439                         $this->users = CUSTOM_USER_TABLE; 
    440  
    441                 if ( defined('CUSTOM_USER_META_TABLE') ) 
    442                         $this->usermeta = CUSTOM_USER_META_TABLE; 
    443  
    444                 return $old_prefix; 
    445         } 
    446  
    447         /** 
    448          * Selects a database using the current database connection. 
    449          * 
    450          * The database name will be changed based on the current database 
    451          * connection. On failure, the execution will bail and display an DB error. 
    452          * 
    453          * @since 0.71 
    454          * 
    455          * @param string $db MySQL database name 
    456          * @return null Always null. 
    457          */ 
    458         function select($db) { 
    459                 if (!@mysql_select_db($db, $this->dbh)) { 
    460                         $this->ready = false; 
    461                         $this->bail(sprintf(/*WP_I18N_DB_SELECT_DB*/' 
    462 <h1>Can&#8217;t select database</h1> 
    463 <p>We were able to connect to the database server (which means your username and password is okay) but not able to select the <code>%1$s</code> database.</p> 
    464 <ul> 
    465 <li>Are you sure it exists?</li> 
    466 <li>Does the user <code>%2$s</code> have permission to use the <code>%1$s</code> database?</li> 
    467 <li>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?</li> 
    468 </ul> 
    469 <p>If you don\'t know how to setup a database you should <strong>contact your host</strong>. If all else fails you may find help at the <a href="http://wordpress.org/support/">WordPress Support Forums</a>.</p>'/*/WP_I18N_DB_SELECT_DB*/, $db, $this->dbuser), 'db_select_fail'); 
    470                         return; 
    471                 } 
    472         } 
    473  
    474         function _weak_escape($string) { 
    475                 return addslashes($string); 
    476         } 
    477  
    478         function _real_escape($string) { 
    479                 if ( $this->dbh && $this->real_escape ) 
    480                         return mysql_real_escape_string( $string, $this->dbh ); 
    481                 else 
    482                         return addslashes( $string ); 
    483         } 
    484  
    485         function _escape($data) { 
    486                 if ( is_array($data) ) { 
    487                         foreach ( (array) $data as $k => $v ) { 
    488                                 if ( is_array($v) ) 
    489                                         $data[$k] = $this->_escape( $v ); 
    490                                 else 
    491                                         $data[$k] = $this->_real_escape( $v ); 
    492                         } 
    493                 } else { 
    494                         $data = $this->_real_escape( $data ); 
    495                 } 
    496  
    497                 return $data; 
    498         } 
    499  
    500         /** 
    501          * Escapes content for insertion into the database using addslashes(), for security 
    502          * 
    503          * @since 0.71 
    504          * 
    505          * @param string|array $data 
    506          * @return string query safe string 
    507          */ 
    508         function escape($data) { 
    509                 if ( is_array($data) ) { 
    510                         foreach ( (array) $data as $k => $v ) { 
    511                                 if ( is_array($v) ) 
    512                                         $data[$k] = $this->escape( $v ); 
    513                                 else 
    514                                         $data[$k] = $this->_weak_escape( $v ); 
    515                         } 
    516                 } else { 
    517                         $data = $this->_weak_escape( $data ); 
    518                 } 
    519  
    520                 return $data; 
    521         } 
    522  
    523         /** 
    524          * Escapes content by reference for insertion into the database, for security 
    525          * 
    526          * @since 2.3.0 
    527          * 
    528          * @param string $s 
    529          */ 
    530         function escape_by_ref(&$string) { 
    531                 $string = $this->_real_escape( $string ); 
    532         } 
    533  
    534         /** 
    535          * Prepares a SQL query for safe execution.  Uses sprintf()-like syntax. 
    536          * 
    537          * This function only supports a small subset of the sprintf syntax; it only supports %d (decimal number), %s (string). 
    538          * Does not support sign, padding, alignment, width or precision specifiers. 
    539          * Does not support argument numbering/swapping. 
    540          * 
    541          * May be called like {@link http://php.net/sprintf sprintf()} or like {@link http://php.net/vsprintf vsprintf()}. 
    542          * 
    543          * Both %d and %s should be left unquoted in the query string. 
    544          * 
    545          * <code> 
    546          * wpdb::prepare( "SELECT * FROM `table` WHERE `column` = %s AND `field` = %d", "foo", 1337 ) 
    547          * </code> 
    548          * 
    549          * @link http://php.net/sprintf Description of syntax. 
    550          * @since 2.3.0 
    551          * 
    552          * @param string $query Query statement with sprintf()-like placeholders 
    553          * @param array|mixed $args The array of variables to substitute into the query's placeholders if being called like {@link http://php.net/vsprintf vsprintf()}, or the first variable to substitute into the query's placeholders if being called like {@link http://php.net/sprintf sprintf()}. 
    554          * @param mixed $args,... further variables to substitute into the query's placeholders if being called like {@link http://php.net/sprintf sprintf()}. 
    555          * @return null|string Sanitized query string 
    556          */ 
    557         function prepare($query = null) { // ( $query, *$args ) 
    558                 if ( is_null( $query ) ) 
    559                         return; 
    560                 $args = func_get_args(); 
    561                 array_shift($args); 
    562                 // If args were passed as an array (as in vsprintf), move them up 
    563                 if ( isset($args[0]) && is_array($args[0]) ) 
    564                         $args = $args[0]; 
    565                 $query = str_replace("'%s'", '%s', $query); // in case someone mistakenly already singlequoted it 
    566                 $query = str_replace('"%s"', '%s', $query); // doublequote unquoting 
    567                 $query = str_replace('%s', "'%s'", $query); // quote the strings 
    568                 array_walk($args, array(&$this, 'escape_by_ref')); 
    569                 return @vsprintf($query, $args); 
    570         } 
    571  
    572         /** 
    573          * Print SQL/DB error. 
    574          * 
    575          * @since 0.71 
    576          * @global array $EZSQL_ERROR Stores error information of query and error string 
    577          * 
    578          * @param string $str The error to display 
    579          * @return bool False if the showing of errors is disabled. 
    580          */ 
    581         function print_error($str = '') { 
    582                 global $EZSQL_ERROR; 
    583  
    584                 if (!$str) $str = mysql_error($this->dbh); 
    585                 $EZSQL_ERROR[] = array ('query' => $this->last_query, 'error_str' => $str); 
    586  
    587                 if ( $this->suppress_errors ) 
    588                         return false; 
    589  
    590                 if ( $caller = $this->get_caller() ) 
    591                         $error_str = sprintf(/*WP_I18N_DB_QUERY_ERROR_FULL*/'WordPress database error %1$s for query %2$s made by %3$s'/*/WP_I18N_DB_QUERY_ERROR_FULL*/, $str, $this->last_query, $caller); 
    592                 else 
    593                         $error_str = sprintf(/*WP_I18N_DB_QUERY_ERROR*/'WordPress database error %1$s for query %2$s'/*/WP_I18N_DB_QUERY_ERROR*/, $str, $this->last_query); 
    594  
    595                 $log_error = true; 
    596                 if ( ! function_exists('error_log') ) 
    597                         $log_error = false; 
    598  
    599                 $log_file = @ini_get('error_log'); 
    600                 if ( !empty($log_file) && ('syslog' != $log_file) && !@is_writable($log_file) ) 
    601                         $log_error = false; 
    602  
    603                 if ( $log_error ) 
    604                         @error_log($error_str, 0); 
    605  
    606                 // Is error output turned on or not.. 
    607                 if ( !$this->show_errors ) 
    608                         return false; 
    609  
    610                 $str = htmlspecialchars($str, ENT_QUOTES); 
    611                 $query = htmlspecialchars($this->last_query, ENT_QUOTES); 
    612  
    613                 // If there is an error then take note of it 
    614                 print "<div id='error'> 
    615                 <p class='wpdberror'><strong>WordPress database error:</strong> [$str]<br /> 
    616                 <code>$query</code></p> 
    617                 </div>"; 
    618         } 
    619  
    620         /** 
    621          * Enables showing of database errors. 
    622          * 
    623          * This function should be used only to enable showing of errors. 
    624          * wpdb::hide_errors() should be used instead for hiding of errors. However, 
    625          * this function can be used to enable and disable showing of database 
    626          * errors. 
    627          * 
    628          * @since 0.71 
    629          * 
    630          * @param bool $show Whether to show or hide errors 
    631          * @return bool Old value for showing errors. 
    632          */ 
    633         function show_errors( $show = true ) { 
    634                 $errors = $this->show_errors; 
    635                 $this->show_errors = $show; 
    636                 return $errors; 
    637         } 
    638  
    639         /** 
    640          * Disables showing of database errors. 
    641          * 
    642          * @since 0.71 
    643          * 
    644          * @return bool Whether showing of errors was active or not 
    645          */ 
    646         function hide_errors() { 
    647                 $show = $this->show_errors; 
    648                 $this->show_errors = false; 
    649                 return $show; 
    650         } 
    651  
    652         /** 
    653          * Whether to suppress database errors. 
    654          * 
    655          * @param unknown_type $suppress 
    656          * @return unknown 
    657          */ 
    658         function suppress_errors( $suppress = true ) { 
    659                 $errors = $this->suppress_errors; 
    660                 $this->suppress_errors = $suppress; 
    661                 return $errors; 
    662         } 
    663  
    664         /** 
    665          * Kill cached query results. 
    666          * 
    667          * @since 0.71 
    668          */ 
    669         function flush() { 
    670                 $this->last_result = array(); 
    671                 $this->col_info = null; 
    672                 $this->last_query = null; 
    673         } 
    674  
    675         /** 
    676          * Perform a MySQL database query, using current database connection. 
    677          * 
    678          * More information can be found on the codex page. 
    679          * 
    680          * @since 0.71 
    681          * 
    682          * @param string $query 
    683          * @return int|false Number of rows affected/selected or false on error 
    684          */ 
    685         function query($query) { 
    686                 if ( ! $this->ready ) 
    687                         return false; 
    688  
    689                 // filter the query, if filters are available 
    690                 // NOTE: some queries are made before the plugins have been loaded, and thus cannot be filtered with this method 
    691                 if ( function_exists('apply_filters') ) 
    692                         $query = apply_filters('query', $query); 
    693  
    694                 // initialise return 
    695                 $return_val = 0; 
    696                 $this->flush(); 
    697  
    698                 // Log how the function was called 
    699                 $this->func_call = "\$db->query(\"$query\")"; 
    700  
    701                 // Keep track of the last query for debug.. 
    702                 $this->last_query = $query; 
    703  
    704                 // Perform the query via std mysql_query function.. 
    705                 if ( defined('SAVEQUERIES') && SAVEQUERIES ) 
    706                         $this->timer_start(); 
    707  
    708                 $this->result = @mysql_query($query, $this->dbh); 
    709                 ++$this->num_queries; 
    710  
    711                 if ( defined('SAVEQUERIES') && SAVEQUERIES ) 
    712                         $this->queries[] = array( $query, $this->timer_stop(), $this->get_caller() ); 
    713  
    714                 // If there is an error then take note of it.. 
    715                 if ( $this->last_error = mysql_error($this->dbh) ) { 
    716                         $this->print_error(); 
    717                         return false; 
    718                 } 
    719  
    720                 if ( preg_match("/^\\s*(insert|delete|update|replace|alter) /i",$query) ) { 
    721                         $this->rows_affected = mysql_affected_rows($this->dbh); 
    722                         // Take note of the insert_id 
    723                         if ( preg_match("/^\\s*(insert|replace) /i",$query) ) { 
    724                                 $this->insert_id = mysql_insert_id($this->dbh); 
    725                         } 
    726                         // Return number of rows affected 
    727                         $return_val = $this->rows_affected; 
    728                 } else { 
    729                         $i = 0; 
    730                         while ($i < @mysql_num_fields($this->result)) { 
    731                                 $this->col_info[$i] = @mysql_fetch_field($this->result); 
    732                                 $i++; 
    733                         } 
    734                         $num_rows = 0; 
    735                         while ( $row = @mysql_fetch_object($this->result) ) { 
    736                                 $this->last_result[$num_rows] = $row; 
    737                                 $num_rows++; 
    738                         } 
    739  
    740                         @mysql_free_result($this->result); 
    741  
    742                         // Log number of rows the query returned 
    743                         $this->num_rows = $num_rows; 
    744  
    745                         // Return number of rows selected 
    746                         $return_val = $this->num_rows; 
    747                 } 
    748  
    749                 return $return_val; 
    750         } 
    751  
    752         /** 
    753          * Insert a row into a table. 
    754          * 
    755          * <code> 
    756          * wpdb::insert( 'table', array( 'column' => 'foo', 'field' => 1337 ), array( '%s', '%d' ) ) 
    757          * </code> 
    758          * 
    759          * @since 2.5.0 
    760          * @see wpdb::prepare() 
    761          * 
    762          * @param string $table table name 
    763          * @param array $data Data to insert (in column => value pairs).  Both $data columns and $data values should be "raw" (neither should be SQL escaped). 
    764          * @param array|string $format (optional) An array of formats to be mapped to each of the value in $data.  If string, that format will be used for all of the values in $data.  A format is one of '%d', '%s' (decimal number, string).  If omitted, all values in $data will be treated as strings. 
    765          * @return int|false The number of rows inserted, or false on error. 
    766          */ 
    767         function insert($table, $data, $format = null) { 
    768                 $formats = $format = (array) $format; 
    769                 $fields = array_keys($data); 
    770                 $formatted_fields = array(); 
    771                 foreach ( $fields as $field ) { 
    772                         if ( !empty($format) ) 
    773                                 $form = ( $form = array_shift($formats) ) ? $form : $format[0]; 
    774                         elseif ( isset($this->field_types[$field]) ) 
    775                                 $form = $this->field_types[$field]; 
    776                         else 
    777                                 $form = '%s'; 
    778                         $formatted_fields[] = $form; 
    779                 } 
    780                 $sql = "INSERT INTO `$table` (`" . implode( '`,`', $fields ) . "`) VALUES ('" . implode( "','", $formatted_fields ) . "')"; 
    781                 return $this->query( $this->prepare( $sql, $data) ); 
    782         } 
    783  
    784  
    785         /** 
    786          * Update a row in the table 
    787          * 
    788          * <code> 
    789          * wpdb::update( 'table', array( 'column' => 'foo', 'field' => 1337 ), array( 'ID' => 1 ), array( '%s', '%d' ), array( '%d' ) ) 
    790          * </code> 
    791          * 
    792          * @since 2.5.0 
    793          * @see wpdb::prepare() 
    794          * 
    795          * @param string $table table name 
    796          * @param array $data Data to update (in column => value pairs).  Both $data columns and $data values should be "raw" (neither should be SQL escaped). 
    797          * @param array $where A named array of WHERE clauses (in column => value pairs).  Multiple clauses will be joined with ANDs.  Both $where columns and $where values should be "raw". 
    798          * @param array|string $format (optional) An array of formats to be mapped to each of the values in $data.  If string, that format will be used for all of the values in $data.  A format is one of '%d', '%s' (decimal number, string).  If omitted, all values in $data will be treated as strings. 
    799          * @param array|string $format_where (optional) An array of formats to be mapped to each of the values in $where.  If string, that format will be used for all of  the items in $where.  A format is one of '%d', '%s' (decimal number, string).  If omitted, all values in $where will be treated as strings. 
    800          * @return int|false The number of rows updated, or false on error. 
    801          */ 
    802         function update($table, $data, $where, $format = null, $where_format = null) { 
    803                 if ( !is_array( $where ) ) 
    804                         return false; 
    805  
    806                 $formats = $format = (array) $format; 
    807                 $bits = $wheres = array(); 
    808                 foreach ( (array) array_keys($data) as $field ) { 
    809                         if ( !empty($format) ) 
    810                                 $form = ( $form = array_shift($formats) ) ? $form : $format[0]; 
    811                         elseif ( isset($this->field_types[$field]) ) 
    812                                 $form = $this->field_types[$field]; 
    813                         else 
    814                                 $form = '%s'; 
    815                         $bits[] = "`$field` = {$form}"; 
    816                 } 
    817  
    818                 $where_formats = $where_format = (array) $where_format; 
    819                 foreach ( (array) array_keys($where) as $field ) { 
    820                         if ( !empty($where_format) ) 
    821                                 $form = ( $form = array_shift($where_formats) ) ? $form : $where_format[0]; 
    822                         elseif ( isset($this->field_types[$field]) ) 
    823                                 $form = $this->field_types[$field]; 
    824                         else 
    825                                 $form = '%s'; 
    826                         $wheres[] = "`$field` = {$form}"; 
    827                 } 
    828  
    829                 $sql = "UPDATE `$table` SET " . implode( ', ', $bits ) . ' WHERE ' . implode( ' AND ', $wheres ); 
    830                 return $this->query( $this->prepare( $sql, array_merge(array_values($data), array_values($where))) ); 
    831         } 
    832  
    833         /** 
    834          * Retrieve one variable from the database. 
    835          * 
    836          * Executes a SQL query and returns the value from the SQL result. 
    837          * If the SQL result contains more than one column and/or more than one row, this function returns the value in the column and row specified. 
    838          * If $query is null, this function returns the value in the specified column and row from the previous SQL result. 
    839          * 
    840          * @since 0.71 
    841          * 
    842          * @param string|null $query SQL query.  If null, use the result from the previous query. 
    843          * @param int $x (optional) Column of value to return.  Indexed from 0. 
    844          * @param int $y (optional) Row of value to return.  Indexed from 0. 
    845          * @return string Database query result 
    846          */ 
    847         function get_var($query=null, $x = 0, $y = 0) { 
    848                 $this->func_call = "\$db->get_var(\"$query\",$x,$y)"; 
    849                 if ( $query ) 
    850                         $this->query($query); 
    851  
    852                 // Extract var out of cached results based x,y vals 
    853                 if ( !empty( $this->last_result[$y] ) ) { 
    854                         $values = array_values(get_object_vars($this->last_result[$y])); 
    855                 } 
    856  
    857                 // If there is a value return it else return null 
    858                 return (isset($values[$x]) && $values[$x]!=='') ? $values[$x] : null; 
    859         } 
    860  
    861         /** 
    862          * Retrieve one row from the database. 
    863          * 
    864          * Executes a SQL query and returns the row from the SQL result. 
    865          * 
    866          * @since 0.71 
    867          * 
    868          * @param string|null $query SQL query. 
    869          * @param string $output (optional) one of ARRAY_A | ARRAY_N | OBJECT constants.  Return an associative array (column => value, ...), a numerically indexed array (0 => value, ...) or an object ( ->column = value ), respectively. 
    870          * @param int $y (optional) Row to return.  Indexed from 0. 
    871          * @return mixed Database query result in format specifed by $output 
    872          */ 
    873         function get_row($query = null, $output = OBJECT, $y = 0) { 
    874                 $this->func_call = "\$db->get_row(\"$query\",$output,$y)"; 
    875                 if ( $query ) 
    876                         $this->query($query); 
    877                 else 
    878                         return null; 
    879  
    880                 if ( !isset($this->last_result[$y]) ) 
    881                         return null; 
    882  
    883                 if ( $output == OBJECT ) { 
    884                         return $this->last_result[$y] ? $this->last_result[$y] : null; 
    885                 } elseif ( $output == ARRAY_A ) { 
    886                         return $this->last_result[$y] ? get_object_vars($this->last_result[$y]) : null; 
    887                 } elseif ( $output == ARRAY_N ) { 
    888                         return $this->last_result[$y] ? array_values(get_object_vars($this->last_result[$y])) : null; 
    889                 } else { 
    890                         $this->print_error(/*WP_I18N_DB_GETROW_ERROR*/" \$db->get_row(string query, output type, int offset) -- Output type must be one of: OBJECT, ARRAY_A, ARRAY_N"/*/WP_I18N_DB_GETROW_ERROR*/); 
    891                 } 
    892         } 
    893  
    894         /** 
    895          * Retrieve one column from the database. 
    896          * 
    897          * Executes a SQL query and returns the column from the SQL result. 
    898          * If the SQL result contains more than one column, this function returns the column specified. 
    899          * If $query is null, this function returns the specified column from the previous SQL result. 
    900          * 
    901          * @since 0.71 
    902          * 
    903          * @param string|null $query SQL query.  If null, use the result from the previous query. 
    904          * @param int $x Column to return.  Indexed from 0. 
    905          * @return array Database query result.  Array indexed from 0 by SQL result row number. 
    906          */ 
    907         function get_col($query = null , $x = 0) { 
    908                 if ( $query ) 
    909                         $this->query($query); 
    910  
    911                 $new_array = array(); 
    912                 // Extract the column values 
    913                 for ( $i=0; $i < count($this->last_result); $i++ ) { 
    914                         $new_array[$i] = $this->get_var(null, $x, $i); 
    915                 } 
    916                 return $new_array; 
    917         } 
    918  
    919         /** 
    920          * Retrieve an entire SQL result set from the database (i.e., many rows) 
    921          * 
    922          * Executes a SQL query and returns the entire SQL result. 
    923          * 
    924          * @since 0.71 
    925          * 
    926          * @param string $query SQL query. 
    927          * @param string $output (optional) ane of ARRAY_A | ARRAY_N | OBJECT | OBJECT_K constants.  With one of the first three, return an array of rows indexed from 0 by SQL result row number.  Each row is an associative array (column => value, ...), a numerically indexed array (0 => value, ...), or an object. ( ->column = value ), respectively.  With OBJECT_K, return an associative array of row objects keyed by the value of each row's first column's value.  Duplicate keys are discarded. 
    928          * @return mixed Database query results 
    929          */ 
    930         function get_results($query = null, $output = OBJECT) { 
    931                 $this->func_call = "\$db->get_results(\"$query\", $output)"; 
    932  
    933                 if ( $query ) 
    934                         $this->query($query); 
    935                 else 
    936                         return null; 
    937  
    938                 if ( $output == OBJECT ) { 
    939                         // Return an integer-keyed array of row objects 
    940                         return $this->last_result; 
    941                 } elseif ( $output == OBJECT_K ) { 
    942                         // Return an array of row objects with keys from column 1 
    943                         // (Duplicates are discarded) 
    944                         foreach ( $this->last_result as $row ) { 
    945                                 $key = array_shift( get_object_vars( $row ) ); 
    946                                 if ( !isset( $new_array[ $key ] ) ) 
    947                                         $new_array[ $key ] = $row; 
    948                         } 
    949                         return $new_array; 
    950                 } elseif ( $output == ARRAY_A || $output == ARRAY_N ) { 
    951                         // Return an integer-keyed array of... 
    952                         if ( $this->last_result ) { 
    953                                 $i = 0; 
    954                                 foreach( (array) $this->last_result as $row ) { 
    955                                         if ( $output == ARRAY_N ) { 
    956                                                 // ...integer-keyed row arrays 
    957                                                 $new_array[$i] = array_values( get_object_vars( $row ) ); 
    958                                         } else { 
    959                                                 // ...column name-keyed row arrays 
    960                                                 $new_array[$i] = get_object_vars( $row ); 
    961                                         } 
    962                                         ++$i; 
    963                                 } 
    964                                 return $new_array; 
    965                         } 
    966                 } 
    967         } 
    968  
    969         /** 
    970          * Retrieve column metadata from the last query. 
    971          * 
    972          * @since 0.71 
    973          * 
    974          * @param string $info_type one of name, table, def, max_length, not_null, primary_key, multiple_key, unique_key, numeric, blob, type, unsigned, zerofill 
    975          * @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 
    976          * @return mixed Column Results 
    977          */ 
    978         function get_col_info($info_type = 'name', $col_offset = -1) { 
    979                 if ( $this->col_info ) { 
    980                         if ( $col_offset == -1 ) { 
    981                                 $i = 0; 
    982                                 foreach( (array) $this->col_info as $col ) { 
    983                                         $new_array[$i] = $col->{$info_type}; 
    984                                         $i++; 
    985                                 } 
    986                                 return $new_array; 
    987                         } else { 
    988                                 return $this->col_info[$col_offset]->{$info_type}; 
    989                         } 
    990                 } 
    991         } 
    992  
    993         /** 
    994          * Starts the timer, for debugging purposes. 
    995          * 
    996          * @since 1.5.0 
    997          * 
    998          * @return true 
    999          */ 
    1000         function timer_start() { 
    1001                 $mtime = microtime(); 
    1002                 $mtime = explode(' ', $mtime); 
    1003                 $this->time_start = $mtime[1] + $mtime[0]; 
    1004                 return true; 
    1005         } 
    1006  
    1007         /** 
    1008          * Stops the debugging timer. 
    1009          * 
    1010          * @since 1.5.0 
    1011          * 
    1012          * @return int Total time spent on the query, in milliseconds 
    1013          */ 
    1014         function timer_stop() { 
    1015                 $mtime = microtime(); 
    1016                 $mtime = explode(' ', $mtime); 
    1017                 $time_end = $mtime[1] + $mtime[0]; 
    1018                 $time_total = $time_end - $this->time_start; 
    1019                 return $time_total; 
    1020         } 
    1021  
    1022         /** 
    1023          * Wraps errors in a nice header and footer and dies. 
    1024          * 
    1025          * Will not die if wpdb::$show_errors is true 
    1026          * 
    1027          * @since 1.5.0 
    1028          * 
    1029          * @param string $message The Error message 
    1030          * @param string $error_code (optional) A Computer readable string to identify the error. 
    1031          * @return false|void 
    1032          */ 
    1033         function bail($message, $error_code = '500') { 
    1034                 if ( !$this->show_errors ) { 
    1035                         if ( class_exists('WP_Error') ) 
    1036                                 $this->error = new WP_Error($error_code, $message); 
    1037                         else 
    1038                                 $this->error = $message; 
    1039                         return false; 
    1040                 } 
    1041                 wp_die($message); 
    1042         } 
    1043  
    1044         /** 
    1045          * Whether or not MySQL database is at least the required minimum version. 
    1046          * 
    1047          * @since 2.5.0 
    1048          * @uses $wp_version 
    1049          * 
    1050          * @return WP_Error 
    1051          */ 
    1052         function check_database_version() 
    1053         { 
    1054                 global $wp_version; 
    1055                 // Make sure the server has MySQL 4.0 
    1056                 if ( version_compare($this->db_version(), '4.0.0', '<') ) 
    1057                         return new WP_Error('database_version',sprintf(__('<strong>ERROR</strong>: WordPress %s requires MySQL 4.0.0 or higher'), $wp_version)); 
    1058         } 
    1059  
    1060         /** 
    1061          * Whether of not the database supports collation. 
    1062          * 
    1063          * Called when WordPress is generating the table scheme. 
    1064          * 
    1065          * @since 2.5.0 
    1066          * 
    1067          * @return bool True if collation is supported, false if version does not 
    1068          */ 
    1069         function supports_collation() { 
    1070                 return $this->has_cap( 'collation' ); 
    1071         } 
    1072  
    1073         /** 
    1074          * Generic function to determine if a database supports a particular feature 
    1075          * @param string $db_cap the feature 
    1076          * @param false|string|resource $dbh_or_table (not implemented) Which database to test.  False = the currently selected database, string = the database containing the specified table, resource = the database corresponding to the specified mysql resource. 
    1077          * @return bool 
    1078          */ 
    1079         function has_cap( $db_cap ) { 
    1080                 $version = $this->db_version(); 
    1081  
    1082                 switch ( strtolower( $db_cap ) ) : 
    1083                 case 'collation' :    // @since 2.5.0 
    1084                 case 'group_concat' : // @since 2.7 
    1085                 case 'subqueries' :   // @since 2.7 
    1086                         return version_compare($version, '4.1', '>='); 
    1087                         break; 
    1088                 endswitch; 
    1089  
    1090                 return false; 
    1091         } 
    1092  
    1093         /** 
    1094          * Retrieve the name of the function that called wpdb. 
    1095          * 
    1096          * Requires PHP 4.3 and searches up the list of functions until it reaches 
    1097          * the one that would most logically had called this method. 
    1098          * 
    1099          * @since 2.5.0 
    1100          * 
    1101          * @return string The name of the calling function 
    1102          */ 
    1103         function get_caller() { 
    1104                 // requires PHP 4.3+ 
    1105                 if ( !is_callable('debug_backtrace') ) 
    1106                         return ''; 
    1107  
    1108                 $bt = debug_backtrace(); 
    1109                 $caller = array(); 
    1110  
    1111                 $bt = array_reverse( $bt ); 
    1112                 foreach ( (array) $bt as $call ) { 
    1113                         if ( @$call['class'] == __CLASS__ ) 
    1114                                 continue; 
    1115                         $function = $call['function']; 
    1116                         if ( isset( $call['class'] ) ) 
    1117                                 $function = $call['class'] . "->$function"; 
    1118                         $caller[] = $function; 
    1119                 } 
    1120                 $caller = join( ', ', $caller ); 
    1121  
    1122                 return $caller; 
    1123         } 
    1124  
    1125         /** 
    1126          * The database version number 
    1127          * @param false|string|resource $dbh_or_table (not implemented) Which database to test.  False = the currently selected database, string = the database containing the specified table, resource = the database corresponding to the specified mysql resource. 
    1128          * @return false|string false on failure, version number on success 
    1129          */ 
    1130         function db_version() { 
    1131                 return preg_replace('/[^0-9.].*/', '', mysql_get_server_info( $this->dbh )); 
    1132         } 
    1133 } 
    1134  
    1135 if ( ! isset($wpdb) ) { 
    1136         /** 
    1137          * WordPress Database Object, if it isn't set already in wp-content/db.php 
    1138          * @global object $wpdb Creates a new wpdb object based on wp-config.php Constants for the database 
    1139          * @since 0.71 
    1140          */ 
     11        * WordPress Database Object, if it isn't set already in wp-content/db.php 
     12        * @global object $wpdb Creates a new wpdb object based on wp-config.php Constants for the database 
     13        * @since 0.71 
     14        */ 
    114115        $wpdb = new wpdb(DB_USER, DB_PASSWORD, DB_NAME, DB_HOST); 
    114216} 
    1143 ?> 
  • wp-config-sample.php

     
    11<?php 
    2 /**  
     2/** 
    33 * The base configurations of the WordPress. 
    44 * 
    55 * This file has the following configurations: MySQL settings, Table Prefix, 
     
    1818/** The name of the database for WordPress */ 
    1919define('DB_NAME', 'putyourdbnamehere'); 
    2020 
    21 /** MySQL database username */ 
     21/** Database username */ 
    2222define('DB_USER', 'usernamehere'); 
    2323 
    24 /** MySQL database password */ 
     24/** Database password */ 
    2525define('DB_PASSWORD', 'yourpasswordhere'); 
    2626 
    27 /** MySQL hostname */ 
     27/** Database hostname */ 
    2828define('DB_HOST', 'localhost'); 
    2929 
     30/** Database Type. Defaults to mysql */ 
     31define('DB_TYPE', 'mysql'); 
     32 
    3033/** Database Charset to use in creating database tables. */ 
    3134define('DB_CHARSET', 'utf8'); 
    3235 
     
    7073 
    7174/** WordPress absolute path to the Wordpress directory. */ 
    7275if ( !defined('ABSPATH') ) 
    73         define('ABSPATH', dirname(__FILE__) . '/'); 
     76        define('ABSPATH', dirname(__FILE__) . '/'); 
    7477 
    7578/** Sets up WordPress vars and included files. */ 
    76 require_once(ABSPATH . 'wp-settings.php'); 
     79require_once(ABSPATH . 'wp-settings.php'); 
     80 No newline at end of file 
  • wp-admin/includes/schema.php

     
    1919// Declare these as global in case schema.php is included from a function. 
    2020global $wpdb, $wp_queries; 
    2121 
    22 if ( $wpdb->has_cap( 'collation' ) ) { 
    23         if ( ! empty($wpdb->charset) ) 
    24                 $charset_collate = "DEFAULT CHARACTER SET $wpdb->charset"; 
    25         if ( ! empty($wpdb->collate) ) 
    26                 $charset_collate .= " COLLATE $wpdb->collate"; 
     22if ( DB_TYPE == 'mysql' && $wpdb->has_cap( 'collation' ) ) { 
     23    if ( ! empty($wpdb->charset) ) 
     24        $charset_collate = "DEFAULT CHARACTER SET $wpdb->charset"; 
     25    if ( ! empty($wpdb->collate) ) 
     26        $charset_collate .= " COLLATE $wpdb->collate"; 
    2727} 
    2828 
    2929/** Create WordPress database tables SQL */ 
     
    5454 PRIMARY KEY  (object_id,term_taxonomy_id), 
    5555 KEY term_taxonomy_id (term_taxonomy_id) 
    5656) $charset_collate; 
    57 CREATE TABLE $wpdb->commentmeta ( 
    58   meta_id bigint(20) unsigned NOT NULL auto_increment, 
    59   comment_id bigint(20) unsigned NOT NULL default '0', 
    60   meta_key varchar(255) default NULL, 
    61   meta_value longtext, 
    62   PRIMARY KEY  (meta_id), 
    63   KEY comment_id (comment_id), 
    64   KEY meta_key (meta_key) 
    65 ) $charset_collate; 
    6657CREATE TABLE $wpdb->comments ( 
    6758  comment_ID bigint(20) unsigned NOT NULL auto_increment, 
    6859  comment_post_ID bigint(20) unsigned NOT NULL default '0', 
     
    10899  option_name varchar(64) NOT NULL default '', 
    109100  option_value longtext NOT NULL, 
    110101  autoload varchar(20) NOT NULL default 'yes', 
    111   PRIMARY KEY  (option_name), 
    112   KEY option_id (option_id) 
     102  PRIMARY KEY  (option_id,blog_id,option_name), 
     103  KEY option_name (option_name) 
    113104) $charset_collate; 
    114105CREATE TABLE $wpdb->postmeta ( 
    115106  meta_id bigint(20) unsigned NOT NULL auto_increment, 
     
    182173 * @uses $wp_db_version 
    183174 */ 
    184175function populate_options() { 
    185         global $wpdb, $wp_db_version; 
     176    global $wpdb, $wp_db_version; 
    186177 
    187         $guessurl = wp_guess_url(); 
     178    $guessurl = wp_guess_url(); 
    188179 
    189         do_action('populate_options'); 
     180    do_action('populate_options'); 
    190181 
    191         if ( ini_get('safe_mode') ) { 
    192                 // Safe mode screws up mkdir(), so we must use a flat structure. 
    193                 $uploads_use_yearmonth_folders = 0; 
    194                 $upload_path = WP_CONTENT_DIR; 
    195         } else { 
    196                 $uploads_use_yearmonth_folders = 1; 
    197                 $upload_path = WP_CONTENT_DIR . '/uploads'; 
    198         } 
     182    if ( ini_get('safe_mode') ) { 
     183        // Safe mode screws up mkdir(), so we must use a flat structure. 
     184        $uploads_use_yearmonth_folders = 0; 
     185        $upload_path = WP_CONTENT_DIR; 
     186    } else { 
     187        $uploads_use_yearmonth_folders = 1; 
     188        $upload_path = WP_CONTENT_DIR . '/uploads'; 
     189    } 
    199190 
    200         $options = array( 
    201         'siteurl' => $guessurl, 
    202         'blogname' => __('My Blog'), 
    203         'blogdescription' => __('Just another WordPress weblog'), 
    204         'users_can_register' => 0, 
    205         'admin_email' => 'you@example.com', 
    206         'start_of_week' => 1, 
    207         'use_balanceTags' => 0, 
    208         'use_smilies' => 1, 
    209         'require_name_email' => 1, 
    210         'comments_notify' => 1, 
    211         'posts_per_rss' => 10, 
    212         'rss_use_excerpt' => 0, 
    213         'mailserver_url' => 'mail.example.com', 
    214         'mailserver_login' => 'login@example.com', 
    215         'mailserver_pass' => 'password', 
    216         'mailserver_port' => 110, 
    217         'default_category' => 1, 
    218         'default_comment_status' => 'open', 
    219         'default_ping_status' => 'open', 
    220         'default_pingback_flag' => 1, 
    221         'default_post_edit_rows' => 10, 
    222         'posts_per_page' => 10, 
    223         /* translators: default date format, see http://php.net/date */ 
    224         'date_format' => __('F j, Y'), 
    225         /* translators: default time format, see http://php.net/date */ 
    226         'time_format' => __('g:i a'), 
    227         /* translators: links last updated date format, see http://php.net/date */ 
    228         'links_updated_date_format' => __('F j, Y g:i a'), 
    229         'links_recently_updated_prepend' => '<em>', 
    230         'links_recently_updated_append' => '</em>', 
    231         'links_recently_updated_time' => 120, 
    232         'comment_moderation' => 0, 
    233         'moderation_notify' => 1, 
    234         'permalink_structure' => '', 
    235         'gzipcompression' => 0, 
    236         'hack_file' => 0, 
    237         'blog_charset' => 'UTF-8', 
    238         'moderation_keys' => '', 
    239         'active_plugins' => array(), 
    240         'home' => $guessurl, 
    241         'category_base' => '', 
    242         'ping_sites' => 'http://rpc.pingomatic.com/', 
    243         'advanced_edit' => 0, 
    244         'comment_max_links' => 2, 
    245         'gmt_offset' => date('Z') / 3600, 
     191    $options = array( 
     192    'siteurl' => $guessurl, 
     193    'blogname' => __('My Blog'), 
     194    'blogdescription' => __('Just another WordPress weblog'), 
     195    'users_can_register' => 0, 
     196    'admin_email' => 'you@example.com', 
     197    'start_of_week' => 1, 
     198    'use_balanceTags' => 0, 
     199    'use_smilies' => 1, 
     200    'require_name_email' => 1, 
     201    'comments_notify' => 1, 
     202    'posts_per_rss' => 10, 
     203    'rss_excerpt_length' => 50, 
     204    'rss_use_excerpt' => 0, 
     205    'mailserver_url' => 'mail.example.com', 
     206    'mailserver_login' => 'login@example.com', 
     207    'mailserver_pass' => 'password', 
     208    'mailserver_port' => 110, 
     209    'default_category' => 1, 
     210    'default_comment_status' => 'open', 
     211    'default_ping_status' => 'open', 
     212    'default_pingback_flag' => 1, 
     213    'default_post_edit_rows' => 10, 
     214    'posts_per_page' => 10, 
     215    /* translators: default date format, see http://php.net/date */ 
     216    'date_format' => __('F j, Y'), 
     217    /* translators: default time format, see http://php.net/date */ 
     218    'time_format' => __('g:i a'), 
     219    /* translators: links last updated date format, see http://php.net/date */ 
     220    'links_updated_date_format' => __('F j, Y g:i a'), 
     221    'links_recently_updated_prepend' => '<em>', 
     222    'links_recently_updated_append' => '</em>', 
     223    'links_recently_updated_time' => 120, 
     224    'comment_moderation' => 0, 
     225    'moderation_notify' => 1, 
     226    'permalink_structure' => '', 
     227    'gzipcompression' => 0, 
     228    'hack_file' => 0, 
     229    'blog_charset' => 'UTF-8', 
     230    'moderation_keys' => '', 
     231    'active_plugins' => array(), 
     232    'home' => $guessurl, 
     233    'category_base' => '', 
     234    'ping_sites' => 'http://rpc.pingomatic.com/', 
     235    'advanced_edit' => 0, 
     236    'comment_max_links' => 2, 
     237    'gmt_offset' => date('Z') / 3600, 
    246238 
    247         // 1.5 
    248         'default_email_category' => 1, 
    249         'recently_edited' => '', 
    250         'use_linksupdate' => 0, 
    251         'template' => 'default', 
    252         'stylesheet' => 'default', 
    253         'comment_whitelist' => 1, 
    254         'blacklist_keys' => '', 
    255         'comment_registration' => 0, 
    256         'rss_language' => 'en', 
    257         'html_type' => 'text/html', 
     239    // 1.5 
     240    'default_email_category' => 1, 
     241    'recently_edited' => '', 
     242    'use_linksupdate' => 0, 
     243    'template' => 'default', 
     244    'stylesheet' => 'default', 
     245    'comment_whitelist' => 1, 
     246    'blacklist_keys' => '', 
     247    'comment_registration' => 0, 
     248    'rss_language' => 'en', 
     249    'html_type' => 'text/html', 
    258250 
    259         // 1.5.1 
    260         'use_trackback' => 0, 
     251    // 1.5.1 
     252    'use_trackback' => 0, 
    261253 
    262         // 2.0 
    263         'default_role' => 'subscriber', 
    264         'db_version' => $wp_db_version, 
     254    // 2.0 
     255    'default_role' => 'subscriber', 
     256    'db_version' => $wp_db_version, 
    265257 
    266         // 2.0.1 
    267         'uploads_use_yearmonth_folders' => $uploads_use_yearmonth_folders, 
    268         'upload_path' => $upload_path, 
     258    // 2.0.1 
     259    'uploads_use_yearmonth_folders' => $uploads_use_yearmonth_folders, 
     260    'upload_path' => $upload_path, 
    269261 
    270         // 2.0.3 
    271         'secret' => wp_generate_password(64), 
     262    // 2.0.3 
     263    'secret' => wp_generate_password(64), 
    272264 
    273         // 2.1 
    274         'blog_public' => '1', 
    275         'default_link_category' => 2, 
    276         'show_on_front' => 'posts', 
     265    // 2.1 
     266    'blog_public' => '1', 
     267    'default_link_category' => 2, 
     268    'show_on_front' => 'posts', 
    277269 
    278         // 2.2 
    279         'tag_base' => '', 
     270    // 2.2 
     271    'tag_base' => '', 
    280272 
    281         // 2.5 
    282         'show_avatars' => '1', 
    283         'avatar_rating' => 'G', 
    284         'upload_url_path' => '', 
    285         'thumbnail_size_w' => 150, 
    286         'thumbnail_size_h' => 150, 
    287         'thumbnail_crop' => 1, 
    288         'medium_size_w' => 300, 
    289         'medium_size_h' => 300, 
     273    // 2.5 
     274    'show_avatars' => '1', 
     275    'avatar_rating' => 'G', 
     276    'upload_url_path' => '', 
     277    'thumbnail_size_w' => 150, 
     278    'thumbnail_size_h' => 150, 
     279    'thumbnail_crop' => 1, 
     280    'medium_size_w' => 300, 
     281    'medium_size_h' => 300, 
    290282 
    291         // 2.6 
    292         'avatar_default' => 'mystery', 
    293         'enable_app' => 0, 
    294         'enable_xmlrpc' => 0, 
     283    // 2.6 
     284    'avatar_default' => 'mystery', 
     285    'enable_app' => 0, 
     286    'enable_xmlrpc' => 0, 
    295287 
    296         // 2.7 
    297         'large_size_w' => 1024, 
    298         'large_size_h' => 1024, 
    299         'image_default_link_type' => 'file', 
    300         'image_default_size' => '', 
    301         'image_default_align' => '', 
    302         'close_comments_for_old_posts' => 0, 
    303         'close_comments_days_old' => 14, 
    304         'thread_comments' => 0, 
    305         'thread_comments_depth' => 5, 
    306         'page_comments' => 1, 
    307         'comments_per_page' => 50, 
    308         'default_comments_page' => 'newest', 
    309         'comment_order' => 'asc', 
    310         'sticky_posts' => array(), 
    311         'widget_categories' => array(), 
    312         'widget_text' => array(), 
    313         'widget_rss' => array(), 
     288    // 2.7 
     289    'large_size_w' => 1024, 
     290    'large_size_h' => 1024, 
     291    'image_default_link_type' => 'file', 
     292    'image_default_size' => '', 
     293    'image_default_align' => '', 
     294    'close_comments_for_old_posts' => 0, 
     295    'close_comments_days_old' => 14, 
     296    'thread_comments' => 0, 
     297    'thread_comments_depth' => 5, 
     298    'page_comments' => 1, 
     299    'comments_per_page' => 50, 
     300    'default_comments_page' => 'newest', 
     301    'comment_order' => 'asc', 
     302    'sticky_posts' => array(), 
     303    'widget_categories' => array(), 
     304    'widget_text' => array(), 
     305    'widget_rss' => array(), 
    314306 
    315         // 2.8 
    316         'timezone_string' => '' 
    317         ); 
     307    // 2.8 
     308    'timezone_string' => '' 
     309    ); 
    318310 
    319         // Set autoload to no for these options 
    320         $fat_options = array( 'moderation_keys', 'recently_edited', 'blacklist_keys' ); 
     311    // Set autoload to no for these options 
     312    $fat_options = array( 'moderation_keys', 'recently_edited', 'blacklist_keys' ); 
    321313 
    322         $existing_options = $wpdb->get_col("SELECT option_name FROM $wpdb->options"); 
     314    $existing_options = $wpdb->get_col("SELECT option_name FROM $wpdb->options"); 
    323315 
    324         $insert = ''; 
    325         foreach ( $options as $option => $value ) { 
    326                 if ( in_array($option, $existing_options) ) 
    327                         continue; 
    328                 if ( in_array($option, $fat_options) ) 
    329                         $autoload = 'no'; 
    330                 else 
    331                         $autoload = 'yes'; 
     316    $insert = ''; 
     317    foreach ( $options as $option => $value ) { 
     318        if ( in_array($option, $existing_options) ) 
     319            continue; 
     320        if ( in_array($option, $fat_options) ) 
     321            $autoload = 'no'; 
     322        else 
     323            $autoload = 'yes'; 
    332324 
    333                 $option = $wpdb->escape($option); 
    334                 if ( is_array($value) ) 
    335                         $value = serialize($value); 
    336                 $value = $wpdb->escape($value); 
    337                 if ( !empty($insert) ) 
    338                         $insert .= ', '; 
    339                 $insert .= "('$option', '$value', '$autoload')"; 
    340         } 
     325        $option = $wpdb->escape($option); 
     326        if ( is_array($value) ) 
     327            $value = serialize($value); 
     328        $value = $wpdb->escape($value); 
     329        if ( !empty($insert) ) 
     330            $insert .= ', '; 
     331        $insert .= "('$option', '$value', '$autoload')"; 
     332    } 
    341333 
    342         if ( !empty($insert) ) 
    343                 $wpdb->query("INSERT INTO $wpdb->options (option_name, option_value, autoload) VALUES " . $insert); 
     334    if ( !empty($insert) ) 
     335        $wpdb->query("INSERT INTO $wpdb->options (option_name, option_value, autoload) VALUES " . $insert); 
    344336 
    345         // in case it is set, but blank, update "home" 
    346         if ( !__get_option('home') ) update_option('home', $guessurl); 
     337    // in case it is set, but blank, update "home" 
     338    if ( !__get_option('home') ) update_option('home', $guessurl); 
    347339 
    348         // Delete unused options 
    349         $unusedoptions = array ('blodotgsping_url', 'bodyterminator', 'emailtestonly', 'phoneemail_separator', 'smilies_directory', 'subjectprefix', 'use_bbcode', 'use_blodotgsping', 'use_phoneemail', 'use_quicktags', 'use_weblogsping', 'weblogs_cache_file', 'use_preview', 'use_htmltrans', 'smilies_directory', 'fileupload_allowedusers', 'use_phoneemail', 'default_post_status', 'default_post_category', 'archive_mode', 'time_difference', 'links_minadminlevel', 'links_use_adminlevels', 'links_rating_type', 'links_rating_char', 'links_rating_ignore_zero', 'links_rating_single_image', 'links_rating_image0', 'links_rating_image1', 'links_rating_image2', 'links_rating_image3', 'links_rating_image4', 'links_rating_image5', 'links_rating_image6', 'links_rating_image7', 'links_rating_image8', 'links_rating_image9', 'weblogs_cacheminutes', 'comment_allowed_tags', 'search_engine_friendly_urls', 'default_geourl_lat', 'default_geourl_lon', 'use_default_geourl', 'weblogs_xml_url', 'new_users_can_blog', '_wpnonce', '_wp_http_referer', 'Update', 'action', 'rich_editing', 'autosave_interval', 'deactivated_plugins', 'can_compress_scripts', 
    350                 'page_uris', 'rewrite_rules', 'update_core', 'update_plugins', 'update_themes', 'doing_cron', 'random_seed', 'rss_excerpt_length'); 
    351         foreach ($unusedoptions as $option) 
    352                 delete_option($option); 
     340    // Delete unused options 
     341    $unusedoptions = array ('blodotgsping_url', 'bodyterminator', 'emailtestonly', 'phoneemail_separator', 'smilies_directory', 'subjectprefix', 'use_bbcode', 'use_blodotgsping', 'use_phoneemail', 'use_quicktags', 'use_weblogsping', 'weblogs_cache_file', 'use_preview', 'use_htmltrans', 'smilies_directory', 'fileupload_allowedusers', 'use_phoneemail', 'default_post_status', 'default_post_category', 'archive_mode', 'time_difference', 'links_minadminlevel', 'links_use_adminlevels', 'links_rating_type', 'links_rating_char', 'links_rating_ignore_zero', 'links_rating_single_image', 'links_rating_image0', 'links_rating_image1', 'links_rating_image2', 'links_rating_image3', 'links_rating_image4', 'links_rating_image5', 'links_rating_image6', 'links_rating_image7', 'links_rating_image8', 'links_rating_image9', 'weblogs_cacheminutes', 'comment_allowed_tags', 'search_engine_friendly_urls', 'default_geourl_lat', 'default_geourl_lon', 'use_default_geourl', 'weblogs_xml_url', 'new_users_can_blog', '_wpnonce', '_wp_http_referer', 'Update', 'action', 'rich_editing', 'autosave_interval', 'deactivated_plugins', 'can_compress_scripts', 
     342        'page_uris', 'rewrite_rules', 'update_core', 'update_plugins', 'update_themes', 'doing_cron', 'random_seed'); 
     343    foreach ($unusedoptions as $option) 
     344        delete_option($option); 
    353345} 
    354346 
    355347/** 
     
    358350 * @since 2.0.0 
    359351 */ 
    360352function populate_roles() { 
    361         populate_roles_160(); 
    362         populate_roles_210(); 
    363         populate_roles_230(); 
    364         populate_roles_250(); 
    365         populate_roles_260(); 
    366         populate_roles_270(); 
    367         populate_roles_280(); 
     353    populate_roles_160(); 
     354    populate_roles_210(); 
     355    populate_roles_230(); 
     356    populate_roles_250(); 
     357    populate_roles_260(); 
     358    populate_roles_270(); 
     359    populate_roles_280(); 
    368360} 
    369361 
    370362/** 
     
    373365 * @since 2.0.0 
    374366 */ 
    375367function populate_roles_160() { 
    376         // Add roles 
     368    // Add roles 
    377369 
    378         // Dummy gettext calls to get strings in the catalog. 
    379         /* translators: user role */ 
    380         _x('Administrator', 'User role'); 
    381         /* translators: user role */ 
    382         _x('Editor', 'User role'); 
    383         /* translators: user role */ 
    384         _x('Author', 'User role'); 
    385         /* translators: user role */ 
    386         _x('Contributor', 'User role'); 
    387         /* translators: user role */ 
    388         _x('Subscriber', 'User role'); 
     370    // Dummy gettext calls to get strings in the catalog. 
     371    /* translators: user role */ 
     372    _x('Administrator', 'User role'); 
     373    /* translators: user role */ 
     374    _x('Editor', 'User role'); 
     375    /* translators: user role */ 
     376    _x('Author', 'User role'); 
     377    /* translators: user role */ 
     378    _x('Contributor', 'User role'); 
     379    /* translators: user role */ 
     380    _x('Subscriber', 'User role'); 
    389381 
    390         add_role('administrator', 'Administrator'); 
    391         add_role('editor', 'Editor'); 
    392         add_role('author', 'Author'); 
    393         add_role('contributor', 'Contributor'); 
    394         add_role('subscriber', 'Subscriber'); 
     382    add_role('administrator', 'Administrator'); 
     383    add_role('editor', 'Editor'); 
     384    add_role('author', 'Author'); 
     385    add_role('contributor', 'Contributor'); 
     386    add_role('subscriber', 'Subscriber'); 
    395387 
    396         // Add caps for Administrator role 
    397         $role =& get_role('administrator'); 
    398         $role->add_cap('switch_themes'); 
    399         $role->add_cap('edit_themes'); 
    400         $role->add_cap('activate_plugins'); 
    401         $role->add_cap('edit_plugins'); 
    402         $role->add_cap('edit_users'); 
    403         $role->add_cap('edit_files'); 
    404         $role->add_cap('manage_options'); 
    405         $role->add_cap('moderate_comments'); 
    406         $role->add_cap('manage_categories'); 
    407         $role->add_cap('manage_links'); 
    408         $role->add_cap('upload_files'); 
    409         $role->add_cap('import'); 
    410         $role->add_cap('unfiltered_html'); 
    411         $role->add_cap('edit_posts'); 
    412         $role->add_cap('edit_others_posts'); 
    413         $role->add_cap('edit_published_posts'); 
    414         $role->add_cap('publish_posts'); 
    415         $role->add_cap('edit_pages'); 
    416         $role->add_cap('read'); 
    417         $role->add_cap('level_10'); 
    418         $role->add_cap('level_9'); 
    419         $role->add_cap('level_8'); 
    420         $role->add_cap('level_7'); 
    421         $role->add_cap('level_6'); 
    422         $role->add_cap('level_5'); 
    423         $role->add_cap('level_4'); 
    424         $role->add_cap('level_3'); 
    425         $role->add_cap('level_2'); 
    426         $role->add_cap('level_1'); 
    427         $role->add_cap('level_0'); 
     388    // Add caps for Administrator role 
     389    $role =& get_role('administrator'); 
     390    $role->add_cap('switch_themes'); 
     391    $role->add_cap('edit_themes'); 
     392    $role->add_cap('activate_plugins'); 
     393    $role->add_cap('edit_plugins'); 
     394    $role->add_cap('edit_users'); 
     395    $role->add_cap('edit_files'); 
     396    $role->add_cap('manage_options'); 
     397    $role->add_cap('moderate_comments'); 
     398    $role->add_cap('manage_categories'); 
     399    $role->add_cap('manage_links'); 
     400    $role->add_cap('upload_files'); 
     401    $role->add_cap('import'); 
     402    $role->add_cap('unfiltered_html'); 
     403    $role->add_cap('edit_posts'); 
     404    $role->add_cap('edit_others_posts'); 
     405    $role->add_cap('edit_published_posts'); 
     406    $role->add_cap('publish_posts'); 
     407    $role->add_cap('edit_pages'); 
     408    $role->add_cap('read'); 
     409    $role->add_cap('level_10'); 
     410    $role->add_cap('level_9'); 
     411    $role->add_cap('level_8'); 
     412    $role->add_cap('level_7'); 
     413    $role->add_cap('level_6'); 
     414    $role->add_cap('level_5'); 
     415    $role->add_cap('level_4'); 
     416    $role->add_cap('level_3'); 
     417    $role->add_cap('level_2'); 
     418    $role->add_cap('level_1'); 
     419    $role->add_cap('level_0'); 
    428420 
    429         // Add caps for Editor role 
    430         $role =& get_role('editor'); 
    431         $role->add_cap('moderate_comments'); 
    432         $role->add_cap('manage_categories'); 
    433         $role->add_cap('manage_links'); 
    434         $role->add_cap('upload_files'); 
    435         $role->add_cap('unfiltered_html'); 
    436         $role->add_cap('edit_posts'); 
    437         $role->add_cap('edit_others_posts'); 
    438         $role->add_cap('edit_published_posts'); 
    439         $role->add_cap('publish_posts'); 
    440         $role->add_cap('edit_pages'); 
    441         $role->add_cap('read'); 
    442         $role->add_cap('level_7'); 
    443         $role->add_cap('level_6'); 
    444         $role->add_cap('level_5'); 
    445         $role->add_cap('level_4'); 
    446         $role->add_cap('level_3'); 
    447         $role->add_cap('level_2'); 
    448         $role->add_cap('level_1'); 
    449         $role->add_cap('level_0'); 
     421    // Add caps for Editor role 
     422    $role =& get_role('editor'); 
     423    $role->add_cap('moderate_comments'); 
     424    $role->add_cap('manage_categories'); 
     425    $role->add_cap('manage_links'); 
     426    $role->add_cap('upload_files'); 
     427    $role->add_cap('unfiltered_html'); 
     428    $role->add_cap('edit_posts'); 
     429    $role->add_cap('edit_others_posts'); 
     430    $role->add_cap('edit_published_posts'); 
     431    $role->add_cap('publish_posts'); 
     432    $role->add_cap('edit_pages'); 
     433    $role->add_cap('read'); 
     434    $role->add_cap('level_7'); 
     435    $role->add_cap('level_6'); 
     436    $role->add_cap('level_5'); 
     437    $role->add_cap('level_4'); 
     438    $role->add_cap('level_3'); 
     439    $role->add_cap('level_2'); 
     440    $role->add_cap('level_1'); 
     441    $role->add_cap('level_0'); 
    450442 
    451         // Add caps for Author role 
    452         $role =& get_role('author'); 
    453         $role->add_cap('upload_files'); 
    454         $role->add_cap('edit_posts'); 
    455         $role->add_cap('edit_published_posts'); 
    456         $role->add_cap('publish_posts'); 
    457         $role->add_cap('read'); 
    458         $role->add_cap('level_2'); 
    459         $role->add_cap('level_1'); 
    460         $role->add_cap('level_0'); 
     443    // Add caps for Author role 
     444    $role =& get_role('author'); 
     445    $role->add_cap('upload_files'); 
     446    $role->add_cap('edit_posts'); 
     447    $role->add_cap('edit_published_posts'); 
     448    $role->add_cap('publish_posts'); 
     449    $role->add_cap('read'); 
     450    $role->add_cap('level_2'); 
     451    $role->add_cap('level_1'); 
     452    $role->add_cap('level_0'); 
    461453 
    462         // Add caps for Contributor role 
    463         $role =& get_role('contributor'); 
    464         $role->add_cap('edit_posts'); 
    465         $role->add_cap('read'); 
    466         $role->add_cap('level_1'); 
    467         $role->add_cap('level_0'); 
     454    // Add caps for Contributor role 
     455    $role =& get_role('contributor'); 
     456    $role->add_cap('edit_posts'); 
     457    $role->add_cap('read'); 
     458    $role->add_cap('level_1'); 
     459    $role->add_cap('level_0'); 
    468460 
    469         // Add caps for Subscriber role 
    470         $role =& get_role('subscriber'); 
    471         $role->add_cap('read'); 
    472         $role->add_cap('level_0'); 
     461    // Add caps for Subscriber role 
     462    $role =& get_role('subscriber'); 
     463    $role->add_cap('read'); 
     464    $role->add_cap('level_0'); 
    473465} 
    474466 
    475467/** 
     
    478470 * @since 2.1.0 
    479471 */ 
    480472function populate_roles_210() { 
    481         $roles = array('administrator', 'editor'); 
    482         foreach ($roles as $role) { 
    483                 $role =& get_role($role); 
    484                 if ( empty($role) ) 
    485                         continue; 
     473    $roles = array('administrator', 'editor'); 
     474    foreach ($roles as $role) { 
     475        $role =& get_role($role); 
     476        if ( empty($role) ) 
     477            continue; 
    486478 
    487                 $role->add_cap('edit_others_pages'); 
    488                 $role->add_cap('edit_published_pages'); 
    489                 $role->add_cap('publish_pages'); 
    490                 $role->add_cap('delete_pages'); 
    491                 $role->add_cap('delete_others_pages'); 
    492                 $role->add_cap('delete_published_pages'); 
    493                 $role->add_cap('delete_posts'); 
    494                 $role->add_cap('delete_others_posts'); 
    495                 $role->add_cap('delete_published_posts'); 
    496                 $role->add_cap('delete_private_posts'); 
    497                 $role->add_cap('edit_private_posts'); 
    498                 $role->add_cap('read_private_posts'); 
    499                 $role->add_cap('delete_private_pages'); 
    500                 $role->add_cap('edit_private_pages'); 
    501                 $role->add_cap('read_private_pages'); 
    502         } 
     479        $role->add_cap('edit_others_pages'); 
     480        $role->add_cap('edit_published_pages'); 
     481        $role->add_cap('publish_pages'); 
     482        $role->add_cap('delete_pages'); 
     483        $role->add_cap('delete_others_pages'); 
     484        $role->add_cap('delete_published_pages'); 
     485        $role->add_cap('delete_posts'); 
     486        $role->add_cap('delete_others_posts'); 
     487        $role->add_cap('delete_published_posts'); 
     488        $role->add_cap('delete_private_posts'); 
     489        $role->add_cap('edit_private_posts'); 
     490        $role->add_cap('read_private_posts'); 
     491        $role->add_cap('delete_private_pages'); 
     492        $role->add_cap('edit_private_pages'); 
     493        $role->add_cap('read_private_pages'); 
     494    } 
    503495 
    504         $role =& get_role('administrator'); 
    505         if ( ! empty($role) ) { 
    506                 $role->add_cap('delete_users'); 
    507                 $role->add_cap('create_users'); 
    508         } 
     496    $role =& get_role('administrator'); 
     497    if ( ! empty($role) ) { 
     498        $role->add_cap('delete_users'); 
     499        $role->add_cap('create_users'); 
     500    } 
    509501 
    510         $role =& get_role('author'); 
    511         if ( ! empty($role) ) { 
    512                 $role->add_cap('delete_posts'); 
    513                 $role->add_cap('delete_published_posts'); 
    514         } 
     502    $role =& get_role('author'); 
     503    if ( ! empty($role) ) { 
     504        $role->add_cap('delete_posts'); 
     505        $role->add_cap('delete_published_posts'); 
     506    } 
    515507 
    516         $role =& get_role('contributor'); 
    517         if ( ! empty($role) ) { 
    518                 $role->add_cap('delete_posts'); 
    519         } 
     508    $role =& get_role('contributor'); 
     509    if ( ! empty($role) ) { 
     510        $role->add_cap('delete_posts'); 
     511    } 
    520512} 
    521513 
    522514/** 
     
    525517 * @since 2.3.0 
    526518 */ 
    527519function populate_roles_230() { 
    528         $role =& get_role( 'administrator' ); 
     520    $role =& get_role( 'administrator' ); 
    529521 
    530         if ( !empty( $role ) ) { 
    531                 $role->add_cap( 'unfiltered_upload' ); 
    532         } 
     522    if ( !empty( $role ) ) { 
     523        $role->add_cap( 'unfiltered_upload' ); 
     524    } 
    533525} 
    534526 
    535527/** 
     
    538530 * @since 2.5.0 
    539531 */ 
    540532function populate_roles_250() { 
    541         $role =& get_role( 'administrator' ); 
     533    $role =& get_role( 'administrator' ); 
    542534 
    543         if ( !empty( $role ) ) { 
    544                 $role->add_cap( 'edit_dashboard' ); 
    545         } 
     535    if ( !empty( $role ) ) { 
     536        $role->add_cap( 'edit_dashboard' ); 
     537    } 
    546538} 
    547539 
    548540/** 
     
    551543 * @since 2.6.0 
    552544 */ 
    553545function populate_roles_260() { 
    554         $role =& get_role( 'administrator' ); 
     546    $role =& get_role( 'administrator' ); 
    555547 
    556         if ( !empty( $role ) ) { 
    557                 $role->add_cap( 'update_plugins' ); 
    558                 $role->add_cap( 'delete_plugins' ); 
    559         } 
     548    if ( !empty( $role ) ) { 
     549        $role->add_cap( 'update_plugins' ); 
     550        $role->add_cap( 'delete_plugins' ); 
     551    } 
    560552} 
    561553 
    562554/** 
     
    565557 * @since 2.7.0 
    566558 */ 
    567559function populate_roles_270() { 
    568         $role =& get_role( 'administrator' ); 
     560    $role =& get_role( 'administrator' ); 
    569561 
    570         if ( !empty( $role ) ) { 
    571                 $role->add_cap( 'install_plugins' ); 
    572                 $role->add_cap( 'update_themes' ); 
    573         } 
     562    if ( !empty( $role ) ) { 
     563        $role->add_cap( 'install_plugins' ); 
     564        $role->add_cap( 'update_themes' ); 
     565    } 
    574566} 
    575567 
    576568/** 
     
    579571 * @since 2.8.0 
    580572 */ 
    581573function populate_roles_280() { 
    582         $role =& get_role( 'administrator' ); 
     574    $role =& get_role( 'administrator' ); 
    583575 
    584         if ( !empty( $role ) ) { 
    585                 $role->add_cap( 'install_themes' ); 
    586         } 
     576    if ( !empty( $role ) ) { 
     577        $role->add_cap( 'install_themes' ); 
     578    } 
    587579} 
    588580 
    589581?> 
  • wp-admin/setup-config.php

     
    3535 
    3636$configFile = file(ABSPATH . 'wp-config-sample.php'); 
    3737 
     38if ( !is_writable(ABSPATH)) 
     39        wp_die("Sorry, I can't write to the directory. You'll have to either change the permissions on your WordPress directory or create your wp-config.php manually."); 
     40 
    3841// Check if wp-config.php has been created 
    3942if (file_exists(ABSPATH . 'wp-config.php')) 
    4043        wp_die("<p>The file 'wp-config.php' already exists. If you need to reset any of the configuration items in this file, please delete it first. You may try <a href='install.php'>installing now</a>.</p>"); 
    4144 
    42 // Check if wp-config.php exists above the root directory but is not part of another install 
    43 if (file_exists(ABSPATH . '../wp-config.php') && ! file_exists(ABSPATH . '../wp-settings.php')) 
     45// Check if wp-config.php exists above the root directory 
     46if (file_exists(ABSPATH . '../wp-config.php') && ! file_exists(ABSPATH . '../wp-load.php')) 
    4447        wp_die("<p>The file 'wp-config.php' already exists one level above your WordPress installation. If you need to reset any of the configuration items in this file, please delete it first. You may try <a href='install.php'>installing now</a>.</p>"); 
    4548 
    4649if (isset($_GET['step'])) 
     
    8386        <li>Database username</li> 
    8487        <li>Database password</li> 
    8588        <li>Database host</li> 
     89        <li>Database type</li> 
    8690        <li>Table prefix (if you want to run more than one WordPress in a single database) </li> 
    8791</ol> 
    8892<p><strong>If for any reason this automatic file creation doesn't work, don't worry. All this does is fill in the database information to a configuration file. You may also simply open <code>wp-config-sample.php</code> in a text editor, fill in your information, and save it as <code>wp-config.php</code>. </strong></p> 
     
    106110                <tr> 
    107111                        <th scope="row"><label for="uname">User Name</label></th> 
    108112                        <td><input name="uname" id="uname" type="text" size="25" value="username" /></td> 
    109                         <td>Your MySQL username</td> 
     113                        <td>Your DB username</td> 
    110114                </tr> 
    111115                <tr> 
    112116                        <th scope="row"><label for="pwd">Password</label></th> 
    113117                        <td><input name="pwd" id="pwd" type="text" size="25" value="password" /></td> 
    114                         <td>...and MySQL password.</td> 
     118                        <td>...and DB password.</td> 
    115119                </tr> 
    116120                <tr> 
    117121                        <th scope="row"><label for="dbhost">Database Host</label></th> 
    118122                        <td><input name="dbhost" id="dbhost" type="text" size="25" value="localhost" /></td> 
    119                         <td>99% chance you won't need to change this value.</td> 
     123                        <td>DB host.</td> 
    120124                </tr> 
    121125                <tr> 
     126                        <th scope="row"><label for="dbtype">Database Type</label></th> 
     127                        <td> 
     128                                <select name="dbtype" id="dbtype"> 
     129                                <?php 
     130                                $folders = array(); 
     131                                if (is_dir(ABSPATH . 'wp-includes/wp-db/')) { 
     132                                        $dir = ABSPATH . 'wp-includes/wp-db/'; 
     133                                        $handle = dir($dir); 
     134                                        while ($filename = $handle->read()) { 
     135                                                $restricted = array('.','..','.svn'); 
     136                                                $path = realpath($dir.$filename); 
     137                                                if (is_dir($path) && !in_array($filename,$restricted)) { 
     138                                                        if ($path !== '/') { 
     139                                                                $path .= '/'; 
     140                                                        } 
     141                                                        if (is_readable($path)) { 
     142                                                                $folders[] = $filename; 
     143                                                        } 
     144                                                } 
     145                                        } 
     146                                } 
     147                                if (empty($folders)) { 
     148                                        $folders[] = 'mysql'; // should always have at least mysql 
     149                                } 
     150                                foreach($folders as $folder) { 
     151                                        // mysql as default 
     152                                        if ($folder == 'mysql') { 
     153                                                echo "<option value=\"$folder\" selected=\"true\">MySQL</option>\n"; 
     154                                        } elseif ($folder == 'sqlsrv') { 
     155                                                echo "<option value=\"$folder\">SQL Server using MS PHP driver (SQLSRV; PHP5 &amp; Win req.)</option>\n"; 
     156                                        } elseif ($folder == 'mssql') { 
     157                                                echo "<option value=\"$folder\">SQL Server using PHP native driver (MSSQL)</option>\n"; 
     158                                        } else { 
     159                                                echo "<option value=\"$folder\">$folder</option>\n"; 
     160                                        } 
     161                                } 
     162                                ?> 
     163                                </select> 
     164                <td>The DB Type.</td> 
     165                </tr> 
     166                <tr> 
    122167                        <th scope="row"><label for="prefix">Table Prefix</label></th> 
    123168                        <td><input name="prefix" id="prefix" type="text" id="prefix" value="wp_" size="25" /></td> 
    124169                        <td>If you want to run multiple WordPress installations in a single database, change this.</td> 
     
    134179        $uname   = trim($_POST['uname']); 
    135180        $passwrd = trim($_POST['pwd']); 
    136181        $dbhost  = trim($_POST['dbhost']); 
     182        $dbtype  = trim($_POST['dbtype']); 
    137183        $prefix  = trim($_POST['prefix']); 
    138184        if (empty($prefix)) $prefix = 'wp_'; 
    139185 
     
    145191        define('DB_USER', $uname); 
    146192        define('DB_PASSWORD', $passwrd); 
    147193        define('DB_HOST', $dbhost); 
     194        define('DB_TYPE', $dbtype); 
    148195        /**#@-*/ 
    149196 
    150197        // We'll fail here if the values are no good. 
     
    152199        if ( !empty($wpdb->error) ) 
    153200                wp_die($wpdb->error->get_error_message()); 
    154201 
     202        $handle = fopen(ABSPATH . 'wp-config.php', 'w'); 
     203 
    155204        foreach ($configFile as $line_num => $line) { 
    156205                switch (substr($line,0,16)) { 
    157206                        case "define('DB_NAME'": 
    158                                 $configFile[$line_num] = str_replace("putyourdbnamehere", $dbname, $line); 
     207                                fwrite($handle, str_replace("putyourdbnamehere", $dbname, $line)); 
    159208                                break; 
    160209                        case "define('DB_USER'": 
    161                                 $configFile[$line_num] = str_replace("'usernamehere'", "'$uname'", $line); 
     210                                fwrite($handle, str_replace("'usernamehere'", "'$uname'", $line)); 
    162211                                break; 
    163212                        case "define('DB_PASSW": 
    164                                 $configFile[$line_num] = str_replace("'yourpasswordhere'", "'$passwrd'", $line); 
     213                                fwrite($handle, str_replace("'yourpasswordhere'", "'$passwrd'", $line)); 
    165214                                break; 
    166215                        case "define('DB_HOST'": 
    167                                 $configFile[$line_num] = str_replace("localhost", $dbhost, $line); 
     216                                fwrite($handle, str_replace("localhost", $dbhost, $line)); 
    168217                                break; 
     218                        case "define('DB_TYPE'": 
     219                                        fwrite($handle, str_replace("mysql", $dbtype, $line)); 
     220                        break; 
    169221                        case '$table_prefix  =': 
    170                                 $configFile[$line_num] = str_replace('wp_', $prefix, $line); 
     222                                fwrite($handle, str_replace('wp_', $prefix, $line)); 
    171223                                break; 
     224                        default: 
     225                                fwrite($handle, $line); 
    172226                } 
    173227        } 
    174         if ( ! is_writable(ABSPATH) ) : 
    175                 display_header(); 
     228        fclose($handle); 
     229        chmod(ABSPATH . 'wp-config.php', 0666); 
     230 
     231        display_header(); 
    176232?> 
    177 <p>Sorry, but I can't write the <code>wp-config.php</code> file.</p> 
    178 <p>You can create the <code>wp-config.php</code> manually and paste the following text into it.</p> 
    179 <textarea cols="90" rows="15"><?php 
    180                 foreach( $configFile as $line ) { 
    181                         echo htmlentities($line); 
    182                 } 
    183 ?></textarea> 
    184 <p>After you've done that, click "Run the install."</p> 
    185 <p class="step"><a href="install.php" class="button">Run the install</a></p> 
    186 <?php 
    187         else : 
    188                 $handle = fopen(ABSPATH . 'wp-config.php', 'w'); 
    189                 foreach( $configFile as $line ) { 
    190                         fwrite($handle, $line); 
    191                 } 
    192                 fclose($handle); 
    193                 chmod(ABSPATH . 'wp-config.php', 0666); 
    194                 display_header(); 
    195 ?> 
    196233<p>All right sparky! You've made it through this part of the installation. WordPress can now communicate with your database. If you are ready, time now to&hellip;</p> 
    197234 
    198235<p class="step"><a href="install.php" class="button">Run the install</a></p> 
    199236<?php 
    200         endif; 
    201237        break; 
    202238} 
    203239?>