WordPress.org

Make WordPress Core

Ticket #37699: 37699.diff

File 37699.diff, 216.8 KB (added by wonderboymusic, 3 years ago)
  • src/wp-includes/author-template.php

     
    332332 *
    333333 * @since 1.2.0
    334334 *
    335  * @global wpdb $wpdb WordPress database abstraction object.
    336  *
    337335 * @param string|array $args {
    338336 *     Optional. Array or string of default arguments.
    339337 *
     
    361359 * @return string|void The output, if echo is set to false.
    362360 */
    363361function wp_list_authors( $args = '' ) {
    364         global $wpdb;
    365 
    366362        $defaults = array(
    367363                'orderby' => 'name', 'order' => 'ASC', 'number' => '',
    368364                'optioncount' => false, 'exclude_admin' => true,
     
    379375        $query_args['fields'] = 'ids';
    380376        $authors = get_users( $query_args );
    381377
     378        $wpdb = WP::get( 'wpdb' );
    382379        $author_count = array();
    383380        foreach ( (array) $wpdb->get_results( "SELECT DISTINCT post_author, COUNT(ID) AS count FROM $wpdb->posts WHERE " . get_private_posts_cap_sql( 'post' ) . " GROUP BY post_author" ) as $row ) {
    384381                $author_count[$row->post_author] = $row->count;
     
    466463 *
    467464 * @since 3.2.0
    468465 *
    469  * @global wpdb $wpdb WordPress database abstraction object.
    470  *
    471466 * @return bool Whether or not we have more than one author
    472467 */
    473468function is_multi_author() {
    474         global $wpdb;
    475 
    476469        if ( false === ( $is_multi_author = get_transient( 'is_multi_author' ) ) ) {
     470                $wpdb = WP::get( 'wpdb' );
    477471                $rows = (array) $wpdb->get_col("SELECT DISTINCT post_author FROM $wpdb->posts WHERE post_type = 'post' AND post_status = 'publish' LIMIT 2");
    478472                $is_multi_author = 1 < count( $rows ) ? 1 : 0;
    479473                set_transient( 'is_multi_author', $is_multi_author );
  • src/wp-includes/bookmark.php

     
    1111 *
    1212 * @since 2.1.0
    1313 *
    14  * @global wpdb $wpdb WordPress database abstraction object.
    15  *
    1614 * @param int|stdClass $bookmark
    1715 * @param string $output Optional. Either OBJECT, ARRAY_N, or ARRAY_A constant
    1816 * @param string $filter Optional, default is 'raw'.
     
    1917 * @return array|object|null Type returned depends on $output value.
    2018 */
    2119function get_bookmark($bookmark, $output = OBJECT, $filter = 'raw') {
    22         global $wpdb;
    23 
    2420        if ( empty($bookmark) ) {
    2521                if ( isset($GLOBALS['link']) )
    2622                        $_bookmark = & $GLOBALS['link'];
     
    3329                if ( isset($GLOBALS['link']) && ($GLOBALS['link']->link_id == $bookmark) ) {
    3430                        $_bookmark = & $GLOBALS['link'];
    3531                } elseif ( ! $_bookmark = wp_cache_get($bookmark, 'bookmark') ) {
     32                        $wpdb = WP::get( 'wpdb' );
    3633                        $_bookmark = $wpdb->get_row($wpdb->prepare("SELECT * FROM $wpdb->links WHERE link_id = %d LIMIT 1", $bookmark));
    3734                        if ( $_bookmark ) {
    3835                                $_bookmark->link_category = array_unique( wp_get_object_terms( $_bookmark->link_id, 'link_category', array( 'fields' => 'ids' ) ) );
     
    9289 *
    9390 * @since 2.1.0
    9491 *
    95  * @global wpdb $wpdb WordPress database abstraction object.
    96  *
    9792 * @param string|array $args {
    9893 *     Optional. String or array of arguments to retrieve bookmarks.
    9994 *
     
    115110 * @return array List of bookmark row objects.
    116111 */
    117112function get_bookmarks( $args = '' ) {
    118         global $wpdb;
    119 
    120113        $defaults = array(
    121114                'orderby' => 'name', 'order' => 'ASC',
    122115                'limit' => -1, 'category' => '',
     
    203196                }
    204197        }
    205198
     199        $wpdb = WP::get( 'wpdb' );
    206200        $search = '';
    207201        if ( ! empty( $r['search'] ) ) {
    208202                $like = '%' . $wpdb->esc_like( $r['search'] ) . '%';
  • src/wp-includes/canonical.php

     
    3131 * @global WP_Rewrite $wp_rewrite
    3232 * @global bool $is_IIS
    3333 * @global WP_Query $wp_query
    34  * @global wpdb $wpdb WordPress database abstraction object.
    3534 *
    3635 * @param string $requested_url Optional. The URL that was requested, used to
    3736 *              figure if redirect is needed.
     
    3938 * @return string|void The string of the URL, if redirect needed.
    4039 */
    4140function redirect_canonical( $requested_url = null, $do_redirect = true ) {
    42         global $wp_rewrite, $is_IIS, $wp_query, $wpdb, $wp;
     41        global $wp_rewrite, $is_IIS, $wp_query, $wp;
    4342
    4443        if ( isset( $_SERVER['REQUEST_METHOD'] ) && ! in_array( strtoupper( $_SERVER['REQUEST_METHOD'] ), array( 'GET', 'HEAD' ) ) ) {
    4544                return;
     
    9897        }
    9998
    10099        if ( is_singular() && 1 > $wp_query->post_count && ($id = get_query_var('p')) ) {
    101 
     100                $wpdb = WP::get( 'wpdb' );
    102101                $vars = $wpdb->get_results( $wpdb->prepare("SELECT post_type, post_parent FROM $wpdb->posts WHERE ID = %d", $id) );
    103102
    104103                if ( isset($vars[0]) && $vars = $vars[0] ) {
     
    204203                                $redirect['query'] = remove_query_arg('year', $redirect['query']);
    205204                } elseif ( is_author() && !empty($_GET['author']) && preg_match( '|^[0-9]+$|', $_GET['author'] ) ) {
    206205                        $author = get_userdata(get_query_var('author'));
     206                        $wpdb = WP::get( 'wpdb' );
    207207                        if ( ( false !== $author ) && $wpdb->get_var( $wpdb->prepare( "SELECT ID FROM $wpdb->posts WHERE $wpdb->posts.post_author = %d AND $wpdb->posts.post_status = 'publish' LIMIT 1", $author->ID ) ) ) {
    208208                                if ( $redirect_url = get_author_posts_url($author->ID, $author->user_nicename) )
    209209                                        $redirect['query'] = remove_query_arg('author', $redirect['query']);
     
    581581 *
    582582 * @since 2.3.0
    583583 *
    584  * @global wpdb $wpdb WordPress database abstraction object.
    585  *
    586584 * @return false|string The correct URL if one is found. False on failure.
    587585 */
    588586function redirect_guess_404_permalink() {
    589         global $wpdb;
    590 
    591587        if ( get_query_var('name') ) {
     588                $wpdb = WP::get( 'wpdb' );
    592589                $where = $wpdb->prepare("post_name LIKE %s", $wpdb->esc_like( get_query_var('name') ) . '%');
    593590
    594591                // if any of post_type, year, monthnum, or day are set, use them to refine the query
  • src/wp-includes/class-wp-comment-query.php

     
    141141                return false;
    142142        }
    143143
     144        protected $dbh;
     145
    144146        /**
    145147         * Constructor.
    146148         *
     
    260262         * }
    261263         */
    262264        public function __construct( $query = '' ) {
     265                $this->dbh = WP::get( 'wpdb' );
     266
    263267                $this->query_var_defaults = array(
    264268                        'author_email' => '',
    265269                        'author_url' => '',
     
    363367         * @since 4.2.0
    364368         * @access public
    365369         *
    366          * @global wpdb $wpdb WordPress database abstraction object.
    367          *
    368370         * @return int|array List of comments or number of found comments if `$count` argument is true.
    369371         */
    370372        public function get_comments() {
    371                 global $wpdb;
    372 
    373373                $this->parse_query();
    374374
    375375                // Parse meta query
     
    388388                // Reparse query vars, in case they were modified in a 'pre_get_comments' callback.
    389389                $this->meta_query->parse_query_vars( $this->query_vars );
    390390                if ( ! empty( $this->meta_query->queries ) ) {
    391                         $this->meta_query_clauses = $this->meta_query->get_sql( 'comment', $wpdb->comments, 'comment_ID', $this );
     391                        $this->meta_query_clauses = $this->meta_query->get_sql( 'comment', $this->dbh->comments, 'comment_ID', $this );
    392392                }
    393393
    394394                // $args can include anything. Only use the args defined in the query_var_defaults to compute the key.
     
    480480         *
    481481         * @since 4.4.0
    482482         * @access protected
    483          *
    484          * @global wpdb $wpdb WordPress database abstraction object.
    485483         */
    486484        protected function get_comment_ids() {
    487                 global $wpdb;
    488 
    489485                // Assemble clauses related to 'comment_approved'.
    490486                $approved_clauses = array();
    491487
     
    514510                                                break;
    515511
    516512                                        default :
    517                                                 $status_clauses[] = $wpdb->prepare( "comment_approved = %s", $status );
     513                                                $status_clauses[] = $this->dbh->prepare( "comment_approved = %s", $status );
    518514                                                break;
    519515                                }
    520516                        }
     
    537533                        foreach ( $include_unapproved as $unapproved_identifier ) {
    538534                                // Numeric values are assumed to be user ids.
    539535                                if ( is_numeric( $unapproved_identifier ) ) {
    540                                         $approved_clauses[] = $wpdb->prepare( "( user_id = %d AND comment_approved = '0' )", $unapproved_identifier );
     536                                        $approved_clauses[] = $this->dbh->prepare( "( user_id = %d AND comment_approved = '0' )", $unapproved_identifier );
    541537
    542538                                // Otherwise we match against email addresses.
    543539                                } else {
    544                                         $approved_clauses[] = $wpdb->prepare( "( comment_author_email = %s AND comment_approved = '0' )", $unapproved_identifier );
     540                                        $approved_clauses[] = $this->dbh->prepare( "( comment_author_email = %s AND comment_approved = '0' )", $unapproved_identifier );
    545541                                }
    546542                        }
    547543                }
     
    600596
    601597                        // If no valid clauses were found, order by comment_date_gmt.
    602598                        if ( empty( $orderby_array ) ) {
    603                                 $orderby_array[] = "$wpdb->comments.comment_date_gmt $order";
     599                                $orderby_array[] = "{$this->dbh->comments}.comment_date_gmt $order";
    604600                        }
    605601
    606602                        // To ensure determinate sorting, always include a comment_ID clause.
     
    633629                                        $comment_ID_order = 'DESC';
    634630                                }
    635631
    636                                 $orderby_array[] = "$wpdb->comments.comment_ID $comment_ID_order";
     632                                $orderby_array[] = "{$this->dbh->comments}.comment_ID $comment_ID_order";
    637633                        }
    638634
    639635                        $orderby = implode( ', ', $orderby_array );
    640636                } else {
    641                         $orderby = "$wpdb->comments.comment_date_gmt $order";
     637                        $orderby = "{$this->dbh->comments}.comment_date_gmt $order";
    642638                }
    643639
    644640                $number = absint( $this->query_vars['number'] );
     
    655651                if ( $this->query_vars['count'] ) {
    656652                        $fields = 'COUNT(*)';
    657653                } else {
    658                         $fields = "$wpdb->comments.comment_ID";
     654                        $fields = "{$this->dbh->comments}.comment_ID";
    659655                }
    660656
    661657                $post_id = absint( $this->query_vars['post_id'] );
    662658                if ( ! empty( $post_id ) ) {
    663                         $this->sql_clauses['where']['post_id'] = $wpdb->prepare( 'comment_post_ID = %d', $post_id );
     659                        $this->sql_clauses['where']['post_id'] = $this->dbh->prepare( 'comment_post_ID = %d', $post_id );
    664660                }
    665661
    666662                // Parse comment IDs for an IN clause.
    667663                if ( ! empty( $this->query_vars['comment__in'] ) ) {
    668                         $this->sql_clauses['where']['comment__in'] = "$wpdb->comments.comment_ID IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['comment__in'] ) ) . ' )';
     664                        $this->sql_clauses['where']['comment__in'] = "{$this->dbh->comments}.comment_ID IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['comment__in'] ) ) . ' )';
    669665                }
    670666
    671667                // Parse comment IDs for a NOT IN clause.
    672668                if ( ! empty( $this->query_vars['comment__not_in'] ) ) {
    673                         $this->sql_clauses['where']['comment__not_in'] = "$wpdb->comments.comment_ID NOT IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['comment__not_in'] ) ) . ' )';
     669                        $this->sql_clauses['where']['comment__not_in'] = "{$this->dbh->comments}.comment_ID NOT IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['comment__not_in'] ) ) . ' )';
    674670                }
    675671
    676672                // Parse comment parent IDs for an IN clause.
     
    694690                }
    695691
    696692                if ( '' !== $this->query_vars['author_email'] ) {
    697                         $this->sql_clauses['where']['author_email'] = $wpdb->prepare( 'comment_author_email = %s', $this->query_vars['author_email'] );
     693                        $this->sql_clauses['where']['author_email'] = $this->dbh->prepare( 'comment_author_email = %s', $this->query_vars['author_email'] );
    698694                }
    699695
    700696                if ( '' !== $this->query_vars['author_url'] ) {
    701                         $this->sql_clauses['where']['author_url'] = $wpdb->prepare( 'comment_author_url = %s', $this->query_vars['author_url'] );
     697                        $this->sql_clauses['where']['author_url'] = $this->dbh->prepare( 'comment_author_url = %s', $this->query_vars['author_url'] );
    702698                }
    703699
    704700                if ( '' !== $this->query_vars['karma'] ) {
    705                         $this->sql_clauses['where']['karma'] = $wpdb->prepare( 'comment_karma = %d', $this->query_vars['karma'] );
     701                        $this->sql_clauses['where']['karma'] = $this->dbh->prepare( 'comment_karma = %d', $this->query_vars['karma'] );
    706702                }
    707703
    708704                // Filtering by comment_type: 'type', 'type__in', 'type__not_in'.
     
    733729                                                break;
    734730
    735731                                        default:
    736                                                 $comment_types[ $operator ][] = $wpdb->prepare( '%s', $type );
     732                                                $comment_types[ $operator ][] = $this->dbh->prepare( '%s', $type );
    737733                                                break;
    738734                                }
    739735                        }
     
    750746                }
    751747
    752748                if ( '' !== $parent ) {
    753                         $this->sql_clauses['where']['parent'] = $wpdb->prepare( 'comment_parent = %d', $parent );
     749                        $this->sql_clauses['where']['parent'] = $this->dbh->prepare( 'comment_parent = %d', $parent );
    754750                }
    755751
    756752                if ( is_array( $this->query_vars['user_id'] ) ) {
    757753                        $this->sql_clauses['where']['user_id'] = 'user_id IN (' . implode( ',', array_map( 'absint', $this->query_vars['user_id'] ) ) . ')';
    758754                } elseif ( '' !== $this->query_vars['user_id'] ) {
    759                         $this->sql_clauses['where']['user_id'] = $wpdb->prepare( 'user_id = %d', $this->query_vars['user_id'] );
     755                        $this->sql_clauses['where']['user_id'] = $this->dbh->prepare( 'user_id = %d', $this->query_vars['user_id'] );
    760756                }
    761757
    762758                // Falsy search strings are ignored.
     
    780776                        foreach ( $post_fields as $field_name => $field_value ) {
    781777                                // $field_value may be an array.
    782778                                $esses = array_fill( 0, count( (array) $field_value ), '%s' );
    783                                 $this->sql_clauses['where'][ $field_name ] = $wpdb->prepare( " {$wpdb->posts}.{$field_name} IN (" . implode( ',', $esses ) . ')', $field_value );
     779                                $this->sql_clauses['where'][ $field_name ] = $this->dbh->prepare( " {$this->dbh->posts}.{$field_name} IN (" . implode( ',', $esses ) . ')', $field_value );
    784780                        }
    785781                }
    786782
     
    801797                                $join_posts_table = true;
    802798
    803799                                $esses = array_fill( 0, count( $q_values ), '%s' );
    804                                 $this->sql_clauses['where'][ $field_name ] = $wpdb->prepare( " {$wpdb->posts}.{$field_name} IN (" . implode( ',', $esses ) . ")", $q_values );
     800                                $this->sql_clauses['where'][ $field_name ] = $this->dbh->prepare( " {$this->dbh->posts}.{$field_name} IN (" . implode( ',', $esses ) . ")", $q_values );
    805801                        }
    806802                }
    807803
     
    830826                $join = '';
    831827
    832828                if ( $join_posts_table ) {
    833                         $join .= "JOIN $wpdb->posts ON $wpdb->posts.ID = $wpdb->comments.comment_post_ID";
     829                        $join .= "JOIN {$this->dbh->posts} ON {$this->dbh->posts}.ID = {$this->dbh->comments}.comment_post_ID";
    834830                }
    835831
    836832                if ( ! empty( $this->meta_query_clauses ) ) {
     
    840836                        $this->sql_clauses['where']['meta_query'] = preg_replace( '/^\s*AND\s*/', '', $this->meta_query_clauses['where'] );
    841837
    842838                        if ( ! $this->query_vars['count'] ) {
    843                                 $groupby = "{$wpdb->comments}.comment_ID";
     839                                $groupby = "{$this->dbh->comments}.comment_ID";
    844840                        }
    845841                }
    846842
     
    889885                }
    890886
    891887                $this->sql_clauses['select']  = "SELECT $found_rows $fields";
    892                 $this->sql_clauses['from']    = "FROM $wpdb->comments $join";
     888                $this->sql_clauses['from']    = "FROM {$this->dbh->comments} $join";
    893889                $this->sql_clauses['groupby'] = $groupby;
    894890                $this->sql_clauses['orderby'] = $orderby;
    895891                $this->sql_clauses['limits']  = $limits;
     
    897893                $this->request = "{$this->sql_clauses['select']} {$this->sql_clauses['from']} {$where} {$this->sql_clauses['groupby']} {$this->sql_clauses['orderby']} {$this->sql_clauses['limits']}";
    898894
    899895                if ( $this->query_vars['count'] ) {
    900                         return intval( $wpdb->get_var( $this->request ) );
     896                        return intval( $this->dbh->get_var( $this->request ) );
    901897                } else {
    902                         $comment_ids = $wpdb->get_col( $this->request );
     898                        $comment_ids = $this->dbh->get_col( $this->request );
    903899                        return array_map( 'intval', $comment_ids );
    904900                }
    905901        }
     
    910906         *
    911907         * @since 4.6.0
    912908         * @access private
    913          *
    914          * @global wpdb $wpdb WordPress database abstraction object.
    915909         */
    916910        private function set_found_comments() {
    917                 global $wpdb;
    918 
    919911                if ( $this->query_vars['number'] && ! $this->query_vars['no_found_rows'] ) {
    920912                        /**
    921913                         * Filters the query used to retrieve found comment count.
     
    927919                         */
    928920                        $found_comments_query = apply_filters( 'found_comments_query', 'SELECT FOUND_ROWS()', $this );
    929921
    930                         $this->found_comments = (int) $wpdb->get_var( $found_comments_query );
     922                        $this->found_comments = (int) $this->dbh->get_var( $found_comments_query );
    931923                }
    932924        }
    933925
     
    943935         * @return array
    944936         */
    945937        protected function fill_descendants( $comments ) {
    946                 global $wpdb;
    947 
    948938                $levels = array(
    949939                        0 => wp_list_pluck( $comments, 'comment_ID' ),
    950940                );
     
    996986
    997987                        if ( $uncached_parent_ids ) {
    998988                                $where = 'WHERE ' . $_where . ' AND comment_parent IN (' . implode( ',', array_map( 'intval', $uncached_parent_ids ) ) . ')';
    999                                 $level_comments = $wpdb->get_results( "SELECT $wpdb->comments.comment_ID, $wpdb->comments.comment_parent {$this->sql_clauses['from']} {$where} {$this->sql_clauses['groupby']} ORDER BY comment_date_gmt ASC, comment_ID ASC" );
     989                                $level_comments = $this->dbh->get_results( "SELECT {$this->dbh->comments}.comment_ID, {$this->dbh->comments}.comment_parent {$this->sql_clauses['from']} {$where} {$this->sql_clauses['groupby']} ORDER BY comment_date_gmt ASC, comment_ID ASC" );
    1000990
    1001991                                // Cache parent-child relationships.
    1002992                                $parent_map = array_fill_keys( $uncached_parent_ids, array() );
     
    10671057         * @since 3.1.0
    10681058         * @access protected
    10691059         *
    1070          * @global wpdb $wpdb WordPress database abstraction object.
    1071          *
    10721060         * @param string $string
    10731061         * @param array $cols
    10741062         * @return string
    10751063         */
    10761064        protected function get_search_sql( $string, $cols ) {
    1077                 global $wpdb;
     1065                $like = '%' . $this->dbh->esc_like( $string ) . '%';
    10781066
    1079                 $like = '%' . $wpdb->esc_like( $string ) . '%';
    1080 
    10811067                $searches = array();
    10821068                foreach ( $cols as $col ) {
    1083                         $searches[] = $wpdb->prepare( "$col LIKE %s", $like );
     1069                        $searches[] = $this->dbh->prepare( "$col LIKE %s", $like );
    10841070                }
    10851071
    10861072                return ' AND (' . implode(' OR ', $searches) . ')';
     
    10921078         * @since 4.2.0
    10931079         * @access protected
    10941080         *
    1095          * @global wpdb $wpdb WordPress database abstraction object.
    1096          *
    10971081         * @param string $orderby Alias for the field to order by.
    10981082         * @return string|false Value to used in the ORDER clause. False otherwise.
    10991083         */
    11001084        protected function parse_orderby( $orderby ) {
    1101                 global $wpdb;
    1102 
    11031085                $allowed_keys = array(
    11041086                        'comment_agent',
    11051087                        'comment_approved',
     
    11311113
    11321114                $parsed = false;
    11331115                if ( $orderby == $this->query_vars['meta_key'] || $orderby == 'meta_value' ) {
    1134                         $parsed = "$wpdb->commentmeta.meta_value";
     1116                        $parsed = "{$this->dbh->commentmeta}.meta_value";
    11351117                } elseif ( $orderby == 'meta_value_num' ) {
    1136                         $parsed = "$wpdb->commentmeta.meta_value+0";
     1118                        $parsed = "{$this->dbh->commentmeta}.meta_value+0";
    11371119                } elseif ( $orderby == 'comment__in' ) {
    11381120                        $comment__in = implode( ',', array_map( 'absint', $this->query_vars['comment__in'] ) );
    1139                         $parsed = "FIELD( {$wpdb->comments}.comment_ID, $comment__in )";
     1121                        $parsed = "FIELD( {$this->dbh->comments}.comment_ID, $comment__in )";
    11401122                } elseif ( in_array( $orderby, $allowed_keys ) ) {
    11411123
    11421124                        if ( isset( $meta_query_clauses[ $orderby ] ) ) {
     
    11431125                                $meta_clause = $meta_query_clauses[ $orderby ];
    11441126                                $parsed = sprintf( "CAST(%s.meta_value AS %s)", esc_sql( $meta_clause['alias'] ), esc_sql( $meta_clause['cast'] ) );
    11451127                        } else {
    1146                                 $parsed = "$wpdb->comments.$orderby";
     1128                                $parsed = "{$this->dbh->comments}.$orderby";
    11471129                        }
    11481130                }
    11491131
  • src/wp-includes/class-wp-comment.php

     
    183183         * @access public
    184184         * @static
    185185         *
    186          * @global wpdb $wpdb WordPress database abstraction object.
    187          *
    188186         * @param int $id Comment ID.
    189187         * @return WP_Comment|false Comment object, otherwise false.
    190188         */
    191189        public static function get_instance( $id ) {
    192                 global $wpdb;
    193 
    194190                $comment_id = (int) $id;
    195191                if ( ! $comment_id ) {
    196192                        return false;
     
    199195                $_comment = wp_cache_get( $comment_id, 'comment' );
    200196
    201197                if ( ! $_comment ) {
     198                        $wpdb = WP::get( 'wpdb' );
    202199                        $_comment = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->comments WHERE comment_ID = %d LIMIT 1", $comment_id ) );
    203200
    204201                        if ( ! $_comment ) {
  • src/wp-includes/class-wp-meta-query.php

     
    105105         */
    106106        protected $has_or_relation = false;
    107107
     108        protected $dbh;
     109
    108110        /**
    109111         * Constructor.
    110112         *
     
    137139         * }
    138140         */
    139141        public function __construct( $meta_query = false ) {
     142                $this->dbh = WP::get( 'wpdb' );
     143
    140144                if ( !$meta_query )
    141145                        return;
    142146
     
    484488         * @since 4.1.0
    485489         * @access public
    486490         *
    487          * @global wpdb $wpdb WordPress database abstraction object.
    488          *
    489491         * @param array  $clause       Query clause, passed by reference.
    490492         * @param array  $parent_query Parent query array.
    491493         * @param string $clause_key   Optional. The array key used to name the clause in the original `$meta_query`
     
    498500         * }
    499501         */
    500502        public function get_sql_for_clause( &$clause, $parent_query, $clause_key = '' ) {
    501                 global $wpdb;
    502 
    503503                $sql_chunks = array(
    504504                        'where' => array(),
    505505                        'join' => array(),
     
    537537                        if ( 'NOT EXISTS' === $meta_compare ) {
    538538                                $join .= " LEFT JOIN $this->meta_table";
    539539                                $join .= $i ? " AS $alias" : '';
    540                                 $join .= $wpdb->prepare( " ON ($this->primary_table.$this->primary_id_column = $alias.$this->meta_id_column AND $alias.meta_key = %s )", $clause['key'] );
     540                                $join .= $this->dbh->prepare( " ON ($this->primary_table.$this->primary_id_column = $alias.$this->meta_id_column AND $alias.meta_key = %s )", $clause['key'] );
    541541
    542542                        // All other JOIN clauses.
    543543                        } else {
     
    581581                        if ( 'NOT EXISTS' === $meta_compare ) {
    582582                                $sql_chunks['where'][] = $alias . '.' . $this->meta_id_column . ' IS NULL';
    583583                        } else {
    584                                 $sql_chunks['where'][] = $wpdb->prepare( "$alias.meta_key = %s", trim( $clause['key'] ) );
     584                                $sql_chunks['where'][] = $this->dbh->prepare( "{$alias}.meta_key = %s", trim( $clause['key'] ) );
    585585                        }
    586586                }
    587587
     
    601601                                case 'IN' :
    602602                                case 'NOT IN' :
    603603                                        $meta_compare_string = '(' . substr( str_repeat( ',%s', count( $meta_value ) ), 1 ) . ')';
    604                                         $where = $wpdb->prepare( $meta_compare_string, $meta_value );
     604                                        $where = $this->dbh->prepare( $meta_compare_string, $meta_value );
    605605                                        break;
    606606
    607607                                case 'BETWEEN' :
    608608                                case 'NOT BETWEEN' :
    609609                                        $meta_value = array_slice( $meta_value, 0, 2 );
    610                                         $where = $wpdb->prepare( '%s AND %s', $meta_value );
     610                                        $where = $this->dbh->prepare( '%s AND %s', $meta_value );
    611611                                        break;
    612612
    613613                                case 'LIKE' :
    614614                                case 'NOT LIKE' :
    615                                         $meta_value = '%' . $wpdb->esc_like( $meta_value ) . '%';
    616                                         $where = $wpdb->prepare( '%s', $meta_value );
     615                                        $meta_value = '%' . $this->dbh->esc_like( $meta_value ) . '%';
     616                                        $where = $this->dbh->prepare( '%s', $meta_value );
    617617                                        break;
    618618
    619619                                // EXISTS with a value is interpreted as '='.
    620620                                case 'EXISTS' :
    621621                                        $meta_compare = '=';
    622                                         $where = $wpdb->prepare( '%s', $meta_value );
     622                                        $where = $this->dbh->prepare( '%s', $meta_value );
    623623                                        break;
    624624
    625625                                // 'value' is ignored for NOT EXISTS.
     
    628628                                        break;
    629629
    630630                                default :
    631                                         $where = $wpdb->prepare( '%s', $meta_value );
     631                                        $where = $this->dbh->prepare( '%s', $meta_value );
    632632                                        break;
    633633
    634634                        }
  • src/wp-includes/class-wp-network-query.php

     
    8686         */
    8787        public $max_num_pages = 0;
    8888
     89        protected $dbh;
     90
    8991        /**
    9092         * Constructor.
    9193         *
     
    124126         * }
    125127         */
    126128        public function __construct( $query = '' ) {
     129                $this->dbh = WP::get( 'wpdb' );
     130
    127131                $this->query_var_defaults = array(
    128132                        'network__in'          => '',
    129133                        'network__not_in'      => '',
     
    290294         * @return int|array A single count of network IDs if a count query. An array of network IDs if a full query.
    291295         */
    292296        protected function get_network_ids() {
    293                 global $wpdb;
    294 
    295297                $order = $this->parse_order( $this->query_vars['order'] );
    296298
    297299                // Disable ORDER BY with 'none', an empty array, or boolean false.
     
    332334
    333335                        $orderby = implode( ', ', $orderby_array );
    334336                } else {
    335                         $orderby = "$wpdb->site.id $order";
     337                        $orderby = "{$this->dbh->site}.id $order";
    336338                }
    337339
    338340                $number = absint( $this->query_vars['number'] );
     
    349351                if ( $this->query_vars['count'] ) {
    350352                        $fields = 'COUNT(*)';
    351353                } else {
    352                         $fields = "$wpdb->site.id";
     354                        $fields = "{$this->dbh->site}.id";
    353355                }
    354356
    355357                // Parse network IDs for an IN clause.
    356358                if ( ! empty( $this->query_vars['network__in'] ) ) {
    357                         $this->sql_clauses['where']['network__in'] = "$wpdb->site.id IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['network__in'] ) ) . ' )';
     359                        $this->sql_clauses['where']['network__in'] = "{$this->dbh->site}.id IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['network__in'] ) ) . ' )';
    358360                }
    359361
    360362                // Parse network IDs for a NOT IN clause.
    361363                if ( ! empty( $this->query_vars['network__not_in'] ) ) {
    362                         $this->sql_clauses['where']['network__not_in'] = "$wpdb->site.id NOT IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['network__not_in'] ) ) . ' )';
     364                        $this->sql_clauses['where']['network__not_in'] = "{$this->dbh->site}.id NOT IN ( " . implode( ',', wp_parse_id_list( $this->query_vars['network__not_in'] ) ) . ' )';
    363365                }
    364366
    365367                if ( ! empty( $this->query_vars['domain'] ) ) {
    366                         $this->sql_clauses['where']['domain'] = $wpdb->prepare( "$wpdb->site.domain = %s", $this->query_vars['domain'] );
     368                        $this->sql_clauses['where']['domain'] = $this->dbh->prepare( "{$this->dbh->site}.domain = %s", $this->query_vars['domain'] );
    367369                }
    368370
    369371                // Parse network domain for an IN clause.
    370372                if ( is_array( $this->query_vars['domain__in'] ) ) {
    371                         $this->sql_clauses['where']['domain__in'] = "$wpdb->site.domain IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['domain__in'] ) ) . "' )";
     373                        $this->sql_clauses['where']['domain__in'] = "{$this->dbh->site}.domain IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['domain__in'] ) ) . "' )";
    372374                }
    373375
    374376                // Parse network domain for a NOT IN clause.
    375377                if ( is_array( $this->query_vars['domain__not_in'] ) ) {
    376                         $this->sql_clauses['where']['domain__not_in'] = "$wpdb->site.domain NOT IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['domain__not_in'] ) ) . "' )";
     378                        $this->sql_clauses['where']['domain__not_in'] = "{$this->dbh->site}.domain NOT IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['domain__not_in'] ) ) . "' )";
    377379                }
    378380
    379381                if ( ! empty( $this->query_vars['path'] ) ) {
    380                         $this->sql_clauses['where']['path'] = $wpdb->prepare( "$wpdb->site.path = %s", $this->query_vars['path'] );
     382                        $this->sql_clauses['where']['path'] = $this->dbh->prepare( "{$this->dbh->site}.path = %s", $this->query_vars['path'] );
    381383                }
    382384
    383385                // Parse network path for an IN clause.
    384386                if ( is_array( $this->query_vars['path__in'] ) ) {
    385                         $this->sql_clauses['where']['path__in'] = "$wpdb->site.path IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['path__in'] ) ) . "' )";
     387                        $this->sql_clauses['where']['path__in'] = "{$this->dbh->site}.path IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['path__in'] ) ) . "' )";
    386388                }
    387389
    388390                // Parse network path for a NOT IN clause.
    389391                if ( is_array( $this->query_vars['path__not_in'] ) ) {
    390                         $this->sql_clauses['where']['path__not_in'] = "$wpdb->site.path NOT IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['path__not_in'] ) ) . "' )";
     392                        $this->sql_clauses['where']['path__not_in'] = "{$this->dbh->site}.path NOT IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['path__not_in'] ) ) . "' )";
    391393                }
    392394
    393395                // Falsey search strings are ignored.
     
    394396                if ( strlen( $this->query_vars['search'] ) ) {
    395397                        $this->sql_clauses['where']['search'] = $this->get_search_sql(
    396398                                $this->query_vars['search'],
    397                                 array( "$wpdb->site.domain", "$wpdb->site.path" )
     399                                array( "{$this->dbh->site}.domain", "{$this->dbh->site}.path" )
    398400                        );
    399401                }
    400402
     
    439441                }
    440442
    441443                $this->sql_clauses['select']  = "SELECT $found_rows $fields";
    442                 $this->sql_clauses['from']    = "FROM $wpdb->site $join";
     444                $this->sql_clauses['from']    = "FROM {$this->dbh->site} $join";
    443445                $this->sql_clauses['groupby'] = $groupby;
    444446                $this->sql_clauses['orderby'] = $orderby;
    445447                $this->sql_clauses['limits']  = $limits;
     
    447449                $this->request = "{$this->sql_clauses['select']} {$this->sql_clauses['from']} {$where} {$this->sql_clauses['groupby']} {$this->sql_clauses['orderby']} {$this->sql_clauses['limits']}";
    448450
    449451                if ( $this->query_vars['count'] ) {
    450                         return intval( $wpdb->get_var( $this->request ) );
     452                        return intval( $this->dbh->get_var( $this->request ) );
    451453                }
    452454
    453                 $network_ids = $wpdb->get_col( $this->request );
     455                $network_ids = $this->dbh->get_col( $this->request );
    454456
    455457                return array_map( 'intval', $network_ids );
    456458        }
     
    461463         *
    462464         * @since 4.6.0
    463465         * @access private
    464          *
    465          * @global wpdb $wpdb WordPress database abstraction object.
    466466         */
    467467        private function set_found_networks() {
    468                 global $wpdb;
    469 
    470468                if ( $this->query_vars['number'] && ! $this->query_vars['no_found_rows'] ) {
    471469                        /**
    472470                         * Filters the query used to retrieve found network count.
     
    478476                         */
    479477                        $found_networks_query = apply_filters( 'found_networks_query', 'SELECT FOUND_ROWS()', $this );
    480478
    481                         $this->found_networks = (int) $wpdb->get_var( $found_networks_query );
     479                        $this->found_networks = (int) $this->dbh->get_var( $found_networks_query );
    482480                }
    483481        }
    484482
     
    488486         * @since 4.6.0
    489487         * @access protected
    490488         *
    491          * @global wpdb  $wpdb WordPress database abstraction object.
    492          *
    493489         * @param string $string  Search string.
    494490         * @param array  $columns Columns to search.
    495491         *
     
    496492         * @return string Search SQL.
    497493         */
    498494        protected function get_search_sql( $string, $columns ) {
    499                 global $wpdb;
     495                $like = '%' . $this->dbh->esc_like( $string ) . '%';
    500496
    501                 $like = '%' . $wpdb->esc_like( $string ) . '%';
    502 
    503497                $searches = array();
    504498                foreach ( $columns as $column ) {
    505                         $searches[] = $wpdb->prepare( "$column LIKE %s", $like );
     499                        $searches[] = $this->dbh->prepare( "$column LIKE %s", $like );
    506500                }
    507501
    508502                return '(' . implode( ' OR ', $searches ) . ')';
     
    514508         * @since 4.6.0
    515509         * @access protected
    516510         *
    517          * @global wpdb $wpdb WordPress database abstraction object.
    518          *
    519511         * @param string $orderby Alias for the field to order by.
    520512         * @return string|false Value to used in the ORDER clause. False otherwise.
    521513         */
    522514        protected function parse_orderby( $orderby ) {
    523                 global $wpdb;
    524 
    525515                $allowed_keys = array(
    526516                        'id',
    527517                        'domain',
     
    531521                $parsed = false;
    532522                if ( $orderby == 'network__in' ) {
    533523                        $network__in = implode( ',', array_map( 'absint', $this->query_vars['network__in'] ) );
    534                         $parsed = "FIELD( {$wpdb->site}.id, $network__in )";
     524                        $parsed = "FIELD( {$this->dbh->site}.id, $network__in )";
    535525                } elseif ( $orderby == 'domain_length' || $orderby == 'path_length' ) {
    536526                        $field = substr( $orderby, 0, -7 );
    537                         $parsed = "CHAR_LENGTH($wpdb->site.$field)";
     527                        $parsed = "CHAR_LENGTH({$this->dbh->site}.$field)";
    538528                } elseif ( in_array( $orderby, $allowed_keys ) ) {
    539                         $parsed = "$wpdb->site.$orderby";
     529                        $parsed = "{$this->dbh->site}.$orderby";
    540530                }
    541531
    542532                return $parsed;
  • src/wp-includes/class-wp-network.php

     
    8787         */
    8888        public $site_name = '';
    8989
     90        protected $dbh;
     91
    9092        /**
    9193         * Retrieve a network from the database by its ID.
    9294         *
     
    9395         * @since 4.4.0
    9496         * @access public
    9597         *
    96          * @global wpdb $wpdb WordPress database abstraction object.
    97          *
    9898         * @param int $network_id The ID of the network to retrieve.
    9999         * @return WP_Network|bool The network's object if found. False if not.
    100100         */
    101101        public static function get_instance( $network_id ) {
    102                 global $wpdb;
    103 
    104102                $network_id = (int) $network_id;
    105103                if ( ! $network_id ) {
    106104                        return false;
     
    109107                $_network = wp_cache_get( $network_id, 'networks' );
    110108
    111109                if ( ! $_network ) {
     110                        $wpdb = WP::get( 'wpdb' );
    112111                        $_network = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$wpdb->site} WHERE id = %d LIMIT 1", $network_id ) );
    113112
    114113                        if ( empty( $_network ) || is_wp_error( $_network ) ) {
     
    137136                        $this->$key = $value;
    138137                }
    139138
     139                $this->dbh = WP::get( 'wpdb' );
     140
    140141                $this->_set_site_name();
    141142                $this->_set_cookie_domain();
    142143        }
     
    267268         * @return WP_Network|bool Network object if successful. False when no network is found.
    268269         */
    269270        public static function get_by_path( $domain = '', $path = '', $segments = null ) {
    270                 global $wpdb;
    271 
    272271                $domains = array( $domain );
    273272                $pieces  = explode( '.', $domain );
    274273
     
    295294                if ( wp_using_ext_object_cache() ) {
    296295                        $using_paths = wp_cache_get( 'networks_have_paths', 'site-options' );
    297296                        if ( false === $using_paths ) {
    298                                 $using_paths = (int) $wpdb->get_var( "SELECT id FROM {$wpdb->site} WHERE path <> '/' LIMIT 1" );
     297                                $using_paths = (int) $this->dbh->get_var( "SELECT id FROM {$this->dbh->site} WHERE path <> '/' LIMIT 1" );
    299298                                wp_cache_add( 'networks_have_paths', $using_paths, 'site-options'  );
    300299                        }
    301300                }
     
    356355                // @todo Consider additional optimization routes, perhaps as an opt-in for plugins.
    357356                // We already have paths covered. What about how far domains should be drilled down (including www)?
    358357
    359                 $search_domains = "'" . implode( "', '", $wpdb->_escape( $domains ) ) . "'";
     358                $search_domains = "'" . implode( "', '", $this->dbh->_escape( $domains ) ) . "'";
    360359
    361360                if ( ! $using_paths ) {
    362                         $network = $wpdb->get_row( "
    363                                 SELECT * FROM {$wpdb->site}
     361                        $network = $this->dbh->get_row( "
     362                                SELECT * FROM {$this->dbh->site}
    364363                                WHERE domain IN ({$search_domains})
    365364                                ORDER BY CHAR_LENGTH(domain)
    366365                                DESC LIMIT 1
     
    373372                        return false;
    374373
    375374                } else {
    376                         $search_paths = "'" . implode( "', '", $wpdb->_escape( $paths ) ) . "'";
    377                         $networks = $wpdb->get_results( "
    378                                 SELECT * FROM {$wpdb->site}
     375                        $search_paths = "'" . implode( "', '", $this->dbh->_escape( $paths ) ) . "'";
     376                        $networks = $this->dbh->get_results( "
     377                                SELECT * FROM {$this->dbh->site}
    379378                                WHERE domain IN ({$search_domains})
    380379                                AND path IN ({$search_paths})
    381380                                ORDER BY CHAR_LENGTH(domain) DESC, CHAR_LENGTH(path) DESC
  • src/wp-includes/class-wp-post.php

     
    202202         * @static
    203203         * @access public
    204204         *
    205          * @global wpdb $wpdb WordPress database abstraction object.
    206          *
    207205         * @param int $post_id Post ID.
    208206         * @return WP_Post|false Post object, false otherwise.
    209207         */
    210208        public static function get_instance( $post_id ) {
    211                 global $wpdb;
    212 
    213209                $post_id = (int) $post_id;
    214210                if ( ! $post_id )
    215211                        return false;
     
    217213                $_post = wp_cache_get( $post_id, 'posts' );
    218214
    219215                if ( ! $_post ) {
     216                        $wpdb = WP::get( 'wpdb' );
    220217                        $_post = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->posts WHERE ID = %d LIMIT 1", $post_id ) );
    221218
    222219                        if ( ! $_post )
  • src/wp-includes/class-wp-registry.php

     
     1<?php
     2
     3class WP_Registry {
     4        private $data = array();
     5        private static $instance;
     6
     7        public static function instance() {
     8                if ( ! self::$instance ) {
     9                        self::$instance = new self;
     10                }
     11                return self::$instance;
     12        }
     13
     14        private function __construct() {}
     15
     16        private function __clone() {}
     17
     18        public function get( $key, $global = true ) {
     19                if ( $global && array_key_exists( $key, $GLOBALS ) ) {
     20                        return $GLOBALS[ $key ];
     21                } elseif ( array_key_exists( $key, $this->data ) ) {
     22                        return $this->data[ $key ];
     23                }
     24
     25                return $this->set( $key, null, $global );
     26        }
     27
     28        public function set( $key, $value = null, $global = false ) {
     29                if ( null === $value ) {
     30                        switch ( $key ) {
     31                        case 'wp_hasher':
     32                                require_once ABSPATH . WPINC . '/class-phpass.php';
     33                                $value = new PasswordHash( 8, true );
     34                                break;
     35                        }
     36                }
     37                $this->data[ $key ] = $value;
     38                if ( $global ) {
     39                        $GLOBALS[ $key ] = $this->data[ $key ];
     40                }
     41                return $value;
     42        }
     43}
     44 No newline at end of file
  • src/wp-includes/class-wp-rewrite.php

     
    450450         * @since 2.5.0
    451451         * @access public
    452452         *
    453          * @global wpdb $wpdb WordPress database abstraction object.
    454          *
    455453         * @return array Array of page URIs as first element and attachment URIs as second element.
    456454         */
    457455        public function page_uri_index() {
    458                 global $wpdb;
     456                $wpdb = WP::get( 'wpdb' );
    459457
    460458                // Get pages in order of hierarchy, i.e. children after parents.
    461459                $pages = $wpdb->get_results("SELECT ID, post_name, post_parent FROM $wpdb->posts WHERE post_type = 'page' AND post_status != 'auto-draft'");
  • src/wp-includes/class-wp-roles.php

     
    105105         * @since 2.1.0
    106106         * @access protected
    107107         *
    108          * @global wpdb  $wpdb          WordPress database abstraction object.
    109108         * @global array $wp_user_roles Used to set the 'roles' property value.
    110109         */
    111110        protected function _init() {
    112                 global $wpdb, $wp_user_roles;
     111                global $wp_user_roles;
     112                $wpdb = WP::get( 'wpdb' );
    113113                $this->role_key = $wpdb->get_blog_prefix() . 'user_roles';
    114114                if ( ! empty( $wp_user_roles ) ) {
    115115                        $this->roles = $wp_user_roles;
     
    137137         *
    138138         * @since 3.5.0
    139139         * @access public
    140          *
    141          * @global wpdb $wpdb WordPress database abstraction object.
    142140         */
    143141        public function reinit() {
    144142                // There is no need to reinit if using the wp_user_roles global.
     
    145143                if ( ! $this->use_db )
    146144                        return;
    147145
    148                 global $wpdb;
     146                $wpdb = WP::get( 'wpdb' );
    149147
    150148                // Duplicated from _init() to avoid an extra function call.
    151149                $this->role_key = $wpdb->get_blog_prefix() . 'user_roles';
  • src/wp-includes/class-wp-site-query.php

     
    9595         */
    9696        public $max_num_pages = 0;
    9797
     98        protected $dbh;
     99
    98100        /**
    99101         * Sets up the site query, based on the query vars passed.
    100102         *
     
    147149         * }
    148150         */
    149151        public function __construct( $query = '' ) {
     152                $this->dbh = WP::get( 'wpdb' );
     153
    150154                $this->query_var_defaults = array(
    151155                        'fields'            => '',
    152156                        'ID'                => '',
     
    325329         * @since 4.6.0
    326330         * @access protected
    327331         *
    328          * @global wpdb $wpdb WordPress database abstraction object.
    329          *
    330332         * @return int|array A single count of site IDs if a count query. An array of site IDs if a full query.
    331333         */
    332334        protected function get_site_ids() {
    333                 global $wpdb;
    334 
    335335                $order = $this->parse_order( $this->query_vars['order'] );
    336336
    337337                // Disable ORDER BY with 'none', an empty array, or boolean false.
     
    395395                // Parse site IDs for an IN clause.
    396396                $site_id = absint( $this->query_vars['ID'] );
    397397                if ( ! empty( $site_id ) ) {
    398                         $this->sql_clauses['where']['ID'] = $wpdb->prepare( 'blog_id = %d', $site_id );
     398                        $this->sql_clauses['where']['ID'] = $this->dbh->prepare( 'blog_id = %d', $site_id );
    399399                }
    400400
    401401                // Parse site IDs for an IN clause.
     
    411411                $network_id = absint( $this->query_vars['network_id'] );
    412412
    413413                if ( ! empty( $network_id ) ) {
    414                         $this->sql_clauses['where']['network_id'] = $wpdb->prepare( 'site_id = %d', $network_id );
     414                        $this->sql_clauses['where']['network_id'] = $this->dbh->prepare( 'site_id = %d', $network_id );
    415415                }
    416416
    417417                // Parse site network IDs for an IN clause.
     
    425425                }
    426426
    427427                if ( ! empty( $this->query_vars['domain'] ) ) {
    428                         $this->sql_clauses['where']['domain'] = $wpdb->prepare( 'domain = %s', $this->query_vars['domain'] );
     428                        $this->sql_clauses['where']['domain'] = $this->dbh->prepare( 'domain = %s', $this->query_vars['domain'] );
    429429                }
    430430
    431431                // Parse site domain for an IN clause.
    432432                if ( is_array( $this->query_vars['domain__in'] ) ) {
    433                         $this->sql_clauses['where']['domain__in'] = "domain IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['domain__in'] ) ) . "' )";
     433                        $this->sql_clauses['where']['domain__in'] = "domain IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['domain__in'] ) ) . "' )";
    434434                }
    435435
    436436                // Parse site domain for a NOT IN clause.
    437437                if ( is_array( $this->query_vars['domain__not_in'] ) ) {
    438                         $this->sql_clauses['where']['domain__not_in'] = "domain NOT IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['domain__not_in'] ) ) . "' )";
     438                        $this->sql_clauses['where']['domain__not_in'] = "domain NOT IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['domain__not_in'] ) ) . "' )";
    439439                }
    440440
    441441                if ( ! empty( $this->query_vars['path'] ) ) {
    442                         $this->sql_clauses['where']['path'] = $wpdb->prepare( 'path = %s', $this->query_vars['path'] );
     442                        $this->sql_clauses['where']['path'] = $this->dbh->prepare( 'path = %s', $this->query_vars['path'] );
    443443                }
    444444
    445445                // Parse site path for an IN clause.
    446446                if ( is_array( $this->query_vars['path__in'] ) ) {
    447                         $this->sql_clauses['where']['path__in'] = "path IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['path__in'] ) ) . "' )";
     447                        $this->sql_clauses['where']['path__in'] = "path IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['path__in'] ) ) . "' )";
    448448                }
    449449
    450450                // Parse site path for a NOT IN clause.
    451451                if ( is_array( $this->query_vars['path__not_in'] ) ) {
    452                         $this->sql_clauses['where']['path__not_in'] = "path NOT IN ( '" . implode( "', '", $wpdb->_escape( $this->query_vars['path__not_in'] ) ) . "' )";
     452                        $this->sql_clauses['where']['path__not_in'] = "path NOT IN ( '" . implode( "', '", $this->dbh->_escape( $this->query_vars['path__not_in'] ) ) . "' )";
    453453                }
    454454
    455455                if ( is_numeric( $this->query_vars['archived'] ) ) {
    456456                        $archived = absint( $this->query_vars['archived'] );
    457                         $this->sql_clauses['where']['archived'] = $wpdb->prepare( "archived = %d ", $archived );
     457                        $this->sql_clauses['where']['archived'] = $this->dbh->prepare( "archived = %d ", $archived );
    458458                }
    459459
    460460                if ( is_numeric( $this->query_vars['mature'] ) ) {
    461461                        $mature = absint( $this->query_vars['mature'] );
    462                         $this->sql_clauses['where']['mature'] = $wpdb->prepare( "mature = %d ", $mature );
     462                        $this->sql_clauses['where']['mature'] = $this->dbh->prepare( "mature = %d ", $mature );
    463463                }
    464464
    465465                if ( is_numeric( $this->query_vars['spam'] ) ) {
    466466                        $spam = absint( $this->query_vars['spam'] );
    467                         $this->sql_clauses['where']['spam'] = $wpdb->prepare( "spam = %d ", $spam );
     467                        $this->sql_clauses['where']['spam'] = $this->dbh->prepare( "spam = %d ", $spam );
    468468                }
    469469
    470470                if ( is_numeric( $this->query_vars['deleted'] ) ) {
    471471                        $deleted = absint( $this->query_vars['deleted'] );
    472                         $this->sql_clauses['where']['deleted'] = $wpdb->prepare( "deleted = %d ", $deleted );
     472                        $this->sql_clauses['where']['deleted'] = $this->dbh->prepare( "deleted = %d ", $deleted );
    473473                }
    474474
    475475                if ( is_numeric( $this->query_vars['public'] ) ) {
    476476                        $public = absint( $this->query_vars['public'] );
    477                         $this->sql_clauses['where']['public'] = $wpdb->prepare( "public = %d ", $public );
     477                        $this->sql_clauses['where']['public'] = $this->dbh->prepare( "public = %d ", $public );
    478478                }
    479479
    480480                // Falsey search strings are ignored.
     
    550550                }
    551551
    552552                $this->sql_clauses['select']  = "SELECT $found_rows $fields";
    553                 $this->sql_clauses['from']    = "FROM $wpdb->blogs $join";
     553                $this->sql_clauses['from']    = "FROM {$this->dbh->blogs} $join";
    554554                $this->sql_clauses['groupby'] = $groupby;
    555555                $this->sql_clauses['orderby'] = $orderby;
    556556                $this->sql_clauses['limits']  = $limits;
     
    558558                $this->request = "{$this->sql_clauses['select']} {$this->sql_clauses['from']} {$where} {$this->sql_clauses['groupby']} {$this->sql_clauses['orderby']} {$this->sql_clauses['limits']}";
    559559
    560560                if ( $this->query_vars['count'] ) {
    561                         return intval( $wpdb->get_var( $this->request ) );
     561                        return intval( $this->dbh->get_var( $this->request ) );
    562562                }
    563563
    564                 $site_ids = $wpdb->get_col( $this->request );
     564                $site_ids = $this->dbh->get_col( $this->request );
    565565
    566566                return array_map( 'intval', $site_ids );
    567567        }
     
    572572         *
    573573         * @since 4.6.0
    574574         * @access private
    575          *
    576          * @global wpdb $wpdb WordPress database abstraction object.
    577575         */
    578576        private function set_found_sites() {
    579                 global $wpdb;
    580 
    581577                if ( $this->query_vars['number'] && ! $this->query_vars['no_found_rows'] ) {
    582578                        /**
    583579                         * Filters the query used to retrieve found site count.
     
    589585                         */
    590586                        $found_sites_query = apply_filters( 'found_sites_query', 'SELECT FOUND_ROWS()', $this );
    591587
    592                         $this->found_sites = (int) $wpdb->get_var( $found_sites_query );
     588                        $this->found_sites = (int) $this->dbh->get_var( $found_sites_query );
    593589                }
    594590        }
    595591
     
    599595         * @since 4.6.0
    600596         * @access protected
    601597         *
    602          * @global wpdb  $wpdb WordPress database abstraction object.
    603          *
    604598         * @param string $string  Search string.
    605599         * @param array  $columns Columns to search.
    606600         * @return string Search SQL.
    607601         */
    608602        protected function get_search_sql( $string, $columns ) {
    609                 global $wpdb;
    610 
    611603                if ( false !== strpos( $string, '*' ) ) {
    612                         $like = '%' . implode( '%', array_map( array( $wpdb, 'esc_like' ), explode( '*', $string ) ) ) . '%';
     604                        $like = '%' . implode( '%', array_map( array( $this->dbh, 'esc_like' ), explode( '*', $string ) ) ) . '%';
    613605                } else {
    614                         $like = '%' . $wpdb->esc_like( $string ) . '%';
     606                        $like = '%' . $this->dbh->esc_like( $string ) . '%';
    615607                }
    616608
    617609                $searches = array();
    618610                foreach ( $columns as $column ) {
    619                         $searches[] = $wpdb->prepare( "$column LIKE %s", $like );
     611                        $searches[] = $this->dbh->prepare( "$column LIKE %s", $like );
    620612                }
    621613
    622614                return '(' . implode( ' OR ', $searches ) . ')';
     
    628620         * @since 4.6.0
    629621         * @access protected
    630622         *
    631          * @global wpdb $wpdb WordPress database abstraction object.
    632          *
    633623         * @param string $orderby Alias for the field to order by.
    634624         * @return string|false Value to used in the ORDER clause. False otherwise.
    635625         */
    636626        protected function parse_orderby( $orderby ) {
    637                 global $wpdb;
    638 
    639627                $parsed = false;
    640628
    641629                switch ( $orderby ) {
    642630                        case 'site__in':
    643631                                $site__in = implode( ',', array_map( 'absint', $this->query_vars['site__in'] ) );
    644                                 $parsed = "FIELD( {$wpdb->blogs}.blog_id, $site__in )";
     632                                $parsed = "FIELD( {$this->dbh->blogs}.blog_id, $site__in )";
    645633                                break;
    646634                        case 'network__in':
    647635                                $network__in = implode( ',', array_map( 'absint', $this->query_vars['network__in'] ) );
    648                                 $parsed = "FIELD( {$wpdb->blogs}.site_id, $network__in )";
     636                                $parsed = "FIELD( {$this->dbh->blogs}.site_id, $network__in )";
    649637                                break;
    650638                        case 'domain':
    651639                        case 'last_updated':
  • src/wp-includes/class-wp-site.php

     
    157157         * @since 4.5.0
    158158         * @access public
    159159         *
    160          * @global wpdb $wpdb WordPress database abstraction object.
    161          *
    162160         * @param int $site_id The ID of the site to retrieve.
    163161         * @return WP_Site|false The site's object if found. False if not.
    164162         */
    165163        public static function get_instance( $site_id ) {
    166                 global $wpdb;
    167 
    168164                $site_id = (int) $site_id;
    169165                if ( ! $site_id ) {
    170166                        return false;
     
    173169                $_site = wp_cache_get( $site_id, 'sites' );
    174170
    175171                if ( ! $_site ) {
     172                        $wpdb = WP::get( 'wpdb' );
    176173                        $_site = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM {$wpdb->blogs} WHERE blog_id = %d LIMIT 1", $site_id ) );
    177174
    178175                        if ( empty( $_site ) || is_wp_error( $_site ) ) {
  • src/wp-includes/class-wp-tax-query.php

     
    9191         */
    9292        public $primary_id_column;
    9393
     94        protected $dbh;
     95
    9496        /**
    9597         * Constructor.
    9698         *
     
    125127                        $this->relation = 'AND';
    126128                }
    127129
     130                $this->dbh = WP::get( 'wpdb' );
     131
    128132                $this->queries = $this->sanitize_query( $tax_query );
    129133        }
    130134
     
    387391         * @since 4.1.0
    388392         * @access public
    389393         *
    390          * @global wpdb $wpdb The WordPress database abstraction object.
    391          *
    392394         * @param array $clause       Query clause, passed by reference.
    393395         * @param array $parent_query Parent query array.
    394396         * @return array {
     
    399401         * }
    400402         */
    401403        public function get_sql_for_clause( &$clause, $parent_query ) {
    402                 global $wpdb;
    403 
    404404                $sql = array(
    405405                        'where' => array(),
    406406                        'join'  => array(),
     
    432432                        $alias = $this->find_compatible_table_alias( $clause, $parent_query );
    433433                        if ( false === $alias ) {
    434434                                $i = count( $this->table_aliases );
    435                                 $alias = $i ? 'tt' . $i : $wpdb->term_relationships;
     435                                $alias = $i ? 'tt' . $i : $this->dbh->term_relationships;
    436436
    437437                                // Store the alias as part of a flat array to build future iterators.
    438438                                $this->table_aliases[] = $alias;
     
    440440                                // Store the alias with this clause, so later siblings can use it.
    441441                                $clause['alias'] = $alias;
    442442
    443                                 $join .= " LEFT JOIN $wpdb->term_relationships";
     443                                $join .= " LEFT JOIN {$this->dbh->term_relationships}";
    444444                                $join .= $i ? " AS $alias" : '';
    445445                                $join .= " ON ($this->primary_table.$this->primary_id_column = $alias.object_id)";
    446446                        }
     
    458458
    459459                        $where = "$this->primary_table.$this->primary_id_column NOT IN (
    460460                                SELECT object_id
    461                                 FROM $wpdb->term_relationships
     461                                FROM {$this->dbh->term_relationships}
    462462                                WHERE term_taxonomy_id IN ($terms)
    463463                        )";
    464464
     
    474474
    475475                        $where = "(
    476476                                SELECT COUNT(1)
    477                                 FROM $wpdb->term_relationships
     477                                FROM {$this->dbh->term_relationships}
    478478                                WHERE term_taxonomy_id IN ($terms)
    479479                                AND object_id = $this->primary_table.$this->primary_id_column
    480480                        ) = $num_terms";
     
    481481
    482482                } elseif ( 'NOT EXISTS' === $operator || 'EXISTS' === $operator ) {
    483483
    484                         $where = $wpdb->prepare( "$operator (
     484                        $where = $this->dbh->prepare( "$operator (
    485485                                SELECT 1
    486                                 FROM $wpdb->term_relationships
    487                                 INNER JOIN $wpdb->term_taxonomy
    488                                 ON $wpdb->term_taxonomy.term_taxonomy_id = $wpdb->term_relationships.term_taxonomy_id
    489                                 WHERE $wpdb->term_taxonomy.taxonomy = %s
    490                                 AND $wpdb->term_relationships.object_id = $this->primary_table.$this->primary_id_column
     486                                FROM {$this->dbh->term_relationships}
     487                                INNER JOIN {$this->dbh->term_taxonomy}
     488                                ON {$this->dbh->term_taxonomy}.term_taxonomy_id = {$this->dbh->term_relationships}.term_taxonomy_id
     489                                WHERE {$this->dbh->term_taxonomy}.taxonomy = %s
     490                                AND {$this->dbh->term_relationships}.object_id = {$this->primary_table}.{$this->primary_id_column}
    491491                        )", $clause['taxonomy'] );
    492492
    493493                }
     
    597597         *
    598598         * @since 3.2.0
    599599         *
    600          * @global wpdb $wpdb The WordPress database abstraction object.
    601          *
    602600         * @param array  $query           The single query. Passed by reference.
    603601         * @param string $resulting_field The resulting field. Accepts 'slug', 'name', 'term_taxonomy_id',
    604602         *                                or 'term_id'. Default 'term_id'.
    605603         */
    606604        public function transform_query( &$query, $resulting_field ) {
    607                 global $wpdb;
    608 
    609605                if ( empty( $query['terms'] ) )
    610606                        return;
    611607
     
    628624
    629625                                $terms = implode( ",", $query['terms'] );
    630626
    631                                 $terms = $wpdb->get_col( "
    632                                         SELECT $wpdb->term_taxonomy.$resulting_field
    633                                         FROM $wpdb->term_taxonomy
    634                                         INNER JOIN $wpdb->terms USING (term_id)
     627                                $terms = $this->dbh->get_col( "
     628                                        SELECT {$this->dbh->term_taxonomy}.$resulting_field
     629                                        FROM {$this->dbh->term_taxonomy}
     630                                        INNER JOIN {$this->dbh->terms} USING (term_id)
    635631                                        WHERE taxonomy = '{$query['taxonomy']}'
    636                                         AND $wpdb->terms.{$query['field']} IN ($terms)
     632                                        AND {$this->dbh->terms}.{$query['field']} IN ($terms)
    637633                                " );
    638634                                break;
    639635                        case 'term_taxonomy_id':
    640636                                $terms = implode( ',', array_map( 'intval', $query['terms'] ) );
    641                                 $terms = $wpdb->get_col( "
     637                                $terms = $this->dbh->get_col( "
    642638                                        SELECT $resulting_field
    643                                         FROM $wpdb->term_taxonomy
     639                                        FROM {$this->dbh->term_taxonomy}
    644640                                        WHERE term_taxonomy_id IN ($terms)
    645641                                " );
    646642                                break;
    647643                        default:
    648644                                $terms = implode( ',', array_map( 'intval', $query['terms'] ) );
    649                                 $terms = $wpdb->get_col( "
     645                                $terms = $this->dbh->get_col( "
    650646                                        SELECT $resulting_field
    651                                         FROM $wpdb->term_taxonomy
     647                                        FROM {$this->dbh->term_taxonomy}
    652648                                        WHERE taxonomy = '{$query['taxonomy']}'
    653649                                        AND term_id IN ($terms)
    654650                                " );
  • src/wp-includes/class-wp-term-query.php

     
    8686         */
    8787        public $terms;
    8888
     89        protected $dbh;
     90
    8991        /**
    9092         * Constructor.
    9193         *
     
    201203                        'meta_query'             => '',
    202204                );
    203205
     206                $this->dbh = WP::get( 'wpdb' );
     207
    204208                if ( ! empty( $query ) ) {
    205209                        $this->query( $query );
    206210                }
     
    293297         * @param 4.6.0
    294298         * @access public
    295299         *
    296          * @global wpdb $wpdb WordPress database abstraction object.
    297          *
    298300         * @return array
    299301         */
    300302        public function get_terms() {
    301                 global $wpdb;
    302 
    303303                $this->parse_query( $this->query_vars );
    304304                $args = $this->query_vars;
    305305
     
    486486                                $tt_ids = implode( ',', array_map( 'intval', $args['term_taxonomy_id'] ) );
    487487                                $this->sql_clauses['where']['term_taxonomy_id'] = "tt.term_taxonomy_id IN ({$tt_ids})";
    488488                        } else {
    489                                 $this->sql_clauses['where']['term_taxonomy_id'] = $wpdb->prepare( "tt.term_taxonomy_id = %d", $args['term_taxonomy_id'] );
     489                                $this->sql_clauses['where']['term_taxonomy_id'] = $this->dbh->prepare( "tt.term_taxonomy_id = %d", $args['term_taxonomy_id'] );
    490490                        }
    491491                }
    492492
    493493                if ( ! empty( $args['name__like'] ) ) {
    494                         $this->sql_clauses['where']['name__like'] = $wpdb->prepare( "t.name LIKE %s", '%' . $wpdb->esc_like( $args['name__like'] ) . '%' );
     494                        $this->sql_clauses['where']['name__like'] = $this->dbh->prepare( "t.name LIKE %s", '%' . $this->dbh->esc_like( $args['name__like'] ) . '%' );
    495495                }
    496496
    497497                if ( ! empty( $args['description__like'] ) ) {
    498                         $this->sql_clauses['where']['description__like'] = $wpdb->prepare( "tt.description LIKE %s", '%' . $wpdb->esc_like( $args['description__like'] ) . '%' );
     498                        $this->sql_clauses['where']['description__like'] = $this->dbh->prepare( "tt.description LIKE %s", '%' . $this->dbh->esc_like( $args['description__like'] ) . '%' );
    499499                }
    500500
    501501                if ( '' !== $parent ) {
     
    591591                 */
    592592                $fields = implode( ', ', apply_filters( 'get_terms_fields', $selects, $args, $taxonomies ) );
    593593
    594                 $join .= " INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id";
     594                $join .= " INNER JOIN {$this->dbh->term_taxonomy} AS tt ON t.term_id = tt.term_id";
    595595
    596596                $where = implode( ' AND ', $this->sql_clauses['where'] );
    597597
     
    621621                }
    622622
    623623                $this->sql_clauses['select']  = "SELECT $distinct $fields";
    624                 $this->sql_clauses['from']    = "FROM $wpdb->terms AS t $join";
     624                $this->sql_clauses['from']    = "FROM {$this->dbh->terms} AS t $join";
    625625                $this->sql_clauses['orderby'] = $orderby ? "$orderby $order" : '';
    626626                $this->sql_clauses['limits']  = $limits;
    627627
     
    646646                }
    647647
    648648                if ( 'count' == $_fields ) {
    649                         return $wpdb->get_var( $this->request );
     649                        return $this->dbh->get_var( $this->request );
    650650                }
    651651
    652                 $terms = $wpdb->get_results( $this->request );
     652                $terms = $this->dbh->get_results( $this->request );
    653653                if ( 'all' == $_fields ) {
    654654                        update_term_cache( $terms );
    655655                }
     
    753753         * @since 4.6.0
    754754         * @access protected
    755755         *
    756          * @global wpdb $wpdb WordPress database abstraction object.
    757          *
    758756         * @param string $orderby_raw Alias for the field to order by.
    759757         * @return string|false Value to used in the ORDER clause. False otherwise.
    760758         */
     
    894892         * @since 4.6.0
    895893         * @access protected
    896894         *
    897          * @global wpdb $wpdb WordPress database abstraction object.
    898          *
    899895         * @param string $string
    900896         * @return string
    901897         */
    902898        protected function get_search_sql( $string ) {
    903                 global $wpdb;
     899                $like = '%' . $this->dbh->esc_like( $string ) . '%';
    904900
    905                 $like = '%' . $wpdb->esc_like( $string ) . '%';
    906 
    907                 return $wpdb->prepare( '((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like );
     901                return $this->dbh->prepare( '((t.name LIKE %s) OR (t.slug LIKE %s))', $like, $like );
    908902        }
    909903}
  • src/wp-includes/class-wp-term.php

     
    113113         * @access public
    114114         * @static
    115115         *
    116          * @global wpdb $wpdb WordPress database abstraction object.
    117          *
    118116         * @param int    $term_id  Term ID.
    119117         * @param string $taxonomy Optional. Limit matched terms to those matching `$taxonomy`. Only used for
    120118         *                         disambiguating potentially shared terms.
     
    123121         *                                False for other failures.
    124122         */
    125123        public static function get_instance( $term_id, $taxonomy = null ) {
    126                 global $wpdb;
    127 
    128124                $term_id = (int) $term_id;
    129125                if ( ! $term_id ) {
    130126                        return false;
     
    134130
    135131                // If there isn't a cached version, hit the database.
    136132                if ( ! $_term || ( $taxonomy && $taxonomy !== $_term->taxonomy ) ) {
     133                        $wpdb = WP::get( 'wpdb' );
    137134                        // Grab all matching terms, in case any are shared between taxonomies.
    138135                        $terms = $wpdb->get_results( $wpdb->prepare( "SELECT t.*, tt.* FROM $wpdb->terms AS t INNER JOIN $wpdb->term_taxonomy AS tt ON t.term_id = tt.term_id WHERE t.term_id = %d", $term_id ) );
    139136                        if ( ! $terms ) {
  • src/wp-includes/class-wp-user-query.php

     
    7070        public $query_orderby;
    7171        public $query_limit;
    7272
     73        protected $dbh;
     74
    7375        /**
    7476         * PHP5 constructor.
    7577         *
     
    7880         * @param null|string|array $query Optional. The query variables.
    7981         */
    8082        public function __construct( $query = null ) {
     83                $this->dbh = WP::get( 'wpdb' );
     84
    8185                if ( ! empty( $query ) ) {
    8286                        $this->prepare_query( $query );
    8387                        $this->query();
     
    134138         *
    135139         * @access public
    136140         *
    137          * @global wpdb $wpdb WordPress database abstraction object.
    138141         * @global int  $blog_id
    139142         *
    140143         * @param string|array $query {
     
    198201         * }
    199202         */
    200203        public function prepare_query( $query = array() ) {
    201                 global $wpdb;
    202 
    203204                if ( empty( $this->query_vars ) || ! empty( $query ) ) {
    204205                        $this->query_limit = null;
    205206                        $this->query_vars = $this->fill_query_vars( $query );
     
    228229                        $this->query_fields = array();
    229230                        foreach ( $qv['fields'] as $field ) {
    230231                                $field = 'ID' === $field ? 'ID' : sanitize_key( $field );
    231                                 $this->query_fields[] = "$wpdb->users.$field";
     232                                $this->query_fields[] = "{$this->dbh->users}.$field";
    232233                        }
    233234                        $this->query_fields = implode( ',', $this->query_fields );
    234235                } elseif ( 'all' == $qv['fields'] ) {
    235                         $this->query_fields = "$wpdb->users.*";
     236                        $this->query_fields = "{$this->dbh->users}.*";
    236237                } else {
    237                         $this->query_fields = "$wpdb->users.ID";
     238                        $this->query_fields = "{$this->dbh->users}.ID";
    238239                }
    239240
    240241                if ( isset( $qv['count_total'] ) && $qv['count_total'] )
    241242                        $this->query_fields = 'SQL_CALC_FOUND_ROWS ' . $this->query_fields;
    242243
    243                 $this->query_from = "FROM $wpdb->users";
     244                $this->query_from = "FROM {$this->dbh->users}";
    244245                $this->query_where = "WHERE 1=1";
    245246
    246247                // Parse and sanitize 'include', for use by 'orderby' as well as 'include' below.
     
    263264                        }
    264265
    265266                        foreach ( $post_types as &$post_type ) {
    266                                 $post_type = $wpdb->prepare( '%s', $post_type );
     267                                $post_type = $this->dbh->prepare( '%s', $post_type );
    267268                        }
    268269
    269                         $posts_table = $wpdb->get_blog_prefix( $blog_id ) . 'posts';
    270                         $this->query_where .= " AND $wpdb->users.ID IN ( SELECT DISTINCT $posts_table.post_author FROM $posts_table WHERE $posts_table.post_status = 'publish' AND $posts_table.post_type IN ( " . join( ", ", $post_types ) . " ) )";
     270                        $posts_table = $this->dbh->get_blog_prefix( $blog_id ) . 'posts';
     271                        $this->query_where .= " AND {$this->dbh->users}.ID IN ( SELECT DISTINCT $posts_table.post_author FROM $posts_table WHERE $posts_table.post_status = 'publish' AND $posts_table.post_type IN ( " . join( ", ", $post_types ) . " ) )";
    271272                }
    272273
    273274                // Meta query.
     
    276277
    277278                if ( isset( $qv['who'] ) && 'authors' == $qv['who'] && $blog_id ) {
    278279                        $who_query = array(
    279                                 'key' => $wpdb->get_blog_prefix( $blog_id ) . 'user_level',
     280                                'key' => $this->dbh->get_blog_prefix( $blog_id ) . 'user_level',
    280281                                'value' => 0,
    281282                                'compare' => '!=',
    282283                        );
     
    323324                        if ( ! empty( $roles ) ) {
    324325                                foreach ( $roles as $role ) {
    325326                                        $roles_clauses[] = array(
    326                                                 'key'     => $wpdb->get_blog_prefix( $blog_id ) . 'capabilities',
     327                                                'key'     => $this->dbh->get_blog_prefix( $blog_id ) . 'capabilities',
    327328                                                'value'   => '"' . $role . '"',
    328329                                                'compare' => 'LIKE',
    329330                                        );
     
    336337                        if ( ! empty( $role__in ) ) {
    337338                                foreach ( $role__in as $role ) {
    338339                                        $role__in_clauses[] = array(
    339                                                 'key'     => $wpdb->get_blog_prefix( $blog_id ) . 'capabilities',
     340                                                'key'     => $this->dbh->get_blog_prefix( $blog_id ) . 'capabilities',
    340341                                                'value'   => '"' . $role . '"',
    341342                                                'compare' => 'LIKE',
    342343                                        );
     
    349350                        if ( ! empty( $role__not_in ) ) {
    350351                                foreach ( $role__not_in as $role ) {
    351352                                        $role__not_in_clauses[] = array(
    352                                                 'key'     => $wpdb->get_blog_prefix( $blog_id ) . 'capabilities',
     353                                                'key'     => $this->dbh->get_blog_prefix( $blog_id ) . 'capabilities',
    353354                                                'value'   => '"' . $role . '"',
    354355                                                'compare' => 'NOT LIKE',
    355356                                        );
     
    361362                        // If there are no specific roles named, make sure the user is a member of the site.
    362363                        if ( empty( $role_queries ) ) {
    363364                                $role_queries[] = array(
    364                                         'key' => $wpdb->get_blog_prefix( $blog_id ) . 'capabilities',
     365                                        'key' => $this->dbh->get_blog_prefix( $blog_id ) . 'capabilities',
    365366                                        'compare' => 'EXISTS',
    366367                                );
    367368                        }
     
    383384                }
    384385
    385386                if ( ! empty( $this->meta_query->queries ) ) {
    386                         $clauses = $this->meta_query->get_sql( 'user', $wpdb->users, 'ID', $this );
     387                        $clauses = $this->meta_query->get_sql( 'user', $this->dbh->users, 'ID', $this );
    387388                        $this->query_from .= $clauses['join'];
    388389                        $this->query_where .= $clauses['where'];
    389390
     
    441442                // limit
    442443                if ( isset( $qv['number'] ) && $qv['number'] > 0 ) {
    443444                        if ( $qv['offset'] ) {
    444                                 $this->query_limit = $wpdb->prepare("LIMIT %d, %d", $qv['offset'], $qv['number']);
     445                                $this->query_limit = $this->dbh->prepare("LIMIT %d, %d", $qv['offset'], $qv['number']);
    445446                        } else {
    446                                 $this->query_limit = $wpdb->prepare( "LIMIT %d, %d", $qv['number'] * ( $qv['paged'] - 1 ), $qv['number'] );
     447                                $this->query_limit = $this->dbh->prepare( "LIMIT %d, %d", $qv['number'] * ( $qv['paged'] - 1 ), $qv['number'] );
    447448                        }
    448449                }
    449450
     
    499500                if ( ! empty( $include ) ) {
    500501                        // Sanitized earlier.
    501502                        $ids = implode( ',', $include );
    502                         $this->query_where .= " AND $wpdb->users.ID IN ($ids)";
     503                        $this->query_where .= " AND {$this->dbh->users}.ID IN ($ids)";
    503504                } elseif ( ! empty( $qv['exclude'] ) ) {
    504505                        $ids = implode( ',', wp_parse_id_list( $qv['exclude'] ) );
    505                         $this->query_where .= " AND $wpdb->users.ID NOT IN ($ids)";
     506                        $this->query_where .= " AND {$this->dbh->users}.ID NOT IN ($ids)";
    506507                }
    507508
    508509                // Date queries are allowed for the user_registered field.
     
    530531         * Execute the query, with the current variables.
    531532         *
    532533         * @since 3.1.0
    533          *
    534          * @global wpdb $wpdb WordPress database abstraction object.
    535534         */
    536535        public function query() {
    537                 global $wpdb;
    538 
    539536                $qv =& $this->query_vars;
    540537
    541538                $this->request = "SELECT $this->query_fields $this->query_from $this->query_where $this->query_orderby $this->query_limit";
    542539
    543540                if ( is_array( $qv['fields'] ) || 'all' == $qv['fields'] ) {
    544                         $this->results = $wpdb->get_results( $this->request );
     541                        $this->results = $this->dbh->get_results( $this->request );
    545542                } else {
    546                         $this->results = $wpdb->get_col( $this->request );
     543                        $this->results = $this->dbh->get_col( $this->request );
    547544                }
    548545
    549546                /**
     
    551548                 *
    552549                 * @since 3.2.0
    553550                 *
    554                  * @global wpdb $wpdb WordPress database abstraction object.
    555                  *
    556551                 * @param string $sql The SELECT FOUND_ROWS() query for the current WP_User_Query.
    557552                 */
    558553                if ( isset( $qv['count_total'] ) && $qv['count_total'] )
    559                         $this->total_users = $wpdb->get_var( apply_filters( 'found_users_query', 'SELECT FOUND_ROWS()' ) );
     554                        $this->total_users = $this->dbh->get_var( apply_filters( 'found_users_query', 'SELECT FOUND_ROWS()' ) );
    560555
    561556                if ( !$this->results )
    562557                        return;
     
    611606         * @access protected
    612607         * @since 3.1.0
    613608         *
    614          * @global wpdb $wpdb WordPress database abstraction object.
    615          *
    616609         * @param string $string
    617610         * @param array  $cols
    618611         * @param bool   $wild   Whether to allow wildcard searches. Default is false for Network Admin, true for single site.
     
    620613         * @return string
    621614         */
    622615        protected function get_search_sql( $string, $cols, $wild = false ) {
    623                 global $wpdb;
    624 
    625616                $searches = array();
    626617                $leading_wild = ( 'leading' == $wild || 'both' == $wild ) ? '%' : '';
    627618                $trailing_wild = ( 'trailing' == $wild || 'both' == $wild ) ? '%' : '';
    628                 $like = $leading_wild . $wpdb->esc_like( $string ) . $trailing_wild;
     619                $like = $leading_wild . $this->dbh->esc_like( $string ) . $trailing_wild;
    629620
    630621                foreach ( $cols as $col ) {
    631622                        if ( 'ID' == $col ) {
    632                                 $searches[] = $wpdb->prepare( "$col = %s", $string );
     623                                $searches[] = $this->dbh->prepare( "$col = %s", $string );
    633624                        } else {
    634                                 $searches[] = $wpdb->prepare( "$col LIKE %s", $like );
     625                                $searches[] = $this->dbh->prepare( "$col LIKE %s", $like );
    635626                        }
    636627                }
    637628
     
    668659         * @since 4.2.0
    669660         * @access protected
    670661         *
    671          * @global wpdb $wpdb WordPress database abstraction object.
    672          *
    673662         * @param string $orderby Alias for the field to order by.
    674663         * @return string Value to used in the ORDER clause, if `$orderby` is valid.
    675664         */
    676665        protected function parse_orderby( $orderby ) {
    677                 global $wpdb;
    678 
    679666                $meta_query_clauses = $this->meta_query->get_clauses();
    680667
    681668                $_orderby = '';
     
    690677                        $where = get_posts_by_author_sql( 'post' );
    691678                        $this->query_from .= " LEFT OUTER JOIN (
    692679                                SELECT post_author, COUNT(*) as post_count
    693                                 FROM $wpdb->posts
     680                                FROM {$this->dbh->posts}
    694681                                $where
    695682                                GROUP BY post_author
    696                         ) p ON ({$wpdb->users}.ID = p.post_author)
     683                        ) p ON ({$this->dbh->users}.ID = p.post_author)
    697684                        ";
    698685                        $_orderby = 'post_count';
    699686                } elseif ( 'ID' == $orderby || 'id' == $orderby ) {
    700687                        $_orderby = 'ID';
    701688                } elseif ( 'meta_value' == $orderby || $this->get( 'meta_key' ) == $orderby ) {
    702                         $_orderby = "$wpdb->usermeta.meta_value";
     689                        $_orderby = "{$this->dbh->usermeta}.meta_value";
    703690                } elseif ( 'meta_value_num' == $orderby ) {
    704                         $_orderby = "$wpdb->usermeta.meta_value+0";
     691                        $_orderby = "{$this->dbh->usermeta}.meta_value+0";
    705692                } elseif ( 'include' === $orderby && ! empty( $this->query_vars['include'] ) ) {
    706693                        $include = wp_parse_id_list( $this->query_vars['include'] );
    707694                        $include_sql = implode( ',', $include );
    708                         $_orderby = "FIELD( $wpdb->users.ID, $include_sql )";
     695                        $_orderby = "FIELD( {$this->dbh->users}.ID, $include_sql )";
    709696                } elseif ( isset( $meta_query_clauses[ $orderby ] ) ) {
    710697                        $meta_clause = $meta_query_clauses[ $orderby ];
    711698                        $_orderby = sprintf( "CAST(%s.meta_value AS %s)", esc_sql( $meta_clause['alias'] ), esc_sql( $meta_clause['cast'] ) );
  • src/wp-includes/class-wp-user.php

     
    101101         */
    102102        private static $back_compat_keys;
    103103
     104        protected $dbh;
     105
    104106        /**
    105107         * Constructor.
    106108         *
     
    109111         * @since 2.0.0
    110112         * @access public
    111113         *
    112          * @global wpdb $wpdb WordPress database abstraction object.
    113          *
    114114         * @param int|string|stdClass|WP_User $id User's ID, a WP_User object, or a user object from the DB.
    115115         * @param string $name Optional. User's username
    116116         * @param int $blog_id Optional Site ID, defaults to current site.
    117117         */
    118118        public function __construct( $id = 0, $name = '', $blog_id = '' ) {
     119                $this->dbh = WP::get( 'wpdb' );
     120
    119121                if ( ! isset( self::$back_compat_keys ) ) {
    120                         $prefix = $GLOBALS['wpdb']->prefix;
     122                        $prefix = $this->dbh->prefix;
    121123                        self::$back_compat_keys = array(
    122124                                'user_firstname' => 'first_name',
    123125                                'user_lastname' => 'last_name',
     
    175177         *
    176178         * @static
    177179         *
    178          * @global wpdb $wpdb WordPress database abstraction object.
    179          *
    180180         * @param string $field The field to query against: 'id', 'ID', 'slug', 'email' or 'login'.
    181181         * @param string|int $value The field value
    182182         * @return object|false Raw user object
    183183         */
    184184        public static function get_data_by( $field, $value ) {
    185                 global $wpdb;
    186 
    187185                // 'ID' is an alias of 'id'.
    188186                if ( 'ID' === $field ) {
    189187                        $field = 'id';
     
    231229                                return $user;
    232230                }
    233231
     232                $wpdb = WP::get( 'wpdb' );
    234233                if ( !$user = $wpdb->get_row( $wpdb->prepare(
    235234                        "SELECT * FROM $wpdb->users WHERE $db_field = %s", $value
    236235                ) ) )
     
    442441         * @access protected
    443442         * @since 2.1.0
    444443         *
    445          * @global wpdb $wpdb WordPress database abstraction object.
    446          *
    447444         * @param string $cap_key Optional capability key
    448445         */
    449446        protected function _init_caps( $cap_key = '' ) {
    450                 global $wpdb;
    451 
    452447                if ( empty($cap_key) )
    453                         $this->cap_key = $wpdb->get_blog_prefix() . 'capabilities';
     448                        $this->cap_key = $this->dbh->get_blog_prefix() . 'capabilities';
    454449                else
    455450                        $this->cap_key = $cap_key;
    456451
     
    631626         *
    632627         * @since 2.0.0
    633628         * @access public
    634          *
    635          * @global wpdb $wpdb WordPress database abstraction object.
    636629         */
    637630        public function update_user_level_from_caps() {
    638                 global $wpdb;
    639631                $this->user_level = array_reduce( array_keys( $this->allcaps ), array( $this, 'level_reduction' ), 0 );
    640                 update_user_meta( $this->ID, $wpdb->get_blog_prefix() . 'user_level', $this->user_level );
     632                update_user_meta( $this->ID, $this->dbh->get_blog_prefix() . 'user_level', $this->user_level );
    641633        }
    642634
    643635        /**
     
    679671         *
    680672         * @since 2.1.0
    681673         * @access public
    682          *
    683          * @global wpdb $wpdb WordPress database abstraction object.
    684674         */
    685675        public function remove_all_caps() {
    686                 global $wpdb;
    687676                $this->caps = array();
    688677                delete_user_meta( $this->ID, $this->cap_key );
    689                 delete_user_meta( $this->ID, $wpdb->get_blog_prefix() . 'user_level' );
     678                delete_user_meta( $this->ID, $this->dbh->get_blog_prefix() . 'user_level' );
    690679                $this->get_role_caps();
    691680        }
    692681
     
    772761         *
    773762         * @since 3.0.0
    774763         *
    775          * @global wpdb $wpdb WordPress database abstraction object.
    776          *
    777764         * @param int $blog_id Optional. Site ID, defaults to current site.
    778765         */
    779766        public function for_blog( $blog_id = '' ) {
    780                 global $wpdb;
    781767                if ( ! empty( $blog_id ) )
    782                         $cap_key = $wpdb->get_blog_prefix( $blog_id ) . 'capabilities';
     768                        $cap_key = $this->dbh->get_blog_prefix( $blog_id ) . 'capabilities';
    783769                else
    784770                        $cap_key = '';
    785771                $this->_init_caps( $cap_key );
  • src/wp-includes/class-wp-xmlrpc-server.php

     
    5353         */
    5454        protected $auth_failed = false;
    5555
     56        protected $dbh;
     57
    5658        /**
    5759         * Registers all of the XMLRPC methods that XMLRPC server understands.
    5860         *
     
    6365         * @since 1.5.0
    6466         */
    6567        public function __construct() {
     68                $this->dbh = WP::get( 'wpdb' );
     69
    6670                $this->methods = array(
    6771                        // WordPress API
    6872                        'wp.getUsersBlogs'              => 'this:wp_getUsersBlogs',
     
    28822886         *
    28832887         * @since 2.2.0
    28842888         *
    2885          * @global wpdb $wpdb WordPress database abstraction object.
    2886          *
    28872889         * @param array  $args {
    28882890         *     Method arguments. Note: arguments must be ordered as documented.
    28892891         *
     
    28942896         * @return array|IXR_Error
    28952897         */
    28962898        public function wp_getPageList( $args ) {
    2897                 global $wpdb;
    2898 
    28992899                $this->escape( $args );
    29002900
    29012901                $username = $args[1];
     
    29112911                do_action( 'xmlrpc_call', 'wp.getPageList' );
    29122912
    29132913                // Get list of pages ids and titles
    2914                 $page_list = $wpdb->get_results("
     2914                $page_list = $this->dbh->get_results("
    29152915                        SELECT ID page_id,
    29162916                                post_title page_title,
    29172917                                post_parent page_parent_id,
     
    29182918                                post_date_gmt,
    29192919                                post_date,
    29202920                                post_status
    2921                         FROM {$wpdb->posts}
     2921                        FROM {$this->dbh->posts}
    29222922                        WHERE post_type = 'page'
    29232923                        ORDER BY ID
    29242924                ");
     
    51305130         *
    51315131         * @since 2.1.0
    51325132         *
    5133          * @global wpdb $wpdb WordPress database abstraction object.
    5134          *
    51355133         * @param int $post_ID Post ID.
    51365134         * @param string $post_content Post Content for attachment.
    51375135         */
    51385136        public function attach_uploads( $post_ID, $post_content ) {
    5139                 global $wpdb;
    5140 
    51415137                // find any unattached files
    5142                 $attachments = $wpdb->get_results( "SELECT ID, guid FROM {$wpdb->posts} WHERE post_parent = '0' AND post_type = 'attachment'" );
     5138                $attachments = $this->dbh->get_results( "SELECT ID, guid FROM {$this->dbh->posts} WHERE post_parent = '0' AND post_type = 'attachment'" );
    51435139                if ( is_array( $attachments ) ) {
    51445140                        foreach ( $attachments as $file ) {
    5145                                 if ( ! empty( $file->guid ) && strpos( $post_content, $file->guid ) !== false )
    5146                                         $wpdb->update($wpdb->posts, array('post_parent' => $post_ID), array('ID' => $file->ID) );
     5141                                if ( ! empty( $file->guid ) && strpos( $post_content, $file->guid ) !== false ) {
     5142                                        $this->dbh->update($this->dbh->posts, array('post_parent' => $post_ID), array('ID' => $file->ID) );
     5143                                }
    51475144                        }
    51485145                }
    51495146        }
     
    57635760         *
    57645761         * @since 1.5.0
    57655762         *
    5766          * @global wpdb $wpdb WordPress database abstraction object.
    5767          *
    57685763         * @param array  $args {
    57695764         *     Method arguments. Note: arguments must be ordered as documented.
    57705765         *
     
    57765771         * @return array|IXR_Error
    57775772         */
    57785773        public function mw_newMediaObject( $args ) {
    5779                 global $wpdb;
    5780 
    57815774                $username = $this->escape( $args[1] );
    57825775                $password = $this->escape( $args[2] );
    57835776                $data     = $args[3];
     
    61026095         *
    61036096         * @since 1.5.0
    61046097         *
    6105          * @global wpdb $wpdb WordPress database abstraction object.
    6106          *
    61076098         * @param int $post_ID
    61086099         * @return array|IXR_Error
    61096100         */
    61106101        public function mt_getTrackbackPings( $post_ID ) {
    6111                 global $wpdb;
    6112 
    61136102                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    61146103                do_action( 'xmlrpc_call', 'mt.getTrackbackPings' );
    61156104
     
    61186107                if ( !$actual_post )
    61196108                        return new IXR_Error(404, __('Sorry, no such post.'));
    61206109
    6121                 $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM $wpdb->comments WHERE comment_post_ID = %d", $post_ID) );
     6110                $comments = $this->dbh->get_results( $this->dbh->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM {$this->dbh->comments} WHERE comment_post_ID = %d", $post_ID) );
    61226111
    61236112                if ( !$comments )
    61246113                        return array();
     
    61926181         *
    61936182         * @since 1.5.0
    61946183         *
    6195          * @global wpdb $wpdb WordPress database abstraction object.
    61966184         * @global string $wp_version
    61976185         *
    61986186         * @param array  $args {
     
    62046192         * @return string|IXR_Error
    62056193         */
    62066194        public function pingback_ping( $args ) {
    6207                 global $wpdb, $wp_version;
     6195                global $wp_version;
    62086196
    62096197                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    62106198                do_action( 'xmlrpc_call', 'pingback.ping' );
     
    62586246                        } elseif ( is_string($urltest['fragment']) ) {
    62596247                                // ...or a string #title, a little more complicated
    62606248                                $title = preg_replace('/[^a-z0-9]/i', '.', $urltest['fragment']);
    6261                                 $sql = $wpdb->prepare("SELECT ID FROM $wpdb->posts WHERE post_title RLIKE %s", $title );
    6262                                 if (! ($post_ID = $wpdb->get_var($sql)) ) {
     6249                                $sql = $this->dbh->prepare("SELECT ID FROM {$this->dbh->posts} WHERE post_title RLIKE %s", $title );
     6250                                if (! ($post_ID = $this->dbh->get_var($sql)) ) {
    62636251                                        // returning unknown error '0' is better than die()ing
    62646252                                        return $this->pingback_error( 0, '' );
    62656253                                }
     
    62836271                        return $this->pingback_error( 33, __( 'The specified target URL cannot be used as a target. It either doesn&#8217;t exist, or it is not a pingback-enabled resource.' ) );
    62846272
    62856273                // Let's check that the remote site didn't already pingback this entry
    6286                 if ( $wpdb->get_results( $wpdb->prepare("SELECT * FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_author_url = %s", $post_ID, $pagelinkedfrom) ) )
     6274                if ( $this->dbh->get_results( $this->dbh->prepare("SELECT * FROM {$this->dbh->comments} WHERE comment_post_ID = %d AND comment_author_url = %s", $post_ID, $pagelinkedfrom) ) )
    62876275                        return $this->pingback_error( 48, __( 'The pingback has already been registered.' ) );
    62886276
    62896277                // very stupid, but gives time to the 'from' server to publish !
     
    64086396         *
    64096397         * @since 1.5.0
    64106398         *
    6411          * @global wpdb $wpdb WordPress database abstraction object.
    6412          *
    64136399         * @param string $url
    64146400         * @return array|IXR_Error
    64156401         */
    64166402        public function pingback_extensions_getPingbacks( $url ) {
    6417                 global $wpdb;
    6418 
    64196403                /** This action is documented in wp-includes/class-wp-xmlrpc-server.php */
    64206404                do_action( 'xmlrpc_call', 'pingback.extensions.getPingbacks' );
    64216405
     
    64346418                        return $this->pingback_error( 32, __('The specified target URL does not exist.' ) );
    64356419                }
    64366420
    6437                 $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM $wpdb->comments WHERE comment_post_ID = %d", $post_ID) );
     6421                $comments = $this->dbh->get_results( $this->dbh->prepare("SELECT comment_author_url, comment_content, comment_author_IP, comment_type FROM {$this->dbh->comments} WHERE comment_post_ID = %d", $post_ID) );
    64386422
    64396423                if ( !$comments )
    64406424                        return array();
  • src/wp-includes/class-wp.php

     
    9191         */
    9292        public $did_permalink = false;
    9393
     94        public static function get( $key, $global = false ) {
     95                return WP_Registry::instance()->get( $key, $global );
     96        }
     97
     98        public static function set( $key, $value = null, $global = false ) {
     99                return WP_Registry::instance()->set( $key, $value, $global );
     100        }
     101
    94102        /**
    95103         * Add name to list of public query variables.
    96104         *
  • src/wp-includes/comment-template.php

     
    12751275 *
    12761276 * @global WP_Query   $wp_query
    12771277 * @global WP_Post    $post
    1278  * @global wpdb       $wpdb
    12791278 * @global int        $id
    12801279 * @global WP_Comment $comment
    12811280 * @global string     $user_login
     
    12891288 *                                  Default false.
    12901289 */
    12911290function comments_template( $file = '/comments.php', $separate_comments = false ) {
    1292         global $wp_query, $withcomments, $post, $wpdb, $id, $comment, $user_login, $user_ID, $user_identity, $overridden_cpage;
     1291        global $wp_query, $withcomments, $post, $id, $comment, $user_login, $user_ID, $user_identity, $overridden_cpage;
    12931292
     1293        $wpdb = WP::get( 'wpdb' );
     1294
    12941295        if ( !(is_single() || is_page() || $withcomments) || empty($post) )
    12951296                return;
    12961297
  • src/wp-includes/comment.php

     
    2424 *
    2525 * @since 1.2.0
    2626 *
    27  * @global wpdb $wpdb WordPress database abstraction object.
    28  *
    2927 * @param string $author       Comment author name.
    3028 * @param string $email        Comment author email.
    3129 * @param string $url          Comment author URL.
     
    3735 * @return bool If all checks pass, true, otherwise false.
    3836 */
    3937function check_comment($author, $email, $url, $comment, $user_ip, $user_agent, $comment_type) {
    40         global $wpdb;
    41 
    4238        // If manual moderation is enabled, skip all checks and return false.
    4339        if ( 1 == get_option('comment_moderation') )
    4440                return false;
     
    110106         */
    111107        if ( 1 == get_option('comment_whitelist')) {
    112108                if ( 'trackback' != $comment_type && 'pingback' != $comment_type && $author != '' && $email != '' ) {
     109                        $wpdb = WP::get( 'wpdb' );
    113110                        // expected_slashed ($author, $email)
    114111                        $ok_to_comment = $wpdb->get_var("SELECT comment_approved FROM $wpdb->comments WHERE comment_author = '$author' AND comment_author_email = '$email' and comment_approved = '1' LIMIT 1");
    115112                        if ( ( 1 == $ok_to_comment ) &&
     
    287284 *
    288285 * @since 1.5.0
    289286 *
    290  * @global wpdb $wpdb WordPress database abstraction object.
    291287 * @staticvar array $cache_lastcommentmodified
    292288 *
    293289 * @param string $timezone Which timezone to use in reference to 'gmt', 'blog',
     
    295291 * @return string Last comment modified date.
    296292 */
    297293function get_lastcommentmodified($timezone = 'server') {
    298         global $wpdb;
    299294        static $cache_lastcommentmodified = array();
    300295
    301296        if ( isset($cache_lastcommentmodified[$timezone]) )
     
    303298
    304299        $add_seconds_server = date('Z');
    305300
     301        $wpdb = WP::get( 'wpdb' );
    306302        switch ( strtolower($timezone)) {
    307303                case 'gmt':
    308304                        $lastcommentmodified = $wpdb->get_var("SELECT comment_date_gmt FROM $wpdb->comments WHERE comment_approved = '1' ORDER BY comment_date_gmt DESC LIMIT 1");
     
    328324 *
    329325 * @since 2.0.0
    330326 *
    331  * @global wpdb $wpdb WordPress database abstraction object.
    332  *
    333327 * @param int $post_id Optional. Comment amount in post if > 0, else total comments blog wide.
    334328 * @return array The amount of spam, approved, awaiting moderation, and total comments.
    335329 */
    336330function get_comment_count( $post_id = 0 ) {
    337         global $wpdb;
    338 
     331        $wpdb = WP::get( 'wpdb' );
    339332        $post_id = (int) $post_id;
    340333
    341334        $where = '';
     
    582575 *
    583576 * @since 2.0.0
    584577 *
    585  * @global wpdb $wpdb WordPress database abstraction object.
    586  *
    587578 * @param array $commentdata Contains information on the comment
    588579 * @return int|string Signifies the approval status (0|1|'spam')
    589580 */
    590581function wp_allow_comment( $commentdata ) {
    591         global $wpdb;
     582        $wpdb = WP::get( 'wpdb' );
    592583
    593584        // Simple duplicate check
    594585        // expected_slashed ($comment_post_ID, $comment_author, $comment_author_email, $comment_content)
     
    715706 *
    716707 * @since 2.3.0
    717708 *
    718  * @global wpdb $wpdb WordPress database abstraction object.
    719  *
    720709 * @param string $ip Comment IP.
    721710 * @param string $email Comment author email address.
    722711 * @param string $date MySQL time string.
    723712 */
    724713function check_comment_flood_db( $ip, $email, $date ) {
    725         global $wpdb;
    726714        // don't throttle admins or moderators
    727715        if ( current_user_can( 'manage_options' ) || current_user_can( 'moderate_comments' ) ) {
    728716                return;
     
    737725                $check_column = '`comment_author_IP`';
    738726        }
    739727
     728        $wpdb = WP::get( 'wpdb' );
    740729        $sql = $wpdb->prepare(
    741730                "SELECT `comment_date_gmt` FROM `$wpdb->comments` WHERE `comment_date_gmt` >= %s AND ( $check_column = %s OR `comment_author_email` = %s ) ORDER BY `comment_date_gmt` DESC LIMIT 1",
    742731                $hour_ago,
     
    854843 *
    855844 * @since 2.7.0
    856845 *
    857  * @global wpdb $wpdb WordPress database abstraction object.
    858  *
    859846 * @param int   $comment_ID Comment ID.
    860847 * @param array $args {
    861848 *      Array of optional arguments.
     
    870857 * @return int|null Comment page number or null on error.
    871858 */
    872859function get_page_of_comment( $comment_ID, $args = array() ) {
    873         global $wpdb;
    874 
    875860        $page = null;
    876861
    877862        if ( !$comment = get_comment( $comment_ID ) )
     
    913898                if ( $args['max_depth'] > 1 && 0 != $comment->comment_parent )
    914899                        return get_page_of_comment( $comment->comment_parent, $args );
    915900
     901                $wpdb = WP::get( 'wpdb' );
    916902                $comment_args = array(
    917903                        'type'       => $args['type'],
    918904                        'post_id'    => $comment->comment_post_ID,
     
    974960 *
    975961 * @since 4.5.0
    976962 *
    977  * @global wpdb $wpdb WordPress database abstraction object.
    978  *
    979963 * @return array Maximum character length for the comment form fields.
    980964 */
    981965function wp_get_comment_fields_max_lengths() {
    982         global $wpdb;
    983 
     966        $wpdb = WP::get( 'wpdb' );
    984967        $lengths = array(
    985968                'comment_author'       => 245,
    986969                'comment_author_email' => 100,
     
    11441127 *
    11451128 * @since 2.0.0
    11461129 *
    1147  * @global wpdb $wpdb WordPress database abstraction object.
    1148  *
    11491130 * @param int|WP_Comment $comment_id   Comment ID or WP_Comment object.
    11501131 * @param bool           $force_delete Whether to bypass trash and force deletion. Default is false.
    11511132 * @return bool True on success, false on failure.
    11521133 */
    11531134function wp_delete_comment($comment_id, $force_delete = false) {
    1154         global $wpdb;
    11551135        if (!$comment = get_comment($comment_id))
    11561136                return false;
    11571137
     
    11671147         */
    11681148        do_action( 'delete_comment', $comment->comment_ID );
    11691149
     1150        $wpdb = WP::get( 'wpdb' );
    11701151        // Move children up a level.
    11711152        $children = $wpdb->get_col( $wpdb->prepare("SELECT comment_ID FROM $wpdb->comments WHERE comment_parent = %d", $comment->comment_ID) );
    11721153        if ( !empty($children) ) {
     
    15321513 * @since 2.0.0
    15331514 * @since 4.4.0 Introduced `$comment_meta` argument.
    15341515 *
    1535  * @global wpdb $wpdb WordPress database abstraction object.
    1536  *
    15371516 * @param array $commentdata {
    15381517 *     Array of arguments for inserting a new comment.
    15391518 *
     
    15621541 * @return int|false The new comment's ID on success, false on failure.
    15631542 */
    15641543function wp_insert_comment( $commentdata ) {
    1565         global $wpdb;
    15661544        $data = wp_unslash( $commentdata );
    15671545
    15681546        $comment_author       = ! isset( $data['comment_author'] )       ? '' : $data['comment_author'];
     
    15841562        $user_id  = ! isset( $data['user_id'] ) ? 0 : $data['user_id'];
    15851563
    15861564        $compacted = compact( 'comment_post_ID', 'comment_author', 'comment_author_email', 'comment_author_url', 'comment_author_IP', 'comment_date', 'comment_date_gmt', 'comment_content', 'comment_karma', 'comment_approved', 'comment_agent', 'comment_type', 'comment_parent', 'user_id' );
     1565        $wpdb = WP::get( 'wpdb' );
    15871566        if ( ! $wpdb->insert( $wpdb->comments, $compacted ) ) {
    15881567                return false;
    15891568        }
     
    17171696 * @since 4.3.0 'comment_agent' and 'comment_author_IP' can be set via `$commentdata`.
    17181697 *
    17191698 * @see wp_insert_comment()
    1720  * @global wpdb $wpdb WordPress database abstraction object.
    17211699 *
    17221700 * @param array $commentdata {
    17231701 *     Comment data.
     
    17411719 * @return int|false The ID of the comment on success, false on failure.
    17421720 */
    17431721function wp_new_comment( $commentdata ) {
    1744         global $wpdb;
    1745 
    17461722        if ( isset( $commentdata['user_ID'] ) ) {
    17471723                $commentdata['user_id'] = $commentdata['user_ID'] = (int) $commentdata['user_ID'];
    17481724        }
     
    17971773
    17981774                foreach ( $fields as $field ) {
    17991775                        if ( isset( $commentdata[ $field ] ) ) {
     1776                                $wpdb = WP::get( 'wpdb' );
    18001777                                $commentdata[ $field ] = $wpdb->strip_invalid_text_for_column( $wpdb->comments, $field, $commentdata[ $field ] );
    18011778                        }
    18021779                }
     
    19011878 *
    19021879 * @since 1.0.0
    19031880 *
    1904  * @global wpdb $wpdb WordPress database abstraction object.
    1905  *
    19061881 * @param int|WP_Comment $comment_id     Comment ID or WP_Comment object.
    19071882 * @param string         $comment_status New comment status, either 'hold', 'approve', 'spam', or 'trash'.
    19081883 * @param bool           $wp_error       Whether to return a WP_Error object if there is a failure. Default is false.
     
    19091884 * @return bool|WP_Error True on success, false or WP_Error on failure.
    19101885 */
    19111886function wp_set_comment_status($comment_id, $comment_status, $wp_error = false) {
    1912         global $wpdb;
    1913 
    19141887        switch ( $comment_status ) {
    19151888                case 'hold':
    19161889                case '0':
     
    19331906
    19341907        $comment_old = clone get_comment($comment_id);
    19351908
     1909        $wpdb = WP::get( 'wpdb' );
    19361910        if ( !$wpdb->update( $wpdb->comments, array('comment_approved' => $status), array( 'comment_ID' => $comment_old->comment_ID ) ) ) {
    1937                 if ( $wp_error )
     1911                if ( $wp_error ) {
    19381912                        return new WP_Error('db_update_error', __('Could not update comment status'), $wpdb->last_error);
    1939                 else
     1913                } else {
    19401914                        return false;
     1915                }
    19411916        }
    19421917
    19431918        clean_comment_cache( $comment_old->comment_ID );
     
    19701945 *
    19711946 * @since 2.0.0
    19721947 *
    1973  * @global wpdb $wpdb WordPress database abstraction object.
    1974  *
    19751948 * @param array $commentarr Contains information on the comment.
    19761949 * @return int Comment was updated if value is 1, or was not updated if value is 0.
    19771950 */
    19781951function wp_update_comment($commentarr) {
    1979         global $wpdb;
    1980 
    19811952        // First, get all of the original fields
    19821953        $comment = get_comment($commentarr['comment_ID'], ARRAY_A);
    19831954        if ( empty( $comment ) ) {
     
    20251996        $comment_post_ID = $data['comment_post_ID'];
    20261997        $keys = array( 'comment_post_ID', 'comment_content', 'comment_author', 'comment_author_email', 'comment_approved', 'comment_karma', 'comment_author_url', 'comment_date', 'comment_date_gmt', 'comment_type', 'comment_parent', 'user_id', 'comment_agent', 'comment_author_IP' );
    20271998        $data = wp_array_slice_assoc( $data, $keys );
     1999        $wpdb = WP::get( 'wpdb' );
    20282000        $rval = $wpdb->update( $wpdb->comments, $data, compact( 'comment_ID' ) );
    20292001
    20302002        clean_comment_cache( $comment_ID );
     
    21252097 *
    21262098 * @since 2.5.0
    21272099 *
    2128  * @global wpdb $wpdb WordPress database abstraction object.
    2129  *
    21302100 * @param int $post_id Post ID
    21312101 * @return bool True on success, false on '0' $post_id or if post with ID does not exist.
    21322102 */
    21332103function wp_update_comment_count_now($post_id) {
    2134         global $wpdb;
    21352104        $post_id = (int) $post_id;
    21362105        if ( !$post_id )
    21372106                return false;
     
    21552124         */
    21562125        $new = apply_filters( 'pre_wp_update_comment_count_now', null, $old, $post_id );
    21572126
     2127        $wpdb = WP::get( 'wpdb' );
    21582128        if ( is_null( $new ) ) {
    21592129                $new = (int) $wpdb->get_var( $wpdb->prepare( "SELECT COUNT(*) FROM $wpdb->comments WHERE comment_post_ID = %d AND comment_approved = '1'", $post_id ) );
    21602130        } else {
     
    22602230 * Perform all pingbacks, enclosures, trackbacks, and send to pingback services.
    22612231 *
    22622232 * @since 2.1.0
    2263  *
    2264  * @global wpdb $wpdb WordPress database abstraction object.
    22652233 */
    22662234function do_all_pings() {
    2267         global $wpdb;
     2235        $wpdb = WP::get( 'wpdb' );
    22682236
    22692237        // Do pingbacks
    22702238        while ($ping = $wpdb->get_row("SELECT ID, post_content, meta_id FROM {$wpdb->posts}, {$wpdb->postmeta} WHERE {$wpdb->posts}.ID = {$wpdb->postmeta}.post_id AND {$wpdb->postmeta}.meta_key = '_pingme' LIMIT 1")) {
     
    22932261 *
    22942262 * @since 1.5.0
    22952263 *
    2296  * @global wpdb $wpdb WordPress database abstraction object.
    2297  *
    22982264 * @param int $post_id Post ID to do trackbacks on.
    22992265 */
    23002266function do_trackbacks($post_id) {
    2301         global $wpdb;
    2302 
    23032267        $post = get_post( $post_id );
    23042268        $to_ping = get_to_ping($post_id);
    23052269        $pinged  = get_pung($post_id);
    23062270        if ( empty($to_ping) ) {
     2271                $wpdb = WP::get( 'wpdb' );
    23072272                $wpdb->update($wpdb->posts, array('to_ping' => ''), array('ID' => $post_id) );
    23082273                return;
    23092274        }
     
    23302295                                trackback($tb_ping, $post_title, $excerpt, $post_id);
    23312296                                $pinged[] = $tb_ping;
    23322297                        } else {
     2298                                $wpdb = WP::get( 'wpdb' );
    23332299                                $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, %s, '')) WHERE ID = %d", $tb_ping, $post_id) );
    23342300                        }
    23352301                }
     
    24692435 *
    24702436 * @since 0.71
    24712437 *
    2472  * @global wpdb $wpdb WordPress database abstraction object.
    2473  *
    24742438 * @param string $trackback_url URL to send trackbacks.
    24752439 * @param string $title Title of post.
    24762440 * @param string $excerpt Excerpt of post.
     
    24782442 * @return int|false|void Database query from update.
    24792443 */
    24802444function trackback($trackback_url, $title, $excerpt, $ID) {
    2481         global $wpdb;
    2482 
    24832445        if ( empty($trackback_url) )
    24842446                return;
    24852447
     
    24972459        if ( is_wp_error( $response ) )
    24982460                return;
    24992461
     2462        $wpdb = WP::get( 'wpdb' );
    25002463        $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET pinged = CONCAT(pinged, '\n', %s) WHERE ID = %d", $trackback_url, $ID) );
    25012464        return $wpdb->query( $wpdb->prepare("UPDATE $wpdb->posts SET to_ping = TRIM(REPLACE(to_ping, %s, '')) WHERE ID = %d", $trackback_url, $ID) );
    25022465}
     
    26212584 * @access private
    26222585 *
    26232586 * @see update_comment_cache()
    2624  * @global wpdb $wpdb WordPress database abstraction object.
    26252587 *
    26262588 * @param array $comment_ids       Array of comment IDs.
    26272589 * @param bool  $update_meta_cache Optional. Whether to update the meta cache. Default true.
    26282590 */
    26292591function _prime_comment_caches( $comment_ids, $update_meta_cache = true ) {
    2630         global $wpdb;
    2631 
    26322592        $non_cached_ids = _get_non_cached_ids( $comment_ids, 'comment' );
    26332593        if ( !empty( $non_cached_ids ) ) {
     2594                $wpdb = WP::get( 'wpdb' );
    26342595                $fresh_comments = $wpdb->get_results( sprintf( "SELECT $wpdb->comments.* FROM $wpdb->comments WHERE comment_ID IN (%s)", join( ",", array_map( 'intval', $non_cached_ids ) ) ) );
    26352596
    26362597                update_comment_cache( $fresh_comments, $update_meta_cache );
  • src/wp-includes/date.php

     
    6262         */
    6363        public $time_keys = array( 'after', 'before', 'year', 'month', 'monthnum', 'week', 'w', 'dayofyear', 'day', 'dayofweek', 'dayofweek_iso', 'hour', 'minute', 'second' );
    6464
     65        protected $dbh;
     66
    6567        /**
    6668         * Constructor.
    6769         *
     
    158160                        $this->relation = 'AND';
    159161                }
    160162
     163                $this->dbh = WP::get( 'wpdb' );
     164
    161165                if ( ! is_array( $date_query ) ) {
    162166                        return;
    163167                }
     
    486490         * @return string A validated column name value.
    487491         */
    488492        public function validate_column( $column ) {
    489                 global $wpdb;
    490 
    491493                $valid_columns = array(
    492494                        'post_date', 'post_date_gmt', 'post_modified',
    493495                        'post_modified_gmt', 'comment_date', 'comment_date_gmt',
     
    512514                        }
    513515
    514516                        $known_columns = array(
    515                                 $wpdb->posts => array(
     517                                $this->dbh->posts => array(
    516518                                        'post_date',
    517519                                        'post_date_gmt',
    518520                                        'post_modified',
    519521                                        'post_modified_gmt',
    520522                                ),
    521                                 $wpdb->comments => array(
     523                                $this->dbh->comments => array(
    522524                                        'comment_date',
    523525                                        'comment_date_gmt',
    524526                                ),
    525                                 $wpdb->users => array(
     527                                $this->dbh->users => array(
    526528                                        'user_registered',
    527529                                ),
    528                                 $wpdb->blogs => array(
     530                                $this->dbh->blogs => array(
    529531                                        'registered',
    530532                                        'last_updated',
    531533                                ),
     
    717719         * }
    718720         */
    719721        protected function get_sql_for_clause( $query, $parent_query ) {
    720                 global $wpdb;
    721 
    722722                // The sub-parts of a $where part.
    723723                $where_parts = array();
    724724
     
    741741
    742742                // Range queries.
    743743                if ( ! empty( $query['after'] ) )
    744                         $where_parts[] = $wpdb->prepare( "$column $gt %s", $this->build_mysql_datetime( $query['after'], ! $inclusive ) );
     744                        $where_parts[] = $this->dbh->prepare( "$column $gt %s", $this->build_mysql_datetime( $query['after'], ! $inclusive ) );
    745745
    746746                if ( ! empty( $query['before'] ) )
    747                         $where_parts[] = $wpdb->prepare( "$column $lt %s", $this->build_mysql_datetime( $query['before'], $inclusive ) );
     747                        $where_parts[] = $this->dbh->prepare( "$column $lt %s", $this->build_mysql_datetime( $query['before'], $inclusive ) );
    748748
    749749                // Specific value queries.
    750750
     
    958958         * @return string|false A query part or false on failure.
    959959         */
    960960        public function build_time_query( $column, $compare, $hour = null, $minute = null, $second = null ) {
    961                 global $wpdb;
    962 
    963961                // Have to have at least one
    964962                if ( ! isset( $hour ) && ! isset( $minute ) && ! isset( $second ) )
    965963                        return false;
     
    10131011                        $time   .= sprintf( '%02d', $second );
    10141012                }
    10151013
    1016                 return $wpdb->prepare( "DATE_FORMAT( $column, %s ) $compare %f", $format, $time );
     1014                return $this->dbh->prepare( "DATE_FORMAT( $column, %s ) $compare %f", $format, $time );
    10171015        }
    10181016}
  • src/wp-includes/deprecated.php

     
    22102210 */
    22112211function delete_usermeta( $user_id, $meta_key, $meta_value = '' ) {
    22122212        _deprecated_function( __FUNCTION__, '3.0.0', 'delete_user_meta()' );
    2213         global $wpdb;
     2213
    22142214        if ( !is_numeric( $user_id ) )
    22152215                return false;
    22162216        $meta_key = preg_replace('|[^a-z0-9_]|i', '', $meta_key);
     
    22192219                $meta_value = serialize($meta_value);
    22202220        $meta_value = trim( $meta_value );
    22212221
     2222        $wpdb = WP::get( 'wpdb' );
    22222223        $cur = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->usermeta WHERE user_id = %d AND meta_key = %s", $user_id, $meta_key) );
    22232224
    22242225        if ( $cur && $cur->umeta_id )
     
    22562257 */
    22572258function get_usermeta( $user_id, $meta_key = '' ) {
    22582259        _deprecated_function( __FUNCTION__, '3.0.0', 'get_user_meta()' );
    2259         global $wpdb;
     2260
    22602261        $user_id = (int) $user_id;
    22612262
    22622263        if ( !$user_id )
    22632264                return false;
    22642265
     2266        $wpdb = WP::get( 'wpdb' );
     2267
    22652268        if ( !empty($meta_key) ) {
    22662269                $meta_key = preg_replace('|[^a-z0-9_]|i', '', $meta_key);
    22672270                $user = wp_cache_get($user_id, 'users');
     
    23092312 */
    23102313function update_usermeta( $user_id, $meta_key, $meta_value ) {
    23112314        _deprecated_function( __FUNCTION__, '3.0.0', 'update_user_meta()' );
    2312         global $wpdb;
     2315
    23132316        if ( !is_numeric( $user_id ) )
    23142317                return false;
    23152318        $meta_key = preg_replace('|[^a-z0-9_]|i', '', $meta_key);
     
    23232326                return delete_usermeta($user_id, $meta_key);
    23242327        }
    23252328
     2329        $wpdb = WP::get( 'wpdb' );
    23262330        $cur = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->usermeta WHERE user_id = %d AND meta_key = %s", $user_id, $meta_key) );
    23272331
    23282332        if ( $cur )
     
    23562360 * @deprecated 3.1.0 Use get_users()
    23572361 * @see get_users()
    23582362 *
    2359  * @global wpdb $wpdb    WordPress database abstraction object.
    23602363 * @global int  $blog_id The site ID of the site for those that use more than one site.
    23612364 *
    23622365 * @param int $id Site ID.
     
    23652368function get_users_of_blog( $id = '' ) {
    23662369        _deprecated_function( __FUNCTION__, '3.1.0', 'get_users()' );
    23672370
    2368         global $wpdb, $blog_id;
    2369         if ( empty($id) )
     2371        global $blog_id;
     2372        if ( empty( $id ) ) {
    23702373                $id = (int) $blog_id;
     2374        }
     2375        $wpdb = WP::get( 'wpdb' );
    23712376        $blog_prefix = $wpdb->get_blog_prefix($id);
    23722377        $users = $wpdb->get_results( "SELECT user_id, user_id AS ID, user_login, display_name, user_email, meta_value FROM $wpdb->users, $wpdb->usermeta WHERE {$wpdb->users}.ID = {$wpdb->usermeta}.user_id AND meta_key = '{$blog_prefix}capabilities' ORDER BY {$wpdb->usermeta}.user_id" );
    23732378        return $users;
  • src/wp-includes/formatting.php

     
    37173717 *
    37183718 * @since 2.8.0
    37193719 *
    3720  * @global wpdb $wpdb WordPress database abstraction object.
    3721  *
    37223720 * @param string|array $data Unescaped data
    37233721 * @return string|array Escaped data
    37243722 */
    37253723function esc_sql( $data ) {
    3726         global $wpdb;
    3727         return $wpdb->_escape( $data );
     3724        return WP::get( 'wpdb' )->_escape( $data );
    37283725}
    37293726
    37303727/**
     
    40124009 *
    40134010 * @since 2.0.5
    40144011 *
    4015  * @global wpdb $wpdb WordPress database abstraction object.
    4016  *
    40174012 * @param string $option The name of the option.
    40184013 * @param string $value  The unsanitised value.
    40194014 * @return string Sanitized value.
    40204015 */
    40214016function sanitize_option( $option, $value ) {
    4022         global $wpdb;
    4023 
    40244017        $original_value = $value;
    40254018        $error = '';
    40264019
     4020        $wpdb = WP::get( 'wpdb' );
     4021
    40274022        switch ( $option ) {
    40284023                case 'admin_email' :
    40294024                case 'new_admin_email' :
  • src/wp-includes/functions.php

     
    554554 *
    555555 * @since 1.5.0
    556556 *
    557  * @global wpdb $wpdb WordPress database abstraction object.
    558  *
    559557 * @param string $content Post Content.
    560558 * @param int    $post_ID Post ID.
    561559 */
    562560function do_enclose( $content, $post_ID ) {
    563         global $wpdb;
     561        $wpdb = WP::get( 'wpdb' );
    564562
    565563        //TODO: Tidy this ghetto code up and make the debug code optional
    566564        include_once( ABSPATH . WPINC . '/class-IXR.php' );
     
    11831181 *
    11841182 * @since 2.0.0
    11851183 *
    1186  * @global wpdb $wpdb WordPress database abstraction object.
    1187  *
    11881184 * @return int Number of database queries.
    11891185 */
    11901186function get_num_queries() {
    1191         global $wpdb;
    1192         return $wpdb->num_queries;
     1187        return WP::get( 'wpdb' )->num_queries;
    11931188}
    11941189
    11951190/**
     
    13531348 *
    13541349 * @since 2.1.0
    13551350 *
    1356  * @global wpdb $wpdb WordPress database abstraction object.
    1357  *
    13581351 * @return bool Whether the site is already installed.
    13591352 */
    13601353function is_blog_installed() {
    1361         global $wpdb;
    1362 
    13631354        /*
    13641355         * Check cache first. If options table goes away and we have true
    13651356         * cached, oh well.
     
    13671358        if ( wp_cache_get( 'is_blog_installed' ) )
    13681359                return true;
    13691360
     1361        $wpdb = WP::get( 'wpdb' );
    13701362        $suppress = $wpdb->suppress_errors();
    13711363        if ( ! wp_installing() ) {
    13721364                $alloptions = wp_load_alloptions();
     
    36123604 * in WordPress 2.5.0.
    36133605 *
    36143606 * @since 2.3.2
    3615  *
    3616  * @global wpdb $wpdb WordPress database abstraction object.
    36173607 */
    36183608function dead_db() {
    3619         global $wpdb;
     3609        $wpdb = WP::get( 'wpdb' );
    36203610
    36213611        wp_load_translations_early();
    36223612
     
    42854275 *
    42864276 * @since 4.3.0
    42874277 *
    4288  * @global wpdb $wpdb WordPress database abstraction object.
    4289  *
    42904278 * @return int The ID of the main network.
    42914279 */
    42924280function get_main_network_id() {
    4293         global $wpdb;
    4294 
    42954281        if ( ! is_multisite() ) {
    42964282                return 1;
    42974283        }
     
    43074293                $main_network_id = wp_cache_get( 'primary_network_id', 'site-options' );
    43084294
    43094295                if ( false === $main_network_id ) {
     4296                        $wpdb = WP::get( 'wpdb' );
    43104297                        $main_network_id = (int) $wpdb->get_var( "SELECT id FROM {$wpdb->site} ORDER BY id LIMIT 1" );
    43114298                        wp_cache_add( 'primary_network_id', $main_network_id, 'site-options' );
    43124299                }
     
    45804567 * The default value of `EMPTY_TRASH_DAYS` is 30 (days).
    45814568 *
    45824569 * @since 2.9.0
    4583  *
    4584  * @global wpdb $wpdb WordPress database abstraction object.
    45854570 */
    45864571function wp_scheduled_delete() {
    4587         global $wpdb;
     4572        $wpdb = WP::get( 'wpdb' );
    45884573
    45894574        $delete_timestamp = time() - ( DAY_IN_SECONDS * EMPTY_TRASH_DAYS );
    45904575
  • src/wp-includes/general-template.php

     
    16111611 *
    16121612 * @see get_archives_link()
    16131613 *
    1614  * @global wpdb      $wpdb
    16151614 * @global WP_Locale $wp_locale
    16161615 *
    16171616 * @param string|array $args {
     
    16391638 * @return string|void String when retrieving.
    16401639 */
    16411640function wp_get_archives( $args = '' ) {
    1642         global $wpdb, $wp_locale;
     1641        global $wp_locale;
    16431642
    16441643        $defaults = array(
    16451644                'type' => 'monthly', 'limit' => '',
     
    16741673        // this is what will separate dates on weekly archive links
    16751674        $archive_week_separator = '&#8211;';
    16761675
     1676        $wpdb = WP::get( 'wpdb' );
    16771677        $sql_where = $wpdb->prepare( "WHERE post_type = %s AND post_status = 'publish'", $r['post_type'] );
    16781678
    16791679        /**
     
    18571857 *
    18581858 * @since 1.0.0
    18591859 *
    1860  * @global wpdb      $wpdb
    18611860 * @global int       $m
    18621861 * @global int       $monthnum
    18631862 * @global int       $year
     
    18691868 * @return string|void String when retrieving.
    18701869 */
    18711870function get_calendar( $initial = true, $echo = true ) {
    1872         global $wpdb, $m, $monthnum, $year, $wp_locale, $posts;
     1871        global $m, $monthnum, $year, $wp_locale, $posts;
    18731872
     1873        $wpdb = WP::get( 'wpdb' );
     1874
    18741875        $key = md5( $m . $monthnum . $year );
    18751876        $cache = wp_cache_get( 'get_calendar', 'calendar' );
    18761877
  • src/wp-includes/http.php

     
    602602 *
    603603 * @since 3.6.0
    604604 *
    605  * @global wpdb $wpdb WordPress database abstraction object.
    606605 * @staticvar array $queried
    607606 *
    608607 * @param bool   $is_external
     
    610609 * @return bool
    611610 */
    612611function ms_allowed_http_request_hosts( $is_external, $host ) {
    613         global $wpdb;
    614612        static $queried = array();
    615613        if ( $is_external )
    616614                return $is_external;
     
    618616                return true;
    619617        if ( isset( $queried[ $host ] ) )
    620618                return $queried[ $host ];
     619
     620        $wpdb = WP::get( 'wpdb' );
    621621        $queried[ $host ] = (bool) $wpdb->get_var( $wpdb->prepare( "SELECT domain FROM $wpdb->blogs WHERE domain = %s LIMIT 1", $host ) );
    622622        return $queried[ $host ];
    623623}
  • src/wp-includes/link-template.php

     
    15761576 *
    15771577 * @since 2.5.0
    15781578 *
    1579  * @global wpdb $wpdb WordPress database abstraction object.
    1580  *
    15811579 * @param bool         $in_same_term   Optional. Whether post should be in a same taxonomy term. Default false.
    15821580 * @param array|string $excluded_terms Optional. Array or comma-separated list of excluded term IDs. Default empty.
    15831581 * @param bool         $previous       Optional. Whether to retrieve previous post. Default true
     
    15861584 *                             corresponding post exists.
    15871585 */
    15881586function get_adjacent_post( $in_same_term = false, $excluded_terms = '', $previous = true, $taxonomy = 'category' ) {
    1589         global $wpdb;
    1590 
    15911587        if ( ( ! $post = get_post() ) || ! taxonomy_exists( $taxonomy ) )
    15921588                return null;
    15931589
     1590        $wpdb = WP::get( 'wpdb' );
     1591
    15941592        $current_post_date = $post->post_date;
    15951593
    15961594        $join = '';
  • src/wp-includes/load.php

     
    388388 * Load the database class file and instantiate the `$wpdb` global.
    389389 *
    390390 * @since 2.5.0
    391  *
    392  * @global wpdb $wpdb The WordPress database class.
    393391 */
    394392function require_wp_db() {
    395         global $wpdb;
     393        $wpdb = null;
    396394
    397395        require_once( ABSPATH . WPINC . '/wp-db.php' );
    398         if ( file_exists( WP_CONTENT_DIR . '/db.php' ) )
     396        if ( file_exists( WP_CONTENT_DIR . '/db.php' ) ) {
    399397                require_once( WP_CONTENT_DIR . '/db.php' );
     398        }
    400399
    401         if ( isset( $wpdb ) )
     400        if ( isset( $wpdb ) ) {
     401                WP::set( 'wpdb', $wpdb, true );
    402402                return;
     403        }
    403404
    404         $wpdb = new wpdb( DB_USER, DB_PASSWORD, DB_NAME, DB_HOST );
     405        $db = new wpdb( DB_USER, DB_PASSWORD, DB_NAME, DB_HOST );
     406
     407        WP::set( 'wpdb', $db, true );
    405408}
    406409
    407410/**
  • src/wp-includes/media.php

     
    32163216 * @since 3.5.0
    32173217 *
    32183218 * @global int       $content_width
    3219  * @global wpdb      $wpdb
    32203219 * @global WP_Locale $wp_locale
    32213220 *
    32223221 * @param array $args {
     
    32303229        if ( did_action( 'wp_enqueue_media' ) )
    32313230                return;
    32323231
    3233         global $content_width, $wpdb, $wp_locale;
     3232        global $content_width, $wp_locale;
    32343233
    32353234        $defaults = array(
    32363235                'post' => null,
     
    32693268                }
    32703269        }
    32713270
     3271        $wpdb = WP::get( 'wpdb' );
     3272
    32723273        $has_audio = $wpdb->get_var( "
    32733274                SELECT ID
    32743275                FROM $wpdb->posts
     
    37433744 *
    37443745 * @since 4.0.0
    37453746 *
    3746  * @global wpdb $wpdb WordPress database abstraction object.
    3747  *
    37483747 * @param string $url The URL to resolve.
    37493748 * @return int The found post ID, or 0 on failure.
    37503749 */
    37513750function attachment_url_to_postid( $url ) {
    3752         global $wpdb;
    3753 
    37543751        $dir = wp_get_upload_dir();
    37553752        $path = $url;
    37563753
     
    37663763                $path = substr( $path, strlen( $dir['baseurl'] . '/' ) );
    37673764        }
    37683765
     3766        $wpdb = WP::get( 'wpdb' );
    37693767        $sql = $wpdb->prepare(
    37703768                "SELECT post_id FROM $wpdb->postmeta WHERE meta_key = '_wp_attached_file' AND meta_value = %s",
    37713769                $path
  • src/wp-includes/meta.php

     
    1515 *
    1616 * @since 2.9.0
    1717 *
    18  * @global wpdb $wpdb WordPress database abstraction object.
    19  *
    2018 * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
    2119 * @param int    $object_id  ID of the object metadata is for
    2220 * @param string $meta_key   Metadata key
     
    2826 * @return int|false The meta ID on success, false on failure.
    2927 */
    3028function add_metadata($meta_type, $object_id, $meta_key, $meta_value, $unique = false) {
    31         global $wpdb;
    32 
    3329        if ( ! $meta_type || ! $meta_key || ! is_numeric( $object_id ) ) {
    3430                return false;
    3531        }
     
    7167        if ( null !== $check )
    7268                return $check;
    7369
     70        $wpdb = WP::get( 'wpdb' );
    7471        if ( $unique && $wpdb->get_var( $wpdb->prepare(
    7572                "SELECT COUNT(*) FROM $table WHERE meta_key = %s AND $column = %d",
    7673                $meta_key, $object_id ) ) )
     
    130127 *
    131128 * @since 2.9.0
    132129 *
    133  * @global wpdb $wpdb WordPress database abstraction object.
    134  *
    135130 * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
    136131 * @param int    $object_id  ID of the object metadata is for
    137132 * @param string $meta_key   Metadata key
     
    141136 * @return int|bool Meta ID if the key didn't exist, true on successful update, false on failure.
    142137 */
    143138function update_metadata($meta_type, $object_id, $meta_key, $meta_value, $prev_value = '') {
    144         global $wpdb;
    145 
    146139        if ( ! $meta_type || ! $meta_key || ! is_numeric( $object_id ) ) {
    147140                return false;
    148141        }
     
    197190                }
    198191        }
    199192
     193        $wpdb = WP::get( 'wpdb' );
    200194        $meta_ids = $wpdb->get_col( $wpdb->prepare( "SELECT $id_column FROM $table WHERE meta_key = %s AND $column = %d", $meta_key, $object_id ) );
    201195        if ( empty( $meta_ids ) ) {
    202196                return add_metadata( $meta_type, $object_id, $raw_meta_key, $passed_value );
     
    289283 *
    290284 * @since 2.9.0
    291285 *
    292  * @global wpdb $wpdb WordPress database abstraction object.
    293  *
    294286 * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
    295287 * @param int    $object_id  ID of the object metadata is for
    296288 * @param string $meta_key   Metadata key
     
    305297 * @return bool True on successful delete, false on failure.
    306298 */
    307299function delete_metadata($meta_type, $object_id, $meta_key, $meta_value = '', $delete_all = false) {
    308         global $wpdb;
    309 
    310300        if ( ! $meta_type || ! $meta_key || ! is_numeric( $object_id ) && ! $delete_all ) {
    311301                return false;
    312302        }
     
    351341        $_meta_value = $meta_value;
    352342        $meta_value = maybe_serialize( $meta_value );
    353343
     344        $wpdb = WP::get( 'wpdb' );
     345
    354346        $query = $wpdb->prepare( "SELECT $id_column FROM $table WHERE meta_key = %s", $meta_key );
    355347
    356348        if ( !$delete_all )
     
    558550 *
    559551 * @since 3.3.0
    560552 *
    561  * @global wpdb $wpdb WordPress database abstraction object.
    562  *
    563553 * @param string $meta_type Type of object metadata is for (e.g., comment, post, term, or user).
    564554 * @param int    $meta_id   ID for a specific meta row
    565555 * @return object|false Meta object or false.
    566556 */
    567557function get_metadata_by_mid( $meta_type, $meta_id ) {
    568         global $wpdb;
    569 
    570558        if ( ! $meta_type || ! is_numeric( $meta_id ) ) {
    571559                return false;
    572560        }
     
    583571
    584572        $id_column = ( 'user' == $meta_type ) ? 'umeta_id' : 'meta_id';
    585573
     574        $wpdb = WP::get( 'wpdb' );
    586575        $meta = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $table WHERE $id_column = %d", $meta_id ) );
    587576
    588577        if ( empty( $meta ) )
     
    599588 *
    600589 * @since 3.3.0
    601590 *
    602  * @global wpdb $wpdb WordPress database abstraction object.
    603  *
    604591 * @param string $meta_type  Type of object metadata is for (e.g., comment, post, or user)
    605592 * @param int    $meta_id    ID for a specific meta row
    606593 * @param string $meta_value Metadata value
     
    608595 * @return bool True on successful update, false on failure.
    609596 */
    610597function update_metadata_by_mid( $meta_type, $meta_id, $meta_value, $meta_key = false ) {
    611         global $wpdb;
    612 
    613598        // Make sure everything is valid.
    614599        if ( ! $meta_type || ! is_numeric( $meta_id ) ) {
    615600                return false;
     
    664649                        do_action( 'update_postmeta', $meta_id, $object_id, $meta_key, $meta_value );
    665650                }
    666651
     652                $wpdb = WP::get( 'wpdb' );
    667653                // Run the update query, all fields in $data are %s, $where is a %d.
    668654                $result = $wpdb->update( $table, $data, $where, '%s', '%d' );
    669655                if ( ! $result )
     
    692678 *
    693679 * @since 3.3.0
    694680 *
    695  * @global wpdb $wpdb WordPress database abstraction object.
    696  *
    697681 * @param string $meta_type Type of object metadata is for (e.g., comment, post, term, or user).
    698682 * @param int    $meta_id   ID for a specific meta row
    699683 * @return bool True on successful delete, false on failure.
    700684 */
    701685function delete_metadata_by_mid( $meta_type, $meta_id ) {
    702         global $wpdb;
    703 
    704686        // Make sure everything is valid.
    705687        if ( ! $meta_type || ! is_numeric( $meta_id ) ) {
    706688                return false;
     
    742724                        do_action( "delete_{$meta_type}meta", $meta_id );
    743725                }
    744726
     727                $wpdb = WP::get( 'wpdb' );
    745728                // Run the query, will return true if deleted, false otherwise
    746729                $result = (bool) $wpdb->delete( $table, array( $id_column => $meta_id ) );
    747730
     
    779762 *
    780763 * @since 2.9.0
    781764 *
    782  * @global wpdb $wpdb WordPress database abstraction object.
    783  *
    784765 * @param string    $meta_type  Type of object metadata is for (e.g., comment, post, or user)
    785766 * @param int|array $object_ids Array or comma delimited list of object IDs to update cache for
    786767 * @return array|false Metadata cache for the specified objects, or false on failure.
    787768 */
    788769function update_meta_cache($meta_type, $object_ids) {
    789         global $wpdb;
    790 
    791770        if ( ! $meta_type || ! $object_ids ) {
    792771                return false;
    793772        }
     
    823802        // Get meta info
    824803        $id_list = join( ',', $ids );
    825804        $id_column = 'user' == $meta_type ? 'umeta_id' : 'meta_id';
     805
     806        $wpdb = WP::get( 'wpdb' );
    826807        $meta_list = $wpdb->get_results( "SELECT $column, meta_key, meta_value FROM $table WHERE $column IN ($id_list) ORDER BY $id_column ASC", ARRAY_A );
    827808
    828809        if ( !empty($meta_list) ) {
     
    892873 *
    893874 * @since 2.9.0
    894875 *
    895  * @global wpdb $wpdb WordPress database abstraction object.
    896  *
    897876 * @param string $type Type of object to get metadata table for (e.g., comment, post, or user)
    898877 * @return string|false Metadata table name, or false if no metadata table exists
    899878 */
    900879function _get_meta_table($type) {
    901         global $wpdb;
     880        $wpdb = WP::get( 'wpdb' );
    902881
    903882        $table_name = $type . 'meta';
    904883
  • src/wp-includes/ms-blogs.php

     
    1212 * Update the last_updated field for the current site.
    1313 *
    1414 * @since MU
    15  *
    16  * @global wpdb $wpdb WordPress database abstraction object.
    1715 */
    1816function wpmu_update_blogs_date() {
    19         global $wpdb;
     17        $wpdb = WP::get( 'wpdb' );
    2018
    2119        update_blog_details( $wpdb->blogid, array('last_updated' => current_time('mysql', true)) );
    2220        /**
     
    7674 *
    7775 * @since MU
    7876 *
    79  * @global wpdb $wpdb WordPress database abstraction object.
    80  *
    8177 * @param string $slug
    8278 * @return int A blog id
    8379 */
    8480function get_id_from_blogname( $slug ) {
    85         global $wpdb;
    86 
    8781        $current_site = get_current_site();
    8882        $slug = trim( $slug, '/' );
    8983
     
    9993                $path = $current_site->path . $slug . '/';
    10094        }
    10195
     96        $wpdb = WP::get( 'wpdb' );
    10297        $blog_id = $wpdb->get_var( $wpdb->prepare("SELECT blog_id FROM {$wpdb->blogs} WHERE domain = %s AND path = %s", $domain, $path) );
    10398        wp_cache_set( 'get_id_from_blogname_' . $slug, $blog_id, 'blog-details' );
    10499        return $blog_id;
     
    109104 *
    110105 * @since MU
    111106 *
    112  * @global wpdb $wpdb WordPress database abstraction object.
    113  *
    114107 * @param int|string|array $fields  Optional. A blog ID, a blog slug, or an array of fields to query against.
    115108 *                                  If not specified the current blog ID is used.
    116109 * @param bool             $get_all Whether to retrieve all details or only the details in the blogs table.
     
    118111 * @return WP_Site|false Blog details on success. False on failure.
    119112 */
    120113function get_blog_details( $fields = null, $get_all = true ) {
    121         global $wpdb;
     114        $wpdb = WP::get( 'wpdb' );
    122115
    123116        if ( is_array($fields ) ) {
    124117                if ( isset($fields['blog_id']) ) {
     
    293286 *
    294287 * @since MU
    295288 *
    296  * @global wpdb $wpdb WordPress database abstraction object.
    297  *
    298289 * @param int   $blog_id Blog ID
    299290 * @param array $details Array of details keyed by blogs table field names.
    300291 * @return bool True if update succeeds, false otherwise.
    301292 */
    302293function update_blog_details( $blog_id, $details = array() ) {
    303         global $wpdb;
    304 
    305294        if ( empty($details) )
    306295                return false;
    307296
     
    327316                $update_details[ $field ] = $details[ $field ];
    328317        }
    329318
     319        $wpdb = WP::get( 'wpdb' );
    330320        $result = $wpdb->update( $wpdb->blogs, $update_details, array('blog_id' => $blog_id) );
    331321
    332322        if ( false === $result )
     
    517507 * @access private
    518508 *
    519509 * @see update_site_cache()
    520  * @global wpdb $wpdb WordPress database abstraction object.
    521510 *
    522511 * @param array $ids ID list.
    523512 */
    524513function _prime_site_caches( $ids ) {
    525         global $wpdb;
    526 
    527514        $non_cached_ids = _get_non_cached_ids( $ids, 'sites' );
    528515        if ( ! empty( $non_cached_ids ) ) {
     516                $wpdb = WP::get( 'wpdb' );
    529517                $fresh_sites = $wpdb->get_results( sprintf( "SELECT * FROM $wpdb->blogs WHERE blog_id IN (%s)", join( ",", array_map( 'intval', $non_cached_ids ) ) ) );
    530518
    531519                update_site_cache( $fresh_sites );
     
    752740 * @see restore_current_blog()
    753741 * @since MU
    754742 *
    755  * @global wpdb            $wpdb
    756743 * @global int             $blog_id
    757744 * @global array           $_wp_switched_stack
    758745 * @global bool            $switched
     
    764751 * @return true Always returns True.
    765752 */
    766753function switch_to_blog( $new_blog, $deprecated = null ) {
    767         global $wpdb;
    768 
    769754        if ( empty( $new_blog ) )
    770755                $new_blog = $GLOBALS['blog_id'];
    771756
     
    790775                return true;
    791776        }
    792777
     778        $wpdb = WP::get( 'wpdb' );
    793779        $wpdb->set_blog_id( $new_blog );
    794780        $GLOBALS['table_prefix'] = $wpdb->get_blog_prefix();
    795781        $prev_blog_id = $GLOBALS['blog_id'];
     
    836822 * @see switch_to_blog()
    837823 * @since MU
    838824 *
    839  * @global wpdb            $wpdb
    840825 * @global array           $_wp_switched_stack
    841826 * @global int             $blog_id
    842827 * @global bool            $switched
     
    846831 * @return bool True on success, false if we're already on the current blog
    847832 */
    848833function restore_current_blog() {
    849         global $wpdb;
    850 
    851834        if ( empty( $GLOBALS['_wp_switched_stack'] ) )
    852835                return false;
    853836
     
    861844                return true;
    862845        }
    863846
     847        $wpdb = WP::get( 'wpdb' );
    864848        $wpdb->set_blog_id( $blog );
    865849        $prev_blog_id = $GLOBALS['blog_id'];
    866850        $GLOBALS['blog_id'] = $blog;
     
    947931 *
    948932 * @since MU
    949933 *
    950  * @global wpdb $wpdb WordPress database abstraction object.
    951  *
    952934 * @param int    $blog_id BLog ID
    953935 * @param string $pref    A field name
    954936 * @param string $value   Value for $pref
     
    956938 * @return string|false $value
    957939 */
    958940function update_blog_status( $blog_id, $pref, $value, $deprecated = null ) {
    959         global $wpdb;
    960 
    961941        if ( null !== $deprecated  )
    962942                _deprecated_argument( __FUNCTION__, '3.1.0' );
    963943
     
    964944        if ( ! in_array( $pref, array( 'site_id', 'domain', 'path', 'registered', 'last_updated', 'public', 'archived', 'mature', 'spam', 'deleted', 'lang_id') ) )
    965945                return $value;
    966946
     947        $wpdb = WP::get( 'wpdb' );
    967948        $result = $wpdb->update( $wpdb->blogs, array($pref => $value, 'last_updated' => current_time('mysql', true)), array('blog_id' => $blog_id) );
    968949
    969950        if ( false === $result )
     
    10231004 *
    10241005 * @since MU
    10251006 *
    1026  * @global wpdb $wpdb WordPress database abstraction object.
    1027  *
    10281007 * @param int    $id   The blog id
    10291008 * @param string $pref A field name
    10301009 * @return bool|string|null $value
    10311010 */
    10321011function get_blog_status( $id, $pref ) {
    1033         global $wpdb;
    1034 
    10351012        $details = get_blog_details( $id, false );
    10361013        if ( $details )
    10371014                return $details->$pref;
    10381015
     1016        $wpdb = WP::get( 'wpdb' );
    10391017        return $wpdb->get_var( $wpdb->prepare("SELECT %s FROM {$wpdb->blogs} WHERE blog_id = %d", $pref, $id) );
    10401018}
    10411019
     
    10441022 *
    10451023 * @since MU
    10461024 *
    1047  * @global wpdb $wpdb WordPress database abstraction object.
    1048  *
    10491025 * @param mixed $deprecated Not used
    10501026 * @param int   $start      The offset
    10511027 * @param int   $quantity   The maximum number of blogs to retrieve. Default is 40.
     
    10521028 * @return array The list of blogs
    10531029 */
    10541030function get_last_updated( $deprecated = '', $start = 0, $quantity = 40 ) {
    1055         global $wpdb;
    1056 
    10571031        if ( ! empty( $deprecated ) )
    10581032                _deprecated_argument( __FUNCTION__, 'MU' ); // never used
    10591033
     1034        $wpdb = WP::get( 'wpdb' );
    10601035        return $wpdb->get_results( $wpdb->prepare("SELECT blog_id, domain, path FROM $wpdb->blogs WHERE site_id = %d AND public = '1' AND archived = '0' AND mature = '0' AND spam = '0' AND deleted = '0' AND last_updated != '0000-00-00 00:00:00' ORDER BY last_updated DESC limit %d, %d", $wpdb->siteid, $start, $quantity ) , ARRAY_A );
    10611036}
    10621037
     
    11661141 * @access private
    11671142 *
    11681143 * @see update_network_cache()
    1169  * @global wpdb $wpdb WordPress database abstraction object.
    11701144 *
    11711145 * @param array $network_ids Array of network IDs.
    11721146 */
    11731147function _prime_network_caches( $network_ids ) {
    1174         global $wpdb;
    1175 
    11761148        $non_cached_ids = _get_non_cached_ids( $network_ids, 'networks' );
    11771149        if ( !empty( $non_cached_ids ) ) {
     1150                $wpdb = WP::get( 'wpdb' );
    11781151                $fresh_networks = $wpdb->get_results( sprintf( "SELECT $wpdb->site.* FROM $wpdb->site WHERE id IN (%s)", join( ",", array_map( 'intval', $non_cached_ids ) ) ) );
    11791152
    11801153                update_network_cache( $fresh_networks );
  • src/wp-includes/ms-default-constants.php

     
    1414 * wp-includes/ms-files.php (wp-content/blogs.php in MU).
    1515 *
    1616 * @since 3.0.0
    17  *
    18  * @global wpdb $wpdb WordPress database abstraction object.
    1917 */
    2018function ms_upload_constants() {
    21         global $wpdb;
    22 
    2319        // This filter is attached in ms-default-filters.php but that file is not included during SHORTINIT.
    2420        add_filter( 'default_site_option_ms_files_rewriting', '__return_true' );
    2521
     
    3329        // Note, the main site in a post-MU network uses wp-content/uploads.
    3430        // This is handled in wp_upload_dir() by ignoring UPLOADS for this case.
    3531        if ( ! defined( 'UPLOADS' ) ) {
     32                $wpdb = WP::get( 'wpdb' );
    3633                define( 'UPLOADS', UPLOADBLOGSDIR . "/{$wpdb->blogid}/files/" );
    3734
    3835                // Uploads dir relative to ABSPATH
  • src/wp-includes/ms-deprecated.php

     
    185185function get_blog_list( $start = 0, $num = 10, $deprecated = '' ) {
    186186        _deprecated_function( __FUNCTION__, '3.0.0', 'wp_get_sites()' );
    187187
    188         global $wpdb;
     188        $wpdb = WP::get( 'wpdb' );
    189189        $blogs = $wpdb->get_results( $wpdb->prepare("SELECT blog_id, domain, path FROM $wpdb->blogs WHERE site_id = %d AND public = '1' AND archived = '0' AND mature = '0' AND spam = '0' AND deleted = '0' ORDER BY registered DESC", $wpdb->siteid), ARRAY_A );
    190190
    191191        $blog_list = array();
     
    417417 * @since MU 1.0
    418418 * @deprecated 4.4.0
    419419 *
    420  * @global wpdb $wpdb WordPress database abstraction object.
    421  *
    422420 * @param string $sitedomain Optional. Site domain.
    423421 * @param string $path       Optional. Site path.
    424422 * @return array|false The network admins
     
    426424function get_admin_users_for_domain( $sitedomain = '', $path = '' ) {
    427425        _deprecated_function( __FUNCTION__, '4.4.0' );
    428426
    429         global $wpdb;
     427        $wpdb = WP::get( 'wpdb' );
    430428
    431429        if ( ! $sitedomain )
    432430                $site_id = $wpdb->siteid;
     
    446444 * @deprecated 4.6.0
    447445 * @see get_sites()
    448446 *
    449  * @global wpdb $wpdb WordPress database abstraction object.
    450  *
    451447 * @param array $args {
    452448 *     Array of default arguments. Optional.
    453449 *
     
    467463 *               values for whether the site is public, archived, mature, spam, and/or deleted.
    468464 */
    469465function wp_get_sites( $args = array() ) {
    470         global $wpdb;
    471 
    472466        _deprecated_function( __FUNCTION__, '4.6.0', 'get_sites()' );
    473467
    474468        if ( wp_is_large_network() )
    475469                return array();
    476470
     471        $wpdb = WP::get( 'wpdb' );
     472
    477473        $defaults = array(
    478474                'network_id' => $wpdb->siteid,
    479475                'public'     => null,
  • src/wp-includes/ms-functions.php

     
    3434 *
    3535 * @since MU 1.0
    3636 *
    37  * @global wpdb $wpdb WordPress database abstraction object.
    38  *
    3937 * @param int $user_id The unique ID of the user
    4038 * @return WP_Site|void The blog object
    4139 */
    4240function get_active_blog_for_user( $user_id ) {
    43         global $wpdb;
    4441        $blogs = get_blogs_of_user( $user_id );
    4542        if ( empty( $blogs ) )
    4643                return;
    4744
     45        $wpdb = WP::get( 'wpdb' );
    4846        if ( !is_multisite() )
    4947                return $blogs[$wpdb->blogid];
    5048
     
    194192 *
    195193 * @since MU 1.0
    196194 *
    197  * @global wpdb $wpdb WordPress database abstraction object.
    198  *
    199195 * @param int    $user_id  ID of the user you're removing.
    200196 * @param int    $blog_id  ID of the blog you're removing the user from.
    201197 * @param string $reassign Optional. A user to whom to reassign posts.
     
    202198 * @return true|WP_Error
    203199 */
    204200function remove_user_from_blog($user_id, $blog_id = '', $reassign = '') {
    205         global $wpdb;
    206201        switch_to_blog($blog_id);
    207202        $user_id = (int) $user_id;
    208203        /**
     
    250245        }
    251246
    252247        if ( $reassign != '' ) {
     248                $wpdb = WP::get( 'wpdb' );
    253249                $reassign = (int) $reassign;
    254250                $post_ids = $wpdb->get_col( $wpdb->prepare( "SELECT ID FROM $wpdb->posts WHERE post_author = %d", $user_id ) );
    255251                $link_ids = $wpdb->get_col( $wpdb->prepare( "SELECT link_id FROM $wpdb->links WHERE link_owner = %d", $user_id ) );
     
    297293 *
    298294 * @since MU 2.6.5
    299295 *
    300  * @global wpdb $wpdb WordPress database abstraction object.
    301  *
    302296 * @param string $domain
    303297 * @param string $path   Optional. Not required for subdomain installations.
    304298 * @return int 0 if no blog found, otherwise the ID of the matching blog
     
    401395 *
    402396 * @since MU
    403397 *
    404  * @global wpdb $wpdb WordPress database abstraction object.
    405  *
    406398 * @param string $user_name  The login name provided by the user.
    407399 * @param string $user_email The email provided by the user.
    408400 * @return array Contains username, email, and error messages.
    409401 */
    410402function wpmu_validate_user_signup($user_name, $user_email) {
    411         global $wpdb;
    412 
    413403        $errors = new WP_Error();
    414404
    415405        $orig_username = $user_name;
     
    474464        if ( email_exists($user_email) )
    475465                $errors->add( 'user_email', __( 'Sorry, that email address is already used!' ) );
    476466
     467        $wpdb = WP::get( 'wpdb' );
    477468        // Has someone already signed up for this username?
    478469        $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE user_login = %s", $user_name) );
    479470        if ( $signup != null ) {
     
    535526 *
    536527 * @since MU
    537528 *
    538  * @global wpdb   $wpdb
    539529 * @global string $domain
    540530 *
    541531 * @param string         $blogname   The blog name provided by the user. Must be unique.
     
    544534 * @return array Contains the new site data and error messages.
    545535 */
    546536function wpmu_validate_blog_signup( $blogname, $blog_title, $user = '' ) {
    547         global $wpdb, $domain;
     537        global $domain;
    548538
    549539        $current_site = get_current_site();
    550540        $base = $current_site->path;
     
    579569        if ( strlen( $blogname ) < 4 && !is_super_admin() )
    580570                $errors->add('blogname',  __( 'Site name must be at least 4 characters.' ) );
    581571
     572        $wpdb = WP::get( 'wpdb' );
    582573        // do not allow users to create a blog that conflicts with a page on the main blog.
    583574        if ( !is_subdomain_install() && $wpdb->get_var( $wpdb->prepare( "SELECT post_name FROM " . $wpdb->get_blog_prefix( $current_site->blog_id ) . "posts WHERE post_type = 'page' AND post_name = %s", $blogname ) ) )
    584575                $errors->add( 'blogname', __( 'Sorry, you may not use that site name.' ) );
     
    657648 *
    658649 * @since MU
    659650 *
    660  * @global wpdb $wpdb WordPress database abstraction object.
    661  *
    662651 * @param string $domain     The requested domain.
    663652 * @param string $path       The requested path.
    664653 * @param string $title      The requested site title.
     
    667656 * @param array  $meta       By default, contains the requested privacy setting and lang_id.
    668657 */
    669658function wpmu_signup_blog( $domain, $path, $title, $user, $user_email, $meta = array() )  {
    670         global $wpdb;
    671 
    672659        $key = substr( md5( time() . rand() . $domain ), 0, 16 );
    673660        $meta = serialize($meta);
    674661
     662        $wpdb = WP::get( 'wpdb' );
    675663        $wpdb->insert( $wpdb->signups, array(
    676664                'domain' => $domain,
    677665                'path' => $path,
     
    707695 *
    708696 * @since MU
    709697 *
    710  * @global wpdb $wpdb WordPress database abstraction object.
    711  *
    712698 * @param string $user       The user's requested login name.
    713699 * @param string $user_email The user's email address.
    714700 * @param array  $meta       By default, this is an empty array.
    715701 */
    716702function wpmu_signup_user( $user, $user_email, $meta = array() ) {
    717         global $wpdb;
    718 
    719703        // Format data
    720704        $user = preg_replace( '/\s+/', '', sanitize_user( $user, true ) );
    721705        $user_email = sanitize_email( $user_email );
     
    722706        $key = substr( md5( time() . rand() . $user_email ), 0, 16 );
    723707        $meta = serialize($meta);
    724708
     709        $wpdb = WP::get( 'wpdb' );
    725710        $wpdb->insert( $wpdb->signups, array(
    726711                'domain' => '',
    727712                'path' => '',
     
    947932 *
    948933 * @since MU
    949934 *
    950  * @global wpdb $wpdb WordPress database abstraction object.
    951  *
    952935 * @param string $key The activation key provided to the user.
    953936 * @return array|WP_Error An array containing information about the activated user and/or blog
    954937 */
    955938function wpmu_activate_signup($key) {
    956         global $wpdb;
     939        $wpdb = WP::get( 'wpdb' );
    957940
    958941        $signup = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->signups WHERE activation_key = %s", $key) );
    959942
     
    12521235 *
    12531236 * @since MU
    12541237 *
    1255  * @global wpdb $wpdb WordPress database abstraction object.
    1256  *
    12571238 * @param string $domain  The domain to be checked.
    12581239 * @param string $path    The path to be checked.
    12591240 * @param int    $site_id Optional. Relevant only on multi-network installs.
     
    12911272 *
    12921273 * @since MU
    12931274 *
    1294  * @global wpdb $wpdb WordPress database abstraction object.
    1295  *
    12961275 * @param string $domain  The domain of the new site.
    12971276 * @param string $path    The path of the new site.
    12981277 * @param int    $site_id Unless you're running a multi-network install, be sure to set this value to 1.
     
    12991278 * @return int|false The ID of the new row
    13001279 */
    13011280function insert_blog($domain, $path, $site_id) {
    1302         global $wpdb;
     1281        $wpdb = WP::get( 'wpdb' );
    13031282
    13041283        $path = trailingslashit($path);
    13051284        $site_id = (int) $site_id;
     
    13251304 *
    13261305 * @since MU
    13271306 *
    1328  * @global wpdb     $wpdb
    13291307 * @global WP_Roles $wp_roles
    13301308 *
    13311309 * @param int    $blog_id    The value returned by insert_blog().
     
    13321310 * @param string $blog_title The title of the new site.
    13331311 */
    13341312function install_blog( $blog_id, $blog_title = '' ) {
    1335         global $wpdb, $wp_roles, $current_site;
     1313        global $wp_roles, $current_site;
    13361314
     1315        $wpdb = WP::get( 'wpdb' );
     1316
    13371317        // Cast for security
    13381318        $blog_id = (int) $blog_id;
    13391319
     
    13931373 * @deprecated MU
    13941374 * @deprecated Use wp_install_defaults()
    13951375 *
    1396  * @global wpdb $wpdb WordPress database abstraction object.
    1397  *
    13981376 * @param int $blog_id Ignored in this function.
    13991377 * @param int $user_id
    14001378 */
    14011379function install_blog_defaults($blog_id, $user_id) {
    1402         global $wpdb;
     1380        $wpdb = WP::get( 'wpdb' );
    14031381
    14041382        require_once( ABSPATH . 'wp-admin/includes/upgrade.php' );
    14051383
     
    16181596 *
    16191597 * @since MU
    16201598 *
    1621  * @global wpdb $wpdb WordPress database abstraction object.
    1622  *
    16231599 * @param int $user_id
    16241600 * @return array Contains the blog_id, post_id, post_date_gmt, and post_gmt_ts
    16251601 */
    16261602function get_most_recent_post_of_user( $user_id ) {
    1627         global $wpdb;
     1603        $wpdb = WP::get( 'wpdb' );
    16281604
    16291605        $user_blogs = get_blogs_of_user( (int) $user_id );
    16301606        $most_recent_post = array();
     
    17651741 *
    17661742 * @since MU
    17671743 *
    1768  * @global wpdb $wpdb WordPress database abstraction object.
    1769  *
    17701744 * @param string $deprecated Not used.
    17711745 */
    17721746function update_posts_count( $deprecated = '' ) {
    1773         global $wpdb;
     1747        $wpdb = WP::get( 'wpdb' );
    17741748        update_option( 'post_count', (int) $wpdb->get_var( "SELECT COUNT(ID) FROM {$wpdb->posts} WHERE post_status = 'publish' and post_type = 'post'" ) );
    17751749}
    17761750
     
    17791753 *
    17801754 * @since MU
    17811755 *
    1782  * @global wpdb $wpdb WordPress database abstraction object.
    1783  *
    17841756 * @param int $blog_id
    17851757 * @param int $user_id
    17861758 */
    17871759function wpmu_log_new_registrations( $blog_id, $user_id ) {
    1788         global $wpdb;
    17891760        $user = get_userdata( (int) $user_id );
    1790         if ( $user )
     1761        if ( $user ) {
     1762                $wpdb = WP::get( 'wpdb' );
    17911763                $wpdb->insert( $wpdb->registration_log, array('email' => $user->user_email, 'IP' => preg_replace( '/[^0-9., ]/', '', wp_unslash( $_SERVER['REMOTE_ADDR'] ) ), 'blog_id' => $blog_id, 'date_registered' => current_time('mysql')) );
     1764        }
    17921765}
    17931766
    17941767/**
     
    17981771 *
    17991772 * @see term_id_filter
    18001773 *
    1801  * @global wpdb $wpdb WordPress database abstraction object.
    18021774 * @staticvar int $global_terms_recurse
    18031775 *
    18041776 * @param int    $term_id    An ID for a term on the current blog.
     
    18061778 * @return int An ID from the global terms table mapped from $term_id.
    18071779 */
    18081780function global_terms( $term_id, $deprecated = '' ) {
    1809         global $wpdb;
    18101781        static $global_terms_recurse = null;
    18111782
    18121783        if ( !global_terms_enabled() )
     
    18221793        }
    18231794
    18241795        $term_id = intval( $term_id );
     1796        $wpdb = WP::get( 'wpdb' );
    18251797        $c = $wpdb->get_row( $wpdb->prepare( "SELECT * FROM $wpdb->terms WHERE term_id = %d", $term_id ) );
    18261798
    18271799        $global_id = $wpdb->get_var( $wpdb->prepare( "SELECT cat_ID FROM $wpdb->sitecategories WHERE category_nicename = %s", $c->slug ) );
     
    20822054 *
    20832055 * @since MU
    20842056 *
    2085  * @global wpdb $wpdb WordPress database abstraction object.
    2086  *
    20872057 * @param string $key
    20882058 * @param int    $user_id Optional. Defaults to current user.
    20892059 * @param int    $blog_id Optional. Defaults to current blog.
     
    20902060 * @return bool
    20912061 */
    20922062function is_user_option_local( $key, $user_id = 0, $blog_id = 0 ) {
    2093         global $wpdb;
    2094 
     2063        $wpdb = WP::get( 'wpdb' );
    20952064        $current_user = wp_get_current_user();
    20962065        if ( $blog_id == 0 ) {
    20972066                $blog_id = $wpdb->blogid;
     
    22572226 * Update the network-wide site count.
    22582227 *
    22592228 * @since 3.7.0
    2260  *
    2261  * @global wpdb $wpdb WordPress database abstraction object.
    22622229 */
    22632230function wp_update_network_site_counts() {
    2264         global $wpdb;
     2231        $wpdb = WP::get( 'wpdb' );
    22652232
    22662233        $count = get_sites( array(
    22672234                'network_id' => $wpdb->siteid,
     
    22782245 * Update the network-wide user count.
    22792246 *
    22802247 * @since 3.7.0
    2281  *
    2282  * @global wpdb $wpdb WordPress database abstraction object.
    22832248 */
    22842249function wp_update_network_user_counts() {
    2285         global $wpdb;
     2250        $wpdb = WP::get( 'wpdb' );
    22862251
    22872252        $count = $wpdb->get_var( "SELECT COUNT(ID) as c FROM $wpdb->users WHERE spam = '0' AND deleted = '0'" );
    22882253        update_site_option( 'user_count', $count );
  • src/wp-includes/ms-load.php

     
    157157 *
    158158 * @since 3.9.0
    159159 *
    160  * @global wpdb $wpdb WordPress database abstraction object.
    161  *
    162160 * @param string   $domain   Domain to check.
    163161 * @param string   $path     Path to check.
    164162 * @param int|null $segments Path segments to use. Defaults to null, or the full path.
     
    277275 * @since 4.6.0
    278276 * @access private
    279277 *
    280  * @global wpdb       $wpdb         WordPress database abstraction object.
    281278 * @global WP_Network $current_site The current network.
    282279 * @global WP_Site    $current_blog The current site.
    283280 *
     
    290287 *                     Redirect URL if parts exist, but the request as a whole can not be fulfilled.
    291288 */
    292289function ms_load_current_site_and_network( $domain, $path, $subdomain = false ) {
    293         global $wpdb, $current_site, $current_blog;
     290        global $current_site, $current_blog;
    294291
     292        $wpdb = WP::get( 'wpdb' );
     293
    295294        // If the network is defined in wp-config.php, we can simply use that.
    296295        if ( defined( 'DOMAIN_CURRENT_SITE' ) && defined( 'PATH_CURRENT_SITE' ) ) {
    297296                $current_site = new stdClass;
     
    454453 * @since 3.0.0
    455454 * @since 4.4.0 The `$domain` and `$path` parameters were added.
    456455 *
    457  * @global wpdb $wpdb WordPress database abstraction object.
    458  *
    459456 * @param string $domain The requested domain for the error to reference.
    460457 * @param string $path   The requested path for the error to reference.
    461458 */
    462459function ms_not_installed( $domain, $path ) {
    463         global $wpdb;
    464 
    465460        if ( ! is_admin() ) {
    466461                dead_db();
    467462        }
     
    473468        $msg  = '<h1>' . $title . '</h1>';
    474469        $msg .= '<p>' . __( 'If your site does not display, please contact the owner of this network.' ) . '';
    475470        $msg .= ' ' . __( 'If you are the owner of this network please check that MySQL is running properly and all tables are error free.' ) . '</p>';
     471
     472        $wpdb = WP::get( 'wpdb' );
    476473        $query = $wpdb->prepare( "SHOW TABLES LIKE %s", $wpdb->esc_like( $wpdb->site ) );
    477474        if ( ! $wpdb->get_var( $query ) ) {
    478475                $msg .= '<p>' . sprintf(
  • src/wp-includes/ms-settings.php

     
    8585        wp_load_core_site_options( $site_id );
    8686}
    8787
     88$wpdb = WP::get( 'wpdb' );
     89
    8890$wpdb->set_prefix( $table_prefix, false ); // $table_prefix can be set in sunrise.php
    8991$wpdb->set_blog_id( $current_blog->blog_id, $current_blog->site_id );
    9092$table_prefix = $wpdb->get_blog_prefix();
  • src/wp-includes/option.php

     
    2121 *
    2222 * @since 1.5.0
    2323 *
    24  * @global wpdb $wpdb WordPress database abstraction object.
    25  *
    2624 * @param string $option  Name of option to retrieve. Expected to not be SQL-escaped.
    2725 * @param mixed  $default Optional. Default value to return if the option does not exist.
    2826 * @return mixed Value set for the option.
    2927 */
    3028function get_option( $option, $default = false ) {
    31         global $wpdb;
    32 
    3329        $option = trim( $option );
    3430        if ( empty( $option ) )
    3531                return false;
     
    8379                        $value = wp_cache_get( $option, 'options' );
    8480
    8581                        if ( false === $value ) {
     82                                $wpdb = WP::get( 'wpdb' );
    8683                                $row = $wpdb->get_row( $wpdb->prepare( "SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1", $option ) );
    8784
    8885                                // Has to be get_row instead of get_var because of funkiness with 0, false, null values
     
    10299                        }
    103100                }
    104101        } else {
     102                $wpdb = WP::get( 'wpdb' );
    105103                $suppress = $wpdb->suppress_errors();
    106104                $row = $wpdb->get_row( $wpdb->prepare( "SELECT option_value FROM $wpdb->options WHERE option_name = %s LIMIT 1", $option ) );
    107105                $wpdb->suppress_errors( $suppress );
     
    167165 *
    168166 * @since 2.2.0
    169167 *
    170  * @global wpdb $wpdb WordPress database abstraction object.
    171  *
    172168 * @return array List of all options.
    173169 */
    174170function wp_load_alloptions() {
    175         global $wpdb;
    176 
    177171        if ( ! wp_installing() || ! is_multisite() )
    178172                $alloptions = wp_cache_get( 'alloptions', 'options' );
    179173        else
     
    180174                $alloptions = false;
    181175
    182176        if ( !$alloptions ) {
     177                $wpdb = WP::get( 'wpdb' );
    183178                $suppress = $wpdb->suppress_errors();
    184179                if ( !$alloptions_db = $wpdb->get_results( "SELECT option_name, option_value FROM $wpdb->options WHERE autoload = 'yes'" ) )
    185180                        $alloptions_db = $wpdb->get_results( "SELECT option_name, option_value FROM $wpdb->options" );
     
    200195 *
    201196 * @since 3.0.0
    202197 *
    203  * @global wpdb $wpdb WordPress database abstraction object.
    204  *
    205198 * @param int $site_id Optional site ID for which to query the options. Defaults to the current site.
    206199 */
    207200function wp_load_core_site_options( $site_id = null ) {
    208         global $wpdb;
    209 
    210201        if ( ! is_multisite() || wp_using_ext_object_cache() || wp_installing() )
    211202                return;
    212203
     204        $wpdb = WP::get( 'wpdb' );
    213205        if ( empty($site_id) )
    214206                $site_id = $wpdb->siteid;
    215207
     
    240232 * @since 1.0.0
    241233 * @since 4.2.0 The `$autoload` parameter was added.
    242234 *
    243  * @global wpdb $wpdb WordPress database abstraction object.
    244  *
    245235 * @param string      $option   Option name. Expected to not be SQL-escaped.
    246236 * @param mixed       $value    Option value. Must be serializable if non-scalar. Expected to not be SQL-escaped.
    247237 * @param string|bool $autoload Optional. Whether to load the option when WordPress starts up. For existing options,
     
    251241 * @return bool False if value was not updated and true if value was updated.
    252242 */
    253243function update_option( $option, $value, $autoload = null ) {
    254         global $wpdb;
    255 
    256244        $option = trim($option);
    257245        if ( empty($option) )
    258246                return false;
     
    325313                $update_args['autoload'] = ( 'no' === $autoload || false === $autoload ) ? 'no' : 'yes';
    326314        }
    327315
     316        $wpdb = WP::get( 'wpdb' );
    328317        $result = $wpdb->update( $wpdb->options, $update_args, array( 'option_name' => $option ) );
    329318        if ( ! $result )
    330319                return false;
     
    386375 *
    387376 * @since 1.0.0
    388377 *
    389  * @global wpdb $wpdb WordPress database abstraction object.
    390  *
    391378 * @param string         $option      Name of option to add. Expected to not be SQL-escaped.
    392379 * @param mixed          $value       Optional. Option value. Must be serializable if non-scalar. Expected to not be SQL-escaped.
    393380 * @param string         $deprecated  Optional. Description. Not used anymore.
     
    396383 * @return bool False if option was not added and true if option was added.
    397384 */
    398385function add_option( $option, $value = '', $deprecated = '', $autoload = 'yes' ) {
    399         global $wpdb;
    400 
    401386        if ( !empty( $deprecated ) )
    402387                _deprecated_argument( __FUNCTION__, '2.3.0' );
    403388
     
    432417         */
    433418        do_action( 'add_option', $option, $value );
    434419
     420        $wpdb = WP::get( 'wpdb' );
    435421        $result = $wpdb->query( $wpdb->prepare( "INSERT INTO `$wpdb->options` (`option_name`, `option_value`, `autoload`) VALUES (%s, %s, %s) ON DUPLICATE KEY UPDATE `option_name` = VALUES(`option_name`), `option_value` = VALUES(`option_value`), `autoload` = VALUES(`autoload`)", $option, $serialized_value, $autoload ) );
    436422        if ( ! $result )
    437423                return false;
     
    483469 *
    484470 * @since 1.2.0
    485471 *
    486  * @global wpdb $wpdb WordPress database abstraction object.
    487  *
    488472 * @param string $option Name of option to remove. Expected to not be SQL-escaped.
    489473 * @return bool True, if option is successfully deleted. False on failure.
    490474 */
    491475function delete_option( $option ) {
    492         global $wpdb;
    493 
    494476        $option = trim( $option );
    495477        if ( empty( $option ) )
    496478                return false;
     
    497479
    498480        wp_protect_special_option( $option );
    499481
     482        $wpdb = WP::get( 'wpdb' );
    500483        // Get the ID, if no ID then return
    501484        $row = $wpdb->get_row( $wpdb->prepare( "SELECT autoload FROM $wpdb->options WHERE option_name = %s", $option ) );
    502485        if ( is_null( $row ) )
     
    10691052 *
    10701053 * @see get_option()
    10711054 *
    1072  * @global wpdb   $wpdb
    10731055 * @global object $current_site
    10741056 *
    10751057 * @param int      $network_id ID of the network. Can be null to default to the current network ID.
     
    10781060 * @return mixed Value set for the option.
    10791061 */
    10801062function get_network_option( $network_id, $option, $default = false ) {
    1081         global $wpdb, $current_site;
     1063        global $current_site;
    10821064
    10831065        if ( $network_id && ! is_numeric( $network_id ) ) {
    10841066                return false;
     
    11421124                $value = wp_cache_get( $cache_key, 'site-options' );
    11431125
    11441126                if ( ! isset( $value ) || false === $value ) {
     1127                        $wpdb = WP::get( 'wpdb' );
    11451128                        $row = $wpdb->get_row( $wpdb->prepare( "SELECT meta_value FROM $wpdb->sitemeta WHERE meta_key = %s AND site_id = %d", $option, $network_id ) );
    11461129
    11471130                        // Has to be get_row instead of get_var because of funkiness with 0, false, null values
     
    11861169 *
    11871170 * @see add_option()
    11881171 *
    1189  * @global wpdb   $wpdb
    11901172 * @global object $current_site
    11911173 *
    11921174 * @param int    $network_id ID of the network. Can be null to default to the current network ID.
     
    11951177 * @return bool False if option was not added and true if option was added.
    11961178 */
    11971179function add_network_option( $network_id, $option, $value ) {
    1198         global $wpdb, $current_site;
     1180        global $current_site;
    11991181
    12001182        if ( $network_id && ! is_numeric( $network_id ) ) {
    12011183                return false;
     
    12421224                $value = sanitize_option( $option, $value );
    12431225
    12441226                $serialized_value = maybe_serialize( $value );
     1227                $wpdb = WP::get( 'wpdb' );
    12451228                $result = $wpdb->insert( $wpdb->sitemeta, array( 'site_id'    => $network_id, 'meta_key'   => $option, 'meta_value' => $serialized_value ) );
    12461229
    12471230                if ( ! $result ) {
     
    12961279 *
    12971280 * @see delete_option()
    12981281 *
    1299  * @global wpdb   $wpdb
    13001282 * @global object $current_site
    13011283 *
    13021284 * @param int    $network_id ID of the network. Can be null to default to the current network ID.
     
    13041286 * @return bool True, if succeed. False, if failure.
    13051287 */
    13061288function delete_network_option( $network_id, $option ) {
    1307         global $wpdb, $current_site;
     1289        global $current_site;
    13081290
    13091291        if ( $network_id && ! is_numeric( $network_id ) ) {
    13101292                return false;
     
    13321314        if ( ! is_multisite() ) {
    13331315                $result = delete_option( $option );
    13341316        } else {
     1317                $wpdb = WP::get( 'wpdb' );
    13351318                $row = $wpdb->get_row( $wpdb->prepare( "SELECT meta_id FROM {$wpdb->sitemeta} WHERE meta_key = %s AND site_id = %d", $option, $network_id ) );
    13361319                if ( is_null( $row ) || ! $row->meta_id ) {
    13371320                        return false;
     
    13781361 *
    13791362 * @see update_option()
    13801363 *
    1381  * @global wpdb   $wpdb
    13821364 * @global object $current_site
    13831365 *
    13841366 * @param int      $network_id ID of the network. Can be null to default to the current network ID.
     
    13871369 * @return bool False if value was not updated and true if value was updated.
    13881370 */
    13891371function update_network_option( $network_id, $option, $value ) {
    1390         global $wpdb, $current_site;
     1372        global $current_site;
    13911373
    13921374        if ( $network_id && ! is_numeric( $network_id ) ) {
    13931375                return false;
     
    14401422                $value = sanitize_option( $option, $value );
    14411423
    14421424                $serialized_value = maybe_serialize( $value );
     1425                $wpdb = WP::get( 'wpdb' );
    14431426                $result = $wpdb->update( $wpdb->sitemeta, array( 'meta_value' => $serialized_value ), array( 'site_id' => $network_id, 'meta_key' => $option ) );
    14441427
    14451428                if ( $result ) {
  • src/wp-includes/pluggable.php

     
    114114 *
    115115 * @since 3.0.0
    116116 *
    117  * @global wpdb $wpdb WordPress database abstraction object.
    118  *
    119117 * @param array $user_ids User ID numbers list
    120118 */
    121119function cache_users( $user_ids ) {
    122         global $wpdb;
    123 
    124120        $clean = _get_non_cached_ids( $user_ids, 'users' );
    125121
    126122        if ( empty( $clean ) )
     
    128124
    129125        $list = implode( ',', $clean );
    130126
     127        $wpdb = WP::get( 'wpdb' );
    131128        $users = $wpdb->get_results( "SELECT * FROM $wpdb->users WHERE ID IN ($list)" );
    132129
    133130        $ids = array();
     
    15281525 *
    15291526 * @since 1.0.0
    15301527 *
    1531  * @global wpdb $wpdb WordPress database abstraction object.
    1532  *
    15331528 * Uses the {@see 'notify_moderator'} filter to determine whether the site moderator
    15341529 * should be notified, overriding the site setting.
    15351530 *
     
    15371532 * @return true Always returns true.
    15381533 */
    15391534function wp_notify_moderator($comment_id) {
    1540         global $wpdb;
    1541 
    15421535        $maybe_notify = get_option( 'moderation_notify' );
    15431536
    15441537        /**
     
    15661559        }
    15671560
    15681561        $comment_author_domain = @gethostbyaddr($comment->comment_author_IP);
     1562        $wpdb = WP::get( 'wpdb' );
    15691563        $comments_waiting = $wpdb->get_var("SELECT count(comment_ID) FROM $wpdb->comments WHERE comment_approved = '0'");
    15701564
    15711565        // The blogname option is escaped with esc_html on the way into the database in sanitize_option
     
    16981692 * @since 4.3.1 The `$plaintext_pass` parameter was deprecated. `$notify` added as a third parameter.
    16991693 * @since 4.6.0 The `$notify` parameter accepts 'user' for sending notification only to the user created.
    17001694 *
    1701  * @global wpdb         $wpdb      WordPress database object for queries.
    17021695 * @global PasswordHash $wp_hasher Portable PHP password hashing framework instance.
    17031696 *
    17041697 * @param int    $user_id    User ID.
     
    17111704                _deprecated_argument( __FUNCTION__, '4.3.1' );
    17121705        }
    17131706
    1714         global $wpdb, $wp_hasher;
     1707        global $wp_hasher;
    17151708        $user = get_userdata( $user_id );
    17161709
    17171710        // The blogname option is escaped with esc_html on the way into the database in sanitize_option
     
    17431736                $wp_hasher = new PasswordHash( 8, true );
    17441737        }
    17451738        $hashed = time() . ':' . $wp_hasher->HashPassword( $key );
     1739        $wpdb = WP::get( 'wpdb' );
    17461740        $wpdb->update( $wpdb->users, array( 'user_activation_key' => $hashed ), array( 'user_login' => $user->user_login ) );
    17471741
    17481742        $message = sprintf(__('Username: %s'), $user->user_login) . "\r\n\r\n";
     
    22132207 *
    22142208 * @since 2.5.0
    22152209 *
    2216  * @global wpdb $wpdb WordPress database abstraction object.
    2217  *
    22182210 * @param string $password The plaintext new user password
    22192211 * @param int    $user_id  User ID
    22202212 */
    22212213function wp_set_password( $password, $user_id ) {
    2222         global $wpdb;
     2214        $wpdb = WP::get( 'wpdb' );
    22232215
    22242216        $hash = wp_hash_password( $password );
    22252217        $wpdb->update($wpdb->users, array('user_pass' => $hash, 'user_activation_key' => ''), array('ID' => $user_id) );
  • src/wp-includes/post.php

     
    14981498 *
    14991499 * @since 2.5.0
    15001500 *
    1501  * @global wpdb $wpdb WordPress database abstraction object.
    1502  *
    15031501 * @param int    $post_id   Optional. Post ID to change post type. Default 0.
    15041502 * @param string $post_type Optional. Post type. Accepts 'post' or 'page' to
    15051503 *                          name a few. Default 'post'.
     
    15061504 * @return int|false Amount of rows changed. Should be 1 for success and 0 for failure.
    15071505 */
    15081506function set_post_type( $post_id = 0, $post_type = 'post' ) {
    1509         global $wpdb;
     1507        $wpdb = WP::get( 'wpdb' );
    15101508
    15111509        $post_type = sanitize_post_field('post_type', $post_type, $post_id, 'db');
    15121510        $return = $wpdb->update( $wpdb->posts, array('post_type' => $post_type), array('ID' => $post_id) );
     
    20852083 *
    20862084 * @since 2.5.0
    20872085 *
    2088  * @global wpdb $wpdb WordPress database abstraction object.
    2089  *
    20902086 * @param string $type Optional. Post type to retrieve count. Default 'post'.
    20912087 * @param string $perm Optional. 'readable' or empty. Default empty.
    20922088 * @return object Number of posts for each status.
    20932089 */
    20942090function wp_count_posts( $type = 'post', $perm = '' ) {
    2095         global $wpdb;
    2096 
    20972091        if ( ! post_type_exists( $type ) )
    20982092                return new stdClass;
    20992093
     
    21052099                return apply_filters( 'wp_count_posts', $counts, $type, $perm );
    21062100        }
    21072101
     2102        $wpdb = WP::get( 'wpdb' );
    21082103        $query = "SELECT post_status, COUNT( * ) AS num_posts FROM {$wpdb->posts} WHERE post_type = %s";
    21092104        if ( 'readable' == $perm && is_user_logged_in() ) {
    21102105                $post_type_object = get_post_type_object($type);
     
    21502145 *
    21512146 * @since 2.5.0
    21522147 *
    2153  * @global wpdb $wpdb WordPress database abstraction object.
    2154  *
    21552148 * @param string|array $mime_type Optional. Array or comma-separated list of
    21562149 *                                MIME patterns. Default empty.
    21572150 * @return object An object containing the attachment counts by mime type.
    21582151 */
    21592152function wp_count_attachments( $mime_type = '' ) {
    2160         global $wpdb;
     2153        $wpdb = WP::get( 'wpdb' );
    21612154
    21622155        $and = wp_post_mime_type_where( $mime_type );
    21632156        $count = $wpdb->get_results( "SELECT post_mime_type, COUNT( * ) AS num_posts FROM $wpdb->posts WHERE post_type = 'attachment' AND post_status != 'trash' $and GROUP BY post_mime_type", ARRAY_A );
     
    23192312 *
    23202313 * @since 1.0.0
    23212314 *
    2322  * @global wpdb $wpdb WordPress database abstraction object.
    23232315 * @see wp_delete_attachment()
    23242316 * @see wp_trash_post()
    23252317 *
     
    23292321 * @return array|false|WP_Post False on failure.
    23302322 */
    23312323function wp_delete_post( $postid = 0, $force_delete = false ) {
    2332         global $wpdb;
     2324        $wpdb = WP::get( 'wpdb' );;
    23332325
    23342326        if ( !$post = $wpdb->get_row($wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d", $postid)) )
    23352327                return $post;
     
    25822574 *
    25832575 * @since 2.9.0
    25842576 *
    2585  * @global wpdb $wpdb WordPress database abstraction object.
    2586  *
    25872577 * @param int|WP_Post|null $post Optional. Post ID or post object. Defaults to global $post.
    25882578 * @return mixed|void False on failure.
    25892579 */
    25902580function wp_trash_post_comments( $post = null ) {
    2591         global $wpdb;
    2592 
    25932581        $post = get_post($post);
    25942582        if ( empty($post) )
    25952583                return;
     
    26052593         */
    26062594        do_action( 'trash_post_comments', $post_id );
    26072595
     2596        $wpdb = WP::get( 'wpdb' );
    26082597        $comments = $wpdb->get_results( $wpdb->prepare("SELECT comment_ID, comment_approved FROM $wpdb->comments WHERE comment_post_ID = %d", $post_id) );
    26092598        if ( empty($comments) )
    26102599                return;
     
    26382627 *
    26392628 * @since 2.9.0
    26402629 *
    2641  * @global wpdb $wpdb WordPress database abstraction object.
    2642  *
    26432630 * @param int|WP_Post|null $post Optional. Post ID or post object. Defaults to global $post.
    26442631 * @return true|void
    26452632 */
    26462633function wp_untrash_post_comments( $post = null ) {
    2647         global $wpdb;
    2648 
    26492634        $post = get_post($post);
    26502635        if ( empty($post) )
    26512636                return;
     
    26712656        foreach ( $statuses as $comment_id => $comment_status )
    26722657                $group_by_status[$comment_status][] = $comment_id;
    26732658
     2659        $wpdb = WP::get( 'wpdb' );
    26742660        foreach ( $group_by_status as $status => $comments ) {
    26752661                // Sanity check. This shouldn't happen.
    26762662                if ( 'post-trashed' == $status ) {
     
    28242810 * @since 4.4.0 A 'meta_input' array can now be passed to `$postarr` to add post meta data.
    28252811 *
    28262812 * @see sanitize_post()
    2827  * @global wpdb $wpdb WordPress database abstraction object.
    28282813 *
    28292814 * @param array $postarr {
    28302815 *     An array of elements that make up a post to update or insert.
     
    28702855 * @return int|WP_Error The post ID on success. The value 0 or WP_Error on failure.
    28712856 */
    28722857function wp_insert_post( $postarr, $wp_error = false ) {
    2873         global $wpdb;
    2874 
    28752858        $user_id = get_current_user_id();
    28762859
    28772860        $defaults = array(
     
    31543137
    31553138        $emoji_fields = array( 'post_title', 'post_content', 'post_excerpt' );
    31563139
     3140        $wpdb = WP::get( 'wpdb' );
    31573141        foreach ( $emoji_fields as $emoji_field ) {
    31583142                if ( isset( $data[ $emoji_field ] ) ) {
    31593143                        $charset = $wpdb->get_col_charset( $wpdb->posts, $emoji_field );
     
    34873471 *
    34883472 * @since 2.1.0
    34893473 *
    3490  * @global wpdb $wpdb WordPress database abstraction object.
    3491  *
    34923474 * @param int|WP_Post $post Post ID or post object.
    34933475 */
    34943476function wp_publish_post( $post ) {
    3495         global $wpdb;
    3496 
    34973477        if ( ! $post = get_post( $post ) )
    34983478                return;
    34993479
     
    35003480        if ( 'publish' == $post->post_status )
    35013481                return;
    35023482
     3483        $wpdb = WP::get( 'wpdb' );
    35033484        $wpdb->update( $wpdb->posts, array( 'post_status' => 'publish' ), array( 'ID' => $post->ID ) );
    35043485
    35053486        clean_post_cache( $post->ID );
     
    35583539 *
    35593540 * @since 2.8.0
    35603541 *
    3561  * @global wpdb       $wpdb WordPress database abstraction object.
    35623542 * @global WP_Rewrite $wp_rewrite
    35633543 *
    35643544 * @param string $slug        The desired slug (post_name).
     
    35723552        if ( in_array( $post_status, array( 'draft', 'pending', 'auto-draft' ) ) || ( 'inherit' == $post_status && 'revision' == $post_type ) )
    35733553                return $slug;
    35743554
    3575         global $wpdb, $wp_rewrite;
     3555        global $wp_rewrite;
    35763556
    35773557        $original_slug = $slug;
    35783558
     
    35803560        if ( ! is_array( $feeds ) )
    35813561                $feeds = array();
    35823562
     3563        $wpdb = WP::get( 'wpdb' );
    35833564        if ( 'attachment' == $post_type ) {
    35843565                // Attachment slugs must be unique across all types.
    35853566                $check_sql = "SELECT post_name FROM $wpdb->posts WHERE post_name = %s AND ID != %d LIMIT 1";
     
    39063887 *
    39073888 * @since 1.5.0
    39083889 *
    3909  * @global wpdb $wpdb WordPress database abstraction object.
    3910  *
    39113890 * @param int    $post_id Post ID.
    39123891 * @param string $uri     Ping URI.
    39133892 * @return int|false How many rows were updated.
    39143893 */
    39153894function add_ping( $post_id, $uri ) {
    3916         global $wpdb;
     3895        $wpdb = WP::get( 'wpdb' );
     3896
    39173897        $pung = $wpdb->get_var( $wpdb->prepare( "SELECT pinged FROM $wpdb->posts WHERE ID = %d", $post_id ));
    39183898        $pung = trim($pung);
    39193899        $pung = preg_split('/\s/', $pung);
     
    39733953 *
    39743954 * @since 1.5.0
    39753955 *
    3976  * @global wpdb $wpdb WordPress database abstraction object.
    3977  *
    39783956 * @param int $post_id Post ID.
    39793957 * @return array
    39803958 */
    39813959function get_pung( $post_id ) {
    3982         global $wpdb;
     3960        $wpdb = WP::get( 'wpdb' );
     3961
    39833962        $pung = $wpdb->get_var( $wpdb->prepare( "SELECT pinged FROM $wpdb->posts WHERE ID = %d", $post_id ));
    39843963        $pung = trim($pung);
    39853964        $pung = preg_split('/\s/', $pung);
     
    39993978 *
    40003979 * @since 1.5.0
    40013980 *
    4002  * @global wpdb $wpdb WordPress database abstraction object.
    4003  *
    40043981 * @param int $post_id Post ID
    40053982 * @return array
    40063983 */
    40073984function get_to_ping( $post_id ) {
    4008         global $wpdb;
     3985        $wpdb = WP::get( 'wpdb' );
     3986
    40093987        $to_ping = $wpdb->get_var( $wpdb->prepare( "SELECT to_ping FROM $wpdb->posts WHERE ID = %d", $post_id ));
    40103988        $to_ping = sanitize_trackback_urls( $to_ping );
    40113989        $to_ping = preg_split('/\s/', $to_ping, -1, PREG_SPLIT_NO_EMPTY);
     
    40574035 *
    40584036 * @since 2.0.0
    40594037 *
    4060  * @global wpdb $wpdb WordPress database abstraction object.
    4061  *
    40624038 * @return array List of page IDs.
    40634039 */
    40644040function get_all_page_ids() {
    4065         global $wpdb;
    4066 
    40674041        $page_ids = wp_cache_get('all_page_ids', 'posts');
    40684042        if ( ! is_array( $page_ids ) ) {
     4043                $wpdb = WP::get( 'wpdb' );
    40694044                $page_ids = $wpdb->get_col("SELECT ID FROM $wpdb->posts WHERE post_type = 'page'");
    40704045                wp_cache_add('all_page_ids', $page_ids, 'posts');
    40714046        }
     
    40974072 *
    40984073 * @since 2.1.0
    40994074 *
    4100  * @global wpdb $wpdb WordPress database abstraction object.
    4101  *
    41024075 * @param string       $page_path Page path.
    41034076 * @param string       $output    Optional. Output type. Accepts OBJECT, ARRAY_N, or ARRAY_A.
    41044077 *                                Default OBJECT.
     
    41064079 * @return WP_Post|array|void WP_Post on success.
    41074080 */
    41084081function get_page_by_path( $page_path, $output = OBJECT, $post_type = 'page' ) {
    4109         global $wpdb;
    4110 
    41114082        $last_changed = wp_cache_get( 'last_changed', 'posts' );
    41124083        if ( false === $last_changed ) {
    41134084                $last_changed = microtime();
     
    41434114
    41444115        $post_types = esc_sql( $post_types );
    41454116        $post_type_in_string = "'" . implode( "','", $post_types ) . "'";
     4117
     4118        $wpdb = WP::get( 'wpdb' );
    41464119        $sql = "
    41474120                SELECT ID, post_name, post_parent, post_type
    41484121                FROM $wpdb->posts
     
    41934166 *
    41944167 * @since 2.1.0
    41954168 *
    4196  * @global wpdb $wpdb WordPress database abstraction object.
    4197  *
    41984169 * @param string       $page_title Page title
    41994170 * @param string       $output     Optional. Output type. OBJECT, ARRAY_N, or ARRAY_A.
    42004171 *                                 Default OBJECT.
     
    42024173 * @return WP_Post|array|void WP_Post on success or null on failure
    42034174 */
    42044175function get_page_by_title( $page_title, $output = OBJECT, $post_type = 'page' ) {
    4205         global $wpdb;
    4206 
     4176        $wpdb = WP::get( 'wpdb' );
    42074177        if ( is_array( $post_type ) ) {
    42084178                $post_type = esc_sql( $post_type );
    42094179                $post_type_in_string = "'" . implode( "','", $post_type ) . "'";
     
    43624332/**
    43634333 * Retrieve a list of pages.
    43644334 *
    4365  * @global wpdb $wpdb WordPress database abstraction object.
    4366  *
    43674335 * @since 1.5.0
    43684336 *
    43694337 * @param array|string $args {
     
    44024370 * @return array|false List of pages matching defaults or `$args`.
    44034371 */
    44044372function get_pages( $args = array() ) {
    4405         global $wpdb;
    4406 
    44074373        $defaults = array(
    44084374                'child_of' => 0, 'sort_order' => 'ASC',
    44094375                'sort_column' => 'post_title', 'hierarchical' => 1,
     
    44834449                }
    44844450        }
    44854451
     4452        $wpdb = WP::get( 'wpdb' );
     4453
    44864454        $author_query = '';
    44874455        if ( ! empty( $r['authors'] ) ) {
    44884456                $post_authors = preg_split( '/[\s,]+/', $r['authors'] );
     
    47314699 *
    47324700 * @since 2.0.0
    47334701 *
    4734  * @global wpdb $wpdb WordPress database abstraction object.
    4735  *
    47364702 * @param int  $post_id      Attachment ID.
    47374703 * @param bool $force_delete Optional. Whether to bypass trash and force deletion.
    47384704 *                           Default false.
     
    47394705 * @return mixed False on failure. Post data on success.
    47404706 */
    47414707function wp_delete_attachment( $post_id, $force_delete = false ) {
    4742         global $wpdb;
     4708        $wpdb = WP::get( 'wpdb' );
    47434709
    47444710        if ( !$post = $wpdb->get_row( $wpdb->prepare("SELECT * FROM $wpdb->posts WHERE ID = %d", $post_id) ) )
    47454711                return $post;
     
    53165282 * @since 4.3.0 Introduced the ability to pass an array of post types to `$post_type`.
    53175283 *
    53185284 * @see get_private_posts_cap_sql()
    5319  * @global wpdb $wpdb WordPress database abstraction object.
    53205285 *
    53215286 * @param array|string   $post_type   Single post type or an array of post types.
    53225287 * @param bool           $full        Optional. Returns a full WHERE statement instead of just
     
    53275292 * @return string SQL WHERE code that can be added to a query.
    53285293 */
    53295294function get_posts_by_author_sql( $post_type, $full = true, $post_author = null, $public_only = false ) {
    5330         global $wpdb;
    5331 
    53325295        if ( is_array( $post_type ) ) {
    53335296                $post_types = $post_type;
    53345297        } else {
     
    53825345        $sql = '( '. implode( ' OR ', $post_type_clauses ) . ' )';
    53835346
    53845347        if ( null !== $post_author ) {
     5348                $wpdb = WP::get( 'wpdb' );
    53855349                $sql .= $wpdb->prepare( ' AND post_author = %d', $post_author );
    53865350        }
    53875351
     
    54825446 * @since 4.4.0 The `$post_type` argument was added.
    54835447 * @access private
    54845448 *
    5485  * @global wpdb $wpdb WordPress database abstraction object.
    5486  *
    54875449 * @param string $timezone  The timezone for the timestamp. See get_lastpostdate().
    54885450 *                          for information on accepted values.
    54895451 * @param string $field     Post field to check. Accepts 'date' or 'modified'.
     
    54915453 * @return string|false The timestamp.
    54925454 */
    54935455function _get_last_post_time( $timezone, $field, $post_type = 'any' ) {
    5494         global $wpdb;
    5495 
    54965456        if ( ! in_array( $field, array( 'date', 'modified' ) ) ) {
    54975457                return false;
    54985458        }
     
    55065466
    55075467        $date = wp_cache_get( $key, 'timeinfo' );
    55085468
     5469        $wpdb = WP::get( 'wpdb' );
     5470
    55095471        if ( ! $date ) {
    55105472                if ( 'any' === $post_type ) {
    55115473                        $post_types = get_post_types( array( 'public' => true ) );
     
    57225684 * @access private
    57235685 *
    57245686 * @see wp_clear_scheduled_hook()
    5725  * @global wpdb $wpdb WordPress database abstraction object.
    57265687 *
     5688 *
    57275689 * @param string  $new_status New post status.
    57285690 * @param string  $old_status Previous post status.
    57295691 * @param WP_Post $post       Post object.
    57305692 */
    57315693function _transition_post_status( $new_status, $old_status, $post ) {
    5732         global $wpdb;
    5733 
    57345694        if ( $old_status != 'publish' && $new_status == 'publish' ) {
    57355695                // Reset GUID if transitioning to publish and it is empty.
    5736                 if ( '' == get_the_guid($post->ID) )
     5696                if ( '' == get_the_guid($post->ID) ) {
     5697                        $wpdb = WP::get( 'wpdb' );
    57375698                        $wpdb->update( $wpdb->posts, array( 'guid' => get_permalink( $post->ID ) ), array( 'ID' => $post->ID ) );
    5738 
     5699                }
    57395700                /**
    57405701                 * Fires when a post's status is transitioned from private to published.
    57415702                 *
     
    59135874 * Delete auto-drafts for new posts that are > 7 days old.
    59145875 *
    59155876 * @since 3.4.0
    5916  *
    5917  * @global wpdb $wpdb WordPress database abstraction object.
    59185877 */
    59195878function wp_delete_auto_drafts() {
    5920         global $wpdb;
     5879        $wpdb = WP::get( 'wpdb' );
    59215880
    59225881        // Cleanup old auto-drafts more than 7 days old.
    59235882        $old_posts = $wpdb->get_col( "SELECT ID FROM $wpdb->posts WHERE post_status = 'auto-draft' AND DATE_SUB( NOW(), INTERVAL 7 DAY ) > post_date" );
     
    59935952 *
    59945953 * @see update_post_caches()
    59955954 *
    5996  * @global wpdb $wpdb WordPress database abstraction object.
    5997  *
    59985955 * @param array $ids               ID list.
    59995956 * @param bool  $update_term_cache Optional. Whether to update the term cache. Default true.
    60005957 * @param bool  $update_meta_cache Optional. Whether to update the meta cache. Default true.
    60015958 */
    60025959function _prime_post_caches( $ids, $update_term_cache = true, $update_meta_cache = true ) {
    6003         global $wpdb;
    6004 
    60055960        $non_cached_ids = _get_non_cached_ids( $ids, 'posts' );
    60065961        if ( !empty( $non_cached_ids ) ) {
     5962                $wpdb = WP::get( 'wpdb' );
    60075963                $fresh_posts = $wpdb->get_results( sprintf( "SELECT $wpdb->posts.* FROM $wpdb->posts WHERE ID IN (%s)", join( ",", $non_cached_ids ) ) );
    60085964
    60095965                update_post_caches( $fresh_posts, 'any', $update_term_cache, $update_meta_cache );
     
    60556011 * @return string New slug for the post.
    60566012 */
    60576013function wp_add_trashed_suffix_to_post_name_for_post( $post ) {
    6058         global $wpdb;
    6059 
    60606014        $post = get_post( $post );
    60616015
    60626016        if ( '__trashed' === substr( $post->post_name, -9 ) ) {
     
    60646018        }
    60656019        add_post_meta( $post->ID, '_wp_desired_post_slug', $post->post_name );
    60666020        $post_name = _truncate_post_slug( $post->post_name, 191 ) . '__trashed';
     6021        $wpdb = WP::get( 'wpdb' );
    60676022        $wpdb->update( $wpdb->posts, array( 'post_name' => $post_name ), array( 'ID' => $post->ID ) );
    60686023        clean_post_cache( $post->ID );
    60696024        return $post_name;
  • src/wp-includes/query.php

     
    13201320
    13211321        private $compat_methods = array( 'init_query_flags', 'parse_tax_query' );
    13221322
     1323        protected $dbh;
     1324
    13231325        /**
    13241326         * Resets query flags to false.
    13251327         *
     
    21142116         *
    21152117         * @since 3.7.0
    21162118         *
    2117          * @global wpdb $wpdb WordPress database abstraction object.
    2118          *
    21192119         * @param array $q Query variables.
    21202120         * @return string WHERE clause.
    21212121         */
    21222122        protected function parse_search( &$q ) {
    2123                 global $wpdb;
    2124 
    21252123                $search = '';
    21262124
    21272125                // added slashes screw with quote grouping when done early, so done later
     
    21612159                        }
    21622160
    21632161                        if ( $n && $include ) {
    2164                                 $like = '%' . $wpdb->esc_like( $term ) . '%';
    2165                                 $q['search_orderby_title'][] = $wpdb->prepare( "$wpdb->posts.post_title LIKE %s", $like );
     2162                                $like = '%' . $this->dbh->esc_like( $term ) . '%';
     2163                                $q['search_orderby_title'][] = $this->dbh->prepare( "{$this->dbh->posts}.post_title LIKE %s", $like );
    21662164                        }
    21672165
    2168                         $like = $n . $wpdb->esc_like( $term ) . $n;
    2169                         $search .= $wpdb->prepare( "{$searchand}(($wpdb->posts.post_title $like_op %s) $andor_op ($wpdb->posts.post_excerpt $like_op %s) $andor_op ($wpdb->posts.post_content $like_op %s))", $like, $like, $like );
     2166                        $like = $n . $this->dbh->esc_like( $term ) . $n;
     2167                        $search .= $this->dbh->prepare( "{$searchand}(({$this->dbh->posts}.post_title $like_op %s) $andor_op ({$this->dbh->posts}.post_excerpt $like_op %s) $andor_op ({$this->dbh->posts}.post_content $like_op %s))", $like, $like, $like );
    21702168                        $searchand = ' AND ';
    21712169                }
    21722170
     
    21732171                if ( ! empty( $search ) ) {
    21742172                        $search = " AND ({$search}) ";
    21752173                        if ( ! is_user_logged_in() )
    2176                                 $search .= " AND ($wpdb->posts.post_password = '') ";
     2174                                $search .= " AND ({$this->dbh->posts}.post_password = '') ";
    21772175                }
    21782176
    21792177                return $search;
     
    22562254        /**
    22572255         * Generate SQL for the ORDER BY condition based on passed search terms.
    22582256         *
    2259          * @global wpdb $wpdb WordPress database abstraction object.
    2260          *
    22612257         * @param array $q Query variables.
    22622258         * @return string ORDER BY clause.
    22632259         */
    22642260        protected function parse_search_order( &$q ) {
    2265                 global $wpdb;
    2266 
    22672261                if ( $q['search_terms_count'] > 1 ) {
    22682262                        $num_terms = count( $q['search_orderby_title'] );
    22692263
     
    22702264                        // If the search terms contain negative queries, don't bother ordering by sentence matches.
    22712265                        $like = '';
    22722266                        if ( ! preg_match( '/(?:\s|^)\-/', $q['s'] ) ) {
    2273                                 $like = '%' . $wpdb->esc_like( $q['s'] ) . '%';
     2267                                $like = '%' . $this->dbh->esc_like( $q['s'] ) . '%';
    22742268                        }
    22752269
    22762270                        $search_orderby = '';
     
    22772271
    22782272                        // sentence match in 'post_title'
    22792273                        if ( $like ) {
    2280                                 $search_orderby .= $wpdb->prepare( "WHEN $wpdb->posts.post_title LIKE %s THEN 1 ", $like );
     2274                                $search_orderby .= $this->dbh->prepare( "WHEN {$this->dbh->posts}.post_title LIKE %s THEN 1 ", $like );
    22812275                        }
    22822276
    22832277                        // sanity limit, sort as sentence when more than 6 terms
     
    22922286
    22932287                        // Sentence match in 'post_content' and 'post_excerpt'.
    22942288                        if ( $like ) {
    2295                                 $search_orderby .= $wpdb->prepare( "WHEN $wpdb->posts.post_excerpt LIKE %s THEN 4 ", $like );
    2296                                 $search_orderby .= $wpdb->prepare( "WHEN $wpdb->posts.post_content LIKE %s THEN 5 ", $like );
     2289                                $search_orderby .= $this->dbh->prepare( "WHEN {$this->dbh->posts}.post_excerpt LIKE %s THEN 4 ", $like );
     2290                                $search_orderby .= $this->dbh->prepare( "WHEN {$this->dbh->posts}.post_content LIKE %s THEN 5 ", $like );
    22972291                        }
    22982292
    22992293                        if ( $search_orderby ) {
     
    23142308