Vous faire comprendre la structure de requête définie en PHP en trois minutes

Cet article vous présentera la structure de requête définie dans PHPPHP. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer. J'espère qu'il sera utile à tout le monde.

Apprentissage des opérations PDO en PHP (4) Ensemble de structures de requête

Pour le dernier article sur PDO, nous prendrons L'opération L'interrogation de l'ensemble de résultats est terminée. Dans les opérations de base de données, les requêtes représentent souvent une proportion très élevée. Dans le développement quotidien, la plupart des entreprises sont des entreprises sans lecture ni écriture, la maîtrise des opérations liées aux requêtes est donc une partie importante de notre apprentissage. Comme MySQLi, la prise en charge des requêtes par PDO est également très pratique et rapide. Vous pouvez utiliser diverses instructions de requête de manière très pratique et efficace grâce à quelques fonctions.

Lors de l'utilisation d'instructions préparées, après avoir utilisé execute() pour exécuter, l'ensemble de résultats de la requête sera enregistré dans l'objet PDOStatement. Les opérations sur les données sont transférées vers des objets PHP, nous avons donc besoin de quelques méthodes de PDOStatement pour obtenir le contenu du jeu de résultats.

Méthode fetch()

Grâce à la méthode fetch(), la ligne suivante de l'ensemble de résultats de la requête est obtenue.

$stmt = $pdo->prepare("select * from zyblog_test_user");
$stmt->execute();

$row = $stmt->fetch();
print_r($row);
// Array
// (
//     [id] => 1
//     [0] => 1
//     [username] => aaa
//     [1] => aaa
//     [password] => aaa
//     [2] => aaa
//     [salt] => aaa
//     [3] => aaa
// )

À en juger par les résultats renvoyés, nous n'avons pas spécifié l'attribut PDO::ATTR_DEFAULT_FETCH_MODE pour l'objet PDO, c'est donc le format PDO::FETCH_BOTH par défaut renvoyé, c'est-à-dire que le nom du champ et l'indice existent à en même temps. En fait, cette méthode peut spécifier directement le FETCH_STYLE dont nous avons besoin.

La spécification du type de jeu de résultats

$row = $stmt->fetch(PDO::FETCH_ASSOC);
print_r($row);
// Array
// (
//     [id] => 2
//     [username] => bbb
//     [password] => bbb
//     [salt] => 123
// )

$row = $stmt->fetch(PDO::FETCH_LAZY);
print_r($row);
// PDORow Object
// (
//     [queryString] => select * from zyblog_test_user
//     [id] => 3
//     [username] => ccc
//     [password] => bbb
//     [salt] => c3
// )

$row = $stmt->fetch(PDO::FETCH_OBJ);
print_r($row);
// stdClass Object
// (
//     [id] => 4
//     [username] => ccc
//     [password] => bbb
//     [salt] => c3
// )

est la même que PDO::ATTR_DEFAULT_FETCH_MODE spécifiant l'objet PDO. Lorsque vous utilisez la méthode fetch(), spécifiez directement le paramètre de type de résultat de retour requis au premier paramètre de la méthode, réalisant ainsi la spécification de FETCH_STYLE. Les formats spécifiques pris en charge sont exactement les mêmes que l'attribut PDO::ATTR_DEFAULT_FETCH_MODE de l'objet PDO mentionné précédemment.

Obtenir toutes les données

Comme le montrent le code et la définition, la méthode fetch() consiste à obtenir la ligne de données suivante dans l'ensemble de données actuel, tout comme l'opération du curseur de la base de données. Par conséquent, nous pouvons parcourir l’ensemble de résultats en bouclant fetch() pour obtenir toutes les données de l’ensemble de résultats.

 while($row = $stmt->fetch()){
    print_r($row);
}
// Array
// (
//     [id] => 2
//     [0] => 2
//     [username] => bbb
//     [1] => bbb
//     [password] => bbb
//     [2] => bbb
//     [salt] => 123
//     [3] => 123
// )
// ……

MySQL ne prend pas en charge les curseurs

Comme mentionné ci-dessus, l'opération du curseur est prise en charge par l'extension PDO, mais il convient de noter que l'extension MySQL ne prend pas en charge cette opération. Par conséquent, les propriétés liées au curseur que nous utilisons n'ont aucun effet sur la bibliothèque MySQL.

$stmt = $pdo->prepare("select * from zyblog_test_user", [PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL]);
$stmt->execute();

$row = $stmt->fetch(PDO::FETCH_ASSOC, PDO::FETCH_ORI_NEXT);
print_r($row);
// Array
// (
//     [id] => 1
//     [username] => aaa
//     [password] => aaa
//     [salt] => aaa
// )

$stmt = $pdo->prepare("select * from zyblog_test_user", [PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL]);
$stmt->execute();

$row = $stmt->fetch(PDO::FETCH_ASSOC, PDO::FETCH_ORI_LAST);
print_r($row);
// Array
// (
//     [id] => 1
//     [username] => aaa
//     [password] => aaa
//     [salt] => aaa
// )

S'il s'agit d'une base de données et d'une extension qui prennent en charge les opérations de curseur, une fois le deuxième paramètre de fetch() dans le code ci-dessus spécifié, les résultats obtenus seront différents. PDO::FETCH_ORI_NEXT doit obtenir les données suivantes du curseur, et PDO::FETCH_ORI_LAST doit obtenir les dernières données du curseur. Mais lors de notre test sur MySQL, ils n’ont eu aucun effet et ont quand même obtenu la donnée suivante dans le jeu de résultats.

Méthode fetchAll()

Grâce à la méthode fetch(), nous pouvons obtenir toutes les données de l'ensemble de résultats, mais cela nécessite toujours une boucle à parcourir, ce qui c'est un peu gênant. En fait, PDO nous a déjà préparé une autre méthode, fetchAll(), qui renvoie un tableau contenant toutes les lignes du jeu de résultats.

$stmt = $pdo->prepare("select * from zyblog_test_user limit 2");
$stmt->execute();

$list = $stmt->fetchAll();
print_r($list);
// Array
// (
//     [0] => Array
//         (
//             [id] => 1
//             [0] => 1
//             [username] => aaa
//             [1] => aaa
//             [password] => aaa
//             [2] => aaa
//             [salt] => aaa
//             [3] => aaa
//         )

//     [1] => Array
//         (
//             [id] => 2
//             [0] => 2
//             [username] => bbb
//             [1] => bbb
//             [password] => bbb
//             [2] => bbb
//             [salt] => 123
//             [3] => 123
//         )

// )

fetchAll() utilise fetch() en interne pour nous aider à parcourir l'ensemble de résultats et à l'attribuer à un tableau. Donc, si nous appelons à nouveau fetchAll() sans re-execute(), nous obtiendrons des données vides. Parce que le curseur a atteint le bas.

$list = $stmt->fetchAll();
print_r($list);
// Array
// (
// )

Il prend également en charge la spécification de FETCH_STYLE Comme la méthode fetch(), vous pouvez directement attribuer la constante de type requise au premier paramètre.

// PDO::FETCH_ASSOC
$stmt = $pdo->prepare("select * from zyblog_test_user limit 2");
$stmt->execute();

$list = $stmt->fetchAll(PDO::FETCH_ASSOC);
print_r($list);
// Array
// (
//     [0] => Array
//         (
//             [id] => 1
//             [username] => aaa
//             [password] => aaa
//             [salt] => aaa
//         )

//     [1] => Array
//         (
//             [id] => 2
//             [username] => bbb
//             [password] => bbb
//             [salt] => 123
//         )

// )

// PDO::FETCH_COLUMN
$stmt = $pdo->prepare("select * from zyblog_test_user limit 2");
$stmt->execute();

$list = $stmt->fetchAll(PDO::FETCH_COLUMN, 1);
print_r($list);
// Array
// (
//     [0] => aaa
//     [1] => bbb
// )

// PDO::FETCH_CLASS
class User{
    function __construct($a){
        echo $a, PHP_EOL;
    }
}
$stmt = $pdo->prepare("select * from zyblog_test_user limit 2");
$stmt->execute();
$list = $stmt->fetchAll(PDO::FETCH_CLASS, 'User', ['FetchAll User']);
print_r($list);
// FetchAll User
// FetchAll User
// Array
// (
//     [0] => User Object
//         (
//             [id] => 1
//             [username] => aaa
//             [password] => aaa
//             [salt] => aaa
//         )

//     [1] => User Object
//         (
//             [id] => 2
//             [username] => bbb
//             [password] => bbb
//             [salt] => 123
//         )

// )

Êtes-vous très familier ? Je n'entrerai pas dans les détails ici. J'ai parlé à plusieurs reprises de la spécification de type de FETCH_STYLE. Son utilisation est la même que celle de fetch() et de la méthode query() dans le. Objet PDO. Cependant, il prend également en charge une forme d'appel d'une méthode dans un rappel pour obtenir l'ensemble de données.

function getValue(){
    print_r(func_get_args());
}
// Array
// (
//     [0] => 1
//     [1] => aaa
//     [2] => aaa
//     [3] => aaa
// )
// Array
// (
//     [0] => 2
//     [1] => bbb
//     [2] => bbb
//     [3] => 123
// )
$stmt = $pdo->prepare("select * from zyblog_test_user limit 2");
$stmt->execute();
$list = $stmt->fetchAll(PDO::FETCH_FUNC, 'getValue');
print_r($list);
// Array
// (
//     [0] => 
//     [1] => 
// )

Dans ce code, nous utilisons PDO::FETCH_FUNC, et le deuxième paramètre est un nom de méthode. De cette façon, chaque ensemble de structures sera utilisé comme paramètre de méthode pour appeler la méthode spécifiée lors du parcours. Nous pouvons obtenir le contenu de ces paramètres via func_get_args(). Dans ce code, le jeu de résultats ne sera pas affecté à la variable $list via la valeur de retour de la méthode fetchAll(). Parce que les données ont été transmises à la méthode getValue() spécifiée.

Méthode fetchColumn()

Dans le code de test ci-dessus, nous avons utilisé PDO::FETCH_COLUMN pour obtenir une certaine colonne de données dans l'ensemble de résultats. Il n'y a rien de mal à écrire de cette façon, mais il existe une manière plus pratique, qui est la méthode fetchColumn() que PDOStatment nous fournit directement. Cela équivaut à spécifier PDO::FETCH_COLUMN par défaut dans la méthode et ne nécessite qu'un seul paramètre, qui est l'indice de la colonne.

Il convient de noter que son retour est la valeur de colonne spécifiée de la ligne suivante, c'est-à-dire qu'il appelle la méthode fetch() sous le capot. Si nous voulons obtenir le contenu de toutes les colonnes spécifiées dans le jeu de résultats, nous devons également parcourir le jeu de résultats de la même manière que fetch().

// fetchColumn
$stmt = $pdo->prepare("select * from zyblog_test_user");
$stmt->execute();
$column = $stmt->fetchColumn(2);
echo $column, PHP_EOL;
// aaa

$column = $stmt->fetchColumn(3);
echo $column, PHP_EOL;
// 123

fetchObject() 方法

fetchObject() 就不用多解释了，它和 fetchColumn() 是类似的，只是返回的是下一行数据的对象格式。同样的，它也是可以传递构造参数的，这点和 PDO 对象的 query() 中指定的 PDO::FETCH_CLASS 格式的使用是一样的。我们在第一篇文章中就有讲解。

// fetchObject
$stmt = $pdo->prepare("select * from zyblog_test_user");
$stmt->execute();
$user = $stmt->fetchObject('User', ['FetchObject User']);
print_r($user);
// FetchObject User
// User Object
// (
//     [id] => 1
//     [username] => aaa
//     [password] => aaa
//     [salt] => aaa
// )

rowCount() 返回查询结果数量

要获得查询的结果集行数就需要我们的 rowCount() 方法了。数据库中不管是查询还是增、删、改操作，都会返回语句执行结果，也就是受影响的行数。这些信息都是通过 rowCount() 这个方法获得的。

查询语句返回行数

需要注意的是，在查询语句中，有些数据是可能返回此语句的行数的。但这种方式不能保证对所有数据有效，且对可移植的应用更不要依赖这种方式。我们如果需要知道当前查询结果的数量，还是通过遍历 fetch() 或者通过 count(fetchAll()) 来根据真实查询到的结果集数量确定这一次查询的真实行数。

其实它就像是 PDO 对象的 exec() 方法所返回的数据。在不使用预处理语句的情况下，直接使用 PDO 的 exec() 方法执行 SQL 语句后，返回的也是语句执行后受影响的行数。

$stmt = $pdo->prepare("select * from zyblog_test_user");
$stmt->execute();
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL;
// 41

增、删、改语句返回受影响的行数

$stmt = $pdo->prepare("insert into zyblog_test_user(username, password, salt) values(?, ?, ?)");
$stmt->execute(['kkk','666','k6']);
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL; // 1
$id = $pdo->lastInsertId();
echo $rowCount, PHP_EOL; // 1

$stmt = $pdo->prepare("update zyblog_test_user set username=? where username = ?");
$stmt->execute(['ccc','cccc']);
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL; // 25

$stmt = $pdo->prepare("update zyblog_test_user set username=? where username = ?");
$stmt->execute(['ccc','cccc']);
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL; // 0

$stmt = $pdo->prepare("delete from zyblog_test_user where username = ?");
$stmt->execute(['ddd']);
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL; // 11

$stmt = $pdo->prepare("delete from zyblog_test_user where username = ?");
$stmt->execute(['ddd']);
$rowCount = $stmt->rowCount();
echo $rowCount, PHP_EOL; // 0

更新和删除操作在数据不存在、没有更新、没有删除的情况下都返回的是 0 。这一点我们也在 PDO 相关的第一篇文章中就说过了，对于业务来说，这种更新或删除到底算是成功还是失败呢？还是大家根据自己的实际业务情况来确定吧！

总结

关于 PDO 和 PDOStatement 相关的内容就学习到这里了。我们完整地梳理了一遍它们两个所有的方法，也都进行了相关的测试。大家在日常使用中可能接触到的并不多，框架都已经为我们封装好了。不过对于学习来说，平常的小测试、小调试完全可以自己手写来加深记忆和理解。在深入理解了这些扩展类的使用方法后，反过来又能帮助我们更加的清楚框架是如何去封装它们的。总之，学习就是不断的从高层到底层，再从底层返回高层，循环往复，才能更加的得心应手。

测试代码：

https://github.com/zhangyue0503/dev-blog/blob/master/php/202009/source/PHP%E4%B8%AD%E7%9A%84PDO%E6%93%8D%E4%BD%9C%E5%AD%A6%E4%B9%A0%EF%BC%88%E5%9B%9B%EF%BC%89%E6%9F%A5%E8%AF%A2%E7%BB%93%E6%9E%84%E9%9B%86.php

推荐学习：php视频教程

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!