Peremhálózati korlátozások

A következőkre vonatkozik: Az SQL Server 2019 (15.x) és újabb verziói az Azure SQL DatabaseAzure SQL Managed InstanceSQL Database-adatbázist a Microsoft Fabricben

A peremhálózati korlátozások az SQL Server gráfadatbázis peremtábláinak adatintegritásának és adott szemantikájának kényszerítésére használhatók.

Peremhálózati (Edge) korlátozások

Alapértelmezés szerint az éltáblák nem kényszerítenek semmit az él végpontjaira. Ez azt is jelentheti, hogy a gráfadatbázis élei bármilyen csomópontot csatlakoztathatnak bármely más csomóponthoz, a típustól függetlenül.

Az SQL Graph támogatja az él korlátozásokat, amelyek lehetővé teszik a felhasználók számára, hogy kényszereket adjanak az éltáblákhoz, ezáltal bizonyos szemantikát érvényesítve és fenntartva az adatintegritást is. Amikor új élt adnak hozzá egy éltáblához élek korlátozásaival, az adatbázismotor biztosítja, hogy az él által összekötni próbált csomópontok a megfelelő csomóponttáblákban létezzenek. Azt is biztosítja, hogy a csomópontot ne lehessen elvetni, ha valamelyik él erre a csomópontra hivatkozik.

Perem korlátozási záradékok

Egy élkényszer egy vagy több élkényszer-záradékból áll.

CONSTRAINT constraint_name CONNECTION (cause1[, clause2...])

• Az élkorlátozási záradék csomóponttáblák neveinek párja, amelyeket a TO kulcsszó választ el egymástól.
• Az él kényszerzáradékban szereplő első táblanév azt a táblát jelöli, amelyről az él kapcsolat indul, tehát a FROM csomópont táblájának nevét.
• A peremhálózati kényszer záradék második táblaneve az élkapcsolat TO csomóponttáblájának neve.
• A táblanevek párja ezért az élkapcsolat irányát jelzi.
• Amint már korábban megjegyeztük, az élkényszer egy vagy több élkényszeres záradékot tartalmazhat.

Több kényszer és záradék

• Az ugyanazon éltáblához definiált több élkorlátozást egy AND operátorral kényszeríti ki a rendszer.
• Több élkényszer záradékot, amelyeket ugyanazon élkényszerben definiáltak, egy OR operátorral érvényesítünk.

Vegye figyelembe a gráf Supplier és Customer csomópontjait. Mindegyik a Product csomóponthoz kapcsolódhat egyetlen, megosztott éltáblával: bought. A bought éltábla támogatja Customer-(bought)->Product és Supplier-(bought)->Product kapcsolattípusokat. Az elvégzés egyetlen élkényszer használatával és több élkényszer-záradékkal lehetséges.

Examples

CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product)

A fenti példa egy élkorlátozást mutat be, egy élkorlátozási záradékkal. Ez a korlátozás támogatja a Customer-(bought)->Product. Ez lehetővé teszi a bought élkapcsolat beszúrását, amely Customer-ből Product-be megy. Ha megpróbál bármilyen más csomópont-kombinációt beszúrni, például Supplier-(bought)->Product, annak ellenére, hogy a valós világban érvényes kapcsolatot ír le, sikertelen lenne.

CONSTRAINT EC_BOUGHT CONNECTION (Supplier TO Product, Customer TO Product)

A fenti példa egy élkényszert határoz meg két élkényszer-záradékkal. Ezek a kényszerfeltételek lehetővé teszik, hogy a bought él Supplier-(bought)->Product vagy Customer-(bought)->Product kapcsolatokat tartalmazzon. Ha bármilyen más típusú élkapcsolatot szúr be a bought táblába, az nem sikerül.

CONSTRAINT EC_BOUGHT1 CONNECTION (Supplier TO Product)
CONSTRAINT EC_BOUGHT2 CONNECTION (Customer TO Product)

A fenti példa két kényszert mutat be ugyanazon az éltáblán, és mindegyik élkényszer egy kényszer záradékot ad meg. Ebben az esetben az SQL csak olyan beszúrásokat engedélyezne, amelyek egyszerre teljesítik a MINDKÉT peremhálózati korlátozási záradékot. Ez nem lehetséges. Nincs olyan csomópontpár, amely megfelelhet mindkét peremfeltétel-záradéknak. Ez az élkényszer-kombináció használhatatlanná teszi az éltáblát.

Annak részletes magyarázatáért, hogy hol használható több élkényszer egy valós forgatókönyvben, tekintse meg a lap későbbi, "Új élkorlátozás létrehozása meglévő éltáblán új élkényszer-záradékkal" című példáját.

Indexek az élkorlátozások esetén

A peremkorlátozás létrehozása nem hoz létre automatikusan megfelelően hozzárendelt indexet az $from_id és $to_id oszlopokon az éltáblában. Egy index manuális létrehozása egy $from_id, $to_id párra ajánlott, ha pontkeresési lekérdezései vannak, vagy OLTP munkaterhelés esetén.

ON DELETE hivatkozási műveletek peremhálózati korlátozások esetén

A peremhálózati korlátozások kaszkádolt műveletei lehetővé teszik a felhasználók számára, hogy meghatározzák az adatbázismotor által végrehajtott műveleteket, amikor egy felhasználó törli az adott peremhálózathoz csatlakozó csomópont(ok)t. A következő hivatkozási műveletek határozhatók meg: NINCS MŰVELET Az adatbázismotor hibát jelez, amikor olyan csomópontot próbál törölni, amely a csatlakozó él(ek)et használja.

CASCADE Amikor egy csomópontot töröl az adatbázisból, a csatlakozó élek törlődnek.

Az élkorlátokkal való munka

A Transact-SQL használatával peremhálózati kényszert definiálhat az SQL Serverben. Élkényszer csak gráf éltábla alapján határozható meg. Élkényszer létrehozásához, törléséhez vagy módosításához ALTER engedéllyel kell rendelkeznie a táblában.

Peremhálózati korlátozások létrehozása

Az alábbi példák bemutatják, hogyan hozhat létre peremkorlátot új vagy meglévő táblákon.

Élkorlát létrehozása új éltáblán

Az alábbi példa egy élkorlátot hoz létre a bought éltáblán.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      ,CustomerName VARCHAR(100)
   )
AS NODE;
GO
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      ,ProductName VARCHAR(100)
   )
AS NODE;
GO
CREATE TABLE bought
   (
      PurchaseCount INT
         ,CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product) ON DELETE NO ACTION
   )
   AS EDGE;

Hivatkozási műveletek definiálása új éltáblán

Az alábbi példa egy élkorlátot hoz létre a bought éltáblán, és meghatározza a ON DELETE CASCADE hivatkozási műveletet.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      ,CustomerName VARCHAR(100)
   )
AS NODE;
GO
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      ,ProductName VARCHAR(100)
   )
AS NODE;
GO
CREATE TABLE bought
   (
      PurchaseCount INT
         ,CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product) ON DELETE CASCADE
   )
   AS EDGE;

Élkorlát hozzáadása meglévő éltáblához

Az alábbi példa az ALTER TABLE használatával vesz fel élkorlátot a bought éltáblához.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      , CustomerName VARCHAR(100)
   )
   AS NODE;
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      , ProductName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE bought
   (
      PurchaseCount INT
   )
   AS EDGE;
GO
ALTER TABLE bought ADD CONSTRAINT EC_BOUGHT1 CONNECTION (Customer TO Product);

Új peremfeltétel létrehozása a meglévő éltáblán, további peremfeltétel-záradékokkal

Az alábbi példa a ALTER TABLE paranccsal ad hozzá egy új élkényszert a bought éltábla további élkényszer-záradékaival.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      , CustomerName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE Supplier
   (
      ID INTEGER PRIMARY KEY
      , SupplierName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      , ProductName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE bought
   (
      PurchaseCount INT
      , CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product)
   )
   AS EDGE;
-- Drop the existing edge constraint first and then create a new one.
ALTER TABLE bought DROP CONSTRAINT EC_BOUGHT;
GO
-- User ALTER TABLE to create a new edge constraint.
ALTER TABLE bought ADD CONSTRAINT EC_BOUGHT1 CONNECTION (Customer TO Product, Supplier TO Product);

Az előző példában két peremkorlát-záradék található a EC_BOUGHT1 kényszerben: az egyik összeköti a Customer-et a Product-vel, a másik pedig a Supplier-at a Product-gyel. Mindkét záradékot diszjunkcióban alkalmazzák. Vagyis egy adott élnek meg kell felelnie a két feltétel egyikének ahhoz, hogy engedélyezhető legyen az éltáblában.

Új élkényszer létrehozása meglévő éltáblán új élkényszer feltétellel

Az alábbi példa a ALTER TABLE paranccsal ad hozzá egy új élkényszert egy új élkényszer-záradékkal a bought éltáblán.

-- CREATE node and edge tables
CREATE TABLE Customer
  (
     ID INTEGER PRIMARY KEY
     , CustomerName VARCHAR(100)
  )
  AS NODE;
GO
CREATE TABLE Supplier
  (
     ID INTEGER PRIMARY KEY
     , SupplierName VARCHAR(100)
  )
  AS NODE;
GO
CREATE TABLE Product
  (
     ID INTEGER PRIMARY KEY
     , ProductName VARCHAR(100)
  )
  AS NODE;
GO
CREATE TABLE bought
  (
     PurchaseCount INT,
        CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product)
  )
  AS EDGE;
GO

A következő példában képzelje el, hogy most már a Supplier éltáblán keresztül szükséges hozzáadni a Product-bought kapcsolatot is. Megpróbálhat új élkorlátot hozzáadni:

ALTER TABLE bought ADD CONSTRAINT EC_BOUGHT1 CONNECTION (Supplier TO Product);

Az új peremhálózati korlátozás hozzáadása azonban nem a megfelelő megoldás. Két külön élkorlátozást hoztunk létre a bought éltáblán, EC_BOUGHT és EC_BOUGHT1. Mindkét élkényszer eltérő kényszerzáradékokkal rendelkezik. Ha egy éltáblán egynél több élkorlátozás van, akkor egy adott élnek meg kell felelnie MINDEN élkorlátozásnak, hogy szerepelhessen az éltáblában. Mivel itt egyetlen él sem teljesítheti mindkettőt: EC_BOUGHT és EC_BOUGHT1, a fenti ALTER TABLE utasítás kudarcot vall, ha a bought éltáblában egyáltalán vannak sorok.

A peremhálózati korlátozás sikeres létrehozásához az előírt módszer egy sorozat követése, ahogyan az ebben a példában látható:

-- First, add the desired ("super-set") constraint:
ALTER TABLE bought ADD CONSTRAINT EC_BOUGHT_NEW CONNECTION (Customer TO Product, Supplier TO Product);
GO

-- Then, drop the older edge constraint:
ALTER TABLE bought DROP CONSTRAINT EC_BOUGHT;
GO

-- If needed, you can rename the new edge constraint to match the original name:
EXECUTE sp_rename '[dbo].[EC_BOUGHT_NEW]', '[dbo].[EC_BOUGHT]';

Az a tény, hogy az új "super-set" kényszert először hozzáadtuk anélkül, hogy elvetnénk a korábbit, lehetővé teszi, hogy a művelet csak metaadat-művelet legyen – nem kell ellenőriznie a bought táblában lévő összes meglévő adatot, mivel az magában foglalja a meglévő kényszert.

Ezzel ahhoz, hogy egy adott él engedélyezve legyen a bought élen, meg kell felelnie az EC_BOUGHT_NEW kényszer valamelyik élkényszer-záradékának. Ezért bármely él, amely érvényes Customer csomópontot próbál csatlakoztatni Product-hez, vagy Supplier csomópontot Product-hoz, engedélyezett.

Élkorlátozások törlése

Az alábbi példa először azonosítja a peremhálózati kényszer nevét, majd törli a kényszert.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      , CustomerName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      , ProductName VARCHAR(100)
   ) AS NODE;
GO
CREATE TABLE bought
   (
      PurchaseCount INT
      , CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product)
    )
    AS EDGE;
GO

-- Return the name of edge constraint.
SELECT name
   FROM sys.edge_constraints
   WHERE type = 'EC' AND parent_object_id = OBJECT_ID('bought');
GO

-- Delete the primary key constraint.
ALTER TABLE bought
DROP CONSTRAINT EC_BOUGHT;

Élkorlátozások módosítása

Ha a Transact-SQL használatával szeretne módosítani egy élkényszert, először törölnie kell a meglévő élkényszert, majd újra létre kell hoznia az új definícióval.

Élkorlátozások megtekintése

A katalógusnézetekben a metaadatok láthatósága olyan biztonságos adatokra korlátozódik, amelyek egy felhasználó tulajdonában vannak, vagy amelyeken a felhasználó engedélyt kapott. További információ: Metaadatok láthatóságának konfigurációja.

A példa a bought adatbázisban tempdb éltáblához tartozó összes élkorlátozást és azok tulajdonságait adja vissza.

-- CREATE node and edge tables
CREATE TABLE Customer
   (
      ID INTEGER PRIMARY KEY
      , CustomerName VARCHAR(100)
   )
   AS NODE;
GO
CREATE TABLE Supplier
   (
      ID INTEGER PRIMARY KEY
      , SupplierName VARCHAR(100)
   )
   AS NODE;
   GO
CREATE TABLE Product
   (
      ID INTEGER PRIMARY KEY
      , ProductName VARCHAR(100)
   )
   AS NODE;

-- CREATE edge table with edge constraints.
CREATE TABLE bought
   (
      PurchaseCount INT
      , CONSTRAINT EC_BOUGHT CONNECTION (Customer TO Product, Supplier TO Product)
   )
   AS EDGE;

-- Query sys.edge_constraints and sys.edge_constraint_clauses to view
-- edge constraint properties.
SELECT
   EC.name AS edge_constraint_name
   , OBJECT_NAME(EC.parent_object_id) AS edge_table_name
   , OBJECT_NAME(ECC.from_object_id) AS from_node_table_name
   , OBJECT_NAME(ECC.to_object_id) AS to_node_table_name
   , is_disabled
   , is_not_trusted
FROM sys.edge_constraints EC
   INNER JOIN sys.edge_constraint_clauses ECC
   ON EC.object_id = ECC.object_id
WHERE EC.parent_object_id = object_id('bought');

Következő lépések

• SQL Graph-architektúra
• SQL gráf adatbázis példa
• TÁBLA LÉTREHOZÁSA (SQL Graph)
• ALTER TABLE táblázat_korlátozás