(PHP 5 >= 5.1.0, PHP 7, PHP 8, PECL pdo >= 0.1.0)
PDOStatement::fetchAll — 获取结果集中剩余的行
mode控制返回数组的内容，如 PDOStatement::fetch() 中所述。默认值为 PDO::ATTR_DEFAULT_FETCH_MODE（默认为 PDO::FETCH_BOTH）
要返回一个包含结果集中单个列的所有值的数组，请指定 PDO::FETCH_COLUMN。您可以使用 column 参数指定要获取的列。
要从结果集中获取单个列的唯一值，请将 PDO::FETCH_COLUMN 与 PDO::FETCH_UNIQUE 按位或运算。
要返回一个按指定列的值分组的关联数组，请将 PDO::FETCH_COLUMN 与 PDO::FETCH_GROUP 按位或运算。
column与 PDO::FETCH_COLUMN 一起使用。返回指示的 0 索引列。
class与 PDO::FETCH_CLASS 一起使用。返回指定类的实例，将每行中的列映射到类中的命名属性。
constructorArgs当 mode 参数为 PDO::FETCH_CLASS 时，自定义类构造函数的参数。
callback与 PDO::FETCH_FUNC 一起使用。返回调用指定函数的结果，使用每行中的列作为调用中的参数。
PDOStatement::fetchAll() 返回一个数组，包含结果集中所有剩余的行。该数组将每行表示为列值的数组或具有与每个列名称相对应的属性的对象。如果要获取的结果为零，则返回一个空数组。
使用此方法来获取大型结果集将导致系统和网络资源的巨大需求。与其检索所有数据并在 PHP 中对其进行操作，不如考虑使用数据库服务器来操作结果集。例如，在 SQL 中使用 WHERE 和 ORDER BY 子句来限制结果，然后再使用 PHP 获取和处理它们。
如果属性 PDO::ATTR_ERRMODE 设置为 PDO::ERRMODE_WARNING，则发出级别为 E_WARNING 的错误。
如果属性 PDO::ATTR_ERRMODE 设置为 PDO::ERRMODE_EXCEPTION，则抛出 PDOException。
示例 #1 获取结果集中所有剩余的行
<?php
$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();
/* 获取结果集中所有剩余的行 */
print "获取结果集中所有剩余的行:\n";
$result = $sth->fetchAll();
print_r($result);
?>上面的示例将输出类似于以下内容
Fetch all of the remaining rows in the result set:
Array
(
[0] => Array
(
[name] => apple
[0] => apple
[colour] => red
[1] => red
)
[1] => Array
(
[name] => pear
[0] => pear
[colour] => green
[1] => green
)
[2] => Array
(
[name] => watermelon
[0] => watermelon
[colour] => pink
[1] => pink
)
)
示例 #2 获取结果集中单个列的所有值
以下示例演示如何从结果集中返回单个列的所有值，即使 SQL 语句本身可能每行返回多个列。
<?php
$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();
/* 获取第一列的所有值 */
print "获取第一列的所有值:\n";
$result = $sth->fetchAll(PDO::FETCH_COLUMN, 0);
var_dump($result);
?>上面的示例将输出类似于以下内容
Array(3)
(
[0] =>
string(5) => apple
[1] =>
string(4) => pear
[2] =>
string(10) => watermelon
)
示例 #3 按单个列对所有值进行分组
以下示例演示如何返回一个按结果集中指定列的值分组的关联数组。该数组包含三个键：值 apple 和 pear 作为包含两种不同颜色的数组返回，而 watermelon 作为包含只有一种颜色的数组返回。
<?php
$insert = $dbh->prepare("INSERT INTO fruit(name, colour) VALUES (?, ?)");
$insert->execute(array('apple', 'green'));
$insert->execute(array('pear', 'yellow'));
$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();
/* 按第一列对值进行分组 */
print "按第一列对值进行分组:\n";
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
?>上面的示例将输出类似于以下内容
array(3) {
["apple"]=>
array(2) {
[0]=>
string(5) "green"
[1]=>
string(3) "red"
}
["pear"]=>
array(2) {
[0]=>
string(5) "green"
[1]=>
string(6) "yellow"
}
["watermelon"]=>
array(1) {
[0]=>
string(5) "pink"
}
}
示例 #4 为每个结果实例化一个类
以下示例演示了**PDO::FETCH_CLASS** 获取样式的行为。
<?php
class fruit {
public $name;
public $colour;
}
$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();
$result = $sth->fetchAll(PDO::FETCH_CLASS, "fruit");
var_dump($result);
?>上面的示例将输出类似于以下内容
array(3) {
[0]=>
object(fruit)#1 (2) {
["name"]=>
string(5) "apple"
["colour"]=>
string(5) "green"
}
[1]=>
object(fruit)#2 (2) {
["name"]=>
string(4) "pear"
["colour"]=>
string(6) "yellow"
}
[2]=>
object(fruit)#3 (2) {
["name"]=>
string(10) "watermelon"
["colour"]=>
string(4) "pink"
}
[3]=>
object(fruit)#4 (2) {
["name"]=>
string(5) "apple"
["colour"]=>
string(3) "red"
}
[4]=>
object(fruit)#5 (2) {
["name"]=>
string(4) "pear"
["colour"]=>
string(5) "green"
}
}
示例 #5 为每个结果调用函数
以下示例演示了**PDO::FETCH_FUNC** 获取样式的行为。
<?php
function fruit($name, $colour) {
return "{$name}: {$colour}";
}
$sth = $dbh->prepare("SELECT name, colour FROM fruit");
$sth->execute();
$result = $sth->fetchAll(PDO::FETCH_FUNC, "fruit");
var_dump($result);
?>上面的示例将输出类似于以下内容
array(3) {
[0]=>
string(12) "apple: green"
[1]=>
string(12) "pear: yellow"
[2]=>
string(16) "watermelon: pink"
[3]=>
string(10) "apple: red"
[4]=>
string(11) "pear: green"
}
我仍然不明白为什么 FETCH_KEY_PAIR 在这里没有记录 (https://php.net/manual/fr/pdo.constants.php)，因为它非常有用！
<?php
var_dump($pdo->query('select id, name from table')->fetchAll(PDO::FETCH_KEY_PAIR));
?>
这将显示
array(2) {
[2]=>
string(10) "name2"
[5]=>
string(10) "name5"
}让 foreach 与来自 PDO FetchAll() 的某些数据完美配合
我不理解如何在 foreach 中正确使用 $value 部分，希望这能帮助其他人。
示例
<?php
$stmt = $this->db->prepare('SELECT title, FMarticle_id FROM articles WHERE domain_name =:domain_name');
$stmt->bindValue(':domain_name', $domain);
$stmt->execute();
$article_list = $stmt->fetchAll(PDO::FETCH_ASSOC);
?>
这将给出
array (size=2)
0 =>
array (size=2)
'title' => string '关于猫的超长文章标题' (length=44)
'FMarticle_id' => string '7CAEBB15-6784-3A41-909A-1B6D12667499' (length=36)
1 =>
array (size=2)
'title' => string '另一个猫的故事' (length=17)
'FMarticle_id' => string '0BB86A06-2A79-3145-8A02-ECF6EA5C405C' (length=36)
然后使用
<?php
foreach ($article_list as $row => $link) {
echo '<a href="'. $link['FMarticle_id'].'">' . $link['title']. '</a></br>';
}
?>有趣的是，当您使用 fetchAll 时，对象的构造函数是在分配属性之后调用的。例如
<?php
class person {
public $name;
function __construct() {
$this->name = $this->name . " is my name.";
}
}
# 在这里设置 PDO 从数据库中选择
$obj = $STH->fetchALL(PDO::FETCH_CLASS, 'person');
?>
将导致 ' is my name' 被追加到所有 name 列。但是，如果您以稍微不同的方式调用它
<?php
$obj = $obj = $STH->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, 'person');
?>
那么构造函数将在分配属性之前被调用。我在任何地方都找不到对此的记录，所以我想在这里添加一个说明会很好。请注意：如果您执行外部左联接并将 PDO FetchALL 设置为 PDO::FETCH_ASSOC，那么在联接中没有返回任何记录时，您在外部左联接中使用的任何主键都将被设置为空白。
例如
<?php
// 查询 product 表并联接到 image 表，并返回每个产品的任何图像（如果有）
$sql = "SELECT * FROM product, image
LEFT OUTER JOIN image ON (product.product_id = image.product_id)";
$array = $stmt->fetchAll(PDO::FETCH_ASSOC);
print_r($array);
?>
结果数组将类似于以下内容
Array
(
[0] => Array
(
[product_id] =>
[notes] => "this product..."
[brand] => "Best Yet"
...
解决方法是简单地指定 SELECT 子句中的字段名称，而不是使用 * 作为通配符，或者，您也可以除了 * 之外还指定字段。以下示例将正确返回 product_id 字段
<?php
$sql = "SELECT *, product.product_id FROM product, image
LEFT OUTER JOIN image ON (product.product_id = image.product_id)";
$array = $stmt->fetchAll(PDO::FETCH_ASSOC);
print_r($array);
?>
结果数组将类似于以下内容
Array
(
[0] => Array
(
[product_id] => 3
[notes] => "this product..."
[brand] => "Best Yet"
...请注意，fetchAll() 对于大型数据集来说可能极其低效。我的内存限制设置为 160 MB，这是我尝试时发生的事情
<?php
$arr = $stmt->fetchAll();
// 致命错误：已用尽 16777216 字节的允许内存大小
?>
如果您要遍历 fetchAll() 的输出数组，请改用 fetch() 来最小化内存使用，如下所示
<?php
while ($arr = $stmt->fetch()) {
echo round(memory_get_usage() / (1024*1024),3) .' MB<br />';
// do_other_stuff();
}
// 相同查询的最后一行仅显示 28.973 MB 的使用量
?>如果您想使用 PDO::FETCH_CLASS 但不喜欢所有值都是字符串类型，您始终可以使用指定类的 __construct 函数将它们转换为不同的类型。
另一种方法是使用 mysqlnd，但我似乎不得不为此重新编译 PHP。
<?php
class Cdr {
public $a; // int
public $b; // float
public $c; // string
public function __construct() {
$this->a = intval($this->a);
$this->b = floatval($this->b);
}
}
// ...
$arrCdrs = $objSqlStatement->fetchAll(PDO::FETCH_CLASS, 'Cdr');
?>文档中缺少一些内容。
例如，如果您尝试使用 fetchAll(PDO::CLASS, "Class")，它有时会返回一个包含 NULL 值的对象数组，但获取的对象数量与表行数一致。
这种方式可以正常工作
fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "Class");
例如
$stm = $pdo->prepare("SELECT * FROM Fruit");
$stm->execute();
$stm->fetchAll(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, "Fruit");使用 PDO::FETCH_COLUMN 和 PDO::FETCH_GROUP 时要小心。默认情况下，结果按第一列（索引 0）分组，并返回第二列（索引 1）。但是，如果您提供获取参数，它不会影响返回的列，而是影响分组列。如果显式设置分组列，则返回第一列而不是第二列。
<?php
$insert = $dbh->prepare("INSERT INTO people(id, gender) VALUES (?, ?)");
$insert->execute(array('2', 'female'));
$insert->execute(array('3', 'female'));
$insert->execute(array('4', 'female'));
$insert->execute(array('5', 'male'));
$insert->execute(array('6', 'male'));
$sth = $dbh->prepare("SELECT gender, id FROM people");
$sth->execute();
/* 按第一列分组 */
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP));
?>
返回
<?php
array (size=2)
'female' =>
array (size=3)
0 => string '2' (length=1)
1 => string '3' (length=1)
2 => string '4' (length=1)
'male' =>
array (size=2)
0 => string '5' (length=1)
1 => string '6' (length=1)
?>
但是，
<?php
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP, 0));
?>
返回
<?php
array (size=2)
'female' =>
array (size=3)
0 => string 'female' (length=1)
1 => string 'female' (length=1)
2 => string 'female' (length=1)
'male' =>
array (size=2)
0 => string 'male' (length=1)
1 => string 'male' (length=1)
?>
<?php
var_dump($sth->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP, 1));
?>
返回
<?php
array (size=5)
2 =>
array (size=1)
0 => string 'female' (length=1)
3 =>
array (size=1)
0 => string 'female' (length=1)
4 =>
array (size=1)
0 => string 'female' (length=1)
5 =>
array (size=1)
0 => string 'male' (length=1)
6 =>
array (size=1)
0 => string 'male' (length=1)
?>
返回第一列，并按提供的列索引进行分组。使用返回对象的方法 (PHP 7.2)
class MySql {
public function __construct()
{
parent::__construct();
try{
$options = array
(
PDO::MYSQL_ATTR_INIT_COMMAND => "SET NAMES UTF8"
);
$this->pdo = new PDO('mysql:host=127.0.0.1;dbname=testuser','dbtest', 'xxxxxxx',$options);
$this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}catch(PDOException $e) {
print "Error!: " . $e->getMessage() . "<br/>";
die();
}
}
public function selectAll(string $sql)
{
$conn = $this->pdo->query($sql);
return $conn->fetchAll(PDO::FETCH_OBJ);
}
}如果您使用 PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE 标志将列映射到对象属性，则 fetchAll() 将在执行映射时使用您的对象具有的任何 __set() 方法。请注意，您只能在选择两列时使用 PDO::FETCH_COLUMN|PDO::FETCH_GROUP 对，而不像 DB_common::getAssoc()，在其中分组设置为 true。Oracle 和 MSSQL 还支持另一种获取模式
PDO::FETCH_ASSOC
> 只获取列名，并省略数字索引。
如果您想从 SQL 语句中返回所有列，并将列键作为表头，只需执行以下操作即可
<?php
$dbh = new PDO("DS", "USERNAME", "PASSWORD");
$stmt = $dbh->prepare("SELECT * FROM tablename");
$stmt->execute();
$arrValues = $stmt->fetchAll(PDO::FETCH_ASSOC);
// 打开表格
print "<table wdith=\"100%\">\n";
print "<tr>\n";
// 添加表头
foreach ($arrValues[0] as $key => $useless){
print "<th>$key</th>";
}
print "</tr>";
// 显示数据
foreach ($arrValues as $row){
print "<tr>";
foreach ($row as $key => $val){
print "<td>$val</td>";
}
print "</tr>\n";
}
// 关闭表格
print "</table>\n";
?>可能有些用户需要将他们的 MySQL 类升级到 PDO 类。获取结果的方式已从 while 循环更改为 foreach 循环。对于希望在 while 循环中获取结果的人，这里有一个简单的技巧。
<?php
$db = new DB();
$query = $db->prepare("SELECT * FROM CPUCategory");
$query = $db->execute();
$result = $db->fetchAll();
var_dump($result);
?>
输出将是
array(2) {
[0]=> array(2) {
["ccatid"]=> int(1)
["ccatname"]=> string(5) "Intel"
}
[1]=> array(2) {
["ccatid"]=> int(2)
["ccatname"]=> string(3) "AMD"
}
}
看起来不像旧函数的输出。
[原始风格] mysql_fetch_array($query)
[ MYSQL 类] $db->fetch_array($query)
你可能会放弃。
但有一个简单的方法可以使用 while 循环来获取结果。
<?php
$db = new DB();
$query = $db->prepare("SELECT * FROM CPUCategory");
$query = $db->execute();
$result = $db->fetchAll();
$row = array_shift($result);
// 如果你现在需要获取它们，就把它放在下面的 while 循环中：
// while($row = array_shift($result)) { ... }
var_dump($row);
?>
输出将在一个包含 while 循环返回值 TRUE 的单个数组中。
array(2) {
["ccatid"]=> int(1)
["ccatname"]=> string(5) "Intel"
}
因此，在获取了这一行之后，while 循环会再次运行并获取下一行，直到所有行都被获取，然后 while 循环将返回 false。（就像旧函数所做的那样）
当你需要升级到 PDO 类时，不需要修改太多代码，记住。错误
SQLSTATE[HY000]: General error: 2014 Cannot execute queries while other unbuffered queries are active. Consider using PDOStatement::fetchAll(). Alternatively, if your code is only ever going to run against mysql, you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute.
如果你使用的是类似于
while ($row = $query->fetchObject()) {
[...]
}
尝试使用以下代码代替
$rows = $query->fetchAll(PDO::FETCH_CLASS, 'ArrayObject');
foreach ($rows as $row) {
[...]
}PHP 从 SQL Server 2005 获取所有数据
如果字段的数据类型是 varchar(nvarchar)，则只获取 255 个字符。但“text”数据类型是可以的。
因此，请注意！将“varchar”或“nvarchar”（长度 > 255）更改为“text”数据类型。
希望对您有所帮助。
<?php
$user = 'sa';
$pass = 'pass';
$conn = new PDO('mssql:host=127.0.0.1; dbname=tempdb;', $user, $pass);
$mainSQL = "SELECT field_varchar, field_text FROM table1";
$sth = $conn->prepare($mainSQL);
$sth->setFetchMode(PDO::FETCH_ASSOC);
$sth->execute();
$retRows = $sth->fetchAll();
// field_varchar 字段仅获取 255 个字符（最大）
// field_text 是可以的。
var_dump($retRows);
unset($sth); unset($conn);
?>我在这里添加这个，因为我似乎找不到任何清晰易懂的 PDO::FETCH_GROUP 示例和解释以及它的工作原理。
我认为这是 fetchAll() 中最实用的模式之一，当你需要处理任何形式的分组时。
本质上，PDO 可以根据选定的第一个字段将结果分组到嵌套数组中。
示例
<?php
$data = $pdo->query('SELECT sex, name, car FROM users')->fetchAll(PDO::FETCH_GROUP);
/* array (
'male' => array ( 0 =>
array (
'name' => 'John',
'car' => 'Toyota',
),
1 => array (
'name' => 'Mike',
'car' => 'Ford',
),
),
'female' => array (
0 => array (
'name' => 'Mary',
'car' => 'Mazda',
),
1 => array (
'name' => 'Kathy',
'car' => 'Mazda',
),
),
) */
?>
提示：如果你需要按除第一个字段以外的其他字段对数据进行分组，也可以这样做
<?php
SELECT sex, users.* FROM users
?>我注意到一个非常奇怪（至少对我来说）的行为。也许这可以帮助那些也在为此而挣扎的人。
<?php
$stmt = new PDOStatement();
$foo = $stmt->fetchAll();
var_dump($foo);
$stmt = $pdo->prepare('SELECT VERSION()');
$foo = $stmt->fetchAll();
var_dump($foo);
$stmt = $pdo->prepare("INSERT INTO `tblnm` (date) VALUES (NOW())");
$stmt->execute();
$foo = $stmt->fetchAll();
var_dump($foo);
$stmt = $pdo->query("INSERT INTO `tblnm` (date) VALUES (NOW())");
$foo = $stmt->fetchAll();
var_dump($foo);
?>
第一个只是一个空对象，所以 $foo === bool(false)
第二个没有执行，所以 $foo === array(0) {}
第三个和第四个在 fetchAll() 时抛出异常
"General error: 2014 Cannot execute queries while other unbuffered queries are active. Consider using PDOStatement::fetchAll(). Alternatively, [...] you may enable query buffering by setting the PDO::MYSQL_ATTR_USE_BUFFERED_QUERY attribute."
fetchAll() 已经被使用，并且在 true 和 false 之间更改上面的属性没有任何改变。
这可能是由于 INSERT 没有返回值造成的。我们可以在 sql 中使用 RETURNING，但它相当新，因此可能还没有在所有地方都得到支持。
最终对我起作用的是 $pdo->exec() 和 lastInsertId()，因为无论如何我只需要 ID。
<?php
$count = $pdo->exec('INSERT INTO `tblnm` (date) VALUES (NOW())');
$foo = $pdo->lastInsertId();
var_dump($foo);
?>
然后例如 $foo === string(2) "93"从 PHP<7.4 升级到 PHP 8.0 会导致重大变更。如果您的类扩展了 PDOStatement，则 PHP 8.0 的类型原型不兼容
- PHP 7.4 = public PDOStatement::fetchAll ([ int $fetch_style [, mixed $fetch_argument [, array $ctor_args = array() ]]] ) : array
- PHP 8.0 = public PDOStatement::fetchAll ([ int $mode = PDO::FETCH_BOTH[, mixed ...$args] ]) : array
虽然对人来说是兼容的，但 PHP 不喜欢它
- PHP 7.4 = PHP Warning: Declaration of (您的类原型) 应该与 (PDOStatement 的原型) 兼容
- PHP 8.0 = [PhpCompileError] Declaration of (您的类原型) 必须与 (PDOStatement 的原型) 兼容
由于第一个是警告，它不是致命的，您可能很乐意使用 PHP 8.0 的原型。我个人的解决方案是停止扩展 PDOStatement，因此重写相关的类型声明和条件。我被震惊了，您实际上可以组合 PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE | PDO::FETCH_UNIQUE，因为 PDO::FETCH_CLASSTYPE 和 PDO::FETCH_UNIQUE 都说它们将使用第一列，但事实证明 PDO::FETCH_CLASSTYPE 优先，然后 PDO::FETCH_UNIQUE 将使用下一列。这样，您可以创建一个对象的关联数组，其中表列之一作为键。例如，类似这样的查询
'SELECT Class, Id, t.* FROM subscriptions_tbl t'
可能会给你这个结果
Array
(
[20481086] => WConsumerSubscription Object
(
[Variant] => 2
[_Expiration:WSubscriptionModel:private] => DateTime Object
(
[date] => 2018-08-08 00:00:00.000000
[timezone_type] => 3
[timezone] => UTC
)
[Notes] =>
[Id] => 20481086
[_Deleted:protected] => 0
[_VersionNo:protected] => 2
[ContactId] =>
[ConsumerId] => 2
)
[21878324] => WAdminSubscription Object
(
[Variant] =>
[_Expiration:WSubscriptionModel:private] =>
[Notes] =>
[Id] => 21878324
[_Deleted:protected] => 0
[_VersionNo:protected] => 1
[ContactId] =>
)
)将参数直接注入 `fetchAll` 而不是使用 `bindValue`
$query = "
SELECT
a.total_paid_tax_incl AS prize,
a.date_add AS date_add
FROM orders a
WHERE a.order_id = :seventeen
AND a.name = :name";
// 连接 (在 Symfony 中，您在命名空间 Doctrine\DBAL\Connection 中使用类 Connection)
$this->connection->fetchAll($query, ['seventeen' => 70, 'name' => 'Sidi'])如果您想将行作为您没有定义类的对象来获取，您可以执行以下操作
<?php
$result = $q->fetchAll(PDO::FETCH_OBJ);
?>当将 PDO::FETCH_CLASS 作为第一个参数传递时，此方法将接受类名作为第二个选项
<?php
$query = $pdo->prepare($sql);
$result = $query->execute($values);
if ($result && $query->rowCount() > 0) {
$records = $query->fetchAll(PDO::FETCH_CLASS, 'Some_Class');
// $record 现在是 Some_Class 对象的数组
}
?>
- Davey我遇到了将 PDO 查询结果返回到数组中的问题，这是由于这些查询结果的结构（包含结果数组的查询数组）。现在，当对查询执行 fetchAll() 时，您会得到以下内容
Array ( [0] = Array ( [key1] => "value1", [key2] => "value2") [1] = Array( [key1] => "value1", [key2] => "value2") )
这是一个更小的数组，但是以这种方式返回大型数据库中的结果，很快就会变得无法读取。
这就是 glorius foreach 出现的地方！我们都知道 foreach 的基本写法（foreach ($array as $key => $value) {...}），但是对于查询结果，有一个技巧，因为 $key 和 $value 变量都是数组，其中 $key 是包含结果数组的查询数组，而 $value 是结果数组本身。
因此，在这个 foreach 中，我们必须直接与 $value 交谈才能获得我们的结果！这看起来像这样
<?php
foreach ($query as $key => $value) {
return $value["key2"];
}
?>
这已经完成了工作，但是要将它们返回到数组中，我们必须稍微更改一下 return 代码，如下所示
<?php
foreach ($query as $key => $value) {
return array (
"key1" => $value["key1"],
"key2" => $value["key2"]
);
}
?>
这个 foreach 循环遍历查询数组，就像第一个一样，但是 return 代码只是不返回代表结果数组的键 ($key)，而只返回存储在 $value 中的结果数组内的键。这给了我们一个看起来像这样的数组
Array ( [key1] => "value1", [key2] => "value2")
如果正确编写，这应该返回数组中的所有值。我仍然在遇到 foreach 没有返回所有结果的问题，但是这个注释主要是为了展示它如何以数组的形式返回。如果您尝试调用 PDOStatement::fetchAll 并且没有按预期获取结果集（而是空），请检查是否首先调用了 PDOStatement::execute。
请记住 PDOStatement::fetchAll 不会执行查询，它只是装配数组。
:)