Ik slaag er niet in om een "boomstructuur" te laten werken in PHP7
Ik wil namelijk mijn menu dynamisch houden en dat lukte in php5.6
Maar om de een of andere reden wil deze niet in php7
De afzonderlijke queries werken echter wel....
maar als ik de geneste query wil uitvoeren dan toont hij enkel de eerste parent categorie.
Doe ik de geneste query niet dan toont hij wel alle parent categoriën
is daar een reden voor?
<?
$sql_q_salon ="SELECT
*
FROM
shop_produkt_type
WHERE
sh_pt_onderdeel_van = 9
ORDER BY
sh_pt_volgorde";
$r_list = mysqli_query($con, $sql_q_salon);
while($salon = mysqli_fetch_assoc($r_list))
{
echo'<ul ';
echo'class="column" ';
echo'>
<li class="column-title">'.$salon['sh_pt_naam_nl'].' </li>
' ;
// als ik de volgende query uitschakel dan heeft hij wel alle bovenliggende categorien weer, schakel ik deze in dan heeft hij enkel de regels van de eerste categorie weer
$q_list ="SELECT
*
FROM
shop_produkt_type
WHERE
sh_pt_onderdeel_van = '".$salon['sh_pt_id']."'
ORDER BY
sh_pt_volgorde
";
$r_list = mysqli_query($con, $q_list) or die (mysqli_error());
while($list = mysqli_fetch_assoc($r_list))
{
echo'<li><a href="/?view=category&id='.$list['sh_pt_id'].'">'.$list['sh_pt_naam_nl'].'</a></li>
';
}
echo'</ul>
';
}
?>
Ik zie niet echt een reden waarom het in PHP 7 niet zou werken?
Heb je al je foutmeldingen bovenaan je script aangezet met:
<?php
error_reporting(E_ALL);
ini_set('display_errors',true);
?>
Verder is een while-loop in een while-loop niet echt bevorderlijk. Ik zou meer aan een goede recursie denken, omdat je queries spaarzaam moet gebruiken.
Misschien wordt het in jouw geval iets ingewikkelder omdat het enige verbindende attribuut sh_pt_onderdeel_van lijkt te zijn. Je zult dus alle onderdelen op moeten halen en dan de subboom uitlezen van een specifiek (hoofd)onderdeel.
En dit gaat waarschijnlijk alleen (direct) werken als de subonderdelen zijn toegevoegd na de hoofdonderdelen, zodat een subonderdeel altijd een hoger id heeft dan het hoofdonderdeel. Je kunt dan oplopend sorteren op onderdeel-id en dan kun je in PHP een soort van geneste datastructuur uitrollen.
Als hier niet aan voldaan is is er nog geen kind overboord maar dan wordt het bouwen van de boom waarschijnlijk wel wat lastiger (kun je in ieder geval niet meer on the fly doen dan waarschijnlijk) omdat de elementen daar dan niet in de goede volgorde gezet kunnen worden.
Vaak zit in bomen een volgorde van elementen van eenzelfde niveau en hebben elementen een voorgeschreven diepte. Deze twee zaken helpen je om zo'n datastructuur sneller op te tuigen. Maar deze hulpstukken zijn dus niet altijd van toepassing. Misschien is het het overwegen waard om van een (geassembleerd) product een aparte boom te maken? Dus elk product heeft een eigen boom? Dan kun je die concepten (volgorde, (en in ieder geval, en in zekere zin, belangrijker de) diepte) weer wel toepassen.
Deze oplossing is ook nog steeds maar "twee niveau's diep"? Dit werkt zolang een produkt geen sub-sub-subonderdelen heeft.
Ook hier doe je in wezen wat ik in een andere thread tegen die topicstarter zei: je combineert hier verschillende dingen tegelijkertijd:
- het bouwen van de dataset
- het filteren van de items waarin je geïnteresseerd bent
- het weergeven van de relevante items
Als je dit nu eens opsplitst door:
- alle items op te halen met één query
- je een recursieve PHP-functie bouwt die de relevante items ophaalt (de PHP-kant heeft op dit moment al alle informatie uit de database, er zijn dus geen extra queries meer nodig)
- je (nog) een recursieve PHP-functie schrijft die hier een boom van maakt
De voordelen hiervan zijn:
- je schrijft herbruikbare code, waarbij elk onderdeel een (één) specifieke taak verricht, ik kan mij best voorstellen dat je andere bomen wilt kunnen bouwen en/of wilt kunnen filteren in deze data-structuur
- door deze eenvoud kun je beter het overzicht houden doordat je deze taken splitst (separation of concerns)
- deze aanpak helpt bij het leren om "complexe" problemen op te splitsen in kleinere deelproblemen zodat je stapsgewijs naar een oplossing werkt, in plaats van te pogen om dit rechtstreeks te doen, de volgende keer dat je zoiets doet zul je dan waarschijnlijk weer code op maat moeten schrijven voor dat specifieke probleem en dat is zonde van de tijd
En wat je hier dus effectief doet is het "probleem" overhevelen van de database naar PHP, zoals eerder aangehaald zijn queries redelijk dure operaties, dus hoe minder queries je uitvoert, hoe beter. PHP kan ook een heleboel werk verzetten door wat simpele datastructuren te bouwen in de vorm van (geneste) arrays en wat hulpfuncties.
Er is mogelijk geen garantie dat de parents zijn toegevoegd voor de children, daarom is het misschien veiliger om eerst alle resultaten op te halen, en dan pas alles aan elkaar te knopen.
