[Mysql] Complexe query (meer-op-meer relatie) 5 tabellen

[Gerwin]

Ik loop bij het opzetten van een mysql nieuwe database tegen een aantal zaken op.
Ruwweg heb ik een vijftal tabellen zoals in onderstaande afbeelding.



Alle tabellen hebben voor dit voorbeeld de volgende structuur.

code:

TableA
ID (int)
TEXT (text)

Vervolgens wil ik tussen elke tabel een relatie hebben. Zodat ik uiteindelijk een result kan krijgen met alle row conmbinatie's. Om dit mogelijk te makken heb ik op de plekken waar een sterretje staat een meer-op-meer koppeltabel gemaakt "TabelA2TableB", "TableA2TableC", TableB2TableA", etc.

Vervolgens leek het me de manier om vervolgens alle tabellen middels LEFT JOIN aan elkaar te koppelen. Dit is natuurlijk een gigantische lange lijst, echter kom ik op deze manier problemen tegen.

code:

LEFT JOIN `TableA2TableB` USING (`TableAID`)
LEFT JOIN `TableA2TableC` USING (`TableAID`)
LEFT JOIN `TableA2TableD` USING (`TableAID`)
LEFT JOIN `TableA2TableE` USING (`TableAID`)

LEFT JOIN `TableB2TableA` USING (`TableBID`)
LEFT JOIN `TableB2TableC` USING (`TableBID`)
LEFT JOIN `TableB2TableD` USING (`TableBID`)
LEFT JOIN `TableB2TableE` USING (`TableBID`)

LEFT JOIN `TableC2TableB` USING (`TableCID`)
LEFT JOIN `TableC2TableC` USING (`TableCID`)
LEFT JOIN `TableC2TableD` USING (`TableCID`)
LEFT JOIN `TableC2TableE` USING (`TableCID`)

en dan de tabellen daadwerkelijk koppelen middels

code:

LEFT JOIN `TableA` ON (
    `TableA2TableB`.`TableAID` = `TableA`.`TableAID` OR
    `TableA2TableC`.`TableAID` = `TableA`.`TableAID` OR
    `TableA2TableD`.`TableAID` = `TableA`.`TableAID` OR
    `TableA2TableE`.`TableAID` = `TableA`.`TableAID` OR

    `TableB2TableA`.`TableAID` = `TableA`.`TableAID`  OR
    `TableC2TableA`.`TableAID` = `TableA`.`TableAID`  OR
    `TableD2TableA`.`TableAID` = `TableA`.`TableAID`  OR
    `TableE2TableA`.`TableAID` = `TableA`.`TableAID`

)

Ik loop tegen het probleem op dat bepaalde kolommen nog niet bestaan of dat de kolomnaam niet uniek is. Is er in (my)sql misschien een mogelijkheid dit simpeler te doen. Of kan zoiets helemaal niet?

[Verwijderd]

Ik zou me eerder afvragen wat er mis is met je database-ontwerp. En zoals zovelen stel je volgens mij de verkeerde vraag. De vraag is niet "Hoe kan ik dit doen in MySQL?", de vraag is "Hoe moet ik het probleem aanpakken?".

Het lijkt erop alsof je een graaf probeert te modelleren in de database. Welke verschillende soorten gegevens staan er in tabelle A t/m E?

[Y0ur1]

Zo'n graaf heb ik nog nooit gezien in een db Ben benieuwd wat voor een data daar in zit en waarom je hier voor hebt gekozen? Kun je daar wat meer over vertellen? Ik denk dat je databaseontwerp niet helemaal jofel is.

[Gerwin]

Wat er daadwerkelijk in de tabellen staat doet maakt op zich niet veel uit. Maar ik zal hier toch wat over zeggen. Moet je voorstellen dat je bijvoorbeeld een product hebt (tableA), dit product staat bekend onder meerdere namen (tableB), wordt verkocht door meerdere winkels (tableC), heeft verschillende kleuren (tableD), heeft verschillende optie's (tableE).

TableA
- niet alle producten hebben dezelfde namen (koppeltable A-B)
- niet alle producten hebben dezelfde winkels (koppeltable A-C)
- niet alle producten hebben dezelfde kleuren (koppeltable A-D)
- niet alle producten hebben dezelfde opties (koppeltable A-E)

Table B
- niet alle namen hebben dezelfde producten (koppeltable B-A)
- niet alle namen hebben dezelfde winkels (koppeltable B-C)
- niet alle namen hebben dezelfde kleuren (koppeltable B-D)
- niet alle namen hebben dezelfde opties (koppeltable B-E)

Table C
- niet alle winkels hebben dezelfde producten (koppeltable C-A)
- niet alle winkels hebben dezelfde namen (koppeltable C-B)
- niet alle winkels hebben dezelfde kleuren (koppeltable C-D)
- niet alle winkels hebben dezelfde opties (koppeltable C-E)

Table D
- niet alle kleuren hebben dezelfde producten (koppeltable D-A)
- niet alle kleuren hebben dezelfde namen (koppeltable D-B)
- niet alle kleuren hebben dezelfde winkels (koppeltable D-C)
- niet alle kleuren hebben dezelfde opties (koppeltable D-E)

Table E
- niet alle opties hebben dezelfde producten (koppeltable E-A)
- niet alle opties hebben dezelfde namen (koppeltable E-B)
- niet alle opties hebben dezelfde winkels (koppeltable E-C)
- niet alle opties hebben dezelfde kleuren (koppeltable E-D)


Het is nogal een complex verhaal. Ik wil als er een product bijkomt dus exact opslaan welke namen het product heeft, welke winkels, kleuren, opties, etc het heeft.

Nu wil ik een lijst hebben met alle mogelijkheden in de database.
Alle "producten-namen-winkels-kleuren-opties-plaatjes" mogelijkheden.
Maar dan wel middels een koppeltabel omdat niet alles op alles is.

Ik hoop dat dit alles het iets duidelijker maakt.

[ Voor 49% gewijzigd door Gerwin op 14-10-2007 01:18 ]

[OnTracK]

Wat dacht je van in plaats van íedere tabel met íedere tabel te koppelen, álles in één koppeltabel te doen.

winkels (id, winkel)
produkten (id, produkt)
namen (id, naam)
opties (id, optie)
plaatjes (id, plaatje)
winkelinhoud (winkel_id, produkt_id, naam_id, optie_id, plaatje_id)

Op deze manier staat in winkelinhoud iedere mogelijke combinatie van produkten zoals deze in een winkel verkocht worden. Hierbij ga ik ervan uit dat íedere combinatie van produkt/naam mogelijk is. Waarschijnlijk is dit niet het geval en wil je van "namen" meer een soort "produktinstances" maken. Oftewel een bepaalde produktnaam is een afgeleide van produkt, deze hebben dan een bepaalde naam en worden verkocht in een winkel, dan krijg je zoiets:

namen (id, produkt_id, naam)
winkelinhoud (winkel_id, naam_id, optie_id, plaatje_id)

Maar weer andere vormen zijn mogelijk afhankelijk van waar je constraints liggen.

[ Voor 40% gewijzigd door OnTracK op 14-10-2007 01:27 ]

[Gerwin]

OnTrack moet ik in jou voorstel dan niet alle combinaties zelf in de database zetten (onbegonnen werk). Ik had juist voor ogen dit lekker door de database te laten doen en enkel de "key's" op te geven. Als er een relatie met A naar B is dan heeft op zijn beurt B ook weer relaties met C,D,E en die op hun beurt ook weer. Zoiets moet toch met een paar joins te fixen zijn?

[Pete]

Wat voor relatie hebben kleuren en winkels? En wat voor relatie hebben namen en opties?

De relatie die er bestaan gaan allemaal over een product. Dus winkel -> heeft producten -> heeft kleur.

Het database schema dat OnTrack aangeeft is veel beter. (zonder meer info kan het niet beter). Je moet niet willen om het te doen met je eigen database model. Naast het feit dat het gans onduidelijk is wat het betekent als een winkel een bepaalde kleur heeft kun je niet eens alles kwijt in dit datamodel.

Als we het alleen over kleuren producten en winkels hebben. Kleuren A en B, producten J en K en winkels Y en Z
Product J wordt verkocht in alle kleuren.
Winkel Y verkoopt Product J in kleur A en product K in kleur B
Winkel X verkoopt Product J in kleur B en product K in kleur A

Hoe zou je dit in jouw databasemodel gaan representeren? Dit kan niet.

Natuurlijk ga je bij het goede databasemodel geen combinaties zelf in een database zetten. Ik neem aan dat je een datasource hebt waarvanuit je je eigen databasemodel zou willen vullen, die datasource kun je ook gewoon in het nieuw datamodel kwijt.

Tip: Ga eens lezen over functionele afhankelijkheden en database normalisatie.

[Gerwin]

Complex allemaal. Ik wil de mogelijkheid willen houden om bijvoorbeeld een plaatje aan een titel te koppelen. Vervolgens moet vanuit die titel het plaatje ook automatisch gekoppeld zijn aan alle rows waar die titel aan gekoppeld is.


Hieronder een export van mijn voorbeelddatabase. Alles moet zo aan elkaar gekoppeld worden dat er automatisch het noodzakelijke aantal rows gegenereerd word om aan relaties te kunnen voldoen. Zoals je ziet hebben alle records relaties met records in andere tabellen. Titels zijn gekoppeld aan plaatjes, producten, winkels. En op hun beurt hebben die ook weer relaties met andere records. En die vervolgens ook weer.

code:

--
-- Table structure for table `Company`
--

CREATE TABLE IF NOT EXISTS `Company` (
  `CompanyID` int(10) unsigned NOT NULL auto_increment,
  `Company` char(100) NOT NULL,
  PRIMARY KEY  (`CompanyID`),
  UNIQUE KEY `Company` (`Company`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

--
-- Dumping data for table `Company`
--

INSERT INTO `Company` (`CompanyID`, `Company`) VALUES(1, 'Company1');
INSERT INTO `Company` (`CompanyID`, `Company`) VALUES(2, 'Company2');

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

--
-- Table structure for table `Description`
--

CREATE TABLE IF NOT EXISTS `Description` (
  `DescriptionID` int(10) unsigned NOT NULL auto_increment,
  `Description` text NOT NULL,
  PRIMARY KEY  (`DescriptionID`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=7 ;

--
-- Dumping data for table `Description`
--

INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(1, 'Description from Company1');
INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(2, 'Description from Product1');
INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(3, 'Description from Title1');
INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(4, 'Description from Image1');
INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(5, 'Description from Title2 and Product4');
INSERT INTO `Description` (`DescriptionID`, `Description`) VALUES(6, 'Description from Image2 and Product1');

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

--
-- Table structure for table `Image`
--

CREATE TABLE IF NOT EXISTS `Image` (
  `ImageID` int(10) unsigned NOT NULL auto_increment,
  `Image` char(250) NOT NULL,
  PRIMARY KEY  (`ImageID`),
  UNIQUE KEY `Image` (`Image`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

--
-- Dumping data for table `Image`
--

INSERT INTO `Image` (`ImageID`, `Image`) VALUES(1, 'Image1 from Company1');
INSERT INTO `Image` (`ImageID`, `Image`) VALUES(2, 'Image2 from Product1 and Description3');
INSERT INTO `Image` (`ImageID`, `Image`) VALUES(3, 'Image3 from Title1 and Title3');
INSERT INTO `Image` (`ImageID`, `Image`) VALUES(4, 'Image4 from Description1');

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

--
-- Table structure for table `Producten`
--

CREATE TABLE IF NOT EXISTS `Producten` (
  `ProductID` int(10) unsigned NOT NULL auto_increment,
  `Product` char(100) NOT NULL,
  PRIMARY KEY  (`ProductID`),
  UNIQUE KEY `Product` (`Product`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=5 ;

--
-- Dumping data for table `Producten`
--

INSERT INTO `Producten` (`ProductID`, `Product`) VALUES(1, 'Product1 from Company1 and Company2');
INSERT INTO `Producten` (`ProductID`, `Product`) VALUES(2, 'Product2 from Company1');
INSERT INTO `Producten` (`ProductID`, `Product`) VALUES(3, 'Product3 from Company2');
INSERT INTO `Producten` (`ProductID`, `Product`) VALUES(4, 'Product4 from Company2');

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

--
-- Table structure for table `Title`
--

CREATE TABLE IF NOT EXISTS `Title` (
  `TitleID` int(10) unsigned NOT NULL auto_increment,
  `Title` char(100) NOT NULL,
  PRIMARY KEY  (`TitleID`),
  UNIQUE KEY `Title` (`Title`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=7 ;

--
-- Dumping data for table `Title`
--

INSERT INTO `Title` (`TitleID`, `Title`) VALUES(1, 'Title1 from Company1');
INSERT INTO `Title` (`TitleID`, `Title`) VALUES(2, 'Title2 from Product1 and Product4');
INSERT INTO `Title` (`TitleID`, `Title`) VALUES(3, 'Title3 from Description1');
INSERT INTO `Title` (`TitleID`, `Title`) VALUES(4, 'Title4 from Image1');
INSERT INTO `Title` (`TitleID`, `Title`) VALUES(5, 'Title5 from Product3');

[Pete]

Je bent al bezig met de implementatie. Je kunt beter beginnen met het design. Dat is wat ik bedoel met functionele afhankelijkheden en nomalisatie. Zoek uit wat je precies wilt. En begin pas met het denken in SQL zodra je je datamodel afhebt.

[NMe]

Ik heb hier maar één opmerking over. Pas je op dat je, door het zo generiek te willen doen, niet uit het oog verliest wat je applicatie eigenlijk doen moet? Er is een reden dat de manier die OnTrack hierboven noemt het meest toegepast wordt, en ik gok dat dat te maken heeft met performance en onderhoudbaarheid.

[KopjeThee]

-NMe- schreef op zondag 14 oktober 2007 @ 14:32:
Ik heb hier maar één opmerking over. Pas je op dat je, door het zo generiek te willen doen, niet uit het oog verliest wat je applicatie eigenlijk doen moet? Er is een reden dat de manier die OnTrack hierboven noemt het meest toegepast wordt, en ik gok dat dat te maken heeft met performance en onderhoudbaarheid.

Het idee van de TS doet me een beetje denken een Data vault modelleren. Misschien kan hij/zij daar eens op googelen en implementatie voorbeelden te vinden.

[Verwijderd]

volgens mij wil je gewoon een cartetisch produkt; alle mogelijke combinaties van rijen uit de tabellen.

voorbeeld: 3 tabellen met elk 2 rijen: als tabellen A, B en C elk 2 rijen hebben 1,2 krijg je zonder where clause alle combinaties:

select * from A,B,C

A1, B1, C1
A1, B1, C2
A1, B2, C1
A1, B2, C2
A2, B1, C1
A2, B1, C2
A2, B2, C1
A2, B2, C2

voor 3 tabellen met elk 2 rijen krijg je dan: 2 * 2 * 2 = 8 combinaties.

[Gerwin]

Ik heb dat artikel van Data vault doorgelezen en het heeft er volgens mij wel iets van weg, het is echter niet zo zoals Bierbuik zegt dat ik van alle rijen alle combinaties wil hebben. Ik zou haast willen zeggen juist niet.

Het design van de database zit zo in mijn hoofd:

code:

.                                             /--omschrijving
                                             /
                                            /-- kleuren
                                           /
                                 /--titel----plaatje
                                /
                               /
                              /               /--titel
                             /               /
                            /               /-- kleuren
                           /---omschrijving--
                          /                 \--plaatje
                         /
                        /
                       /              /-- titel
                      /              /
                     /              /--omschrijving
                    /              /
              Product----kleuren--/--plaatje
             /      \
            /        \
           /          \
          /            \  
Winkels---              \
          \              \----plaatje--\--titel
           \                            \
            \                            \--omschrijving
             \                            \
              Product                      \--kleuren
                 (idem)

Zoals je ziet heeft elk item een reeks (of juist geen) eigen relaties met de andere tabellen. Het probleem zit hem dan ook niet zozeer in de "eerste JOIN reeks". Maar als ik bovenstaande titel gejoind heb middels een koppeltabel en de omschrijving ook, dan moet ik deze opnieuw JOINEN (zie de nieuwe relatie "na" titel. Daarna voorzie ik ook weer problemen omdat die Omschrijving natuurlijk ook weer een JOIN heeft op al het andere (als dat in een koppeltabel van die Omschrijving staat.

SELECT * FROM
Winkels
LEFT JOIN Product2Winkels ON Product2Winkels.Winkels.ID = Winkels.WinkelsID
LEFT JOIN Product ON Product.ProductID = Product2Winkels.ProductID

LEFT JOIN Titel2Product ON Titel2Product.ProductID = Product.ProductID
LEFT JOIN Titel ON Titel.TitelID = Titel2Product.TitelID

LEFT JOIN Omschrijving2Product ON Omschrijving2Product.ProductID = Product.ProductID
LEFT JOIN Omschrijving ON Omschrijving.OmschrijvingID = Omschrijving2Product.OmschrijvingID

LEFT JOIN Kleuren2Product ON Kleuren2Product.ProductID = Product.ProductID
LEFT JOIN Kleuren ON Kleuren.KleurenID = Kleuren2Product.KleurenID

LEFT JOIN Plaatje2Product ON Plaatje2Product.ProductID = Product.ProductID
LEFT JOIN Plaatje ON Plaatje.PlaatjeID = Plaatje2Product.PlaatjeID

--
LEFT JOIN (de titel tabel), en voeg alle relaties op Omschrijving2Titel toe???

Dit slikt de mysql database niet, ik heb immers al een join "Omschrijving" gedaan, en toch wil ik die in dezelfde row hebben. Daarbij komt het probleem als alle Omschrijvingen inderdaad geJOINT zijn op de titel het volgende probleem, moet vervolgens de Titel ook weer geJOINT worden op de Omschrijving. (alles middels een koppeltabel)

[Pete]

Jouw probleem kun je simpel oplossen door tabel aliassen te gebruiken. Dus bijv.

SQL:

SELECT a.id, a2.*
FROM aardappels a 
JOIN aardappels a2 ON (a.child = a2.id)

Maar toch zeg ik het nog een keer, weet je zeker dat je nu niet een level "te diep" gaat. Zoiezo zou je hier misschien dan makkelijker kunnen werken met een iets minder genormaliseerde tabel waar je null waarden in toelaat.

[Gerwin]

phsmit schreef op maandag 15 oktober 2007 @ 14:36:
Jouw probleem kun je simpel oplossen door tabel aliassen te gebruiken. Dus bijv.

SQL:

SELECT a.id, a2.*
FROM aardappels a 
JOIN aardappels a2 ON (a.child = a2.id)

Maar toch zeg ik het nog een keer, weet je zeker dat je nu niet een level "te diep" gaat. Zoiezo zou je hier misschien dan makkelijker kunnen werken met een iets minder genormaliseerde tabel waar je null waarden in toelaat.

Krijg je dan geen dubbele kolommen op je rij "aardappelen". Of in mijn geval "titel".

Je JOINT een keer de Titel op Product en vervolgens JOIN je die Titel op andere zaken...?

Begint allemaal iets duidelijker te worden, maar wel complex.

Bestaat er in Mysql ook zoiets als:

SELECT TableA.Naam & TableB.Naam as Naam?

[Dido]

Gerwin schreef op maandag 15 oktober 2007 @ 14:31:
Het design van de database zit zo in mijn hoofd:

Wow.

Wat betekenen de lijntjes in dat schema?
Wat links staat "heeft" wat rechts staat, dus winkels hebben producten?

Dan vraag ik me af wat het betekent, in simpel Nederlands, dat "kleuren" een "plaatje" hebben.

Ik heb misschien een gloednieuw stuk ontwikkeling gemist, maar jouw plaatje en het woord databaseontwerp zou ik tot 2 minuten geleden niet met elkaar in verband gebracht hebben.

Ik ben niet de eerste die het zegt, maar ik zou een paar stappen terug doen, en de hele implementatie vergeten tot je een daadwerkelijk inzichtelijk, werkbaar, begrijpelijk en liefst enigszins gestandaardiseerd modelhebt.

[Gerwin]

Het is allemaal wat ingewikkeld, daT moet ik zelf ook bekennen, echter zou ik niet weten hoe ik dat anders aan elkaar moet zetten. Of (meer) gestandaardiseerd kan krijgen.

Je moet je voorstellen dat ik bijvoorbeeld Producten heb. Alle producten worden van één of meerdere Titels, Omschrijving, Plaatje, etc. voorzien. Dat is geen enkel probleem, krijg ik netjes rows van alle combinaties.

De "trouble" ontstaat op het moment dat ik aan de reeds gejoinde rows andere optieś op alle extra rows wil hebben.

Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 1
Company 1 - Product 2 - Titel 2 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 3 - Omschrijving 3 - Plaatje 2
Company 1 - Product 3 - Titel 4 - Omschrijving 2 - Plaatje 4
etc..

Maar nu wil ik op waar overal Product 2 is als extra Titel 4 hebben

Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 1
Company 1 - Product 2 - Titel 2 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 3 - Omschrijving 3 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 3 - Plaatje 2
Company 1 - Product 3 - Titel 4 - Omschrijving 2 - Plaatje 4
etc..

en alle Omschrijvingen 1 krijgen Plaatje 5 erbij

Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 1
Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 5
Company 1 - Product 2 - Titel 2 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 3 - Omschrijving 3 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 3 - Plaatje 2
Company 1 - Product 3 - Titel 4 - Omschrijving 2 - Plaatje 4

Alle plaatsen waar Plaatje 4 bestaat krijgen Titel 6 erbij

Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 1
Company 1 - Product 1 - Titel 1 - Omschrijving 1 - Plaatje 5
Company 1 - Product 2 - Titel 2 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 3 - Omschrijving 3 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 2 - Plaatje 2
Company 1 - Product 2 - Titel 4 - Omschrijving 3 - Plaatje 2
Company 1 - Product 3 - Titel 4 - Omschrijving 2 - Plaatje 4
Company 1 - Product 3 - Titel 6 - Omschrijving 2 - Plaatje 4

etc etc.

Alleen hoe dat aan elkaar te "lussen" is mij niet helemaal duidelijk. Ik kom met dubbele rows uit.

Suggesties en opties zijn welkom..

[Verwijderd]

Misschien een schot voor open doel... Maar is 't koste wat kost nodig om alles in één enkele query te proppen? Is het misschien niet een stuk eenvoudiger om dit alles in stukjes op te splitsen?

Verder ben ik het eens met de mening van de massa in dit draadje: je database ontwerp komt op z'n minst vreemd over. Ik vraag me bijvoorbeeld af wie je het enorme karwei van alle omschrijvingen die in je systeem hebt staan laat invullen ;-)

Misschien een optie om e.e.a. in een koppeltabel te proppen?

Je hebt de volgende tabellen:
- Product
- Kleur
- ProductKleur

In de tabel ProductKleur heb je een primary key die bestaat uit productid en kleurid, beide foreign keys naar de respectievelijke tabellen. Daarbij heb je nog de velden titel, omschrijving, plaatje.

Heb je dan niet eigenlijk alles wat je wil? Als ik je goed begrijp heb je een product in een bepaalde kleur, die een titel, omschrijving en plaatje hebben. Met wat slim ge-query kan je uit de drie tabellen die ik noemde een hoop informatie ophalen...

[edit]
Wil je meer dan één combinatie van alles, dan voeg je een identity veld toe aan je koppeltabel die je PK maakt.
Als je plaatjes wilt hergebruiken, maak je een plaatjes tabel aan + relatie met je productkleur tabel (die je dan misschien beter ProductCompositie oid kan noemen)... Is dat iets?

[ Voor 12% gewijzigd door Verwijderd op 15-10-2007 23:55 ]

[Gerwin]

Ik had het idee dat als het middels één grote query mogelijk zou moeten zijn om die combinaties allemaal door mysql te laten regelen. In de relatiestructeur komt tot op zekere hoogte een soort van "loop" voor.

product krijgt titel erbij,
titel krijgt omschrijving erbij,
omschrijving krijgt plaatje erbij,
plaatje krijgt titel erbij (!),
titel krijgt omschrijving erbij (!).

Op het moment dat ik nadat ik een relatie heb gelegd middels een koppeltabel tussen de eerste titel en omschrijving gaat het problemen geven als er vervolgens voor elke omschrijving en plaatje combinaties vervolgens weer nieuwe titel rows ontstaan. Als ik stuk voor stuk selectieś doe mis ik de updates aan de rows van de vorige relaties zegmaar.

Een manier om twee kolommen die joins hebben met één (of meerdere andere kolommen) samen te voegen in één kolom zou welkom zijn. Dit lost dan ook het probleem op middels de "relaties die later gelegd worden en ook effect hebben op eerdere gelegde relaties".

Dat idee met één grote koppeltabel is misschien wel iets, moet je wel "alles" zelf bijhouden, en dat had ik nu toch graag automatisch door de database laten doen.

[RobIII]

Het is hier al vaker gezegd; maar ik mis nog steeds een heel stuk normalisatie in je verhaal. Dit is als welbedoelde tip dus ook wat ik je wil meegeven: lees je even in in databasenormalisatie. Dat is geen rocket science en moet met een middagje oefenen (aardig) onder de knie te krijgen zijn. Je zult misschien geen expert worden maar je zult wel snel zien dat het ontwerp dat je nu hebt op z'n zachtst gezegd vreemd te noemen is
Mocht je gaan googlen op database normalisatie (of een goed boek uit een schap van, ik noem maar eens wat, een bilbliotheek trekken _{bestaan die nog anno 2007?} ) hou dan wel in je achterhoofd dat normalisatie ook geen heilige en 'final' oplossing zal geven. Een goed model kan prima her- en der wat gedenormaliseerde data bevatten; zolang er maar een gegronde reden voor is.

[ Voor 41% gewijzigd door RobIII op 16-10-2007 01:58 ]

[Gerwin]

Ik heb me ingelezen op normalisatie. Dit is me allemaal bekend, alleen had ik tit niet onder de titel Normalisatie geplaatst. Echter is me niet duidelijk hoe het geheel van normalisatie in een kopppelingstructuur past waarin de soort van "loop" en "met terugwerkende kracht" zit. Dus:

Company -> Company2Product -> Product -> Product2Title -> Title -> Title2Company -> Company

De Titel is dus afhankelijk van CompanyID en Product ID zegmaar.

[ Voor 17% gewijzigd door Gerwin op 16-10-2007 12:01 ]

[Verwijderd]

Titel is afhankelijk van CompanyID en ProductID... Dan heb je toch een tabel Product, Company en een koppeltabel tussen beide? Met als extra veld in je koppeltabel 'titel' ?

[Pete]

Het probleem is dat je op dit moment kijkt vanuit de "bewerkingen" ipv naar de data.

Je datamodel gaat in eerste instantie hoe je je data het beste kan opslaan. Hoe je later makkelijk aan een bepaalde groep artikelen een beschrijving toe voegt dat zie je later wel. Eerst moet je dus een clean databasemodel maken, en daarna (als je echt gegronde redenen hebt) pas optimalisaties toepassen om eenvoudige bewerkingen te kunnen doen.

Voorbeeld (als je een stermodel hebt vanuit product (dus iedere andere eigenschap heeft een relatie met product)) dan:
Voeg omschrijving "doei" toe aan alle rode producten:

SQL:

INSERT INTO product_omschrijving (productid, omschrijvingid) 
SELECT pk.productid, o.omschrijvingid FROM product_kleur pk JOIN kleur k ON (pk.kleurid = k.id) JOIN omschrijving o
WHERE o.text LIKE 'doei' and k.kleur LIKE 'rood'

[Gerwin]

Dat klopt maar nu zijn er natuurlijk meer relaties. Ik weet ook niet hoe ik het nog duiderlijker uit kan leggen.

Als ik aan onderstaande regels wil voldoen kom ik er niet uit:

- alle winkels hebben meerdere producten (Winkel2Producten)

- alle producten hebben meerdere titels (Producten2Titel)
- alle producten hebben meerdere omschrijvingen (Producten2Omschrijving)
- alle producten hebben meerdere plaatjes (Producten2Plaatje)

- alle titels hebben meerdere producten (kan in Producten2Titel ^ )
- alle titels hebben meerdere omschrijvingen (Titel2Omschrijving)
- alle titels hebben meerdere plaatjes (Titel2Plaatje)

- alle omschrijvingen hebben meerdere producten (kan in Product2Omschrijving ^ )
- alle omschrijvingen hebben meerdere titels (kan in Titel2Omschrijving ^ )
- alle omschrijvingen hebben meerdere plaatjes (Omschrijving2Plaatje)

- alle plaatjes hebben meerdere producten (kan in Product2Plaatje ^ )
- alle plaatjes hebben meerdere titels (kan in Titel2Plaatje ^ )
- alle plaatjes hebben meerdere omschrijvingen (kan in Omschrijving2Plaatje ^ )

waar een ^ staat is eigenlijk niet nodig omdat die relatie reeds bestaat.

Nu komt het:

SQL:

SELECT Winkel, Product, Titel, Omschrijving, Plaatje
FROM Winkel

LEFT JOIN Winkel2Producten ON Winkel.WinkelID = Winkel2Product.WinkelID
LEFT JOIN Product ON Winkel2Product.ProductID = Product.ProductID

LEFT JOIN Product2Titel ON Product.ProductID = Product2Titel.ProductID
LEFT JOIN Titel ON Product2Titel.TitelID = Titel.TitelID

LEFT JOIN Product2Omschrijving ON Product.ProductID = Product2Omschrijving.ProductID
LEFT JOIN Omschrijving ON Product2Omschrijving.ProductID = Omschrijving.OmschrijvingID

LEFT JOIN Product2Plaatje ON Product.ProductID = Product2Plaatje.ProductID
LEFT JOIN Plaatje ON Product2Plaatje.PlaatjeID = Plaatje.PlaatjeID

LEFT JOIN Titel2Omschrijving ON Titel.TitelID = Titel2Omschrijving.TitelID
LEFT JOIN Titel ON Titel2Omschrijving.TitelID = Titel.TitelID

LEFT JOIN Titel2Plaatje ON Titel.TitelID = Titel2Plaatje.TitelID
LEFT JOIN Plaatje ON Titel2Plaatje.PlaatjeID = Plaatje.PlaatjeID

LEFT JOIN Omschrijving2Plaatje ON Plaatje.PlaatjeID = Omschrijving2Plaatje.PlaatjeID
LEFT JOIN Plaatje ON Omschrijving2Plaatje.PlaatjeID = Plaatje.PlaatjeID

Deze code loopt mank. Het probleem ontstaat op regel 15. Als ik aan de titel een extra omschrijving wil koppelen en daarmee alle rows met die titel dus "verdubbel". De Titel is ineens niet meer uniek. Eerder in het topic is gezegd dan een alias te gebruiken. Dat is een mogelijkheid, echter krijg ik dan niet in alle gevallen extra rows en zit ik met twee extra kolommen in de output. Ik wil gewoon uiteindelijk hebben

[Pete]

Denk nog even goed na of de volgende relaties wel echt bestaan:
- alle titels hebben meerdere omschrijvingen (Titel2Omschrijving)
- alle titels hebben meerdere plaatjes (Titel2Plaatje)
- alle omschrijvingen hebben meerdere titels (kan in Titel2Omschrijving ^ )
- alle omschrijvingen hebben meerdere plaatjes (Omschrijving2Plaatje)
- alle plaatjes hebben meerdere titels (kan in Titel2Plaatje ^ )
- alle plaatjes hebben meerdere omschrijvingen (kan in Omschrijving2Plaatje ^ )

Dat kan ik nl. niet echt geloven. Helemaal niet als de omschrijving voor een plaatje hetzelfde is als de omschrijving voor een product. Nee, die omschrijving van een plaatje is een omschrijving van het product.
Zoiezo, wat moet ik me voorstellen bij een titel met een omschrijving? Je bedoelt waarschijnlijk weer een omschrijving voor een product.

[Dido]

Ik begin ondertussen te zien wat j evoor iets recursiefs in je datamodel hebt zitten (hoewel het me nog steed seen raadsel is wat je met die query wilt, maar goed).

Wat iedereen instinctief zal begrijpen is dat je producten hebt en dat een product titels, omschrijvingen en plaatjes kan hebben.

Wat jij echter stelt is dat een omschrijving ook op een plaatje kan slaan, en een plaatje op een titel.

Daar raak je mij, en met mij denk ik velen, kwijt.

Ik heb zoiets al eerder gevraagd: wat betekent in normaal Nederlands dat een plaatje een titel heeft?
En dat een product een titel heeft?

En zijn die titels in die twee zinnen gelijke entiteiten, of heb je plaatjestitels en producttitels.

[ Voor 0% gewijzigd door Dido op 16-10-2007 13:53 . Reden: wat phsmit dus zegt :P ]

[Gerwin]

De relaties die ik noemde bestaan echt. Er is een titel gekoppeld aan bijvoorbeeld het product "Fiets". Deze heeft als titel "Fiets" gekoppeld. Vervolgens heeft het product fiets de volgende plaatjes fiets-rood.jpg, fiets-blauw.jpg.

De volgende rows ontstaan:

Fiets - Fiets - fiets-rood.jpg
Fiets - Fiets - fiets-blauw.jpg

Nu wordt er aan fiets-rood.jpg een extra titel "Fiets rood" gekoppeld.
Er ontstaan nu ineens 3 rows. De vorige twee bestaan nog, maar er is een extra row ontstaan waar het plaatje fiets-rood.jpg was. Merk op dat de gekoppelde titel "Fiets" ook nog gekoppeld is aan product "Fiets".

Fiets - Fiets - fiets-rood.jpg
Fiets - Fiets rood - fiets-rood.jpg
Fiets - Fiets - fiets-blauw.jpg

Er zullen dus in de toekomst inderdaad bijvoorbeeld titels en omschrijvingen gebaseerd worden niet op direct het product maar ook op het plaatje bijvoorbeeld, echter wil ik dan toch de oorspronkelijke titels en omschrijvingen behouden en moeten er extra rows ontstaan doordat er voor het plaatje andere omschrijvingen zijn gekoppeld. Echter doordat eerder in de query de titel en omschrijving reeds aan product gekoppeld is zie ik geen mogelijkheid om de waardes van die kolom afhankelijk te maken van twee zaken (kolom titel = product & plaatje).

Ik zoek dan ook iets waarmee ik in één query een kolomnaam kan koppelen aan meerdere andere kolommen. Iets als

code:

LEFT JOIN Title ON 
Title.TitleID = Title2Company.TitleID &&
Title.TitleID = Title2Product.TitleID &&
Title.TitleID = Title2Description.TitleID &&
Title.TitleID = Title2Plaatje.TitleID

LEFT JOIN Description ON 
Description.DescriptionID = Description2Company.DescriptionID &&
Description.DescriptionID = Description2Product.DescriptionID &&
Description.DescriptionID = Description2Title.DescriptionID &&
Description.DescriptionID = Description2Plaatje.DescriptionID

etc.

[Gerwin]

Als test heb ik het volgende opgezet om alles makkelijker te maken ook hier op het forum.

Ter illustratie is hier een relatie via de Shop->Product en Product->Shop. Voor de één ben ik de ene nodig en voor de andere de ander. Ze moeten dus tegelijk gejoind worden (ofzo).

SQL:

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

--
-- Tabel structuur voor tabel `Description`
--

CREATE TABLE IF NOT EXISTS `Description` (
  `Description` int(10) unsigned NOT NULL auto_increment,
  `DescriptionID` char(100) NOT NULL,
  PRIMARY KEY  (`Description`),
  UNIQUE KEY `Winkel` (`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

--
-- Gegevens worden uitgevoerd voor tabel `Description`
--


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

--
-- Tabel structuur voor tabel `Description2Image`
--

CREATE TABLE IF NOT EXISTS `Description2Image` (
  `DescriptionID` int(10) unsigned NOT NULL,
  `ImageID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`DescriptionID`,`ImageID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Description2Image`
--


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

--
-- Tabel structuur voor tabel `Description2Product`
--

CREATE TABLE IF NOT EXISTS `Description2Product` (
  `DescriptionID` int(10) unsigned NOT NULL,
  `ProductID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`DescriptionID`,`ProductID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Description2Product`
--


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

--
-- Tabel structuur voor tabel `Description2Shop`
--

CREATE TABLE IF NOT EXISTS `Description2Shop` (
  `DescriptionID` int(10) unsigned NOT NULL,
  `ShopID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`DescriptionID`,`ShopID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Description2Shop`
--


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

--
-- Tabel structuur voor tabel `Description2Title`
--

CREATE TABLE IF NOT EXISTS `Description2Title` (
  `DescriptionID` int(10) unsigned NOT NULL,
  `TitleID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`DescriptionID`,`TitleID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Description2Title`
--


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

--
-- Tabel structuur voor tabel `Image`
--

CREATE TABLE IF NOT EXISTS `Image` (
  `ImageID` int(10) unsigned NOT NULL auto_increment,
  `Image` char(100) NOT NULL,
  PRIMARY KEY  (`ImageID`),
  UNIQUE KEY `Winkel` (`Image`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

--
-- Gegevens worden uitgevoerd voor tabel `Image`
--


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

--
-- Tabel structuur voor tabel `Image2Description`
--

CREATE TABLE IF NOT EXISTS `Image2Description` (
  `ImageID` int(10) unsigned NOT NULL,
  `DescriptionID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ImageID`,`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Image2Description`
--


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

--
-- Tabel structuur voor tabel `Image2Product`
--

CREATE TABLE IF NOT EXISTS `Image2Product` (
  `ImageID` int(10) unsigned NOT NULL,
  `ProductID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ImageID`,`ProductID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Image2Product`
--


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

--
-- Tabel structuur voor tabel `Image2Shop`
--

CREATE TABLE IF NOT EXISTS `Image2Shop` (
  `ImageID` int(10) unsigned NOT NULL,
  `ShopID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ImageID`,`ShopID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Image2Shop`
--


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

--
-- Tabel structuur voor tabel `Image2Title`
--

CREATE TABLE IF NOT EXISTS `Image2Title` (
  `ImageID` int(10) unsigned NOT NULL,
  `DescriptionID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ImageID`,`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Image2Title`
--


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

--
-- Tabel structuur voor tabel `Product`
--

CREATE TABLE IF NOT EXISTS `Product` (
  `ProductID` int(10) unsigned NOT NULL auto_increment,
  `Product` char(100) NOT NULL,
  PRIMARY KEY  (`ProductID`),
  UNIQUE KEY `Winkel` (`Product`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

--
-- Gegevens worden uitgevoerd voor tabel `Product`
--

INSERT INTO `Product` (`ProductID`, `Product`) VALUES(1, 'Product1');
INSERT INTO `Product` (`ProductID`, `Product`) VALUES(2, 'Product2');

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

--
-- Tabel structuur voor tabel `Product2Description`
--

CREATE TABLE IF NOT EXISTS `Product2Description` (
  `ProductID` int(10) unsigned NOT NULL,
  `DescriptionID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ProductID`,`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Product2Description`
--


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

--
-- Tabel structuur voor tabel `Product2Image`
--

CREATE TABLE IF NOT EXISTS `Product2Image` (
  `ProductID` int(10) unsigned NOT NULL,
  `ImageID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ProductID`,`ImageID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Product2Image`
--


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

--
-- Tabel structuur voor tabel `Product2Shop`
--

CREATE TABLE IF NOT EXISTS `Product2Shop` (
  `ProductID` int(10) unsigned NOT NULL,
  `ShopID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ProductID`,`ShopID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Product2Shop`
--

INSERT INTO `Product2Shop` (`ProductID`, `ShopID`) VALUES(1, 1);

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

--
-- Tabel structuur voor tabel `Product2Title`
--

CREATE TABLE IF NOT EXISTS `Product2Title` (
  `ProductID` int(10) unsigned NOT NULL,
  `TitleID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`ProductID`,`TitleID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Product2Title`
--


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

--
-- Tabel structuur voor tabel `Shop`
--

CREATE TABLE IF NOT EXISTS `Shop` (
  `ShopID` int(10) unsigned NOT NULL auto_increment,
  `Shop` char(100) NOT NULL,
  PRIMARY KEY  (`ShopID`),
  UNIQUE KEY `Winkel` (`Shop`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=2 ;

--
-- Gegevens worden uitgevoerd voor tabel `Shop`
--

INSERT INTO `Shop` (`ShopID`, `Shop`) VALUES(1, 'NaamShop1');

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

--
-- Tabel structuur voor tabel `Shop2Description`
--

CREATE TABLE IF NOT EXISTS `Shop2Description` (
  `ShopID` int(10) unsigned NOT NULL,
  `DescriptionID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ShopID` (`ShopID`,`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Shop2Description`
--


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

--
-- Tabel structuur voor tabel `Shop2Image`
--

CREATE TABLE IF NOT EXISTS `Shop2Image` (
  `ShopID` int(10) unsigned NOT NULL,
  `ImageID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ShopID` (`ShopID`,`ImageID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Shop2Image`
--


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

--
-- Tabel structuur voor tabel `Shop2Product`
--

CREATE TABLE IF NOT EXISTS `Shop2Product` (
  `ShopID` int(10) unsigned NOT NULL,
  `ProductID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ShopID` (`ShopID`,`ProductID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Shop2Product`
--

INSERT INTO `Shop2Product` (`ShopID`, `ProductID`) VALUES(1, 2);

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

--
-- Tabel structuur voor tabel `Shop2Title`
--

CREATE TABLE IF NOT EXISTS `Shop2Title` (
  `ShopID` int(10) unsigned NOT NULL,
  `TitleID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ShopID` (`ShopID`,`TitleID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Shop2Title`
--


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

--
-- Tabel structuur voor tabel `Title`
--

CREATE TABLE IF NOT EXISTS `Title` (
  `TitleID` int(10) unsigned NOT NULL auto_increment,
  `Title` char(100) NOT NULL,
  PRIMARY KEY  (`TitleID`),
  UNIQUE KEY `Winkel` (`Title`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1 AUTO_INCREMENT=1 ;

--
-- Gegevens worden uitgevoerd voor tabel `Title`
--


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

--
-- Tabel structuur voor tabel `Title2Description`
--

CREATE TABLE IF NOT EXISTS `Title2Description` (
  `TitleID` int(10) unsigned NOT NULL,
  `DescriptionID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`TitleID`,`DescriptionID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Title2Description`
--


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

--
-- Tabel structuur voor tabel `Title2Image`
--

CREATE TABLE IF NOT EXISTS `Title2Image` (
  `TitleID` int(10) unsigned NOT NULL,
  `ImageID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`TitleID`,`ImageID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Title2Image`
--


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

--
-- Tabel structuur voor tabel `Title2Product`
--

CREATE TABLE IF NOT EXISTS `Title2Product` (
  `TitleID` int(10) unsigned NOT NULL,
  `ProductID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`TitleID`,`ProductID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Title2Product`
--


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

--
-- Tabel structuur voor tabel `Title2Shop`
--

CREATE TABLE IF NOT EXISTS `Title2Shop` (
  `TitleID` int(10) unsigned NOT NULL,
  `ShopID` int(10) unsigned NOT NULL,
  UNIQUE KEY `ProductID` (`TitleID`,`ShopID`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

--
-- Gegevens worden uitgevoerd voor tabel `Title2Shop`
--

SQL:

SELECT Shop, Product, Title, Description, Image
FROM Shop

# We koppelen alle Product, Titel, Description en Image aan de Shop

LEFT JOIN Shop2Product ON Shop.ShopID = Shop2Product.ShopID
LEFT JOIN Shop2Title ON Shop.ShopID = Shop2Title.ShopID
LEFT JOIN Shop2Description ON Shop.ShopID = Shop2Description.ShopID
LEFT JOIN Shop2Image ON Shop.ShopID = Shop2Image.ShopID

# We koppelen alle Shop, Title, Description en Image aan Product

LEFT JOIN Product2Shop ON Product.ProductID = Product2Shop.ProductID
LEFT JOIN Product2Title ON Product.ProductID = Product2Title.ProductID
LEFT JOIN Product2Description ON Product.ProductID = Product2Description.ProductID
LEFT JOIN Product2Image ON Product.ProductID = Product2Image.ProductID

# We koppelen alle Shop, Product, Description en Image aan Title

LEFT JOIN Title2Shop ON Title.TitleID = Title2Shop.TitleID
LEFT JOIN Title2Product ON Title.TitleID = Title2Product.TitleID
LEFT JOIN Title2Description ON Title.TitleID = Title2Description.TitleID
LEFT JOIN Title2Image ON Title.TitleID = Title2Image.TitleID

# We koppelen alle Shop, Product, Title en Image aan Description

LEFT JOIN Description2Shop ON Description.DescriptionID = Description2Shop.DescriptionID
LEFT JOIN Description2Product ON Description.DescriptionID = Description2Product.DescriptionID
LEFT JOIN Description2Title ON Description.DescriptionID = Description2Title.DescriptionID
LEFT JOIN Description2Image ON Description.DescriptionID = Description2Image.DescriptionID

# We koppelen alle Shop, Product, Title, Description aan Image

LEFT JOIN Image2Shop ON Image.ImageID = Image2Shop.ImageID
LEFT JOIN Image2Product ON Image.ImageID = Image2Product.ImageID
LEFT JOIN Image2Title ON Image.ImageID = Image2Title.ImageID
LEFT JOIN Image2Description ON Image.ImageID = Image2Description.ImageID

Nu had ik als opzet de bovenstaande nog niet werkende query. Maar waar moet ik nu die ShopID, ProductID, TitleID, DescriptionID en ImageID koppelen? Ik ben die eigenlijk al nodig vanaf het begin dus zou je zeggen koppel op regel 11 die zaken aan de Shop. Echter worden later de rijen nog uitgebreid omdat er nieuwe rijen met andere descriptions worden ingevoegd.

[B-Man]

Volgens mij is het simpel. Wat je nu wil kan niet middels standaard SQL; Je moet ofwel stored procedures gaan gebruiken (die kunnen loopen), of iets in de trant van een Oracle CONNECT BY (alleen is dat volgens mij enkel voor een loop binnen een entity).

Je wil te veel dingen generiek opslaan volgens mij, en dat gaat met een normaal RDBMS niet (goed).

Kijk, je spreekt over product -> kleur -> foto. Dan zeg je: die foto moet nog meer omschrijvingen/titels krijgen. Oke. Dan zit je eigenlijk (zoals al eerder geopperd) met twee soorten titels:
- productKleurTitel
- fotoTitel

Jij probeert deze twee in een tabel te verenigen, en dan kom je in de knel met je SQL. De database kan dan onmogelijk de relatie leggen die jij voor je ziet, omdat dit simpelweg ambigu is.
Als je wel verder gaat op de weg die je nu ingeslagen bent, zul je vermoedelijk met veel dubbele data opgezadeld worden. Je moet dan immers alle relaties expliciet op gaan slaan:
product -> kleur -> titel1 -> foto
als de foto dan nog een tweede titel heeft, moet je ook opslaan
product -> kleur -> titel1 -> foto -> titel2
Anders is het met normale SQL simpelweg niet mogelijk om je vraag op te lossen. Met SQL ga je er vanuit dat de entiteiten in je datamodel zich op een vaste plek bevinden, en in jouw geval is dat niet zo: een titel kan los bestaan, in relatie tot een kleur, product, foto, enz.

-- Kleine edit:
Overigens is het bij mij overheersende gevoel een vraag: waarom wil je het zo complex maken? Vaak geniet een datamodel dat transparant is de voorkeur, daarmee voorkom je nu problemen, en helemaal het gezever dat je jezelf op de nek haalt als je er een jaar niet meer naar gekeken hebt, en dan ergens wat moet aanpassen.

// Zo, genoeg gezegd voor dit uur van de dag/nacht

[ Voor 10% gewijzigd door B-Man op 17-10-2007 03:04 ]

[Gerwin]

Waarom werkt dit niet?

SQL:

SELECT
    Shop,Product,Title,Description,Image
FROM 
    Shop,Shop2Product,Shop2Title,Shop2Description,Shop2Image,
    Product,Product2Shop,Product2Title,Product2Description,Product2Image,
    Title,Title2Shop,Title2Product,Title2Description,Title2Image,
    Description,Description2Shop,Description2Product,Description2Title,Description2Image,
    Image,Image2Shop,Image2Product,Image2Title,Image2Description
WHERE
    Shop.ShopID = Shop2Product.ShopID AND
    Shop.ShopID = Shop2Title.ShopID AND
    Shop.ShopID = Shop2Description.ShopID AND
    Shop.ShopID = Shop2Image.ShopID AND
    Product.ProductID = Product2Shop.ProductID AND
    Product.ProductID = Product2Title.ProductID AND
    Product.ProductID = Product2Description.ProductID AND
    Product.ProductID = Product2Image.ProductID AND
    Title.TitleID = Title2Shop.TitleID AND
    Title.TitleID = Title2Product.TitleID AND
    Title.TitleID = Title2Description.TitleID AND
    Title.TitleID = Title2Image.TitleID AND
    Description.DescriptionID = Description2Shop.DescriptionID AND
    Description.DescriptionID = Description2Product.DescriptionID AND
    Description.DescriptionID = Description2Title.DescriptionID AND
    Description.DescriptionID = Description2Image.DescriptionID AND
    Image.ImageID = Image2Shop.ImageID AND
    Image.ImageID = Image2Product.ImageID AND
    Image.ImageID = Image2Title.ImageID AND
    Image.ImageID = Image2Description.ImageID 
LIMIT 10;

Mysql moet uit zoiets toch komen?

edit:

Mmm ik zit me net te bedenken dat je zo ook geen één op meer relaties kunt zetten natuurlijk

[ Voor 5% gewijzigd door Gerwin op 17-10-2007 07:34 ]

[wizzkizz]

Ik kan me niet aan de indruk ontrekken dat je te moeilijk probeert te doen. Volgens mij probeer je on-the-fly (in je query) entiteiten te koppelen die alleen maar in je hoofd bestaan en nog NIET in de databse. In de database staan namelijk alleen wat gegevens, die je in je hoofd al omgezet hebt naat entiteiten. Ik heb een quick-and-dirty ERD in mekaar geflanst van hoe ik jouw vraag interpreteer. Let niet te veel op de tabelnamen, kon snel ff niets beters verzinnen. (als de pijltjes niet helemaal kloppen, don't blame me, blame visio )



Je kunt zo alle entiteiten die je wilt hebben in een koppeltabel zetten en daar weer mee aan de gang gaan. Zo kun je zoveel entiteiten maken als nodig gaat terwijl je 'building blocks' nog steeds die losse tabellen met data zijn.

In je applicatie kun je vervolgens weer een ORMapper gebruiken om de database-entiteiten om te zetten in objecten waar je mee aan de slag gaat.

Als ik er heeelemaal naast zit: sorry.

[Gerwin]

wizzkizz, die tabel structuur zoals je die getekend hebt is correct. Echter mis ik geloof ik een aantel relaties, tenzij je van kpProducts via Images weer op de kpImages uitkomt. De volgende tabel is wat er aan het handje is. Echter hoe dat in een query te krijgen:



Ik geloof dat het gebruik van een JOIN niet dè manier is. Een JOIN is gebasserd op een begin en een einde, en ik zoek iets die tegelijk alle relaties legt. Op die manier blijft hij niet ronddraaien:

Shop -> Product -> Title -> Shop -> Product -> Title -> Shop - Product -> Title

[ Voor 31% gewijzigd door Gerwin op 18-10-2007 06:41 ]

[wizzkizz]

Nou, het idee is dat je alleen de entiteiten die je concreet nodig hebt aanmaakt in je database.

Dus heb je die kpProducts nodig, dan zorg je dat die aanwezig is. Wil je dan bijvoorbeeld meerdere images per product toestaan, dan maak je een apart tabel kpProductImages, die je koppelt aan zowel images als aan het veld uniqueID uit je kpProducts.


Met een paar queries kun je dan alle gegevens ophalen die je nodig hebt. Wil je het met alle geweld in 1 query stoppen, dan maak je in je database een aantal views aan die je allerhande koppelwerk uit handen nemen. Dan maak je bijvoorbeeld een view voor je products waarin je alvast de images aan je products koppelt, zodat je in je view rijen krijgt met bijv:

..., product1, company4, ..., image1, desc1
..., product1, company4, ..., image2, desc2
..., product1, company4, ..., image3, desc3
..., product1, company5, ..., image2, desc4

Aan die desc2 bijvoorbeeld nog een image koppelen heeft geen zin, want die desc2 is nu al gekoppeld aan (image2 + company4 + product1). Hij hoort al bij een bepaalde set gegevens. Koppelen aan nog een andere set gegevens lijkt mij zeer onwenselijk.

Je basis idee lijkt me wel redelijk te realiseren, maar met je koppeltabellen ga je volgens mij de mist in. Wat je niet per sé nodig hebt, zou ik niet aanmaken in de database. Ik zou het oplossen met een aantal goed gekozen koppeltabellen en wat views.

[DeZwarteKip]

Misschien is het een idee om met CaseTalk aan de gang te gaan eerst. Hier kun je de elementaire feiten gaan corpuleren om tot een database-ontwerp te komen.
Een conceptueel databaseontwerp is echt essentieel voor dit soort projecten.
Kun je onderscheiden wat de 'objecten' zijn in jou ontwerp en wat daar de 'eigenschappen' van zijn?
Volgens mij moet dit het veel efficienter kunnen...

[Gerwin]

wizzkizz schreef op donderdag 18 oktober 2007 @ 08:48:
Aan die desc2 bijvoorbeeld nog een image koppelen heeft geen zin, want die desc2 is nu al gekoppeld aan (image2 + company4 + product1). Hij hoort al bij een bepaalde set gegevens. Koppelen aan nog een andere set gegevens lijkt mij zeer onwenselijk.

Om het heel erg simpel te houden.

Het idee is juist dat als ik de JOINS heb gedaan:

code:

SHOP
JOIN Product
JOIN Title
JOIN Description
JOIN Image

Dat ik dan voor bijvoorbeeld de Title extra rijen wil hebben met andere image's.

Dus via een andere koppeltabel nogmaals JOIN Image, waarbij de bestaande rijden blijven en nieuwe rijen komen waar enkel de Image anders is.

Maikel_PumaCatz schreef op donderdag 18 oktober 2007 @ 08:59:
Misschien is het een idee om met CaseTalk aan de gang te gaan eerst. Hier kun je de elementaire feiten gaan corpuleren om tot een database-ontwerp te komen.
Een conceptueel databaseontwerp is echt essentieel voor dit soort projecten.
Kun je onderscheiden wat de 'objecten' zijn in jou ontwerp en wat daar de 'eigenschappen' van zijn?
Volgens mij moet dit het veel efficienter kunnen...

Ik kan zeggen wat de feiten zijn en wat de objecten zijn alleen zit er in de relaties en het database ontwerp een soort van LOOP. Hier lijkt mysql in elk geval op de manier zoals ik het doe niet mee onverweg te kunnen. Volgens mij moet dit inderdaad veel efficienter kunnen met een simpele query code ipv alles maar bij te gaan houden en alles maar op te moeten geven...

[B-Man]

wizzkizz schreef op donderdag 18 oktober 2007 @ 08:48:
...

Je basis idee lijkt me wel redelijk te realiseren, maar met je koppeltabellen ga je volgens mij de mist in. Wat je niet per sé nodig hebt, zou ik niet aanmaken in de database. Ik zou het oplossen met een aantal goed gekozen koppeltabellen en wat views.

Ik lees dat je met MySQL werkt; De suggestie die wizzkizz doet (werken met views) wil ik je in dat geval afraden. De performance van MySQL i.c.m. views is in een aantal gevallen (nog?) onder de maat, en specifiek daarop een systeem bouwen lijkt me (qua performance) dus riskant.

[Gerwin]

Dat werken met views geen goed idee, ok. Maar welke kant moet ik dan wel op om zoiets gerealiseerd te krijgen. Zoiets moet toch mogelijk zijn, op papier is te zetten wat er moet gebeuren.



Deze relaties zijn er. Alleen wil ik nu zegmaar al deze relaties in een query hebben en een lijstje met Company, Product, Title, Description en Image terugkrijgen.

Ik zit echt op een dood spoor, waar moet ik op zoeken in Google?
Of heeft er iemand een hele simpele oplossing of een tip voor mij?

[ Voor 13% gewijzigd door Gerwin op 18-10-2007 16:05 ]

[DeZwarteKip]

Misschien zit ik er helemaal naast hoor, maar volgens mij zou je databaseontwerp er als volgt ongeveer uit moeten zien:

[Gerwin]

Maikel_PumaCatz schreef op donderdag 18 oktober 2007 @ 16:19:
Misschien zit ik er helemaal naast hoor, maar volgens mij zou je databaseontwerp er als volgt ongeveer uit moeten zien:
[afbeelding]

Dat klopt helemaal, maar ik mis in jou grafiek de het volgende:

- Productkleur, Productnaam, Productomschrijving van Productafbeelding. van alle Productafbeelding
- WinkelProduct, Productafbeelding, Productnaam, Productomschrijving van alle Productkleur
- WinkelProduct, Productafbeelding, Productkleur, Productomschrijving van alle Productnaam
- WinkelProduct, Productafbeelding, Productkleur, Productnaam van alle Productomschrijving

Het idee is dat ik bijvoorbeeld het volgende wil kunnen krijgen:

WinkelProduct - Productafbeelding - Productkleur - Productnaam - Productomschrijving
8. Leen Bakker - 1. bjorn.jpg - 1. rood - 3. 2 persoonsbed
8. Leen Bakker - 3. Frans.jpg - 1. rood - 3. 2 persoonsbed
8. Leen Bakker - 3. Frans.jpg - 3. bruin - 3. 2 persoonsbed

Zoals je ziet is de winkel hetzelfde (8 ), maar de Productafbeelding is anders omdat er tevens een relatie bestaat op Productkleur.

"Winkel met naam 8 heeft Productafbeelding 3"
"Productkleur met code 1 heeft Productafbeelding 1"
"Productkleur met code 3 heeft Productafbeelding 3"

Uiteraard kunnen er vanuit al die andere tabellen op deze manier relaties bestaan tussen de verschillende tabellen waardoor er meer rijen ontstaan. Maar hoe krijg je dat in een query?

Het probleem zit hem erin dat vanuit een Wikelproduct via Productafbeelding je bij Productkleur komt die weer extra Productafbeeldingen toevoegd, en die Productafbeelding natuurlijk weer naar Productkleur gaat etc. etc.

[ Voor 0% gewijzigd door Gerwin op 18-10-2007 16:39 . Reden: smilie maakte mijn tekst onleesbaar ]

[DeZwarteKip]

Gerwin schreef op donderdag 18 oktober 2007 @ 16:38:
[...]
Dat klopt helemaal, maar ik mis in jou grafiek het volgende:

- Productkleur, Productnaam, Productomschrijving van Productafbeelding. van alle Productafbeelding
- WinkelProduct, Productafbeelding, Productnaam, Productomschrijving van alle Productkleur
- WinkelProduct, Productafbeelding, Productkleur, Productomschrijving van alle Productnaam
- WinkelProduct, Productafbeelding, Productkleur, Productnaam van alle Productomschrijving

Het idee is dat ik bijvoorbeeld het volgende wil kunnen krijgen:

WinkelProduct - Productafbeelding - Productkleur - Productnaam - Productomschrijving
8. Leen Bakker - 1. bjorn.jpg - 1. rood - 3. 2 persoonsbed
8. Leen Bakker - 3. Frans.jpg - 1. rood - 3. 2 persoonsbed
8. Leen Bakker - 3. Frans.jpg - 3. bruin - 3. 2 persoonsbed

Zoals je ziet is de winkel hetzelfde (8 ), maar de Productafbeelding is anders omdat er tevens een relatie bestaat op Productkleur.

"Winkel met naam 8 heeft Productafbeelding 3"
"Productkleur met code 1 heeft Productafbeelding 1"
"Productkleur met code 3 heeft Productafbeelding 3"

Uiteraard kunnen er vanuit al die andere tabellen op deze manier relaties bestaan tussen de verschillende tabellen waardoor er meer rijen ontstaan. Maar hoe krijg je dat in een query?

Het probleem zit hem erin dat vanuit een Wikelproduct via Productafbeelding je bij Productkleur komt die weer extra Productafbeeldingen toevoegd, en die Productafbeelding natuurlijk weer naar Productkleur gaat etc. etc.

Volgens mij wil jij dingen recursive gaan opslaan, wat natuurlijk niet de bedoeling is...
Als ik jou begrijp dan veranderd de afbeelding dus aan de hand van eerder gestelde eigenschappen zoals artikel, kleur? Als dat het geval is dan zou ik met variabele gaan werken.
Je zou bijvoorbeeld %artikel%.%kleur%.jpg kunnen gebruiken. Zo zoekt hij zelf aan de hand van de eigenschappen van het product de juiste afbeelding erbij...
Verder kun je natuurlijk ook natuurlijk d.m.v. integriteitsregels ook vaststellen of bepaalde producten gewoon meerdere keren voor kunnen komen met andere kleuren en eigenschappen.

[Gerwin]

Ik wil juist niet die zaken zelf opslaan en die verbindingen door mysql laten leggen zodat hij zelf alle rijen gegenereerd krijgt door de relaties. Ik heb een stukje gevonden over KEYS is dat misschien wat ik zoek? Mysql hoeft immers bij vijf tabellen slechts vijf keer "loop" te doen omdat hij dan niet meer rows zal krijgen. Het moet toch mogelijk zijn om zegmaar vanuit alle tabellen een JOIN te doen en dan de results te JOINEN? Misschien iets met UNION?

[RobIII]

Met alle respect Gerwin, maar ik volg dit topic al een tijdje en er is werkelijk geen touw vast te knopen aan waar je mee bezig bent, wat je probeert te bereiken of wat je eigenlijke bedoeling nou precies is. En dan begin je nu over keys, joins en unions alsof ze onderling uitwisselbaar zijn. Die drie dingen zijn toch echt wel basiskennis databases en ik kan me dan ook nog steeds niet aan de indruk onttrekken dat je ergens wat van die kennis mist om je model op orde te krijgen. Don't get me wrong; we zijn allemaal ergens begonnen en hebben het allemaal moeten leren, maar ik blijf toch steeds in de loop van dit topic terugkomen op een goed genormaliseerd model en ik kan me echt met de beste wil van de wereld niet voorstellen wat je nou eigenlijk aan 't doen bent. Het duizelt me gewoon.

Dus neem dit als een vriendelijk advies, maar misschien is het verstandig om eens je héle probleem tekstueel uiteen te zetten en dat aan ons, een collega of kennis voor te leggen of om het hele probleem door iemand aan te laten pakken die al vaker met dit bijltje heeft gehakt.

Posts als deze geven mij de indruk dat je voor ieder veldje zowat een nieuwe tabel aanlegt om maar te voorkomen dat er ergens dubbele waarden in zouden voorkomen. Ik zie niet waarom je niet in 1 tabel 5 FK's zou kunnen hebben naar andere tabellen met eigenschappen(?) van je product/winkel etc. Ergens zit er een kink in de kabel en of die komt niet goed bij ons over omdat het probleem voor ons niet helder is, of je bent de verkeerde weg ingeslagen en dan moet je je originele idee nog eens herbeschouwen en herzien.

[ Voor 22% gewijzigd door RobIII op 18-10-2007 22:00 ]

[Gerwin]

Roblll, geloof me, de basiskennis van mysql en databases is er echt wel. Ik werk al ruin 6 jaar met dit soort dingen alleen ben ik dit soort problemen zelf ook nooit tegengekomen. Normaliter werk ik ook met een structeur wat op een simpele manier te ontleden is en dan krijg je een paar tabellen unieke data die aan elkaar gekoppeld zijn. Dit "unieke tabellen die aan elkaar gekoppeld zijn" probeer ik ook op dit concept los te laten, echter loop ik hier vast. Ben het met je eens dat er ergens iets niet goed zit, maar het de doelstelling is wel degelijk duidelijk alleen is het "zeer moeilijk" om dit in een query vast te leggen. Een grafiek is makkelijker maar de query die de magic moet doen ontbreekt.

Bedrijven verkopen producten en geven aan deze producten hun eigen titel, omschrijving en plaatje. Vervolgengens gebruiken ze ook de titel, omschrijving en plaatje die aan hun gekozen titel, omschrijving en plaatje gekoppeld zit. Ook gebruikt men de titel, omschrijving en plaatje die gekoppeld zit aan de titel, omschrijving en plaatje die gekoppeld zit aan de aan hun gekozen titel, omschrijving, en plaatje. Ook de aan deze gekoppelde titel, omschrijving en plaatje worden gebruikt. En aan deze gekoppelde titel, omschrijving en plaatje. Dit gebruikt men totdat er geen nieuwe combinaites meer ontstaan.

[ Voor 34% gewijzigd door Gerwin op 19-10-2007 11:41 ]

[Janoz]

Wat je daar opschrijft is volgens mij ook gewoon te maken met 1 koppeltabel met een FK naar product, naam, titel, omschrijving en plaatje. Daarbij ga ik er vanuit dat elke leverancier de plaatjes en omschrijvingen kan hergebruiken. Als dat neit zo is dan kunnen veel van deze dingen ook gewoon in de koppeltabel zelf opgenomen worden (denk hierbij aan omschrijving en naam).

[ Voor 46% gewijzigd door Janoz op 19-10-2007 11:47 ]

[Gerwin]

Janoz schreef op vrijdag 19 oktober 2007 @ 11:45:
Wat je daar opschrijft is volgens mij ook gewoon te maken met 1 koppeltabel met een FK naar product, naam, titel, omschrijving en plaatje. Daarbij ga ik er vanuit dat elke leverancier de plaatjes en omschrijvingen kan hergebruiken. Als dat neit zo is dan kunnen veel van deze dingen ook gewoon in de koppeltabel zelf opgenomen worden (denk hierbij aan omschrijving en naam).

Jazeker, de Producten, Titels, Omschrijvingen en Plaatjes kunnen verspreid over alles meerdere malen voorkomen. Maar ze zijn op hun beurt afhankelijk van de waarde van wat er in één veld van Company, Product, Titel, Omschrijving of plaatje staat. Echter wordt er zo'n relatie gevonden moet er een extra rij (bij één tabel dus record) gemaakt worden. Ik ga even wat uitproberen. Misschien dat een TRIGGERS dan werkt voor de nieuwer records. In dit geval moet je dus wel alles opslaan. Het was mooi geweest als ik middels 1 record in één van de koppeltabellen (bijvoorbeeld Title->Product) ineens alle Producten gekoppeld had aan een bepaalde titel en zo dus tientallen records overbodig maak. In dit het geval met één koppeltabel moet ik alle combinaties opslaan.

[Janoz]

Wat is het probleem met dat extra record. Je hebt aan mij nog steeds niet duidelijk kunnen maken waarom je die volledig verbonden graaf structuur nodig hebt, en volgens mij ben ik daarin niet de enige. Zou je voor onze (maar waarschijnlijk ook je eigen) duidelijkheid misschien enkele usecases uit kunnen schrijven? Ik blijf namelijk nog steeds van mening dat je zo enorm in de details van je gekozen oplossingsrichting gezakt bent dat je het overzicht verloren bent.

[? ?]

Ik heb niet de hele thread doorlezen wegens teveel hersenvervuiling...

Maar DB's ontwerpen is een kunst op zich, als je al moeilijkheden hebt met wat productjes, titels, omschrijvingen en plaatjes verdiep je dan eerst.

Ik zag hier ook dat je verschillende tabellen wilt voor omschrijvingen van afbeeldingen en titels.

zoiets wordt zo opgelost:

omschrijvingen
---------------------
id
tekst
soort
bedrijf

waar soort bv. staat of het een omschrijving van een titel of van een afbeelding of product of weet ik veel is.
Bedrijf kun je ook toevoegen, zo kun je alle omschrijvingen voor elk bedrijf in 1 tabel stoppen..

Misschien begin je beter eens opnieuw en bekijk je al je zogezegde regels eens opnieuw. Simpel = good

[ Voor 23% gewijzigd door ? ? op 19-10-2007 13:55 ]

[Pete]

Gerwin schreef op vrijdag 19 oktober 2007 @ 11:17:
Roblll, geloof me, de basiskennis van mysql en databases is er echt wel. Ik werk al ruin 6 jaar met dit soort dingen alleen ben ik dit soort problemen zelf ook nooit tegengekomen.

Sorry, maar ik kan me niet voorstellen dat je nooit tegen bent gekomen dat je kolom en tabel aliassen nodig hebt zoals hier uitgelegd moest worden. Zoiezo blijkt in dit topic dat je kennis niet helemaal toereikend is.

Daarnaast, geef je nu wel een tekstuele beschrijving, maar kijk eens of die beschrijving duidelijk is voor iemand zonder voorkennis. Dat issie niet. Daarnaast, als wij niet mogen helpen met het databasemodel, wat is dan je probleem? Met 6 jaar ervaring moet je ondertussen de documentatie van mysql wel gevonden hebben om de syntax van een query uit te vinden. Bedenk welke data je wilt hebben en maak je query.

[ Voor 3% gewijzigd door Pete op 19-10-2007 13:43 ]

[Gerwin]

Janoz schreef op vrijdag 19 oktober 2007 @ 13:02:
Wat is het probleem met dat extra record. Je hebt aan mij nog steeds niet duidelijk kunnen maken waarom je die volledig verbonden graaf structuur nodig hebt, en volgens mij ben ik daarin niet de enige. Zou je voor onze (maar waarschijnlijk ook je eigen) duidelijkheid misschien enkele usecases uit kunnen schrijven? Ik blijf namelijk nog steeds van mening dat je zo enorm in de details van je gekozen oplossingsrichting gezakt bent dat je het overzicht verloren bent.

Ik wil het voor mijzelf zo gemakkelijk mogelijk maken om de combinaties uit de database te krijgen van de mogelijke combinaties.

Stel de opzet is:
Shops hebben meerdere Product,
Producten hebben meerdere Title,
Titels hebben meerdere Description,
Description hebben meerdere Image.

Stel ik heb het volgende record:

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg

Nu zeg ik: "Dat plaatje dat wil ik ook omschrijven met: 'Foto met bank1'".

Nu krijg ik als records die omschrijving er niet in. Maar ik wil dat wel. In feite ontstaat er een nieuw record zodat ik er twee heb.
De oude constructie blijft overeind, maar doordat Description ook afhankelijk is van de waarde van Image krijg ik een extra record.

De opzet is geworden:
Shops hebben meerdere Product,
Producten hebben meerdere Title,
Title hebben meerdere Description,
Description hebben meerdere Image,
Image hebben meerdere Description.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg

Vervolgend zeg ik: "Dat plaatje dat wil ik ook als titel geven: 'Bank 1'".

Die Title was afhankelijk van Product, maar nu dus ook van de Image waarde. Er ontstaat in elk geval weer nieuwe rows omdat anders de voorgaande feiten niet overeind gehouden kunnen worden. En omdat bank1.jpg ineens tweemaal voorkomt twee nieuwe rows.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   bank1.jpg
Blokker     Bankstel    Bank 1         Foto met bank1     bank1.jpg

NU zeg ik: "Die omschrijving 'Deze is erg goed' wil ik van plaatje 'topper.jpg' voorzien".

Er ontstaan wederom nieuwe rows om voorgaande overeind te kunnen houden.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   bank1.jpg
Blokker     Bankstel    Bank 1         Foto met bank1     bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   topper.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   topper.jpg

Nu komt er een nieuw product bij 'Stoel'.

Er bestaan verder geen verwijzingen.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   bank1.jpg
Blokker     Bankstel    Bank 1         Foto met bank1     bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   topper.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   topper.jpg
NULL        Stoel       NULL           NULL               NULL

Nu zeg ik 'Stoel' heeft als plaatje 'topper.jpg'.

Het plaatje word gekoppeld, maar doordat het plaatje toppet.jpg ook gekoppeld was aan Description 'Deze is erg goed'. Komt deze ook als extra row.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   bank1.jpg
Blokker     Bankstel    Bank 1         Foto met bank1     bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   topper.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   topper.jpg
NULL        Stoel       NULL           NULL               NULL
NULL        Stoel       NULL           Deze is erg goed   topper.jpg

Nu koppel ik aan "Deze is erg goed" een nieuw plaatje: 'nieuw.jpg'.

Ineens krijg ik veel meer rows, de omschrijving bestaat meerdere malen. Echter om ook de voorgaanse in stand te houden blijven deze ook bestaan.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   nieuw.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   bank1.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   nieuw.jpg
Blokker     Bankstel    Bank 1         Foto met bank1     bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   topper.jpg
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   nieuw.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   topper.jpg
Blokker     Bankstel    Bank 1         Deze is erg goed   nieuw.jpg
NULL        Stoel       NULL           NULL               NULL
NULL        Stoel       NULL           Deze is erg goed   topper.jpg
NULL        Stoel       NULL           Deze is erg goed   nieuw.jpg

Om bovenstaande output te krijgen moeten er veel koppelingen gelegd worden.

Vul nu aan een willekeurig veld een nieuwe koppeling en "floep" om alle andere koppelingen ook overeind te kunnen houden krijg je weer meer rows.

Koppel aan Title 'Bank 1" een nieuw plaatje en er ontstaan 5 nieuwe rijen.
Koppel aan Product 'Stoel" een nieuwe Title en we hebben 3 nieuwe rijen.

etc.

[Confusion]

Gerwin schreef op vrijdag 19 oktober 2007 @ 13:57:
En omdat bank1.jpg ineens tweemaal voorkomt twee nieuwe rows.

En wat denk je dat er gebeurt in jouw queries? Die maken diezelfde dubbele rij, maar dan in je geheugen. Je kan kiezen: of een grote tabel, waarin alle combinaties een keer voorkomen of outer joins en die combinaties telkens opnieuw genereren. Ik zou voor het eerste kiezen.

[Dido]

Gerwin schreef op vrijdag 19 oktober 2007 @ 13:57:
Stel ik heb het volgende record:

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg

Nu zeg ik: "Dat plaatje dat wil ik ook omschrijven met: 'Foto met bank1'".

Nu krijg ik als records die omschrijving er niet in. Maar ik wil dat wel. In feite ontstaat er een nieuw record zodat ik er twee heb.
De oude constructie blijft overeind, maar doordat Description ook afhankelijk is van de waarde van Image krijg ik een extra record.

De opzet is geworden:
Shops hebben meerdere Product,
Producten hebben meerdere Title,
Title hebben meerdere Description,
Description hebben meerdere Image,
Image hebben meerdere Description.

code:

Shop        Product     Title          Description        Image
Blokker     Bankstel    Leuk Bankstel  Deze is erg goed   bank1.jpg
Blokker     Bankstel    Leuk Bankstel  Foto met bank1     bank1.jpg

En daar gaat je normalisatie alle ramen uit.

Dat jij vind dat een description een description is, is je goed recht, maar heb het dan niet over een datamodel.
Ik heb enkele dagen geleden al gevraagd of je niet toevallig verschillende beschrijvingen had, en zie hier: die heb je. Een titel-description is namelijk geen image-description.

Functioneel zeggen je voorbeeldtabellen dan ook geen ruk: de omschrijving in de kolom description kan slaan op je image of op je titel, en er is geen enkele aanwijzing op welke van de twee het slaat. Dus als ik een omschrijving "onscherp" heb, kan dat slaan op een broodmes, of op de foto ervan - maar dat weet niemand.

Daar zit ej dus met een funcamenteel functioneel probleem, en ik ben er dus ook nog steeds niet van overtuigd dat je ook maar in de buurt zit van een werkbare oplossing.

[Gerwin]

De tabellen die ik gegeven heb die moesten duidelijk maken welke relaties de verschillende velden uit de verschillende tabellen met elkaar hebben. Als dat niet duidelijk is geworden dan spijt me dat, maar ik weet echt niet hoe ik dat nog duidelijker moet maken. De relaties die op de tabellen bestaan wil ik allemaal "ineens" weergegeven hebben in een enkele query, zodat ik uiteindelijk een lijst krijg van "alles"

Wat ik tot nu toe heb geprobeerd draaid telkens weer op hetzelfde uit. Ik doe een join van Product naar Titel en van Titel naar Image. Om vervolgens geen join te kunnen doen van Image naar meer Producten. Of hij blijft ronddraaien op een WHERE clausule of aan het joinen komt geen eind.

[Verwijderd]

En pak het dan eens als volgt aan;

Een product heeft altijd:
* description
* title
* shop
* image

Wanneer een van deze dingen anders is (zoals een andere image) gewoon bekijken als een nieuw product en dus een nieuwe record in je product tabel.

Mijns inziens kom je zo op een veel simpeler model

code:

PRODUCT: id, descriptionid, imageid, shopid, titleid, ...
DESCRIPTION: id, description, ....
IMAGE: id, url, ....
SHOP: id, description, ...
TITLE: id, description, ...

Misschien snap ik je probleemstelling niet goed, maar wat is verkeerd aan deze methode?

[Gerwin]

Even een update hoever ik ben gekomen. Om alles gelijktijdig uit de verschillende tabellen te halen is me tot op heden niet gelukt. Ik blijf maar tegenkomen dat ik (of mysql althans) in een soort van oneindige loop komt, dit terwijl als gewoon de relaties gelijk gezet worden het niet het geval is. Tabel1 wijst via Tabel2 naar Tabel 3 die via Tabel 4 weer naar Tabel1 verwijst, die weer naar Tabel2... etc. Mysql lijkt niet dit niet te begrijpen, en ik begrijp niet waarom mysql het niet gewoon doet.

Ik heb verschillende posts gezien die voorstelden de tabelstructuur terug te brengen. Echter omdat ik alle mogelijkheden wel wil houden zal ik op enige manier al die mogelijikheden in de tabel moeten opslaan. Op dit moment verdiep ik me in het gebruik van Triggers en Procedures. Ik weet niet of dit tot iets gaat leiden, maar het is op deze manier in elk geval wel mogelijk dat als er bijvoorbeeld een Titel aan een Product gekoppeld wordt de rows waarin het product voorkomt extra rijen krijgt met deze nieuwe titels. Wordt de Titel verwijderd dan kan ook in één vlaag alle rows verwijderd worden met die titel. Ik blijf in dit geval wel de tabellen houden die wel geldige relaties opslaan. Dit omdat ik er vooralsnog niet uit ben hoe dat met één tabel te doen. Het geheel is wel een hele brei met code procedures en triggers.

[MrBucket]

Gerwin schreef op zondag 21 oktober 2007 @ 01:37:
Even een update hoever ik ben gekomen. Om alles gelijktijdig uit de verschillende tabellen te halen is me tot op heden niet gelukt. Ik blijf maar tegenkomen dat ik (of mysql althans) in een soort van oneindige loop komt, dit terwijl als gewoon de relaties gelijk gezet worden het niet het geval is. Tabel1 wijst via Tabel2 naar Tabel 3 die via Tabel 4 weer naar Tabel1 verwijst, die weer naar Tabel2... etc. Mysql lijkt niet dit niet te begrijpen, en ik begrijp niet waarom mysql het niet gewoon doet.

Volgens mij komt dit omdat je in je hoofd niet duidelijk hebt welke rollen er gemodelleerd moeten worden. Een omschrijving bij een product speelt een andere rol dan een omschrijving bij een afbeelding, en waneer je dit toch op dezelfde manier gaat opslaan, dan verlies je informatie. Hoe weet jij straks waar "een omschrijving" bij hoort?

Zorg nu eerst dat je in je hoofd duidelijk krijgt wat er moet gebeuren, en probeer dan pas naar een oplossing te werken.

...maar het is op deze manier in elk geval wel mogelijk dat als er bijvoorbeeld een Titel aan een Product gekoppeld wordt de rows waarin het product voorkomt extra rijen krijgt met deze nieuwe titels.

Je wilt geen extra rijen creeeren; In dit geval zou je een tabel Titels moeten maken met een foreign key die verwijst naar het Product waar het bijhoort. En dan kun je met een query alle titels weer ophalen die bij een bepaald product horen.

Wordt de Titel verwijderd dan kan ook in één vlaag alle rows verwijderd worden met die titel.

Ligt eraan wat je bedoelt:
Als een Product een one-to-many relatie heeft met Titels, dan ben je er met de foreign key oplossing die ik net noemde ook.
Als een Product een many-to-many relatie heeft met Titels, dan moet je oppassen waar je mee bezig bent. Wil je een Titel wel kunnen delen met meerdere Producten? Als je een Titel voor een Product aanpast, dan verandert de titel voor alle andere producten met deze titel dus mee. Mag een Product bestaan zonder Titel, en mag een Titel bestaan zonder dat er een Product bestaat die er gebruik van maakt?

[Gerwin]

Een update over hetgene wat ik tot nu toe verder ben gekomen. Met triggers loop ik tegen hetzelfde probleem aan dat ik eerder al gezegd had. Dit komt omdat ik vervolgens een trigger moet zetten op de tabel waar een trigger een insert op doet. Dat veroorzaakt een oneindige loop.

Mede door het testen met triggers ben ik tot de conslusie gekomen dat ik eigenlijk helemaal niet een alles op alles relatie wil hebben. En dat lost meteen het probleem gedeeltelijk op met die oneindige verwijzingen naar elkaar. Als ik van Product naar Image verwijs en vervolgens van Image naar Title en dan de Title weer koppel aan Product die ook zelf eigen Title's heeft dan krijg ik natuurlijk ook de Title's van bijvoorbeeld Product 1 (via Image) bij Product 2. En dat is niet de bedoeling.

Helemaal opnieuw ben ik begonnen met het opzetten van een structuur en heb een groot aantal relaties "dag" gezegd. Het idee is nu de volgende:

Company heeft meerdere Shop en die shop verkopen Product.
Daarnaast zijn er Image voor alle producten en shop.

Bovenstaande had ik zo bedacht:

Company (CompanyID, Company)
Shop (ShopID, CompanyID, Shop)
Product (ProductID, Product)

En een koppeling aan de Shop vanuit Product, omdat er meerdere shops aan Product gekoppeld kunnen zijn via een koppeltable.

Shop2Product (ShopID, ProductID)

Vervolgens moet ik de Image koppelen aan zowel de Shop (zodat van alle producten uiteindelijk een row met het plaatje van de shop wordt voorzien. Daarnaast moet Image ook aan de producten gekoppeld worden.

Image (ImageID,Image)
Shop2Image (ShopID, ImageID)
Shop2Product (ShopID, ImageID)

Nu komt dan het probleem waar ik vooralsnog niet uit ben gekomen. Alle Shop, Product en Image krijgen eigen Title, Description en Text. De titels, descriptions en text van de Shop mogen doorwerken op de product en image rijen, echter de description van de Image niet op Product en omgekeerd.

Uiteindelijk wil ik dus een reeks rows terugkrijgen van de database met:
Company, Shop, Product, Image, Title, Description, Text.

Company -> Shop
Shop -> Product
Product -> Image
Shop -> Image
Shop -> Title, Description, Text (maakt extra rows voor Product en Image)
Product -> Title, Description, Text (alleen voor eigen product)
Image -> Title, Description, Text (alleen voor eigen image)

Wat ik nu doe geeft altijd ook de Title, Description en Text weer voor alle mogelijkheden.

[Confusion]

Gerwin schreef op vrijdag 26 oktober 2007 @ 17:53:
En een koppeling aan de Shop vanuit Product, omdat er meerdere shops aan Product gekoppeld kunnen zijn

Als je wilt weten welke shops er allemaal een bepaald product verkopen, dan laat je een query los op de tabel die producten aan shops koppelt. Waarom je daar nog een extra koppeltabel voor wilt gebruiken is mij een raadsel.

Vervolgens moet ik de Image koppelen aan zowel de Shop (zodat van alle producten uiteindelijk een row met het plaatje van de shop wordt voorzien. Daarnaast moet Image ook aan de producten gekoppeld worden.

Bij producten een plaatje van de shop? Dus je hebt straks 100 rijen met hetzelfde product en hetzelfde productplaatje, maar een ander shop-plaatje? Ik kan me geen systeem voorstellen waarin niet een shopID rondzweeft, zodat je dezelfde site kan gebruiken voor verschillende shops, door gewoon een ander shopID door te geven en daarmee bijvoorbeeld de backlink naar het shop-image kunt bepalen. Een tabel met producten met rijen waarin een plaatje staat van de shop waarin het product verkocht wordt? Sorry, maar dat is totale waanzin.

[Gerwin]

Het doel (afgezien van waarom) is dat ik in een lijst middels 1 query een lijst willen kunnen tonen waarin ik alle Companynamen, Shopnamen, Productnamen, Title's, Descriptions, Text en Image wil hebben.

Company's hebben meerdere shops, shops hebben meerdere producten, producten meerdere titels, descriptions en text. Maar van de andere kant heb ik ook nog Image met titels, descriptions en text. Die zijn allemaal aan elkaar gejoint. Alleen krijg ik nu de texten van de Image ook bij de Producten en omgekeerd. De Title moet zegmaar die van de Shop zijn, het Product en de Image. De Shoptitel komt wel bij Product en Image, maar die van Image niet bij Product en Product niet bij image.

[Verwijderd]

Gerwin schreef op zaterdag 27 oktober 2007 @ 01:17:
Het doel (afgezien van waarom) is dat ik in een lijst middels 1 query een lijst willen kunnen tonen waarin ik alle Companynamen, Shopnamen, Productnamen, Title's, Descriptions, Text en Image wil hebben.

Company's hebben meerdere shops, shops hebben meerdere producten, producten meerdere titels, descriptions en text. Maar van de andere kant heb ik ook nog Image met titels, descriptions en text. Die zijn allemaal aan elkaar gejoint. Alleen krijg ik nu de texten van de Image ook bij de Producten en omgekeerd. De Title moet zegmaar die van de Shop zijn, het Product en de Image. De Shoptitel komt wel bij Product en Image, maar die van Image niet bij Product en Product niet bij image.

Je gooit dus feitelijk verschillende informatie in één tabel. Een description, title en text van een image is misschien qua data hetzelfde, maar qua idee anders. Je hebt het over een omschrijving (en titel, en tekst) van een plaatje. Dat is anders dan een omschrijving (en titel, en tekst) van een shop. Ik zou daar dus ook een tabel ImageDescription etc. verwachten...

[Confusion]

Gerwin schreef op zaterdag 27 oktober 2007 @ 01:17:
Company's hebben meerdere shops, shops hebben meerdere producten, producten meerdere titels, descriptions en text. Maar van de andere kant heb ik ook nog Image met titels, descriptions en text. Die zijn allemaal aan elkaar gejoint. Alleen krijg ik nu de texten van de Image ook bij de Producten en omgekeerd. De Title moet zegmaar die van de Shop zijn, het Product en de Image. De Shoptitel komt wel bij Product en Image, maar die van Image niet bij Product en Product niet bij image.

In zo'n geval zullen shops, in geval van fatsoenlijke titels, meestal de default producttitel willen hanteren. Je houdt dan dus in een losse tabel alleen de producttitels bij die een bepaalde shop als 'override' definieert. Die tabellen join je met een functie als COALESCE(a1, b1), die de eerste non-null waarde teruggeeft.

Bovendien moet je, zoals al een keer of -tig gezegd, een tabel met image-onderschriften scheiden van een tabel met shop-toelichtingen en een tabel met productbeschrijvingen. Dat je dat allemaal 'titel' zou kunnen noemen, is een gebrek van onze taal en geeft geen noodzakelijke verbintenis tussen de entiteiten weer.

[Gerwin]

Verwijderd schreef op zaterdag 27 oktober 2007 @ 03:04:
[...]


Je gooit dus feitelijk verschillende informatie in één tabel. Een description, title en text van een image is misschien qua data hetzelfde, maar qua idee anders. Je hebt het over een omschrijving (en titel, en tekst) van een plaatje. Dat is anders dan een omschrijving (en titel, en tekst) van een shop. Ik zou daar dus ook een tabel ImageDescription etc. verwachten...

Wat er eigenlijk moet gebeuren is de Titel moet de Titel zijn die de Shop aan het Product gegeven heeft. Daarnaast ook de Titels van de Image die bij dat Product hoort. Daarbij wil ik de titels van het product alleen bij de producten hebben en de titels van de image alleen als de image ook echt aanwezig is.

Wat ik tot nu toe heb:

SQL:

SELECT `Company`, `Shop`, `Product`, `Image`, `Title`, `Description`, `Text`
FROM `Company`

  # Shop, en Product erbij
  LEFT JOIN `Shop` USING (`CompanyID`)
  LEFT JOIN `Product` USING (`ShopID`)
  
  # Jointabellen van Shop en Product
  LEFT JOIN `Shop2Image` ON `Shop2Image`.`ImageID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Image` ON `Product2Image`.`ImageID` = `Product`.`ProductID`
  
  # Image erbij
  LEFT JOIN `Image` ON (`Image`.`ImageID` = `Shop2Image`.`ImageID` OR
                        `Image`.`ImageID` = `Product2Image`.`ImageID`)
  
  # Alle Titels, Descriptions en Text
  LEFT JOIN `Shop2Title` ON `Shop2Title`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Title` ON `Product2Title`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Title` ON `Image2Title`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Title` ON (`Title`.`TitleID` = `Shop2Title`.`TitleID` OR
                        `Title`.`TitleID` = `Product2Title`.`TitleID` OR
                        `Title`.`TitleID` = `Image2Title`.`TitleID`)

  LEFT JOIN `Shop2Description` ON `Shop2Description`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Description` ON `Product2Description`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Description` ON `Image2Description`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Description` ON (`Description`.`DescriptionID` = `Shop2Description`.`DescriptionID` OR
                              `Description`.`DescriptionID` = `Product2Description`.`DescriptionID` OR
                              `Description`.`DescriptionID` = `Image2Description`.`DescriptionID`)

  LEFT JOIN `Shop2Text` ON `Shop2Text`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Text` ON `Product2Text`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Text` ON `Image2Text`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Text` ON (`Text`.`TextID` = `Shop2Text`.`TextID` OR
                       `Text`.`TextID` = `Product2Text`.`TextID` OR
                       `Text`.`TextID` = `Image2Text`.`TextID`)

Ik zal wederom kijken of bepaalde zaken uit elkaar te trekken is. Maar ik wil eigenlijk zo weinig mogelijk opslaan en alle relaties lekker door de database laten doen. Ik vindt het nu al beetje overdreven om al die koppeltabellen te moeten hebben om te krijgen wat ik wil. De inzet van die hele topic was juist om alles geautomatiseert te krijgen en dat ik met een aantal simpele koppelingen een hele reeks rows kon genereren.

[Gerwin]

Bovenstaande mysql oplossing schijnt wel te werken achteraf. Ik krijg nu netjes alle rijen terug die ik wil. Echter moet ik nu wel alles handmatig via PHP in de database gooien wat een gigantisch probleem is. In mijn achterhoofd ben ik natuurlijk ook al bezig geweest om bovenstaande beheerbaar te houden een soort van administratie systeem te ontwikkelen. Afgezien dat het misschien een heel ander topic zou moeten is het misschien niet verkeerd om wat tips te vragen welk uitgangspunt genomen zou moeten worden. Welk uitgangspunt zou het beste zijn?

[Voutloos]

OR gebruiken in join condities, dat is imo toch wel behoorlijk ranzig. Of je datamodel is niet goed, of als je zelf vind van wel , kan je imo beter een type kolom introduceren en gewoon joinen op beide voorwaarden. Je zal dan wellicht een aantal extra joins moeten opschrijven, maar dan kan je tenminste wel via aliases duidelijk een Shop Image en een Product Image selecteren (of je weet tenminste of de Image van een Shop of Product is) in die mega select.

Ik pak nu 1 puntje eruit, maar ik kan me nog steeds niet vinden in het gehele datamodel. Ik ken heel wat grote(re) db's die eenvoudiger te query'en zijn en kan me niet herinneren ooit een OR clause in een join conditie gebruikt te hebben.

[Verwijderd]

Gerwin schreef op woensdag 31 oktober 2007 @ 00:04:
Bovenstaande mysql oplossing schijnt wel te werken achteraf. Ik krijg nu netjes alle rijen terug die ik wil. Echter moet ik nu wel alles handmatig via PHP in de database gooien wat een gigantisch probleem is. In mijn achterhoofd ben ik natuurlijk ook al bezig geweest om bovenstaande beheerbaar te houden een soort van administratie systeem te ontwikkelen. Afgezien dat het misschien een heel ander topic zou moeten is het misschien niet verkeerd om wat tips te vragen welk uitgangspunt genomen zou moeten worden. Welk uitgangspunt zou het beste zijn?

Ik denk dat het belangrijkste uitgangspunt is dat je user interface om de boel te onderhouden echt niet 1 op 1 hoeft overeen te komen met wat er precies in de database wordt opgeslagen.

[Gerwin]

Voutloos schreef op woensdag 31 oktober 2007 @ 09:32:
OR gebruiken in join condities, dat is imo toch wel behoorlijk ranzig. Of je datamodel is niet goed, of als je zelf vind van wel , kan je imo beter een type kolom introduceren en gewoon joinen op beide voorwaarden. Je zal dan wellicht een aantal extra joins moeten opschrijven, maar dan kan je tenminste wel via aliases duidelijk een Shop Image en een Product Image selecteren (of je weet tenminste of de Image van een Shop of Product is) in die mega select.

Ik pak nu 1 puntje eruit, maar ik kan me nog steeds niet vinden in het gehele datamodel. Ik ken heel wat grote(re) db's die eenvoudiger te query'en zijn en kan me niet herinneren ooit een OR clause in een join conditie gebruikt te hebben.

Dat verhaal met OR in JOIN condities is niet erg netjes maar ik zie direct niet zo een andere mogelijkheid om een tabel "dubbel" te joinen. Dit is waar ik de hele tijd hoe ik het ook draai tegenaan loop. Ik heb 3 of 4 tabellen met Titels bijvoorbeeld. Vervolgens wil ik in de kolom Titel alle Titels van de 3 of 4 bestaande tabellen hebben. Als ik hiervoor weer extra koppeltabellen moet maken is het einde zoek. De suggestie om zoiets met meerdere joins te doen begrijp ik. Dat heb ik geprobeerd, alleen kun je een tabel maar eenmaal joinen, ik bedoel dan: zie dan alles toch maar in 1 kolom te krijgen. Concreet hoe had jij dan zo'n join gedaan?

Verwijderd schreef op woensdag 31 oktober 2007 @ 09:34:
[...]

Ik denk dat het belangrijkste uitgangspunt is dat je user interface om de boel te onderhouden echt niet 1 op 1 hoeft overeen te komen met wat er precies in de database wordt opgeslagen.

Dat is zeker waar, maar zeker bij een gebruikersinterface moet je top-down systeem hebben. Ik ben in elk geval weer terug bij de tekentafel voor het database model.

[Voutloos]

Gerwin schreef op dinsdag 06 november 2007 @ 13:18:
De suggestie om zoiets met meerdere joins te doen begrijp ik. Dat heb ik geprobeerd, alleen kun je een tabel maar eenmaal joinen, ik bedoel dan: zie dan alles toch maar in 1 kolom te krijgen. Concreet hoe had jij dan zo'n join gedaan?

Met oa aliases kan het dus wel (had ik al gezegd ).

SQL:

SELECT A1.Kolom AS A1Kolom, A2.Kolom AS A2Kolom ...
[...]
LEFT JOIN A as A1 ON ...
LEFT JOIN A as A2 ON ...
[..]

Als het in 1 kolom moet kan het ook op 101 manieren, oa if en coalesce functies.

[Gerwin]

Voutloos schreef op dinsdag 06 november 2007 @ 13:38:
[...]
Met oa aliases kan het dus wel (had ik al gezegd ).

SQL:

SELECT A1.Kolom AS A1Kolom, A2.Kolom AS A2Kolom ...
[...]
LEFT JOIN A as A1 ON ...
LEFT JOIN A as A2 ON ...
[..]

Als het in 1 kolom moet kan het ook op 101 manieren, oa if en coalesce functies.

Juist, maar als ik nu het volgende wil:

SQL:

SELECT A1.Kolom AS A1Kolom, A2.Kolom AS A2Kolom ...
[...]
LEFT JOIN A as A1 ON Koppeltabel1....
LEFT JOIN A as A1 ON Koppeltabel2....
[..]

Ik wil de joins samenvoegen zodat ik alles in 1 kolom krijg. In bovenstaande dus A1.Kolom "waarde". van de join van de eerste of de join van de tweede en/of waar dat mogelijk is. In dit geval krijg ik de melding dat de tabel niet uniek is. Dit terwijl ik de waarde van de kolom zegmaar toch wil 'samenvoegen' tot 1.

[Voutloos]

Lees mijn laatste opmerking nog eens. Ik had het eerst over aliases en vervolgens mag ik die voorkauwen omdat je erover heen leest, nu noem ik bijv. een coalesce, maar die mag je zelf uitzoeken.

_{En ik zou ze dus in de meeste situaties apart willen hebben, danwel gewoon echt een ander datamodel nemen.}

[ Voor 23% gewijzigd door Voutloos op 07-11-2007 08:01 ]

[Confusion]

Voutloos schreef op woensdag 07 november 2007 @ 08:00:
nu noem ik bijv. een coalesce, maar die mag je zelf uitzoeken.

Die noemde ik 27 oktober ook al, maar ik heb niet het idee heb dat de topicstarter al enig advies in dit topic heeft opgevolgd. Vandaar dat er waarschijnlijk ook niemand meer reageert.

[Gerwin]

Voeg Productnaam1 toe aan Product-tabel.

code:

Product         Image        Title
Productnaam1    NULL         NULL

Voeg Image1 toe aan Productnaam1.

code:

Product         Image        Title
Productnaam1    Image1       NULL

Nu heb ik dus een product met een plaatje in de database.
Ik voeg Titel1 toe aan Productnaam1

code:

Product         Image        Title
Productnaam1    Image1       Titel1

Hier loopt het dan spaak.
Ik voeg Titel2 toe aan Image1.

code:

Product         Image        Title
Productnaam1    Image1       Titel1        
Productnaam1    Image1       Titel2

Titel1 is gekoppeld met koppeltabel Product2Title.
Titel2 is gekoppeld met koppeltabel Image2Title.

Nu wil ik zoals hierboven de titels gelijk in 1 kolom houden.
Op een-of-andere manier moet ik dus dubbel koppelen op de tabellen.

SQL:

SELECT
    Product, Image, ProductTitle.Title as ProductTitle, ImageTitle.Title as ImageTitle
FROM
    Company
    LEFT JOIN Product ON Company.CompanyID = Product.CompanyID
    LEFT JOIN Product2Image ON Product.ProductID = Product2Image.ProductID
    LEFT JOIN Image ON Product2Image.ImageID = Image.ImageID
     
    LEFT JOIN Product2Title ON Product.ProductID = Product2Title.ProductID
    LEFT JOIN Image2Title ON Image.ImageID = Image2Title.ImageID
    
    LEFT JOIN Title ProductTitle ON Product2Title.TitleID = ProductTitle.TitleID
    LEFT JOIN Title ImageTitle ON Image2Title.TitleID = ImageTitle.TitleID

En nu zou ik middels 'Coalesce' de ProductTitle en ImageTitle in 1 kolom kunnen krijgen?

[ Voor 3% gewijzigd door Gerwin op 08-11-2007 02:01 ]

[P.O. Box]

wat jij wilt kan helaas niet... althans, niet in MySQL....
tenzij je er een stored procedure voor gaat schrijven...

[ Voor 33% gewijzigd door P.O. Box op 08-11-2007 04:11 ]

[Gerwin]

Edwardvb schreef op donderdag 08 november 2007 @ 03:25:
wat jij wilt kan helaas niet... althans, niet in MySQL....
tenzij je er een stored procedure voor gaat schrijven...

Ik had dit probleem opgelost met de volgende code:

SQL:

SELECT
    Product, Image, Title
FROM
    Company
    LEFT JOIN Product ON Company.CompanyID = Product.CompanyID
    LEFT JOIN Product2Image ON Product.ProductID = Product2Image.ProductID
    LEFT JOIN Image ON Product2Image.ImageID = Image.ImageID
     
    LEFT JOIN Product2Title ON Product.ProductID = Product2Title.ProductID
    LEFT JOIN Image2Title ON Image.ImageID = Image2Title.ImageID
    
    LEFT JOIN Title ON (Product2Title.TitleID = ProductTitle.TitleID OR
                                       Image2Title.TitleID = ImageTitle.TitleID)
    
 

Waarna ik een comment kreeg dat OR niet nodig was en dat het anders kon.
En nu blijkt alles toch niet te kunnen?

[P.O. Box]

volgens mij wil jij dit:

code:

Productnaam1    Image1       Titel1, Titel2

althans, dat zeg je...

dat los je niet op met die OR... met een stored procedure of stored function kun je denk ik eventueel een functie schrijven die bovenstaande wel bewerkstellig... dan krijg je zoiets als
pseudo:

SQL:

select productnaam, imagenaam, MyFuncTitels(productid)
from blabla

waarbij MyFuncTitels door alle mogelijke titels bij een product loopt en ze in een string teruggeeft...

overigens heb ik dit probleem ooit eens met pivottables opgelost volgens mij... maar de mogelijkheid voor pivottables bestaat iig niet tot en met MySQL 4... weet niet hoe het met versie 5 zit...

[ Voor 17% gewijzigd door P.O. Box op 08-11-2007 07:48 ]

[Gerwin]

Nee, nee, als in dit hele topic een dele heeft gedacht dat ik zaken achter elkaar wil plakken of op de manier die Edwardvb zegt achter elkaar wil dan spijt me dat. Ik krijgt met mijn volgende query in elk geval voor elkaar wat ik wil bereiken, er kwamen echter reply's dat een join met een OR erin niet een nette query was en dat het anders kon met 'Coalesce'. Ik zie alleen niet hoe dat mogelijk moet zijn.

Wat ik heb is:

SQL:

SELECT
    Product, Image, Title
FROM
    Company
    LEFT JOIN Product ON Company.CompanyID = Product.CompanyID
    LEFT JOIN Product2Image ON Product.ProductID = Product2Image.ProductID
    LEFT JOIN Image ON Product2Image.ImageID = Image.ImageID
     
    LEFT JOIN Product2Title ON Product.ProductID = Product2Title.ProductID
    LEFT JOIN Image2Title ON Image.ImageID = Image2Title.ImageID
    
    LEFT JOIN Title Title ON (Product2Title.TitleID = ProductTitle.TitleID OR
                              ImageTitle ON Image2Title.TitleID = ImageTitle.TitleID)
 

En meer complex met alle tabellen erin:

SQL:

SELECT `Company`, `Shop`, `Product`, `Image`, `Title`, `Description`, `Text`
FROM `Company`

  # Shop, en Product erbij
  LEFT JOIN `Shop` USING (`CompanyID`)
  LEFT JOIN `Product` USING (`ShopID`)
  
  # Jointabellen van Shop en Product
  LEFT JOIN `Shop2Image` ON `Shop2Image`.`ImageID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Image` ON `Product2Image`.`ImageID` = `Product`.`ProductID`
  
  # Image erbij
  LEFT JOIN `Image` ON (`Image`.`ImageID` = `Shop2Image`.`ImageID` OR
                        `Image`.`ImageID` = `Product2Image`.`ImageID`)
  
  # Alle Titels, Descriptions en Text
  LEFT JOIN `Shop2Title` ON `Shop2Title`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Title` ON `Product2Title`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Title` ON `Image2Title`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Title` ON (`Title`.`TitleID` = `Shop2Title`.`TitleID` OR
                        `Title`.`TitleID` = `Product2Title`.`TitleID` OR
                        `Title`.`TitleID` = `Image2Title`.`TitleID`)

  LEFT JOIN `Shop2Description` ON `Shop2Description`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Description` ON `Product2Description`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Description` ON `Image2Description`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Description` ON (`Description`.`DescriptionID` = `Shop2Description`.`DescriptionID` OR
                              `Description`.`DescriptionID` = `Product2Description`.`DescriptionID` OR
                              `Description`.`DescriptionID` = `Image2Description`.`DescriptionID`)

  LEFT JOIN `Shop2Text` ON `Shop2Text`.`ShopID` = `Shop`.`ShopID`
  LEFT JOIN `Product2Text` ON `Product2Text`.`ProductID` = `Product`.`ProductID`
  LEFT JOIN `Image2Text` ON `Image2Text`.`ImageID` = `Image`.`ImageID`
  LEFT JOIN `Text` ON (`Text`.`TextID` = `Shop2Text`.`TextID` OR
                       `Text`.`TextID` = `Product2Text`.`TextID` OR
                       `Text`.`TextID` = `Image2Text`.`TextID`)

De code werkt; dat wil zeggen vooralsnog ben ik geen dingen tegengekomen die ik niet zou willen.
Als deze code dan toch niet netjes is hoe is dan de code netter te maken en kan toch hetzelfde bereikt worden?