Obracaj limit 61 JOIN tabeli w MySQL, zagnieżdżając podzapytania wewnątrz siebie
Zorientowałem się, że możesz ominąć limit łączenia tabeli 61 w MySQL, używając podkwerend.https://stackoverflow.com/a/20134402/2843690
Próbuję wymyślić, jak to zrobićz łatwością użyj tego w programie, nad którym pracuję, aby uzyskać szczegółową listę produktów z Magento (ale myślę, że odpowiedź na to pytanie może dotyczyć wielu sytuacji, w których zaangażowany jest eav). Tabele, które należy połączyć, wyglądają mniej więcej tak:
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 |
+----------+-----------+-------------------+
Program, który piszę, wygenerował kwerendy sql, które wyglądały mniej więcej tak:
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)
;
Pisanie kodu w celu wygenerowania zapytania było stosunkowo łatwe, a zapytanie było dość łatwe do zrozumienia; jednak dość łatwo jest trafić na limit łączenia przy stole 61, co zrobiłem z moimi prawdziwymi danymi. Wierzę, że matematyka mówi, że 21 atrybutów typu całkowitego przekroczy limit, a to jeszcze zanim zacznę dodawać atrybuty varchar, text i decimal.
Rozwiązaniem, które wymyśliłem, było użycie podzapytań w celu pokonania limitu 61 tabel.
Jednym ze sposobów jest zgrupowanie złączeń w podkwerendach 61 złączeń. A potem wszystkie grupy zostaną połączone. Myślę, że mogę dowiedzieć się, jak powinny wyglądać kwerendy sql, ale trudno napisać kod generujący zapytania. Istnieje jeszcze jeden (choć teoretyczny) problem polegający na tym, że można ponownie naruszyć limit tabeli 61, jeśli jest wystarczająco dużo atrybutów. Innymi słowy, jeśli mam 62 grupy po 61 tabel, wystąpi błąd MySQL. Oczywiście można to obejść, grupując grupy grup w 61. Ale to jeszcze bardziej utrudnia pisanie i zrozumienie kodu.
Myślę, że rozwiązaniem, które chcę, jest zagnieżdżanie podkwerend w podzapytaniach tak, że każde podzapytanie używa pojedynczego łączenia 2 tabel (lub jednej tabeli i jednego podzapytania). Intuicyjnie wydaje się, że kod byłby łatwiejszy do napisania dla tego rodzaju zapytań. Niestety, myślenie o tym, jak powinny wyglądać te zapytania, powoduje, że mój mózg boli. Dlatego potrzebuję pomocy.
Jak wyglądałoby takie zapytanie MySQL?