contagem de linhas com DOP

votos
150

Há muitas declarações contraditórias ao redor. Qual é a melhor maneira de remar contagem usando DOP em PHP? Antes de usar DOP, eu simplesmente usado mysql_num_rows.

fetchAll é algo que não vai querer porque eu às vezes pode ser lidar com grandes conjuntos de dados, por isso não é bom para o meu uso.

Você tem alguma sugestão?

Publicado 19/05/2009 em 16:12
fonte usuário
Em outras línguas...                            


23 respostas

votos
211

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

Não da maneira mais elegante para fazê-lo, mais ele envolve uma consulta extra.

DOP tem PDOStatement::rowCount(), que aparentemente se não trabalhar em MySql. Que dor.

Do Doc 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 () :: a emitir uma declaração SELECT COUNT (*) com os mesmos predicados como sua instrução SELECT destina, em seguida, usar PDOStatement :: fetchColumn () para recuperar o número de linhas que serão retornados. O aplicativo pode, em seguida, executar a ação correta.

EDIT: O exemplo de código acima usa uma declaração preparada, que é, em muitos casos é provavelmente desnecessário para efeitos de contagem de linhas, de modo que:

$nRows = $pdo->query('select count(*) from blah')->fetchColumn(); 
echo $nRows;
Respondeu 19/05/2009 em 16:16
fonte usuário

votos
75

Como escrevi anteriormente em uma resposta a uma pergunta semelhante , a única razão pela qual mysql_num_rows()trabalhou é porque ele foi buscar internamente todas as linhas para dar-lhe essa informação, mesmo se ele não parece ser para você.

Assim, em DOP, as opções são:

  1. Use do MySQL FOUND_ROWS()função.
  2. Use do DOP fetchAll()função para buscar todas as linhas em uma matriz, em seguida, usar count()nele.
  3. Fazer uma consulta extra para SELECT COUNT(*), como karim79 sugeriu.
Respondeu 19/05/2009 em 16:39
fonte usuário

votos
18

Antes de usar DOP eu simplesmente usado mysql_num_rows().

Você não deveria ter sido a usá-lo em primeiro lugar.

mysql_num_rows(), Bem como PDOStatement::rowCount()implica que você já selecionou seus dados. Neste caso há apenas dois possíveis casos de uso para uma função como:

  1. Você estava selecionando seus dados apenas para obter a contagem.
  2. Você quer saber se a sua consulta retornou nenhuma linha.

E o anterior nunca deve ser usado em tudo. Nunca se deve selecionar linhas de contá-las, como seu servidor de fato pode sufocar devido ao grande conjunto de dados retornado.

Além disso, selecionando linhas apenas para contá-los simplesmente não faz sentido. A count(*)consulta tem que ser executado em vez, com apenas uma linha retornada.

O segundo caso de uso é menos desastrosa, mas bastante inútil: no caso de você precisa saber se sua consulta retornou dados, você sempre tem os dados em si!

Digamos que, se você está selecionando apenas uma linha, em seguida, basta buscá-la, e verificar o resultado:

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

No caso de você precisa obter muitas linhas, então você pode usar fetchAll().

fetchAll() é algo que não vai querer que eu às vezes pode ser lidar com grandes conjuntos de dados

Note-se que em uma aplicação web que você nunca deve selecionar uma enorme quantidade de linhas. Somente linhas que serão efectivamente utilizados em uma página web deve ser selecionada. Para o que um LIMITou cláusula semelhante no SQL tem que ser usado. E para uma quantidade tão moderada de dados que está tudo bem para usarfetchAll()

Em um caso raro tal quando você precisa selecionar uma quantidade enorme verdadeira de linhas (em um aplicativo de console, por exemplo), para reduzir a quantidade de memória usada, você tem que usar uma consulta sem buffer, mas neste caso rowCount()não estarão disponíveis de qualquer maneira , portanto, não há nenhum uso para esta função também.

Então você vê, não há nenhum caso de uso nem para rowCount()nem para uma consulta extra para substituí-lo, como sugerido na resposta aceita.

Respondeu 27/05/2013 em 17:00
fonte usuário

votos
18

Isso é super tarde, mas eu corri para o problema e eu fazer isso:

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. :)

Respondeu 06/03/2013 em 08:02
fonte usuário

votos
15

Acabei usando este:

$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>";
}
Respondeu 31/07/2011 em 18:05
fonte usuário

votos
6

Este post é antiga, mas Obtendo contagem de linhas em php com DOP é simples

$stmt = $db->query('SELECT * FROM table');
$row_count = $stmt->rowCount();
Respondeu 23/07/2014 em 01:31
fonte usuário

votos
5

Este é um post antigo, mas ficar frustrado à procura de alternativas. É super lamentável que DOP não tem esse recurso, especialmente como PHP e MySQL tendem a andar de mãos dadas.

Há uma falha infeliz em usar fetchColumn () como você não pode mais usar, que conjunto de resultados (efetivamente) como o fetchColumn () move a agulha para a próxima linha. Assim, por exemplo, se você tem um resultado semelhante ao

  1. Frutas-> Banana
  2. Frutas-> Apple
  3. Frutas-> Orange

Se você usar fetchColumn () você pode descobrir que há 3 frutas devolvidos, mas se você agora percorrer o resultado, você só tem duas colunas, o preço do fetchColumn () é a perda da primeira coluna de resultados apenas para encontrar quantas linhas foram retornadas. Isso leva a codificação desleixada, e erro totalmente resultados ridden se implementadas.

Então, agora, usando fetchColumn () você tem que implementar e inteiramente nova chamada e consulta MySQL apenas para obter um conjunto de resultados de trabalho de fresco. (Que espero que não mudou desde a sua última consulta), eu sei, improvável, mas pode acontecer. Além disso, a sobrecarga de consultas dupla em todas contagem de linha de validação. Que para este exemplo é pequeno, mas a análise de 2 milhões de linhas em uma consulta juntou, não um agradável preço a pagar.

Eu amo PHP e apoiar todos os envolvidos em seu desenvolvimento, bem como a comunidade em geral utilizando PHP em uma base diária, mas realmente espero que este é abordada em futuras versões. Este é 'realmente' a minha única reclamação com PHP DOP, que de outra forma é uma grande classe.

Respondeu 14/07/2010 em 03:29
fonte usuário

votos
1

Se você quiser apenas para obter uma contagem de linhas (não os dados) ie. utilizando COUNT (*) em uma declaração preparada então tudo que você precisa fazer é recuperar o resultado e leia 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 realizar uma contagem simples é um desperdício de recursos. Se o conjunto de resultados é grande o servidor pode sufocá-lo.

Respondeu 11/06/2016 em 09:16
fonte usuário

votos
1

Responder a esta porque eu mesmo preso com ele até agora sabendo disso e talvez ele vai ser útil.

Tenha em mente que você não pode buscar resultados duas vezes. Você tem que salvar fetch resultar em array, obter contagem de linhas por count($array)e resultados de saída 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
    }                       
}
Respondeu 10/08/2014 em 07:01
fonte usuário

votos
0

Há uma solução simples. Se você usar DOP conectar ao seu DB assim:

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 a DB será:

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

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

$amountOfRows = $query->rowcount();
Respondeu 21/02/2019 em 18:13
fonte usuário

votos
0

Para usar variáveis dentro da consulta, você pode bindValue()ou bindParam() usar variáveis dentro de uma consulta você tem que 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

Respondeu 07/12/2018 em 23:44
fonte usuário

votos
0

função count_x ($ conectar) {$ consulta = "SELECT * FROM tbl WHERE ID = '0'"; $ Declaração = $ conectar-> prepare ($ query); $ Instrução-> execute (); $ TOTAL_ROWS = $ Instrução-> rowCount (); retornar $ TOTAL_ROWS; }

Respondeu 11/04/2018 em 06:22
fonte usuário

votos
0

Quando é questão de mysql como contar ou obter quantas linhas em uma tabela com PHP DOP 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 vai para Mike @ codeofaninja.com

Respondeu 12/08/2017 em 14:45
fonte usuário

votos
0

Dê uma olhada neste link: http://php.net/manual/en/pdostatement.rowcount.php não é recomendado o uso de rowCount () em instruções SELECT!

Respondeu 13/04/2017 em 04:19
fonte usuário

votos
-1
$qry = "select * from tabel";
$cmd = $conn->prepare($qry);
$cmd->execute();
$cmd->rowCount()
Respondeu 31/05/2016 em 06:10
fonte usuário

votos
-1

Você pode combinar o melhor método em uma linha ou função, e ter a nova consulta auto-gerado para você:

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

$numRows = getRowCount($query);
Respondeu 26/05/2016 em 23:25
fonte usuário

votos
-1

Para consultas retas onde eu quero uma linha específica, e quer saber se ele foi encontrado, eu 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;
}
Respondeu 30/01/2016 em 23:33
fonte usuário

votos
-1

Eu tentei $count = $stmt->rowCount();com o Oracle 11.2 e não funcionou. Eu decidi usado um loop, 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;
Respondeu 08/05/2014 em 20:53
fonte usuário

votos
-1

Um um forro rápida de obter a primeira entrada retornada. Isso é bom para consultas básicas.

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

Referência

Respondeu 02/10/2013 em 13:57
fonte usuário

votos
-1

Aqui está uma extensão feito por encomenda da classe DOP, com uma função auxiliar para recuperar o número de linhas incluídas por critérios "onde" a última consulta.

Você pode precisar adicionar mais 'manipuladores', embora, dependendo do que os comandos que você usa. Agora ele só funciona para consultas que usam "de" 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();
    }
}
Respondeu 15/07/2013 em 09:32
fonte usuário

votos
-2
<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>
Respondeu 25/06/2016 em 05:40
fonte usuário

votos
-2

quando você faz um COUNT (*) em sua declaração mysql como em

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

sua consulta mysql já está contando o número de resultado por 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 de ter contado com a sua declaração mysql um pouco longo para escrever, mas rápido para executar

Edit: Desculpe para o cargo errado, mas como alguns exemplos mostram consulta com o conde, eu estava sugerindo usando o resultado mysql, mas se você não usar a contagem em fetchAll sql () é eficiente, se você salvar o resultado em uma variável você não vai perder uma linha.

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

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

foreach($table as $row){
  print $row->id;
}
Respondeu 27/05/2013 em 16:48
fonte usuário

votos
-3

Use parâmetro array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL), outra show de -1:

Usen parametro array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL), o pecado 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;
Respondeu 23/03/2016 em 18:32
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more