Einführung in Graphdatenbanken SQL Server 2017

Im Vorfeld des Kursstarts «MS SQL Server-Entwickler» Wir haben für Sie eine weitere nützliche Übersetzung vorbereitet.

Graphdatenbanken sind eine wichtige Technologie für Datenbankspezialisten. Ich versuche, über Innovationen und neue Technologien in diesem Bereich auf dem Laufenden zu bleiben und sehe nach der Arbeit mit relationalen und NoSQL-Datenbanken, dass die Rolle der Graphdatenbanken immer größer wird. Bei der Arbeit mit komplexen hierarchischen Daten sind nicht nur traditionelle Datenbanken, sondern auch NoSQL-Datenbanken oft ineffizient. Häufig führt eine Zunahme der Anzahl der Beziehungsebenen und der Datenbankgröße zu einem Rückgang der Leistung. Und mit der Komplexität der Verknüpfungen nimmt auch die Anzahl der JOINs zu.

Natürlich gibt es in dem relationalen Modell Lösungen für die Arbeit mit Hierarchien (zum Beispiel durch rekursive CTEs), aber das bleibt dennoch ein Umweg. Gleichzeitig ermöglicht die Funktionalität der Graphdatenbanken in SQL Server die einfache Handhabung mehrerer Hierarchieebenen. Sowohl das Datenmodell als auch die Abfragen werden vereinfacht, was deren Effizienz erhöht. Der Codeumfang wird erheblich reduziert.

Graphdatenbanken sind eine ausdrucksstarke Sprache zur Darstellung komplexer Systeme. Diese Technologie wird bereits in der IT-Branche in Bereichen wie sozialen Netzwerken, Betrugsbekämpfungssystemen, IT-Netzwerkanalysen, sozialen Empfehlungen sowie Produkt- und Inhaltsvorschlägen weit verbreitet eingesetzt.

Die Funktionalität der Graphdatenbanken in SQL Server ist für Szenarien geeignet, in denen die Daten stark miteinander verbunden sind und klar definierte Beziehungen aufweisen.

Graphdatenmodell

Ein Graph besteht aus einer Menge von Knoten (vertices, node) und Kanten (edges, Beziehungen). Die Knoten repräsentieren Entitäten, während die Kanten die Beziehungen darstellen, in deren Attributen Informationen enthalten sein können.

Eine Graphdatenbank modelliert Entitäten in Form eines Graphen, wie er in der Graphentheorie definiert ist. Die Datenstrukturen sind Knoten und Kanten. Attribute sind die Eigenschaften der Knoten und Kanten. Eine Verbindung ist eine Verknüpfung von Knoten.

Im Gegensatz zu anderen Datenmodellen liegt der Schwerpunkt in Graphdatenbanken auf den Beziehungen zwischen Entitäten. Daher ist es nicht notwendig, Verbindungen über Fremdschlüssel oder andere Methoden zu berechnen. Komplexe Datenmodelle können erstellt werden, indem man nur Abstraktionen von Knoten und Kanten verwendet.

In der modernen Welt erfordert die Modellierung von Beziehungen immer komplexere Methoden. Für die Modellierung von Beziehungen bietet SQL Server 2017 die Möglichkeiten von Graphdatenbanken. Knoten und Kanten des Graphen werden als neue Tabellentypen dargestellt: NODE und EDGE. Für Anfragen an den Graphen wird die neue T-SQL-Funktion namens MATCH() verwendet. Da diese Funktionalität in SQL Server 2017 integriert ist, kann sie in Ihren vorhandenen Datenbanken ohne Notwendigkeit irgendeiner Konvertierung verwendet werden.

Der Nutzen des Graphmodells

Heute verlangen Unternehmen und Benutzer Anwendungen, die mit immer größeren Datenmengen arbeiten, und erwarten dabei hohe Leistung und Zuverlässigkeit. Die Darstellung von Daten als Graph bietet bequeme Mittel zur Verarbeitung komplexer Beziehungen. Dieser Ansatz ermöglicht es, viele Probleme zu lösen und Ergebnisse im Rahmen des vorgegebenen Kontexts zu erzielen.

Offenbar werden viele Anwendungen in der Zukunft von der Nutzung von Graphdatenbanken profitieren.

Datenmodellierung: vom relationalen Modell zum Graphmodell

Beispiel

Betrachten wir ein Beispiel für eine Organisationsstruktur mit einer Hierarchie von Mitarbeitern: Ein Mitarbeiter untersteht einem Manager, der Manager einem Senior Manager und so weiter. Je nach spezifischem Unternehmen kann es in dieser Hierarchie eine beliebige Anzahl von Ebenen geben. Aber mit zunehmender Anzahl von Ebenen wird die Berechnung der Beziehungen in einer relationalen Datenbank immer komplizierter. Es ist ziemlich schwierig, die Hierarchie von Mitarbeitern, die Hierarchie im Marketing oder Beziehungen in sozialen Netzwerken darzustellen. Schauen wir uns an, wie SQL Graph das Problem der Verarbeitung verschiedener Hierarchieebenen lösen kann.

Für dieses Beispiel erstellen wir ein einfaches Datenmodell. Wir erstellen eine Tabelle für Mitarbeiter. EMP mit der Identifikationsnummer EMPNO und einer Spalte, die auf die Identifikation des Vorgesetzten (Managers) des Mitarbeiters verweist. Alle Informationen zur Hierarchie werden in dieser Tabelle gespeichert und können über die Spalten abgefragt werden. MGRIn dem nächsten Diagramm wird dasselbe Modell der Organisationsstruktur mit vier Ebenen der Verschachtelung in einer vertrauteren Form dargestellt. Die Mitarbeiter sind die Knoten des Graphen aus der Tabelle EMPNO und MGR.

. Die Entität „Mitarbeiter“ ist durch die Beziehung „untersteht“ (ReportsTo) mit sich selbst verbunden. In den Begriffen eines Graphen ist die Beziehung eine Kante (EDGE), die die Knoten (NODE) der Mitarbeiter verbindet. EMP. Die Entität „Mitarbeiter“ hat eine Beziehung „berichtet an“ (ReportsTo) zu sich selbst. In graphentheoretischen Begriffen ist die Beziehung eine Kante (EDGE), die Knoten (NODE) von Mitarbeitern verbindet.

Lassen Sie uns eine normale Tabelle erstellen EMP und Werte gemäß dem obigen Diagramm hinzufügen.

CREATE TABLE EMP
(EMPNO INT NOT NULL,
ENAME VARCHAR(20),
JOB VARCHAR(10),
MGR INT,
JOINDATE DATETIME,
SALARY DECIMAL(7, 2),
COMMISIION DECIMAL(7, 2),
DNO INT)
 
INSERT INTO EMP VALUES
(7369, 'SMITH', 'CLERK', 7902, '02-MAR-1970', 8000, NULL, 2),
(7499, 'ALLEN', 'SALESMAN', 7698, '20-MAR-1971', 1600, 3000, 3),
(7521, 'WARD', 'SALESMAN', 7698, '07-FEB-1983', 1250, 5000, 3),
(7566, 'JONES', 'MANAGER', 7839, '02-JUN-1961', 2975, 50000, 2),
(7654, 'MARTIN', 'SALESMAN', 7698, '28-FEB-1971', 1250, 14000, 3),
(7698, 'BLAKE', 'MANAGER', 7839, '01-JAN-1988', 2850, 12000, 3),
(7782, 'CLARK', 'MANAGER', 7839, '09-APR-1971', 2450, 13000, 1),
(7788, 'SCOTT', 'ANALYST', 7566, '09-DEC-1982', 3000, 1200, 2),
(7839, 'KING', 'PRESIDENT', NULL, '17-JUL-1971', 5000, 1456, 1),
(7844, 'TURNER', 'SALESMAN', 7698, '08-AUG-1971', 1500, 0, 3),
(7876, 'ADAMS', 'CLERK', 7788, '12-MAR-1973', 1100, 0, 2),
(7900, 'JAMES', 'CLERK', 7698, '03-NOV-1971', 950, 0, 3),
(7902, 'FORD', 'ANALYST', 7566, '04-MAR-1961', 3000, 0, 2),
(7934, 'MILLER', 'CLERK', 7782, '21-JAN-1972', 1300, 0, 1)

Die untenstehende Abbildung zeigt die Mitarbeiter:

• der Mitarbeiter mit EMPNO 7369 unterstellt sich 7902;
• der Mitarbeiter mit EMPNO 7902 unterstellt sich 7566
• der Mitarbeiter mit EMPNO 7566 unterstellt sich 7839

Schauen wir uns jetzt die Darstellung derselben Daten als Graph an. Der Knoten EMPLOYEE hat mehrere Attribute und ist über die Beziehung «unterstellt» (EmplReportsTo) mit sich selbst verbunden. EmplReportsTo ist der Name der Beziehung.

In der Kante (EDGE) Tabelle können ebenfalls Attribute vorhanden sein.

Wir erstellen die Knotentabelle EmpNode

Die Syntax zur Erstellung eines Knotens ist recht einfach: Zum Ausdruck CREATE TABLE wird am Ende hinzugefügt „AS NODE“.

CREATE TABLE dbo.EmpNode(
ID Int Identity(1,1),
EMPNO NUMERIC(4) NOT NULL,
ENAME VARCHAR(10),
MGR NUMERIC(4),
DNO INT
) AS NODE;

Jetzt wandeln wir die Daten aus der normalen Tabelle in einen Graphen um. Der folgende INSERT fügt Daten aus der relationalen Tabelle ein EMP.

INSERT INTO EmpNode(EMPNO,ENAME,MGR,DNO) select empno,ename,MGR,dno from emp

In der Knotentabelle wird in einer speziellen Spalte $node_id_* der Knoten-Identifikator im JSON-Format gespeichert. In den anderen Spalten dieser Tabelle befinden sich die Attribute des Knotens.

Wir erstellen Kanten (EDGE)

Die Erstellung der Kante-Tabelle ähnelt sehr der Erstellung der Knotentabelle, mit dem Unterschied, dass das Schlüsselwort „AS EDGE“.

CREATE TABLE empReportsTo(Deptno int) AS EDGE

Jetzt definieren wir die Beziehungen zwischen den Mitarbeitern anhand der Spalten EMPNO und MGR. Anhand des Organigramms ist klar zu sehen, wie man es schreibt INSERT.

FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 1),
   	(SELECT $node_id FROM EmpNode WHERE id = 13),20);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 2),
   	(SELECT $node_id FROM EmpNode WHERE id = 6),10);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 3),
   	(SELECT $node_id FROM EmpNode WHERE id = 6),10)
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 4),
   	(SELECT $node_id FROM EmpNode WHERE id = 9),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 5),
   	(SELECT $node_id FROM EmpNode WHERE id = 6),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 6),
   	(SELECT $node_id FROM EmpNode WHERE id = 9),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 7),
   	(SELECT $node_id FROM EmpNode WHERE id = 9),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 8),
   	(SELECT $node_id FROM EmpNode WHERE id = 4),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 9),
   	(SELECT $node_id FROM EmpNode WHERE id = 9),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 10),
   	(SELECT $node_id FROM EmpNode WHERE id = 6),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 11),
   	(SELECT $node_id FROM EmpNode WHERE id = 8),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 12),
   	(SELECT $node_id FROM EmpNode WHERE id = 6),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 13),
   	(SELECT $node_id FROM EmpNode WHERE id = 4),30);
FÜGE IN empReportsTo WERTE EIN ((SELECT $node_id FROM EmpNode WHERE ID = 14),
   	(SELECT $node_id FROM EmpNode WHERE id = 7),30);

Die Standard-Eckentabelle besteht aus drei Spalten. Die erste, $edge_id — die Identifikation der Kante im JSON-Format. Die beiden anderen ($from_id und $to_id) stellen die Beziehung zwischen Knoten dar. Darüber hinaus können Kanten zusätzliche Eigenschaften haben. In unserem Fall handelt es sich um Deptno.

Systemansichten

In der Systemansicht sys.tables sind zwei neue Spalten hinzugekommen:

1. is_edge
2. is_node

SELECT t.is_edge,t.is_node,*
FROM sys.tables t
WHERE name like 'emp%'

SSMS

Objekte, die mit Graphen verbunden sind, befinden sich im Ordner Graph Tables. Das Symbol der Knotentabelle ist mit einem Punkt gekennzeichnet, während die Kanten Tabellen mit zwei verbundenen Kreisen (ähnlich wie Brillen) gekennzeichnet sind.

Der Ausdruck MATCH

Ausdruck MATCH stammt aus CQL (Cypher Query Language). Dies ist ein effizienter Weg, um Abfragen an die Eigenschaften des Graphen zu stellen. CQL beginnt mit dem Ausdruck MATCH.

Syntax

MATCH ()
 
::=
    { {
                 	{ <-()- }
               	| { -()-> }
             	
             	}
 	}
 	[ { AND } { () } ]
 	[ ,...n ]
 
 ::=
    node_table_name | node_alias
 
 ::=
    edge_table_name | edge_alias

Beispiele

Schauen wir uns einige Beispiele an.

Die folgende Abfrage zeigt die Mitarbeiter, die Smith unterstellt sind, sowie seinen Manager.

SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR
FROM
    empnode e, empnode e1, empReportsTo m
WHERE
    MATCH(e-(m)->e1)
and e.ENAME='SMITH'

Die folgende Anfrage dient der Suche nach Mitarbeitern und Managern der zweiten Ebene für Smith. Wenn Sie den Satz weglassen, WHERE, werden alle Mitarbeiter angezeigt.

SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR
FROM
    empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2
WHERE
    MATCH(e-(m)->e1-(m1)->e2)
and e.ENAME='SMITH'

Und schließlich die Anfrage für Mitarbeiter und Manager der dritten Ebene.

SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR,E3.EMPNO,e3.ENAME,E3.MGR
FROM
    empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2, empReportsTo M2, empnode e3
WHERE
    MATCH(e-(m)->e1-(m1)->e2-(m2)->e3)
and e.ENAME='SMITH'

Jetzt lassen Sie uns die Richtung ändern, um die Vorgesetzten von Smith zu erhalten.

SELECT
E.EMPNO,E.ENAME,E.MGR,E1.EMPNO,E1.ENAME,E1.MGR,E2.EMPNO,e2.ENAME,E2.MGR,E3.EMPNO,e3.ENAME,E3.MGR
FROM
    empnode e, empnode e1, empReportsTo m ,empReportsTo m1, empnode e2, empReportsTo M2, empnode e3
WHERE
    MATCH(e<-(m)-e1<-(m1)-e2<-(m2)-e3)

Fazit

SQL Server 2017 hat sich als umfassende Unternehmenslösung für verschiedene IT-Aufgaben im Geschäftsbereich etabliert. Die erste Version von SQL Graph ist vielversprechend. Trotz einiger Einschränkungen gibt es bereits genügend Funktionalität, um die Möglichkeiten von Graphen zu erkunden.

Die Funktionalität von SQL Graph ist vollständig in die SQL Engine integriert. Es gibt jedoch, wie bereits erwähnt, folgende Einschränkungen im SQL Server 2017:

Keine Unterstützung für Polymorphie.

• Es werden nur unidirektionale Beziehungen unterstützt.
• Die Spalten $from_id und $to_id von Kanten können nicht über UPDATE aktualisiert werden.
• Transitive Abschlüsse werden nicht unterstützt, können jedoch mit CTE erreicht werden.
• Der Support für In-Memory OLTP-Objekte ist eingeschränkt.
• Temporale Tabellen (System-Versionierte Temporale Tabellen), temporäre lokale und globale Tabellen werden nicht unterstützt.
• Tabellentypen und Tabellenvariablen können nicht als NODE oder EDGE deklariert werden.
• Cross-Datenbankabfragen werden nicht unterstützt.
• Es gibt keinen direkten Weg oder einen Wizard, um normale Tabellen in Graphen zu konvertieren.
• Für die Darstellung von Graphen gibt es kein GUI, aber Sie können Power BI verwenden.

Weiterlesen:

• Wie SQL Server Bitmap-Filter verwendet

Quelle: habr.com