5 SQL-korlátozás a jó adatbázis-struktúra garantálásához

Kulcs elvitelek

• Használjon SQL megszorításokat az adatok integritásának megőrzéséhez és az adatbázis egységességének biztosításához. A NOT NULL kényszer arra kényszeríti az oszlopokat, hogy utasítsák el a NULL értékeket.
• Valósítsa meg az elsődleges kulcs megszorításait, hogy biztosítsa az értékek egyediségét egy oszlopban vagy oszlopkészletben. Ez megakadályozza a rekordok ismétlődését egy adatbázistáblában.
• Az idegen kulcs megszorításai kapcsolatokat hoznak létre a táblák között, és megakadályozzák azokat a műveleteket, amelyek tönkretennék a köztük lévő kapcsolatokat. Biztosítják, hogy az utódtáblában lévő rekord hivatkozzon a szülőtáblára.

Az adatbázis sok alkalmazás számára nélkülözhetetlen, de ha nem rendelkezik az adatok tárolására és feldolgozására vonatkozó irányelvekkel, akkor ez összezavarhat.

Az SQL megszorítások szabályokat adnak meg az adatok táblázatban való tárolására. Ha megszorításokat állít be, az adatbázis hibát jelez, ha olyan adatokat próbál meg tárolni, amelyek sértik ezeket a szabályokat. A megszorítások segítenek megőrizni az adatok integritását és biztosítják az adatbázis egységességét.

Számos típusú SQL-megszorítást használhat; íme néhány a leghasznosabbak közül.

1. NOT NULL Megkötés

Az adatbázis oszlopai alapértelmezés szerint NULL értékű adatokat fogadnak el. A NULL lényegében azt jelenti, hogy nem létezik érték. A NOT NULL megszorítás arra kényszeríti az oszlopot, hogy utasítsa el a NULL értékeket.

Ez a megkötés biztosítja, hogy minden oszlopnak tartalmaznia kell egy értéket. Nem adhat hozzá rekordot az adatbázishoz anélkül, hogy a NOT NULL megkötéssel rendelkező oszlopok adatait megadná.

Vegyük a példát a Ügyfelek asztal. Minden egyes ügyfélről van néhány szükséges adat, amelyet rögzíteni szeretne, például a nevét. Adja hozzá a NOT NULL megszorítást a kötelező mezőkhöz, hogy biztosítsa, hogy az ügyfelek megadják ezeket az információkat.

Íme egy példa, amely bemutatja, hogyan használhatja a NOT NULL kényszert a PostgreSQL adatbázis:

CREATETABLE Customers (
 ID int NOT NULL,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255) NOT NULL,
 Mobile_No int NOT NULL,
 Age int
);

Ha megpróbál beszúrni egy ügyfélrekordot anélkül, hogy a Kor mezőben, az adatbázis hiba nélkül elfogadja:

INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (123456, 'Dior', 'Christian', 0723000000);

Ha azonban megpróbál beszúrni egy rekordot a Keresztnév mezőben az adatbázis egy hibaüzenettel elutasítja:

ERROR: null value in column "firstname" violates not-null constraint
Detail: Failing row contains (123456, Dior, null, 723000000, null).

2. PRIMER KULCS kényszer

A KEY egy oszlophoz vagy mezőhöz beállított egyedi attribútum, amely azonosítja a tábla sorát (vagy rekordját) az adatbázisrendszerekben. Az ELSŐDLEGES KULCS kényszer biztosítja az értékek egyediségét egy oszlopban vagy oszlopkészletben. Egyedi azonosítóként működik egy sorban, megakadályozva a rekordok ismétlődését egy adatbázistáblában.

Az elsődleges kulcsok egyedi értékeket tartalmaznak, és nem tartalmazhatnak NULL értéket. Minden egyes SQL adatbázis tábla csak egy elsődleges kulccsal kell rendelkeznie. Az ELSŐDLEGES KULCS egy vagy több oszlopból állhat.

Például létrehoz egy adatbázist az ügyfélrekordokból. Minden ügyfélnek máshogy kell megadnia azonosítószámát, mint a többieknek. Alkalmazhatja az elsődleges kulcs megkötését, hogy biztosítsa, hogy egyik ügyfelének se legyen ugyanaz az azonosító száma.

A következő kód bemutatja, hogyan vezethet be elsődleges kulcs megszorítást egy MySQL adatbázisban:

CREATETABLE Customers (
 ID int NOT NULL,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Age int,
 PRIMARY KEY (ID)
);

Az adatbázis nem fogadja el ezt az értéket, ha egy felhasználó másik rekordot ír be hasonló azonosítóval. Ehelyett hibaüzenetet küld, jelezve a duplikációt. A felhasználó megpróbál beszúrni két rekordot azonos azonosítóval a következő példában:

INSERTINTO Customers (ID, LastName, FirstName, Age)
VALUES (1, 'John', 'Doe', 35 ); 
INSERTINTO Customers (ID, LastName, FirstName, Age)
VALUES (1, 'Mary', 'Jane', 35 );

Az adatbázis hibaüzenetet jelenít meg:

Duplicate entry '1' for key 'PRIMARY'

De ha megváltoztatja a második ügyfél azonosítóját, az adatbázis elfogadja a bejegyzést. Ezért az elsődleges kulcs biztosítja, hogy ne legyenek ismétlődő azonosítók az ügyfélrekordokban.

3. IDEGEN KULCS Kényszer

Idegen kulcsok kapcsolatokat hozzon létre két tábla között. Hozzáadhat egy idegen kulcsot egy olyan mezőhöz/oszlophoz, amely egy másik tábla elsődleges kulcsára hivatkozik.

Az elsődleges kulccsal rendelkező tábla a szülőtábla, míg az idegen kulccsal rendelkező tábla a gyermektábla. Ekkor egy rekord nem létezhet az utódtáblában a szülőtáblára való hivatkozás nélkül.

Az idegen kulcs megszorítása megakadályozza a táblák közötti kapcsolatok tönkretételét okozó műveleteket. Például nem teheted CSEPP egy táblát, ha az idegen kulccsal kapcsolódik egy másikhoz. Egyszerre le kell dobnia mindkét asztalt.

Az elsődleges kulccsal ellentétben megkettőzhet egy idegen kulcsot, és egynél több is lehet egyetlen táblában. Az idegen kulcs értékek is lehetnek NULLA. A következő példában a Ügyfél-azonosító rendelés létrehozásához.

CREATETABLE Customers (
 customer_id INT PRIMARY KEY,
 first_name VARCHAR(50),
 last_name VARCHAR(50)
);
CREATETABLE Orders (
 order_id INT PRIMARY KEY,
 customer_id INT,
 order_date DATE,
 FOREIGN KEY (customer_id) REFERENCES Customers(customer_id)
);
INSERTINTO Customers(customer_id, first_name, last_name)
VALUES (1, 'Christian', 'Dior');
INSERTINTO Orders(order_id, customer_id, order_date)
VALUES (1, 1, '2023-08-07');

Ha meglévő rendelés nélkül próbál létrehozni egy rendelést Ügyfél-azonosító, az adatbázis hibaüzenetet jelenít meg:

Cannot add or update a child row: a foreign key constraint fails
(`db_9_4ee205c`.`orders`, CONSTRAINT `orders_ibfk_1` FOREIGN KEY
(`customer_id`) REFERENCES `customers` (`customer_id`))

4. EGYEDI kényszer

Ez a megszorítás biztosítja, hogy egy adott oszlophoz ne legyen két sor azonos értéke. Az elsődleges kulcsokhoz hasonlóan az egyedi megszorítások is megőrzik az adatok integritását, és megakadályozzák az ismétlődő bejegyzéseket. Ha egy rosszul megtervezett adatbázissal dolgozik az EGYEDI megkötés nélkül, akkor előfordulhat, hogy muszáj lesz keresse meg és törölje a másolatokat.

Az elsődleges kulcsokkal ellentétben egy táblán sok EGYEDI megszorítás lehet. Például létrehozásakor a Ügyfelek táblázatban, érdemes lehet egyedi azonosítókkal és telefonszámokkal rendelkeznie. Egy ilyen megszorítás hozzáadásához a MySQL szerverrel használja a következő szintaxist:

CREATETABLE Customers (
 ID int NOT NULL UNIQUE,
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Mobile_No BIGINT UNIQUE 
);

Ha azonos mobilszámú rekordokat szúr be az adatbázisba, akkor hibaüzenet jelenik meg.

INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (123456, 'Dior', 'Christian', 254000000 );
INSERTINTO Customers (ID, LastName, FirstName, Mobile_No)
VALUES (7891011, 'Dedan', 'Kimathi', 254000000 );

A hibaüzenet valami ilyesmi lesz:

Duplicate entry '254000000' for key 'Mobile_No'

Ez az EGYEDI megszorítás biztosítja, hogy az adatbázisban ne legyenek ugyanazokkal az azonosítókkal vagy mobilszámokkal rendelkező ügyfelek.

5. ELLENŐRIZZE a kényszert

A CHECK kényszer korlátozza az oszlopba helyezett értéktartományt. Ha egy CHECK-megkötést ad hozzá egy oszlophoz, az adott oszlophoz csak meghatározott értékeket engedélyez. Kikényszeríti az adatok integritását azáltal, hogy biztosítja, hogy a felhasználó csak érvényes adatokat szúrjon be egy táblázatba.

Az ELLENŐRZÉS kényszernek minden megadott sor- vagy táblázatbejegyzéshez IGAZ vagy ISMERETLEN értéket kell kiértékelnie. Ha az érték FALSE, az adatbázis hibaüzenetet jelenít meg.

Például előfordulhat, hogy az Ügyfelek táblázatban csak 18 éven felüli ügyfeleket szeretne kiszolgálni. Hozzáadhat egy CHECK-korlátot, hogy ne szolgáljon ki kiskorú ügyfeleket. Hozzáadhatja a megszorítást egy PostgreSQL adatbázishoz, amint az a következő kódban látható:

CREATETABLE Customers (
 ID int NOT NULL,
 Age int CHECK(Age>=18),
 LastName varchar(255) NOT NULL,
 FirstName varchar(255),
 Mobile_No BIGINT UNIQUE 
);

Ha most egy 18 év alatti ügyfél életkorát próbálja megadni:

INSERTINTO Customers (ID, Age, LastName, FirstName, Mobile_No)
VALUES (123456, 15, 'Dior', 'Christian', 1254000000 );

Az adatbázis a következő hibaüzenetet jeleníti meg:

ERROR: new row for relation "customers" violates check constraint
"customers_age_check"
Detail: Failing row contains (123456, 15, Dior, Christian, 1254000000)

SQL-korlátok hozzáadása és eltávolítása az adatbázisokból

Az SQL megszorítások nincsenek kőbe vésve. Az ALTER TABLE utasítással a meglévő táblákhoz korlátozásokat adhat hozzá vagy távolíthat el. Az ALTER utasítás lehetővé teszi, hogy az adatszükségleteinek megfelelő megszorításokkal dolgozzon.

Számos további SQL-megkötést is megtanulhatsz, hogyan tervezhetsz tetszés szerinti adatbázist. Kezdheti a cikkben felsoroltakkal.