¿Qué número de consultas a MySQL podrían considerarse excesivas?

[dec]

Hola,

Bueno. Después de hacer alguna que otra prueba, efectivamente, estaba dando una solución equivocada. Cuento un poco el caso, aunque no creo que le pueda servir de mucho a nadie. En definitiva se trataba de mostrar unos registros de cierta tabla de una base de datos. Entonces, como dije arriba, se me ocurrió escribir una clase para que "cargara" cada uno de los registros, de tal modo que pudiera acceder a las instancias de esta clase para obtener los datos necesarios.

Pero, ese planteamiento llevaba a lo siguiente:

1º Se hacía una consulta a la base de datos para averiguar con cuántos registros contaba un determinado usuario. La consulta SQL venía a quedar más o menos así, donde X es un número identificador de cualquier usuario:

Código SQL [-]
SELECT id FROM registros WHERE id_usuario = X

Eso era ya una primera consulta, ahora bien, ¿qué objetivo tiene esa consulta? Conseguir identificadores... conseguir los identificadores de los registros de un determinado usuario. ¿Y qué hacía luego con esos identificadores?

2º Instanciaba un objeto de la clase "Registro", pasando como parámetro en su constructor el identificador de marras, conseguido con la consulta de antes. ¡Pero esto generaba otra nueva consulta a la base de datos! ¿Y para qué? Pues para conseguir los datos del registro en cuestión, del que hasta ahora sabíamos su identificador, nada más.

3º Es en cierto método de la clase "Registro" en donde se hace la correspondiente consulta (y van dos):

Código SQL [-]
SELECT * FROM registros WHERE id = X

Lo que conocemos es la X, desde luego. Observad que se trabaja contra la misma tabla: ambas consultas tratan con la tabla "registros". ¿Qué estaba fallando aquí, para empezar? Pues que para cada identificador logrado con la primera consulta, se tiene que hacer una nueva consulta a la base de datos de modo que consigamos el resto de información necesaria...

Una locura. ¿Porqué? Pues porque podemos librarnos de la clase "Registros" y obtener los datos necesarios con la primera consulta y ninguna más. ¿Cómo? Pues, en lugar de pidiendo el identificador de cada registro, pidiendo todos sus campos, algo así:

Código SQL [-]
SELECT * FROM registros WHERE id_usuario = X

Y puede decirse que no pediremos todos los datos, puesto que utilizaremos el "LIMIT" de SQL, de tal forma que al final se haga una sola consulta que nos devuelva una decena de registros, por ejemplo. De momento, como he dicho, he mandado a freir espárragos a la clase "Registros" y estoy mostrando los datos, directamente, desde el resultado de la primera consulta. Una consulta contra tantas consultas como registros más una... vamos mejorando.

Gracias a todos, de nuevo, por responder. Seguramente sin sus comentarios no hubiera seguido adelante, o, cuando menos, me hubiera constado más darme cuenta de que estaba haciendo las cosas, ya no mal, pero peor.

[roman]

Bueno dec, contigo hay que leer entre líneas. Tú ya te deshiciste de la clase Registro pero nosotros nada más la vimos pasar rápidamente frente a nuestros ojos.

Te voy a decir lo que yo creo que intentaste y ya me dirás si era así o no.

Pero antes voy a fijar ideas, me cuesta trabajo hablar siempre en abstracto de ciertos registros, ciertas tablas, cierto sistema. Así que supongamos que tienes una tabla de personas:

personas = (id, nombre, telefono)

donde id es la llave primaria.

Tú quieres ver a cada persona con clase:

Código PHP:

class Persona
{
  var id, nombre, telefono;
} 


y qué elegante poder dotar a esta clase de un método para cargar los datos de una persona desde la base de datos partiendo de su identificador:

Código PHP:

class Persona
{
  var id, nombre, telefono;

  function load(id)
  {
    $statement = "select * from personas where id =$id";
    $results = mysql_query($statement);
    $result = mysql_fetch_assoc($results);

    $this->id = id;
    $this->nombre = $result['nombre'];
    $this->telefono = $result['telefono'];
  }
} 


Muy bonito, así haces:

Código PHP:

$persona = new Persona();
$persona->load(84); 


Y ¡listo! ya tienes a la persona con id = 84.

Pero entonces quieres una lista de personas y la clase sólo sabe cargar los datos de una sóla a la vez.

¿Va por ahí la cosa? Dime que me muero de curiosidad.

// Saludos

[dec]

Hola,

Román, no es que vaya por ahí la cosa, es que lo has descrito tal cual era.

Empezado por Román

(...) y qué elegante poder dotar a esta clase de un método para cargar los datos (...)

... esto ya es cachondeo.

[roman]

Y ¿entonces por qué no seguir con esa idea?

Si observas el método load() verás que tiene dos partes: una que hace la consulta sql y otra que transfiere los datos de los resultados a la clase. Esta última parte la puedes separar en otro método:

Código PHP:

class Persona 
{ 
  var id, nombre, telefono; 

  function populate($result)
  {
    $this->nombre = $result['nombre']; 
    $this->telefono = $result['telefono']; 
  }

  function load(id) 
  { 
    $statement = "select * from personas where id =$id"; 
    $results = mysql_query($statement); 
    $result = mysql_fetch_assoc($results); 

    $this->id = $result['id'];
    $this->populate($results);
  } 
} 


Para listas de objetos puedes hacerte de otra clase:

Código PHP:

class ListaPersonas
{
  var $items;

  function ListaPersonas()
  {
    $items = array();
  }

  function loadAll()
  {
    $statement = "select * from personas";
    $results = mysql_query($statement); 

    while ($result = mysql_fetch_assoc($results))
    {
      $persona = new Persona();
      $persona->id = $result['id'];
      $persona->populate($result);

      $this->items[] = $persona;
    }
  }
} 


Así, en $personas->items tendrás todas las personas con una sóla consulta sql. Al separar la consulta sql de la transferencia de datos, logras reutilizar esta última para llenar tu lista de persona obtenida de una sóla consulta.

Sin embargo esto en mi opinión aún no es óptimo. Normalmente requerirás recorrer este arreglo para procesarlo, por ejemplo para mostrarlo en la página:

Código PHP:

// Obtienes todas las personas
$personas = new ListaPersonas();
$personas->loadAll();

// Imprimes encabezado de la tabla
print "<table>";
print "<tr>";
print "<th>nombre</th>";
print "<th>telefono</th>";
print "</tr>";

foreach ($personas->items as $persona)
{
  print "<tr>";
  print "<td>persona->nombre</td>";
  print "<td>persona->telefono</td>";
  print "</tr>";
}

print "</table>"; 


Pero entonces ya recorriste dos veces la lista de personas, una para formar el arreglo y otra para procesar éste. Además mantienes innecesariamente en memoria toda la lista de personas lo que puede no ser muy bueno para muchos registros.

Entonces, puedes optar por dejar que sea la misma clase ListaPersonas quien haga la iteración:

Código PHP:

class ListaPersonas
{
  var $results; // resultados sql
  var $persona; // persona actual en la iteración 

  function ListaPersonas()
  {
    $this->persona = new Persona();
  }

  function loadAll()
  {
    $statement = "select * from personas";

    // guardas los resultados para su posterior iteración
    $this->results = mysql_query($statement); 
  }

  // Iterador
  // Devuelve la siguiente persona o false si no hay más personas
  function next()
  {
    $result = mysql_fetch_assoc($this->results);
    if ($result)
    {
      $persona->id = $result['id'];
      $persona->populate($result);

      return $persona;
    }

    return false;
  }
} 


Así, la construcción de la tabla te queda así:

Código PHP:

$personas = new ListaPersonas();
$personas->loadAll();

// Imprimes encabezado de la tabla
print "<table>";
print "<tr>";
print "<th>nombre</th>";
print "<th>telefono</th>";
print "</tr>";

while ($persona = $personas->next())
{
  print "<tr>";
  print "<td>persona->nombre</td>";
  print "<td>persona->telefono</td>";
  print "</tr>";
}

print "</table>"; 


El punto aquí, es que ahora sólo tienes un objeto Persona a la vez. Normalmente esto es suficiente: en un recorrido haces todo lo que haya que hacer con la persona en turno y te olvidas de la lista. Como te mencioné en algún otro hilo, al no estar trabajando con aplicaciones de escritorio, no tiene mucho objeto preservar la lista para otras cosas ya que al término del script ésta de cualquier manera dejará de existir.

Dime qué piensas y quizá podamos continuar las ideas.

// Saludos

[dec]

Hola,

Bueno, Román, pues muchas gracias de nuevo. Efectivamente, yo había pensado ya en algo así como lo que has propuesto tú, lo que ocurre es que lo había hecho muy por encima, y, desde luego, no hubiera terminado haciéndolo como tú, sino de otra forma... quizá parecida, pero,... me permito dudarlo.

El caso es que he implementado el asunto tal y como has propuesto. Seguramente ese "iterador" de la clase "ListaPersonas" no hubiera llegado a existir, de haberlo dejado de mi cuenta... como poco habría hecho lo que tú has comentado: dos iteraciones. Me juego el cuello.

Gracias otra vez Román, de veras.

[roman]

Ahora lo que falta es hacer las clases Persona y ListaPersonas reusables. Lo único realmente específo de éstas es el nombre de la tabla y el mapeo para llenar las propiedades. Y así como tienes el método loadAll(), clases descendientes puedes declarar sus propios métodos para incluir criterios de búsqueda específicos, por ejemplo

Código PHP:

$personas->loadByNombre('%perez%');
$facturas->loadByCliente($clienteId); 


Si te interesa este tema puedes encontrar información buscando cosas como Data Access Objects, Value Objects, Business Objects, etc. en PHP.

// Saludos

[Casimiro Notevi]

todos los días se aprende algo, hoy dormiré bien