PHP is developed and maintained by a global community of contributors.
The PHP Foundation helps fund this work. If PHP is part of your business or projects, consider sponsoring the Foundation.
(PHP 5 >= 5.1.0, PHP 7, PHP 8, PECL pdo >= 0.1.0)
PDOStatement::fetch — Fetches the next row from a result set
$mode = PDO::FETCH_DEFAULT, int $cursorOrientation = PDO::FETCH_ORI_NEXT, int $cursorOffset = 0): mixed
Fetches a row from a result set associated with a
PDOStatement instance.
The mode parameter determines how PDO returns the row.
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.
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.
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.
Emits an error with level E_WARNING if the attribute PDO::ATTR_ERRMODE is set
to PDO::ERRMODE_WARNING.
Throws a PDOException if the attribute PDO::ATTR_ERRMODE
is set to PDO::ERRMODE_EXCEPTION.
Example #1 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"
}
Example #2 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
Example #3 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.
