Existem muitas declarações conflitantes por aí. Qual é a melhor maneira de contar linhas usando DOP em PHP? Antes de usar o DOP, simplesmente usei mysql_num_rows.

fetchAll é algo que eu não quero, porque às vezes posso lidar com grandes conjuntos de dados, portanto não é bom para o meu uso.

Você tem alguma sugestão?

$sql = "SELECT count(*) FROM `table` WHERE foo = ?"; 
$result = $con->prepare($sql); 
$result->execute([$bar]); 
$number_of_rows = $result->fetchColumn(); 

Não é a maneira mais elegante de fazer isso, além de envolver uma consulta extra.

O DOP possui PDOStatement::rowCount(), o que aparentemente não funciona no MySQL. Que dor.

Do documento DOP:

Para a maioria dos bancos de dados, PDOStatement :: rowCount () não retorna o número de linhas afetadas por uma instrução SELECT. Em vez disso, use PDO :: query () para emitir uma instrução SELECT COUNT (*) com os mesmos predicados que a instrução SELECT pretendida, depois use PDOStatement :: fetchColumn () para recuperar o número de linhas que serão retornadas. Seu aplicativo pode executar a ação correta.

EDIT: O exemplo de código acima usa uma instrução preparada, que em muitos casos é provavelmente desnecessária para a contagem de linhas, portanto:

$nRows = $pdo->query('select count(*) from blah')->fetchColumn(); 
echo $nRows;

Como escrevi anteriormente em uma resposta a uma pergunta semelhante , a única razão pela qual mysql_num_rows()funcionou é porque ele buscava internamente todas as linhas para fornecer essas informações, mesmo que não parecesse isso para você.

Portanto, na DOP, suas opções são:

1. Use a FOUND_ROWS()função do MySQL .
2. Use a fetchAll()função do PDO para buscar todas as linhas em uma matriz e use count()nela.
3. Faça uma consulta extra para SELECT COUNT(*), como karim79 sugeriu.

Como costuma acontecer, essa pergunta é confusa como o inferno. As pessoas estão vindo para cá com duas tarefas diferentes em mente:

1. Eles precisam saber quantas linhas na tabela
2. Eles precisam saber se uma consulta retornou alguma linha

São duas tarefas absolutamente diferentes que não têm nada em comum e não podem ser resolvidas pela mesma função. Ironicamente, para nenhum deles, a PDOStatement::rowCount()função real deve ser usada.

Vamos ver porque

Contando linhas na tabela

Antes de usar o DOP, simplesmente usei mysql_num_rows().

Significa que você já fez errado. Usar mysql_num_rows()ou rowCount()contar o número de linhas na tabela é um desastre real em termos de consumo dos recursos do servidor. Um banco de dados precisa ler todas as linhas do disco, consumir a memória no servidor de banco de dados e enviar toda essa pilha de dados para o PHP, consumindo também a memória do processo do PHP, sobrecarregando o servidor sem motivo.
Além disso, selecionar linhas apenas para contá-las simplesmente não faz sentido. Uma count(*)consulta deve ser executada. O banco de dados contará os registros do índice, sem ler as linhas reais e, em seguida, apenas uma linha retornada.

Para esse fim, o código sugerido na resposta aceita é justo.

Contando o número de linhas retornadas.

O segundo caso de uso não é tão desastroso quanto inútil: caso você precise saber se sua consulta retornou algum dado, você sempre terá os dados em si!

Digamos, se você estiver selecionando apenas uma linha. Tudo bem, você pode usar a linha buscada como um sinalizador:

$stmt->execute();
$row = $stmt->fetch();
if (!$row) { // here! as simple as that
    echo 'No data found';
}

Caso você precise obter muitas linhas, poderá usá-lo fetchAll().

fetchAll() é algo que eu não vou querer, pois às vezes posso lidar com grandes conjuntos de dados

Sim, é claro, para o primeiro caso de uso, seria duas vezes pior. Mas, como já aprendemos, não selecione as linhas apenas para contá-las, nem com rowCount()nem fetchAll().

Mas no caso de você realmente usar as linhas selecionadas, não há nada errado em usar fetchAll(). Lembre-se de que em um aplicativo Web você nunca deve selecionar uma quantidade enorme de linhas. Somente linhas que serão efectivamente utilizados em uma página web deve ser selecionado, portanto, você tem que uso LIMIT, WHEREou uma cláusula semelhante em seu SQL. E para uma quantidade tão moderada de dados, tudo bem em usar fetchAll(). E, novamente, basta usar o resultado desta função na condição:

$stmt->execute();
$data = $stmt->fetchAll();
if (!$data) { // again, no rowCount() is needed!
    echo 'No data found';
}

E é claro que será uma loucura absoluta executar uma consulta extra apenas para saber se sua outra consulta retornou alguma linha, conforme sugerido nas duas principais respostas.

Contando o número de linhas em um grande conjunto de resultados

Em um caso tão raro, quando você precisa selecionar uma quantidade enorme de linhas (em um aplicativo de console, por exemplo), é necessário usar uma consulta sem buffer , para reduzir a quantidade de memória usada. Mas este é o caso real quando rowCount() não estará disponível , portanto, não há uso para essa função também.

Portanto, esse é o único caso de uso em que talvez você precise executar uma consulta extra, caso precise conhecer uma estimativa aproximada do número de linhas selecionadas.

Isso é muito tarde, mas encontrei o problema e faço o seguinte:

function countAll($table){
   $dbh = dbConnect();
   $sql = "select * from `$table`";

   $stmt = $dbh->prepare($sql);
    try { $stmt->execute();}
    catch(PDOException $e){echo $e->getMessage();}

return $stmt->rowCount();

É realmente simples e fácil. :)

Acabei usando isso:

$result = $db->query($query)->fetchAll();

if (count($result) > 0) {
    foreach ($result as $row) {
        echo $row['blah'] . '<br />';
    }
} else {
    echo "<p>Nothing matched your query.</p>";
}

Esta publicação é antiga, mas Obter contagem de linhas em php com DOP é simples

$stmt = $db->query('SELECT * FROM table');
$row_count = $stmt->rowCount();

Este é um post antigo, mas está ficando frustrado em busca de alternativas. É lamentável que o DOP não tenha esse recurso, especialmente porque o PHP e o MySQL tendem a andar de mãos dadas.

Existe uma falha infeliz no uso de fetchColumn (), pois você não pode mais usar esse conjunto de resultados (efetivamente), pois o fetchColumn () move a agulha para a próxima linha. Por exemplo, se você tiver um resultado semelhante a

1. Frutas-> Banana
2. Frutas-> Maçã
3. Frutas-> Laranja

Se você usar fetchColumn (), poderá descobrir que há três frutas retornadas, mas se agora percorrer o resultado, terá apenas duas colunas. O preço de fetchColumn () é a perda da primeira coluna de resultados apenas para encontrar de quantas linhas foram retornadas. Isso leva à codificação desleixada e a resultados totalmente errados, se implementados.

Então agora, usando fetchColumn (), você precisa implementar uma chamada totalmente nova e uma consulta MySQL apenas para obter um novo conjunto de resultados de trabalho. (que, espero, não tenha sido alterado desde sua última consulta), eu sei, improvável, mas isso pode acontecer. Além disso, a sobrecarga de consultas duplas na validação de todas as linhas. Que neste exemplo é pequeno, mas analisa 2 milhões de linhas em uma consulta unida, não é um preço agradável a pagar.

Eu amo PHP e apoio todos os envolvidos em seu desenvolvimento, bem como a comunidade em geral, usando PHP diariamente, mas realmente espero que isso seja resolvido em versões futuras. Esta é 'realmente' a minha única reclamação com o PHP PDO, que de outra forma é uma ótima classe.

Respondendo a isso porque eu me prendi a ela agora, sabendo disso e talvez seja útil.

Lembre-se de que você não pode buscar resultados duas vezes. Você precisa salvar o resultado da busca na matriz, obter a contagem de linhas count($array)e gerar resultados com foreach. Por exemplo:

$query = "your_query_here";
$STH = $DBH->prepare($query);
$STH->execute();
$rows = $STH->fetchAll();
//all your results is in $rows array
$STH->setFetchMode(PDO::FETCH_ASSOC);           
if (count($rows) > 0) {             
    foreach ($rows as $row) {
        //output your rows
    }                       
}

Se você quiser apenas obter uma contagem de linhas (não os dados), por exemplo. usando COUNT (*) em uma instrução preparada, tudo o que você precisa fazer é recuperar o resultado e ler o valor:

$sql = "SELECT count(*) FROM `table` WHERE foo = bar";
$statement = $con->prepare($sql); 
$statement->execute(); 
$count = $statement->fetch(PDO::FETCH_NUM); // Return array indexed by column number
return reset($count); // Resets array cursor and returns first value (the count)

Na verdade, recuperar todas as linhas (dados) para executar uma contagem simples é um desperdício de recursos. Se o conjunto de resultados for grande, seu servidor poderá engasgar.

Dê uma olhada neste link: http://php.net/manual/en/pdostatement.rowcount.php Não é recomendável usar rowCount () nas instruções SELECT!

Para usar variáveis ​​em uma consulta, você deve usar bindValue()ou bindParam(). E não concatenar as variáveis ​​com" . $variable . "

$statement = "SELECT count(account_id) FROM account
                  WHERE email = ? AND is_email_confirmed;";
$preparedStatement = $this->postgreSqlHandler->prepare($statement);
$preparedStatement->bindValue(1, $account->getEmail());
$preparedStatement->execute();
$numberRows= $preparedStatement->fetchColumn();

GL

Quando se trata de mysql como contar ou obter quantas linhas em uma tabela com o PHP PDO eu uso este

// count total number of rows
$query = "SELECT COUNT(*) as total_rows FROM sometable";
$stmt = $con->prepare($query);

// execute query
$stmt->execute();

// get total rows
$row = $stmt->fetch(PDO::FETCH_ASSOC);
$total_rows = $row['total_rows'];

créditos vão para Mike @ codeofaninja.com

Um forro rápido para obter a primeira entrada retornada. Isso é bom para consultas muito básicas.

<?php
$count = current($db->query("select count(*) from table")->fetch());
?>

Referência

Eu tentei $count = $stmt->rowCount();com o Oracle 11.2 e não funcionou. Decidi usar um loop for, como mostrado abaixo.

   $count =  "";
    $stmt =  $conn->prepare($sql);
    $stmt->execute();
   echo "<table border='1'>\n";
   while($row = $stmt->fetch(PDO::FETCH_OBJ)) {
        $count++;
        echo "<tr>\n";
    foreach ($row as $item) {
    echo "<td class='td2'>".($item !== null ? htmlentities($item, ENT_QUOTES):"&nbsp;")."</td>\n";
        } //foreach ends
        }// while ends
        echo "</table>\n";
       //echo " no of rows : ". oci_num_rows($stmt);
       //equivalent in pdo::prepare statement
       echo "no.of rows :".$count;

Para consultas diretas em que desejo uma linha específica e quero saber se foi encontrada, uso algo como:

function fetchSpecificRow(&$myRecord) {
    $myRecord = array();
    $myQuery = "some sql...";
    $stmt = $this->prepare($myQuery);
    $stmt->execute(array($parm1, $parm2, ...));
    if ($myRecord = $stmt->fetch(PDO::FETCH_ASSOC)) return 0;
    return $myErrNum;
}

Há uma solução simples. Se você usa o DOP, conecte-se ao seu banco de dados da seguinte maneira:

try {
    $handler = new PDO('mysql:host=localhost;dbname=name_of_your_db', 'your_login', 'your_password'); 
    $handler -> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} 
    catch (PDOException $e) {   
    echo $e->getMessage();
}

Em seguida, a consulta ao DB será:

$query = $handler->query("SELECT id FROM your_table WHERE ...");

E, finalmente, para contar as linhas correspondentes à sua consulta, escreva assim

$amountOfRows = $query->rowcount();

fetchColumn ()

usado se quiser obter a contagem do registro [effisien]

$sql   = "SELECT COUNT(*) FROM fruit WHERE calories > 100";
$res   = $conn->query($sql);
$count = $res->fetchColumn(); // ex = 2

inquerir()

usado se desejar recuperar dados e contagem de registros [opções]

$sql = "SELECT * FROM fruit WHERE calories > 100";
$res = $conn->query($sql);

if ( $res->rowCount() > 0) {

    foreach ( $res as $row ) {
        print "Name: {$row['NAME']} <br />";
    }

}
else {
    print "No rows matched the query.";
}

PDOStatement :: rowCount

quando você cria COUNT (*) na sua instrução mysql como em

$q = $db->query("SELECT COUNT(*) FROM ...");

sua consulta mysql já está contando o número de resultados por que contar novamente em php? para obter o resultado do seu mysql

$q = $db->query("SELECT COUNT(*) as counted FROM ...");
$nb = $q->fetch(PDO::FETCH_OBJ);
$nb = $nb->counted;

e $nbconterá o número inteiro que você contou com sua instrução mysql um pouco longo para escrever, mas rápido para executar

Edit: desculpe pela postagem errada, mas como algum exemplo mostra consulta com count in, eu estava sugerindo o uso do resultado do mysql, mas se você não usar a contagem no sql fetchAll () é eficiente, se você salvar o resultado em uma variável você não perderá uma linha.

$data = $dbh->query("SELECT * FROM ...");
$table = $data->fetchAll(PDO::FETCH_OBJ);

count($table)retornará o número de linha e você ainda poderá usar o resultado depois de gostar $row = $table[0] ou usar umforeach

foreach($table as $row){
  print $row->id;
}

Aqui está uma extensão personalizada da classe PDO, com uma função auxiliar para recuperar o número de linhas incluídas pelos critérios "WHERE" da última consulta.

Você pode precisar adicionar mais 'manipuladores', dependendo de quais comandos você usa. No momento, ele funciona apenas para consultas que usam "FROM" ou "UPDATE".

class PDO_V extends PDO
{
    private $lastQuery = null;

    public function query($query)
    {
        $this->lastQuery = $query;    
        return parent::query($query);
    }
    public function getLastQueryRowCount()
    {
        $lastQuery = $this->lastQuery;
        $commandBeforeTableName = null;
        if (strpos($lastQuery, 'FROM') !== false)
            $commandBeforeTableName = 'FROM';
        if (strpos($lastQuery, 'UPDATE') !== false)
            $commandBeforeTableName = 'UPDATE';

        $after = substr($lastQuery, strpos($lastQuery, $commandBeforeTableName) + (strlen($commandBeforeTableName) + 1));
        $table = substr($after, 0, strpos($after, ' '));

        $wherePart = substr($lastQuery, strpos($lastQuery, 'WHERE'));

        $result = parent::query("SELECT COUNT(*) FROM $table " . $wherePart);
        if ($result == null)
            return 0;
        return $result->fetchColumn();
    }
}

Você pode combinar o melhor método em uma linha ou função e gerar a nova consulta automaticamente:

function getRowCount($q){ 
    global $db;
    return $db->query(preg_replace('/SELECT [A-Za-z,]+ FROM /i','SELECT count(*) FROM ',$q))->fetchColumn();
}

$numRows = getRowCount($query);

<table>
      <thead>
           <tr>
                <th>Sn.</th>
                <th>Name</th>
           </tr>
      </thead>
      <tbody>
<?php
     $i=0;
     $statement = $db->prepare("SELECT * FROM tbl_user ORDER BY name ASC");
     $statement->execute();
     $result = $statement->fetchColumn();
     foreach($result as $row) {
        $i++;
    ?>  
      <tr>
         <td><?php echo $i; ?></td>
         <td><?php echo $row['name']; ?></td>
      </tr>
     <?php
          }
     ?>
     </tbody>
</table>

function count_x($connect) {  
 $query = "  SELECT * FROM tbl WHERE id = '0' ";  
 $statement = $connect->prepare($query);  $statement->execute();  
 $total_rows = $statement->rowCount();  
 return $total_rows; 
}

Use o parâmetro array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL), senão mostre -1:

Usen parametro array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL), sin ello venda -1

exemplo:

$res1 = $mdb2->prepare("SELECT clave FROM $tb WHERE id_usuario='$username' AND activo=1 and id_tipo_usuario='4'", array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL));
$res1->execute();

$count=$res1->rowCount();
echo $count;