[SQL] Ik kom er even niet meer uit

[.Alex]

Om te beginnen alvast excuses voor de titel maar ik had echt geen idee hoe ik het moest noemen. Ik zit met het volgende probleem. Ik heb twee tabellen waarvan ik iets wil selecteren. Ik wil alle oe_id's hebben waarvan er geen soort2 in de bla-tabel staat. Hoe kan ik dit netjes oplossen? Ik ben het zelf echt even kwijt.

----
tabel 'bla'

colums:
bla_id, FK_oe_id, bla_soort

records:
1, 1, "soort1"
2, 2, "soort1"
3, 2, "soort2"
4, 3, "soort1"

----
tabel 'oe'

columns:
oe_id

records:
1
2
3
----

[ Voor 44% gewijzigd door .Alex op 30-10-2007 11:29 . Reden: Tering. Safari onder Windows zuigt. ]

[P.O. Box]

.Alex schreef op dinsdag 30 oktober 2007 @ 11:26:
Om te beginnen alvast excuses voor de titel maar ik had echt geen idee hoe ik het moest noemen. Ik zit met het volgende probleem. Ik heb twee tabellen waarvan ik iets wil selecteren. Ik wil alle oe_id

code:

select oe_id from table

[ Voor 75% gewijzigd door P.O. Box op 30-10-2007 11:28 ]

[Verwijderd]

Iets te snel gepost wellicht?

[Verwijderd]

Gaat u door!

[.Alex]

Excuus! Ik heb niet te vroeg gepost. M'n post was al wel helemaal af. Safari heeft gewoon m'n post verneukt omdat er "vreemde" tekens zoals apostrofs in stonden Daarna moest ik 'm overtypen want óók copypasten lukte niet.

[ Voor 29% gewijzigd door .Alex op 30-10-2007 11:35 . Reden: typo ]

[Dido]

zoiets?

SQL:

select * from oe left outer join bla on oe.oe_id = bla.oe_id
and bla_soort = "soort2"
where bla.oe_id is null

[ Voor 13% gewijzigd door Dido op 30-10-2007 11:44 ]

[Blackbird-ce]

ik dacht aan (waarschijnlijk foeilelijk...):

code:

SELECT oe_id
FROM oe
WHERE oe_id NOT
IN (
SELECT distinct FK_oe_id
FROM bla
WHERE bla_soort = "soort2"
)

[ Voor 1% gewijzigd door Blackbird-ce op 30-10-2007 11:46 . Reden: errr.... moest een = zijn, niet != ]

[.Alex]

Dido schreef op dinsdag 30 oktober 2007 @ 11:36:
zoiets?

SQL:

select * from oe left outer join bla on oe.oe_id = bla.oe_id
and bla_soort = "soort2"
where bla.oe_id is null

Dan selecteert 'ie toch juist de records waar soort2 wél aanwezig is?

Blackbird-ce schreef op dinsdag 30 oktober 2007 @ 11:44:
ik dacht aan (waarschijnlijk foeilelijk...):

code:

SELECT oe_id
FROM oe
WHERE oe_id NOT
IN (
SELECT distinct FK_oe_id
FROM bla
WHERE bla_soort = "soort2"
)

Juist, dit krijg ik werkend! Maar zijn er ook mooiere oplossingen?

[P.O. Box]

vind je dit niet mooi genoeg dan?

[.Alex]

Edwardvb schreef op dinsdag 30 oktober 2007 @ 12:01:
vind je dit niet mooi genoeg dan?

Nouja, als Blackbird-ce zelf stelt dat het waarschijnlijk foeilelijk is zou het aannemelijk zijn dat er mooiere oplossingen zijn

[Martin Sturm]

Volgens mij is de oplossing van Blackbird-ce de mooiste. Het is gebruikt SQL precies zoals het bedoels is, namelijk het uitvoeren van operaties op Sets. Ik zou niet weten hoe het 'mooier' kan. Je kunt het wellicht met allerlei ranzige WHERE-clauses realiseren, maar imho is dat alleen maar lelijker dan deze oplossing met een subquery.

[Dido]

.Alex schreef op dinsdag 30 oktober 2007 @ 11:57:
Dan selecteert 'ie toch juist de records waar soort2 wél aanwezig is?

Nee, want daar is bla.oe_id niet null, en dat is nou net een vereiste

[Voutloos]

Martin Sturm schreef op dinsdag 30 oktober 2007 @ 12:10:
Volgens mij is de oplossing van Blackbird-ce de mooiste. Het is gebruikt SQL precies zoals het bedoels is, namelijk het uitvoeren van operaties op Sets. Ik zou niet weten hoe het 'mooier' kan. Je kunt het wellicht met allerlei ranzige WHERE-clauses realiseren, maar imho is dat alleen maar lelijker dan deze oplossing met een subquery.

De query zoals Dido dus voorstelt is dus echt minder ranzig dan deze dependant subquery.

Nofi, maar in de basic (my)sql topics op GoT wordt echt té vaak naar subqueries gegrepen waar eenvoudige, basic join kennis volstaat.

[Janoz]

@voutloos (en Dido):
Het probleem is (volgens mij) dat het hier om een eis gaat die een enkel record ontstijgt. De query van Dido zal ook 2 terug geven omdat er een record bestaat waarbij geen soort2 staat. Een subquery is hier onvermijdelijk.

[Voutloos]

Ik zie nu inderdaad dat er meerdere rijen met een bepaald oe_id kunnen zijn.

edit:
Maar dan nog kan de query van Dido inderdaad werken, zoals gezegd in Dido in "[SQL] Ik kom er even niet meer uit"

offtopic:
Dan nog blijf ik achter mijn 2e opmerking staan, maar die slaat nu niet op dit topic.

[ Voor 29% gewijzigd door Voutloos op 30-10-2007 14:40 ]

[_js_]

Voutloos schreef op dinsdag 30 oktober 2007 @ 13:01:
[...]
De query zoals Dido dus voorstelt is dus echt minder ranzig dan deze dependant subquery.

Nofi, maar in de basic (my)sql topics op GoT wordt echt té vaak naar subqueries gegrepen waar eenvoudige, basic join kennis volstaat.

Met de subquery is het veel duidelijker wat de query doet. Alle records, behalve die waarvan de soort "soort2" is. Net zoals de TS het formuleerde in zijn vraag.

Een subquery of een join maakt voor de databaseserver niets uit, die optimaliseert dat toch naar de zelfde vraag, dus moet je altijd die variant nemen die het makkelijkst te lezen is.

[.Alex]

_js_ schreef op dinsdag 30 oktober 2007 @ 13:49:
[...]

Met de subquery is het veel duidelijker wat de query doet. Alle records, behalve die waarvan de soort "soort2" is. Net zoals de TS het formuleerde in zijn vraag.

Een subquery of een join maakt voor de databaseserver niets uit, die optimaliseert dat toch naar de zelfde vraag, dus moet je altijd die variant nemen die het makkelijkst te lezen is.

Dat vraag ik me dus af... zijn beide alternatieve écht even snel?

[Voutloos]

Dan moet je zeggen welk dbms je nou gebruikt. Met mysql is het een dependant subquery en dependant subqueries leer je vanzelf wel te mijden als je een beetje grote tabellen hebt.

[justmental]

Voutloos schreef op dinsdag 30 oktober 2007 @ 14:13:
Dan moet je zeggen welk dbms je nou gebruikt. Met mysql is het een dependant subquery en dependant subqueries leer je vanzelf wel te mijden als je een beetje grote tabellen hebt.

Nog even en je gaat roepen dat mysql workarounds mooie oplossingen zijn

De not in is de nette oplossing voor een dbms die er fatsoenlijk mee om kan gaan.

[Dido]

Janoz schreef op dinsdag 30 oktober 2007 @ 13:19:
@voutloos (en Dido):
Het probleem is (volgens mij) dat het hier om een eis gaat die een enkel record ontstijgt. De query van Dido zal ook 2 terug geven omdat er een record bestaat waarbij geen soort2 staat. Een subquery is hier onvermijdelijk.

Ik heb hem net even geprobeerd op een praktijksituatie, en hij doet het gewoon, hoor.

Ik join op de keys en op soort="soort2", en daaruit pak ik de records waarvoor mijn "rechter" deel niet bestaat.

Ik snap niet helemaal wat je bedoelt met "zal ook 2 teruggeven"? Records met soort="soort2" komen niet terug omdat bla.oe_id daar niet NULL is.

[.Alex]

Voutloos schreef op dinsdag 30 oktober 2007 @ 14:13:
Dan moet je zeggen welk dbms je nou gebruikt. Met mysql is het een dependant subquery en dependant subqueries leer je vanzelf wel te mijden als je een beetje grote tabellen hebt.

Fair enough. Ik moet het nu implementeren in een applicatie die draait op MySQL. De tabel 'oe' heeft zo'n 20000 records en de tabel 'bla' is net nieuw, maar voor elk record in tabel 'oe' worden er over het algemeen 2 records in de tabel 'bla' aangemaakt...

[Voutloos]

'Kleine' tabelletjes dus. Maar dan nog zal de query zoals Dido hem schrijft zodra de tabellen ook maar iets groeien een flink performance voordeel tov eentje met dependent subquery bieden.

justmental schreef op dinsdag 30 oktober 2007 @ 14:22:
[...]
Nog even en je gaat roepen dat mysql workarounds mooie oplossingen zijn

Mwah, outer join met filteren op null is qua logica niet eens zo gek veel anders, dus zo'n workaround vind ik het niet. Uiteraard wel jammer dat je bij mysql soms wat meer voorkauw-werk moet doen omdat de optimizer te dom om te poepen is, maar dat went wel.