Delen via

Relaties beheren in Fabric-API voor GraphQL

Relaties transformeren uw GraphQL-API van eenvoudige gegevenstoegang tot een krachtige grafiek die weerspiegelt hoe uw bedrijfsentiteiten daadwerkelijk verbinding maken. In plaats van klanten te dwingen meerdere roundtrips uit te voeren en gegevens handmatig samen te voegen, maken relaties het mogelijk om diep geneste en gerelateerde gegevens op te halen met één query, waarmee u tegelijkertijd een klant, zijn orders, de producten in die orders en de productcategorieën opvraagt.

Zonder relaties retourneert uw API geïsoleerde gegevens die clients zelf moeten samenvoegen. Met relaties definieert u deze verbindingen eenmaal in uw schema. GraphQL verwerkt de doorkruising automatisch. Een query die begint vanuit een product, kan bijvoorbeeld door orders navigeren om alle klanten te vinden die het hebben gekocht, of beginnen bij een klant om alle producten te zien die ze ooit hebben besteld, allemaal in één efficiënte aanvraag.

Fabric-API voor GraphQL ondersteunt drie relatiepatronen die betrekking hebben op alle algemene scenario's voor gegevensmodellering:

  • Een-op-een (1:1): elke record in één type heeft betrekking op precies één record in een ander type (bijvoorbeeld: Product → ProductCategorie, waarbij elk product één categorie heeft)
  • Een-op-veel (1:N): elke record in één type heeft betrekking op meerdere records in een ander type (bijvoorbeeld: ProductCategory → Product, waarbij elke categorie veel producten bevat)
  • Veel-op-veel (M:N): records in beide typen kunnen betrekking hebben op meerdere records in het andere type (bijvoorbeeld: SalesOrderHeader ↔ Product, waarbij orders meerdere producten bevatten en producten voorkomen in meerdere orders)

Door deze relaties in uw GraphQL-schema te modelleren, maakt u een intuïtieve API die uw domeinmodel weerspiegelt en de code van de clienttoepassing aanzienlijk vereenvoudigt.

Vereiste voorwaarden

Voordat u relaties maakt, hebt u het volgende nodig:

  • Ten minste twee typen die zijn gedefinieerd in uw GraphQL API-schema. Als u bijvoorbeeld AdventureWorks-voorbeeldgegevens gebruikt, hebt u mogelijk typen zoals Product, ProductCategory, SalesOrderHeaderen SalesOrderDetail al gemaakt op basis van uw lakehouse- of magazijntabellen. Als u nog geen typen hebt, raadpleegt u Een API voor GraphQL maken in Fabric en voegt u gegevens toe.

  • Overeenkomende velden (refererende sleutels) tussen de typen die u wilt relateren. Voor een een-op-een- of een-op-veel-relatie hebt u een gemeenschappelijk veld in beide typen nodig, zoals ProductCategoryID in beide Product en ProductCategory. Deze velden fungeren als de verbindingspunten voor de relatie.

  • Een koppelingstype (verbindingstabel) voor veel-op-veel-relaties. Als u een veel-op-veel-relatie maakt, hebt u een derde type nodig dat de andere twee verbindt. Om bijvoorbeeld SalesOrderHeader en Product in een veel-op-veel-relatie te verbinden, hebt u SalesOrderDetail als het koppelingstype nodig. Dit koppelingstype moet refererende sleutels bevatten die verwijzen naar beide typen die u wilt relateren (zoals SalesOrderID en ProductID). Meer informatie over veel-op-veel-relaties.

Een nieuwe een-op-een-relatie maken

Een een-op-een-relatie verbindt twee typen waarbij elke record in één type betrekking heeft op precies één record in het andere type. Dit is handig wanneer u gerelateerde gegevens hebt die zich in dezelfde tabel kunnen bevinden, maar om organisatorische of prestatieredenen zijn gescheiden. Een Product kan bijvoorbeeld verband houden met precies één ProductCategory via een ProductCategoryID-veld.

De volgende stappen laten zien hoe u een een-op-een-relatie maakt:

  1. Selecteer in het deelvenster Schemaverkenner het beletselteken naast een type en selecteer vervolgens de optie Relaties beheren . Het scherm Relaties beheren wordt weergegeven.

    Schermopname die laat zien waar u een nieuwe relatie selecteert in het deelvenster Relaties beheren.

  2. Selecteer Nieuwe relatie. In dit voorbeeld maken we een nieuwe een-op-een-relatie tussen het producttype en het type ProductCategory , op basis van het veld ProductCategoryID dat in beide typen bestaat. We selecteren er een voorkardinaliteit, selecteer de typen Van en Aan en selecteer vervolgens de velden Van en Aan voor deze relatie.

    Schermopname met voorbeelden van selecties voor de vijf vereiste velden voor een nieuwe relatie.

Notitie

U kunt meerdere velden selecteren in de veldkiezers Van en Aan. Met deze functie kunt u relaties maken die meerdere velden bevatten.

  1. Selecteer Relatie maken. In uw lijst met relaties wordt nu de zojuist gemaakte relatie weergegeven.

  2. Selecteer de X in de rechterbovenhoek om het scherm Relaties beheren te sluiten.

Een-op-veel-relaties (1:N) en veel-op-veel-relaties (M:N)

Hoewel een-op-een-relaties eenvoudig zijn, verwerken een-op-veel- en veel-op-veel-relaties complexere gegevenspatronen die gebruikelijk zijn in echte toepassingen. Het proces voor het maken van deze relaties is vergelijkbaar met een-op-een, maar de kardinaliteitsselectie bepaalt hoe GraphQL de relatie interpreteert en beschikbaar maakt.

Een-op-veel-relaties (1:N)

Een een-op-veel-relatie verbindt één record in één type met meerdere records in een ander type. Een enkele ProductCategory bevat bijvoorbeeld veel Product records, maar elk Product behoort tot slechts één categorie.

Als u een een-op-veel-relatie tussen ProductCategory en Product wilt maken, selecteert u een-op-veel-relatie als de kardinaliteit. Volg dezelfde stappen als voor een-op-een-relaties, maar de kardinaliteitsinstelling vertelt GraphQL dat één categorie betrekking heeft op veel producten.

Veel-op-veel-relaties (M:N)

Een veel-op-veel-relatie verbindt records waar beide zijden meerdere gerelateerde records kunnen hebben. Een kan bijvoorbeeld SalesOrderHeader meerdere Product records bevatten en elk Product kan in meerdere orders worden weergegeven. Voor deze relaties is een koppelingstype (verbindingstabel) vereist om de verbindingen tussen de twee hoofdtypen op te slaan.

Als u een veel-op-veel-relatie tussen SalesOrderHeader en Product wilt maken, hebt u het koppelingstype SalesOrderDetail nodig. Dit koppelingstype bevat refererende sleutels die verwijzen naar beide typen die u wilt relateren.

Om de veel-op-veel-relatie te creëren:

  1. Selecteer in het deelvenster Schemaverkenner het beletselteken naast een type en selecteer vervolgens de optie Relaties beheren . Het scherm Relaties beheren wordt weergegeven.
  2. Selecteer Nieuwe relatie.
  3. Kardinaliteit: Selecteer Veel-tot-veel en de extra velden voor koppelen worden weergegeven. Schermopname van het nieuwe dialoogvenster voor een veel-op-veel-relatie.
  4. Van type: SalesOrderHeader selecteren (één kant van de relatie)
  5. Type koppeling: Selecteer SalesOrderDetail (de verbindingstabel die orders verbindt met producten)
  6. Van veld(en): Selecteer SalesOrderID (het veld in SalesOrderHeader dat is gekoppeld aan het koppelingstype)
  7. Koppelen vanuit veld(en): Selecteer SalesOrderID (het overeenkomende veld in SalesOrderDetail dat verbinding maakt met SalesOrderHeader)
  8. Om te typen: Selecteer Product (de andere kant van de relatie)
  9. Veld(en): Selecteer Product-id (het veld in Product dat is gekoppeld aan het koppelingstype)
  10. Koppelen aan veld(en): Selecteer Product-id (het overeenkomende veld in SalesOrderDetail dat verbinding maakt met Product)

Het belangrijkste concept: het koppelingstype (SalesOrderDetail) heeft twee vreemde sleutels, waarvan er één naar elk van de typen verwijst die u wilt relateren. De velden Koppelen van veld(en) en Koppelen aan veld(en) zijn beide velden in het koppelingstype, terwijl 'Van veld(en)' en 'Aan-veld(en)' de gerelateerde typen bevatten.

Overwegingen voor veel-op-veel-relaties

Wanneer u een veel-op-veel-verbinding maakt, hangt wat GraphQL automatisch genereert af van of uw koppelingstype extra velden naast de twee vreemde sleutels bevat.

Algemene regel:

  • Als het koppelingstype extra velden bevat dan de refererende sleutels (meest voorkomende), maakt GraphQL vier een-op-veel-relaties waarmee het koppelingstype wordt weergegeven. Hiermee hebt u toegang tot deze extra velden in uw query's en kunt u tussen typen in beide richtingen navigeren.
  • Als het koppelingstype alleen de twee vreemde sleutels (minder algemeen) bevat, maakt GraphQL de directe veel-op-veel-relatie. U kunt rechtstreeks een query uitvoeren tussen de twee hoofdtypen zonder te verwijzen naar het koppelingstype.

Type koppeling met extra velden (typisch scenario)

In de meeste praktijkscenario's heeft uw koppelingstype velden naast de twee foreign keys. Verbindingstabellen slaan doorgaans informatie op over de relatie zelf, niet alleen welke records zijn gerelateerd, maar details over hoe ze gerelateerd zijn.

Wanneer u de veel-op-veel-relatie maakt, genereert de API vier relaties die worden weergegeven in uw relatielijst. Waarom vier? Omdat u bidirectionele navigatie tussen alle drie de typen nodig hebt.

Als SalesOrderDetail bijvoorbeeld extra velden bevat, zoals OrderQty, UnitPriceof UnitPriceDiscount (verder dan alleen SalesOrderID en ProductID), ziet u deze vier relaties in de portal:

  • SalesOrderHeader → SalesOrderDetail (een-op-veel): Begin bij een order en lijst alle regelitems op om hoeveelheden en prijzen te zien
  • SalesOrderDetail → SalesOrderHeader (veel-op-een): Begin vanaf een regelitem en navigeer terug om te zien tot welke volgorde het behoort
  • Product → SalesOrderDetail (een-op-veel): Begin met een product en bekijk alle orders waarin het wordt weergegeven met hun hoeveelheden
  • SalesOrderDetail → Product (veel-op-een): Begin met een regelitem en navigeer om te zien welk product is besteld

Deze vier relaties bieden u volledige flexibiliteit om te beginnen met elk type (SalesOrderHeader, Product of SalesOrderDetail) en naar elk ander type te navigeren, terwijl u de extra velden opent, zoals OrderQty en UnitPrice die alleen in het koppelingstype bestaan.

Type koppelen met alleen refererende sleutels

Als SalesOrderDetailalleenSalesOrderID en ProductID (geen andere velden) bevat, maakt de API twee een-op-veel-relaties die u in de portal ziet:

  • SalesOrderHeader → SalesOrderDetail (een-op-veel)
  • Product → SalesOrderDetail (een-op-veel)

In dit scenario kunnen query's rechtstreeks van orders naar producten navigeren (en omgekeerd) zonder expliciet te verwijzen naar het koppelingstype in uw GraphQL-query's. Het koppelingstype bestaat, maar voegt geen waarde toe omdat het geen extra gegevens bevat.

Een relatie verwijderen

U kunt relaties verwijderen die niet meer nodig zijn of onjuist zijn gemaakt. Als u een relatie verwijdert, worden de typen zelf niet verwijderd. Hiermee wordt alleen de verbinding tussen deze typen verwijderd.

Een relatie verwijderen:

  1. Selecteer in het deelvenster Schemaverkenner het beletselteken naast een type met relaties en selecteer vervolgens relaties beheren. Het scherm Relaties beheren wordt weergegeven met alle relaties voor het geselecteerde type.

  2. Schakel het selectievakje in naast elke relatie die u wilt verwijderen. U kunt meerdere relaties selecteren om ze in één bewerking te verwijderen.

  3. Selecteer dan Verwijderen op de werkbalk.

  4. Bevestig de verwijdering wanneer hierom wordt gevraagd. De relatie wordt verwijderd uit uw GraphQL-schema.

Aanbeveling

Als u een veel-op-veel relatie hebt gemaakt en deze wilt verwijderen, moet u alle vier relaties verwijderen (of twee relaties als het koppelingstype alleen vreemde sleutels heeft) die zijn aangemaakt. Elke relatie wordt weergegeven als een afzonderlijk item in de relatielijst.

Gerelateerde inhoud

  • Last updated on