Modes de récupération

Voir les constantes de curseur pour les constantes de curseur PDO::FETCH_ORI_*.

Méthodes de récupération de base

Mode de récupération Résumé
PDO::FETCH_DEFAULT Valeur spéciale pour utiliser le mode de récupération par défaut actuel.
PDO::FETCH_ASSOC Tableau indexé par le nom de colonne uniquement.
PDO::FETCH_BOTH (Défaut) Tableau indexé à la fois par le numéro de colonne et par le nom.
PDO::FETCH_NAMED Variante de PDO::FETCH_ASSOC qui conserve les colonnes dupliquées.
PDO::FETCH_NUM Tableau indexé par le numéro de colonne uniquement.
PDO::FETCH_COLUMN Une seule colonne.
PDO::FETCH_KEY_PAIR Paires de clés-valeurs, indexées par la premiÚre colonne.
PDO::FETCH_FUNC Utilise une fonction pour créer la valeur de retour. (seulement PDOStatement::fetchAll())
PDO::FETCH_OBJ Objet anonyme (stdClass).
PDO::FETCH_CLASS Crée un objet d'une classe spécifiée.

PDO::FETCH_CLASS options

Ces modes sont utilisés pour implémenter des options lors de l'utilisation de PDO::FETCH_CLASS.

Mode de récupération Résumé
PDO::FETCH_CLASSTYPE Utilise la premiĂšre colonne comme nom de classe.
PDO::FETCH_PROPS_LATE Appelle le constructeur avant de définir les propriétés.
PDO::FETCH_SERIALIZE Utilise les données PHP sérialisées. ObsolÚte à partir de PHP 8.1.0.

Modes de résultat unique

Les modes suivants ne peuvent pas ĂȘtre utilisĂ©s avec PDOStatement::fetchAll().

Mode de récupération Résumé
PDO::FETCH_BOUND Lie les valeurs aux variables spécifiées.
PDO::FETCH_INTO Met Ă  jour un objet existant.
PDO::FETCH_LAZY Récupération paresseuse via PDORow pour un accÚs de type tableau et objet.

Drapeaux spéciaux pour PDOStatement::fetchAll()

Les modes spéciaux suivants pour plusieurs résultats ne fonctionnent qu'avec PDOStatement::fetchAll() et ne fonctionnent pas avec certains autres modes de récupération. Consulter la documentation complÚte pour plus de détails.

Mode de récupération Résumé
PDO::FETCH_GROUP Les résultats sont regroupés par la premiÚre colonne.
PDO::FETCH_UNIQUE Les résultats sont (uniquement) indexés par la premiÚre colonne.

Gestion des noms de colonnes dupliqués

Il est possible que les rĂ©sultats contiennent plusieurs colonnes utilisant le mĂȘme nom. Par exemple, lors de la jointure de 2 tables contenant toutes deux une colonne avec le mĂȘme nom.

Étant donnĂ© que les structures PHP telles que les tableaux et les objets ne prennent pas en charge plusieurs clĂ©s ou propriĂ©tĂ©s utilisant le mĂȘme nom, le tableau ou l'objet retournĂ© contiendra uniquement 1 des valeurs utilisant le mĂȘme nom.

La valeur retournĂ©e pour un nom dupliquĂ© donnĂ© doit ĂȘtre considĂ©rĂ©e comme indĂ©finie.

Pour Ă©viter ce problĂšme, nommez explicitement les colonnes en utilisant un alias. Par exemple : 

SELECT table1.created_at AS t1_created_at,
       table2.created_at AS t2_created_at
FROM table1
JOIN table2 ON table1.table2id = table2.id

Voir Ă©galement PDO::FETCH_NAMED, PDO::ATTR_FETCH_TABLE_NAMES et PDO::ATTR_FETCH_CATALOG_NAMES.

Définir le mode de récupération par défaut

Il est possible de dĂ©finir le mode de rĂ©cupĂ©ration par dĂ©faut pour toutes les requĂȘtes en utilisant PDO::ATTR_DEFAULT_FETCH_MODE avec PDO::__construct() or PDO::setAttribute().

Le mode de rĂ©cupĂ©ration par dĂ©faut est initialement dĂ©fini sur PDOStatement::setFetchMode(). Cela affecte la rĂ©utilisation en tant que requĂȘte prĂ©parĂ©e et l'itĂ©ration (en utilisant foreach).

Attention

PDOStatement::setAttribute() ne peut pas ĂȘtre utilisĂ© pour dĂ©finir le mode de rĂ©cupĂ©ration par dĂ©faut. Il n'accepte que les attributs spĂ©cifiques au pilote et ignore silencieusement les attributs qui ne sont pas reconnus.

PDO::FETCH_DEFAULT (int)

Disponible Ă  partir de PHP 8.0.7.

Ceci est une valeur spéciale qui utilise le mode de récupération par défaut actuel pour une PDOStatement. C'est particuliÚrement utile comme valeur par défaut pour les paramÚtres de méthode lors de l'extension de PDOStatement pour une utilisation avec PDO::ATTR_STATEMENT_CLASS.

Cette valeur ne peut pas ĂȘtre utilisĂ©e avec PDO::ATTR_DEFAULT_FETCH_MODE.

PDO::FETCH_ASSOC (int)

PDO::FETCH_ASSOC retourne un tableau indexé par le nom de la colonne uniquement.

<?php
$stmt = $pdo->query("SELECT userid, name, country FROM users");
$row = $stmt->fetch(\PDO::FETCH_ASSOC);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [userid] => 104
    [name] => Chris
    [country] => Ukraine
)

PDO::FETCH_BOTH (int)

Ceci est le mode de récupération par défaut.

PDO::FETCH_BOTH retourne un tableau indexé à la fois par le numéro de colonne et par le nom. Cela signifie que chaque valeur retournée est dupliquée pour chaque ligne de résultat.

Le numĂ©ro de colonne commence Ă  0 et est dĂ©terminĂ© par l'ordre des colonnes de rĂ©sultat dans la requĂȘte, et non (par exemple) par l'ordre dans lequel les colonnes sont dĂ©finies dans la table.

Note: L'utilisation de l'index de colonne numĂ©rique n'est pas recommandĂ©e car cela peut changer lorsque la requĂȘte est modifiĂ©e, ou lorsque le schĂ©ma de la table est modifiĂ© lors de l'utilisation de SELECT *.

Note: Le nombre d'entrĂ©es indexĂ©es par le nom peut ne pas correspondre au nombre d'entrĂ©es indexĂ©es par le numĂ©ro dans les cas oĂč plusieurs colonnes retournĂ©es utilisent le mĂȘme nom.

<?php
$stmt = $pdo->query("SELECT userid, name, country FROM users");
$row = $stmt->fetch(\PDO::FETCH_BOTH);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [id] => 104,
    [0] => 104,
    [name] => Chris,
    [1] => Chris,
    [country] => Ukraine,
    [2] => Ukraine
)

PDO::FETCH_NAMED (int)

PDO::FETCH_NAMED renvoie des rĂ©sultats dans le mĂȘme format que PDO::FETCH_ASSOC sauf que lorsque plusieurs colonnes utilisent le mĂȘme nom, toutes les valeurs sont retournĂ©es sous forme de liste.

Pour plus d'informations sur la gestion des noms de colonnes dupliqués et les alternatives, voir la section sur la gestion des noms dupliqués ci-dessus.

L'ordre dans lequel les valeurs dupliquĂ©es sont retournĂ©es doit ĂȘtre considĂ©rĂ© comme indĂ©fini. Il n'y a aucun moyen de savoir d'oĂč provient chaque valeur.

<?php
$stmt = $pdo->query(
"SELECT users.*, referrer.name
FROM users
LEFT JOIN users AS referrer ON users.referred_by = referrer.userid
WHERE userid = 109"
);
$row = $stmt->fetch(\PDO::FETCH_NUM);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [userid] => 109
    [name] => Array
        (
            [0] => Toni
            [1] => Chris
        )
    [country] => Germany
    [referred_by] = 104
)

PDO::FETCH_NUM (int)

PDO::FETCH_NUM renvoie un tableau indexĂ© par le numĂ©ro de colonne uniquement. Le numĂ©ro de colonne commence Ă  0 et est dĂ©terminĂ© par l'ordre des colonnes de rĂ©sultat dans la requĂȘte, et non (par exemple) par l'ordre dans lequel les colonnes sont dĂ©finies dans la table.

Note: L'utilisation de l'index de colonne numĂ©rique n'est pas recommandĂ©e car cela peut changer lorsque la requĂȘte est modifiĂ©e, ou lorsque le schĂ©ma de la table est modifiĂ© lors de l'utilisation de SELECT *.

<?php
$stmt = $pdo->query("SELECT userid, name, country FROM users");
$row = $stmt->fetch(\PDO::FETCH_NUM);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [0] => 104
    [1] => Chris
    [2] => Ukraine
)

PDO::FETCH_COLUMN (int)

PDO::FETCH_COLUMN renvoie des valeurs d'une seule colonne. Utiliser le deuxiÚme argument pour PDOStatement::setFetchMode() ou PDOStatement::fetchAll() pour spécifier quelle colonne est retournée.

Si la colonne spécifiée n'existe pas, une ValueError sera levée.

<?php
$stmt = $pdo->query("SELECT name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_COLUMN);
print_r($row);

$stmt = $pdo->query("SELECT name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_COLUMN, 1);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [0] => Chris
    [1] => Jamie
    [2] => Robin
)

Array
(
    [0] => Ukraine
    [1] => England
    [2] => Germany
)

PDO::FETCH_KEY_PAIR (int)

PDO::FETCH_KEY_PAIR renvoie des paires de valeurs, indexées par la premiÚre colonne. Les résultats doivent contenir uniquement 2 colonnes. Ce mode de récupération n'a de sens qu'avec PDOStatement::fetchAll().

Note: Si la premiĂšre colonne n'est pas unique, des valeurs seront perdues. Les valeurs perdues doivent ĂȘtre considĂ©rĂ©es comme indĂ©finies.

<?php
$stmt = $pdo->query("SELECT name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_KEY_PAIR);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [Chris] => Ukraine
    [Jamie] => England
    [Robin] => Germany
)

PDO::FETCH_FUNC (int)

SpĂ©cifier une fonction pour crĂ©er la valeur retournĂ©e. Ce mode ne peut ĂȘtre utilisĂ© qu'avec PDOStatement::fetchAll().

La fonction reçoit les valeurs en tant que paramĂštres. Il n'y a aucun moyen de rĂ©cupĂ©rer le nom de la colonne Ă  laquelle une valeur donnĂ©e Ă©tait associĂ©e. Il faut s'assurer que l'ordre des colonnes dans la requĂȘte correspond Ă  celui attendu par la fonction.

Note: Les effets de PDO::FETCH_GROUP et PDO::FETCH_UNIQUE sont appliqués aux résultats avant que la fonction ne soit appelée.

<?php
function valueCreator($col1, $col2, $col3)
{
return [
'col1' => $col1,
'col2' => strtoupper($col2),
'col3' => $col3,
'customKey' => 'customValue',
];
}

$stmt = $pdo->query("SELECT userid, name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_FUNC, valueCreator(...));
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [0] => Array
        (
            [col1] => 104
            [col2] => SAM
            [col3] => Ukraine
            [customKey] => customValue
        )

    [1] => Array
        (
            [col1] => 105
            [col2] => JAMIE
            [col3] => England
            [customKey] => customValue
        )

    [2] => Array
        (
            [col1] => 107
            [col2] => ROBIN
            [col3] => Germany
            [customKey] => customValue
        )

)

PDO::FETCH_OBJ (int)

PDO::FETCH_OBJ renvoie un objet stdClass.

Voir aussi PDOStatement::fetchObject() et PDO::FETCH_CLASS.

<?php
$stmt = $pdo->query("SELECT userid, name, country FROM users");
$row = $stmt->fetch(\PDO::FETCH_OBJ);
print_r($row);

L'exemple ci-dessus va afficher :

stdClass Object
(
    [userid] => 104
    [name] => Chris
    [country] => Ukraine
)

PDO::FETCH_CLASS (int)

Renvoie un objet d'une classe spécifiée. Pour des comportements supplémentaires, voir les options de drapeau.

Si une propriété n'existe pas avec le nom d'une colonne retournée, elle sera déclarée dynamiquement. Ce comportement est obsolÚte et entraßnera une erreur à partir de PHP 9.0.

Voir aussi PDOStatement::fetchObject().

<?php
class TestEntity
{
public $userid;

public $name;

public $country;

public $referred_by_userid;

public function __construct()
{
print "Constructor called with ". count(func_get_args()) ." args\n";
print "Properties set when constructor called? "
. (isset($this->name) ? 'Yes' : 'No') . "\n";
}
}

$stmt = $db->query(
"SELECT userid, name, country, referred_by_userid FROM users"
);
$stmt->setFetchMode(PDO::FETCH_CLASS, TestEntity::class);
$result = $stmt->fetch();
var_dump($result);

RĂ©sultat de l'exemple ci-dessus est similaire Ă  :

Constructor called with 0 args
Properties set when constructor called? Yes
object(TestEntity)#3 (4) {
  ["userid"]=>
  int(104)
  ["name"]=>
  string(5) "Chris"
  ["country"]=>
  string(7) "Ukraine"
  ["referred_by_userid"]=>
  NULL
}

PDO::FETCH_CLASSTYPE (int)

Ce mode de rĂ©cupĂ©ration peut uniquement ĂȘtre utilisĂ© en combinaison avec PDO::FETCH_CLASS (et ses autres options).

Lorsque ce mode de récupération est utilisé, PDO utilisera la premiÚre colonne retournée comme nom de la classe à retourner.

Si la classe spĂ©cifiĂ©e ne peut pas ĂȘtre trouvĂ©e, un objet stdClass sera retournĂ©, sans avertissement ni erreur.

<?php
class TestEntity
{
public $userid;

public $name;

public $country;

public $referred_by_userid;

public function __construct()
{
print "Constructor called with ". count(func_get_args()) ." args\n";
print "Properties set when constructor called? "
. (isset($this->name) ? 'Yes' : 'No') . "\n";
}
}

$stmt = $db->query(
"SELECT 'TestEntity', userid, name, country, referred_by_userid FROM users"
);
$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_CLASSTYPE);
$result = $stmt->fetch();
var_dump($result);

RĂ©sultat de l'exemple ci-dessus est similaire Ă  :

Constructor called with 0 args
Properties set when constructor called? Yes
object(TestEntity)#3 (4) {
  ["userid"]=>
  int(104)
  ["name"]=>
  string(5) "Chris"
  ["country"]=>
  string(7) "Ukraine"
  ["referred_by_userid"]=>
  NULL
}

PDO::FETCH_PROPS_LATE (int)

Ce mode de rĂ©cupĂ©ration peut uniquement ĂȘtre utilisĂ© en combinaison avec PDO::FETCH_CLASS (et ses autres options).

Lorsque ce mode de récupération est utilisé, le constructeur sera appelé avant que les propriétés ne soient définies.

<?php
class TestEntity
{
public $userid;

public $name;

public $country;

public $referred_by_userid;

public function __construct()
{
print "Constructor called with ". count(func_get_args()) ." args\n";
print "Properties set when constructor called? "
. (isset($this->name) ? 'Yes' : 'No') . "\n";
}
}

$stmt = $db->query(
"SELECT userid, name, country, referred_by_userid FROM users"
);
$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_PROPS_LATE, TestEntity::class);
$result = $stmt->fetch();
var_dump($result);

RĂ©sultat de l'exemple ci-dessus est similaire Ă  :

Constructor called with 0 args
Properties set when constructor called? No
object(TestEntity)#3 (4) {
  ["userid"]=>
  int(104)
  ["name"]=>
  string(5) "Chris"
  ["country"]=>
  string(7) "Ukraine"
  ["referred_by_userid"]=>
  NULL
}

PDO::FETCH_SERIALIZE (int)

Avertissement

Cette fonctionnalité est OBSOLÈTE depuis PHP 8.1.0. Son utilisation est fortement déconseillée.

Ce mode de rĂ©cupĂ©ration peut uniquement ĂȘtre utilisĂ© en combinaison avec PDO::FETCH_CLASS (et ses autres options).

Lorsque ce mode de rĂ©cupĂ©ration est utilisĂ©, la classe spĂ©cifiĂ©e doit ĂȘtre Serializable.

Attention

Cette fonctionnalité ne prend pas en charge une chaßne contenant un objet sérialisé complet (avec serialize()).

Attention

Ce mode de récupération n'appelle pas le constructeur.

<?php
class TestEntity implements Serializable
{
public $userid;

public $name;

public $country;

public $referred_by_userid;

public function __construct()
{
print "Constructor called with " . count(func_get_args()) . " args\n";
print "Properties set when constructor called? "
. (isset($this->name) ? 'Yes' : 'No') . "\n";
}

public function serialize()
{
return join(
"|",
[$this->userid, $this->name, $this->country, $this->referred_by_userid]
);
}

public function unserialize(string $data)
{
$parts = explode("|", $data);
$this->userid = (int) $parts[0];
$this->name = $parts[1];
$this->country = $parts[2];

$refId = $parts[3];
$this->referred_by_userid = ($refId === "" ? null : (int) $refId);
}
}

print "Set up record (constructor called manually):\n";
$db->exec(
"CREATE TABLE serialize (
sdata TEXT
)"
);

$origObj = new TestEntity();
$origObj->userid = 200;
$origObj->name = 'Seri';
$origObj->country = 'Syria';
$origObj->referred_by_userid = null;

$insert = $db->prepare("INSERT INTO serialize (sdata) VALUES (:sdata)");
$insert->execute(['sdata' => $origObj->serialize()]);

print "\nRetrieve result:\n";
$query = "SELECT sdata FROM serialize";
$stmt = $db->query($query);
// NOTE: Le constructeur n'est jamais appelé
$stmt->setFetchMode(PDO::FETCH_CLASS | PDO::FETCH_SERIALIZE, TestEntity::class);
$result = $stmt->fetch();
var_dump($result);

RĂ©sultat de l'exemple ci-dessus est similaire Ă  :

Deprecated: TestEntity implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary) in Standard input code on line 2
Set up record (constructor called manually):
Constructor called with 0 args
Properties set when constructor called? No

Retrieve result:
Deprecated: PDOStatement::setFetchMode(): The PDO::FETCH_SERIALIZE mode is deprecated in Standard input code on line 58

Deprecated: PDOStatement::fetch(): The PDO::FETCH_SERIALIZE mode is deprecated in Standard input code on line 59
object(TestEntity)#5 (4) {
  ["userid"]=>
  int(200)
  ["name"]=>
  string(4) "Seri"
  ["country"]=>
  string(5) "Syria"
  ["referred_by_userid"]=>
  NULL
}

PDO::FETCH_BOUND (int)

Ce mode de rĂ©cupĂ©ration ne peut pas ĂȘtre utilisĂ© avec PDOStatement::fetchAll().

Ce mode de récupération ne renvoie pas directement un résultat, mais lie des valeurs à des variables spécifiées avec PDOStatement::bindColumn(). La méthode fetch appelée renvoie true.

Note: Lors de l'utilisation d'instructions prĂ©parĂ©es, pour fonctionner correctement, les variables doivent ĂȘtre liĂ©es aprĂšs l'exĂ©cution de la requĂȘte.

<?php
$query = "SELECT users.userid, users.name, users.country, referrer.name
FROM users
LEFT JOIN users AS referrer ON users.referred_by_userid = referrer.userid";
$stmt = $db->prepare($query);
$stmt->execute();

$stmt->bindColumn('userid', $userId);
$stmt->bindColumn('name', $name);
$stmt->bindColumn('country', $country);
// Lie par position de colonne pour résoudre le nom de colonne dupliqué
// Pour Ă©viter que cela ne casse si la requĂȘte est modifiĂ©e, utiliser un alias SQL Ă  la place
// Par exemple : referrer.name AS referrer_name
$stmt->bindColumn(4, $referrerName);

while ($stmt->fetch(\PDO::FETCH_BOUND)) {
print join("\t", [$userId, $name, $country, ($referrerName ?? 'NULL')]) . "\n";
}

L'exemple ci-dessus va afficher :

104	Chris	Ukraine	NULL
105	Jamie	England	NULL
107	Robin	Germany	Chris
108	Sean	Ukraine	NULL
109	Toni	Germany	NULL
110	Toni	Germany	NULL

PDO::FETCH_INTO (int)

Ce mode de rĂ©cupĂ©ration ne peut pas ĂȘtre utilisĂ© avec PDOStatement::fetchAll().

Ce mode de récupération met à jour les propriétés de l'objet spécifié. L'objet est renvoyé en cas de succÚs.

Si une propriété n'existe pas avec le nom d'une colonne renvoyée, elle sera déclarée dynamiquement. Ce comportement est obsolÚte et entraßnera une erreur à partir de PHP 9.0.

Les propriĂ©tĂ©s doivent ĂȘtre public et ne peuvent pas ĂȘtre readonly.

Attention

Il n'y a aucun moyen de changer l'objet à mettre à jour sans utiliser PDOStatement::setFetchMode() entre la récupération de chaque enregistrement.

<?php

class TestEntity
{
public $userid;

public $name;

public $country;

public $referred_by_userid;
}

$obj = new TestEntity();

$stmt = $db->query("SELECT userid, name, country, referred_by_userid FROM users");

$stmt->setFetchMode(\PDO::FETCH_INTO, $obj);
$result = $stmt->fetch();

var_dump($result);

RĂ©sultat de l'exemple ci-dessus est similaire Ă  :

object(TestEntity)#3 (4) {
  ["userid"]=>
  int(104)
  ["name"]=>
  string(5) "Chris"
  ["country"]=>
  string(7) "Ukraine"
  ["referred_by_userid"]=>
  NULL
}

PDO::FETCH_LAZY (int)

Ce mode de rĂ©cupĂ©ration ne peut pas ĂȘtre utilisĂ© avec PDOStatement::fetchAll().

Ce mode de récupération renvoie un objet PDORow qui fournit un accÚs à la fois de type tableau et de type objet aux valeurs (c'est-à-dire qu'il combine le comportement de PDO::FETCH_BOTH et PDO::FETCH_OBJ), récupérées de maniÚre paresseuse.

Cela peut fournir un accÚs efficace en mémoire (du cÎté PHP) aux résultats non mis en mémoire tampon sur le serveur de base de données. Que PDO utilise ou non un tampon cÎté client pour les résultats dépend du pilote spécifique à la base de données utilisé (et de sa configuration).

Attention

PDORow renverra NULL sans aucun avertissement ou erreur lors de l'accĂšs Ă  des propriĂ©tĂ©s ou des clĂ©s qui ne sont pas dĂ©finies. Cela peut rendre des erreurs telles que des fautes de frappe ou des requĂȘtes ne renvoyant pas les donnĂ©es attendues plus difficiles Ă  repĂ©rer et Ă  dĂ©boguer.

Attention

L'objet PDORow renvoyé est mis à jour chaque fois qu'un résultat est récupéré.

<?php
$stmt = $db->query("SELECT userid, name, country, referred_by_userid FROM users");
$result = $stmt->fetch(\PDO::FETCH_LAZY);

print "ID: ". $result[0] ."\n";
print "Name: {$result->name}\n";
print "Country: " . $result['country'] ."\n";
// Renvoie NULL. Aucun avertissement ou erreur n'est levé.
print "Does not exist: " . var_export($result->does_not_exist, true) . "\n";

$differentResult = $stmt->fetch(\PDO::FETCH_LAZY);
// L'objet PDORow précédemment récupéré pointe maintenant vers le nouveau résultat récupéré
print "ID: ". $result[0] ."\n";

L'exemple ci-dessus va afficher :

ID: 104
Name: Chris
Country: Ukraine
Does not exist: NULL
ID: 105

PDO::FETCH_GROUP (int)

PDO::FETCH_GROUP renvoie des listes de tableaux associatifs, indexés par une colonne (non unique). Ce mode de récupération ne fonctionne qu'avec PDOStatement::fetchAll().

Lorsqu'il est combinĂ© avec PDO::FETCH_UNIQUE, les deux modes utiliseront la mĂȘme colonne, rendant la combinaison de ces modes inutile.

Cette rĂ©cupĂ©ration doit ĂȘtre combinĂ©e avec l'un des PDO::FETCH_ASSOC, PDO::FETCH_BOTH, PDO::FETCH_NAMED, PDO::FETCH_NUM, PDO::FETCH_COLUMN ou PDO::FETCH_FUNC.

Si aucun mode de récupération de la liste ci-dessus n'est donné, le mode de récupération par défaut actuel pour la PDOStatement sera utilisé.

<?php
$stmt = $pdo->query("SELECT country, userid, name FROM users");
$row = $stmt->fetchAll(\PDO::FETCH_GROUP | \PDO::FETCH_ASSOC);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [Ukraine] => Array
        (
            [0] => Array
                (
                    [userid] => 104
                    [name] => Chris
                )

            [1] => Array
                (
                    [userid] => 108
                    [name] => Sean
                )

        )
    [England] => Array
        (
            [0] => Array
                (
                    [userid] => 105
                    [name] => Jamie
                )

        )

    [Germany] => Array
        (
            [0] => Array
                (
                    [userid] => 107
                    [name] => Robin
                )

            [1] => Array
                (
                    [userid] => 109
                    [name] => Toni
                )
        )
)

Dans l'exemple ci-dessus, il est notable que la premiĂšre colonne est omise du tableau pour chaque ligne, n'Ă©tant disponible que comme clĂ©. Elle peut ĂȘtre incluse en rĂ©pĂ©tant la colonne, comme dans l'exemple suivant :

<?php
$stmt = $pdo->query("SELECT country, userid, name, country FROM users");
$row = $stmt->fetchAll(\PDO::FETCH_GROUP | \PDO::FETCH_ASSOC);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [Ukraine] => Array
        (
            [0] => Array
                (
                    [userid] => 104
                    [name] => Chris
                    [country] => Ukraine
                )

            [1] => Array
                (
                    [userid] => 108
                    [name] => Sean
                    [country] => Ukraine
                )

        )
    [England] => Array
        (
            [0] => Array
                (
                    [userid] => 105
                    [name] => Jamie
                    [country] => England
                )

        )

    [Germany] => Array
        (
            [0] => Array
                (
                    [userid] => 107
                    [name] => Robin
                    [country] => Germany
                )

            [1] => Array
                (
                    [userid] => 109
                    [name] => Toni
                    [country] => Germany
                )
        )
)

PDO::FETCH_UNIQUE (int)

PDO::FETCH_UNIQUE utilise la premiÚre colonne pour indexer les enregistrements, renvoyant 1 enregistrement par valeur d'index. Ce mode de récupération ne fonctionne qu'avec PDOStatement::fetchAll().

Lorsqu'il est combinĂ© avec PDO::FETCH_GROUP, les deux modes utiliseront la mĂȘme colonne, rendant la combinaison de ces modes inutile.

Cette rĂ©cupĂ©ration doit ĂȘtre combinĂ©e avec l'un des PDO::FETCH_ASSOC, PDO::FETCH_BOTH, PDO::FETCH_NAMED, PDO::FETCH_NUM, PDO::FETCH_COLUMN ou PDO::FETCH_FUNC.

Si aucun mode de récupération de la liste ci-dessus n'est donné, le mode de récupération par défaut actuel pour la PDOStatement sera utilisé.

Lorsqu'il est utilisĂ© avec une colonne qui est connue pour ĂȘtre unique (comme l'ID d'enregistrement), ce mode offre la possibilitĂ© de renvoyer rapidement des rĂ©sultats indexĂ©s par cette valeur.

Note: Si la premiĂšre colonne n'est pas unique, des valeurs seront perdues. La ou les valeur(s) qui sont perdues doivent ĂȘtre considĂ©rĂ©es comme indĂ©finies.

Attention

Le filtrage des enregistrements doit ĂȘtre effectuĂ© dans SQL si possible.La base de donnĂ©es utilisera des index pour optimiser ce processus et ne renvoyer que les enregistrements requis. SĂ©lectionner plus d'enregistrements que nĂ©cessaire dans la base de donnĂ©es peut augmenter considĂ©rablement l'utilisation de la mĂ©moire et le temps de requĂȘte pour des ensembles de rĂ©sultats plus volumineux.

<?php
$stmt = $pdo->query("SELECT userid, name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_UNIQUE | \PDO::FETCH_ASSOC);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [104] => Array
        (
            [name] => Chris
            [country] => Ukraine
        )

    [105] => Array
        (
            [name] => Jamie
            [country] => England
        )

    [107] => Array
        (
            [name] => Robin
            [country] => Germany
        )

)

Dans l'exemple ci-dessus, il est notable que la premiĂšre colonne est omise du tableau pour chaque ligne, n'Ă©tant disponible que comme clĂ©. Elle peut ĂȘtre incluse en rĂ©pĂ©tant la colonne, comme dans l'exemple suivant :

<?php
$stmt = $pdo->query("SELECT userid, userid, name, country FROM users LIMIT 3");
$row = $stmt->fetchAll(\PDO::FETCH_UNIQUE | \PDO::FETCH_ASSOC);
print_r($row);

L'exemple ci-dessus va afficher :

Array
(
    [104] => Array
        (
            [userid] => 104
            [name] => Chris
            [country] => Ukraine
        )

    [105] => Array
        (
            [userid] => 105
            [name] => Jamie
            [country] => England
        )

    [107] => Array
        (
            [userid] => 107
            [name] => Robin
            [country] => Germany
        )

)

Found A Problem?

Learn How To Improve This Page ‱ Submit a Pull Request ‱ Report a Bug
add a note

User Contributed Notes

There are no user contributed notes for this page.