Comment obtenir le nombre total de lignes d'une requête GROUP BY ?

Question

Extrait du manuel de l'AOP :

PDOStatement::rowCount() retourne la valeur de nombre de lignes touchés par la dernière DELETE, INSERT, ou UPDATE déclaration exécutée par l'objet PDOStatement correspondant.

Si la dernière instruction SQL exécutée par l'instruction PDOS associée était un SÉLECTIONNER déclaration, certaines bases de données peuvent retourner le nombre de lignes retournées par cette instruction . Cependant, ce comportement est non garanti pour toutes les bases de données et ne doit pas être utilisé pour des applications portables.

Je ne l'ai découvert que très récemment. Je venais juste de changer ma couche d'abstraction de données pour ne pas utiliser SELECT COUNT(1) ... car il serait beaucoup plus efficace d'interroger les rangées actuelles et de compter le résultat. Et maintenant PDO ne supporte pas ça ! ?

Je n'utilise pas PDO pour MySQL et PgSQL, mais je le fais pour SQLite. Existe-t-il un moyen (sans modifier complètement le dbal) de compter les lignes comme ceci dans PDO ? En MySQL, ce serait quelque chose comme ceci :

$q = $db->query('SELECT a, b, c FROM tbl WHERE oele = 2 GROUP BY boele');
$rows = $q->num_rows;
// and now use $q to get actual data

Avec les pilotes MySQLi et PgSQL, c'est possible. Avec tous les PDO, ça ne l'est pas !?

PS. Ma solution initiale était d'étendre la méthode SQLResult->count (ma propre méthode) pour remplacer SELECT ... FROM par SELECT COUNT(1) FROM et renvoyer simplement ce nombre (très inefficace, mais seulement pour SQLite PDO). Ce n'est cependant pas suffisant, car dans l'exemple de requête ci-dessus, il y a un fichier GROUP BY ce qui modifierait le sens/la fonction de l'expression COUNT(1) .

Answer 1

Voici la solution pour vous

$sql="SELECT count(*) FROM [tablename] WHERE key == ? ";
$sth = $this->db->prepare($sql);
$sth->execute(array($key));
$rows = $sth->fetch(PDO::FETCH_NUM);
echo $rows[0];

Answer 2

C'est un peu inefficace en mémoire mais si vous utilisez les données de toute façon, je l'utilise fréquemment :

$rows = $q->fetchAll();
$num_rows = count($rows);

Answer 3

Je n'utilise pas PDO pour MySQL et PgSQL, mais je le fais pour SQLite. Existe-t-il un moyen (sans modifier complètement le dbal) de compter les lignes de cette manière dans PDO ?

En conséquence ce commentaire le problème de SQLite a été introduit par un changement d'API dans la version 3.x.

Cela dit, il serait bon de vérifier comment PDO implémente réellement la fonctionnalité avant de l'utiliser.

Je ne suis pas familier avec son fonctionnement interne mais je me méfierais de l'idée que PDO analyse votre SQL (puisqu'une erreur de syntaxe SQL apparaîtrait dans les journaux de la base de données) et encore moins qu'il essaie de lui donner le moindre sens afin de compter les lignes en utilisant une stratégie optimale.

En supposant que ce n'est pas le cas, les stratégies réalistes pour qu'il renvoie un compte de toutes les lignes applicables dans une instruction de sélection incluent la manipulation de la clause de limite de votre instruction SQL, et l'une ou l'autre :

1. Exécution d'une select count() en tant que sous-requête (évitant ainsi le problème que vous avez décrit dans votre PS) ;
2. Ouverture d'un curseur, exécution de fetch all et comptage des lignes ; ou
3. Avoir ouvert un tel curseur en premier lieu, et compter de la même manière les rangées restantes.

Une bien meilleure façon de compter, cependant, serait d'exécuter la requête entièrement optimisée qui le fera. Le plus souvent, cela signifie qu'il faut réécrire des parties importantes de la requête initiale que vous essayez de paginer, en supprimant les champs et les opérations d'ordre par inutiles, etc.

Enfin, si vos ensembles de données sont suffisamment importants pour compter tout type de décalage, vous pouvez également envisager de renvoyer l'estimation dérivée de la méthode de l statistiques à la place, et/ou en mettant périodiquement le résultat en cache dans Memcache. À un moment donné, avoir des comptes exacts n'est plus utile...

Answer 4

N'oubliez pas qu'un PDOStatement est Traversable . Étant donné une requête :

$query = $dbh->query('
    SELECT
        *
    FROM
        test
');

Il peut être itéré :

$it = new IteratorIterator($query);
echo '<p>', iterator_count($it), ' items</p>';

// Have to run the query again unfortunately
$query->execute();
foreach ($query as $row) {
    echo '<p>', $row['title'], '</p>';
}

Ou vous pouvez faire quelque chose comme ça :

$it = new IteratorIterator($query);
$it->rewind();

if ($it->valid()) {
    do {
        $row = $it->current();
        echo '<p>', $row['title'], '</p>';
        $it->next();
    } while ($it->valid());
} else {
    echo '<p>No results</p>';
}

Answer 5

Si vous êtes prêt à renoncer à un soupçon d'abstraction, vous pouvez utiliser une classe wrapper personnalisée qui transmet simplement tout au PDO. Disons, quelque chose comme ça : (Attention, code non testé)

class SQLitePDOWrapper
{
    private $pdo;

    public function __construct( $dns, $uname = null, $pwd = null, $opts = null )
    {
        $this->pdo = new PDO( $dns, $unam, $pwd, $opts ); 
    }
    public function __call( $nm, $args )
    {
        $ret = call_user_func_array( array( $this->pdo, $nm ), $args );
        if( $ret instanceof PDOStatement )
        {
            return new StatementWrapper( $this, $ret, $args[ 0 ] ); 
               // I'm pretty sure args[ 0 ] will always be your query, 
               // even when binding
        }

        return $ret;
    }

}

class StatementWrapper
{
    private $pdo; private $stat; private $query;

    public function __construct( PDO $pdo, PDOStatement $stat, $query )
    {
        $this->pdo  = $pdo;
        $this->stat = $stat;
        this->query = $query;
    }

    public function rowCount()
    {
        if( strtolower( substr( $this->query, 0, 6 ) ) == 'select' )
        {
            // replace the select columns with a simple 'count(*)
            $res = $this->pdo->query( 
                     'SELECT COUNT(*)' . 
                          substr( $this->query, 
                              strpos( strtolower( $this->query ), 'from' ) ) 
                   )->fetch( PDO::FETCH_NUM );
            return $res[ 0 ];
        }
        return $this->stat->rowCount();
    }

    public function __call( $nm, $args )
    {
        return call_user_func_array( array( $this->stat, $nm ), $args );
    }
}