Discussion :

[dorian53]

Bonjour,

Prenons un exemple : vous souhaitez retourner la liste des utilisateurs.

Vous créez une méthode (static par exemple), dans une classe "User".

Que retourner vous ?
- un tableau,
- une collection (d'objets),
- le recordset directement issu de la requête.

La collection semble vraiment être la solution la plus propre et maintenable, mais aussi la plus lourde.

Pourquoi parcourir le recordset pour créer un tableau manuellement à retourner alors que le code qui va appeler la méthode va re-parcourir ce même tableau (donc 2 parcours) ?

Comment vous y prenez-vous ? Pourquoi ?

Merci

[transgohan]

Pour ma part je stocke une collection d'objet et je libère la ressource SQL.

Pourquoi pas un tableau ? Parce que je trouve plus propre et plus personnalisable d'utiliser des objets.

Pourquoi pas le recordset ? Parce que garder indéfiniment des tonnes de recordset en mémoire n'est pas franchement optimisé.

[Benjamin Delespierre]

Je récupère dans une collection qui fonctionne en lazy loading.

J'utilise ensuite un Iterator qui me permet de créer les objets sur demande, cela évite la charge inutile. De plus le fait d'utiliser un Iterator permet l'usage du LimitIterator qui est bien pratique pour la pagination.

[dorian53]

Le problème du lazyload dans un parcours c'est qu'il va exécuter N requêtes pour récupérer l'objet.

OK pour l'objet y'a pas photo, mais les "new" sont très gourmands alors que l'on possède déjà toutes les données "à plat" dans le recordset ?

[transgohan]

Mais en cas de grosse requête le recordset est très lourd aussi, de plus cela peut gêner les prochaines requêtes si tu ne le libères pas.

[Benjamin Delespierre]

Le problème du lazyload dans un parcours c'est qu'il va exécuter N requêtes pour récupérer l'objet.

En effet, mais cette solution est plus pratique que performante. Ceux qui veulent une performance accrue peuvent utiliser PDO::FETCH_INTO ou PDO::FETCH_CLASS. Le problème est que bien que le PDOStatement soit traversable il n'implémente pas Iterator et donc, pas de LimitIterator (ou autres FilterIterator). On devrait cependant pouvoir faire un PDOStatementIterator sans trop se casser la tête, c'est à creuser...

OK pour l'objet y'a pas photo, mais les "new" sont très gourmands alors que l'on possède déjà toutes les données "à plat" dans le recordset ?

Je fais ça en deux passes (je sais pertinemment que ce n'est pas optimal):
- une query réccupère les id et les passe à un RecordsetIterator en lui fournissant le nom de la classe à invoquer pour le fech.
- la méthode current du RecordsetIterator génère les objets pour l'id courant.
L'idée n'est bien sûr pas d'appliquer ce traitement sur de larges ensembles d'objets mais sur des sous-ensemble des 10 ou 20 éléments.

Mais en cas de grosse requête le recordset est très lourd aussi, de plus cela peut gêner les prochaines requêtes si tu ne le libères pas.

Cela dépends de ton driver.

Voici à quoi ressemble le recordset (réduit à sa plus simple expression):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
class RecordsetIterator extends ArrayIterator {
 
    protected $_class;
 
    public function __construct ($array, $class) {
        if (!$class || !class_exists($class, true))
            throw new RuntimeException("Unknown class $class");
 
        parent::__construct($array);
        $this->_class = $class;
    }
 
    public function current () {
        return new $this->_class (parent::current());
    }
}

Voici comment il est utilisé par une méthode d'un modèle:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
    public static function getArticles () {
        $query = "SELECT `id` FROM `blog`.`articles`";
 
        if ($stmt = Database::query($query)) {
            $results = $stmt->fetchAll(PDO::FETCH_COLUMN, 0);
            return new RecordsetIterator(array_map('implode', $results), __CLASS__);
        }
        return false;
    }

-- Edit
Si j'ai le temps je fournirai un prototype pour le PDOStatementIterator évoqué plus haut.

[Benjamin Delespierre]

Voici à quoi pourrait bien ressembler notre StatementIterator.
Pour l'utiliser comme un factory d'objet, il est nécéssaire de définir le fetch-mode de PDOStatement avant d'instancier cette classe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
<?php
 
class PDOStatementIterator extends IteratorIterator implements SeekableIterator, Countable {
 
    protected $_statement;
 
    protected $_count;
 
    public function __construct (PDOStatement $statement) {
        parent::__construct($this->_statement = $statement);
    }
 
    public function seek ($position) {
        if ($position > $this->count())
            throw new OutOfBoundsException("Cannot seek to $position");
 
        if ($position < $this->key())
            throw new OutOfRangeException("Cannot seek to $position");
 
        for ($i = $this->key(); $i < $position; $i++)
            $this->next();
    }
 
    public function count () {
        if (!isset($this->_count))
		    return $this->_count = $this->_statement->rowCount();
	    return $this->_count;
    }
}
 
class User { 
  protected $_data;
 
  public function __get ($key) {
    return isset($this->_data[$key]) ? $this->_data[$key] : null;
  }
 
  public function __set ($key, $value) {
	$this->_data[$key] = $value;
  }
}

Il s'utilise ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
echo "<pre>";
 
$db = "backoffice";
$db_type = "mysql";
$db_user = "root";
$db_password = "";
$db_host = "localhost";
$pdo = new PDO("$db_type:dbname=$db;host=$db_host", $db_user, $db_password);
 
$user = new User;
 
$stmt = $pdo->prepare('SELECT * FROM `backoffice`.`users`');
$stmt->setFetchMode(PDO::FETCH_INTO, $user);
$stmt->execute();
 
$it = new PDOStatementIterator($stmt);
 
var_dump(count($it));
foreach ($it as $user) { var_dump($user); }
 
echo "</pre>";

Vos commentaires sont les bienvenus.