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_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.
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.
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);
?>
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() - Prepares a statement for execution and returns a statement object
PDOStatement::execute
PDOStatement