مقدمه
یکی از ویژگی‌های ارزشمند پایگاه‌های داده رابطه‌ای، قالب‌گیری داده‌ها در یک ساختار کاملاً تعریف شده است. این ساختار با استفاده از جداول با ستون های ثابت، پیروی از انواع داده های کاملاً تعریف شده و اطمینان از اینکه هر ردیف دارای شکل یکسانی است، به دست می آید. هنگامی که داده ها را به عنوان ردیف در جداول ذخیره می کنید، به همان اندازه مهم است که بتوانید آنها را پیدا کنید و بدون ابهام به آنها مراجعه کنید. در زبان پرس و جوی ساختاریافته (SQL)، این را می توان با کلیدهای اولیه، که به عنوان شناسه برای ردیف های جداگانه در جداول در پایگاه داده رابطه ای عمل می کنند، به دست آورد.
در این آموزش، با کلیدهای اولیه آشنا می شوید و از چند نوع مختلف برای شناسایی ردیف های منحصر به فرد در جداول پایگاه داده استفاده می کنید. با استفاده از برخی از مجموعه داده‌های نمونه، کلیدهای اولیه را روی ستون‌های منفرد و ستون‌های متعدد و کلیدهای متوالی افزایش خودکار ایجاد می‌کنید.
پیش نیازها
برای پیروی از این راهنما، به رایانه ای نیاز دارید که یک سیستم مدیریت پایگاه داده رابطه ای مبتنی بر SQL (RDBMS) را اجرا کند. دستورالعمل ها و مثال های موجود در این راهنما با استفاده از محیط زیر تأیید شدند:
- سروری که اوبونتو 20.04 را اجرا می کند، با یک کاربر غیر ریشه با امتیازات مدیریتی و فایروال پیکربندی شده با UFW
- MySQL روی سرور نصب و ایمن شده است
- آشنایی اولیه با اجرای کوئری های SELECT برای بازیابی داده ها از پایگاه داده
توجه: لطفاً توجه داشته باشید که بسیاری از RDBMS ها از پیاده سازی منحصر به فرد خود از SQL استفاده می کنند. اگرچه دستورات ذکر شده در این آموزش بر روی اکثر RDBMS ها کار می کنند و کلیدهای اصلی بخشی از استاندارد SQL هستند، برخی از ویژگی ها مختص پایگاه داده هستند و بنابراین اگر آنها را روی سیستمی غیر از MySQL آزمایش کنید، سینتکس یا خروجی دقیق ممکن است متفاوت باشد.
شما همچنین به یک پایگاه داده خالی نیاز دارید که در آن بتوانید جداول استفاده از کلیدهای اصلی را ایجاد کنید. ما شما را تشویق می کنیم که برای جزئیات مربوط به اتصال به سرور MySQL و ایجاد پایگاه داده آزمایشی مورد استفاده در نمونه های این راهنما، بخش اتصال به MySQL و راه اندازی یک پایگاه داده نمونه زیر را طی کنید.
اتصال به MySQL و راه اندازی یک پایگاه داده نمونه
در این قسمت به سرور MySQL متصل می شوید و یک نمونه پایگاه داده ایجاد می کنید تا بتوانید از مثال های این راهنما استفاده کنید.
اگر سیستم پایگاه داده SQL شما بر روی یک سرور راه دور اجرا می شود، SSH را از دستگاه محلی خود به سرور خود وارد کنید:
ssh sammy@your_server_ipسپس اعلان سرور MySQL را باز کنید و نام حساب کاربری MySQL خود را جایگزین سامی کنید:
mysql -u sammy -p
یک پایگاه داده به نام primar_keys ایجاد کنید:
CREATE DATABASE primary_keys;
اگر پایگاه داده با موفقیت ایجاد شده باشد، خروجی زیر را دریافت خواهید کرد:
Output
Query OK, 1 row affected (0.01 sec)برای انتخاب پایگاه داده primar_keys، عبارت USE زیر را اجرا کنید:
USE primary_keys;
خروجی زیر را دریافت خواهید کرد:
Output
Database changedپس از انتخاب پایگاه داده، می توانید نمونه جداول را درون آن ایجاد کنید. اکنون آماده هستید تا بقیه راهنما را دنبال کنید و کار با کلیدهای اصلی در MySQL را شروع کنید.
مقدمه ای بر کلیدهای اصلی
داده ها در یک پایگاه داده رابطه ای در جداول با ساختار خاص و یکنواختی از ردیف های جداگانه ذخیره می شوند. تعریف جدول توضیح می دهد که چه ستون هایی وجود دارد و چه نوع داده هایی را می توان در ستون های جداگانه ذخیره کرد. این به تنهایی برای ذخیره اطلاعات در پایگاه داده و یافتن آن با استفاده از معیارهای مختلف فیلتر با استفاده از عبارت WHERE کافی است. با این حال، این ساختار امکان یافتن هر ردیف را بدون ابهام تضمین نمی کند.
یک بانک اطلاعاتی از تمام وسایل نقلیه ثبت شده مجاز به رانندگی در جاده های عمومی را تصور کنید. پایگاه داده حاوی اطلاعاتی مانند برند خودرو، مدل، سال ساخت و رنگ رنگ است. با این حال، اگر به دنبال یک شورلت کامارو قرمز رنگ ساخته شده در سال 2007 بودید، می توانید بیش از یک دستگاه پیدا کنید. به هر حال، تولیدکنندگان خودرو، خودروهای مشابه را به چندین مشتری می فروشند. به همین دلیل است که خودروهای ثبت شده دارای شماره پلاک هستند که هر وسیله نقلیه را شناسایی می کند. اگر خودرویی با پلاک OFP857 را جستجو کرده باشید، می توانید مطمئن باشید که این معیار تنها یک خودرو را پیدا می کند. این به این دلیل است که طبق قانون، شماره پلاک خودروهای ثبت شده را به طور منحصر به فردی مشخص می کند. در یک پایگاه داده رابطه ای، چنین قطعه ای از داده ها را کلید اولیه می نامند.
کلیدهای اولیه، شناسه‌های منحصربه‌فردی هستند که در یک ستون یا مجموعه‌ای از ستون‌ها یافت می‌شوند که می‌توانند بدون ابهام هر ردیف را در جدول پایگاه داده شناسایی کنند. چند قانون منعکس کننده خصوصیات فنی کلیدهای اولیه است:
- یک کلید اصلی باید از مقادیر منحصر به فرد استفاده کند. اگر کلید اصلی از بیش از یک ستون تشکیل شده باشد، ترکیب مقادیر در این ستون ها باید در کل جدول منحصر به فرد باشد. از آنجایی که کلید برای شناسایی هر ردیف به صورت منحصر به فرد است، نمی تواند بیش از یک بار ظاهر شود.
- یک کلید اصلی نباید حاوی مقادیر NULL باشد.
- هر جدول پایگاه داده می تواند تنها از یک کلید اصلی استفاده کند.
موتور پایگاه داده این قوانین را اعمال می کند، بنابراین اگر کلید اصلی روی یک جدول تعریف شده باشد، می توانید به درست بودن آن ویژگی ها اعتماد کنید.
علاوه بر این ویژگی‌های فنی، باید محتوای داده‌ها را نیز در نظر بگیرید تا تصمیم بگیرید که چه نوع داده‌ای برای تبدیل شدن به کلید اصلی انتخاب خوبی است. کلیدهای طبیعی شناسه هایی هستند که از قبل در مجموعه داده وجود دارند، در حالی که کلیدهای جایگزین شناسه های مصنوعی هستند.
برخی از ساختارهای داده دارای کلیدهای اولیه هستند که به طور طبیعی در مجموعه داده ها وجود دارد، مانند شماره پلاک خودرو در پایگاه داده خودرو یا شماره های تامین اجتماعی در فهرست شهروندان ایالات متحده. گاهی اوقات چنین شناسه هایی یک مقدار نیستند بلکه یک جفت یا ترکیبی از چندین مقدار هستند. برای مثال، در فهرست راهنمای شهری محلی خانه‌ها، فقط یک نام خیابان یا یک شماره خیابان، نمی‌تواند یک خانه را به‌طور منحصربه‌فرد شناسایی کند. ممکن است چندین خانه در یک خیابان وجود داشته باشد و همین تعداد می تواند در چندین خیابان ظاهر شود. اما یک جفت نام و شماره خیابان را می توان یک شناسه خانه منحصر به فرد فرض کرد. چنین شناسه هایی که به طور طبیعی وجود دارند، کلیدهای طبیعی نامیده می شوند.
با این حال، اغلب داده ها را نمی توان به طور منحصر به فرد با مقادیر یک ستون یا زیر مجموعه کوچکی از ستون ها مشخص کرد. سپس، کلیدهای اولیه مصنوعی ایجاد می شوند، به عنوان مثال، با استفاده از دنباله ای از اعداد یا شناسه هایی که به طور تصادفی تولید می شوند مانند UUID. چنین کلیدهایی را کلیدهای جانشین می گویند.
در بخش‌های بعدی، کلیدهای طبیعی را بر اساس یک ستون یا چندین ستون ایجاد می‌کنید و کلیدهای جایگزین را در جداولی که کلید طبیعی گزینه‌ای نیست، ایجاد می‌کنید.
ایجاد یک کلید اصلی در یک ستون
در بسیاری از موارد، یک مجموعه داده به طور طبیعی شامل یک ستون است که می تواند برای شناسایی ردیف های جدول به طور منحصر به فرد استفاده شود. در این موارد می توانید یک کلید طبیعی برای توصیف داده ها ایجاد کنید. به دنبال مثال قبلی از بانک اطلاعاتی خودروهای ثبت نام شده، جدولی را با ساختار زیر تصور کنید:
Sample table
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+ردیف اول و دوم هر دو یک فورد موستانگ قرمز رنگ 2018 را توصیف می‌کنند. با استفاده از مدل و مدل خودرو، نمی‌توانید خودرو را به‌طور منحصربه‌فرد شناسایی کنید. پلاک خودرو در هر دو مورد متفاوت است و یک شناسه منحصر به فرد خوب برای هر ردیف در جدول ارائه می دهد. از آنجایی که شماره پلاک قبلاً بخشی از داده ها است، استفاده از آن به عنوان کلید اصلی یک کلید طبیعی ایجاد می کند. اگر جدول را بدون استفاده از کلید اصلی در ستون License_plate ایجاد کرده باشید، در معرض خطر ظاهر شدن یک صفحه تکراری یا خالی در مجموعه داده‌ها در نقطه‌ای از زمان خواهید بود.
در مرحله بعد، جدولی شبیه جدول بالا با ستون License_plate به عنوان کلید اصلی و ستون های زیر ایجاد می کنید:
- License_plate: این ستون دارای شماره پلاک است که با نوع داده varchar نشان داده شده است.
- نام تجاری: این ستون نشان دهنده مارک خودرو است که با استفاده از نوع داده varchar با حداکثر 50 کاراکتر بیان می شود.
- مدل: این ستون مدل خودرو را نگه می‌دارد که با استفاده از نوع داده varchar با حداکثر 50 کاراکتر بیان شده است.
- رنگ: این ستون رنگ را نگه می دارد که با استفاده از نوع داده varchar با حداکثر 20 کاراکتر بیان می شود.
- year: این ستون سال ساخت خودرو را نشان می دهد که با استفاده از نوع داده int برای ذخیره داده های عددی بیان می شود.
برای ایجاد جدول ماشین‌ها، دستور SQL زیر را اجرا کنید:
CREATE TABLE cars (
license_plate varchar(8) PRIMARY KEY,
brand varchar(50),
model varchar(50),
color varchar(20),
year int
);... */عبارت PRIMARY KEY از تعریف نوع داده License_plate پیروی می کند. هنگامی که با کلیدهای اصلی بر اساس ستون های تک سروکار دارید، می توانید از نحو ساده شده برای ایجاد کلید استفاده کنید و کلید اصلی را در تعریف ستون بنویسید.
اگر خروجی زیر چاپ شود، جدول ایجاد شده است:
Output
Query OK, 0 rows affected (0.00 sec)پس از آن، جدول را با ردیف های نمونه ارائه شده در مثال بالا با اجرای عملیات INSERT INTO زیر بارگذاری کنید:
INSERT INTO cars VALUES
('ABC123', 'Ford', 'Mustang', 'Red', 2018),
('CES214', 'Ford', 'Mustang', 'Red', 2018),
('DEF456', 'Chevrolet', 'Camaro', 'Blue', 2016),
('GHI789', 'Dodge', 'Challenger', 'Black', 2014);پایگاه داده با پیام موفقیت پاسخ خواهد داد:
Output
Query OK, 4 rows affected (0.010 sec)
Records: 4 Duplicates: 0 Warnings: 0اکنون می توانید با استفاده از عبارت SELECT تأیید کنید که جدول جدید ایجاد شده حاوی داده ها و قالب پیش بینی شده است:
SELECT * FROM cars;
خروجی جدولی شبیه به جدول ابتدای بخش نشان می دهد:
Output
+---------------+-----------+------------+-------+------+
| license_plate | brand | model | color | year |
+---------------+-----------+------------+-------+------+
| ABC123 | Ford | Mustang | Red | 2018 |
| CES214 | Ford | Mustang | Red | 2018 |
| DEF456 | Chevrolet | Camaro | Blue | 2016 |
| GHI789 | Dodge | Challenger | Black | 2014 |
+---------------+-----------+------------+-------+------+در مرحله بعد، می توانید بررسی کنید که آیا قوانین کلید اصلی توسط موتور پایگاه داده تضمین شده است یا خیر. سعی کنید خودرویی با شماره پلاک تکراری را با اجرای زیر وارد کنید:
INSERT INTO cars VALUES ('DEF456', 'Jeep', 'Wrangler', 'Yellow', 2019);
MySQL با یک پیغام خطایی پاسخ می‌دهد که می‌گوید پلاک DEF456 منجر به یک ورودی تکراری برای کلید اصلی می‌شود:
Output ERROR 1062 (23000): Duplicate entry 'DEF456' for key 'cars.PRIMARY'
توجه: در زیر هود، کلیدهای اولیه با نمایه‌های منحصربه‌فرد پیاده‌سازی می‌شوند و بسیاری از خصوصیات را با نمایه‌هایی که ممکن است به صورت دستی برای ستون‌های دیگر روی جدول ایجاد کنید، به اشتراک می‌گذارند. مهمتر از همه، شاخص های کلید اولیه همچنین عملکرد پرس و جو جدول را در مقابل ستونی که نمایه روی آن تعریف شده است، بهبود می بخشد. برای کسب اطلاعات بیشتر در مورد استفاده از شاخص ها برای این منظور، راهنمای نحوه استفاده از شاخص ها را در این مجموعه آموزشی ببینید.
اکنون می توانید مطمئن باشید که پلاک های تکراری مجاز نیستند. در مرحله بعد، بررسی کنید که آیا می توان خودرویی با پلاک خالی را وارد کرد:
INSERT INTO cars VALUES (NULL, 'Jeep', 'Wrangler', 'Yellow', 2019);
این بار پایگاه داده با پیغام خطای دیگری پاسخ خواهد داد:
Output
ERROR 1048 (23000): Column 'license_plate' cannot be nullبا این دو قانون که توسط پایگاه داده اعمال می شود، می توانید مطمئن باشید که License_plate هر ردیف در جدول را به طور منحصر به فرد شناسایی می کند. اگر جدول را در برابر هر پلاک پرس و جو کنید، می توانید انتظار داشته باشید که هر بار یک ردیف برگردانده شود.
در بخش بعدی، نحوه استفاده از کلیدهای اصلی با چندین ستون را خواهید آموخت.
ایجاد یک کلید اصلی در چندین ستون
هنگامی که یک ستون برای شناسایی یک ردیف منحصر به فرد در جدول کافی نیست، می توانید کلیدهای اصلی را ایجاد کنید که از بیش از یک ستون استفاده می کنند.
به عنوان مثال، یک دفتر ثبت خانه را تصور کنید که در آن نه نام خیابان و نه شماره خیابان به تنهایی برای شناسایی هر خانه کافی نیست:
Sample table
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+نام خیابان Central Park West بیش از یک بار در جدول ظاهر می‌شود، و همینطور خیابان شماره 100. با این حال، هیچ جفت تکراری نام خیابان و شماره خیابان قابل مشاهده نیست. در این مورد، در حالی که هیچ ستونی نمی تواند کلید اصلی باشد، از جفت آن دو مقدار می توان برای شناسایی هر سطر در جدول به طور منحصر به فرد استفاده کرد.
در مرحله بعد، جدولی شبیه جدول نشان داده شده در بالا با ستون های زیر ایجاد می کنید:
- street_name: این ستون نام خیابانی را که خانه در آن قرار دارد، با نوع داده varchar محدود به 50 کاراکتر نشان می‌دهد.
- street_number: این ستون شماره خیابان خانه را نگه می‌دارد که با نوع داده varchar نمایش داده می‌شود. این ستون می تواند حداکثر 5 کاراکتر را ذخیره کند. از نوع داده int عددی استفاده نمی کند زیرا برخی از شماره های خیابان ممکن است حاوی حروف باشند (مثلاً 200B).
- house_owner: این ستون دارای نام صاحب خانه است که با نوع داده varchar محدود به 50 کاراکتر نشان داده شده است.
- year: این ستون نشان دهنده سال ساخت خانه است که با نوع داده int برای ذخیره مقادیر عددی نمایش داده می شود.
این بار، کلید اصلی از هر دو ستون street_name و street_number به جای یک ستون استفاده می‌کند. برای انجام این کار، دستور SQL زیر را اجرا کنید:
CREATE TABLE houses (
street_name varchar(50),
street_number varchar(5),
house_owner varchar(50),
year int,
PRIMARY KEY(street_name, street_number)
);این بار، بر خلاف مثال قبلی، عبارت PRIMARY KEY در زیر تعاریف ستون ظاهر می شود. عبارت PRIMARY KEY با پرانتزهایی همراه با دو نام ستون در داخل قرار می گیرد: street_name و street_number. این نحو کلید اصلی را در جدول خانه ها ایجاد می کند که در دو ستون قرار دارد.
اگر خروجی زیر چاپ شود، جدول ایجاد شده است:
Output
Query OK, 0 rows affected (0.00 sec)پس از آن، جدول را با ردیف های نمونه ارائه شده در مثال قبلی با اجرای عملیات INSERT INTO زیر بارگذاری کنید:
INSERT INTO houses VALUES
('Central Park West', '100', 'John Doe', 2014),
('Broadway', '1500', 'Jane Smith', 2016),
('5th Avenue', '100', 'Bob Johnson', 2018),
('Lexington Avenue', '5001', 'Samantha Davis', 2010),
('Park Avenue', '7000', 'Michael Rodriguez', 2012),
('Central Park West', '200', 'Tom Thompson', 2015);
پایگاه داده با پیام موفقیت پاسخ خواهد داد:
Output
Query OK, 6 rows affected (0.000 sec)
Records: 6 Duplicates: 0 Warnings: 0اکنون می توانید با استفاده از عبارت SELECT تأیید کنید که جدول جدید ایجاد شده حاوی داده ها و قالب پیش بینی شده است:
SELECT * FROM houses;
خروجی جدولی شبیه به جدول ابتدای بخش نشان می دهد:
Output
+-------------------+---------------+-------------------+------+
| street_name | street_number | house_owner | year |
+-------------------+---------------+-------------------+------+
| 5th Avenue | 100 | Bob Johnson | 2018 |
| Broadway | 1500 | Jane Smith | 2016 |
| Central Park West | 100 | John Doe | 2014 |
| Central Park West | 200 | Tom Thompson | 2015 |
| Lexington Avenue | 5001 | Samantha Davis | 2010 |
| Park Avenue | 7000 | Michael Rodriguez | 2012 |
+-------------------+---------------+-------------------+------+
6 rows in set (0.000 sec)اکنون، اجازه دهید بررسی کنیم که آیا پایگاه داده اجازه درج ردیف‌هایی را می‌دهد که نام خیابان‌ها و شماره خیابان‌ها را تکرار می‌کنند، اما نشانی‌های کامل تکراری را از نمایش در جدول محدود می‌کنند. بیایید با اضافه کردن یک خانه دیگر در خیابان پارک شروع کنیم:
INSERT INTO houses VALUES ('Park Avenue', '8000', 'Emily Brown', 2011);
MySQL با یک پیام موفقیت آمیز پاسخ می دهد زیرا آدرس 8000 Park Avenue قبلاً در جدول ظاهر نشده بود:
Output
Query OK, 1 row affected (0.010 sec)نتیجه مشابه زمانی اتفاق می افتد که خانه ای را در خیابان اصلی 8000 اضافه کنید و شماره خیابان را تکرار کنید:
INSERT INTO houses VALUES ('Main Street', '8000', 'David Jones', 2009);
یک بار دیگر، این یک ردیف جدید را به درستی وارد می کند زیرا کل آدرس تکراری نمی شود:
Output
Query OK, 1 row affected (0.010 sec)با این حال، با استفاده از عبارت INSERT زیر، خانه دیگری در 100 5th Avenue اضافه کنید:
INSERT INTO houses VALUES ('5th Avenue', '100', 'Josh Gordon', 2008);
پایگاه داده با یک پیام خطا پاسخ می دهد و به شما اطلاع می دهد که یک ورودی تکراری برای کلید اصلی برای جفت مقادیر 5th Avenue و 100 وجود دارد:
Output
ERROR 1062 (23000): Duplicate entry '5th Avenue-100' for key 'houses.PRIMARY'پایگاه داده به درستی قوانین کلید اصلی را با کلید تعریف شده روی یک جفت ستون اجرا می کند. می توانید مطمئن باشید که آدرس کامل شامل نام خیابان و شماره خیابان در جدول تکراری نمی شود.
در این بخش، یک کلید طبیعی با یک جفت ستون ایجاد کردید تا هر ردیف در جدول خانه را به طور منحصر به فرد شناسایی کنید. اما همیشه نمی توان کلیدهای اولیه را از مجموعه داده استخراج کرد. در بخش بعدی، از کلیدهای اولیه مصنوعی استفاده خواهید کرد که مستقیماً از داده ها نمی آیند.
ایجاد یک کلید اصلی متوالی
تا به حال، شما کلیدهای اولیه منحصر به فرد را با استفاده از ستون های موجود در مجموعه داده های نمونه ایجاد کرده اید. اما در برخی موارد، داده‌ها ناگزیر تکرار می‌شوند و مانع از این می‌شوند که ستون‌ها شناسه‌های منحصربه‌فرد خوبی باشند. در این موارد، می‌توانید کلیدهای اصلی متوالی را با استفاده از شناسه‌های تولید شده ایجاد کنید. زمانی که داده‌های در اختیار شما از شما می‌خواهد که شناسه‌های جدیدی برای شناسایی ردیف‌ها ایجاد کنید، کلیدهای اولیه ایجاد شده روی آن شناسه‌های مصنوعی، کلیدهای جایگزین نامیده می‌شوند.
فهرستی از اعضای باشگاه کتاب را تصور کنید – یک گردهمایی غیررسمی که در آن هر کسی می‌تواند بدون نشان دادن کارت شناسایی دولتی به آن بپیوندد. این احتمال وجود دارد که افرادی با نام های مشابه در یک مقطع زمانی به باشگاه بپیوندند:
Sample table
+------------+-----------+
| first_name | last_name |
+------------+-----------+
| John | Doe |
| Jane | Smith |
| Bob | Johnson |
| Samantha | Davis |
| Michael | Rodriguez |
| Tom | Thompson |
| Sara | Johnson |
| David | Jones |
| Jane | Smith |
| Bob | Johnson |
+------------+-----------+نام باب جانسون و جین اسمیت در جدول تکرار شده است. شما باید از یک شناسه اضافی استفاده کنید تا مطمئن شوید که چه کسی کیست، و به هیچ وجه نمی توان ردیف ها را به طور منحصر به فرد در آن جدول شناسایی کرد. اگر لیست اعضای باشگاه کتاب را روی کاغذ نگه می داشتید، می توانید شناسه های کمکی را برای کمک به تشخیص افراد با نام های مشابه در بین گروه نگه دارید.
می‌توانید با استفاده از یک ستون اضافی که شناسه‌های تولید شده و بدون واقعیت را نگه می‌دارد، کار مشابهی را در یک پایگاه داده رابطه‌ای انجام دهید که تنها هدف آن جداسازی منحصربه‌فرد همه ردیف‌های جدول است. بیایید آن را Member_id بنامیم.
با این حال، هر زمان که بخواهید یکی دیگر از اعضای باشگاه کتاب را به پایگاه داده اضافه کنید، ایجاد چنین شناسه‌ای کار سختی است. برای حل این مشکل، MySQL یک ویژگی برای ستون‌های عددی افزایش‌یافته خودکار فراهم می‌کند، که در آن پایگاه داده به‌طور خودکار مقدار ستون را با دنباله‌ای از اعداد صحیح افزایش می‌دهد.
بیایید جدولی شبیه جدول بالا ایجاد کنیم. شما یک ستون افزایش خودکار اضافی (member_id) اضافه می کنید تا شماره اختصاص داده شده به طور خودکار برای هر یک از اعضای باشگاه نگه داشته شود. آن شماره اختصاص داده شده به طور خودکار به عنوان کلید اصلی جدول عمل می کند:
Member_id: این ستون دارای یک شناسه عددی با افزایش خودکار است که با نوع داده int نمایش داده می شود.
first_name: این ستون دارای نام کوچک اعضای باشگاه است که با نوع داده varchar محدود به 50 کاراکتر نشان داده شده است.
last_name: این ستون نام خانوادگی اعضای باشگاه را نگه می دارد که با نوع داده varchar محدود به 50 کاراکتر نمایش داده می شود.
برای ایجاد جدول، دستور SQL زیر را اجرا کنید:
CREATE TABLE club_members (
member_id int AUTO_INCREMENT PRIMARY KEY,
first_name varchar(50),
last_name varchar(50)
);در حالی که عبارت PRIMARY KEY بعد از تعریف نوع ستون ظاهر می شود، درست مانند کلید اصلی تک ستونی، یک ویژگی اضافی قبل از آن ظاهر می شود: AUTO_INCREMENT. به MySQL می‌گوید که مقادیر آن ستون را به‌طور خودکار تولید کند، اگر صریحاً ارائه نشده باشد، با استفاده از یک دنباله رو به رشد اعداد.
نکته: خاصیت AUTO_INCREMENT برای تعریف ستون مختص MySQL است. سایر پایگاه های داده اغلب روش های مشابهی را برای تولید کلیدهای متوالی ارائه می دهند، اما نحو در بین موتورها متفاوت است. در صورت شک، توصیه می کنیم به اسناد رسمی RDBMS خود مراجعه کنید.
اگر خروجی زیر چاپ شود، جدول ایجاد شده است:
Output
Query OK, 0 rows affected (0.00 sec)پس از آن، جدول را با ردیف های نمونه ارائه شده در مثال بالا با اجرای عملیات INSERT INTO زیر بارگذاری کنید:
INSERT INTO club_members (first_name, last_name) VALUES
('John', 'Doe'),
('Jane', 'Smith'),
('Bob', 'Johnson'),
('Samantha', 'Davis'),
('Michael', 'Rodriguez'),
('Tom', 'Thompson'),
('Sara', 'Johnson'),
('David', 'Jones'),
('Jane', 'Smith'),
('Bob', 'Johnson');دستور INSERT اکنون شامل فهرستی از نام ستون‌ها (first_name و last_name) می‌شود، که تضمین می‌کند پایگاه داده می‌داند که ستون Member_id در مجموعه داده ارائه نشده است، بنابراین مقدار پیش‌فرض برای آن باید به جای آن گرفته شود.
پایگاه داده با پیام موفقیت پاسخ خواهد داد:
Output
Query OK, 10 rows affected (0.002 sec)
Records: 10 Duplicates: 0 Warnings: 0از دستور SELECT برای تأیید داده ها در جدول جدید ایجاد شده استفاده کنید:
SELECT * FROM club_members;
خروجی جدولی شبیه به جدول ابتدای بخش نشان می دهد:
Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
+-----------+------------+-----------+
10 rows in set (0.000 sec)با این حال، این بار، ستون Member_id در نتیجه ظاهر می شود و شامل دنباله ای از اعداد از 1 تا 10 است. با وجود این ستون، ردیف های تکراری برای جین اسمیت و باب جانسون دیگر قابل تشخیص نیستند زیرا هر نام با یک شناسه منحصر به فرد مرتبط است. (Member_id).
اکنون، بیایید بررسی کنیم که آیا پایگاه داده اجازه می دهد تام تامپسون دیگری را به لیست اعضای باشگاه اضافه کنیم:
INSERT INTO club_members (first_name, last_name) VALUES ('Tom', 'Thompson');
MySQL با یک پیام موفقیت آمیز پاسخ خواهد داد:
Output
Query OK, 1 row affected (0.009 sec)
برای بررسی اینکه چه شناسه عددی به ورودی جدید توسط پایگاه داده اختصاص داده شده است، کوئری SELECT را دوباره اجرا کنید:
SELECT * FROM club_members;
یک ردیف دیگر در خروجی وجود دارد:
Output
+-----------+------------+-----------+
| member_id | first_name | last_name |
+-----------+------------+-----------+
| 1 | John | Doe |
| 2 | Jane | Smith |
| 3 | Bob | Johnson |
| 4 | Samantha | Davis |
| 5 | Michael | Rodriguez |
| 6 | Tom | Thompson |
| 7 | Sara | Johnson |
| 8 | David | Jones |
| 9 | Jane | Smith |
| 10 | Bob | Johnson |
| 11 | Tom | Thompson |
+-----------+------------+-----------+
11 rows in set (0.000 sec)یک ردیف جدید به طور خودکار شماره 11 در ستون Member_id از طریق ویژگی AUTO_INCREMENT پایگاه داده اختصاص داده شد.
اگر داده‌هایی که با آنها کار می‌کنید دارای نامزدهای طبیعی برای کلیدهای اولیه نیستند، و نمی‌خواهید هر بار که داده‌های جدیدی را به پایگاه داده اضافه می‌کنید، شناسه‌های اختراعی ارائه کنید، می‌توانید با خیال راحت به شناسه‌های تولید شده متوالی به عنوان کلیدهای اصلی اعتماد کنید.
نتیجه
با دنبال کردن این راهنما، یاد گرفتید که کلیدهای اصلی چیست و چگونه انواع رایج در MySQL را برای شناسایی ردیف های منحصر به فرد در جداول پایگاه داده ایجاد کنید. شما کلیدهای اولیه طبیعی ایجاد کردید، کلیدهای اولیه را ایجاد کردید که چندین ستون را در بر می گرفت و از کلیدهای متوالی افزایش خودکار در جایی که کلیدهای طبیعی وجود ندارند استفاده کردید.
