[PHP] Array opslaan in MySQL zonder serialize/implode

[Verwijderd]

Is er een mogelijkheid om een array zodanig in mysql op te slaan dat de volgende query mogelijk wordt?

MySQL:

SELECT * FROM table WHERE var[id] = 'value';

Serialize en implode kan dat niet mee afaik.

[Walance]

Voor zover ik weet kun je geen arrays opslaan in mysql, je kunt de waardes van die array beter in een aparte tabel opslaan.

[MueR]

Dit zou het concept van de database een beetje teniet doen. Maak een aparte tabel die linkt tussen de gegevens.

[Janoz]

Arrays sla je niet op in een record, die sla je op in je volgende tabel waarbij je vervolgens een foreign key naar het originele record laat verwijzen.

[Verwijderd]

In mijn situatie betreft het ongeveer 50 records, waarvan ongeveer 20 records een "onderliggende" array bevatten met min. 2 en max. 8 keys. De applicatie zal veel worden gebruikt.

De volgende oplossing lijkt mij een beetje overkill worden, aangezien je zo 51 queries per aanroep moet draaien:

PHP:

$result1 = mysql_query("SELECT * FROM tabel1");

while($row = mysql_fetch_array($result1)) {
   echo $row['keys_van_tabel_1']; // KOPTEKST!

   $result2 = mysql_query("SELECT * FROM tabel1 WHERE tabel2.id = " . $row['id']);

   if (mysql_num_rows($result2)) {
      $record = mysql_fetch_assoc($result2);

      echo $record['keys_van_tabel_2']; // ONDERLIGGENDE REGELS
   }
}

Een andere mogelijkheid, waarbij slechts 1 query (JOIN) nodig is, zou de volgende zijn; maar die voelt ook nogal ranzig aan:

PHP:

$result = mysql_query("SELECT * FROM tabel1 AS t1, tabel2 AS t2 WHERE t1.id = t2.id");

$last_id = 0;
while($row = mysql_fetch_array($result)) {
   if ($last_id != $row['id']) {
      echo $row['keys_van_tabel_1']; // KOPTEKST
      $last_id = $row['id'];
   }

   echo $row['keys_van_tabel_2']; // ONDERLIGGENDE REGELS
}

Zie ik nou mogelijkheden over het hoofd, of is er echt niets beters dan dit?

[MueR]

Allereerst moet je eens ophouden met SELECT * FROM. Heb je echt alles uit de regel nodig, of alleen een ID?

Verder zeg je dat de applicatie veel gebruikt gaat worden? Dan zou ik me eerst eens wat gaan verdiepen in MySQL of databases in het algemeen. Nofi, maar je lijkt niet echt thuis te zijn in datanormalisatie.

[Janoz]

Dat de tweede manier ranzig aanvoelt zou ik als ik jou was maar een beetje af gaan leren aangezien dat toch wel de standaard manier van werken is in het geval van een 1:N relatie. Je kunt hem eventueel wel iets herschrijven tot een query waarin je daadwerkelijk het JOIN keyword gebruikt.

Bedenk iig dat het opslaan van een array in een veld oneindig veel meer ranziger is dan zelfs je eerste stuk code waarbij er 50 queries op de DB afgevuurd werden.

Tot slot ben ik het helemaal met MueR eens dat je van die * af moet, maar daarnaast wil ik je ook adviseren om wat SQL tuts door te nemen. Het joinen van tabellen is nu juist het bestaansrecht van een database. Dat is nu juist de meerwaarde tov wat platte bestandjes.

[Verwijderd]

Janoz schreef op dinsdag 20 november 2007 @ 14:49:
Je kunt hem eventueel wel iets herschrijven tot een query waarin je daadwerkelijk het JOIN keyword gebruikt.

De SQL-optimiser intepreteert een table1.id = table2.id toch heftzelfde als een INNER JOIN?

[ Voor 41% gewijzigd door Verwijderd op 24-11-2007 17:31 ]

[FragFrog]

Verwijderd schreef op zaterdag 24 november 2007 @ 17:28:
De SQL-optimiser intepreteert een table1.id = table2.id toch heftzelfde als een INNER JOIN?

Ik vermoed dat Janoz hint op de ranzigheid van je code. Vergelijk jou blok eens met dit:

PHP:

$result = mysql_query("SELECT     *
                       FROM       `tabel1`
                       JOIN       `tabel2`
                         ON       `tabel1`.`id` = `tabel2`.`id`");
$returnText = false;
while($row = mysql_fetch_array($result))
   $returnText .= $returnText ? $row['keys_van_tabel_2'] : $row['keys_van_tabel_1'];

echo $returnText;

Wellicht kwestie van smaak, maar ik vind dit een stuk leesbaarder, helemaal als je joins gaat uitvoeren op meer tabellen

[ Voor 3% gewijzigd door FragFrog op 24-11-2007 23:35 ]

[Voutloos]

Verwijderd schreef op zaterdag 24 november 2007 @ 17:28:
[...]

De SQL-optimiser intepreteert een table1.id = table2.id toch heftzelfde als een INNER JOIN?

Je helpt de optimizer echt door join condities als dusdanig op te schrijven (ON of USING clause). Verder is ',' als join operator gebruiken imo bad practice. Zeg gewoon expliciet welke join type je wil hebben.

[Verwijderd]

FragFrog schreef op zaterdag 24 november 2007 @ 23:34:
[...]


Ik vermoed dat Janoz hint op de ranzigheid van je code. Vergelijk jou blok eens met dit:

PHP:

$result = mysql_query("SELECT     *
                       FROM       `tabel1`
                       JOIN       `tabel2`
                         ON       `tabel1`.`id` = `tabel2`.`id`");
$returnText = false;
while($row = mysql_fetch_array($result))
   $returnText .= $returnText ? $row['keys_van_tabel_2'] : $row['keys_van_tabel_1'];

echo $returnText;

Wellicht kwestie van smaak, maar ik vind dit een stuk leesbaarder, helemaal als je joins gaat uitvoeren op meer tabellen

Jouw SQL opmaak is idd stukken beter; die ga ik zeker overnemen. Bedankt!

Het PHP voorbeeld is volgens mij niet helemaal correct, wel?

[NMe]

Verwijderd schreef op zondag 25 november 2007 @ 14:07:
Het PHP voorbeeld is volgens mij niet helemaal correct, wel?

Als dat voorbeeld niet correct is, dan is jouw voorbeeld hierboven dat ook niet, want deze code doet als het goed is precies hetzelfde.

offtopic:
Overigens zou ik regels 5 en 7 dan wel herschrijven.

PHP:

$returnText = "";
while($row = mysql_fetch_array($result))
   $returnText .= empty($returnText) ? $row['keys_van_tabel_1'] : $row['keys_van_tabel_2'];

Ik hou zelf niet zo van type-goochelen en het is IMO gewoon vies om eerst een boolean in een variabele op te slaan en vervolgens strings eraan te concateneren. Het gebruik van de ternary operator is overigens ook discutabel, maar dat vind ik hier nog wel leesbaar en dus correct.

[FragFrog]

-NMe- schreef op zondag 25 november 2007 @ 14:30:

offtopic:
Overigens zou ik regels 5 en 7 dan wel herschrijven.

Kwestie van smaak, ik vind persoonlijk het lelijker om een variabele een lege string toe te wijzen en vervolgens te controleren of hij leeg is dan om een variabele false te laten zijn en daarna te controleren of'ie niet false is - voor mijn gevoel is dat laatste efficienter, alhoewel het natuurlijk niet echt iets uitmaakt Er is ook wat voor te zeggen om een string altijd een string te laten zijn, maar de kracht (en zwakheid) van PHP is juist dat je in principe (bijna) nooit zelf hoeft te typecasten en dit soort constructies dus best elegant zijn. Met elke strongtyped taal heb je natuurlijk wel gelijk dat het mooier is om'm direct als string te initialiseren

Overigens, je concat niet een string aan een boolean, die boolean wordt bij het omzetten namelijk gewoon een lege string zodat je effectief een string aan een lege string concat, net als met jou code

[ Voor 11% gewijzigd door FragFrog op 25-11-2007 14:41 ]

[NMe]

FragFrog schreef op zondag 25 november 2007 @ 14:40:
Met elke strongtyped taal heb je natuurlijk wel gelijk dat het mooier is om'm direct als string te initialiseren

Kán het ook nog anders dan, in een strongtyped taal?

Overigens, je concat niet een string aan een boolean, die boolean wordt bij het omzetten namelijk gewoon een lege string zodat je effectief een string aan een lege string concat, net als met jou code

Weet ik, maar iemand die niet bekend is met PHP raakt door dit soort code aardig in de war.

[ Voor 18% gewijzigd door NMe op 25-11-2007 14:45 ]

[Verwijderd]

-NMe- schreef op zondag 25 november 2007 @ 14:30:
[...]

Als dat voorbeeld niet correct is, dan is jouw voorbeeld hierboven dat ook niet, want deze code doet als het goed is precies hetzelfde.

De twee codes doen wel degelijk iets anders. Namelijk:

TABEL 1

code:

id | keys_van_tabel_1
1  | koptekst 1
2  | koptekst 2

TABEL 2

code:

id | sub_id | keys_van_tabel_2
1  | 1      | subtekst 1.1
1  | 2      | subtekst 1.2
2  | 1      | subtekst 2.1
2  | 2      | subtekst 2.2

Mijn voorbeeld:

code:

koptekst 1
   subtekst 1.1
   subtekst 1.2

koptekst 2
   subtekst 2.1
   subtekst 2.2

FragFrog's voorbeeld:

code:

koptekst 1
   subtekst 1.1
   subtekst 1.2
   subtekst 2.1
   subtekst 2.2

Of ben ik nou gek?

De breaks en de spaties moet je er maar even vanaf denken, voor het overzicht

[Verwijderd]

Hey ik heb een soort gelijk probleem
ik wil een array uit:
$_session()
opslaan in:
$code
de array bestaat uit 4 letters en 2 cijfers
echter krijg ik dit niet voor elkaar.
tevens wil ik de array wegschrijven naar een file...

weet iemand hoe??

alvast bedankt

[NMe]

Het is hier op GoT niet de bedoeling om oude topics te kicken met slechts zijdelings gerelateerde vragen. Je hebt een andere vraag dan de topicstarter, en dus zul je ook een ander topic moeten openen dat voldoet aan Programming Beleid - De "quickstart".

Overigens zie ik dat je hier al een topic over hebt; het lijkt me beter als je daarin verder gaat.