Van query naar datatables
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
$value = "3-7-11-2-6-";
$result= explode("-", $value);
foreach($result as $newvalue){
$sql = "SELECT * FROM markers WHERE id ='$newvalue'";
if (!$result = $mysqli->query($sql))
{
echo "<li>Sorry, er zijn problemen met de website.";
}
else
{
$record = $result->fetch_assoc();
echo "<br>".$record['cb'];
echo "<br>".$record['id'];
echo "<br>".$record['name'];
}
}
$result= explode("-", $value);
foreach($result as $newvalue){
$sql = "SELECT * FROM markers WHERE id ='$newvalue'";
if (!$result = $mysqli->query($sql))
{
echo "<li>Sorry, er zijn problemen met de website.";
}
else
{
$record = $result->fetch_assoc();
echo "<br>".$record['cb'];
echo "<br>".$record['id'];
echo "<br>".$record['name'];
}
}
Dit gedeelte werkt..
Maar nu moet ik het sluitend maken naar de datatable toe.
Dit moet aansluiten op:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// DB table to use
$table = 'markers';
// Table's primary key
$primaryKey = 'id';
// Array of database columns which should be read and sent back to DataTables.
// The `db` parameter represents the column name in the database, while the `dt`
// parameter represents the DataTables column identifier. In this case simple
// indexes
$columns = array(
array( 'db' => 'cb', 'dt' => 'cb' ),
array( 'db' => 'id', 'dt' => 'id' ),
array( 'db' => 'name', 'dt' => 'name' ),
.
.
.
);
require( 'ssp.class.php' );
echo json_encode(
SSP::simple( $_GET, $sql_details, $table, $primaryKey, $columns )
);
$table = 'markers';
// Table's primary key
$primaryKey = 'id';
// Array of database columns which should be read and sent back to DataTables.
// The `db` parameter represents the column name in the database, while the `dt`
// parameter represents the DataTables column identifier. In this case simple
// indexes
$columns = array(
array( 'db' => 'cb', 'dt' => 'cb' ),
array( 'db' => 'id', 'dt' => 'id' ),
array( 'db' => 'name', 'dt' => 'name' ),
.
.
.
);
require( 'ssp.class.php' );
echo json_encode(
SSP::simple( $_GET, $sql_details, $table, $primaryKey, $columns )
);
Is dit te doen, of kan ik beter aan de clientside de oplossing zoeken?
Bedankt vast voor het meedenken..
Voor de rest lijkt het standaard.
Overigens, in je eerste stuk source: In plaats van voor elke $newvalue een select te doen, kun je ook overwegen om sql als volgt te doen:
Code (php)
1
SELECT * FROM markers WHERE id IN (3, 7, 11, 2, 6)
Dan heb je in plaats van 6x select nog maar 1x select. De foreach laat je dan los op $record.
Datatables werkt inderdaad wat anders dan datgene waar ik normaal mee geconfronteerd wordt.
Maar wel leuk om mee te spelen.
Net je code uitgeprobeerd...dat geeft teveel problemen.
Ik heb die string echt nodig. En nu moet ik die weer gaan ontleden.
Die string wordt aangemaakt door een lid zelf op grond van het aanvinken van checkboxen uit de ledenlijst.
Er zijn wel andere methoden, maar dit werkt wel lekker...
Als het niet lukt aan de serverside, kan het waarschijnlijk ook wel aan de clientside.
Ik wil die checked checkboxen eigenlijk apart in een tweede tabel of kunnen sorteren.
Dat is wat moeilijker bij datatables.
Of ik moet een nieuwe record maken vanuit die string.
Daar stelde ik dus de vraag over.
De alerts die je in voorbeeld ziet worden gestuurd (niet in voorbeeld) naar de database om de string in te korten of te verlengen met nieuwe ID's van 'vrienden'.
http://pctraverse.nl/DataTables-1.10.11/examples/server_side/simpleZZ.php
Code (php)
1
2
3
2
3
$value = "3-7-11-2-6-";
$result= explode("-", $value);
$where = implode(",", $result);
$result= explode("-", $value);
$where = implode(",", $result);
Dan wordt je $value 3-7-11-2-6- omgezet in 3, 7, 11, 2, 6.
Maar goed, als het een beperkt rijtje is, zul je het misschien nauwelijks merken.
De string zal max. 25 id's bevatten, ga ik vooralsnog vanuit
Quote:
Ik heb die string echt nodig. En nu moet ik die weer gaan ontleden.
Omdat je dit probleem zelf hebt geïntroduceerd.
Quote:
Die string wordt aangemaakt door een lid zelf op grond van het aanvinken van checkboxen uit de ledenlijst. Er zijn wel andere methoden, maar dit werkt wel lekker...
Erm, nee. Zoeken met dit soort constructies is een ramp. Hoe bepaal je snel of persoon X persoon Y volgt?
Quote:
Als het niet lukt aan de serverside, kan het waarschijnlijk ook wel aan de clientside.
Je database bevindt zich aan de serverzijde, dus geen enkele mate van (zwarte) tovenarij aan de clientzijde zal je soelaas bieden.
Ik heb een déja vu volgens mij. Ik zou je dringend doch vriendelijk verzoeken de mogelijkheden van koppeltabellen te verkennen. Dit bespaart je later een hoop hoofdpijn.
Het serialiseren van id's is *soms* verstandig, maar in dit geval niet, lijkt mij.
EDIT: bonus:
Quote:
De string zal max. 25 id's bevatten, ga ik vooralsnog vanuit
"One megabyte is enough" :)
Gewijzigd op 15/06/2016 16:11:07 door Thomas van den Heuvel
Heb wel een en ander bekeken.
Als je een voorbeeld script hebt of een opzetje, heel graag...
Misschien dat ik er dan uitkom.
Neemt niet weg dat ik dan ook de koppeling moet maken naar datatables.
Wat betreft datatables.
Die heeft allerlei mogelijkheden om zaken te veranderen in de weergave van de records en te renderen.
Gewijzigd op 15/06/2016 16:40:31 door Hans De Ridder
Serialiseren in plaats van normaliseren brengt allerlei complicaties met zich mee. Om er eentje uit te pikken: wat doe je als je een gebruiker moet verwijderen? Als je probeert je voor te stellen hoe dat dan zou moeten, zie je dat je opnieuw aanloopt tegen problemen die je zelf hebt geïntroduceerd, precies zoals Thomas voorspelt.
In de getoonde records komen gegevens van andere leden.
Ik heb aparte tabellen aangemaakt voor zaken als basisgegevens, googlemaps, mediagegevens, controle op inloggen, enz.
De enige relatie is de overeenkomstige member_id.
Er is geen echte relatie tussen andere leden.
Als men members wil volgen, dan is een koppeling nodig naar de ID's van die leden.
Dat wordt clientside bepaald en doorgegeven aan een tabel in de database die de ID's bijhoudt.
Hoe dat eruit ziet maakt me niet uit. Of dat een string is of een tabel via koppelen.
Maar ik zie niet hoe ik een koppeltabel kan maken van een en dezelfde tabel waar de gegevens in staan.
Dus daarom heb ik dit bedacht.
Overigens is er geen probleem als er een lid verwijderd wordt.
Want bij vergelijken komt de id dan niet meer voor. (Staat ook niet meer in de record).
Verwijderen gebeurt via administratiepaneel door de beheerder. kan ook tijdelijke block zijn, of definitief ook eventueel op IP.
Een koppeltabel legt een verband tussen twee tabellen. Dit kan best een en dezelfde tabel zijn.
Je zou een koppeltabel "volgers" kunnen maken met de volgende structuur:
lid_id (verwijst naar de ledentabel, specifiek het lid id)
volgt_lid_id (verwijst ook naar de ledentabel, specifiek het lid id)
... that's it.
Elk record bevat de gegevens van één persoon die één ander persoon volgt.
Stel dat je de volgende leden hebt:
(id, naam)
1. Henk
2. Piet
3. Klaas
4. Jan
Als je nu wilt aangeven dat Henk (1) Klaas (3) en Jan (4) volgt, stop je twee records in de koppeltabel:
een record met lid_id 1 en volgt_lid_id 3, en
een record met lid_id 1 en volgt_lid_id 4.
Hetzelfde voor Piet (2) die Henk (1) en Klaas (3) volgt:
een record met lid_id 2 en volgt_lid_id 1, en
een record met lid_id 2 en volgt_lid_id 3.
Et cetera.
Het wordt dan ook een eitje om vraagstukken te beantwoorden als: hoeveel leden volgt lid X of hoeveel volgers heeft lid X.
Maar wat is nu het verschil met wat ik eerst had?
Ik had een tabel met user_id's als referentie.
In de volgende colomns had ik staan a-y ( de id's van de gekozen vrienden).
Met de user_id als referentie wordt uit de algemene tabel een record gemaakt met de gegevens van de vrienden (op grond van de vrienden_id's)
En die wordt doorgestuurd naar datatable.
Hoe krijg ik via een koppeltabel dat nu in 1 record naar mijn datatable toe?
Als ik het goed begrijp moet ik bij 1000 leden dus max. 25000 records maken.
En dan per lid alle records uitdraaien waar zijn id wordt genoemd?
Het verschil tussen jouw en mijn oplossing? Deze zul je merken in het gebruik. Probeer de eerdergenoemde vraagstukken eens (eenvoudig) te beantwoorden met jouw opzet. En kijk dan nog eens naar hoe je dat doet met mijn opzet.
Quote:
Hoe krijg ik via een koppeltabel dat nu in 1 record naar mijn datatable toe?
Dit volg ik niet helemaal? De volgers-relatie is een een-op-veel relatie. Het is dan vrij normaal dat dit zich uit in meerdere records in de koppeltabel, zowel voor iemand die andere leden volgt alsook dat een lid gevolgd kan worden door meerdere andere leden.
Een database is bedoeld om data gestructureerd op te slaan. Maar ook om hier daarna weer makkelijk data uit op te vragen al naar gelang er een bepaalde informatiebehoefte is. Wat jij doet is de data versleuteld opslaan in de database, zodat dit een brok data wordt waar een database zelf niet zoveel mee kan omdat je deze in een eigen alternatief formaat opslaat.
Vergelijk dit met een spreadsheet waarbij je alle volgers-informatie in één cel dumpt. De structuur is dan ver te zoeken... Ook een oplossing met meerdere kolommen in eenzelfde tabel ("maximaal X gebruikers") is geen goede oplossing. Beschouw de koppeltabel als een apart tabblad in de spreadsheet waarin elke regel bestaat uit een lid die een ander lid volgt. In plaats van de tabelstructuur aan te passen als je onverhoopt op een gegeven moment besluit dat iemand meerdere volgers kan hebben hoef je dan enkel een of meer records toe te voegen, aan de structuur verandert niets. Ook kun je regels opleggen aan deze koppeltabel zodat deze geen duplicaten bevat. Zo heb je dus ook nog eens inherente sanity checks op de integriteit van je data.
Hier een voorbeeld waar ik naar toe weil...
Alleen is dit clientside.
Ik kan dit wel ombouwen naar gegevens van database.
En dat werkt ook wel.
Maar een aantal functies verwijst naar de Ajax lijst ( ajax.data)
En die krijg ik in mijn onervarenheid niet herschreven.
In het voorbeeld zit wel een klein foutje in het vergelijken.
Maar als voorbeeld werkt het wel.
Er zijn al wat gecheckte checkboxen (komen normaal van database).
Door te submitten komen uitsluitend de gegevens van gecheckte leden in een tweede tabel.
De verzameltabel is verder gewoon te sorteren. En ook in te zoeken.
De verzameltabel kun je verder andere vrienden aanvinken of verwijderen.
Met submit komen de nieuwe gegevens in de vriendentabel.
En bij submit moeten de nieuwe gegevens weer opgenomen worden of aangevuld in een (koppel) tabel (of string)'
Ik heb zelf ook al een werkende serverside opzet met checkboxen, maar krijg dat niet gesorteerd.
Dan heeft het geen nut om leden de hele record af te laten zoeken naar aangevinkte checkboxen.
Voor datatables kan ik alleen op complexe manier queries toevoegen.
Datatables gaat uit van 1 record die uitgelezen wordt. En er zijn allerlei mogelijkheden om Clientside
de data te wijzigen en te beinvloeden, al dan niet met API's of toevevoegingen vanuit CSS.
Gelet op voorgaande heb ik dus gezocht naar een record met uitsluitend de gegevens van vrienden,
om die rechtstreeks te plaatsen in de vriendentabel.
Dat wordt denk ik met mijn kennis een veel te complex verhaal.
De koppeling van user_id's naar vrienden_id's moet in ieder geval gelegd worden.
Ik snap echter helaas nog steeds niet waar je nu de gegevens vastlegt met die koppelingen.
Ik deed dat in een tabel in de database waar ik de user_id's vastlegde met de vrienden_id's.
Hoe moet dat dan met een koppeltabel?
Los van het feit dat ik slechts 1 record kan uitdraaien naar datatable.
Wel eventueel andere voor een tweede of derde datatable tabel.
http://www.pctraverse.nl/DataTables-1.10.11/examples/server_side/simpleZZZ.php
Het volgende is een compleet standalone script wat ik (eigenlijk tegen beter weten in) in elkaar heb gezet.
Ik zou zeggen, ga hier eens mee spelen en behandel dit soort problemen in afzondering, anders zie je mogelijk door de bomen het bos niet meer.
Disclaimer: er kunnen een heleboel dingen anders en beter, de onderstaande code dient enkel ter illustratie van het concept "koppeltabel".
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
<?php
// Noot: nog beter zouden constraints en foreign keys zijn in de koppetabel uiteraard.
/*
CREATE TABLE personen (
per_id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
per_naam VARCHAR(255)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE volgers (
vol_persoon_id INT UNSIGNED NOT NULL,
vol_volgt_persoon_id INT UNSIGNED NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO personen (per_naam) VALUES ('Henk'), ('Piet'), ('Klaas'), ('Marij'), ('Els'), ('Bob'), ('Justin'), ('Mark'), ('Hanna'), ('Jan'), ('Steven'), ('Kim');
*/
// Wie ben ik? Komt normaal uit een sessie of wat dan ook.
$myUserId = 1; // Henk
$db = new mysqli('hostName', 'userName', 'password', 'databaseName');
$db->set_charset('utf8');
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
// Noot: de volgende queries in een transactie uitvoeren zou beter zijn uiteraard.
// Gooi koppeltabel leeg voor deze gebruiker.
$db->query(
"DELETE
FROM volgers
WHERE vol_persoon_id = '".$db->real_escape_string($myUserId)."'"
);
// Voeg volgers opnieuw toe.
if (isset($_POST['personen'])) {
foreach ($_POST['personen'] as $id) {
$db->query(
"INSERT INTO volgers (
vol_persoon_id, vol_volgt_persoon_id
) VALUES (
'".$db->real_escape_string($myUserId)."',
'".$db->real_escape_string($id)."'
)"
);
}
}
// Ververs pagina (voorkomt dubbelposts, niet dat dat in dit geval iets uitmaakt maar goed).
header('Location: '.$_SERVER['SCRIPT_NAME']);
exit;
}
// Hulpfunctie.
function escape($in) {
return htmlspecialchars($in, ENT_QUOTES, 'UTF-8');
}
// Alles UTF-8.
header('Content-Type: text/html; charset=UTF-8');
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>friend me?</title>
<style type="text/css">
body { font-family: sans-serif; font-size: 10pt; }
</style>
</head>
<body>
<form action="<?php echo escape($_SERVER['SCRIPT_NAME']) ?>" method="post" accept-charset="UTF-8"><?php
// Welke personen zijn er allemaal en wie volg ik?
// Dit zou je ook kunnen opsplitsen in meerdere eenvoudigere queries.
$res = $db->query(
"SELECT p.per_id, p.per_naam, v.vol_volgt_persoon_id
FROM personen p
LEFT JOIN volgers v ON (v.vol_persoon_id = '".$db->real_escape_string($myUserId)."' AND v.vol_volgt_persoon_id = p.per_id)
WHERE p.per_id <> '".$db->real_escape_string($myUserId)."'
ORDER BY p.per_naam"
);
while ($row = $res->fetch_assoc()) {
$id = escape($row['per_id']);
$name = escape($row['per_naam']);
$checked = ($row['vol_volgt_persoon_id'] == NULL ? '' : ' checked="checked"');
?><p>
<input type="checkbox" name="personen[]" id="personen_<?php echo $id ?>" value="<?php echo $id ?>"<?php echo $checked ?>>
<label for="personen_<?php echo $id ?>"><?php echo $name ?></label>
</p><?php
}
?><div>
<button type="submit">opslaan</button>
</div>
</form>
</body>
</html>
// Noot: nog beter zouden constraints en foreign keys zijn in de koppetabel uiteraard.
/*
CREATE TABLE personen (
per_id INT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
per_naam VARCHAR(255)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE volgers (
vol_persoon_id INT UNSIGNED NOT NULL,
vol_volgt_persoon_id INT UNSIGNED NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO personen (per_naam) VALUES ('Henk'), ('Piet'), ('Klaas'), ('Marij'), ('Els'), ('Bob'), ('Justin'), ('Mark'), ('Hanna'), ('Jan'), ('Steven'), ('Kim');
*/
// Wie ben ik? Komt normaal uit een sessie of wat dan ook.
$myUserId = 1; // Henk
$db = new mysqli('hostName', 'userName', 'password', 'databaseName');
$db->set_charset('utf8');
if ($_SERVER['REQUEST_METHOD'] == 'POST') {
// Noot: de volgende queries in een transactie uitvoeren zou beter zijn uiteraard.
// Gooi koppeltabel leeg voor deze gebruiker.
$db->query(
"DELETE
FROM volgers
WHERE vol_persoon_id = '".$db->real_escape_string($myUserId)."'"
);
// Voeg volgers opnieuw toe.
if (isset($_POST['personen'])) {
foreach ($_POST['personen'] as $id) {
$db->query(
"INSERT INTO volgers (
vol_persoon_id, vol_volgt_persoon_id
) VALUES (
'".$db->real_escape_string($myUserId)."',
'".$db->real_escape_string($id)."'
)"
);
}
}
// Ververs pagina (voorkomt dubbelposts, niet dat dat in dit geval iets uitmaakt maar goed).
header('Location: '.$_SERVER['SCRIPT_NAME']);
exit;
}
// Hulpfunctie.
function escape($in) {
return htmlspecialchars($in, ENT_QUOTES, 'UTF-8');
}
// Alles UTF-8.
header('Content-Type: text/html; charset=UTF-8');
?>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>friend me?</title>
<style type="text/css">
body { font-family: sans-serif; font-size: 10pt; }
</style>
</head>
<body>
<form action="<?php echo escape($_SERVER['SCRIPT_NAME']) ?>" method="post" accept-charset="UTF-8"><?php
// Welke personen zijn er allemaal en wie volg ik?
// Dit zou je ook kunnen opsplitsen in meerdere eenvoudigere queries.
$res = $db->query(
"SELECT p.per_id, p.per_naam, v.vol_volgt_persoon_id
FROM personen p
LEFT JOIN volgers v ON (v.vol_persoon_id = '".$db->real_escape_string($myUserId)."' AND v.vol_volgt_persoon_id = p.per_id)
WHERE p.per_id <> '".$db->real_escape_string($myUserId)."'
ORDER BY p.per_naam"
);
while ($row = $res->fetch_assoc()) {
$id = escape($row['per_id']);
$name = escape($row['per_naam']);
$checked = ($row['vol_volgt_persoon_id'] == NULL ? '' : ' checked="checked"');
?><p>
<input type="checkbox" name="personen[]" id="personen_<?php echo $id ?>" value="<?php echo $id ?>"<?php echo $checked ?>>
<label for="personen_<?php echo $id ?>"><?php echo $name ?></label>
</p><?php
}
?><div>
<button type="submit">opslaan</button>
</div>
</form>
</body>
</html>
Ga er zeker mee aan de gang.
Ik meld me wel weer!
Toevoeging op 16/06/2016 21:48:59:
Snel even gekeken tussen het voetballen door.
De bedoeling is me nu duidelijk.
Als ik echter de user 1 verwijder uit de database blijft de volgerstabel van 1 toch bestaan.
Wanneer ik een volger verwijder, dan verdwijnt deze wel uit de lijst, maar bij de checkboxen blijven de namen wel vermeld.
Als ik de verwijderde volger weer aanvink dan gebeurt er uiteraard niks.
Verander ik user naar 2, dan wordt dat ook netjes weerrgegeven.
Maar ik bestudeer het nog wel verder.
Bedankt in ieder geval voor het script.
Toevoeging op 17/06/2016 11:52:25:
Lijkt me ook logisch dat de volgerlijst blijft vestaan als lid wordt verwijderd.
Via administrator paneel zal dat meegenomen moeten worden neem ik aan.
Hans De Ridder op 16/06/2016 20:32:54:
Als ik echter de user 1 verwijder uit de database blijft de volgerstabel van 1 toch bestaan.
Niet als je met een FOREIGN KEY het juiste type relatie legt. Een relationele database kan dankzij een ON DELETE CASCADE afhankelijke tabellen automatisch bijwerken: verwijder je een gebruiker uit de hoofdtabel, dan worden meteen alle records van die gebruiker uit de afhankelijke tabel verwijderd.
Quote:
Wanneer ik een volger verwijder, dan verdwijnt deze wel uit de lijst, maar bij de checkboxen blijven de namen wel vermeld.
Dit lijkt mij niet meer dan logisch. Als je stopt met het volgen van een lid houdt dat niet in dat dat lid ook weggekieperd wordt. Er wordt enkel een relatie tussen twee leden verbroken, er wordt geen lid verwijderd.
Quote:
Als ik de verwijderde volger weer aanvink dan gebeurt er uiteraard niks.
Niet totdat je het formulier opnieuw submit in ieder geval. Wijzigingen in de database worden pas doorgevoerd nadat je de informatie hebt teruggestuurd naar de server.
Quote:
Lijkt me ook logisch dat de volgerlijst blijft vestaan als lid wordt verwijderd.
Via administrator paneel zal dat meegenomen moeten worden neem ik aan.
Via administrator paneel zal dat meegenomen moeten worden neem ik aan.
Zoals aangegeven kun je dit ondervangen zodat deze tabel automatisch bij wordt gewerkt indien er een lid wordt verwijderd. Deze extra voorzieningen zorgen er dus automatisch voor dat de data in de volgers-tabel consistent is en blijft.
Dit doe je als volgt:
Code (php)
1
2
2
ALTER TABLE volgers ADD FOREIGN KEY (vol_persoon_id) REFERENCES personen(per_id) ON DELETE CASCADE;
ALTER TABLE volgers ADD FOREIGN KEY (vol_volgt_persoon_id) REFERENCES personen(per_id) ON DELETE CASCADE;
ALTER TABLE volgers ADD FOREIGN KEY (vol_volgt_persoon_id) REFERENCES personen(per_id) ON DELETE CASCADE;
Indien je dan een persoon verwijdert die volgers had of zelf andere personen volgde zullen de bijbehorende records in de volgers-tabel automatisch opgeschoond worden.
Gewijzigd op 17/06/2016 12:40:51 door Thomas van den Heuvel
Heb even de volledige tabellen opnieuw aangemaakt met de FOREIGN erbij.
Werkt exact zo als jullie hebben aangegeven.
Klasse, bedankt...
Heb nu toch nog misschien een domme vraag, haha
Ik heb natuurlijk de tabel met de basisgegevens die ik laat verschijnen,
eventueel aangevuld met andere tabelgegevens (social media, googlemaps, etc.)
De gegevens voor de koppeltabel (die nu via INSERT komen) moet ik halen uit mijn
basisgegevens? Of is het de bedoeling dat die basisgegevens onderdeel zijn van de koppeltabel?
basistabel:
user_id (primary key) - Voornaam - Achternaam - Gebruikersnaam - Wachtwoord - Email - Geb. Datum
Quote:
phpMyAdmin accepteerde de laatste toevoegingen niet.
Dit kwam waarschijnlijk omdat je tabellen waren aangemaakt met de (standaard) storage engine MyISAM. Deze tabellen lenen zich niet echt voor administratieve systemen omdat deze (nog) geen gebruik kunnen maken van voorzieningen als transacties en foreign keys. Met MyISAM als storage engine hangen je tabellen letterlijk als los zand aan elkaar en is er geen enkele waarborging voor referentiële integriteit van je data. De storage engine InnoDB doet dit alles wel.
Bij het opstellen van je database zul je je moeten afvragen welke storage engine en ook welke character encoding je gebruikt voor de definitie van je tabellen. Dit moeten weloverwogen keuzen (of liever gezegd: ontwerpbeslissingen) zijn. Dit is geen syntactic sugar die je achter je CREATE TABLE statement plakt; je moet tot op zekere hoogte weten wat dit betekent en wat voor implicaties dit heeft.
Ik beschouw een database als het fundament van mijn applicatie. Heb je een slecht fundament, dan vervalt de rest (de applicatie) al snel tot een bouwval.
Quote:
De gegevens voor de koppeltabel (die nu via INSERT komen) moet ik halen uit mijn
basisgegevens?
basisgegevens?
Je kunt deze query uitbouwen door de volgers van de huidige gebruiker in de query te serialiseren middels de MySQL-functie GROUP_CONCAT. Vervolgens dien je te groeperen op het user id. Omdat het voor kan komen dat een gebruiker geen volgers heeft is het verstandig om een LEFT JOIN op de volgers-tabel te doen, anders levert je query op je basisgegevens mogelijk geen resultaat op.
Voortbordurend op het oorspronkelijke voorbeeld ziet de query er bijvoorbeeld als volgt uit:
Code (php)
1
2
3
4
5
2
3
4
5
SELECT per_naam, GROUP_CONCAT(vol_volgt_persoon_id) AS volgt
FROM personen
LEFT JOIN volgers ON (vol_persoon_id = per_id)
WHERE per_id = X
GROUP BY per_id
FROM personen
LEFT JOIN volgers ON (vol_persoon_id = per_id)
WHERE per_id = X
GROUP BY per_id
Waar X een persoon id is. In het SELECT-deel kun je andere basisgegevens opvragen.
Stel dat Henk (id 1) Klaas (id 3), Justin (id 7) en Hanna (9) volgt dan levert dit:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
mysql> SELECT per_naam, GROUP_CONCAT(vol_volgt_persoon_id) AS volgt
-> FROM personen
-> LEFT JOIN volgers ON (vol_persoon_id = per_id)
-> WHERE per_id = 1
-> GROUP BY per_id;
+----------+-------+
| per_naam | volgt |
+----------+-------+
| Henk | 9,7,3 |
+----------+-------+
1 row in set (0.00 sec)
-> FROM personen
-> LEFT JOIN volgers ON (vol_persoon_id = per_id)
-> WHERE per_id = 1
-> GROUP BY per_id;
+----------+-------+
| per_naam | volgt |
+----------+-------+
| Henk | 9,7,3 |
+----------+-------+
1 row in set (0.00 sec)
Vervolgens kun je de "volgt" kolom exploden op een komma, nadat je hebt gecontroleerd of de waarde ongelijk aan NULL is (in het geval dat deze persoon geen volgers heeft).
Hij meldde iets over kon niet editen of toevoegen in child.
Oke, de nieuwe toelichting kan ik nog volgen.
Maar even terug naar de wijze waarop de koppeltabel tot stand komt.
Daar staan namen, id's, etc.
Die gegevens daarvoor komen ergens vandaan.
Ik neem aan van de basis gegevens zoals ik aangaf.
Of is mijn tabel 'basis' dezelfde als jij noemt 'personen', maar dan met meer gegevens?
user_id (primary key) - Voornaam - Achternaam - Gebruikersnaam - Wachtwoord - Email - Geb. Datum
Gewijzigd op 17/06/2016 19:12:41 door Hans De Ridder
In de koppeltabel komen precies twee kolommen voor. Beide verwijzen naar user id's in je basistabel (of zouden dit moeten doen).
In de koppeltabel staat enkel informatie over wie wie volgt.