PDOStatement::fetch

Description

Fetches a row from a result set associated with a PDOStatement instance. The mode parameter determines how PDO returns the row.

Parameters

mode

Controls how the next row will be returned to the caller. This value must be one of the PDO::FETCH_* constants, defaulting to value of PDO::ATTR_DEFAULT_FETCH_MODE (which defaults to PDO::FETCH_BOTH).

• PDO::FETCH_ASSOC: returns an array indexed by column name as returned in the result set.
• PDO::FETCH_NAMED: returns an array with the same form as PDO::FETCH_ASSOC, except that if there are multiple columns with the same name, the value referred to by that key will be an array of all the values in the row that had that column name.
• PDO::FETCH_NUM: returns an array indexed by column number as returned in the result set, starting at column 0.
• PDO::FETCH_BOTH: returns an array indexed by both column name and 0-indexed column number as returned in the result set. This is effectively a combination of PDO::FETCH_NUM and PDO::FETCH_ASSOC.
• PDO::FETCH_BOUND: returns true and assigns the values of the columns in the result set to the PHP variables to which they were bound with the PDOStatement::bindColumn method.
• PDO::FETCH_OBJ: returns an instance of stdClass with property names that correspond to the column names returned in the result set.

• PDO::FETCH_CLASS: returns a new instance of the requested class. Unless the class was set with PDOStatement::setFetchMode, this mode must be combined with PDO::FETCH_CLASSTYPE, in which case the class to instantiate is determined by the value of the first column.

  By default, the object is initialized by mapping the columns of the result set to properties in the class. This occurs prior to calling the constructor, allowing properties to be populated regardless of their visibility or whether they are marked as readonly, as long as the constructor does not initialize them itself. If a property does not exist in the class, the magic __set() method will be invoked if it exists; otherwise, a dynamic public property will be created.

  It is possible to change this behaviour by using the PDO::FETCH_PROPS_LATE flag to call the constructor before the properties are populated.

  Caution

  The column values are not passed as arguments to the constructor, regardless of whether PDO::FETCH_PROPS_LATE is used. Only arguments given to PDOStatement::setFetchMode are passed.

• PDO::FETCH_INTO: updates an existing instance of the requested class, mapping the columns of the result set to named properties in the class.
• PDO::FETCH_LAZY: combines PDO::FETCH_BOTH and PDO::FETCH_OBJ, and returns a PDORow object which creates the object property names as they are accessed.

cursorOrientation

For a PDOStatement object representing a scrollable cursor, this value determines which row will be returned to the caller. This value must be one of the PDO::FETCH_ORI_* constants, defaulting to PDO::FETCH_ORI_NEXT. To request a scrollable cursor for the PDOStatement object, the PDO::ATTR_CURSOR attribute must be set to PDO::CURSOR_SCROLL when the SQL statement is prepared with PDO::prepare.

cursorOffset

If the value of the cursorOrientation parameter is PDO::FETCH_ORI_ABS, this value specifies the absolute number of the row in the result set that shall be fetched.

If the value of the cursorOrientation parameter is PDO::FETCH_ORI_REL, this value specifies the row to fetch relative to the cursor position before PDOStatement::fetch was called.

Return Values

The return value of this function on success depends on the fetch type. In all cases, false is returned on failure or if there are no more rows.

Errors/Exceptions Errors

Examples

Fetching rows using different fetch styles

<?php
$db = new PDO('sqlite::memory:');
$db->exec("CREATE TABLE fruit (name VARCHAR(100), colour VARCHAR(100))");
$db->exec("INSERT INTO fruit (name, colour) VALUES
                             ('apple', 'red'),
                             ('banana', 'yellow'),
                             ('orange', 'orange'),
                             ('kiwi', 'green')");
$sth = $db->prepare("SELECT name, colour FROM fruit");
$sth->execute();

/* Exercise PDOStatement::fetch styles */
echo "PDO::FETCH_ASSOC: ";
echo "Return next row as an array indexed by column name\n";
$result = $sth->fetch(PDO::FETCH_ASSOC);
var_dump($result);
echo "\n";

echo "PDO::FETCH_BOTH: ";
echo "Return next row as an array indexed by both column name and number\n";
$result = $sth->fetch(PDO::FETCH_BOTH);
var_dump($result);
echo "\n";

echo "PDO::FETCH_LAZY: ";
echo "Return next row as a PDORow object with column names as properties\n";
$result = $sth->fetch(PDO::FETCH_LAZY);
var_dump($result);
echo "\n";

echo "PDO::FETCH_OBJ: ";
echo "Return next row as an stdClass object with column names as properties\n";
$result = $sth->fetch(PDO::FETCH_OBJ);
var_dump($result);
echo "\n";
?>

The above example will output:

PDO::FETCH_ASSOC: Return next row as an array indexed by column name
array(2) {
  ["name"]=>
  string(5) "apple"
  ["colour"]=>
  string(3) "red"
}

PDO::FETCH_BOTH: Return next row as an array indexed by both column name and number
array(4) {
  ["name"]=>
  string(6) "banana"
  [0]=>
  string(6) "banana"
  ["colour"]=>
  string(6) "yellow"
  [1]=>
  string(6) "yellow"
}

PDO::FETCH_LAZY: Return next row as a PDORow object with column names as properties
object(PDORow)#3 (3) {
  ["queryString"]=>
  string(30) "SELECT name, colour FROM fruit"
  ["name"]=>
  string(6) "orange"
  ["colour"]=>
  string(6) "orange"
}

PDO::FETCH_OBJ: Return next row as an stdClass object with column names as properties
object(stdClass)#4 (2) {
  ["name"]=>
  string(4) "kiwi"
  ["colour"]=>
  string(5) "green"
}

Fetching rows with a scrollable cursor

<?php
function readDataForwards($dbh) {
    $sql = 'SELECT hand, won, bet FROM mynumbers ORDER BY BET';
    $stmt = $dbh->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL));
    $stmt->execute();
    while ($row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_NEXT)) {
        $data = $row[0] . "\t" . $row[1] . "\t" . $row[2] . "\n";
        print $data;
    }
}
function readDataBackwards($dbh) {
    $sql = 'SELECT hand, won, bet FROM mynumbers ORDER BY bet';
    $stmt = $dbh->prepare($sql, array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL));
    $stmt->execute();
    $row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_LAST);
    do {
        $data = $row[0] . "\t" . $row[1] . "\t" . $row[2] . "\n";
        print $data;
    } while ($row = $stmt->fetch(PDO::FETCH_NUM, PDO::FETCH_ORI_PRIOR));
}

print "Reading forwards:\n";
readDataForwards($conn);

print "Reading backwards:\n";
readDataBackwards($conn);
?>

The above example will output:

Reading forwards:
21    10    5
16    0     5
19    20    10

Reading backwards:
19    20    10
16    0     5
21    10    5

Construction order

When objects are fetched via PDO::FETCH_CLASS, the object properties are assigned first, and then the constructor of the class is invoked. However, when PDO::FETCH_PROPS_LATE is also given, this order is reversed, i.e. first the constructor is called, and afterwards the properties are assigned.

<?php
class Person
{
    private $name;

    public function __construct()
    {
        $this->tell();
    }

    public function tell()
    {
        if (isset($this->name)) {
            echo "I am {$this->name}.\n";
        } else {
            echo "I don't have a name yet.\n";
        }
    }
}

$sth = $dbh->query("SELECT * FROM people");
$sth->setFetchMode(PDO::FETCH_CLASS, 'Person');
$person = $sth->fetch();
$person->tell();
$sth->setFetchMode(PDO::FETCH_CLASS|PDO::FETCH_PROPS_LATE, 'Person');
$person = $sth->fetch();
$person->tell();
?>

The above example will output something similar to:

I am Alice.
I am Alice.
I don't have a name yet.
I am Bob.

See Also

• PDO::prepare
• PDOStatement::execute
• PDOStatement::fetchAll
• PDOStatement::fetchColumn
• PDOStatement::fetchObject
• PDOStatement::setFetchMode