[PHP/MySQL] Database model uitkomst

[Intheweb]

Momenteel ben ik druk bezig met het maken van een programma waarmee activiteiten kunnen worden beheerd.

Hiervan heb ik een diagram gemaakt in UML:


Het probleem waar ik nu tegen aanloop, met het inplementeren in de website, is dat ik een ongelovelijke hoeveelheid aan queries krijg.

Want wat ik nu heb is een query die in php weer een andere query aanroept om de volgende op te halen, etc.
In het kort: dit is een query verslindende situatie.

Nu haal ik de 'act_places' op met een LEFT JOIN want dat is een 1 op 1 relatie.
Maar hoe krijg ik een '1 op meer' netjes uit de database rollen?

Wie kan mij in de juiste richting duwen?

[SchizoDuckie]

ik gebruik meestal een left join, en je kan meerdere joins doen binnen 1 query

[Intheweb]

SchizoDuckie schreef op maandag 20 augustus 2007 @ 13:48:
ik gebruik meestal een left join, en je kan meerdere joins doen binnen 1 query

True, maar dan krijg ik 1 hele lang rij met informatie.

Dan zie ik bijv. de informatie van 'act_category' 10 keer voorbij komen omdat het aantal rijen van 'act_item' 10 is. Terwijl ik maar 1 rij terug krijg van 'act_category'

Leg ik het zo goed uit?

[Verwijderd]

SchizoDuckie schreef op maandag 20 augustus 2007 @ 13:48:
ik gebruik meestal een left join, en je kan meerdere joins doen binnen 1 query

Dat hangt van de MySQL versie af, die de TS gebruikt. By MySQL >= 4 kun je subqueries gebruiken.
Dus TS: Welke MySQL versie gebruik je?

TS: Leg eens uit welke gegevens je uit de database wilt halen?

Want wat ik nu heb is een query die in php weer een andere query aanroept om de volgende op te halen, etc.
In het kort: dit is een query verslindende situatie.

Welke query roept welke query dan aan?

Nu haal ik de 'act_places' op met een LEFT JOIN want dat is een 1 op 1 relatie.
Maar hoe krijg ik een '1 op meer' netjes uit de database rollen?

Kun je bovenstaand nog een beetje uitleggen?

[Creepy]

Een join kan je prima gebruiken voor het ophalen van gegevens uit tabellen met een 1:n relatie. Kan je eens aangeven hoe je nu je JOIN doet? Ik heb het idee dat je geen of een verkeerde JOIN conditie meegeeft.

Je kan in principe al je tabellen met 1 query bevragen.

[ Voor 12% gewijzigd door Creepy op 20-08-2007 15:50 ]

[Intheweb]

Verwijderd schreef op maandag 20 augustus 2007 @ 15:35:
[...]

Dat hangt van de MySQL versie af, die de TS gebruikt. By MySQL >= 4 kun je subqueries gebruiken.
Dus TS: Welke MySQL versie gebruik je?

Momenteel draait de server van ons nog op versie 4.0. Hopelijk dat er binnenkort verandering in komt met een nieuwe MySQL server.

TS: Leg eens uit welke gegevens je uit de database wilt halen?

Ik moet op 1 pagina alle activiteiten tevoorschijn toveren die in een groep staan.
Maar omdat de tijden per plek, plaats en dergelijke aan verandering onderhevig zijn is er gekozen om alles opgesplitst neer te zetten in de database.

Welke query roept welke query dan aan?

Momenteel is het zo dat het zo gaat:

• act_category laat alle categorieen binnen de groep zien.
• Binnen de act_category word weer een query gedraaid om de items (act_item) op te halen.
• Binnen act_item worden de details (act_details) opgehaald.
• En daarna komen de tijden er nog eens bij (act_time).

Bij act_itemdetail word via een LEFT JOIN de plaats erbij gehaald.

Creepy schreef op maandag 20 augustus 2007 @ 15:49:
Een join kan je prima gebruiken voor het ophalen van gegevens uit tabellen met een 1:n relatie. Kan je eens aangeven hoe je nu je JOIN doet? Ik heb het idee dat je geen of een verkeerde JOIN conditie meegeeft.

Je kan in principe al je tabellen met 1 query bevragen.

True en daar ben ik mij van bewust. Maar: hoe krijg ik dan alles netjes in mijn PHP code zodat ik alles netjes kan onderverdelen in de pagina.

Want zover ik weet kan ik dus met een JOIN alleen hele rijen binnenkrijgen.

[Creepy]

Kan je aangeven welke query je nu gebruikt, wat het resultaat daarvan is en welk resultaat je nu eigenlijk wilt hebben en hoe je dat uiteindelijk in je PHP code gebruikt?
Je selecteert nu eenmaal rijen (records) uit tabellen, maar je kan natuurlijk zelf bepalen welke kolommen uit die rijen je wilt hebben.

[Intheweb]

Wederom true... maar ik moet alles hebben...

code:

SELECT * FROM act_category WHERE act_group_id = '1' ORDER BY name ASC
SELECT * FROM act_item WHERE act_category_id = '3' ORDER BY name ASC
SELECT * FROM act_itemdetail LEFT JOIN act_place ON act_itemdetail.act_place_id = act_place.id
SELECT * FROM act_itemdetail LEFT JOIN act_place ON act_itemdetail.act_place_id = act_place.id
SELECT * FROM act_item WHERE act_category_id = '1' ORDER BY name ASC
SELECT * FROM act_itemdetail LEFT JOIN act_place ON act_itemdetail.act_place_id = act_place.id
SELECT * FROM act_itemdetail LEFT JOIN act_place ON act_itemdetail.act_place_id = act_place.id
SELECT * FROM act_itemdetail LEFT JOIN act_place ON act_itemdetail.act_place_id = act_place.id

Dat zijn momenteel alle queries die eruit komen rollen. Er zit momenteel nog niet veel in de database, maar ben bang dat dit een querie verslindende pagina gaat worden.
Zelf ben ik namelijk niet gecharmeerd van meer dan 10 a 15 queries.

Losstaand van dit probleem zit ik daarom ook te kijken of ik bepaalde uitkomsten kan gaan cachen, want vaak zijn het dezelfde uitkomsten. En dan kun je die beter uit een cache trekken. Bijv. 1 keer ophalen met PHP en dan in een variable opslaan.

[ Voor 98% gewijzigd door Intheweb op 20-08-2007 16:45 ]

[Creepy]

Begin anders eens opnieuw met je queries.

De eerste is simpel: maak een query die 1 of meerdere categorien selecteerd. Die heb je al. Breidt deze uit met een JOIN zodat ook de bijbehorende items worden geselecteerd. Breidt die dan weer uit met een JOIN die je details selecteert, etc.

Met een beetje SQL kennis denk ik vrij simpel. Of zie je hier nog andere problemen mee? Ik heb het idee dat je niet precies begrijpt hoe een JOIN werk aangezien je deze nu alleen voor 1:1 relaties gebruikt terwijl ze prima inzetbaar zijn voor 1:n relaties.

offtopic:
Ik zet expres geen volledig uitgewerkte query neer om zo dom copy en paste gedrag tegen te gaan en je tot nadenken te dwingen

[ Voor 42% gewijzigd door Creepy op 20-08-2007 17:00 ]

[Intheweb]

Misschien denk ik te moeilijk... opzich heb ik de kennis van MySQL. Werk er al een aantal jaar mee, maar heb nooit JOINS hoeven te gebruiken.
Morgen duik ik er weer met frisse moed in: dus word vervolgd.

[edit] Owke wilde toch nog even er naar kijken en deze code in elkaar gezet:

code:

SELECT
*
FROM
act_category
Left Join act_group ON act_group.id = act_category.act_group_id
Left Join act_item ON act_category.id = act_item.act_category_id
Left Join act_itemdetail ON act_item.id = act_itemdetail.act_item_id
Left Join act_time ON act_time.act_itemdetail_id = act_itemdetail.act_item_id
Left Join act_place ON act_itemdetail.act_place_id = act_place.id
WHERE
act_category.id =  '1'

Ik krijg daarmee dus alle resultaten terug die ik wil... alleen alle informatie zit nu op 1 rij. Als in het volgende:

Niet echt handig bij mijn inziens om dit dan nog in bepaalde onderdelen te gaan verdelen voor een mooi overzichtje. En dat is nou net mijn blokkade iedere keer.

Creepy schreef op maandag 20 augustus 2007 @ 16:57:

offtopic:
Ik zet expres geen volledig uitgewerkte query neer om zo dom copy en paste gedrag tegen te gaan en je tot nadenken te dwingen

En daar ben ik het ook mee eens. Daarom zette ik in de OP ook "Wie kan mij in de juiste richting duwen?" Wil er wel van leren

[ Voor 80% gewijzigd door Intheweb op 20-08-2007 17:28 ]

[edeboeck]

Intheweb schreef op maandag 20 augustus 2007 @ 17:01:(knip)
Ik krijg daarmee dus alle resultaten terug die ik wil... alleen alle informatie zit nu op 1 rij.

Een kleinigheidje, maar aangezien je zelf aangeeft dat je wilt bijleren:
In een rekenblad spreken we van rijen en kolommen;
In een database spreken we van records en velden.

Intheweb schreef op maandag 20 augustus 2007 @ 17:01:(knip)
Niet echt handig bij mijn inziens om dit dan nog in bepaalde onderdelen te gaan verdelen voor een mooi overzichtje. En dat is nou net mijn blokkade iedere keer.

Nochtans is dat wel mogelijk hoor ... wat bedoel ik:
- je doet 1 call naar je db met bovenstaande allesomvattende query en stopt het resultaat in een (PHP-)variabele (wat je zelf ook al aangaf) ... je resultatenset
- je loopt door je resultatenset en deelt de info naar wens op in verschillende variabelen
- deze variabelen voeg je met je layout samen tot het gewenste resultaat
- klaar! (al kan het in de praktijk natuurlijk ietsje complexer worden )

Intheweb schreef op maandag 20 augustus 2007 @ 17:01:(knip)
En daar ben ik het ook mee eens. Daarom zette ik in de OP ook "Wie kan mij in de juiste richting duwen?" Wil er wel van leren

Wat je noemt een goede ingesteldheid, dat siert je!

[Intheweb]

edeboeck schreef op maandag 20 augustus 2007 @ 19:43:
[...]
Een kleinigheidje, maar aangezien je zelf aangeeft dat je wilt bijleren:
In een rekenblad spreken we van rijen en kolommen;
In een database spreken we van records en velden.

Hehehe, je hebt mijn zwakke plek gevonden

Nochtans is dat wel mogelijk hoor ... wat bedoel ik:
- je doet 1 call naar je db met bovenstaande allesomvattende query en stopt het resultaat in een (PHP-)variabele (wat je zelf ook al aangaf) ... je resultatenset
- je loopt door je resultatenset en deelt de info naar wens op in verschillende variabelen
- deze variabelen voeg je met je layout samen tot het gewenste resultaat
- klaar! (al kan het in de praktijk natuurlijk ietsje complexer worden )

Het klinkt inderdaad eenvoudiger dan het is...
Want waar ik zelf mee zit is het hoeveelheid overhead die ik heb in die variabele...
Stel dat het een grote web appilicatie zou zijn, dan wil je niet dat de complete inhoud van de database in het geheugen word geladen om vanuit daar alles weer te gaan verdelen in stukjes in je website.
Denk dat het nu kiezen is voor een middenweg. Wat kan ik cachen en wat draai ik doormiddel van de query.

Ik ga ff brainstormen...

[Creepy]

Je query is prima hoor. Als je je wilt beperken in het aantal kolommen geef dan geen select * op maar een select tabelnaam.veldnaam, tabelnaam2.veldnaam etc. op. Als je het aantal records wilt beperken dan gebruikt je uiteraard een extra where conditie.

[ Voor 22% gewijzigd door Creepy op 21-08-2007 09:56 ]

[Intheweb]

Creepy schreef op dinsdag 21 augustus 2007 @ 09:56:
Je query is prima hoor. Als je je wilt beperken in het aantal kolommen geef dan geen select * op maar een select tabelnaam.veldnaam, tabelnaam2.veldnaam etc. op. Als je het aantal records wilt beperken dan gebruikt je uiteraard een extra where conditie.

Ja, dat is mij bekend en dat zal later in het ontwikkel traject ook wel tersprake komen. T'is nog maar een topje van de ijsberg.

Ik heb alles even goed bekeken en ik ga mee met het idee om alles met 1 query te doen.

Nu heb ik rondgekeken naar de manier hoe ik deze gegevens kan gaan verwerken tot een mooi overzichts plaatje.

Nu kwam ik deze reactie tegen in de php.net manual: http://nl3.php.net/manual...sql-fetch-array.php#66280
Volgens mij, als ik de code goed begrijp loopt deze code door de velden heen en kun je, door zelf nog wat erbij te proggen, de loops uitvoeren die je wil bereiken.

Zit ik een beetje warm? Volgens mij wel

[ Voor 31% gewijzigd door Intheweb op 21-08-2007 10:18 ]

[Grijze Vos]

Dat klopt. Als je met je query je data hebt "plat geslagen", en je gebruikt netjes ORDER BY CategoryName (bijv.), dan is het makkelijk te zien wanneer je de volgende categorie moet gaan weergeven, dat is namelijk wanneer je huidige categoryname/categoryid verschilt van die van het vorige record.

[Intheweb]

Hmm, het wil maar niet lekker lukken om dat uit elkaar te halen.

Ik heb de loop er in zitten en ik probeer er nu door heen te lopen en het uit elkaar te trekken, maar word een beetje gek van de manier waarop ik het nu doe.

Dit is de voor nu onvolledige en nog niet netjes afgewerkte code:

PHP:

    $sql = "SELECT * FROM act_category ";
    $sql .= "Left Join act_item ON act_category.id = act_item.act_category_id ";
    $sql .= "Left Join act_itemdetail ON act_item.id = act_itemdetail.act_item_id ";
    $sql .= "Left Join act_time ON act_time.act_itemdetail_id = act_itemdetail.act_item_id ";
    $sql .= "Left Join act_place ON act_itemdetail.act_place_id = act_place.id ";
    $sql .= "WHERE act_category.act_group_id =  '".$id."' ";
    $sql .= "ORDER BY act_category.name ASC";

    $r = mysql_query($sql);
    if (!$r) die(mysql_error());

    $numfields = mysql_num_fields($r);
    $tfields = array();

    for ($i=0;$i<$numfields;$i++) {
        $field =  mysql_fetch_field($r,$i);
        $tfields[$i] = $field->table.'.'.$field->name;
    }

    $rowAssoc = array();
    $arr_items = array();

    $x=0;
    // Loop through the output of the query
    while ($row = mysql_fetch_row($r)) {
            
        for ($i=0;$i<$numfields;$i++) {
            $rowAssoc[$tfields[$i]] = $row[$i];
            $arr_items[$x][$tfields[$i]] = $row[$i];
        }
        
        // Check if the Cat name is the same as the previous one
        // Else make a new array entry
        if($arr_items[$x]['act_category.id'] == $oldCatId) {
            
            // Check if the item id is already in the array
            if($arr_items[$x]['act_item']['id'] == $oldItemId) {
                $arr_items[$x]['act_item'][] = "test ".$x;
                
                $oldItemId = $arr_items[$x]['act_item']['id'];
            }
            
        } else {
        
        }
        $oldCatId = $arr_items[$x]['act_category.id'];      
    
    $x++;
    }
    return $arr_items;

Het lijkt nu echt of ik een n00b ben, maar dat is zeker niet zo...maar ik zie gewoon ff de uitgang van deze tunnel niet

[edit 12:23]
I give up... tijd voor dit project begint te dringen en ik ga denk ik dan eerst maar de quick en dirty manier met meerdere queries. Later maak ik hem dan wel gereed met deze... ik hoor graag wat ik beter kan doen

[ Voor 5% gewijzigd door Intheweb op 21-08-2007 12:24 ]

[Spockz]

Is het volgende niet makkelijker?

(ongetest)

PHP:

function doeiets() {
  $database =& GetDatabase();
  
  $sql = "SELECT * FROM act_category ";
  $sql .= "Left Join act_item ON act_category.id = act_item.act_category_id ";
  $sql .= "Left Join act_itemdetail ON act_item.id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_time ON act_time.act_itemdetail_id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_place ON act_itemdetail.act_place_id = act_place.id ";
  $sql .= "WHERE act_category.act_group_id =  '".$id."' ";
  $sql .= "ORDER BY act_category.name ASC";
  
  $RecordsArray = $database->queryA($sql); // array of object.
  $ArrayForDisplay = array();
  
  foreach ($RecordsArray as $Record) {
    //Als de key van het het huidige record anders dan de vorige (dus de laatste in dit array)
    if ($Record->{hierjouwkey} != end($ArrayForDisplay)[{jouwkey}]) {
      $ArrayForDisplay[{jouwkey}] = array(); // Maak een nieuw child aan met als index de val van de key
    }
    
    $ArrayForDisplay[{jouwkey}][] = $Record; // Stop het record als een child bij de huidige {key} val.
  }
  
  return $ArrayForDisplay; // Geef het bijltje maar terug.
}

class database {
  function QueryA ($sql) {
    //exec sql
    //fetch all rows as objects and put them in an array
    //return the rowsarray
  }
}

[ Voor 10% gewijzigd door Spockz op 21-08-2007 12:44 ]

[_Sunnyboy_]

Ik heb de thread met plezier gelezen en zou je graag nog een duwtje in de goede richting geven, maar het is me niet precies duidelijk welk eindresultaat je nou wil hebben.

Misschien je een schetsje maken van een gewenste eindsituatie. Dat zou (mij in ieder geval) helpen om te begrijpen waar je heen wilt.

[Intheweb]

Spockz schreef op dinsdag 21 augustus 2007 @ 12:41:
Is het volgende niet makkelijker?

(ongetest)

PHP:

...

Bedankt voor een duw in de goede richting. Ik denk dat mijn warrige code mij even de nek om deed. Na een lekkere lunch ben ik aan de slag gegaan aan de hand van jouw code en ik heb eindelijk een beetje output wat er oplijkt:

code:

            [3] => Array
                (
                    [cat_name] => Yoga
                    [item_id] => 1
                    [item_name] => Beginners lessen
                    [item_content] => Leuke nieuwe sport
                    [act_category_id] => 1
                    [duration] => 1 uur
                    [date] => 
                    [price] => 55 eur
                    [age_55] => 0
                    [time] => 
                    [place_name] => Wijkcentrum
                    [zipcode] => 1234AA
                    [street] => Daar 1
                    [place] => Maastricht
                    [phonenumber] => 555-01234
                    [email] => 
                    [woejcenter] => 1
                    [items] => Array
                        (
                            [0] => Array
                                (
                                    [name] => Beginners lessen
                                    [content] => Leuke nieuwe sport
                                    [age_55] => 0
                                )

                            [1] => Array
                                (
                                    [name] => Beginners lessen
                                    [content] => Leuke nieuwe sport
                                    [age_55] => 0
                                )

                        )

                )

Dit heb ik gedaan met:

PHP:

  $sql = "SELECT  ";
  $sql .= "act_category.name AS cat_name, ";
  $sql .= "act_item.id AS item_id, ";
  $sql .= "act_item.name AS item_name, ";
  $sql .= "act_item.content AS item_content, ";
  $sql .= "act_item.act_category_id, ";
  $sql .= "act_itemdetail.duration, ";
  $sql .= "act_itemdetail.`date`, ";
  $sql .= "act_itemdetail.price, ";
  $sql .= "act_itemdetail.age_55, ";
  $sql .= "act_time.`time`, ";
  $sql .= "act_place.name AS place_name, ";
  $sql .= "act_place.zipcode, ";
  $sql .= "act_place.street, ";
  $sql .= "act_place.place, ";
  $sql .= "act_place.phonenumber, ";
  $sql .= "act_place.email, ";
  $sql .= "act_place.woejcenter FROM act_category ";
  $sql .= "Left Join act_item ON act_category.id = act_item.act_category_id ";
  $sql .= "Left Join act_itemdetail ON act_item.id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_time ON act_time.act_itemdetail_id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_place ON act_itemdetail.act_place_id = act_place.id ";
  $sql .= "WHERE act_category.act_group_id =  '".$id."' ";
  $sql .= "ORDER BY act_category.name ASC"; 

  $result   =   mysql_query($sql);

    $x=0;
    while( $row = mysql_fetch_assoc($result) ) { 
        $arr_records[$x] = $row;
    $x++;
    }

    $y=-1;
    foreach ($arr_records as $record) {
        if ($record['cat_name'] != $arr_output['categories'][($y-1)]['cat_name']) {
            $y++;
            $arr_output['categories'][$y] = $record; 
        }
        
        if($record['item_id'] == $arr_output['categories'][$y]['item_id']) {
            $arr_output['categories'][$y]['items'][] = array('name' => $record['item_name'],
                                                             'content' => $record['item_content'],
                                                             'age_55' => $record['age_55']);
        }
    
    }

    return $arr_output;

Maar denk dat mensen wel er mee eens zijn, dat er een overhead is aan data.
Ik kan hard in de code wel gaan aangeven, zoals ik nu gedaan heb bij de items, wat er in de array terecht moet komen, maar is er handigere manier om dit te doen?

_Sunnyboy_ schreef op dinsdag 21 augustus 2007 @ 12:44:
Ik heb de thread met plezier gelezen en zou je graag nog een duwtje in de goede richting geven, maar het is me niet precies duidelijk welk eindresultaat je nou wil hebben.

Misschien je een schetsje maken van een gewenste eindsituatie. Dat zou (mij in ieder geval) helpen om te begrijpen waar je heen wilt.

De gewenste eindsituatie is dat er een lijst komt die er zo uit ziet, alleen dan netjes opgemaakt met HTML enzo
Categorie Dans
Item Line Dance
* Plaats
     Tijdstip
     Tijdstip
* Plaats
     Tijdstip
     Tijdstip

Categorie Yoga
Item Soepele bewegingen
* Plaats
     Tijdstip
     Tijdstip
* Plaats
     Tijdstip
     Tijdstip

[SchizoDuckie]

Spockz schreef op dinsdag 21 augustus 2007 @ 12:41:
Is het volgende niet makkelijker?

(ongetest)

PHP:

function doeiets() {
  $database =& GetDatabase();
  
  $sql = "SELECT * FROM act_category ";
  $sql .= "Left Join act_item ON act_category.id = act_item.act_category_id ";
  $sql .= "Left Join act_itemdetail ON act_item.id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_time ON act_time.act_itemdetail_id = act_itemdetail.act_item_id ";
  $sql .= "Left Join act_place ON act_itemdetail.act_place_id = act_place.id ";
  $sql .= "WHERE act_category.act_group_id =  '".$id."' ";
  $sql .= "ORDER BY act_category.name ASC";

• Waarom die loze =& notatie
• In PHP mag je al jaren een string over meerdere regels schrijven. waarom dat lelijke geconcat?

[Spockz]

SchizoDuckie schreef op dinsdag 21 augustus 2007 @ 14:12:
[...]


• Waarom die loze =& notatie
• In PHP mag je al jaren een string over meerdere regels schrijven. waarom dat lelijke geconcat?

• Omdat ik niet telkens een nieuwe instantie van mijn DB object maak maar met 1 Database Object werk.
• Vanwege de C/P?

[SchizoDuckie]

Spockz schreef op dinsdag 21 augustus 2007 @ 14:56:
[...]

• Omdat ik niet telkens een nieuwe instantie van mijn DB object maak maar met 1 Database Object werk.
• Vanwege de C/P?

Singleton?

[Intheweb]

Die dingen hoef ik gelukkig niet te gebruiken omdat het binnen een framework komt te hangen waar dat niet nodig is
Als iemand maybe nog commentaar op mijn vorige post wil geven graag

[Spockz]

SchizoDuckie schreef op dinsdag 21 augustus 2007 @ 15:23:
[...]

Singleton?

Ja, dat is dit ook min of meer. Dit object is overal hetzelfde omdat ik de stats in het object zelf opsla en niet in een aparte stats container.

PHP:

function &GetDatabase($aDatabaseObject) {
  static $DatabaseObject;

  if (!isset($DatabaseObject)) {
    //Plus meer checks
    $DatabaseObject = $aDatabaseObject;
  }

  return $DatabaseObject;
}

[Intheweb]

Heel erg bedankt voor de reactie's.
Maar, deze query en php code word niet meer gebruikt in de code.
Er is nu gekozen voor een oplossing die minder joins vereist. En waarmee ik niet moeilijk hoef te doen met het splitsen van de querys.

Maar ben zeker wat wijzer hiervan geworden, dus bedankt voor jullie bijdrage daar aan