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 de l'array 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
        )

)