5

Busque esta misma pregunta & respuestas aquí y en otros sitios indagando en la web, encontrando siempre comentarios negativos sobre hacer una consulta dentro del bucle while.

Algunos comentarios

Para obtener resultados adicionales debo hacer consultas dentro de un bucle while si o si, no tengo otra opción en mi poca base de conocimientos, esta es mi contradicción hacia mí.

Mi pregunta:

¿Cómo puedo obtener datos adicionales sin que exista problemas de rendimiento de la aplicación?

Nota: La consulta y el resultado lo realice como un procedimiento de prueba los resultados se muestran sin error alguno, lo que sí preocupa son los comentarios negativos de realizar consultas dentro de un bucle while todas las consultas se basan a contenido relacional, pero si no fuera así, si no fueran datos relacionales.


$stmt = $con->prepare("SELECT id_producto,producto FROM producto WHERE activo=? order by id_producto ASC limit 5");
$stmt->bind_param("i",$activo);
$activo = "1";
$stmt->execute();
$stmt->store_result();
if ($stmt->num_rows>0) {
  $stmt->bind_result($id_producto, $producto);
  while ($stmt->fetch()) {
    echo "<h1>$producto</h1>";

    //Comporbar cuantas personas compraron este producto
    $stmtOrden = $con->prepare("SELECT * FROM orden WHERE id_producto=? AND estadodelpedido=?");
    $stmtOrden->bind_param("is",$id_producto,$estadodelpedido);
    $estadodelpedido = "pagado";
    $stmtOrden->execute();
    $stmtOrden->store_result();

    $comprasdeesteproducto = $stmtOrden->num_rows;
    $stmtOrden->close();
    echo "este producto se compro $comprasdeesteproducto veces";


    //Comprobar dato del anunciante del producto 
    $stmtads = $con->prepare("SELECT * FROM ads WHERE id_producto=?");
    $stmtads->execute();
    $stmtads->store_result();
    if ($stmtads->num_rows>0) {
    $stmtads->bind_result();
    while ($stmtads->fetch()) {}
   } else {}

    //Para evitar un extenso código solo añado las consultas como ejemplo


    //Comprobar la eficiencia del vendedor al entregar el producto al cliente
    $stmtVendedorCliente = $con->prepare("SELECT * FROM vendedor WHERE id_producto=?");
    $stmtVendedorCliente->execute();
    $stmtVendedorCliente->store_result();
    if ($stmtVendedorCliente->num_rows>0) {
    $stmtVendedorCliente->bind_result();
    while ($stmtVendedorCliente->fetch()) {}
   } else {}


    //Comprobar el país del producto
    $stmtPais = $con->prepare("SELECT * FROM pais WHERE id_producto=?");
    $stmtPais->execute();
    $stmtPais->store_result();
    if ($stmtPais->num_rows>0) {
    $stmtPais->bind_result();
    while ($stmtPais->fetch()) {}
   } else {}


}
} else {
   echo "No existen registros";
}

Estructura de las tablas:

-- phpMyAdmin SQL Dump
-- version 4.5.1
-- http://www.phpmyadmin.net
--
-- Servidor: 127.0.0.1
-- Tiempo de generación: 24-10-2017 a las 03:50:04
-- Versión del servidor: 10.1.19-MariaDB
-- Versión de PHP: 5.6.28

SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
SET time_zone = "+00:00";


/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8mb4 */;

--
-- Base de datos: `shopping`
--

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `ads`
--

CREATE TABLE `ads` (
  `id_ads` int(11) NOT NULL,
  `id_producto` int(11) NOT NULL,
  `ads` varchar(100) COLLATE utf8_spanish_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

--
-- Volcado de datos para la tabla `ads`
--

INSERT INTO `ads` (`id_ads`, `id_producto`, `ads`) VALUES
(1, 1, 'J.Doe'),
(2, 2, 'Dani'),
(3, 3, 'mel');

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `orden`
--

CREATE TABLE `orden` (
  `id_orden` int(11) NOT NULL,
  `id_producto` int(11) NOT NULL,
  `estadodelpedido` varchar(50) COLLATE utf8_spanish_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

--
-- Volcado de datos para la tabla `orden`
--

INSERT INTO `orden` (`id_orden`, `id_producto`, `estadodelpedido`) VALUES
(2, 1, 'pagado'),
(3, 1, 'pagado'),
(4, 1, 'pagado'),
(5, 2, 'pagado'),
(6, 2, 'pagado'),
(7, 3, 'pagado');

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `pais`
--

CREATE TABLE `pais` (
  `id_pais` int(11) NOT NULL,
  `id_producto` int(11) NOT NULL,
  `pais` varchar(100) COLLATE utf8_spanish_ci NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

--
-- Volcado de datos para la tabla `pais`
--

INSERT INTO `pais` (`id_pais`, `id_producto`, `pais`) VALUES
(2, 1, 'Mexico'),
(3, 2, 'España'),
(5, 3, 'sweden');

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `producto`
--

CREATE TABLE `producto` (
  `id_producto` int(11) NOT NULL,
  `producto` varchar(255) COLLATE utf8_spanish_ci NOT NULL,
  `activo` tinyint(1) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

--
-- Volcado de datos para la tabla `producto`
--

INSERT INTO `producto` (`id_producto`, `producto`, `activo`) VALUES
(1, 'Nike', 1),
(2, 'Adidad', 1),
(3, 'gel', 1);

-- --------------------------------------------------------

--
-- Estructura de tabla para la tabla `vendedor`
--

CREATE TABLE `vendedor` (
  `id_vendedor` int(11) NOT NULL,
  `id_producto` int(11) NOT NULL,
  `calidad_de_entrega` int(11) NOT NULL,
  `id_usuario` int(11) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_spanish_ci;

--
-- Volcado de datos para la tabla `vendedor`
--

INSERT INTO `vendedor` (`id_vendedor`, `id_producto`, `calidad_de_entrega`, `id_usuario`) VALUES
(1, 1, 4, 1),
(2, 2, 5, 2),
(3, 3, 3, 6);

--
-- Índices para tablas volcadas
--

--
-- Indices de la tabla `ads`
--
ALTER TABLE `ads`
  ADD PRIMARY KEY (`id_ads`);

--
-- Indices de la tabla `orden`
--
ALTER TABLE `orden`
  ADD PRIMARY KEY (`id_orden`);

--
-- Indices de la tabla `pais`
--
ALTER TABLE `pais`
  ADD PRIMARY KEY (`id_pais`);

--
-- Indices de la tabla `producto`
--
ALTER TABLE `producto`
  ADD PRIMARY KEY (`id_producto`);

--
-- Indices de la tabla `vendedor`
--
ALTER TABLE `vendedor`
  ADD PRIMARY KEY (`id_vendedor`);

--
-- AUTO_INCREMENT de las tablas volcadas
--

--
-- AUTO_INCREMENT de la tabla `ads`
--
ALTER TABLE `ads`
  MODIFY `id_ads` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=4;
--
-- AUTO_INCREMENT de la tabla `orden`
--
ALTER TABLE `orden`
  MODIFY `id_orden` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=8;
--
-- AUTO_INCREMENT de la tabla `pais`
--
ALTER TABLE `pais`
  MODIFY `id_pais` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=6;
--
-- AUTO_INCREMENT de la tabla `producto`
--
ALTER TABLE `producto`
  MODIFY `id_producto` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=4;
--
-- AUTO_INCREMENT de la tabla `vendedor`
--
ALTER TABLE `vendedor`
  MODIFY `id_vendedor` int(11) NOT NULL AUTO_INCREMENT, AUTO_INCREMENT=4;
/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;

El resultado que obtengo:

introducir la descripción de la imagen aquí

Otto
  • 632
  • 5
  • 22
  • 48
  • 1
    Sospecho que esto puedes hacerlo con una sola consulta, uniendo las tablas mediante `JOIN` en un modelo de datos relacional. De ese modo envías una sola consulta a la BD y obtienes en ella todos los datos necesarios. No es tan complicado como puede parecer. Si te interesa y tienes la libertad de modificar la base de datos podemos intentar una solución mejor, pero deberías aportar en la pregunta cómo están constituidas tus tablas y un ejemplo del resultado final que quieres obtener. – A. Cedano Oct 21 '17 at 21:48
  • Hola @A.Cedano añadí lo que me has sugerido, es correcto los datos son relacionados con el mismo producto principal llamados desde su id del producto pero todo esto solo es una prueba funciona bien realizando consultas dentro de un `while` pero me he basado a los comentarios negativos si tienes más de 3 opciones como poder hacer de este algo más eficaz para no perder el rendimiento de la aplicación mucho mejor :) ***recordando que aveces existen otras consultas que no son datos relacional*** se debe tener algunos peros y otros más fácil tener varias carta bajo la manga para poner en practica. – Otto Oct 22 '17 at 05:36
  • La respuesta de @DBulten me parece interesante, siempre y cuando la consulta funcione (habría que probarlo). Por otra parte, la *optimización* no depende solamente del código. Podemos enumerar algunos aspectos de optimización. *1. Código*: a. Evitar los `SELECT *`, b. Mientras menos peticiones hagas a la BD, mejor (uso de `JOIN`, etc), c. Para consultar la BD yo cambiaría a PDO. *2. Base de datos*: a. Diseño adecuado que evite datos redundantes; b. Tablas debidamente indexadas... *3. DOM*: a. Verificar que no haya librerías o archivos CSS o utros innecesarios o repetidos, b. Optimizar JS ... – A. Cedano Oct 24 '17 at 11:21
  • @A.Cedano estuve haciendo pruebas en `localhost`, al principio me estaba dando problemas usar `count`, al investigar un poco vi que se podría crear una subconsulta, que al final dio el resultado esperado :). Vi un ejemplo de la subquery en https://stackoverflow.com/questions/16806837/mysql-count-with-inner-join-of-two-tables-average-join – Diablo Oct 24 '17 at 18:13
  • @D.Bulten sería interesante que la ejecutes con [`EXPLAIN`](https://es.stackoverflow.com/q/53779/29967) para verificar si se está ejecutando de forma óptima. – A. Cedano Oct 24 '17 at 18:15
  • @A.Cedano creí una `Base de Datos` rápido, sin llaves `foreigns` etc., pero ahora cuando pueda añado el resultado de `explain` a mi respuesta. – Diablo Oct 24 '17 at 18:21
  • @A.Cedano Yo creo que no estaría demás explicar las contras y desventajas de hacer consultas dentro de un `bucle while` entre otras recomendaciones que sean necesarias hacer enriquecer un poco las respuesta para esta pregunta muy necesaria creo yo no, y no estaría demás su aporte en **PDO** como lo comenta para futuros lectores que quizás deseen esa opción de desarrollo, saludos! – Otto Oct 30 '17 at 05:06

2 Answers2

7

Como ya te han comentado tus consultas anidadas consumen muchos recursos y memoria.

Hacer INNER JOIN no resuelve tu problema ya que estarías dejando de traer los productos que no tengan país,vendedor o ads.

Ademas Al aplicar el LIMIT 5 se reducirían todos los resultados a 5 y en caso que la cardinalidad entre tablas no sea 1-1 el resultado seria incorrecto.

Una posible solución seria hacer una subconsulta de productos, aplicar el LIMIT 5 y con el resultado hacer un LEFT JOIN posteriormente para saber el numero de compras agrupar los resultados y hacer un COUNT con y obtener las mismas.

El problema de esto es que obtendrás un solo conjunto de resultados donde la descripción de los productos se repetirá de acuerdo a los países,ads, y vendedores (si la cardinalidad no es 1-1). En ese caso en el while validaríamos imprimir una vez por cada articulo su descripción así como validar los vendedores,países y ads para imprimir sus correspondientes de acuerdo a cada producto.

Como no describes que haces con los países, ads, y vendedores te puse las opciones pero las deje sin código.

aquí el ejemplo:

<?php
$stmt = $con->prepare("SELECT p.id_producto,
                              p.producto,
                              a.id_ads,
                              a.ads,
                              v.id_vendedor,
                              v.calidad_de_entrega,
                              pais.id_pais,
                              pais.pais,
                              COUNT(o.id_producto) AS 'compras'
                      FROM (SELECT id_producto,producto FROM producto WHERE activo = ? ORDER BY id_producto ASC LIMIT ?) p
                        LEFT JOIN orden o ON o.id_producto = p.id_producto
                        LEFT JOIN ads a ON a.id_producto = p.id_producto
                        LEFT JOIN vendedor v ON v.id_producto = p.id_producto
                        LEFT JOIN pais ON pais.id_producto = p.id_producto
                    WHERE o.estadodelpedido = ?
                    GROUP BY  p.id_producto,
                              p.producto,
                              a.id_ads,
                              a.ads,
                              v.id_vendedor,
                              v.calidad_de_entrega,
                              pais.id_pais,
                              pais.pais
                    ORDER BY p.id_producto,
                              p.producto,
                              a.id_ads,
                              a.ads,
                              v.id_vendedor,
                              v.calidad_de_entrega,
                              pais.id_pais,
                              pais.pais");





if ($stmt === false) {

  echo "Error al preparar la consulta";
  exit(0);
}

$stmt->bind_param("isi",$activo,$estadodelpedido,$limit);
$estadodelpedido = "pagado";
$activo = "1";
$limit = 5;

$stmt->execute();
$stmt->store_result();
if ($stmt->num_rows>0) {


  $stmt->bind_result($idProducto,
                     $producto,
                     $idAds,
                     $ads,
                     $idVendedor,
                     $calidadEntrega,
                     $idPais,
                     $pais,
                     $comprasdeesteproducto,
                     $comprasdeesteproducto);



  $productoAnterior = null;
  $productoActual = null;
  $adsActual = null;
  $adsAnterior = null;
  $vendedorActual = null;
  $vendedorAnterior = null;
  $paisActual = null;
  $paisAnterior = null;

  while ($stmt->fetch()) {


    $nuevoProducto = (empty($productoActual)  || $productoActual !== $idProducto);
    /* Evitamos imprimir varias veces el mismo producto */
    if ($nuevoProducto) { // Si es el producto anterior es diferente al actual

      echo "<h1>$producto</h1>";
      echo "este producto se compro $comprasdeesteproducto veces";

      $productoAnterior = $productoActual;
      $productoActual = $idProducto;
      /* Se inicializan las variables por que el producto cambio */
      $adsActual = null;
      $adsAnterior = null;
      $vendedorActual = null;
      $vendedorAnterior = null;
      $paisActual = null;
      $paisAnterior = null;
    }



    $nuevoAds = (empty($adsActual)  || $adsAnterior !== $idAds);
    if ($nuevoAds) {

      if ($nuevoProducto) {

          /* Cambio el ads y el producto. Primer ds del producto*/

      } else {

        /* Cambio el ads pero el producto sigue siendo el mismo */
      }

      $adsAnterior = $adsActual;
      $adsActual = $idAds;
    }


    $nuevoVendedor = (empty($VendedorActual)  || $vendedorAnterior !== $idVendedor);
    if ($nuevoVendedor) {

      if ($nuevoProducto) {

          /* Cambio el vendedor y el producto. Primer vendedor del producto */

      } else {

        /* Cambio el vendedor pero el producto sigue siendo el mismo */
      }

      $vendedorAnterior = $vendedorActual;
      $vendedorActual = $idVendedor;
    }


    $nuevoPais = (empty($VendedorPais)  || $vendedorPais !== $idPais);
    if ($nuevoPais) {

      if ($nuevoProducto) {

          /* Cambio el pais y el producto. Primer pais del producto */

      } else {

        /* Cambio el pais pero el producto sigue siendo el mismo */
      }

      $paisAnterior = $paisActual;
      $paisActual = $idPais;

    }

}
} else {
   echo "No existen registros";
}
Sergio Cauich
  • 1,527
  • 6
  • 8
  • Aun así, si pensamos por lógica un `inner join` también podría servir, porque un producto siempre va tener un país de origen, siempre va tener un vendedor, lo único cuando podría dejar de traer un producto si la eficiencia de la entrega no es obligatoria al hacer la compra. – Diablo Oct 27 '17 at 15:28
  • Es correcto. El **INNER JOIN** funcionaria si todas sus relaciones son obligatorias y están previamente validadas, pero imaginemos el caso. en el cual un articulo tenga mas de un vendedor, mas de un **ads** o mas de un país de origen. El conjunto de resultados repetiría el producto. Por ejemplo si pack 1 viene de 3 países y tiene 2 vendedores distintos, el conjunto de resultados con el **LIMIT** en la consulta general unicamente retornaría el **pack 1**. ahora con mi planteamiento el poner el **Limit 5** en una subconsulta traemos siempre 5 productos diferentes. ya sea 1-1 o 1-n o m-n. – Sergio Cauich Oct 27 '17 at 15:52
  • @d-bulten. de hecho según las imágenes de la BD a menos que **id_producto** sea **UNIQUE** en las tablas vendedor,ads,país. un producto puede pertenecer a mas de un vendedor, un ads, un país. Lo cual tambien me parece raro ya que a la inversa un vendedor solo puede vender un producto. lo normal seria hacer una relacion n-m, con tablas intermedias de relación. – Sergio Cauich Oct 27 '17 at 16:07
  • Si vamos más allá de la pregunta, si tienes razón, si supongamos, pero tal cual está planteada, yo solo veo un país, un anunciante, el total de numero de compras y la eficiencia de la entrega. Si nos ponemos a pensar que quizás lo tiene así, también se podría guardar más vendedores en el mismo registro como un array (vendedor1, vendedor2, Etc.) y así evitar varios registros para el mismo producto y optimizar más la Base de Datos. En la pregunta, yo no veo que haya registros repetido con el mismo id_producto en adds, pais, etc. Se podría interpretar de varias formas. – Diablo Oct 27 '17 at 16:21
  • @d-bulten. Como Comente hace un momento. La solución que ofreces no es incorrecta solo no es general. y que otros registros hay en la base de datos ambos lo ignoramos. Bien como mencionas mi respuesta puede ir mas allá de la pregunta. Pero si analizas el código que ponen de ejemplo ese también funcionaria en n-m. Por ello respondí de esta forma. Sin embargo cual respuesta es mas satisfactoria es cuestión de quien pregunta. Saludos – Sergio Cauich Oct 27 '17 at 16:32
  • @SergioCauich Existe un problema en realizar pruebas, muestra el siguiente mensaje Fatal error: Uncaught Error: Call to a member function bind_param() on boolean in `$stmt->bind_param("is",$activo,$estadodelpedido);` – Otto Oct 30 '17 at 05:09
  • @SergioCauich Vamos aclarar ambas parte en mi pregunta se basa a dos preguntas para ser verdad ***Por qué pregunte como hacer consultas con datos relacionados y por otra parte mencioné que pasa si no fuera así*** ambas respuesta son correctas individualmente y si sucede lo comentado por ejemplo borre el país de un `id` de un producto y este ya no se muestra ese sería una contra pero se basa a que son productos relacionados en ese sentido no se presentaran esos problemas, ahora si no fuera datos relacionados su pregunta esta también correcta y es correcta porque tambien pregunte en mi pregunta – Otto Oct 30 '17 at 05:15
  • @SergioCauich Ambas preguntas son ideales sin pero alguno, solo que muestra el error mencionado no ejecuta los resultados, esta correcta la base `i` numérico `s` letras entonces creo que ya depende el error de la consulta pero a decir verdad ahí si me pierdo, ambas preguntas son correctas e interesantes se pueden dar uso de alguna manera como relacionados cuando son datos fijos y cuando no lo son. – Otto Oct 30 '17 at 05:19
  • @SergioCauich Si existirá problema por el `limit` entonces lo más sano será seguir realizando las consultas dentro de un `bucle while` no siempre el `limit` será `5` puede ser `3` o `10` y puede ser igual más adelante una paginación de resultados donde ahí se complica más entonces, debido a que el `limit` cambiara constantemente y más que todo siempre será un valor intervalo no fijo ... – Otto Oct 30 '17 at 10:37
6

Para obtener datos adicionales podrías usar SQL JOINS y así asociar datos en una misma sentencia.

Para entender mejor la lógica de la sentencia en mi ejemplo he puesto el nombre completa de cada tabla antes de las columnas que deseas obtener desde la Base de datos, de esta manera sabrás diferenciar bien cada dato que deseas obtener desde diferentes tablas asociadas con JOINS.

//Datos a obtener desde la Base de datos
SELECT producto.id_producto, producto.producto, ads.ads, vendedor.calidad_de_entrega, pais.pais,

Ahora para calcular el total de compras debes añadir otro SELECT y podrías usar count para calcular el total de compras, ya que solo debe escoger donde su ID sea igual.

//Calculamos el número de compras.
(
  SELECT COUNT(*) 
  FROM `orden`
  WHERE producto.id_producto = orden.id_producto AND estadodelpedido=?
)

En los INNER JOIN LEFT JOIN simplemente se compara el mismo id que usas como identificador y así escoger correctamente el dato.

Si supongamos que siempre va existir un vendedor y un país de origen, sobra con INNER JOIN.

//Ejemplo de comparación.
INNER JOIN `ads` ON producto.id_producto = ads.id_producto

En caso que no es obligatorio la votación de la calidad de entrega, es decir, podría ocurrir que no exista un registro, usas un LEFT JOIN, de esta manera aunque no existe registro, va a ejecutar la sentencia de igual forma.

//Ejemplo de comparación.
LEFT JOIN `vendedor` ON producto.id_producto = vendedor.id_producto

Un posible ejemplo:

<?php    
//Sentencia
$sql = "SELECT producto.id_producto, producto.producto, ads.ads, vendedor.calidad_de_entrega, pais.pais,
        (
            SELECT COUNT(*) 
            FROM `orden`
            where producto.id_producto = orden.id_producto AND estadodelpedido=?
        )
        FROM `producto`   
  INNER JOIN `ads` ON producto.id_producto = ads.id_producto
  LEFT JOIN `vendedor` ON producto.id_producto = vendedor.id_producto
  INNER JOIN `pais` ON producto.id_producto = pais.id_producto
       WHERE producto.activo=? ORDER BY producto.id_producto limit 5";

$stmt = $con->prepare($sql);

$stmt->bind_param("si",$estadodelpedido,$activo);

$estadodelpedido = 'pagado';
$activo = "1";

$stmt->execute();
$stmt->store_result();

if ($stmt->num_rows>0) {
  $stmt->bind_result($id_producto, $producto, $ads, $calidad_de_entrega, $pais, $orders);
  while ($stmt->fetch()) {
    echo "<h1>$producto</h1>";    
    echo "Anunciante: $ads<br />";
    echo "$orders personas compraron este producto.<br />";
    echo "Pais: $pais<br />";
    //No existe registro de calidad de entraga
    if (empty($calidad_de_entrega)) {
       echo "0 votación de eficiencia de entrega.";
    } else { //Existe calidad de entrega
       echo "Eficiencia en la entrega $calidad_de_entrega / 5 (0)";
    }    
  }
} else {
   echo "No existen registros";
}    
?>
Diablo
  • 6,417
  • 2
  • 21
  • 40
  • no resuelve el problema porque limitas en la consulta el resultado final a 5 registros y no es lo que la persona busca – Strife86 Oct 24 '17 at 18:26
  • @Strife86 A decir verdad no haz visualizado la pregunta bien, la consulta principal tiene un `limit 5` esto no es un problema a la pregunta... – Josues Oct 24 '17 at 18:30
  • @D.Bulten El procedimiento es perfecto para productos relacionados cuando existen valores fijos está muy bien, solo que se debe tener mucho cuidado porque al no existir dato importante relacionado este ya no mostrará en el listado el producto, es un mensaje como nota de advertencia pero de ahí es correcto ambas preguntas son ideales. – Otto Oct 30 '17 at 05:23
  • @J.Doe sí, hay que tener en cuenta que en los `INNER JOIN` si no existe ningún registro la sentencia no se va ejecutar, se podría evitar usando `LEFT JOIN` en su caso, si tienes más datos no obligatorio, ya que así aunque no existe registro va continuar la sentencia. Creí la sentencia pensando que el *país de origen* y el *anunciante* siempre va ser obligatorio, sino es así el caso podrías aplicarles lo mencionado un `LEFT JOIN` también. Un saludo. – Diablo Oct 30 '17 at 10:47
  • 1
    @D.Bulten Si es perfecto amigo :) es un buen tema para estudiarlo... Saludos! – Otto Oct 30 '17 at 10:51