[Mysql] "DISTINCT" op gehele row in result

[Gerwin]

Ik heb een hele reeks Mysql tabellen die ik aan elkaar gekoppeld heb met LEFT JOIN. Nu krijg ik netjes een null veld op plekken waar voor sommige rows in bepaalde kolommen geen waarde gevonden kan worden. Echter ik krijgt nu identieke rows terug omdat een tweetal tabellen dezelfde combinatie gemaakt word (mogelijk zelfs tussen andere tabellen ook). Mijn vraag is nu is het mogelijk om op een gehele row unieke resultaten te krijgen iets van DESTINCT op de gehele row. DISTINCTROW heb ik geprobeerd, maar dat schijnt niet te werken.

[SWINX]

Zou toch moeten werken met DISTINCTROW.
Hoe ziet je query er uit?

[ACM]

Ik snap eerlijk gezegd je vraag niet zo goed? Wat zijn de waarden van die records die je terugkrijgt, want als je gewoon SELECT DISTINCT ... FROM ... doet krijg je toch echt unieke rijen terug.

Wel moet je uitkijken dat in sommige gevallen geldt dat de ene NULL niet gelijk is aan de andere. Ik meen dat dat bij distinct en/of group by niet echt uitmaakt.

[Gerwin]

Ik heb een ruwe schets gemaakt om duidelijk te maken wat het punt is waar ik tegenaanloop.

De volgende tabellen bestaan in de database:

code:

CREATE TABLE IF NOT EXISTS `TabelA` (
  `ID` int(11) NOT NULL,
  `PlaatsID` int(11) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

-- 
-- Gegevens worden uitgevoerd voor tabel `TabelA`
-- 

INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (1, 1);
INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (2, 2);
INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (3, 3);
INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (4, 4);
INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (3, 4);
INSERT INTO `TabelA` (`ID`, `PlaatsID`) VALUES (1, 2);

-- --------------------------------------------------------

-- 
-- Tabel structuur voor tabel `TabelB`
-- 

CREATE TABLE IF NOT EXISTS `TabelB` (
  `PlaatsID` int(11) NOT NULL,
  `Plaats` varchar(10) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

-- 
-- Gegevens worden uitgevoerd voor tabel `TabelB`
-- 

INSERT INTO `TabelB` (`PlaatsID`, `Plaats`) VALUES (2, 'Rotterdam');
INSERT INTO `TabelB` (`PlaatsID`, `Plaats`) VALUES (4, 'Assen');
INSERT INTO `TabelB` (`PlaatsID`, `Plaats`) VALUES (5, 'Utrecht');
INSERT INTO `TabelB` (`PlaatsID`, `Plaats`) VALUES (3, 'Emmen');
INSERT INTO `TabelB` (`PlaatsID`, `Plaats`) VALUES (2, 'Dieren');

-- --------------------------------------------------------

-- 
-- Tabel structuur voor tabel `TabelC`
-- 

CREATE TABLE IF NOT EXISTS `TabelC` (
  `OverigeID` int(11) NOT NULL,
  `Overige` varchar(10) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

-- 
-- Gegevens worden uitgevoerd voor tabel `TabelC`
-- 

INSERT INTO `TabelC` (`OverigeID`, `Overige`) VALUES (1, 'boer');
INSERT INTO `TabelC` (`OverigeID`, `Overige`) VALUES (2, 'kaas');
INSERT INTO `TabelC` (`OverigeID`, `Overige`) VALUES (3, 'eieren');
INSERT INTO `TabelC` (`OverigeID`, `Overige`) VALUES (4, 'vlees');
INSERT INTO `TabelC` (`OverigeID`, `Overige`) VALUES (4, 'vlees');

-- --------------------------------------------------------

-- 
-- Tabel structuur voor tabel `TabelD`
-- 

CREATE TABLE IF NOT EXISTS `TabelD` (
  `ID` int(11) NOT NULL,
  `OverigeID` int(11) NOT NULL
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

-- 
-- Gegevens worden uitgevoerd voor tabel `TabelD`
-- 

INSERT INTO `TabelD` (`ID`, `OverigeID`) VALUES (1, 1);
INSERT INTO `TabelD` (`ID`, `OverigeID`) VALUES (1, 2);
INSERT INTO `TabelD` (`ID`, `OverigeID`) VALUES (2, 3);
INSERT INTO `TabelD` (`ID`, `OverigeID`) VALUES (1, 4);

code:

SELECT *
FROM TabelA
    LEFT JOIN TabelB ON (TabelA.PlaatsID = TabelB.PlaatsID)
    LEFT JOIN TabelD ON (TabelA.ID = TabelD.ID)
    LEFT JOIN TabelC ON (TabelD.OverigeID = TabelC.OverigeID)

Krijg ik dubbele, de result:



Nu kan ik inderdaad wel unieke uit 1 tabel halen, maar het probleem zit hem er juist in dat door het koppelen van de tabellen dubbele rows ontstaan. En die wil ik graag filteren zodat ik enkel unieke rows uit voor mijn query terugkrijg.

[ Voor 24% gewijzigd door Gerwin op 12-08-2007 19:34 ]

[ACM]

En je had DISTINCT geprobeerd, maar wat werkte daar niet aan (en voor syntactische fouten moet je bij de sql-manual's zijn uiteraard...)?

[Gerwin]

DISTINCT werkt uiteraard wel, maar dan blijf je dubbele rows houden. Stel dat je DISTINCT op alle tabellen zou zetten dan krijg je van elke table dus unieke rows en velden, echter bij het op een hoop gooien en na de koppelingen die gemaakt worden heb je dan toch weer dubbele, maar dan samengesteld uit twee of meerdere tabellen. Moet ik het toch zoeken in de DISTINT volgens jou? Moet ik niet iets gebruiken dat NADAT de data is samengesteld de dubbele laat vallen?

[ACM]

Gerwin schreef op zondag 12 augustus 2007 @ 20:33:
DISTINCT werkt uiteraard wel, maar dan blijf je dubbele rows houden.

Euh... die opmerking snap ik dus niet.

Stel dat je DISTINCT op alle tabellen zou zetten dan krijg je van elke table dus unieke rows en velden,

Hoe kan je distinct op een tabel zetten, het is toch onderdeel van je select-query

Moet ik niet iets gebruiken dat NADAT de data is samengesteld de dubbele laat vallen?

Ik weet niet waar jij distinct denkt te moeten plaatsen, maar dat is de enige plek waar ik weet dat het kan... Wellicht dat je dingen met unique keys verward, maar de distinct-clause is een filter voor unieke rows uit een select-query.

[Bolukan]

En als je een DISTINCT op tabelC zet, dan krijg je toch geen dubbele rows meer?? Met andere woorden, kun je door naar de opzet van je tabellen te kijken, dit niet voorkomen?

[DataGhost]

Wat is je query dan precies met DISTINCT erin? Als ik hem namelijk uitvoer krijg ik netjes geen enkele dubbele rij terug hoor Je moet DISTINCT dus op de hele dataset uitvoeren, niet op elke tabel apart (ik neem dus aan dat je dat doet), dan is er namelijk nog steeds de mogelijkheid dat je dubbele rijen krijgt na het joinen.

SQL:

SELECT DISTINCT * 
FROM TabelA
LEFT JOIN TabelB ON ( TabelA.PlaatsID = TabelB.PlaatsID ) 
LEFT JOIN TabelD ON ( TabelA.ID = TabelD.ID ) 
LEFT JOIN TabelC ON ( TabelD.OverigeID = TabelC.OverigeID )

ID	PlaatsID	PlaatsID	Plaats	ID	OverigeID	OverigeID	Overige
1	1	NULL	NULL	1	1	1	boer
1	1	NULL	NULL	1	2	2	kaas
1	1	NULL	NULL	1	4	4	vlees
2	2	2	Rotterdam	2	3	3	eieren
2	2	2	Dieren	2	3	3	eieren
3	3	3	Emmen	NULL	NULL	NULL	NULL
4	4	4	Assen	NULL	NULL	NULL	NULL
3	4	4	Assen	NULL	NULL	NULL	NULL
1	2	2	Rotterdam	1	1	1	boer
1	2	2	Rotterdam	1	2	2	kaas
1	2	2	Rotterdam	1	4	4	vlees
1	2	2	Dieren	1	1	1	boer
1	2	2	Dieren	1	2	2	kaas
1	2	2	Dieren	1	4	4	vlees

[ACM]

Bolukan schreef op zondag 12 augustus 2007 @ 23:04:
En als je een DISTINCT op tabelC zet, dan krijg je toch geen dubbele rows meer?? Met andere woorden, kun je door naar de opzet van je tabellen te kijken, dit niet voorkomen?

Nogmaals: Hoe kan je uberhaupt "een distinct op een tabel zetten"?

DataGhost schreef op maandag 13 augustus 2007 @ 00:27:
Je moet DISTINCT dus op de hele dataset uitvoeren, niet op elke tabel apart (ik neem dus aan dat je dat doet)

En hoe precies zou ie dat kunnen doen? Er mogen helemaal niet meerdere distinct's in een select-list voorkomen toch? Althans, niet als we de count(distinct ...) uitsluiten.

Nouja, strict genomen zou het natuurlijk zo kunnen, maar het lijkt me sterk dat iemand wel dergelijke subqueries kan bedenken, maar niet snapt hoe distinct werkt:

SQL:

SELECT * 
FROM (SELECT DISTINCT * FROM TabelA) as TabelA
LEFT JOIN (SELECT DISTINCT * FROM TabelB) as TabelB
           ON (TabelA.PlaatsID = TabelB.PlaatsID)
LEFT JOIN (SELECT DISTINCT * FROM TabelD) as TabelD
           ON ( TabelA.ID = TabelD.ID ) 
LEFT JOIN (SELECT DISTINCT * FROM TabelC) as TabelC
           ON ( TabelD.OverigeID = TabelC.OverigeID )

[DataGhost]

Nouja, ik vroeg me dus ook min of meer af wat hij dan voor query maakte, verder weet ik niet precies hoe hij dat voor elkaar zou willen krijgen. Het enige wat ik zag was dat hij kennelijk wel DISTINCT gebruikte maar niet het gewenste resultaat kreeg. Dan blijft er voor mij niet zoveel over, hoe onwaarschijnlijk het ook klinkt.
Daarom vroeg ik ook naar zijn precieze query, ben er wel benieuwd naar

[Bolukan]

Ik ben geen SQL expert, maar de code DataGhost is wat ik bedoelde:

SQL:

LEFT JOIN (SELECT DISTINCT * FROM TabelC) as TabelC 
           ON ( TabelD.OverigeID = TabelC.OverigeID )

De eerste genoemde query is echter simpeler te lezen. En nogmaals, de DISTINCT op TabelC is in het voorbeeld voldoende om de dubbele regels te verwijderen. Waarom staan daar dubbele regels in?