PHP 7.0.6 Released

    The mysqli_result class

    (PHP 5, PHP 7)

    Introduction

    Represents the result set obtained from a query against the database.

    Changelog

    Changelog
    Version Description
    5.4.0 Iterator support was added, as mysqli_result now implements Traversable.

    Class synopsis

    mysqli_result implements Traversable {
    /* Properties */
    int $current_field ;
    int $field_count;
    array $lengths;
    int $num_rows;
    /* Methods */
    bool data_seek ( int $offset )
    mixed fetch_all ([ int $resulttype = MYSQLI_NUM ] )
    mixed fetch_array ([ int $resulttype = MYSQLI_BOTH ] )
    array fetch_assoc ( void )
    object fetch_field_direct ( int $fieldnr )
    object fetch_field ( void )
    array fetch_fields ( void )
    object fetch_object ([ string $class_name = "stdClass" [, array $params ]] )
    mixed fetch_row ( void )
    bool field_seek ( int $fieldnr )
    void free ( void )
    }

    Table of Contents

    User Contributed Notes

    tuxedobob
    3 years ago
    Converting an old project from using the mysql extension to the mysqli extension, I found the most annoying change to be the lack of a corresponding mysql_result function in mysqli. While mysql_result is a generally terrible function, it was useful for fetching a single result field *value* from a result set (for example, if looking up a user's ID).

    The behavior of mysql_result is approximated here, though you may want to name it something other than mysqli_result so as to avoid thinking it's an actual, built-in function.

    <?php
    function mysqli_result($res, $row, $field=0) {
            $res->data_seek($row);
            $datarow = $res->fetch_array();
        return     $datarow[$field];
    }
    ?>

    Implementing it via the OO interface is left as an exercise to the reader.
    Anonymous
    6 years ago
    Generally, it appears Mysqli OO vs Procedural style has no significant difference in speed, at least with the more generally used functions and methods (connect, close, query, free, etc).

    With the fetch_* family of functions and methods dealing with result rows, however, Procedural wins out.  Averaging over a hundred or so tests with a result set of 180,000 records, and using mysqli_fetch_*() functions vs. their mysqli_result::fetch_*() counterpart object methods to read and iterate over all records, all of the mysqli_fetch_*() functions win by ~0.1 seconds less.

    This is interesting considering we're dealing with the same result object in both styles.

    This was using Vistax64, PHP5.3.2, Mysql 5.1.45, using a bit of this code:

    <?php

    // procedural - takes 0.1 seconds less than OO here
    $stopwatch = microtime(true);
    while(    $row = mysqli_fetch_assoc($result)){
        ++    $z;
        }
    echo     microtime(true) - $stopwatch;

    // OO
    $stopwatch = microtime(true);
    while(    $row = $result->fetch_assoc()){
        ++    $z;
        }
    echo     microtime(true) - $stopwatch;

    ?>
    blar at blar dot de
    7 years ago
    Extending the MySQLi_Result

    <?php

    class Database_MySQLi extends MySQLi
    {
        public function     query($query)
        {
                $this->real_query($query);
            return new     Database_MySQLi_Result($this);
        }
    }

    class     Database_MySQLi_Result extends MySQLi_Result
    {
        public function     fetch()
        {
            return     $this->fetch_assoc();
        }

        public function     fetchAll()
        {
                $rows = array();
            while(    $row = $this->fetch())
            {
                    $rows[] = $row;
            }
            return     $rows;
        }
    }

    ?>
    Marc17
    2 years ago
    An "mysqli_result" function where $field can be like table_name.field_name with alias or not.
    <?php
    function mysqli_result($result,$row,$field=0) {
        if (    $result===false) return false;
        if (    $row>=mysqli_num_rows($result)) return false;
        if (    is_string($field) && !(strpos($field,".")===false)) {
                $t_field=explode(".",$field);
                $field=-1;
                $t_fields=mysqli_fetch_fields($result);
            for (    $id=0;$id<mysqli_num_fields($result);$id++) {
                if (    $t_fields[$id]->table==$t_field[0] && $t_fields[$id]->name==$t_field[1]) {
                        $field=$id;
                    break;
                }
            }
            if (    $field==-1) return false;
        }
            mysqli_data_seek($result,$row);
            $line=mysqli_fetch_array($result);
        return isset(    $line[$field])?$line[$field]:false;
    }
    ?>
    marcus at synchromedia dot co dot uk
    8 months ago
    If you're using the iterator interface on a result instance ($r), like this:

        foreach ($r as $d) {

    the iterated value ($d) is an associative-only array, i.e. it's the same as doing this:

        while ($d = $r->fetch_assoc()) {

    and NOT like this:

        while ($d = $r->fetch_row()) {

    so you can't access row elements by numeric index ($d[0] etc) if you use the foreach syntax.
    sinisaculic at gmail dot com
    5 years ago
    storing this object in ANY kind will result in storing an empty object... if you try to serialize it dump it or do anything with it you will end up with a empty object.

    you have to pull all data out f the object and then store the data... no other way.
    To Top