php - insertar - Recuento de filas con DOP

php mysql connect

Question

Hay muchas declaraciones conflictivas alrededor. ¿Cuál es la mejor manera de contar las filas usando PDO en PHP? Antes de usar PDO, simplemente utilicé mysql_num_rows .

fetchAll es algo que no quiero porque a veces trato con conjuntos de datos grandes, por lo que no es bueno para mi uso.

¿Tienes alguna sugerencia?

Answer 1

Antes de usar PDO simplemente utilicé mysql_num_rows() .

No deberías haberlo usado en primer lugar.

mysql_num_rows() , así como PDOStatement::rowCount() implican que ya seleccionó sus datos. En este caso, solo hay dos posibles casos de uso para dicha función:

1. Usted seleccionó sus datos solo para obtener el conteo.
2. Desea saber si su consulta arrojó alguna fila.

Y el primero nunca debe ser usado en absoluto. Nunca se deben seleccionar las filas para contarlas, ya que el servidor puede ahogarse debido a la devolución de un gran conjunto de datos.

Además, seleccionar filas solo para contarlas simplemente no tiene sentido. En su lugar, se debe ejecutar una consulta de count(*) , con solo una fila devuelta.

El segundo caso de uso es menos desastroso, pero no tiene sentido: en caso de que necesite saber si su consulta arrojó algún dato, ¡siempre tendrá los datos!

Digamos, si está seleccionando solo una fila, simplemente busquela y verifique el resultado:

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

En caso de que necesite obtener muchas filas, puede usar fetchAll() .

fetchAll() es algo que no quiero ya que a veces trato con grandes conjuntos de datos

Tenga en cuenta que en una aplicación web nunca debe seleccionar una gran cantidad de filas. Solo se deben seleccionar las filas que se usarán realmente en una página web. Para lo cual se debe usar una cláusula LIMIT o similar en SQL. Y para una cantidad tan moderada de datos, está bien usar fetchAll()

En un caso tan raro cuando necesita seleccionar una gran cantidad de filas (en una aplicación de consola, por ejemplo), para reducir la cantidad de memoria utilizada, debe usar una consulta sin búfer, pero en este caso rowCount() ganó '' t estar disponible de todos modos , por lo tanto, no hay uso para esta función también.

rowCount() puede ver, no hay caso de uso ni para rowCount() ni para una consulta adicional para sustituirlo, como se sugiere en la respuesta aceptada.

Answer 2

Aquí hay una extensión hecha a medida de la clase PDO, con una función auxiliar para recuperar el número de filas incluidas en los criterios de "DONDE" de la última consulta.

Sin embargo, puede necesitar agregar más ''manejadores'', dependiendo de qué comandos use. En este momento, solo funciona para consultas que usan "DESDE" o "ACTUALIZAR".

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();
    }
}

Answer 3

Como escribí anteriormente en una respuesta a una pregunta similar , la única razón por la que mysql_num_rows() es porque internamente fue a buscar todas las filas para darle esa información, incluso si no le pareció a usted.

Entonces en PDO, sus opciones son:

1. Use la función FOUND_ROWS() MySQL.
2. Use la función fetchAll() PDO para buscar todas las filas en una matriz y luego use count() en ella.
3. Haga una consulta adicional para SELECT COUNT(*) , como sugirió karim79.

Answer 4

Cuando es cuestión de mysql cómo contar o obtener cuántas filas en una tabla con PHP PDO utilizo esto

// 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''];

los créditos van a Mike @ codeofaninja.com

Answer 5

Eche un vistazo a este enlace: http://php.net/manual/en/pdostatement.rowcount.php No se recomienda usar rowCount () en las sentencias SELECT!

Answer 6

Esta es una publicación anterior, pero se siente frustrado en la búsqueda de alternativas. Es muy desafortunado que PDO carezca de esta característica, especialmente porque PHP y MySQL tienden a ir de la mano.

Existe un desafortunado error al usar fetchColumn () ya que ya no puede usar ese conjunto de resultados (efectivamente) ya que fetchColumn () mueve la aguja a la siguiente fila. Entonces, por ejemplo, si tiene un resultado similar a

1. Fruta-> Plátano
2. Fruta-> Apple
3. Fruta-> Naranja

Si usa fetchColumn () puede descubrir que hay 3 frutas devueltas, pero si ahora recorre el resultado, solo tiene dos columnas. El precio de fetchColumn () es la pérdida de la primera columna de resultados solo para encontrar cuántas filas se devolvieron Eso lleva a una codificación descuidada, y resultados totalmente erróneos si se implementan.

Así que ahora, usando fetchColumn () tienes que implementar una llamada completamente nueva y una consulta MySQL solo para obtener un nuevo conjunto de resultados de trabajo. (Es de esperar que no haya cambiado desde su última consulta), lo sé, es poco probable, pero puede suceder. Además, la sobrecarga de consultas dobles en toda la validación de recuento de filas. Que para este ejemplo es pequeño, pero el análisis de 2 millones de filas en una consulta combinada, no es un precio agradable de pagar.

Me encanta PHP y apoyo a todos los involucrados en su desarrollo, así como a la comunidad en general, utilizando PHP a diario, pero realmente espero que esto se aborde en versiones futuras. Esta es ''realmente'' mi única queja con PHP PDO, que de lo contrario es una gran clase.

Answer 7

Esta publicación es antigua, pero obtener el recuento de filas en PHP con PDO es simple

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

Answer 8

Esto es muy tarde, pero me encontré con el problema y hago esto:

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();

Es realmente simple y fácil. :)

Answer 9

Intenté $count = $stmt->rowCount(); con Oracle 11.2 y no funcionó. Decidí usar un ciclo for como se muestra a continuación.

   $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;

Answer 10

Para consultas directas donde quiero una fila específica, y quiero saber si se encontró, utilizo 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;
}

Answer 11

Puede combinar el mejor método en una línea o función y hacer que la nueva consulta se genere automáticamente para usted:

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

$numRows = getRowCount($query);

Answer 12

Respondiendo a esto porque me atrapé con esto ahora sabiendo esto y tal vez será útil.

Tenga en cuenta que no puede obtener resultados dos veces. Debe guardar el resultado obtenido en la matriz, obtener el recuento de filas por count($array) y los resultados de salida con foreach . Por ejemplo:

$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
    }                       
}

Answer 13

Si solo desea obtener un recuento de filas (no los datos), es decir. usando COUNT (*) en una declaración preparada, entonces todo lo que necesita hacer es recuperar el resultado y leer el 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)

En realidad, recuperar todas las filas (datos) para realizar un conteo simple es una pérdida de recursos. Si el conjunto de resultados es grande, su servidor puede ahogarse.

Answer 14

Terminé usando esto:

$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>";
}

Answer 15

Un trazador de líneas rápido para obtener la primera entrada devuelta. Esto es bueno para consultas muy básicas.

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

Reference

Answer 16

Utilice la array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL) parámetros array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL) , de lo contrario, muestre -1:

Utilizar parametro array(PDO::ATTR_CURSOR => PDO::CURSOR_SCROLL) , sin venta -1

ejemplo:

$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;

Answer 17

cuando haces un COUNT (*) en tu declaración mysql como en

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

su consulta mysql ya está contando el número de resultados ¿por qué contar de nuevo en php? para obtener el resultado de tu mysql

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

y $nb contendrá el número entero que ha contado con su declaración mysql un poco largo para escribir pero rápido para ejecutar

Editar: disculpe por la publicación incorrecta, pero como un ejemplo muestra una consulta con conteo, sugerí usar el resultado de mysql, pero si no usa el recuento en sql fetchAll () es eficiente, si guarda el resultado en una variable no perderás una línea.

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

count($table) devolverá el número de la fila y todavía puede usar el resultado después de como $row = $table[0] o usando un foreach

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

Answer 18

función count_x ($ connect) {$ query = "SELECT * FROM tbl DONDE id = ''0''"; $ statement = $ connect-> prepare ($ query); $ statement-> execute (); $ total_rows = $ statement-> rowCount (); devolver $ total_rows; }

Answer 19

$qry = "select * from tabel";
$cmd = $conn->prepare($qry);
$cmd->execute();
$cmd->rowCount()

Answer 20

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

No es la forma más elegante de hacerlo, además implica una consulta adicional.

PDO tiene PDOStatement::rowCount() , que aparentemente no funciona en MySql. Que dolor.

Del PDO Doc:

Para la mayoría de las bases de datos, PDOStatement :: rowCount () no devuelve el número de filas afectadas por una instrucción SELECT. En su lugar, use PDO :: query () para emitir una instrucción SELECT COUNT (*) con los mismos predicados que su declaración SELECT deseada, luego use PDOStatement :: fetchColumn () para recuperar el número de filas que se devolverán. Su aplicación puede realizar la acción correcta.

EDITAR: El ejemplo de código anterior usa una declaración preparada, que en muchos casos probablemente sea innecesaria para el recuento de filas, por lo que:

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

Answer 21

<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>