serien så langt:

  1. SQL Server Graph Databaser-Del 1:Introduksjon
  2. SQL Server Graph Databaser-Del 2: Spørring Data i En Graf Database
  3. SQL Server Graph Databaser-Del 3: Endre Data i En Graf Database
  4. SQL Server Graph Databaser – Del 4: Arbeide med hierarkiske data i en graf database
  5. SQL Server Graph Databaser – Del 5: Importere Relasjonsdata Til En Grafdatabase

Med utgivelsen AV SQL Server-2017 la Microsoft til støtte for grafdatabaser for å bedre håndtere datasett som inneholder komplekse enhetsrelasjoner, for eksempel typen data generert av et sosialt medieområde, der Du kan ha en blanding av mange til mange relasjoner som endres ofte. Grafdatabaser bruker de samme tabellstrukturene som finnes i tradisjonelle SQL Server-databaser, og støtter de samme verktøyene og T-SQL-setningene, men de inneholder også funksjoner for lagring og navigering av komplekse relasjoner.

denne artikkelen er den første i en serie om SQL Server graph-databaser. Artikkelen introduserer deg til grunnleggende grafkonsepter og demonstrerer hvordan du oppretter og fyller ut graftabeller ved HJELP AV SQL Server Management Studio (SSMS) og en lokal forekomst AV SQL Server 2017. I artiklene som skal følges, graver vi inn i hvordan du spør en grafdatabase og endrer dataene, men for denne artikkelen begynner vi med det grunnleggende.

SQL Server-Grafdatabasen

SQL Servers grafdatabaser kan bidra til å forenkle prosessen med modellering av data som inneholder komplekse mange til mange og hierarkiske relasjoner. På sitt mest grunnleggende, en graf database er en samling av noder og kanter som arbeider sammen for å definere ulike typer relasjoner. En node er en enhet som en person eller et sted. En kant er et forhold mellom to enheter. For eksempel, et forhold kan eksistere mellom et sted som Toledo og en person som heter Chris, som bor I Toledo. Chris Og Toledo er enhetene, og’ bor i ‘ er forholdet mellom de to.

en nodetabell I SQL Server er en samling av lignende enheter, og en kanttabell er en samling av lignende relasjoner. For å forstå hvordan dette fungerer, bør du vurdere grafmodellen vist i figuren nedenfor, som er basert på et fiktivt fiskelskere forum. Modellen inneholder tre noder (FishSpecies, FishLover Og FishPost) og tre kanter (Liker, Innlegg og LinksTo).

rektanglene representerer nodene, og pilene som forbinder nodene representerer kantene, med pilene peker i retning av forholdet. Liker kantene kan for Eksempel definere noen av følgende relasjoner:

  • en fiskelsker liker en fiskeart.
  • en fiskelsker liker et innlegg om fisk.
  • en fiskeelsker liker en annen fiskeelsker.

du kan representere alle tre relasjonene som data i en enkelt kanttabell i grafdatabasen, med hver relasjon i sin egen rad. En node tabell fungerer mye på samme måte, bortsett fra at den inneholder en rad for hver enhet. Du kan også knytte egenskaper til både noder og kanter. En egenskap er et nøkkelverdiattributt som er definert som en kolonne i en node eller kanttabell. For Eksempel Kan FishSpecies node inneholde egenskaper for lagring av de vanlige og vitenskapelige navnene til hver art. Egenskapene opprettes som brukerdefinerte kolonner i FishSpecies-tabellen. Når du oppretter et nodetabell, må du inkludere minst en egenskap.

for de fleste operasjoner fungerer node-og kanttabeller akkurat som alle ANDRE BRUKERDEFINERTE SQL Server-tabeller. Selv om det er noen begrensninger—for eksempel ikke å kunne erklære midlertidige tabeller eller tabellvariabler som node-eller kanttabeller-vil du mesteparten av tiden oppdage at det å jobbe med graftabeller vil være kjent territorium.

hvor ting blir litt uklare, er med grafdatabasen selv. Selv om navnet kan tyde på at du oppretter en ny type databaseobjekt, er det ikke tilfelle. En grafdatabase er bare en logisk konstruksjon definert i en brukerdefinert database, som ikke kan støtte mer enn en grafdatabase. Eksistensen av grafdatabasen er relativt gjennomsiktig fra utsiden, og for det meste er det ikke noe du trenger å være bekymret for. Når du arbeider med grafdatabaser, vil hovedfokuset være på graftabellene og dataene de inneholder.

generelt gir en grafdatabase ingen funksjoner som du ikke kan oppnå ved å bruke tradisjonelle relasjonsfunksjoner. Løftet av grafen databasen ligger i å kunne organisere og spørre visse typer data mer effektivt. Microsoft anbefaler at du vurderer å implementere en grafdatabase under følgende omstendigheter:

  • du må analysere svært sammenkoblede data og relasjonene mellom dataene.
  • du støtter data med komplekse mange-til-mange-relasjoner som kontinuerlig utvikler seg.
  • du arbeider med hierarkiske data mens du prøver å navigere i begrensningene For Datatypen HierarchyID.

SQL Servers grafdatabasefunksjoner er fullt integrert i databasemotoren, og utnytter slike komponenter som spørringsprosessoren og lagringsmotoren. På grunn av denne integrasjonen kan du bruke grafdatabaser sammen med et bredt spekter av komponenter, inkludert columnstore-indekser, Maskinlæringstjenester, SSMS og ulike andre funksjoner og verktøy.

Definere Grafnodetabeller

hvis du vil opprette en grafdatabase basert på modellen som vises i figuren ovenfor, må du opprette tre nodetabeller og tre kanttabeller. Microsoft har oppdatert CREATE TABLE-setningen I SQL Server-2017 for å inkludere alternativer for å definere en av tabelltypene. Som allerede nevnt, kan du opprette tabellene i noen brukerdefinerte databaser. For eksemplene i denne artikkelen opprettet jeg en grunnleggende database Kalt FishGraph, som vist i følgende T-SQL-kode:

1
2
3
4
5
6

BRUK master;
SLIPP DATABASE HVIS Det FINNES FishGraph;
OPPRETT DATABASE FishGraph;

Som du kan se, er det ikke noe spesielt som skjer her. Du oppretter databasen akkurat som alle andre brukerdefinerte database. Det er ikke noe spesielt du trenger å gjøre for å sette det opp for å støtte en grafdatabase.

hvis du har tenkt å prøve ut disse eksemplene selv, kan Du bruke FishGraph database eller en av dine egne valg. Uansett hva du bestemmer deg for, er neste trinn å opprette FishSpecies node-tabellen, ved hjelp av FØLGENDE CREATE TABLE-setning:

1
2
3
4
5
6
7
8
9

BRUK FishGraph;
SLIPP TABELLEN HVIS Finnes FishSpecies;
OPPRETT TABELL FishSpecies (
FishID INT IDENTITET PRIMÆRNØKKEL,
CommonName NVARCHAR(100) IKKE NULL,
Vitenskapelig navn nvarchar(100) ikke null
) SOM NODE;

kolonnedefinisjonene skal være ganske enkle. Det som er viktig her ER AS NODE-klausulen, som du må inkludere for å opprette en nodetabell. Når du angir denne klausulen, legger databasemotoren til to kolonner i tabellen (som vi kommer til kort tid) og oppretter en unik, ikke-gruppert indeks på en av disse kolonnene.

du kan kontrollere om tabellen er opprettet som en nodetabell ved å spørre sys-ene.tabeller visning. Med utgivelsen AV SQL Server 2017 oppdaterte Microsoft visningen for å inkludere is_node-og is_edge-bitkolonnene. Hvis tabellen er en nodetabell, er kolonneverdien is_node satt til 1, og kolonneverdien is_edge er satt til 0. Hvis en kanttabell, reverseres verdiene. Følgende eksempel bruker visningen for å bekrefte At FishSpecies-tabellen er riktig definert:

1
2

VELG is_node, is_edge FRA sys.tabeller
hvor navn = ‘Fiskearter’;

SELECT-setningen returnerer resultatene som vises i figuren nedenfor, som indikerer At Fiskearter ble opprettet som en nodetabell.

Microsoft har også oppdatert systemet.kolonner vise for å inkludere graph_type og graph_type_desc kolonner. Du kan bruke kolonnene vis og nye til å lære mer om Tabellen Fiskearter:

1
2
3

VELG navn, graph_type, graph_type_desc
FRA sys.kolonner
hvor object_id = OBJECT_ID (‘FishSpecies’);

følgende figur viser kolonnene som er opprettet For FishSpecies-tabellen.

når du oppretter en nodetabell, legger databasemotoren til kolonnene graph_id_ < hex_string> og $node_id_ < hex_string > og oppretter en unik indeks som ikke er gruppert i kolonnen $node_id. Databasemotoren bruker den første kolonnen for interne operasjoner og gjør den andre kolonnen tilgjengelig for ekstern tilgang. Kolonnen $node_id lagrer en unik identifikator for hver enhet, som du kan vise når du spør dataene. Dette er den eneste kolonnen av de to du trenger å være opptatt av. Faktisk, hvis du skulle spørre tabellen direkte, ville du bare se $ node_id-kolonnen, ikke graph_id-kolonnen.

kolonnene graph_type og graph_type_desc returnert av sys.kolonnevisningen er spesifikk for de automatisk genererte kolonnene i en graftabell. Kolonnene angir hvilke typer kolonner som databasemotoren genererte. Typen er angitt med en forhåndsdefinert numerisk verdi og tilhørende beskrivelse. Microsoft gir ikke mye detaljer om disse kodene og beskrivelsene, men du finner noen detaljer i Microsoft document SQL Graph-Arkitekturen. Igjen er din primære bekymring med $node_id-kolonnen og dataene den inneholder.

når du har opprettet tabellen, kan du begynne å legge til data. Kjører EN INSERT-setning mot en node tabell fungerer akkurat som alle andre tabeller. Du angir målkolonnene og deres verdier, som vist i følgende eksempel:

1
2
3
4
5
6
7
8
9
10
11

INSERT INTO FishSpecies (CommonName, ScientificName) VALUES
(‘Atlantic halibut’, ‘Hippoglossus hippoglossus’),
(‘Chinook salmon’, ‘Oncorhynchus tshawytscha’),
(‘European seabass’, ‘Morone (Decentrarchus) labrax’),
(‘Gizzard shad’, ‘Dorosoma cepedianum’),
(‘Japanese striped knife jaw’, ‘Opleggnathus faciatus»),
(‘Gjedde’, ‘Esox lucius’),
(‘Pacific sild’, ‘Clupea pallasi’),
(‘Regnbueørret’, ‘Oncorhynchus mykiss’),
(‘Sole (Dover)’, ‘Solea solea’),
(‘Hvit bass’, ‘Morone chrysops’);

Selvfølgelig kan du legge til hva fiskearter du har en spesiell forkjærlighet for. Mine valg her var helt vilkårlig. Men hvis du holder deg til dataene mine og spør Etter fishspecies-tabellen, bør resultatene dine se ut som de i følgende figur.

som nevnt ovenfor vises ikke kolonnen graph_id i resultatene, men kolonnen $node_id gjør det, komplett med automatisk genererte verdier. Databasemotoren oppretter hver verdi som EN json-streng som gir typen (node eller kant), skjema, tabell og EN BIGINT-verdi som er unik for hver rad. Som forventet returnerer databasemotoren også verdiene i de brukerdefinerte kolonnene, akkurat som en vanlig relasjonstabell.

det neste trinnet er å opprette Og fylle FishLover node-tabellen, ved hjelp av følgende T-SQL-kode:

1
2
3
4
5
6
7
8
9
10
11
12

SLIPP TABELL HVIS Finnes FishLover;
OPPRETT Tabell FishLover (
FishLoverID INT IDENTITET PRIMÆRNØKKEL,
Brukernavn NVARCHAR (50) IKKE NULL,
) SOM NODE;
SETT INN FishLover (Brukernavn) VERDIER
(‘powerangler’),
(‘jessie98’),
(‘hekta’),
(‘deepdive’),
(‘undervannsoperasjonercasey’);

tabellen inneholder bare to brukerdefinerte kolonner-FishLoverID og Brukernavn-men du kan definere så mange kolonner som nødvendig. Du kan for eksempel inkludere for-og etternavn, kontaktinformasjon og andre detaljer, avhengig av programmets art. Når du har opprettet tabellen, kan du kjøre en spørring for å bekrefte dataene. Resultatene dine skal se ut som de som er vist i figuren nedenfor.

Du kan deretter ta de samme trinnene for å opprette Og fylle FishPost tabellen, passerer i hva meldingsteksten du ønsker:

1
2
3
4
5
6
7
8
9
10
11
12
13

DROP TABELL HVIS FINNES FishPost;
OPPRETT TABELL FishPost (
POSTID INT IDENTITET PRIMÆRNØKKEL,
Tittel NVARCHAR(50) IKKE NULL,
MessageText NVARCHAR(800) IKKE NULL
) SOM NODE;
sett inn i fishpost (tittel, MESSAGETEXT) VERDIER
(‘Den Som Slapp Unna’, ‘Vårt Team Er Tilgjengelig, VENNLIGST KONTAKT OSS. Aeneas fordel reservert behov.’),
(‘en studie på fisk’, ‘penatibus venenatis, nascetur ridiculus mus.’),
(‘Krok, linje og søkke’, ‘ Donec pede justo, fringilla vel, aliquet nec, vulputate eget, arcu.’),
(‘Så mange fisk, så lite tid’, ‘ Nullam dictum felis eu pede mollis pretium. Integer tincidunt.’),
(‘Min favoritt fisk’, ‘ aenean leo ligula, porttitor eu, consequat vitae, eleifend ac, enim.’);

figuren nedenfor viser resultatene du ville se hvis Du stakk Med Lorem Ipsum data.

Det er alt som er å skape og fylle nodetabellene dine. Bortsett FRA AS NODE-klausulen I CREATE TABLE-setningen, er det meste alt annet som vanlig.

Definere Grafkanttabeller

Opprette en kanttabell ligner på å opprette en nodetabell, bortsett fra at DU må angi AS EDGE-setningsdelen i STEDET FOR AS NODE-setningsdelen. Hvis du for eksempel vil opprette Posts-tabellen, bruker du FØLGENDE CREATE TABLE-setning:

1
2
3
4
5

SLIPP TABELL HVIS Det FINNES Innlegg;
OPPRETT TABELLINNLEGG (
Viktigflaggbit IKKE NULL STANDARD 0
) SOM KANT;

tabelldefinisjonen ligner på en nodetabell, bortsett fra at den ikke inneholder en primærnøkkelkolonne (og selvfølgelig tar DEN AS EDGE-setningsdelen). I dette tilfellet er en primærnøkkel ikke nødvendig, men hvis du på et tidspunkt bestemmer at du trenger en primærnøkkel, kan du sikkert legge til en. (Du vil snart se hvorfor primærnøkler er nyttige for nodetabellene.)

Legg Merke til at tabelldefinisjonen også inneholder Kolonnen ImportantFlag. Jeg inkluderte dette først og fremst for å demonstrere at du kan legge til brukerdefinerte kolonner i kanttabellen, akkurat som med nodetabeller. Når det er sagt, er det ikke uvanlig å lage et kanttabell uten brukerdefinerte kolonner, i motsetning til et nodetabell, som må inneholde minst en brukerdefinert kolonne.

når du har opprettet kanttabellen, kan du bekrefte at den er definert riktig ved å spørre sys.tabellvisning, som du så tidligere:

1
2

VELG is_node, is_edge FRA sys.tabeller
hvor navn = ‘Innlegg’;

hvis du gjorde alt riktig, bør resultatene dine se ut som de i følgende figur.

Du kan også spørre sys.tabeller visning for å bekrefte kolonnedetaljer, akkurat som du gjorde før:

1
2
3

VELG navn, graph_type, graph_type_desc
FRA sys.kolonner
HVOR object_id = OBJECT_ID (‘Innlegg’);

følgende figur viser resultatene som er returnert på systemet mitt.

som du kan se, legger databasemotoren åtte kolonner til et kantbord, i stedet for de to du så med nodetabeller. Igjen, se SQL Graph Arkitektur dokumentet for beskrivelser av hver kolonnetype. At flertallet av disse kolonnene brukes av databasemotoren for interne operasjoner. Du må være opptatt primært med følgende tre kolonner:

  • kolonnen $edge_id_ < hex_string > identifiserer hver relasjon unikt.
  • kolonnen $from_id_<hex_string> lagrer $node_id-verdien som er knyttet til enheten i tabellen der relasjonen kommer fra.
  • kolonnen $to_id_<hex_string> lagrer $node_id-verdien som er knyttet til enheten i tabellen der relasjonen avsluttes.

som med $ node_id-kolonnen i en node-tabell, genererer databasemotoren automatisk verdier for $ edge_id-kolonnen. Du må imidlertid spesifikt legge til verdier i kolonnene $from_id og $to_id for å definere en relasjon. For å demonstrere hvordan dette fungerer, starter vi med en enkelt post:

1
2
3

SETT INN Innlegg ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 1),
(VELG $node_id FRA FishPost HVOR PostID = 3));

INSERT-setningen definerer en relasjon i Posts-tabellen mellom En FishLover-enhet med FishLoverID-verdi på 1 og En FishPost-enhet Med Posttid-verdi på 3. Legg merke til at du kan bruke $node_id, $from_id og $ to_id aliasene for å referere til målkolonnene, uten å måtte komme opp med hex-strengene.

hvis du vil legge til data i kolonnen $from_id, må du angi verdien $node_id som er knyttet Til FishLover-enheten. En måte å få denne verdien på er å inkludere en delquery som retter seg mot enheten, ved hjelp av primærnøkkelverdien. Du kan ta samme tilnærming for $from_id-kolonnen.

Innsetting av dataene på denne måten viser hvorfor det er nyttig å legge til primærnøkler i node-tabellene, men ikke nødvendig for kanttabellene. Primærnøklene på noden tabellene gjør det mye enklere å gi $node_id-verdien TIL INSERT-setningen.

hvis du nå spør I Innleggstabellen, bør resultatene dine se ut som de som vises i figuren nedenfor.

tabellen skal inneholde det nye forholdet, Med ImportantFlag satt til 0, standard. Du kan nå legge til noen flere rader, ved hjelp av FØLGENDE SETT inn setninger:

1
2
3
4
5
6
7
8
9
10
11
12

SETT INN Innlegg ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 3),
(VELG $node_id FRA FishPost HVOR PostID = 2));
SETT INN Innlegg ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 2),
(VELG $node_id FRA FishPost HVOR PostID = 5));
SETT INN I Innlegg ($from_id, $to_id, ImportantFlag) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 5),
(VELG $node_id FRA FishPost HVOR PostID = 4), 1);
SETT INN Innlegg ($from_id, $to_id, ImportantFlag) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 4),
(VELG $node_id FRA FishPost HVOR PostID = 1), 1);

Legg Merke til at de to SISTE INSERT-setningene også gir en verdi for Kolonnen ImportantFlag. Når du spør Etter Innlegg-tabellen, skal resultatene nå inkludere alle fem radene.

det neste trinnet er å opprette og fylle Likes-tabellen, ved hjelp av følgende T-SQL-kode:

1
2
3
4
5
6
7
8
9
10
11
12

DROP TABELL HVIS Finnes Liker;
LAG TABELL Liker SOM KANT;
SETT Inn Liker ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 3),
(VELG $node_id Fra Fiskearter DER FishID = 8));
SETT Inn Likes ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 5),
(VELG $node_id FRA FishPost HVOR PostID = 4));
SETT Inn Likes ($from_id, $to_id) VERDIER (
(VELG $node_id Fra FishLover HVOR FishLoverID = 1),
(VELG $node_id FRA FishLover HVOR FishLoverID = 4));

Du kan selvfølgelig definere eventuelle forhold du vil ha. Det viktige poenget å legge merke til her er at du ikke er begrenset til et sett med noder. Den første INSERT-setningen oppretter For eksempel en relasjon Mellom FishLover Og FishSpecies, den andre setningen oppretter en relasjon Mellom FishLover Og FishPost, og den tredje setningen oppretter en relasjon Mellom FishLover og FishLover. Dette gir oss spørringsresultatene som vises i figuren nedenfor.

Du kan ta samme tilnærming når du oppretter Og fyller Linkto-tabellen:

1
2
3
4
5
6
7
8
9
10
11
12

SLIPP TABELL HVIS Det Finnes LinksTo;
OPPRETT TABELL LinksTo SOM KANT;
SETT Inn I LinksTo ($from_id, $to_id) VERDIER (
(VELG $node_id FRA FishPost HVOR Posttid = 2),
(VELG $node_id Fra Fiskearter DER FishID = 6));
SETT Inn Linkso ($from_id, $to_id) VERDIER (
(VELG $node_id FRA FishPost HVOR PostID = 4),
(VELG $node_id FRA FishLover HVOR FishLoverID = 1));
SETT Inn Linkso ($from_id, $to_id) VERDIER (
(VELG $node_id FRA FishPost HVOR PostID = 3),
(VELG $node_id FRA FishPost HVOR PostID = 5));

følgende figur viser hvordan dataene skal se ut etter å ha blitt lagt til i tabellen, forutsatt at du fulgte eksemplet.

med en grafdatabase kan du legge til et bredt spekter av relasjoner mellom opprinnelses-og avsluttende noder. Du kan også enkelt innlemme endringer i grafmodellen. Du kan for eksempel bestemme deg for å legge Til en fishrecipes node-tabell for lagring av fiskeoppskrifter som brukere legger inn i forumet, i så fall kan du utnytte eksisterende Innlegg, Liker og Linkssto edge-tabeller.

Fremover Med Graph-Databaser

Fordi Microsoft inkluderer graph-databasefunksjonene som en del AV SQL Server-databasemotoren, kan Du enkelt prøve dem uten å måtte installere eller omkonfigurere noen komponenter. Best av alt, du kan bruke de samme verktøyene og prosedyrene du har brukt hele tiden for å opprette og fylle ut node-og kanttabeller. I artiklene som skal følges, dekker vi hvordan du spør og endrer grafdata og ser nærmere på å jobbe med hierarkiske data, så vær sikker på å holde deg oppdatert.

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.