Trabaje alrededor del límite JOIN de la tabla 61 en MySQL anidando subconsultas entre sí
Me di cuenta de que puedes superar el límite de 61 tablas unidas en MySQL usando subconsultas.https://stackoverflow.com/a/20134402/2843690
Estoy tratando de averiguar cómofácilmente use esto en un programa en el que estoy trabajando para obtener una lista detallada de los productos de Magento (pero creo que la respuesta a esta pregunta podría aplicarse a muchas situaciones en las que está involucrado eav). Las tablas que deben unirse se ven algo así:
catalog_product_entity
+-----------+----------------+
| entity_id | entity_type_id |
+-----------+----------------+
| 1 | 4 |
| 2 | 4 |
| 3 | 4 |
| 4 | 4 |
| 5 | 4 |
| 6 | 4 |
| 7 | 4 |
| 8 | 4 |
| 9 | 4 |
+-----------+----------------+
catalog_product_entity_int
+----------+----------------+--------------+-----------+-------+
| value_id | entity_type_id | attribute_id | entity_id | value |
+----------+----------------+--------------+-----------+-------+
| 1 | 4 | 2 | 1 | 245 |
| 2 | 4 | 3 | 1 | 250 |
| 3 | 4 | 4 | 1 | 254 |
| 4 | 4 | 2 | 2 | 245 |
| 5 | 4 | 3 | 2 | 249 |
| 6 | 4 | 4 | 2 | 253 |
| 7 | 4 | 2 | 3 | 247 |
| 8 | 4 | 3 | 3 | 250 |
| 9 | 4 | 4 | 3 | 254 |
+----------+----------------+--------------+-----------+-------+
eav_attribute
+--------------+----------------+----------------+--------------+
| attribute_id | entity_type_id | attribute_code | backend_type |
+--------------+----------------+----------------+--------------+
| 1 | 4 | name | varchar |
| 2 | 4 | brand | int |
| 3 | 4 | color | int |
| 4 | 4 | size | int |
| 5 | 4 | price | decimal |
| 6 | 4 | cost | decimal |
| 7 | 4 | created_at | datetime |
| 8 | 3 | name | varchar |
| 9 | 3 | description | text |
+--------------+----------------+----------------+--------------+
eav_attribute_option
+-----------+--------------+
| option_id | attribute_id |
+-----------+--------------+
| 245 | 2 |
| 246 | 2 |
| 247 | 2 |
| 248 | 3 |
| 249 | 3 |
| 250 | 3 |
| 251 | 4 |
| 252 | 4 |
| 253 | 4 |
| 254 | 4 |
+-----------+--------------+
eav_attribute_option_value
+----------+-----------+-------------------+
| value_id | option_id | value |
+----------+-----------+-------------------+
| 15 | 245 | Fruit of the Loom |
| 16 | 246 | Hanes |
| 17 | 247 | Jockey |
| 18 | 248 | White |
| 19 | 249 | Black |
| 20 | 250 | Gray |
| 21 | 251 | Small |
| 22 | 252 | Medium |
| 23 | 253 | Large |
| 24 | 254 | Extra Large |
+----------+-----------+-------------------+
El programa que estoy escribiendo generó consultas de SQL que se parecían a esto:
SELECT cpe.entity_id
, brand_int.value as brand_int, brand.value as brand
, color_int.value as color_int, color.value as color
, size_int.value as size_int, size.value as size
FROM catalog_product_entity as cpe
LEFT JOIN catalog_product_entity_int as brand_int
ON (cpe.entity_id = brand_int.entity_id
AND brand_int.attribute_id = 2)
LEFT JOIN eav_attribute_option as brand_option
ON (brand_option.attribute_id = 2
AND brand_int.value = brand_option.option_id)
LEFT JOIN eav_attribute_option_value as brand
ON (brand_option.option_id = brand.option_id)
LEFT JOIN catalog_product_entity_int as color_int
ON (cpe.entity_id = color_int.entity_id
AND color_int.attribute_id = 3)
LEFT JOIN eav_attribute_option as color_option
ON (color_option.attribute_id = 3
AND color_int.value = color_option.option_id)
LEFT JOIN eav_attribute_option_value as color
ON (color_option.option_id = color.option_id)
LEFT JOIN catalog_product_entity_int as size_int
ON (cpe.entity_id = size_int.entity_id
AND size_int.attribute_id = 4)
LEFT JOIN eav_attribute_option as size_option
ON (size_option.attribute_id = 4
AND size_int.value = size_option.option_id)
LEFT JOIN eav_attribute_option_value as size
ON (size_option.option_id = size.option_id)
;
Fue relativamente fácil escribir el código para generar la consulta, y la consulta fue bastante fácil de entender; sin embargo, es bastante fácil alcanzar el límite de combinación de 61 mesas, lo que hice con mis datos de la vida real. Creo que la matemática dice que 21 atributos de tipo entero irían más allá del límite, y eso es antes de que incluso comience a agregar atributos varchar, de texto y decimales.
Así que la solución que se me ocurrió fue usar subconsultas para superar el límite de 61 tablas.
Una forma de hacerlo es agrupar las combinaciones en subconsultas de 61 combinaciones. Y entonces todos los grupos se unirían. Creo que puedo averiguar cómo deberían ser las consultas de SQL, pero parece difícil escribir el código para generar las consultas. Hay un problema adicional (aunque teórico) en el que se podría volver a infringir el límite de la tabla 61 si hubiera atributos suficientes. En otras palabras, si tengo 62 grupos de 61 tablas, habrá un error de MySQL. Obviamente, uno podría evitar esto al agrupar los grupos de grupos en 61. Pero eso hace que el código sea aún más difícil de escribir y entender.
Creo que la solución que quiero es anidar subconsultas dentro de subconsultas, de manera que cada subconsulta esté usando una combinación única de 2 tablas (o una tabla y una subconsulta). Intuitivamente, parece que el código sería más fácil de escribir para este tipo de consulta. Desafortunadamente, pensar en cómo deberían ser estas consultas es hacer que me duela el cerebro. Por eso necesito ayuda.
¿Cómo sería una consulta MySQL de este tipo?