ينطوي التعامل مع قواعد البيانات بشكلٍ أساسيّ على استخراج المعلومات حول البيانات المُخزّنة ضمنها. ويُطلق مصطلح الاستعلام query على أي عملية لاسترجاع المعلومات من جدول في أنظمة إدارة قواعد البيانات العلاقية.

سنبحث في هذا المقال في بنية الاستعلامات بلغة الاستعلام البنيوية SQL وبعض الوظائف والعوامل الأكثر استخدامًا فيها.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز كمبيوتر يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العلاقية RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، وللقيام بذلك يمكنك الاطلاع على المقال كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• MySQL مثبتة ومؤمنة على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، مُنشأ وفق الطريقة الموضحة في الخطوة 3 من هذا المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقية RDBMS لها تقديماتها الفريدة من لغة SQL. فبالرغم من كون الأوامر المُقدمة في هذا المقال ستعمل مع معظم هذه الأنظمة، ولكن قد تجد بعض الاختلافات في الصيغة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، ستحتاج أيضًا إلى قاعدة بيانات وجدول مُحمّل ببعض البيانات التجريبية النموذجية لتتمكن من التدرب على كتابة الاستعلامات. لذا ننصحك بقراءة القسم القادم الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية للمزيد من التفاصيل حول كيفية إعداد قاعدة بيانات وجدول لاستخدامهما في الأمثلة خلال هذا المقال.

الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم عن بُعد، اتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو:

$ ssh ssh user@your_server_ip

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

الآن ومن نافذة سطر الأوامر، أنشئ قاعدة بيانات باسم queries_DB:

mysql> CREATE DATABASE queries_DB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات queries_DB، نفّذ تعليمة USE التالية:

mysql> USE queries_DB;

الخرج
Database changed

بعد تحديد قاعدة البيانات queries_db، سننشئ عدة جداول داخلها.

للمتابعة مع الأمثلة المستخدمة في هذا المقال، تخيل أنك تدير مبادرة لتنظيف المنتزهات العامة في مدينة ما. إذ تضم المبادرة عددًا من المتطوعين الملتزمين بتنظيف منتزه المدينة الأقرب لمنازل كل منهم من خلال جمع القمامة بانتظام. ولدى الانضمام إلى المبادرة، يضع كل متطوع هدفًا لعدد أكياس القمامة التي يود جمعها كل أسبوع. وبفرض أننا قررنا تخزين المعلومات حول أهداف المتطوعين في قاعدة بيانات SQL باستخدام جدول يحتوي على خمسة أعمدة، على النحو:

• vol_id: مُعرّف كل متطوع، مُعبرًا عنه بنمط بيانات الأعداد الصحيحة int. سيكون هذا العمود هو المفتاح الأساسي للجدول، مما يعني أن كل قيمة منه ستلعب دور المعرّف الفريد لسجلها المقابل. ونظرًا لأن كل قيمة في المفتاح الأساسي يجب أن تكون فريدة، فسيتم تطبيق قيد UNIQUE على هذا العمود أيضًا.
• name: اسم كل متطوع، مُعبرًا عنه بنمط البيانات varchar بحد أقصى 20 محرفًا.
• park: اسم المنتزه التي سيجمع فيها كل متطوع القمامة، مُعبرًا عنه بنمط البيانات varchar بحد أقصى 20 محرفًا. لاحظ أنه يمكن لعدة متطوعين تنظيف نفس المنتزه.
• weekly_goal: هدف كل متطوع لعدد أكياس القمامة التي يرغب في جمعها في الأسبوع، مُعبرًا عنه بنمط البيانات int.
• max_bags: الرقم القياسي الشخصي لكل متطوع لأكبر عدد من أكياس القمامة التي جمعها في أسبوع واحد، مُعبرًا عنه بنمط البيانات عدد صحيح int.

أنشئ جدولًا باسم volunteers يحتوي على هذه الأعمدة الخمسة بتنفيذ تعليمة CREATE TABLE على النحو:

mysql> CREATE TABLE volunteers (
mysql> vol_id int UNIQUE,
mysql> name varchar(20),
mysql> park varchar(30),
mysql> weekly_goal int,
mysql> max_bags int,
mysql> PRIMARY KEY (vol_id)
mysql> );

بعد إنشاء جدول volunteers، املأه ببعض البيانات النموذجية. نفّذ تعليمة INSERT INTO التالية لإضافة سبع سجلات تمثل سبعة من متطوعي البرنامج:

mysql> INSERT INTO volunteers
mysql> VALUES
mysql> (1, 'Gladys', 'Prospect Park', 3, 5),
mysql> (2, 'Catherine', 'Central Park', 2, 2),
mysql> (3, 'Georgeanna', 'Central Park', 2, 1),
mysql> (4, 'Wanda', 'Van Cortland Park', 1, 1),
mysql> (5, 'Ann', 'Prospect Park', 2, 7),
mysql> (6, 'Juanita', 'Riverside Park', 1, 4),
mysql> (7, 'Georgia', 'Prospect Park', 1, 3);

وبذلك غدوتَ جاهزًا لمتابعة باقي المقال والبدء في تعلم كيفية إنشاء الاستعلامات في لغة الاستعلام البنيوية SQL.

مكونات الاستعلام الأساسية: بنيتي SELECT و FROM

تُعرّف التعليمة البرمجية في SQL بأنّها أي عملية تُرسَل إلى نظام قاعدة البيانات لتنفيذ مهمّة محددة، من قبيل إنشاء جدول أو إدخال أو حذف بيانات أو تغيير هيكلية عمود أو جدول. وما الاستعلام سوى تعليمة برمجية في SQL تسترجع معلومات حول البيانات المحفوظة في قاعدة البيانات.

لن يُغير الاستعلام أي بيانات موجودة في جدول من تلقاء نفسه، إذ سيقتصر الأمر فقط على استرجاع المعلومات حول البيانات التي يطلبها مُنشئ الاستعلام بشكلٍ صريح. ويُشار إلى المعلومات التي يُعيدها استعلام معين بمجموعة نتائجه. والتي عادةً ما تتكون من عمود واحد أو أكثر من جدول محدد، وكل عمود يُعاد في مجموعة النتائج يمكن أن يحتوي على سجل واحد أو أكثر من المعلومات.

فيما يلي الصيغة العامة لاستعلام SQL:

mysql> SELECT columns_to_return
mysql> FROM table_to_query;

تتألف تعليمات SQL من بنى مختلفة، والتي تتكون بدورها من كلمات مفتاحية معينة مع المعلومات التي تتطلبها هذه الكلمات. وفي هذا السياق تتطلب الاستعلامات في SQL منك تضمين بنيتين على الأقل، وهما: SELECT و FROM.

ملاحظة: كُتبت كل بنية في هذه صيغة هذا المثال في سطرها الخاص. ولكن يمكن كتابة أي تعليمة برمجية في SQL على سطرٍ واحد على النحو التالي:

mysql> SELECT columns_to_return FROM table_to_query;

يتبع هذا المقال القاعدة الشائعة في أسلوب SQL بتقسيم التعليمات البرمجية على سطور متعددة بحيث يحتوي كل سطر على بنية واحدة فقط. والهدف من ذلك تحسين قابلية القراءة والفهم لكل مثال، لكن ينبغي الإشارة إلى أنه بإمكانك كتابة استعلام على سطر واحد أو توزيعه على عدة سطور، طالما أنه لا يحتوي على أخطاء في الصياغة.

تبدأ كل استعلامات SQL عادةً ببنية SELECT، ولذلك يُشار إليها عمومًا بتعليمات SELECT. وتأتي بعد كلمة SELECT المفتاحية قائمة بأسماء الأعمدة التي ترغب في استرجاعها في مجموعة النتائج، والتي يتم اختيارها من الجدول المُحدد في بنية FROM.

يبدأ تنفيذ العملية في استعلامات SQL من بنية FROM. الأمر الذي قد يبدو محيرًا نظرًا لأن بنية SELECT تُكتب قبل FROM، ولكن من الضروري أن يحدد نظام إدارة قواعد البيانات أولًا مجموعة البيانات الكاملة التي سيتم الاستعلام عنها قبل البدء في استرجاع المعلومات منها. يُفيد التفكير في الاستعلامات على أنها عملية اختيار SELECT لأعمدة محددة من FROM جدول مُعين. ومن المهم التذكير بأن كل تعليمة SQL يجب أن تختتم بفاصلة منقوطة (;).

كمثال، نفذ الاستعلام التالي الذي يسترجع عمود name من جدول volunteers:

mysql> SELECT name
mysql> FROM volunteers;

إليك مجموعة نتائج هذا الاستعلام:

الخرج
+------------+
| name       |
+------------+
| Gladys     |
| Catherine  |
| Georgeanna |
| Wanda      |
| Ann        |
| Juanita    |
| Georgia    |
+------------+
7 rows in set (0.00 sec)

على الرغم من أن هذه العملية استعرضت جدول volunteers بأكمله، إلا أنها استرجعت فقط العمود المُحدد، ألا وهو name.

يمكنك استرجاع المعلومات من عدة أعمدة عن طريق فصل اسماء الأعمدة بعلامات فاصلة، كما في الاستعلام التالي. إذ سيعيد هذا الاستعلام أعمدة vol_id, name, و park من جدول volunteers:

mysql> SELECT park, name, vol_id
mysql> FROM volunteers;

الخرج
+-------------------+------------+--------+
| park              | name       | vol_id |
+-------------------+------------+--------+
| Prospect Park     | Gladys     |      1 |
| Central Park      | Catherine  |      2 |
| Central Park      | Georgeanna |      3 |
| Van Cortland Park | Wanda      |      4 |
| Prospect Park     | Ann        |      5 |
| Riverside Park    | Juanita    |      6 |
| Prospect Park     | Georgia    |      7 |
+-------------------+------------+--------+
7 rows in set (0.00 sec)

لاحظ أنّ هذه النتيجة تُعيد العمود park أولًا، يليه عمود name ثم vol_id. تُعيد قواعد البيانات SQL الأعمدة عمومًا بالترتيب الذي تم سرده في بنية SELECT.

قد تحتاج في بعض الأحيان إلى استرجاع كل الأعمدة من جدول ما. فبدلًا من كتابة أسماء كافّة الأعمدة في استعلامك، يمكنك ببساطة إدخال علامة النجمة (*). وهي الطريقة المختصرة في SQL، للدلالة على "كل الأعمدة".

الاستعلام التالي سيُعيد كل الأعمدة من جدول volunteers:

mysql> SELECT *
mysql> FROM volunteers;

الخرج
+--------+------------+-------------------+-------------+----------+
| vol_id | name       | park              | weekly_goal | max_bags |
+--------+------------+-------------------+-------------+----------+
|      1 | Gladys     | Prospect Park     |           3 |        5 |
|      2 | Catherine  | Central Park      |           2 |        2 |
|      3 | Georgeanna | Central Park      |           2 |        1 |
|      4 | Wanda      | Van Cortland Park |           1 |        1 |
|      5 | Ann        | Prospect Park     |           2 |        7 |
|      6 | Juanita    | Riverside Park    |           1 |        4 |
|      7 | Georgia    | Prospect Park     |           1 |        3 |
+--------+------------+-------------------+-------------+----------+
7 rows in set (0.00 sec)

لاحظ كيف تُعرَض الأعمدة في هذه النتيجة بنفس الترتيب المُحدّد في تعليمة CREATE TABLE من فقرة الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية السابقة. وهي الطريقة التي ستُرتب بها معظم أنظمة قواعد البيانات العلاقية الأعمدة في مجموعة النتائج عند تنفيذ استعلام يستخدم علامة النجمة (*) بدلًا من أسماء الأعمدة الفردية.

ومن الجدير بالملاحظة أنّه من الممكن استرجاع المعلومات من عدة جداول في نفس الاستعلام باستخدام الكلمة المفتاحية JOIN. ونشجعك في هذا الصدد على قراءة مقال استخدام عمليات الدمج في SQL.

استبعاد القيم المكررة باستخدام DISTINCT

تُعيد أنظمة إدارة قواعد البيانات العلاقية افتراضيًا جميع القيم من أعمدة الجدول المُستعلم عنه، بما في ذلك القيم المكررة.

كمثال، نفّذ الاستعلام التالي. إذ سيُرجع القيم من عمود park في جدول volunteers:

mysql> SELECT park
mysql> FROM volunteers;

الخرج
+-------------------+
| park              |
+-------------------+
| Prospect Park     |
| Central Park      |
| Central Park      |
| Van Cortland Park |
| Prospect Park     |
| Riverside Park    |
| Prospect Park     |
+-------------------+
7 rows in set (0.00 sec)

لاحظ أن مجموعة النتائج تتضمّن قيمتين مكررتين هما Prospect Park وCentral Park. وهو أمر منطقي، إذ يمكن لعدد من المتطوعين التعاون في تنظيف نفس المتنزه. ومع ذلك، قد ترغب في بعض الأحيان بمعرفة القيم الفريدة المخزنة في عمود ما ويمكنك تحقيق ذلك وإزالة القيم المكررة من نتائج استعلامك باستخدام الكلمة المفتاحية DISTINCT بعد SELECT.

سيُرجع الاستعلام التالي كافة القيم الفريدة من عمود park، مُستبعدًا أية قيم مكررة. وهو مُتشابه للاستعلام السابق ولكن مع إضافة كلمة DISTINCT، كما يلي:

mysql> SELECT DISTINCT park
mysql> FROM volunteers;

الخرج
+-------------------+
| park              |
+-------------------+
| Prospect Park     |
| Central Park      |
| Van Cortland Park |
| Riverside Park    |
+-------------------+
4 rows in set (0.00 sec)

تحتوي مجموعة نتائج هذا الاستعلام على ثلاث سجلات أقل من الاستعلام السابق، بسبب إزالة إحدى قيم Central Park واثنتين من قيم Prospect Park.

تجدر الإشارة إلى أن SQL تُعامل كل سجل في مجموعة النتائج كسجل فردي، وتُزيل DISTINCT القيم المكررة فقط في حال تشاركت عدة سجلات بنفس القيم في كل الأعمدة.

لتوضيح ذلك، لنُصدر الاستعلام التالي المُتضمّن للكلمة المفتاحية DISTINCT والذي يُرجع كلا العمودين name وpark:

mysql> SELECT DISTINCT name, park
mysql> FROM volunteers;

الخرج
+------------+-------------------+
| name       | park              |
+------------+-------------------+
| Gladys     | Prospect Park     |
| Catherine  | Central Park      |
| Georgeanna | Central Park      |
| Wanda      | Van Cortland Park |
| Ann        | Prospect Park     |
| Juanita    | Riverside Park    |
| Georgia    | Prospect Park     |
+------------+-------------------+
7 rows in set (0.00 sec)

تشتمل مجموعة النتائج هذه على قيم مكررة في عمود park، بواقع ثلاث تكرارات لقيم Prospect Park وتكرارين لقيم Central Park، وذلك على الرغم من إدراج الكلمة المفتاحية DISTINCT في الاستعلام. فعلى الرغم من احتواء الأعمدة الفردية في مجموعة النتائج على قيم مكررة، لكن يجب أن تكون السجلات متطابقة بالكامل لتُستبعد من قبل DISTINCT. وفي حالتنا، ونظرًا لأن القيم في عمود name فريدة لكل سجل، فإن DISTINCT لن تزيل أي من السجلات لدى تحديد هذا العمود ضمن بنية SELECT.

تصفية البيانات باستخدام بنى WHERE

قد ترغب في بعض الحالات باسترجاع معلومات أكثر تحديدًا من جداول قاعدة البيانات. إذ يمكنك تصفية سجلات معينة بإدراج بنية WHERE في استعلامك بعد بنية FROM، كما في المثال التالي:

mysql> SELECT columns_to_return
mysql> FROM table_to_query
mysql> WHERE search_condition;

يأتي شرط البحث بعد كلمة WHERE في الصيغة المذكورة بالمثال، والذي يُحدّد على وجه الخصوص أي السجلات مُراد تصفيتها من مجموعة النتائج. وما شرط البحث سوى مجموعة من التوابع الشرطية أو التعبيرات القادرة على تقييم تعبير قيمة واحد أو أكثر. إذ يُعرّف تعبير القيمة في لغة SQL - والذي يُشار إليه أحيانًا باسم التعبير ذو القيمة المفردة - بأنّه أي تعبير يُعيد قيمة واحدة. ويمكن أن يكون تعبير القيمة عبارة عن قيمة محددة النوع (سلسلة نصية أو قيمة عددية)، أو تعبير رياضي، أو اسم عمود.

يمكن أن تأخذ التوابع الشرطية في شرط البحث الخاص ببنية WHERE أشكالاً مختلفة، ولكنها عادةً ما تتبع الصيغة التالية:

WHERE value expression OPERATOR value_expression

فقد وضعنا بعد الكلمة المفتاحية WHERE في هذه الصيغة تعبير قيمة، يليه أحد معاملات SQL الخاصة والمُستخدمة لتقييم قيم الأعمدة بالنسبة لتعبير القيمة (أو تعابير القيم) الآتي بعد العامل.

وهناك العديد من هذه العوامل المتاحة في SQL، وسنقدّم في هذا القسم لمحة موجزة عن بعضها، ولكن لغرض التوضيح سنركّز فقط على أحد أكثر العوامل استخدامًا، ألا وهو: علامة المساواة (=). يختبر هذا العامل ما إذا كان تعبيرين يحتويان على قيم متطابقة.

دائمًا ما تُعطي التوابع الشرطية الناتج "صحيح True" أو "خاطئ False" أو "غير محدد Unknown". فلدى تشغيل استعلامات SQL التي تحتوي على بنية WHERE، سيطبّق نظام إدارة قاعدة البيانات شرط البحث تتابعيًا على كل سجل في الجدول المحدد في بنية FROM. ولن يعيد سوى السجلات التي يُقيّم فيها كل شرط بحث على أنه "صحيح".

لتوضيح هذه الفكرة، نفّذ تعليمة SELECT التالية. يُرجع هذا الاستعلام قيمًا من عمود name في جدول volunteers. لكن بدلًا من تقييم قيم أحد أعمدة الجدول، تختبر بنية WHERE في هذا الاستعلام ما إذا كان التعبير (2 + 2) و 4  متساويين.

mysql> SELECT name
mysql> FROM volunteers
mysql> WHERE (2+2) = 4;

ونظرًا لأنّ التعبير (2+2) يساوي 4 دائمًا، فإن شرط البحث هذا يُقيّم بأنه صحيح لكل سجل في الجدول. ونتيجةً لذلك، تُرجع قيمة الاسم لكل سجل في مجموعة النتائج، على النحو:

الخرج
+------------+
| name       |
+------------+
| Gladys     |
| Catherine  |
| Georgeanna |
| Wanda      |
| Ann        |
| Juanita    |
| Georgia    |
+------------+
7 rows in set (0.00 sec)

ولكن ونظرًا لأن شرط البحث هذا يعيد دائمًا نتيجة "صحيحة"، فهو ليس مفيدًا بدرجة كبيرة. وبالتالي من الممكن في هذه الحالة عدم تضمين بنية WHERE أصلًا، لأن تعليمة SELECT name FROM volunteers; ستعطي نفس مجموعة النتائج كما في حالة استخدام WHERE مع شرط بحث مُحقق دومًا.

عادةً ما نستخدم اسم عمود كأحد تعبيري القيمة في شرط البحث ضمن بنية WHERE وذلك بدلاً من مقارنة قيمتين مُحددتي النوع كما في الأسلوب أعلاه. وبذلك نُعلم نظام إدارة قاعدة البيانات باستخدام قيمة كل سجل من العمود المحدد كجزء من تعبير القيمة للتكرار الخاص بكل سجل في شرط البحث.

تُطبّق بنية WHERE في الاستعلام التالي شرط بحث أكثر تحديدًا على كل سجل. إذ ستُرجع قيم كل من عمودي name و max_bags من أي سجل تساوي فيه قيمة max_bags الرقم 4:

mysql> SELECT name, max_bags
mysql> FROM volunteers
mysql> WHERE max_bags = 4;

يُرجع هذا الاستعلام سجل متطوع واحد فقط، نظرًا لأنّ قيمة max_bags لهذا المتطوع وحده تساوي 4 تمامًا، فيكون الخرج على النحو:

الخرج
+---------+----------+
| name    | max_bags |
+---------+----------+
| Juanita |        4 |
+---------+----------+
1 row in set (0.00 sec)

يمكنك أيضًا تقييم قيم السلاسل النصية المحرفية في التوابع الشرطية الخاصة بشروط البحث. فمثلًا يُرجع الاستعلام التالي قيم عمودي vol_id و name لكل سجل تكون قيمة العمود name فيه مساوية لـ 'Wanda':

mysql> SELECT vol_id, name
mysql> FROM volunteers
mysql> WHERE name = 'Wanda';

ونظرًا لوجود متطوعة واحدة فقط تُدعى Wanda، فإن الاستعلام يُرجع معلومات سجلها فقط:

الخرج
+--------+-------+
| vol_id | name  |
+--------+-------+
|      4 | Wanda |
+--------+-------+
1 row in set (0.00 sec)

من الجدير بالملاحظة أنّنا استخدمنا نفس العامل لشرط البحث في جميع أمثلة هذا القسم وهو علامة المساواة وذلك لتوضيح الفكرة. ولكن يوجد العديد من أنواع المعاملات Operators الأخرى التي تتيح لنا إمكانية كتابة مجموعة متنوعة من التوابع الشرطية، مما يوفر مستوى عالٍ من التحكم في المعلومات التي تُرجعها الاستعلامات.

يُحدّد معيار SQL ثمانية عشر نمطًا مختلفًا من التوابع الشرطية، وعلى الرغم من أنّها لا تتوفر كاملةً في كافّة أنظمة إدارة قواعد البيانات العلاقية RDBMS. إليك خمسة من أكثر أنواع توابع الشرط شيوعًا في شروط البحث والعوامل المستخدمة في كل منها:

المقارنة: تقارن التوابع الشرطية المقارنِة بين تعبيري قيمة، وفي معظم الاستعلامات يكون أحد هذين التعبيرين هو اسم عمود. وعوامل المقارنة الستة هي:

• = يختبر ما إذا كانت القيمتان متساويتين.
• <> يختبر ما إذا كانت القيمتان غير متساويتين.
• < يختبر ما إذا كانت القيمة الأولى أقل من الثانية.
• > يختبر ما إذا كانت القيمة الأولى أكبر من الثانية.
• <= يختبر ما إذا كانت القيمة الأولى أقل من أو تساوي الثانية.
• >= يختبر ما إذا كانت القيمة الأولى أكبر من أو تساوي الثانية.

القيم الفارغة: تختبر التوابع الشرطية التي تستخدم عامل IS NULL ما إذا كانت القيم في عمود معين فارغة.

النطاق: تستخدم التوابع الشرطية النطاقية عامل BETWEEN لاختبار ما إذا كان تعبير قيمة ما يقع بين تعبيري قيمة آخرين.

العضوية: يستخدم هذا النوع من التوابع الشرطية عامل IN لاختبار ما إذا كانت قيمة ما تُمثّل عضوًا في مجموعة معينة.

تطابق الأنماط: تستخدم توابع مطابقة الأنماط الشرطية عامل LIKE لاختبار ما إذا كانت قيمة ما تطابق نمطًا نصيًا يحتوي على محارف بدل.

لمعرفة المزيد حول هذه الأنواع من التوابع الشرطية، ننصحك بالاطلاع على المقالات التالية:

• كيفية استخدام عوامل المقارنة و IS NULL في لغة الاستعلام البنيوية SQL
• كيفية استخدام عوامل BETWEEN و IN في لغة الاستعلام البنيوية SQL
• كيفية استخدام محارف البدل في SQL
• وللاطلاع على المزيد حول بنى WHERE عمومًا، ننصحك بقراءة مقالنا حول كيفية استخدام بنى WHERE في لغة الاستعلام البنيوية SQL.

فرز نتائج الاستعلام باستخدام بنية ORDER BY

قد تُعيد الاستعلامات في بعض الأحيان المعلومات بطرق غير واضحة أو غير متوافقة تمامًا مع احتياجاتك. لذا يمكنك فرز أو ترتيب نتائج الاستعلام بتضمين بنية ORDER BY في نهاية تعليمة الاستعلام.

فيما يلي الصيغة العامّة لاستعلام يتضمن بنية ORDER BY:

mysql> SELECT columns_to_return
mysql> FROM table_to_query
mysql> ORDER BY column_name;

لتوضيح الأمر، بفرض أننا نرغب في معرفة أي من المتطوعين يحقق أعلى قيمة في عمود max_bags. لنُنفّذ الاستعلام التالي الذي يُعيد قيم عمودي name وmax_bags من جدول volunteers:

$ SELECT name, max_bags
$ FROM volunteers;

ولكن يفرز هذا الاستعلام مجموعة النتائج حسب الترتيب الذي أُضيف فيه كل سجل.

الخرج
+------------+----------+
| name       | max_bags |
+------------+----------+
| Gladys     |        5 |
| Catherine  |        2 |
| Georgeanna |        1 |
| Wanda      |        1 |
| Ann        |        7 |
| Juanita    |        4 |
| Georgia    |        3 |
+------------+----------+
7 rows in set (0.00 sec)

ولعلّ فرز مجموعة بيانات صغيرة نسبيًا كهذه ليس بتلك الأهمية، إذ يمكننا ببساطة مراجعة قيم max_bags في مجموعة النتائج لإيجاد القيمة الأعلى لكن هذا الأمر قد يصبح متعبًا عند العمل مع كميات أكبر من البيانات.

يمكننا تنفيذ الاستعلام ذاته ولكن مع إضافة بنية ORDER BY التي تفرز مجموعة النتائج تبعًا لقيم max_bags للسجلات:

$ SELECT name, max_bags
$ FROM volunteers
$ ORDER BY max_bags;

الخرج
+------------+----------+
| name       | max_bags |
+------------+----------+
| Georgeanna |        1 |
| Wanda      |        1 |
| Catherine  |        2 |
| Georgia    |        3 |
| Juanita    |        4 |
| Gladys     |        5 |
| Ann        |        7 |
+------------+----------+
7 rows in set (0.00 sec)

كما يُظهر هذا الخرج، فالسلوك الافتراضي لاستعلامات SQL التي تتضمن بنية ORDER BY هو فرز قيم العمود المحدد تصاعديًا (من الأصغر إلى الأكبر). ويمكننا تغيير هذا السلوك وفرزها بترتيب تنازلي عن طريق إضافة الكلمة المفتاحية DESC إلى بنية ORDER BY.

$ SELECT name, max_bags
$ FROM volunteers
$ ORDER BY max_bags DESC;

الخرج
+------------+----------+
| name       | max_bags |
+------------+----------+
| Ann        |        7 |
| Gladys     |        5 |
| Juanita    |        4 |
| Georgia    |        3 |
| Catherine  |        2 |
| Georgeanna |        1 |
| Wanda      |        1 |
+------------+----------+
7 rows in set (0.00 sec)

الخلاصة

باطلاعك على هذا المقال، اكتسبت المعرفة حول كيفية كتابة استعلامات أساسية، وكيفية تصفية وفرز مجموعات نتائج الاستعلام، ومن المفترض أن تعمل الأوامر المشروحة في هذا المقال مع أي نظام لإدارة قواعد البيانات يستخدم SQL، لكن تذكر أن لكل قاعدة بيانات SQL تقديمها الخاص للغة، لذا ينبغي مراجعة التوثيق الرسمي لنظام إدارة قواعد البيانات الخاص بك للحصول على وصف أكثر تفصيلاً لكل أمر فيها ومجموعة خياراته الكاملة.

وللمزيد حول SQL، نشجعك على متابعة المقالات المنشورة تحت وسم سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To SELECT Rows FROM Tables in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: كيفية حذف البيانات في لغة الاستعلام البنيوية SQL
• أنواع قواعد البيانات وأهم مميزاتها واستخداماتها
• تعرف على مكونات قاعدة البيانات
• ما هي محركات قواعد البيانات؟
• فهم قواعد البيانات العلاقية

سنتعرف في مقال اليوم على تعليمة DELETE في لغة الاستعلام البنيوية SQL واحدة من أقوى العمليات المتاحة للمستخدمين. وهي كما يوحي اسمها، تحذف سجلًا أو أكثر من جدول قاعدة البيانات على نحوٍ لا يمكن التراجع عنه. ومن المهم لمستخدمي SQL فهم كيف تعمل تعليمة DELETE باعتبارها جانبًا أساسيًا من إدارة البيانات.

سيغطي المقال كيفية استخدام صيغة DELETE في SQL لحذف البيانات من جدول واحد أو أكثر. كما سيشرح كيف تتعامل SQL مع عمليات الحذف التي قد تتعارض مع قيود المفتاح الخارجي Foreign key.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز حاسوب يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العلاقية RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، ويمكنك إعداد الخادم بالاستعانة بمقال كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• MySQL مثبتة ومؤمنة على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، مُنشأ وفق الطريقة الموضحة في الخطوة 3 من هذا المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقية لها تقديماتها الفريدة من لغة SQL. فبالرغم من كون الأوامر المُقدمة في هذا المقال ستعمل مع معظم هذه الأنظمة، ولكن قد تجد بعض الاختلافات في الصيغة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، ستحتاج أيضًا إلى قاعدة بيانات وجدول مُحمّل ببعض البيانات التجريبية النموذجية لتتمكن من التدرب على حذف البيانات. لذا ننصحك بقراءة الفقرة التالية الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية للمزيد من التفاصيل حول كيفية إعداد قاعدة بيانات وجدول لاستخدامهما في الأمثلة خلال هذا المقال.

الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم عن بُعد، اتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو:

$ ssh ssh user@your_server_ip

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

أنشئ قاعدة بيانات باسمdeleteDB:

mysql> CREATE DATABASE deleteDB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات deleteDB، نفّذ تعليمة USE التالية:

mysql> USE deleteDB;

الخرج
Database changed

بعد اختيار قاعدة البيانات deleteDB، أنشئ جدولين داخلها. كمثال، تخيل أنك وبعض أصدقائك تملكون ناديًا حيث يمكن للأعضاء مشاركة المعدات الموسيقية مع بعضهم البعض. فقررت إنشاء بعض الجداول لتساعدك في تتبع أعضاء النادي ومعداتهم. سيتضمّن الجدول الأول الأعمدة الأربعة التالية:

• memberID: مُعرّف كل عضو في النادي، مُعبّر عنه بنمط بيانات الأعداد الصحيحة int. سيكون هذا العمود هو المفتاح الأساسي للجدول.
• name: اسم كل عضو، مُعبّر عنه بنمط بيانات المحارف varchar مع حد أقصى يصل إلى 30 محرفًا.
• homeBorough: هذا العمود سيخزن المنطقة التي يعيش فيها كل عضو، مُعبر عنه بنمط البيانات varchar ولكن بحد أقصى يصل إلى 15 محرفًا فقط.
• email: عنوان البريد الإلكتروني الذي يمكن من خلاله الاتصال بكل عضو، مُعبر عنه بنمط البيانات varchar مع حد أقصى يصل إلى 30 محرفًا.

لننشئ إذًا جدولًا باسم clubMembers يحتوي على هذه الأعمدة الأربعة.

mysql> CREATE TABLE clubMembers (
mysql> memberID int PRIMARY KEY,
mysql> name varchar(30),
mysql> homeBorough varchar(15),
mysql> email varchar(30)
mysql> );

أمّا الجدول الثاني فسيتضمّن الأعمدة التالية:

• equipmentID: معرّف فريد لكل قطعة من المعدات. إذ ستكون القيم في هذا العمود من نمط بيانات الأعداد الصحيحة int. وسيكون هذا العمود هو المفتاح الأساسي للجدول على نحوٍ مشابه لعمود memberID في جدول clubMembers،
• equipmentType: نوع الآلة أو الأداة التي يُمثّلها كل سجل (على سبيل المثال الغيتار guitar ومازج الأصوات mixer ومضخّم الصوتamplifier وما إلى ذلك). سنعبّر عن هذه القيم باستخدام نمط البيانات varchar مع حد أقصى يصل إلى 30 محرفًا.
• brand: العلامة التجارية التي أنتجت كل قطعة من المعدات، معبّر عنها أيضًا بنمط البيانات varchar مع حد أقصى يصل إلى 30 محرفًا.
• ownerID: هذا العمود سيحتوي على معرّف العضو المالك للقطعة نت المعدات، مُعبر عنه برقم صحيح.

ولضمان أنّ عمود ownerID لن يتضمّن سوى قيم تُمثّل مُعرّفات أعضاء صالحة، يمكنك إنشاء قيد مفتاح خارجي عليه بحيث يُشير إلى عمود memberID في جدول clubMembers. يُعد قيد المفتاح الخارجي طريقة لتحديد علاقة بين جدولين، إذ يفرض أن تكون القيم في العمود المُطبّق عليه موجودة بالفعل في العمود المُشار إليه. في المثال التالي، يشترط قيد المفتاح الخارجي أن تكون كل قيمة تُضاف إلى عمود ownerID موجودة مسبقًا في عمود memberID.

أنشئ جدولًا بهذه الأعمدة وهذا القيد باسم clubEquipment:

mysql> CREATE TABLE clubEquipment (
mysql> equipmentID int PRIMARY KEY,
mysql> equipmentType varchar(30),
mysql> brand varchar(15),
mysql> ownerID int,
mysql> CONSTRAINT fk_ownerID
mysql> FOREIGN KEY (ownerID) REFERENCES clubMembers(memberID)
mysql> );

ومن الجدير بالملاحظة أنّ هذا المثال يوفّر اسمًا لقيد المفتاح الخارجي، ألا وهو: fk_ownerID.

إذ تُنشئ MySQL تلقائيًا اسمًا لأي قيد تضيفه، إلّا أنّ تحديد اسم من قبلنا في هذه الحالة سيكون مفيدًا عندما نحتاج للإشارة إلى هذا القيد لاحقًا.

بعد ذلك، نفّذ تعليمة INSERT INTO التالية لملء جدول clubMembers بستة سجلات من البيانات النموذجية:

mysql> INSERT INTO clubMembers
mysql> VALUES
mysql> (1, 'Rosetta', 'Manhattan', 'hightower@example.com'),
mysql> (2, 'Linda', 'Staten Island', 'lyndell@example.com'),
mysql> (3, 'Labi', 'Brooklyn', 'siffre@example.com'),
mysql> (4, 'Bettye', 'Queens', 'lavette@example.com'),
mysql> (5, 'Phoebe', 'Bronx', 'snow@example.com'),
mysql> (6, 'Mariya', 'Brooklyn', 'takeuchi@example.com');

ثم نفّذ تعليمة INSERT INTO أخرى لملء جدول clubEquipment بعشرين سجلًا من البيانات النموذجية:

mysql> INSERT INTO clubEquipment
mysql> VALUES
mysql> (1, 'electric guitar', 'Gilled', 6),
mysql> (2, 'trumpet', 'Yemehe', 5),
mysql> (3, 'drum kit', 'Purl', 3),
mysql> (4, 'mixer', 'Bearinger', 3),
mysql> (5, 'microphone', 'Sure', 1),
mysql> (6, 'bass guitar', 'Fandar', 4),
mysql> (7, 'acoustic guitar', 'Marten', 6),
mysql> (8, 'synthesizer', 'Korgi', 4),
mysql> (9, 'guitar amplifier', 'Vax', 4),
mysql> (10, 'keytar', 'Poland', 3),
mysql> (11, 'acoustic/electric bass', 'Pepiphone', 2),
mysql> (12, 'trombone', 'Cann', 2),
mysql> (13, 'mandolin', 'Rouge', 1),
mysql> (14, 'electric guitar', 'Vax', 6),
mysql> (15, 'accordion', 'Nonher', 5),
mysql> (16, 'electric organ', 'Spammond', 1),
mysql> (17, 'bass guitar', 'Peabey', 1),
mysql> (18, 'guitar amplifier', 'Fandar', 3),
mysql> (19, 'cello', 'Yemehe', 2),
mysql> (20, 'PA system', 'Mockville', 5);

وبذلك، غدوتَ جاهزًا لمتابعة باقي المقال وبدء التعلم حول كيفية حذف البيانات باستخدام لغة الاستعلام البنيوية SQL.

حذف البيانات من جدول واحد

إنّ الصيغة العامة لحذف البيانات في SQL على النحو:

mysql> DELETE FROM table_name
mysql> WHERE conditions_apply;

تحذير: الجزء المهم من هذه الصيغة هو البنية WHERE فمن خلالها يمكنك تحديد السجلات التي يجب حذفها بدقة. وبدونها، سيُنفَّذ أمر مثل DELETE FROM table_name; على نحوٍ صحيح، ولكنه سيحذف كل سجلات البيانات من الجدول!

وبالعودة إلى موضوعنا، تذكّر أنّ أي عملية حذف ناجحة لا يمكن التراجع عنها. فإذا نفذّت عملية حذف دون معرفة دقيقة بالبيانات التي ستُحذف، فقد تحذف سجلات عن طريق الخطأ. ومن الطرق التي تفيدك في التأكد من عدم حذف بيانات عن طريق الخطأ هي إجراء استعلام عن البيانات المحددة للحذف باستخدام SELECT لرؤية البيانات التي ستعيدها بنية WHERE ضمن عملية الحذف DELETE من البداية قبل تنفيذ عملية الحذف.

ولتوضيح الأمر، لنفترض أنّك تريد إزالة أي سجلات مُتعلقة بمعدات الموسيقى المصنعة من قبل العلامة التجارية Korgi. ولكنك قررت البدء بكتابة استعلام لرؤية كافة سجلات الآلات المُتضمنة لعلامة korgi تحديدًا في عمود brand.

لمعرفة الآلات الموسيقية في جدولك المُصنّعة من قبل Korgi، يمكنك تنفيذ الاستعلام المبيّن أدناه. ومن الجدير بالملاحظة أنّه وعلى العكس من الاستعلام باستخدام SELECT أو عملية INSERT INTO، فلا تسمح عمليات الحذف بتحديد أعمدة فردية، لأنها مُخصصّة لحذف سجلات البيانات بالكامل.

ولمحاكاة هذا السلوك، أتبعنا الكلمة المفتاحية SELECT بعلامة النجمة (*) في الاستعلام التالي والتي تعدّ اختصارًا في SQL يمثل "كل الأعمدة":

mysql> SELECT * FROM clubEquipment
mysql> WHERE brand = 'Korgi';

الخرج
+-------------+---------------+-------+---------+
| equipmentID | equipmentType | brand | ownerID |
+-------------+---------------+-------+---------+
|           8 | synthesizer   | Korgi |       4 |
+-------------+---------------+-------+---------+
1 row in set (0.00 sec)

ولحذف هذا السجل، عليك تنفيذ عملية حذف DELETE تحتوي على بنيتي FROM وWHERE مطابقتين لاستعلام SELECT السابق، على النحو:

mysql> DELETE FROM clubEquipment
mysql> WHERE brand = 'Korgi';

الخرج
Query OK, 1 row affected (0.01 sec)

يُظهر هذا الخرج أن عملية الحذف DELETE قد نُفِّذت على سجل واحد فقط. ولكن بإمكانك حذف عدة سجلات باستخدام بنية WHERE تُعيد أكثر من سجل واحد.

أمّا استعلام SELECT التالي فيعيد كافّة السجلات في جدول clubEquipment التي يتضمن عمود equipmentType فيها كلمة electric:

mysql> SELECT * FROM clubEquipment
mysql> WHERE equipmentType LIKE '%electric%';

الخرج
+-------------+------------------------+-----------+---------+
| equipmentID | equipmentType          | brand     | ownerID |
+-------------+------------------------+-----------+---------+
|           1 | electric guitar        | Gilled    |       6 |
|          11 | acoustic/electric bass | Pepiphone |       2 |
|          14 | electric guitar        | Vax       |       6 |
|          16 | electric organ         | Spammond  |       1 |
+-------------+------------------------+-----------+---------+
4 rows in set (0.00 sec)

ولحذف هذه السجلات الأربعة، لنعد كتابة الاستعلام السابق مستبدلين SELECT * بتعليمة DELETE:

mysql> DELETE FROM clubEquipment
mysql> WHERE equipmentType LIKE '%electric%';

الخرج
Query OK, 4 rows affected (0.00 sec)

كما من الممكن استخدام الاستعلامات الفرعية Subqueries لإعادة وحذف مجموعات نتائج أكثر تفصيلاً. ويُعرّف الاستعلام الفرعي بأنّه عملية استعلام كاملة - تعليمة SQL تبدأ بـ SELECT وتتضمن بنية FROM- مُضمنة ضمن عملية أخرى، تأتي عقب بنية FROM الخاصة بالعملية المحيطة (الاستعلام الرئيسي).

على سبيل المثال، لنفترض أنك ترغب في حذف أي معدات مُدرجة في جدول clubEquipment تخص أي عضو يبدأ اسمه بالحرف "L". يمكنك أولاً الاستعلام عن هذه البيانات باستخدام تعليمة SELECT كالتالي:

mysql> SELECT *
mysql> FROM clubEquipment
mysql> WHERE ownerID IN
mysql> (SELECT memberID FROM clubMembers
mysql> WHERE name LIKE 'L%');

تُعيد هذه العملية كل سجل من جدول clubEquipment تظهر قيمة عمود ownerID الخاصة به ضمن القيم المُعادة من الاستعلام الفرعي الذي يبدأ في السطر الرابع. إذ يُعيد هذا الاستعلام الفرعي مُعرّف العضو memberID لأي سجل تبدأ قيمة العمود name الموافقة له بالحرف "L":

الخرج
+-------------+------------------+-----------+---------+
| equipmentID | equipmentType    | brand     | ownerID |
+-------------+------------------+-----------+---------+
|          12 | trombone         | Cann      |       2 |
|          19 | cello            | Yemehe    |       2 |
|           3 | drum kit         | Purl      |       3 |
|           4 | mixer            | Bearinger |       3 |
|          10 | keytar           | Poland    |       3 |
|          18 | guitar amplifier | Fandar    |       3 |
+-------------+------------------+-----------+---------+
6 rows in set (0.00 sec)

يمكنك بعد ذلك حذف هذه البيانات باستخدام تعليمة DELETE التالية:

mysql> DELETE FROM clubEquipment
mysql> WHERE ownerID IN
mysql> (SELECT memberID FROM clubMembers
mysql> WHERE name LIKE 'L%');

الخرج
Query OK, 6 rows affected (0.01 sec)

حذف البيانات من عدة جداول

يمكنك حذف البيانات من أكثر من جدول في عملية واحدة عن طريق تضمين بنية JOIN.

تُستخدم بنى JOIN لدمج السجلات من جدولين أو أكثر في نتيجة استعلام واحد. يتم ذلك عن طريق إيجاد عمود مشترك بين الجداول وفرز النتائج على نحوٍ مناسب في الخرج.

تبدو صيغة عملية الحذف التي تتضمن بنية JOIN على النحو التالي:

mysql> DELETE table_1, table_2
mysql> FROM table_1 JOIN table_2
mysql> ON table_2.related_column = table_1.related_column
mysql> WHERE conditions_apply;

لاحظ أنه نظرًا لقدرة صيغ الدمج JOIN على مقارنة البيانات من عدة جداول، فإن صيغة هذا المثال تُوضّح الجدول المُستهدف لكل عمود بوضع اسم الجدول متبوعًا بنقطة قبل اسم العمود، وهذا ما يُعرف بالإشارة الكاملة والمؤهلة للعمود. ويُمكنك تحديد الجدول المصدر لكل عمود بهذه الطريقة في أي عملية، على الرغم من عدم ضرورتها عند الاختيار من جدول واحد فقط كما فعلنا في الأمثلة السابقة.

لتوضيح مفهوم حذف البيانات باستخدام بنية JOIN، لنفترض أن ناديك قرر تحديد العلامات التجارية للمعدات الموسيقية التي يمكن للأعضاء مشاركتها. نفّذ الأمر التالي لإنشاء جدول باسم prohibitedBrands حيث ستسرد العلامات التجارية التي لم تعد مقبولة في النادي. يحتوي هذا الجدول على عمودين فقط، كلاهما يستخدم نمط بيانات varchar، لتخزين اسم كل علامة تجارية والبلد الذي تعمل فيه:

mysql> CREATE TABLE prohibitedBrands (
mysql> brandName varchar(30),
mysql> homeCountry varchar(30)
mysql> );

ثم املأ هذا الجدول الجديد ببعض البيانات النموذجية التجريبية:

mysql> INSERT INTO prohibitedBrands
mysql> VALUES 
mysql> ('Fandar', 'USA'),
mysql> ('Givson', 'USA'),
mysql> ('Muug', 'USA'),
mysql> ('Peabey', 'USA'),
mysql> ('Yemehe', 'Japan');

بعد ذلك، يقرر النادي حذف أي سجلات للمعدات من جدول clubEquipment التي تظهر علاماتها التجارية في جدول prohibitedBrands ومقرها في الولايات المتحدة.

يمكنك الاستعلام عن هذه البيانات بتنفيذ عملية استعلام مثل التالية باستخدام SELECT. إذ تدمج هذه العملية جدولي clubEquipment وprohibitedBrands معًا، وتُرجع فقط السجلات التي تشترك فيها أعمدة brand وbrandName في نفس القيمة. وتعمل بنية WHERE على إتمام تحديد نتائج الاستعلام بإقصاء أي علامة تجارية لا تتضمن القيمة "USA" في عمود homeCountry:

mysql> SELECT * 
mysql> FROM clubEquipment JOIN prohibitedBrands
mysql> ON clubEquipment.brand = prohibitedBrands.brandName
mysql> WHERE homeCountry = 'USA';

الخرج
+-------------+---------------+--------+---------+-----------+-------------+
| equipmentID | equipmentType | brand  | ownerID | brandName | homeCountry |
+-------------+---------------+--------+---------+-----------+-------------+
|           6 | bass guitar   | Fandar |       4 | Fandar    | USA         |
|          17 | bass guitar   | Peabey |       1 | Peabey    | USA         |
+-------------+---------------+--------+---------+-----------+-------------+
2 rows in set (0.00 sec)

هذه هي كل المعلومات التي نبحث عنها؛ وهي كل علامة تجارية مقرها الولايات المتحدة والموجودة في جدول prohibitedBrands والتي تظهر أيضًا في جدول clubEquipment.

لحذف هذه العلامات التجارية من جدول prohibitedBrands والمعدات المرتبطة بها من جدول clubEquipment، أعد كتابة استعلام SELECT السابق ولكن استبدل تعليمة SELECT * بتعليمة DELETE متبوعةً بأسماء كلا الجدولين:

mysql> DELETE clubEquipment, prohibitedBrands
mysql> FROM clubEquipment JOIN prohibitedBrands
mysql> ON clubEquipment.brand = prohibitedBrands.brandName
mysql> WHERE homeCountry = 'USA';

الخرج
Query OK, 4 rows affected (0.01 sec)

يشير هذا الخرج إلى أن العملية حذفت أربع سجلات من قاعدة البيانات: سجلين من جدول clubEquipment وسجلين من جدول prohibitedBrands. إذا كنت تريد حذف السجلات من جدول clubEquipment فقط والاحتفاظ بجميع السجلات في جدول prohibitedBrands، فعليك إدراج clubEquipment فقط بعد كلمة DELETE، والعكس صحيح.

تغيير سلوك تعليمة DELETE للمفاتيح الخارجية

ستفشل أي تعليمة DELETE قد تسبب تعارضًا مع قيد FOREIGN KEY افتراضيًا.

بالعودة إلى فقرة الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية في مستلزمات العمل وبتذكّر أنّ العمود ownerID في جدول المعدات clubEquipment هو مفتاح خارجي يشير إلى عمود memberID في جدول الأعضاء clubMembers. فهذا يعني أنّ أي قيمة مُدخلة في عمود ownerID يجب أن تكون موجودة بالفعل في جدول memberID.

إذا حاولت إزالة سجل من جدول clubMembers تُستخدم قيمة memberID المُخصصة له في مكان ما ضمن عمود ownerID من جدول clubEquipment، سيؤدي ذلك إلى ظهور خطأ.

mysql> DELETE FROM clubMembers
mysql> WHERE memberID = 6;

الخرج
ERROR 1217 (23000): Cannot delete or update a parent row: a foreign key constraint fails

يمكنك تجنب هذا الخطأ بإزالة أي سجلات في الجدول الابن (clubEquipment في هذا المثال) حيث توجد قيمة المفتاح الخارجي في الجدول الأب (clubMembers). كبديل، يمكنك تغيير هذا السلوك بتعديل قيد المفتاح الخارجي القائم بآخر يعالج عمليات الحذف على نحوٍ مختلف.

ملاحظة: لا تسمح كافة أنظمة إدارة قواعد البيانات العلاقية أو محركاتها بإضافة أو إزالة قيود من جدول قائم كما هو موضح في الفقرات اللاحقة. فإذا كنت تستخدم نظام RDBMS غير MySQL، يجب عليك مراجعة الوثائق الرسمية الخاصة به لفهم القيود المتعلقة بإدارة القيود.

وبالعودة إلى موضوعنا، بذلك ستكون قادرًا على تحديث قيمة clientID لأي سجل في الجدول الأب clubMembers، وستنتقل هذه التغييرات بشكل تلقائي إلى أي سجلات في الجدول الابن clubEquipment المرتبطة به. لاستبدال القيد الحالي، يجب أولًا إزالته باستخدام تعليمة ALTER TABLE. تذكر أننا في تعليمة CREATE TABLE لجدول clubEquipment، قمنا بتحديد fk_ownerID كاسم لقيد المفتاح الخارجي للجدول.

mysql> ALTER TABLE clubEquipment
mysql> DROP FOREIGN KEY fk_ownerID;

الخرج
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

بعد ذلك، أنشئ قيد مفتاح خارجي جديد مُعدّ ليتعامل مع عمليات الحذف DELETE بطريقة تتناسب مع حالة الاستخدام المعطاة. بصرف النظر عن الإعداد الافتراضي الذي يمنع تعليمات DELETE التي تخالف المفتاح الخارجي، هناك خياران آخران متاحان في معظم أنظمة إدارة قواعد البيانات العلاقية:

• ON DELETE SET NULL: يسمح لك هذا الخيار بحذف السجلات من الجدول الأب، وسيعيد تعيين أي قيم مرتبطة بها في الجدول الابن على أنها قيم فارغة NULL.
• ON DELETE CASCADE: عند حذف سجل في الجدول الأب، سيدفع هذا الخيار SQL لحذف أي سجلات في الجدول الابن مرتبطة بذلك السجل من الجدول الأب.

في سياق هذا المثال، لا يُعد استخدام خيار ON DELETE SET NULL منطقيًا. فإذا غادر أحد الأعضاء النادي وحُذِف سجله من جدول clubMembers، فلن تكون معداته متاحة للأعضاء المتبقين بعد الآن وبالتالي يجب إزالتها من جدول clubEquipment. وفي هذا الصدد يُعدّ خيار ON DELETE CASCADE هو الأنسب لهذا السياق.

لإضافة قيد FOREIGN KEY يعمل وفق آلية ON DELETE CASCADE، نفّذ أمر ALTER TABLE التالي لتعديل الجدول. ستنشئ هذه التعليمة قيدًا جديدًا باسم newfk_ownerID يعكس تعريف القيد السابق ولكن مع إضافة خيار ON DELETE CASCADE.

mysql> ALTER TABLE clubEquipment
mysql> ADD CONSTRAINT newfk_ownerID
mysql> FOREIGN KEY (ownerID)
mysql> REFERENCES clubMembers(memberID)
mysql> ON DELETE CASCADE;

الخرج
Query OK, 7 rows affected (0.07 sec)
Records: 7  Duplicates: 0  Warnings: 0

تشير هذه النتائج إلى أن العملية قد أثرت على جميع السجلات السبعة المتبقية في جدول clubEquipment.

ملاحظة: بدلًا من تغيير تعريف جدول مُعرّف مسبقًا لتعديل كيفية تفاعل قيد المفتاح الخارجي مع عمليات DELETE، يُمكنك من البداية تحديد هذا السلوك عند إنشاء الجدول بواسطة تعليمة إنشاء الجدول CREATE TABLE ، وبذلك تُعيّن السلوك المطلوب مُسبقًا، على النحو التالي:

mysql> CREATE TABLE clubEquipment (
mysql> equipmentID int PRIMARY KEY,
mysql> equipmentType varchar(30),
mysql> brand varchar(15),
mysql> ownerID int,
mysql> CONSTRAINT fk_ownerID
mysql> FOREIGN KEY (ownerID) REFERENCES clubMembers(memberID)
mysql> ON DELETE CASCADE
mysql> );

عقب ذلك، ستكون قادرًا على حذف أي سجل من جدول clubMembers، وستُحذف جميع السجلات المرتبطة به في جدول clubEquipment تلقائيًا:

mysql> DELETE FROM clubMembers
mysql> WHERE memberID = 6;

الخرج
Query OK, 1 row affected (0.00 sec)

رغم أن هذا الخرج يشير إلى تأثر سجل واحد فقط، إلا أنّ العملية قد حذفت أيضًا كافة سجلات المعدات في جدول clubEquipment ذات القيمة 6 في عمود ownerID.

الخلاصة

باطلاعك على هذا المقال، اكتسبت المعرفة حول كيفية حذف البيانات الموجودة في جدول واحد أو أكثر باستخدام تعليمة DELETE في SQL. كما تعرفت على كيفية تعامل SQL مع عمليات الحذف التي تتعارض مع قيود المفتاح الخارجي وطرق تغيير هذا السلوك الافتراضي.

ومن المفترض أن تعمل الأوامر المشروحة في هذا المقال مع أي نظام لإدارة قواعد البيانات يستخدم SQL. لكن تذكر أن لكل قاعدة بيانات SQL تقديمها الخاص للغة، لذا ينبغي مراجعة التوثيق الرسمي لنظام إدارة قواعد البيانات الخاص بك للحصول على وصف أكثر تفصيلاً لكيفية التعامل مع عمليات الحذف والخيارات المتاحة لها.

وللمزيد حول SQL، نشجعك على متابعة المقالات المنشورة تحت وسم سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To Delete Data in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: كيفية تحديث البيانات في لغة الاستعلام البنيوية SQL
• ما هي تقنية SQL
• تنظيم شيفرات SQL وتأمينها
• تصميم الجداول ومعلومات المخطط وترتيب تنفيذ الاستعلامات في SQL

لدى التعامل مع قاعدة بيانات، قد تضطر أحيانًا لتعديل بيانات كانت مدرجة من قبل في جدول أو أكثر. كأن تُضطر مثلًا لتصحيح خطأ إملائي في إدخال معين أو إضافة معلومات جديدة إلى سجل غير مكتمل. وتوفّر لغة الاستعلام البنيوية المعروفة بـ SQL الكلمة المفتاحية UPDATE، التي تُمكّن المستخدمين من تعديل البيانات الموجودة في جدول ما.

يشرح هذا المقال كيفية استعمال الصيغة UPDATE في SQL لتعديل البيانات في جدول واحد أو عدة جداول مرتبطة ببعضها. كما يتناول الطريقة التي تتعامل بها SQL مع عمليات UPDATE التي قد تتعارض مع قيود المفتاح الخارجي.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز حاسوب يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العلاقية RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، ويمكنك إعداد الخادم بالاستعانة بمقالنا  كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• MySQL مثبتة ومؤمنة على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، ومُنشأ وفق الطريقة الموضحة في الخطوة 3 من هذا المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقية لها تقديماتها الفريدة من لغة SQL. فبالرغم من كون الأوامر المُقدمة في هذا المقال ستعمل مع معظم هذه الأنظمة، ولكن قد تجد بعض الاختلافات في الصيغة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، ستحتاج أيضًا إلى قاعدة بيانات مع بعض الجداول المُحمّلة ببعض البيانات التجريبية النموذجية لتتمكن من التدرب على تحديث بيانات SQL. وإذا لم تكن متوفرة لديك، يمكنك مراجعة مقال الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية للمزيد من التفاصيل حول كيفية الاتصال بخادم MySQL وإنشاء قاعدة البيانات التجريبية المُستخدمة في أمثلة هذا المقال.

الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم عن بُعد، اتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو:

$ ssh user@your_server_ip

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

أنشئ قاعدة بيانات باسم updateDB:

mysql> CREATE DATABASE updateDB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات updateDB، نفّذ تعليمة USE التالية:

mysql> USE updateDB;

الخرج
Database changed

وبعد اختيارك لقاعدة البيانات updateDB، أنشئ بعض الجداول ضمنها. ولتوضيح الأمثلة في هذا المقال، تخيّل أنّك تدير وكالة مواهب، وقد قررت تتبّع عملائك وأدائهم عبر قاعدة بيانات SQL، وبأنّك تعتزم البدء بجدولين: الجدول الأوّل لتخزين معلومات عن عملائك. وقد حددت أنّ هذا الجدول يحتاج إلى أربعة أعمدة:

• clientID: مُعرّف كل عميل، مُعبرًا عنه بنمط بيانات الأعداد الصحيحة int، كما سيُمثّل هذا العمود المفتاح الرئيسي للجدول، بحيث تمثل كل قيمة منه دور المُعرف الفريد للسجل المُرتبط بها.
• name: اسم كل عميل، مُعبرًا عنه بنمط بيانات varchar بحد أقصى 20 محرفًا.
• routine: وصف مُختصر لنوع الأداء الرئيسي لكل عميل، مُعبرًا عنه بنمط بيانات varchar بحد أقصى 30 محرفًا.
• performanceFee: عمود لتسجيل رسوم الأداء القياسية لكل عميل، يستخدم نمط البيانات decimal وتُحدد القيم في هذا العمود بحد أقصى قدره خمسة أرقام، بواقع رقمين على يمين الفاصلة العشرية. وبالتالي، تتراوح القيم المسموح بها من -999.99 إلى 999.99.

أنشئ جدولًا باسم clients يشمل هذه الأعمدة الأربعة:

mysql> CREATE TABLE clients
mysql> (clientID int PRIMARY KEY,
mysql> name varchar(20),
mysql> routine varchar(30),
mysql> standardFee decimal (5,2)
mysql> );

أمّا الجدول الثاني فسيكون مخصصًا لتخزين بيانات حول أداء عملائك في مكان عرض محدد محليًا. وبفرض أنك ارتأيت بأنّ هذا الجدول يتطلّب خمسة أعمدة:

• showID: بمثابة عمود clientID، إذ سيحتفظ هذا العمود بمُعرّف فريد لكل عرض، مُعبرًا عنه بنمط بيانات الأعداد الصحيحة int. كما سيمُثّل هذا العمود المفتاح الرئيسي لجدول العروض shows.
• showDate: تاريخ كل عرض. يُعبر عن قيم هذا العمود باستخدام نمط بيانات التواريخ date الذي يستخدم الصيغة YYYY-MM-DD (خانتين لليوم وخانتين للشهر وأربع خانات للسنة).
• clientID: مُعرّف العميل الذي يؤدي في العرض، مُعبرًا عنه كعدد صحيح.
• attendance: عدد الحضور في كل عرض، مُعبرًا عنه كعدد صحيح.
• ticketPrice:سعر تذكرة الدخول لكل عرض. يستخدم هذا العمود نمط البيانات decimal وتُحدد القيم في هذا العمود بحد أقصى قدره خمسة أرقام، بواقع رقمين على يمين الفاصلة العشرية. وبالتالي، تتراوح القيم المسموح بها من- 999.99 إلى 999.99.

ولضمان أنّ عمود clientID لن يتضمّن سوى قيم تُمثّل مُعرّفات عملاء صالحة، قررتَ تطبيق قيد مفتاح خارجي عليه بحيث يُشير إلى عمود clientID في جدول clients. يُعد قيد المفتاح الخارجي طريقة لتحديد علاقة بين جدولين، إذ يفرض أن تكون القيم في العمود المُطبّق عليه موجودة بالفعل في العمود المُشار إليه. في المثال القادم، يشترط قيد FOREIGN KEY أن تكون كل قيمة تُضاف إلى عمود clientID في جدول shows مُسجلة مسبقًا في عمود clientID بجدول clients.

أنشئ جدولًا باسم clients يتضمن هذه الأعمدة الخمسة:

mysql> CREATE TABLE shows
mysql> (showID int PRIMARY KEY,
mysql> showDate date,
mysql> clientID int,
mysql> attendance int,
mysql> ticketPrice decimal (4,2),
mysql> CONSTRAINT client_fk
mysql> FOREIGN KEY (clientID)
mysql> REFERENCES clients(clientID)
mysql> );

ومن الجدير بالملاحظة أنّ هذا المثال يوفّر اسمًا لقيد المفتاح الخارجي، ألا وهو: client_fk. إذ تُنشئ MySQL تلقائيًا اسمًا لأي قيد تضيفه، إلّا أنّ تحديد اسم من قبلنا في هذه الحالة سيكون مفيدًا عندما نحتاج للإشارة إلى هذا القيد لاحقًا.

بعد ذلك، نفّذ تعليمة INSERT INTO التالية لملء جدول العملاء clients بخمسة سجلات من البيانات النموذجية:

mysql> INSERT INTO clients
mysql> VALUES
mysql> (1, 'Fares', 'song and dance', 180),
mysql> (2, 'Camal', 'standup', 99.99),
mysql> (3, 'Karam', 'standup', 45),
mysql> (4, 'Wael', 'song and dance', 200),
mysql> (5, 'Ahmad', 'trained squirrel', 79.99);

ثم نفّذ تعليمة INSERT INTO أخرى لملء جدول shows بعشرة سجلات من البيانات النموذجية:

mysql> INSERT INTO shows
mysql> VALUES
mysql> (1, '2019-12-25', 4, 124, 15),
mysql> (2, '2020-01-11', 5, 84, 29.50),
mysql> (3, '2020-01-17', 3, 170, 12.99),
mysql> (4, '2020-01-31', 5, 234, 14.99),
mysql> (5, '2020-02-08', 1, 86, 25),
mysql> (6, '2020-02-14', 3, 102, 39.5),
mysql> (7, '2020-02-15', 2, 101, 26.50),
mysql> (8, '2020-02-27', 2, 186, 19.99),
mysql> (9, '2020-03-06', 4, 202, 30),
mysql> (10, '2020-03-07', 5, 250, 8.99);

وبذلك، غدوتَ جاهزًا لمتابعة باقي المقال وبدء تعلم كيفية تحديث البيانات باستخدام لغة الاستعلام البنيوية SQL.

تحديث البيانات في جدول واحد

تبدو الصيغة العامّة لتعليمة UPDATE على النحو:

mysql> UPDATE table_name
mysql> SET column_name = value_expression
mysql> WHERE conditions_apply;

تُتبع الكلمة المفتاحية UPDATE باسم الجدول الذي يحتوي على البيانات المُراد تحديثها. ثم تأتي بنية SET، والتي تُحدّد بيانات العمود المُراد تحديثها وكيفية التحديث. تُعدّ بنية SET وكأنها تعيين لقيم العمود المُحدد لتُصبح مطابقة لأي تعبير قيمة تُقدّمه.

يُعرّف تعبير القيمة — الذي يُعرف أحيانًا بالتعبير ذو القيمة المفردة — بأنّه أي تعبير يُعيد قيمة واحدة لكل سجل يُراد تحديثه. يمكن أن تكون القيمة المُعادة عبارة عن سلسلة نصية مجردة، أو عملية رياضية تُجرى على قيم رقمية موجودة في العمود. ولا بُدّ من تضمين عملية إسناد لقيمة واحدة على الأقل في كل تعليمة UPDATE، كما يُمكنك تضمين أكثر من تعليمة واحدة بغية تحديث البيانات في عدة أعمدة.

تُتبع بنية SET ببنية WHERE. فإضافة بنية WHERE إلى تعليمة UPDATE كما في صيغة المثال هذه يُمكنّك من تصفية أي سجلات لا ترغب في تحديثها. إنّ بنية WHERE اختيارية تمامًا في تعليمات UPDATE، ولكن إذا لم تُضمنها، ستُحدّث العملية كل سجل في الجدول.

لتوضيح كيفية تعامل SQL مع عمليات التحديث UPDATE، ابدأ بالاطلاع على كافة البيانات في جدول العملاء clients. يشتمل الاستعلام التالي على علامة النجمة (*)، وهي اختصار في SQL يُمثّل كل عمود في الجدول، لذا سيُعيد هذا الاستعلام جميع البيانات من كل عمود في جدول clients.

$ SELECT * FROM clients;

الخرج
+----------+------------+------------------+-------------+
| clientID | name       | routine          | standardFee |
+----------+------------+------------------+-------------+
|        1 | Fares     | song and dance   |      180.00 |
|        2 | Camal  | standup          |       99.99 |
|        3 | Karam | standup          |       45.00 |
|        4 | Wael      | song and dance   |      200.00 |
|        5 | Ahmad        | trained squirrel |       79.99 |
+----------+------------+------------------+-------------+
5 rows in set (0.00 sec)

لنفترض على سبيل المثال أنّك لاحظت وجود خطأ في تهجئة الاسم Kamal، إذ يجب أن يبدأ بحرف K ولكنه في الجدول يبدأ بحرف C، ولذا قررت تغيير هذه القيمة عبر تنفيذ تعليمة UPDATE التالية. هذه العملية تُحدّث القيم في عمود الاسم name عن طريق تغيير قيمة عمود الاسم name في أي سجل يحتوي على الاسم Camal لتصبح Kamal:

mysql> UPDATE clients
mysql> SET name = 'Kamal'
mysql> WHERE name = 'Camal';

الخرج
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

يُظهر هذا الخرج أن سجلًا واحدًا فقط قد حُدّث. يمكنك التأكد من ذلك بتشغيل استعلام SELECT السابق مجددًا، على النحو:

$ SELECT * FROM clients;

الخرج
+----------+------------+------------------+-------------+
| clientID | name       | routine          | standardFee |
+----------+------------+------------------+-------------+
|        1 | Fares     | song and dance   |      180.00 |
|        2 | Kamal  | standup          |       99.99 |
|        3 | Karam | standup          |       45.00 |
|        4 | Wael      | song and dance   |      200.00 |
|        5 | Ahmad        | trained squirrel |       79.99 |
+----------+------------+------------------+-------------+
5 rows in set (0.00 sec)

تُظهر هذه النتائج أن القيمة المُدخلة سابقًا على أنّها Camal قد عُدلت الآن إلى Kamal.

لقد حُدثّت قيمة واحدة فقط في عمود الاسم name في هذا المثال. ولكن، يمكنك تحديث عدة قيم باستخدام بنية WHERE أشمل.

لإيضاح هذه الفكرة، بفرض أنّك تفاوضت على أجور أداء موحدة لجميع عملائك الذين يؤدون فقرات محددة. ستُحدّث التعليمة التالية القيم في عمود standardFee وتعينها لتكون 140.

يرجى ملاحظة أن بنية WHERE في هذا المثال تتضمن المعامل LIKE، لذا فهي تُحدّث قيمة performanceFee لكل عميل تُطابق قيمة routine له النمط المحدد بالمحرف البديل 's%'. بمعنى آخر، سيُحدّث أجر الأداء لأي مؤدي يبدأ نوع عرضه بالحرف "s":

mysql> UPDATE clients
mysql> SET standardFee = 140
mysql> WHERE routine LIKE 's%';

الخرج
Query OK, 4 rows affected (0.00 sec)
Rows matched: 4  Changed: 4  Warnings: 0

والآن إذا استعلمت مجددًا عن محتويات جدول العملاء clients، فستؤكد مجموعة النتائج أن أربعة من عملائك غدا لديهم الآن رسوم أداء متطابقة:

$ SELECT * FROM clients;

الخرج
+----------+------------+------------------+-------------+
| clientID | name       | routine          | standardFee |
+----------+------------+------------------+-------------+
|        1 | Fares     | song and dance   |      140.00 |
|        2 | Kamal  | standup          |      140.00 |
|        3 | Karam | standup          |      140.00 |
|        4 | Wael      | song and dance   |      140.00 |
|        5 | Ahmad        | trained squirrel |       79.99 |
+----------+------------+------------------+-------------+
5 rows in set (0.00 sec)

في حالة وجود أعمدة بالجدول تحمل قيمًا رقمية، فيُمكن تحديثها بتنفيذ عملية حسابية ضمن بنية SET. لتوضيح الأمر، بفرض أنّك توصلّت لاتفاق على زيادة رسوم الأداء لكل عميل بنسبة أربعين بالمئة، ولتطبيق هذا التغيير على جدول العملاء clients، يمكن تنفيذ عملية UPDATE كالآتي:

mysql> UPDATE clients
mysql> SET standardFee = standardFee * 1.4;

الخرج
Query OK, 5 rows affected, 1 warning (0.00 sec)
Rows matched: 5  Changed: 5  Warnings: 1

ملاحظة: لاحظ أن الخرج يشير إلى أنّ التحديث قد نتج عنه تحذير. ففي كثير من الأحيان، تُصدر MySQL تحذيرًا عندما تُجبر على إجراء تغيير على بياناتك يتعارض والخصائص أو المحددات القياسية لعمود أو جدول معين.

وتوفّر MySQL الاختصار SHOW WARNINGS الذي قد يساعد في شرح أي تحذيرات تتلقاها:

mysql> SHOW WARNINGS;

الخرج
+-------+------+--------------------------------------------------+
| Level | Code | Message                                          |
+-------+------+--------------------------------------------------+
| Note  | 1265 | Data truncated for column 'standardFee' at row 5 |
+-------+------+--------------------------------------------------+
1 row in set (0.00 sec)

يُخبرنا هذا الخرج بأن نظام قاعدة البيانات أصدر التحذير لأنه اضطر إلى اقتطاع إحدى قيم العمود standardFee الجديدة حتى تتوافق مع تنسيق الرقم العشري - خمسة أرقام مع وجود رقمين على يمين الفاصلة العشرية - المُعرّف مسبقًا.

لنستعلم عن جدول العملاء clients مجددًا للتأكد من أن رسوم الأداء لكل من العملاء قد ارتفعت بنسبة أربعين بالمئة بالفعل.

$ SELECT * FROM clients;

الخرج
+----------+------------+------------------+-------------+
| clientID | name       | routine          | standardFee |
+----------+------------+------------------+-------------+
|        1 | Fares     | song and dance   |      196.00 |
|        2 | Kamal  | standup          |      196.00 |
|        3 | Karam | standup          |      196.00 |
|        4 | Wael      | song and dance   |      196.00 |
|        5 | Ahmad        | trained squirrel |      111.99 |
+----------+------------+------------------+-------------+
5 rows in set (0.00 sec)

كما ذكرنا سابقًا، يمكنك أيضًا تحديث البيانات في عدة أعمدة دفعة واحدة باستخدام تعليمة UPDATE واحدة. للقيام بذلك، يجب تحديد كل عمود ترغب في تحديثه، متبوعًا بالتعبير الخاص بالقيمة المراد تعيينها، ثم تفصل بين كل زوج من اسم عمود وتعبير قيمة بعلامة فاصلة.

على سبيل المثال، بفرض أنّك اكتشفت بأنّ القاعة التي يقدم فيها عملاؤك عروضهم قد أخطأت في الإبلاغ عن عدد الحضور لجميع عروض Karam و Wand. وبالصدفة، تبين أيضًا أنك قمت بإدخال أسعار تذاكر خاطئة لكل من عروضهما.

قبل الشروع في تحديث البيانات في جدول العروض shows، نفّذ الاستعلام التالي لاسترجاع كافة البيانات الحالية المُخزنة به حاليًا:

$ SELECT * FROM shows;

الخرج
+--------+------------+----------+------------+-------------+
| showID | showDate   | clientID | attendance | ticketPrice |
+--------+------------+----------+------------+-------------+
|      1 | 2019-12-25 |        4 |        124 |       15.00 |
|      2 | 2020-01-11 |        5 |         84 |       29.50 |
|      3 | 2020-01-17 |        3 |        170 |       12.99 |
|      4 | 2020-01-31 |        5 |        234 |       14.99 |
|      5 | 2020-02-08 |        1 |         86 |       25.00 |
|      6 | 2020-02-14 |        3 |        102 |       39.50 |
|      7 | 2020-02-15 |        2 |        101 |       26.50 |
|      8 | 2020-02-27 |        2 |        186 |       19.99 |
|      9 | 2020-03-06 |        4 |        202 |       30.00 |
|     10 | 2020-03-07 |        5 |        250 |        8.99 |
+--------+------------+----------+------------+-------------+
10 rows in set (0.01 sec)

ولتصحيح أعداد الحضور والأسعار لتعبّر عن تلك الفعلية، سنحدّث الجدول لإضافة عشرين حاضرًا إلى كل عرض لهما وزيادة قيم سعر التذكرة ticketPrice لكل عرض بنسبة خمسين في المئة. يمكنك القيام بذلك من خلال عملية على النحو:

mysql> UPDATE shows
mysql> SET attendance = attendance + 20,
mysql> ticketPrice = ticketPrice * 1.5
mysql> WHERE clientID IN 
mysql> (SELECT clientID
mysql> FROM clients
mysql> WHERE name = 'Karam' OR name = 'Wael');

الخرج
Query OK, 4 rows affected, 1 warning (0.00 sec)
Rows matched: 4  Changed: 4  Warnings: 1

لاحظ أن هذا المثال يستخدم استعلامًا فرعيًا في بنية WHERE لإرجاع قيم clientID لكل من Karam و Wael من جدول العملاء clients. وغالبًا ما يكون من الصعب تذكر القيم المجردة من قبيل أرقام التعريف، إلّا أنّ هذه الطريقة التي تستخدم فيها استعلامًا فرعيًا للعثور على قيمة يمكن أن تكون مفيدة في حال معرفتك لبعض السمات فقط حول السجلات المعنية.

بعد تحديث جدول العروض shows، لنستعلم عنه مجددًا للتأكد من أن التغييرات قد تمّت كما هو متوقع:

$ SELECT * FROM shows;

الخرج
+--------+------------+----------+------------+-------------+
| showID | showDate   | clientID | attendance | ticketPrice |
+--------+------------+----------+------------+-------------+
|      1 | 2019-12-25 |        4 |        144 |       22.50 |
|      2 | 2020-01-11 |        5 |         84 |       29.50 |
|      3 | 2020-01-17 |        3 |        190 |       19.49 |
|      4 | 2020-01-31 |        5 |        234 |       14.99 |
|      5 | 2020-02-08 |        1 |         86 |       25.00 |
|      6 | 2020-02-14 |        3 |        122 |       59.25 |
|      7 | 2020-02-15 |        2 |        101 |       26.50 |
|      8 | 2020-02-27 |        2 |        186 |       19.99 |
|      9 | 2020-03-06 |        4 |        222 |       45.00 |
|     10 | 2020-03-07 |        5 |        250 |        8.99 |
+--------+------------+----------+------------+-------------+
10 rows in set (0.00 sec)

يشير هذا الخرج إلى أن تعليمة UPDATE قد اكتملت بنجاح.

استخدام بنية JOIN لتحديث البيانات في جداول متعددة

ركّز هذا المقال حتى الآن على عرض طرق تحديث البيانات في جدول واحد فقط في كل مرة. ولكن، تُتيح بعض الإصدارات من SQL إمكانية تحديث أعمدة متعددة في جداول متعددة من خلال دمج الجداول مؤقتًا باستخدام بنية JOIN.

فيما يلي الصيغة العامة التي بإمكانك استخدامها لتحديث عدة جداول دفعة واحدة مستخدمًا بنية JOIN:

mysql> UPDATE table_1 JOIN table_2
mysql> ON table_1.related_column = table_2.related_column
mysql> SET table_1.column_name = value_expression,
mysql> table_2.column_name = value_expression
mysql> WHERE conditions_apply;

تبدأ صيغة هذا المثال بالكلمة المفتاحية UPDATE متبوعة بأسماء جدولين، يفصل بينهما صيغة JOIN. يلي ذلك صيغة ON، التي توضّح كيف ينبغي للاستعلام أن يدمج الجدولين معًا.

في معظم تقديمات SQL، يمكنك دمج الجداول عن طريق إيجاد تطابقات ما بين أي مجموعة من الأعمدة تحتوي على ما يُعرف في معيار SQL باسم "أنواع البيانات المؤهلة للدمج" (JOIN eligible). بمعنى آخر، يُمكن بشكل عام دمج أي عمود يحتوي على بيانات عددية مع أي عمود آخر يحتوي على بيانات عددية، بغض النظر عن أنماط البيانات المحددة لكل منهما. وبالمثل، يمكن دمج أي أعمدة تحتوي على قيم محرفية مع أي عمود آخر يحتوي على بيانات محرفية.

لاحظ أنه نظرًا لقدرة بنى JOIN على مقارنة البيانات من عدة جداول، فإن صيغة هذا المثال تُوضّح الجدول المُستهدف لكل عمود بوضع اسم الجدول متبوعًا بنقطة قبل اسم العمود، وهذا ما يُعرف بالإشارة الكاملة والمؤهلة للعمود. يُمكنك تحديد الجدول المصدر لكل عمود بهذه الطريقة في أي عملية، وهي غالبًا ما تُستخدم لزيادة الوضوح عند العمل مع أكثر من جدول.

لتوضيح كيفية تنفيذ ذلك باستخدام جداول clients وshows المُنشأة مسبقًا، نفذ تعليمة UPDATE التالية. ما سيدمج جدولي clients وshows بناءً على أعمدة clientID المتطابقة في كلا الجدولين، ومن ثم تحديث قيم routine وticketPrice لسجل Fares في جدول clients وكل عروضها المدرجة في جدول shows.

mysql> UPDATE clients JOIN shows
mysql> USING (clientID)
mysql> SET clients.routine = 'mime',
mysql> shows.ticketPrice = 30
mysql> WHERE name = 'Fares';

الخرج
Query OK, 2 rows affected (0.01 sec)
Rows matched: 2  Changed: 2  Warnings: 0

لاحظ أنّ هذا المثال يدمج الجداول باستخدام الكلمة المفتاحية USING بدلاً من ON المُستخدمة في صيغة المثال السابق. وهذا ممكن لأنّ كل من الجدولين لديهما عمود clientID يتشاركان فيه نفس نوع البيانات.

لمزيد من التفاصيل حول عمليات الدمج باستخدام JOIN، ننصحك بقراءة المقال التالي كيفية استخدام عمليات الدمج في SQL.

تغيير سلوك تعليمة UPDATE للمفاتيح الخارجية

ستفشل أي تعليمة UPDATE قد تسبب تعارضًا مع قيد FOREIGN KEY افتراضيًا.

بالعودة إلى فقرة الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية في مستلزمات العمل وبتذكّر أنّ العمود clientID في جدول العروض shows هو مفتاح خارجي يشير إلى عمود clientID في جدول العملاء clients. فهذا يعني أنّ أي قيمة مُدخلة في عمود clientID الخاص بجدول العروض يجب أن تكون موجودة بالفعل في جدول العملاء.

فإذا حاولت تحديث قيمة clientID لسجل ما في جدول العملاء والتي تظهر أيضًا في عمود clientID لجدول العروض، فسيؤدي ذلك إلى حدوث خطأ:

mysql> UPDATE clients
mysql> SET clientID = 9
mysql> WHERE name = 'Ahmad';

الخرج
ERROR 1217 (23000): Cannot delete or update a parent row: a foreign key constraint fails

يمكنك تجنب هذا الخطأ بتغيير قيد المفتاح الخارجي الحالي بآخر يتعامل مع عمليات التحديث على نحوٍ مختلف.

ملاحظة: لا تسمح كافة أنظمة إدارة قواعد البيانات العلاقية أو محركات قواعد البيانات بإضافة أو إزالة قيد من جدول موجود بالفعل كما هو موضح في الفقرات التالية. فإذا كنت تستخدم نظام RDBMS غير MySQL، يجب عليك الرجوع إلى الوثائق الرسمية الخاصة به لفهم القيود الموجودة بخصوص إدارة القيود.

بالعودة إلى موضوعنا، ولاستبدال القيد الحالي، عليك بدايةً إزالته باستخدام تعليمة ALTER TABLE. تذكّر أننا في تعليمة CREATE TABLE الخاصة بجدول العروض shows، حددنا client_fk كاسم لقيد المفتاح الخارجي FOREIGN KEY للجدول:

mysql> ALTER TABLE shows
mysql> DROP FOREIGN KEY client_fk;

الخرج
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

بعد ذلك، أنشئ قيد مفتاح خارجي جديد مُعدّ ليتعامل مع عمليات التحديث UPDATE بطريقة تتناسب مع الحالة الاستخدامية المعطاة. بصرف النظر عن الإعداد الافتراضي الذي يمنع تعليمات UPDATE التي تخالف المفتاح الخارجي، هناك خياران آخران متاحان في معظم أنظمة إدارة قواعد البيانات العلاقية:

• ON UPDATE SET NULL: يسمح لك هذا الخيار بتحديث السجلات من الجدول الأب، وسيعيد تعيين أي قيم مرتبطة بها في الجدول الابن على أنها قيم فارغة NULL.
• ON UPDATE CASCADE: عند تحديث سجل في الجدول الأب، سيدفع هذا الخيار SQL لتحديث أي سجلات في الجدول الابن مرتبطة بذلك السجل من الجدول الأب لتتماشى مع القيمة الجديدة المُحدّثة.

في سياق هذا المثال، لا يُعد استخدام خيار ON UPDATE SET NULL منطقيًا، فلو غيّرت مُعرّف لأحد العملاء دون حذفه من جدول clients، ينبغي أن يبقى مرتبطًا بعروضه في الجدول shows. ويجب أن يظهر المُعرّف الجديد ضمن سجلات عروضه، وبالتالي يكون استخدام الخيار ON UPDATE CASCADE هو الأنسب لهذا السياق.

لإضافة قيد FOREIGN KEY يعمل وفق آلية ON UPDATE CASCADE، نفّذ أمر ALTER TABLE التالي. ستنشئ هذه التعليمة قيد جديد باسم new_client_fk يعكس تعريف القيد السابق ولكن مع إضافة خيار ON UPDATE CASCADE.

mysql> ALTER TABLE shows
mysql> ADD CONSTRAINT new_client_fk
mysql> FOREIGN KEY (clientID)
mysql> REFERENCES clients (clientID)
mysql> ON UPDATE CASCADE;

الخرج
Query OK, 10 rows affected (0.02 sec)
Records: 10  Duplicates: 0  Warnings: 0

تشير هذه النتائج إلى أن العملية قد أثرت على جميع السجلات العشرة وقامت بتعديلها في جدول العروض shows.

ملاحظة: بدلًا من تغيير تعريف جدول مُعرّف مسبقًا لتعديل كيفية تفاعل قيد المفتاح الخارجي مع عمليات UPDATE، يُمكنك من البداية تحديد هذا السلوك عند إنشاء الجدول بواسطة تعليمة CREATE TABLE، وبذلك تُعيّن السلوك المطلوب مُسبقًا.

mysql> CREATE TABLE shows
mysql> (showID int PRIMARY KEY,
mysql> showDate date,
mysql> clientID int,
mysql> attendance int,
mysql> ticketPrice decimal (4,2),
mysql> CONSTRAINT client_fk
mysql> FOREIGN KEY (clientID)
mysql> REFERENCES clients(clientID)
mysql> ON UPDATE CASCADE
mysql> );

عقب ذلك، ستكون قادرًا على تحديث قيمة clientID لأي سجل في جدول clients، وستنتقل هذه التغييرات بشكل تلقائي إلى جميع السجلات المرتبطة بها في جدول shows.

mysql> UPDATE clients
mysql> SET clientID = 9
mysql> WHERE name = 'Ahmad';

الخرج
Query OK, 1 row affected (0.01 sec)
Rows matched: 1  Changed: 1  Warnings: 0

رغم أن هذا الخرج يشير إلى تأثر سجل واحد فقط، إلا أنّ العملية قد حدّثت في الواقع قيمة clientID لكل سجلات جدول العروض المرتبطة بـ Ahmad في جدول shows. وللتحقق من ذلك، نفّذ الاستعلام التالي لاسترجاع كافة البيانات من الجدول shows:

$ SELECT * FROM shows;

الخرج
+--------+------------+----------+------------+-------------+
| showID | showDate   | clientID | attendance | ticketPrice |
+--------+------------+----------+------------+-------------+
|      1 | 2019-12-25 |        4 |        144 |       22.50 |
|      2 | 2020-01-11 |        9 |         84 |       29.50 |
|      3 | 2020-01-17 |        3 |        190 |       19.49 |
|      4 | 2020-01-31 |        9 |        234 |       14.99 |
|      5 | 2020-02-08 |        1 |         86 |       30.00 |
|      6 | 2020-02-14 |        3 |        122 |       59.25 |
|      7 | 2020-02-15 |        2 |        101 |       26.50 |
|      8 | 2020-02-27 |        2 |        186 |       19.99 |
|      9 | 2020-03-06 |        4 |        222 |       45.00 |
|     10 | 2020-03-07 |        9 |        250 |        8.99 |
+--------+------------+----------+------------+-------------+
10 rows in set (0.00 sec)

كما هو متوقع، تسبب التحديث الذي أُجري على عمود clientID في جدول clients في تحديث السجلات المرتبطة في جدول shows.

الخلاصة

بوصولك إلى نهاية هذا المقال، ستكون قد اكتسبت المعرفة حول كيفية تعديل السجلات الموجودة في جدول واحد أو أكثر باستخدام تعليمة UPDATE في SQL. كما تعرفت على كيفية تعامل SQL مع عمليات التحديث التي تتعارض مع قيود المفتاح الخارجي وطرق تغيير هذا السلوك الافتراضي.

ومن المفترض أن تعمل الأوامر المشروحة في هذا المقال مع أي نظام لإدارة قواعد البيانات يستخدم SQL. لكن تذكر أن لكل قاعدة بيانات SQL تقديمها الخاص للغة، لذا ينبغي مراجعة التوثيق الرسمي لنظام إدارة قواعد البيانات الخاص بك للحصول على وصف أكثر تفصيلاً لكيفية التعامل مع عمليات التحديث والخيارات المتاحة لها.

وللمزيد حول SQL، نشجعك على متابعة المقالات المنشورة تحت وسم سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To Update Data in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: كيفية إدراج البيانات في SQL
• المرجع المتقدم إلى لغة SQL
• تصميم الجداول ومعلومات المخطط وترتيب تنفيذ الاستعلامات في SQL
• حذف الجداول وقواعد البيانات في SQL
• أهمية قواعد البيانات

تُقدّم لغة الاستعلامات البنيوية SQL، مرونةً هائلةً من حيث الطرق الممكنة لإدراج البيانات في الجداول. فعلى سبيل المثال، يمكنك تحديد سجلات بيانات فردية باستخدام الكلمة المفتاحية VALUES، أو نسخ مجموعات كاملة من البيانات من الجداول الحالية باستخدام الاستعلامات SELECT. كما يمكن تعريف الأعمدة بأساليب تسمح للغة SQL بإدراج البيانات فيها تلقائيًا.

في هذا المقال، سنستعرض كيفية استخدام الصيغة INSERT INTO في SQL لإضافة البيانات إلى الجداول وفق كل من هذه الأساليب.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز حاسوب يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العلاقيَّة RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، كما هو موضح في مقال كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• نظام إدارة قواعد البيانات MySQL مثبت على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، مُنشأ وفق الطريقة الموضحة في سياق المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقيَّة تستخدم تقديمات فريدة خاصة بها للغة SQL. فعلى الرغم من أن الأوامر المُوضحة في هذا المقال ستعمل على نحوٍ سليم في معظم هذه الأنظمة، ولكن قد تختلف الصياغة الدقيقة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، ستحتاج أيضًا إلى قاعدة بيانات يمكنك استخدامها للتدرّب على إدراج البيانات. إذا لم تكن لديك قاعدة بيانات للتجربة، اطلع على فقرة الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية** التالي للحصول على تفاصيل حول كيفية إنشائها.

الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم بعيد، اتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو التالي:

$ mysql -u user -p

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

أنشئ قاعدة بيانات باسم insertDB:

mysql> CREATE DATABASE insertDB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات insertDB، نفّذ تعليمة USE التالية:

mysql> USE insertDB;

الخرج
Database changed

بعد اختيار قاعدة البيانات insertDB، أنشئ جدولًا داخلها. فعلى سبيل المثال، بفرض لديك مصنع وترغب في إنشاء جدول لتخزين بعض المعلومات عن موظفيك. سيحتوي هذا الجدول على الأعمدة الخمسة التالية:

• name: اسم كل موظف، ويُعبّر عنه باستخدام نمط البيانات varchar مع حد أقصى للطول قدره 30 محرفًا.
• position: يخزن هذا العمود الموقع الوظيفي لكل موظف، ويُعبّر عنه أيضًا باستخدام نمط البيانات varchar مع حد أقصى للطول قدره 30 محرفًا.
• department: يمثل القسم الذي يعمل فيه كل موظف، ويُعبّر عنه باستخدام نمط البيانات varchar ولكن بحد أقصى للطول قدره 20 محرفًا فقط.
• hourlyWage: عمود لتسجيل أجر كل موظف بالساعة، ويستخدم نمط البيانات decimal، إذ تقتصر أي قيم في هذا العمود على حد أقصى قدره أربعة أرقام، مع وجود رقمين من هذه الأرقام على يمين الفاصلة العشرية. وبالتالي، تتراوح القيم المسموح بها في هذا العمود من ‎-99.99 إلى 99.99.
• startDate: تاريخ تعيين كل موظف، ويُعبّر عنه باستخدام نمط البيانات date. ويجب أن تتوافق القيم من هذا النوع مع التنسيق YYYY-MM-DD.

أنشئ جدولًا باسم factoryEmployees يحتوي على هذه الأعمدة الخمسة، على النحو:

mysql> CREATE TABLE factoryEmployees (
mysql> name varchar(30),
mysql> position varchar(30),
mysql> department varchar(20),
mysql> hourlyWage decimal(4,2),
mysql> startDate date
mysql> );

وبهذا، أصبحت جاهزًا لمتابعة الخطوات في المقال وبدء التعلم حول كيفية إدراج البيانات باستخدام SQL.

إدراج البيانات يدويًا

تبدو الصيغة العامة لإدراج البيانات في SQL كالتالي:

mysql> INSERT INTO table_name
mysql> (column1, column2, . . . columnN)
mysql> VALUES
mysql> (value1, value2, . . . valueN);

للتوضيح، نفّذ الأمر INSERT INTO التالي لتحميل جدول factoryEmployees مع سجل واحد من البيانات:

mysql> INSERT INTO factoryEmployees
mysql> (name, position, department, hourlyWage, startDate)
mysql> VALUES
mysql> ('Agnes', 'thingamajig foreman', 'management', 26.50, '2017-05-01');

الخرج
Query OK, 1 row affected (0.00 sec)

يبدأ هذا الأمر بالكلمات المفتاحية INSERT INTO، يليها اسم الجدول الذي ترغب في إدراج البيانات فيه. وبعد اسم الجدول، تأتي قائمة بأسماء الأعمدة التي ستضيف البيانات إليها والتي تكون محصورة ضمن أقواس هلالية. وبعد قائمة الأعمدة، تأتي الكلمة المفتاحية VALUES، ومن ثم مجموعة من القيم محاطة بأقواس هلالية ومفصولة برموز فاصلة.

الترتيب الذي تُدرج فيه الأعمدة ليس بالأمر المُلزم، ولكن من الأساسي ضمان تطابق ترتيب القيم مع ترتيب الأعمدة المُدرجة. إذ ستُدرج SQL القيمة الأولى في العمود الأول المُحدد، والقيمة الثانية في العمود الثاني، وهكذا. وللتوضيح لاحظ أن الأمر INSERT في المثال التالي سيضيف سجلًا جديدًا من البيانات، ولكن بترتيب مختلف للأعمدة:

mysql> INSERT INTO factoryEmployees
mysql> (department, hourlyWage, startDate, name, position)
mysql> VALUES
mysql> ('production', 15.59, '2018-04-28', 'Jim', 'widget tightener');

الخرج
Query OK, 1 row affected (0.00 sec)

إذا لم تتطابق القيم على نحوٍ صحيح مع ترتيب الأعمدة، قد تُدرج SQL البيانات في الأعمدة الخاطئة. ناهيك عن إمكانية حدوث خطأ في حال تعارضت أي من القيم مع نوع البيانات المحدد للعمود، كما في المثال التالي:

mysql> INSERT INTO factoryEmployees
mysql> (name, hourlyWage, position, startDate, department)
mysql> VALUES
mysql> ('Louise', 'doodad tester', 16.50, '2017-05-01', 'quality assurance');

الخرج
ERROR 1366 (HY000): Incorrect decimal value: 'doodad tester' for column 'hourlyWage' at row 1

وعلى الرغم من ضرورة توفير قيمة لكل عمود تحدده، ولكن بالمقابل ليس من الضروري تحديد كل عمود في الجدول عند إضافة سجل جديد من البيانات. ففي حال عدم وجود قيود على الأعمدة التي تتجاهلها (كالقيد NOT NULL)، ستضع MySQL القيمة الفارغة NULL في الأعمدة غير المُحددة.

mysql> INSERT INTO factoryEmployees
mysql> (name, position, hourlyWage)
mysql> VALUES
mysql> ('Harry', 'whatzit engineer', 26.50);

الخرج
Query OK, 1 row affected (0.01 sec)

فإذا كنت تخطط لإدخال سجل يتضمّن قيمًا لكل عمود في الجدول، فليس من الضروري تضمين أسماء الأعمدة على الإطلاق. ومع ذلك، عليك التأكد من أن القيم المُدخلة تتوافق مع الترتيب الذي عُرّفت الأعمدة وفقًا له لدى تعريف الجدول.

في هذا المثال، تتوافق القيم المدرجة مع الترتيب الذي عُرّفت الأعمدة وفقًا له في تعليمة CREATE TABLE الخاصة بالجدول factoryEmployee:

mysql> INSERT INTO factoryEmployees
mysql> VALUES
mysql> ('Marie', 'doodad welder', 'production', 27.88, '2018-03-29');

الخرج
Query OK, 1 row affected (0.00 sec)

كما يمكنك إضافة سجلات متعددة في وقت واحد عبر فصل كل سجل بعلامة فاصلة، كما في المثال التالي:

mysql> INSERT INTO factoryEmployees
mysql> VALUES
mysql> ('Giles', 'gizmo inspector', 'quality assurance', 26.50, '2019-08-06'),
mysql> ('Daphne', 'gizmo presser', 'production', 32.45, '2017-11-12'),
mysql> ('Joan', 'whatzit analyst', 'quality assurance', 29.00, '2017-04-29');

الخرج
Query OK, 3 rows affected (0.00 sec)
Records: 3  Duplicates: 0  Warnings: 0

نسخ البيانات باستخدام تعليمات SELECT

يمكنك نسخ سجلات البيانات المتعددة من جدول ما وإدراجها في جدول آخر باستخدام استعلام SELECT بدلًا من تحديد البيانات سجلًا تلو الآخر. تبدو صيغة هذه العملية كالتالي:

mysql> INSERT INTO table_A (col_A1, col_A2, col_A3)
mysql> SELECT col_B1, col_B2, col_B3
mysql> FROM table_B;

فبدلًا من إلحاق قائمة الأعمدة بالكلمة المفتاحية VALUES، ألحقنا الصيغة ضمن هذا المثال بتعليمة SELECT. إذ تشمل تعليمة SELECT في هذه الصيغة بنية FROM فقط، ولكن يمكن لأي استعلام صالح أن يعمل هنا على نحوٍ صحيح.

لتوضيح ذلك، نفّذ العملية CREATE TABLE التالية لإنشاء جدول جديد باسم showroomEmployees. لاحظ أن أعمدة هذا الجدول لها نفس الأسماء وأنماط البيانات كما في ثلاثة أعمدة من الجدول factoryEmployees المُستخدم في القسم السابق:

mysql> CREATE TABLE showroomEmployees (
mysql> name varchar(30),
mysql> hourlyWage decimal(4,2),
mysql> startDate date
mysql> );

الخرج
Query OK, 0 rows affected (0.02 sec)

الآن يمكنك ملء هذا الجدول الجديد ببعض البيانات من الجدول factoryEmployees المُنشأ سابقًا عن طريق إضافة استعلام SELECT ضمن تعليمة INSERT INTO.

إذا أعاد استعلام SELECT نفس عدد الأعمدة وبنفس الترتيب كما في أعمدة الجدول الهدف، وكان لها أيضًا نفس أنماط البيانات، فيمكنك حينها تجاهل قائمة الأعمدة في تعليمة INSERT INTO، على النحو:

mysql> INSERT INTO showroomEmployees
mysql> SELECT
mysql> factoryEmployees.name,
mysql> factoryEmployees.hourlyWage,
mysql> factoryEmployees.startDate
mysql> FROM factoryEmployees
mysql> WHERE name = 'Agnes';

الخرج
Query OK, 1 row affected (0.01 sec)
Records: 1  Duplicates: 0  Warnings: 0

ملاحظة: كل من الأعمدة المدرجة في الاستعلام SELECT الخاص بالعملية أعلاه مسبوقة باسم الجدول factoryEmployees متبوعًا برمز النقطة. وعندما نُحدد اسم جدول بهذه الطريقة عند الإشارة إلى عمود، فيُطلق عليها مصطلح الإشارة الكاملة للعمود fully qualified column reference. الأمر غير الضروري في هذه الحالة الخاصة في المثال أعلاه. ففي الواقع، ستعطي التعليمة INSERT INTO في الأمثلة التالية نفس النتيجة كالتعليمة السابقة:

mysql> INSERT INTO showroomEmployees
mysql> SELECT
mysql> name,
mysql> hourlyWage,
mysql> startDate
mysql> FROM factoryEmployees
mysql> WHERE name = 'Agnes';

وقد استخدمنا في الأمثلة ضمن هذا القسم طريقة الإشارة الكاملة للعمود من باب التوضيح، ولكن من المستحسن استخدامها دائمًا. فهي لا تساعد في جعل لغة الاستعلام SQL أكثر وضوحًا فحسب، ولكنها تغدو كضرورة في العمليات التي تتضمن الإشارة إلى أكثر من جدول، كالاستعلامات التي تحتوي على بنية الدمج JOIN.

تشمل تعليمة الاستعلام SELECT في هذه العملية البنية WHERE، وبوجودها سيُعيد الاستعلام من الجدول factoryEmployees السجلات التي تحتوي على القيمة Agnes في العمود name فقط. وبما أن هناك سجلًا واحدًا فقط في الجدول المصدر موافق لهذه القيمة، فينسخ هذا السجل فقط إلى الجدول showroomEmployees.

لتأكيد ذلك، نفّذ الاستعلام التالي لاسترجاع جميع السجلات في جدول showroomEmployees:

mysql> SELECT * FROM showroomEmployees;

الخرج
+-------+------------+------------+
| name  | hourlyWage | startDate  |
+-------+------------+------------+
| Agnes |      26.50 | 2017-05-01 |
+-------+------------+------------+
1 row in set (0.00 sec)

يمكنك إدراج عدة سجلات من البيانات باستخدام أي استعلام يُعيد أكثر من سجل من الجدول المصدر. فعلى سبيل المثال، سيُعيد الاستعلام في التعليمة التالية جميع سجلات قاعدة البيانات factoryEmployees التي لا تبدأ قيمها ضمن العمود name بالحرف J:

mysql> INSERT INTO showroomEmployees
mysql> SELECT
mysql> factoryEmployees.name,
mysql> factoryEmployees.hourlyWage,
mysql> factoryEmployees.startDate
mysql> FROM factoryEmployees
mysql> WHERE name NOT LIKE 'J%';

الخرج
Query OK, 5 rows affected (0.01 sec)
Records: 5  Duplicates: 0  Warnings: 0

نفّذ هذا الاستعلام مجددًا لاسترجاع جميع السجلات في الجدول showroomEmployees:

mysql> SELECT * FROM showroomEmployees;

+--------+------------+------------+
| name   | hourlyWage | startDate  |
+--------+------------+------------+
| Agnes  |      26.50 | 2017-05-01 |
| Agnes  |      26.50 | 2017-05-01 |
| Harry  |      26.50 | NULL       |
| Marie  |      27.88 | 2018-03-29 |
| Giles  |      26.50 | 2019-08-06 |
| Daphne |      32.45 | 2017-11-12 |
+--------+------------+------------+
6 rows in set (0.00 sec)

نلاحظ وجود سجلين متطابقين يحملان القيمة Agnes في العمود name. فعند تنفيذ تعليمة INSERT INTO التي تستخدم الاستعلام SELECT, تُعامل SQL نتيجة الاستعلام هذا كمجموعة جديدة من البيانات. فبدون فرض قيود محددة على الجدول أو الاعتماد على استعلامات أدق وأكثر تحديدًا، لن يكون هناك ما يمنع وجود تكرار في السجلات عند إضافة البيانات بهذه الطريقة.

إدراج البيانات تلقائيًا

يمكن تطبيق بعض السمات على الأعمدة لدى إنشاء جدول، والتي تجعل نظام إدارة قواعد البيانات العلاقيّ يملؤها بالبيانات تلقائيًا.

للتوضيح، نفّذ التعليمة التالية لتعريف جدول باسم interns. إذ ستُنشئ هذه العملية جدولًا باسم interns يحتوي على ثلاثة أعمدة. العمود الأول في هذا المثال، وهو internID، يحتوي على بيانات من النمط int. ولكن لاحظ أنه يشمل أيضًا سمة AUTO_INCREMENT. هذه السمة ستجعل SQL تُنشئ قيمة رقمية فريدة تلقائيًا لكل سجل جديد، تبدأ افتراضيًا بالرقم 1 وتزداد تلقائيًا بخطوة مقدارها واحد مع كل سجل تالي.

وبالمثل، يشمل تعريف العمود الثاني الذي يُدعى department الكلمة المفتاحية DEFAULT. ما سيجعل نظام إدارة قواعد البيانات العلاقيّ يدرج القيمة الافتراضية – وهي الكلمة 'production' في مثالنا - تلقائيًا وذلك في حال حذف العمود department من قائمة الأعمدة ضمن تعليمة INSERT INTO، على النحو التالي:

mysql> CREATE TABLE interns (
mysql> internID int AUTO_INCREMENT PRIMARY KEY,
mysql> department varchar(20) DEFAULT 'production',
mysql> name varchar(30)
mysql> );

ملاحظة: تعدّ السمة AUTO_INCREMENT ميزة خاصة بنظام إدارة قواعد البيانات MySQL، ولكن العديد من أنظمة إدارة قواعد البيانات العلاقيّة لديها طريقتها الخاصة لتحقيق التزايد في الأرقام الصحيحة. وللحصول على فهم أفضل حول كيفية تعامل نظام إدارة قواعد البيانات العلاقي مع مسألة الزيادة التلقائية، يُفضل الرجوع إلى التوثيق الرسمي الخاص بهذا النظام.

وإليك التوثيق الرسمي بخصوص هذا الموضوع لبعض قواعد البيانات المفتوحة المصدر الشهيرة:

• توثيق سمة AUTO_INCREMENT لـ MySQL
• توثيق نمط البيانات serial لـ PostgreSQL
• توثيق الكلمة المفتاحية Autoincrement لـ SQLite.

ولتوضيح هذه الميزات، لنحمّل الجدول interns ببعض البيانات، وذلك بتنفيذ تعليمة INSERT INTO التالية. إذ تُحدّد هذه العملية القيم للعمود name فقط:

mysql> INSERT INTO interns (name) VALUES ('Pierre'), ('Sheila'), ('Francois');

الخرج
Query OK, 3 rows affected (0.01 sec)
Records: 3  Duplicates: 0  Warnings: 0

ومن ثمّ شغّل هذا الاستعلام ليعيد كافّة السجلات من الجدول:

mysql> SELECT * FROM interns;

الخرج
+----------+------------+----------+
| internID | department | name     |
+----------+------------+----------+
|        1 | production | Pierre   |
|        2 | production | Sheila   |
|        3 | production | Francois |
+----------+------------+----------+
3 rows in set (0.00 sec)

يُظهر هذا الخرج أنّه وبسبب تعريفات الأعمدة فإنّ التعليمة INSERT INTO السابقة أضافت قيمًا إلى العمودين internID وdepartment، على الرغم من عدم تحديدهما.

لإضافة قيمة مختلفة عن تلك الافتراضية لعمود department، يجب تحديد ذلك العمود ضمن تعليمة INSERT INTO، كالتالي:

mysql> INSERT INTO interns (name, department)
mysql> VALUES
mysql> ('Jacques', 'management'),
mysql> ('Max', 'quality assurance'),
mysql> ('Edith', 'management'),
mysql> ('Daniel', DEFAULT);

الخرج
Query OK, 4 rows affected (0.00 sec)
Records: 4  Duplicates: 0  Warnings: 0

لاحظ أن السجل الأخير من القيم المُقدمة في هذا المثال يشتمل على الكلمة المفتاحية DEFAULT بدلًا من قيمة نصية. سيؤدي ذلك إلى جعل قاعدة البيانات تدرج القيمة الافتراضية ('production').

mysql> SELECT * FROM interns;

الخرج
+----------+-------------------+----------+
| internID | department        | name     |
+----------+-------------------+----------+
|        1 | production        | Pierre   |
|        2 | production        | Sheila   |
|        3 | production        | Francois |
|        4 | management        | Jacques  |
|        5 | quality assurance | Max      |
|        6 | management        | Edith    |
|        7 | production        | Daniel   |
+----------+-------------------+----------+
7 rows in set (0.00 sec)

الخلاصة

تعرفت في هذا المقال على العديد من طرق إدراج البيانات في الجداول، بما في ذلك تحديد سجلات البيانات على نحوٍ فرديّ باستخدام الكلمة المفتاحية VALUES، ونسخ مجموعات كاملة من البيانات باستخدام استعلامات SELECT، وتعريف الأعمدة التي ستُدرج فيها SQL البيانات تلقائيًا.

ومن الجدير بالذكر أن الأوامر التي شرحناها هنا يجب أن تعمل على أي نظام لإدارة قواعد البيانات يستخدم SQL. لكن عليك مراعاة أن كل قاعدة بيانات SQL تستخدم تقديمًا فريدًا للّغة، لذلك يُفضّل الرجوع إلى التوثيقات الرسمية لنظام إدارة قواعد البيانات الخاص بك للحصول على توصيف أدق لكيفية التعامل مع تعليمة INSERT INTO والخيارات المتاحة لها.

للمزيد حول كيفية التعامل مع SQL، ننصحك بالاطلاع على سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To Use Constraints in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: كيفية استخدام القيود في SQL
• جلب الاستعلامات عبر SELECT في SQL
• التعامل مع البيانات (الإدخال، الحذف والتعديل) في SQL
• مدخل إلى SQL
• تحديث الجداول في SQL

عند تصميم قاعدة بيانات باستخدام SQL، قد تُضطر أحيانًا إلى فرض قيود على نمط البيانات التي يمكن إضافتها إلى أعمدة معينة ضمن جدول. إذ توفّر لك SQL هذه الإمكانية من خلال ما يُعرف بالقيود constraints. فبمجرد تطبيق قيد على عمود أو جدول، ستفشل أي محاولة لإضافة بيانات لا تتوافق مع هذا القيد. ولعلّ لكل نظام من أنظمة قواعد البيانات التي تستخدم SQL طريقته الخاصة في التعامل مع القيود.

يهدف هذا المقال إلى تقديم نظرة عامة حول الصيغة المُتبعة في العديد من أنظمة إدارة قواعد البيانات للتعامل مع القيود، مع التركيز على MySQL كمثال رئيسي
في هذا الإطار.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز حاسوب يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العِلاقيَّة RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، كما هو موضح في مقال كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• MySQL مثبتة ومؤمنة على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، مُنشأ وفق الطريقة الموضحة في المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقيَّة تستخدم تقديمات فريدة خاصة بها للغة SQL. فعلى الرغم من أن الأوامر المُوضحة في هذا المقال ستعمل على نحوٍ سليم في معظم هذه الأنظمة، ولكن قد تختلف الصياغة الدقيقة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، فمن المفيد أيضًا أن يكون لديك فهم عام حول قيود SQL وكيفية عملها. وللحصول على نظرة عامة حول هذا المفهوم، يمكنك الرجوع إلى مقال فهم قيود SQL.

كما ستحتاج إلى قاعدة بيانات يمكنك استخدامها للتدرّب على إنشاء الجداول مع القيود. إذا لم تكن لديك قاعدة بيانات للتجربة، اطلع على القسم إعداد قاعدة بيانات تجريبية نموذجية والاتصال بها التالي للحصول على تفاصيل حول كيفية إنشائها.

إعداد قاعدة بيانات تجريبية نموذجية والاتصال بها

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم عن بُعد، اتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو:

$ ssh user@your_server_ip

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

أنشئ قاعدة بيانات باسم constraintsDB:

mysql> CREATE DATABASE constraintsDB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات constraintsDB، نفّذ تعليمة USE التالية:

mysql> USE constraintsDB;

الخرج
Database changed

وبذلك تغدو جاهزًا للخوض في الخطوات التالية من مقالنا هذا لتنطلق في تعلّم كيفية إنشاء وإدارة الجداول في SQL.

إنشاء الجداول مع القيود

عادةً ما تُعرّف القيود أثناء إنشاء الجدول. فمثلًا تُنشئ الصيغة التالية لتعليمة CREATE TABLE جدولًا باسم employeeInfo (معلومات الموظفين) يحتوي على ثلاثة أعمدة: empId (لتخزين مُعرّف الموظف) وempName (لتخزين اسم الموظف) و empPhoneNum (لتخزين رقم هاتف الموظف). كما تُطبّق هذه التعليمة أيضًا القيد UNIQUE على العمود empId. ما سيمنع وجود أي قيم متطابقة فيه:

mysql> CREATE TABLE employeeInfo (
mysql> empId int UNIQUE,
mysql> empName varchar(30),
mysql> empPhoneNum int
mysql> );

تُعرّف هذه التعليمة القيد UNIQUE مباشرةً بعد العمود empId، ما يعني أن القيد ينطبق فقط على هذا العمود. فإذا حاولت إضافة أي بيانات إلى هذا الجدول، سيراقب نظام إدارة قواعد البيانات المحتوى الحالي للعمود empId للتأكد من أنّ القيم الجديدة التي تضيفها إليه فريدة بالفعل. وهذا ما يُسمّى بالقيد على مستوى العمود.

كما من الممكن تطبيق القيد خارج تعريفات العمود. ففي المثال التالي، نُنشئ جدولًا باسم racersInfo (معلومات المتسابقين) يحتوي على ثلاثة أعمدة: racerId (لتخزين مُعرّف المتسابق) وracerName (لتخزين اسم المتسابق) وfinish (لتخزين ترتيب إنهاء المتسابق للسباق). وأسفل تعريفات الأعمدة، نُطبّق القيد CHECK على العمود finish لضمان أن ترتيب كل متسابق أكبر من أو يساوي 1 (إذ لا يمكن أن يكون ترتيب أي متسابق أقل من المركز الأول):

mysql> CREATE TABLE racersInfo (
mysql> racerId int,
mysql> finish int,
mysql> racerName varchar(30),
mysql> CHECK (finish > 0)
mysql> );

ونظرًا لتطبيق القيد خارج تعريف أي من الأعمدة الفردية، فيتعين عليك تحديد اسم الأعمدة التي ترغب بتطبيق القيد عليها بين قوسين هلاليين.

دائمًا في حال تحديد قيد خارج تعريفات الأعمدة الفردية، نُسمّي هذا القيد بقيد على مستوى الجدول. فالقيود على مستوى العمود تنطبق فقط على الأعمدة الفردية، في حين قد تُطبّق قيود الجدول على عدة أعمدة.

تسمية القيود

عندما تحدد قيدًا، يولد نظام إدارة قواعد البيانات العِلاقيَّة اسمًا له تلقائيًا. يُستخدم هذا الاسم للإشارة إلى القيد في رسائل الخطأ وفي الأوامر المستخدمة لإدارة القيود.

قد يكون من المريح لمدراء قواعد البيانات في بعض الأحيان توفير اسماء خاصة للقيود. فعادةً لا تكون أسماء القيود المُنشأة تلقائيًا وصفية، لذلك قد يساعد توفير الاسم بنفسك في تذكر الغرض من القيد.

لتسمية قيد، ضع الكلمة المفتاحية CONSTRAINT متبوعة بالاسم الذي تختاره وذلك قبل نوع القيد. فمثلًا تعيد التعليمات التالية إنشاء جدول racersInfo مع تسميته newRacersInfo وإضافة الاسم noNegativeFinish للقيد CHECK:

mysql> CREATE TABLE newRacersInfo (
mysql> racerId int,
mysql> finish int,
mysql> racerName varchar(30),
mysql> CONSTRAINT noNegativeFinish 
mysql> CHECK (finish >= 1)
mysql> );

ملاحظة: إذا لم تُحدّد اسمًا للقيد، أو حددته ونسيته لاحقًا، فمن المحتمل أن تعثر عليه بالرجوع إلى تخطيطات معلومات قاعدة البيانات information schemas لنظام إدارة قواعد البيانات الخاص بك. إذ توفّر العديد من أنظمة قواعد البيانات الحديثة وعملاؤها اختصارًا لعرض تعليمات CREATE الداخلية والتي تشير إلى اسم القيد.

وفيما يلي روابط التوثيقات الرسمية لهذه الاختصارات لكل من MySQL وPostgreSQL:

• MySQL: تتضمّن MySQL التعليمة SHOW CREATE TABLE، والتي تعيد كامل تعليمة CREATE TABLE التي أنشأت الجدول المطوب، على النحو:

mysql> SHOW CREATE TABLE table_name;

• PostgreSQL: يتضمن عميل PostgreSQL المُسمّى psql على العديد من الخيارات التي يمكنك استخدامها للكشف عن معلومات حول جدول معين. فالخيار d\ مثلًا يعيد بياناتٍ وصفية حول الجدول المطلوب:

Postgres=# \d table_name

إدارة القيود

يمكنك إضافة القيود إلى الجداول الموجودة أصلًا في MySQL أو حذفها باستخدام أوامر ALTER TABLE.

على سبيل المثال، الأمر التالي يضيف قيد UNIQUE إلى العمود empName في الجدول employeeInfo المُنشأ مسبقًا:

mysql> ALTER TABLE employeeInfo ADD UNIQUE (empName);

عند إضافة قيد إلى جدول موجود، يمكنك أيضًا استخدام الكلمة المفتاحية CONSTRAINT لتوفير اسم لتعريف القيد. فالأمر في المثال التالي يضيف قيد UNIQUE باسم uID إلى العمود racerId من الجدول racersInfo المُنشأ مسبقًا:

mysql> ALTER TABLE racersInfo ADD CONSTRAINT uID UNIQUE (racerId);

وستفشل التعليمة ALTER TABLE إذا أدخلت أي سجلات قد تنتهك شرط القيد الجديد قبل إضافته وفق هذه الطريقة.

لحذف قيد، استخدم الصيغة DROP CONSTRAINT، متبوعة باسم القيد الذي ترغب في حذفه. فمثلًا الأمر التالي سيحذف القيد uID المُنشأ في الأمر السابق:

mysql> ALTER TABLE racersInfo DROP CONSTRAINT uID;

الخلاصة

تعلمت في هذا المقال كيفية إضافة وحذف القيود للأعمدة والجداول باستخدام SQL. ومن الجدير بالذكر أن الأوامر التي شرحناها هنا يجب أن تعمل على أي نظام لإدارة قواعد البيانات يستخدم SQL. لكن عليك مراعاة أن كل قاعدة بيانات SQL تستخدم تقديمًا فريدًا للّغة، لذلك يُفضّل الرجوع إلى التوثيقات الرسمية لنظام إدارة قواعد البيانات الخاص بك للحصول على توصيف أدق لكل أمر والخيارات المتاحة.

للمزيد حول كيفية التعامل مع SQL، ننصحك بالاطلاع على سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To Use Constraints in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: كيفية إنشاء وإدارة الجداول في SQL
• نظرة سريعة على لغة الاستعلامات الهيكلية SQL
• مدخل إلى أهم الاستعلامات (queries) في MySQL
• مدخل إلى برنامج إدارة قواعد البيانات MySQL

الجداول هي الهياكل التنظيمية الأساسية في قواعد بيانات SQL. وهي تتكون من عدد من الأعمدة التي تعكس السمات الفردية لكل صف أو سجل في الجدول. ولعلّ من المهم لكل من يعمل مع قواعد البيانات العلاقية أن يفهم كيفية إنشاء وتغيير وحذف الجداول حسب الحاجة كونها جزءًا أساسيًا من آلية تنظيم البيانات.

سنتناول في هذا المقال كيفية إنشاء الجداول في SQL، بالإضافة إلى كيفية تعديل وحذف الجداول الموجودة أصلًا في قاعدة البيانات.

مستلزمات العمل

لمتابعة الخطوات في هذا المقال، ستحتاج إلى جهاز كمبيوتر يُشغّل أحد أنواع أنظمة إدارة قواعد البيانات العلاقية RDBMS التي تستخدم SQL. وقد اختبرنا الأوامر البرمجية والأمثلة في هذا المقال مستخدمين البيئة التالية:

• خادم عامل على توزيعة أوبنتو، مع مستخدم ذو صلاحيات مسؤول مختلف عن المستخدم الجذر، وجدار حماية مكوّن باستخدام UFW، كما هو موضح في مقال كيفية تثبيت توزيعة أوبنتو من لينكس بأبسط طريقة.
• نظام إدارة قواعد البيانات MySQL مثبت على الخادم، كما هو موضح في المقال كيفية تثبيت MySQL على أوبونتو. وقد نفذنا خطوات هذا المقال باستخدام مستخدم MySQL مختلف عن المستخدم الجذر، مُنشأ وفق الطريقة الموضحة في الخطوة 3 من هذا المقال.

ملاحظة: تجدر الإشارة إلى أنّ الكثير من أنظمة إدارة قواعد البيانات العلاقية لها تقديماتها الفريدة من لغة SQL. فبالرغم من كون الأوامر المُقدمة في هذا المقال ستعمل مع معظم هذه الأنظمة، ولكن قد تجد بعض الاختلافات الطفيفة في الصيغة أو الناتج عند تنفيذها على أنظمة مختلفة عن MySQL.

وبالعودة إلى مستلزمات العمل، ستحتاج أيضًا إلى قاعدة بيانات وجدول مُحمّل ببعض البيانات التجريبية النموذجية لتتمكن من التدرب على استخدام محارف البدل. وإذا لم تكن متوفرة لديك، يمكنك مراجعة الفقرة التالية الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية للمزيد من التفاصيل حول كيفية إعداد قاعدة بيانات وجدول لاستخدامهما في الأمثلة خلال هذا المقال.

الاتصال بـ MySQL وإعداد قاعدة بيانات تجريبية نموذجية

إذا كان نظام قاعدة بيانات SQL الخاص بك يعمل على خادم بعيد، فاتصل بالخادم مُستخدمًا بروتوكول SSH من جهازك المحلي على النحو التالي:

$ ssh user@your_server_ip

ثم افتح واجهة سطر الأوامر في خادم MySQL، مُستبدلًا user باسم حساب مستخدم MySQL الخاص بك:

$ mysql -u user -p

الآن أنشئ قاعدة بيانات باسم tablesDB:

mysql> CREATE DATABASE tablesDB;

وبمجرّد إنشاء قاعدة البيانات بنجاح ستحصل على خرجٍ كالتالي:

الخرج
Query OK, 1 row affected (0.01 sec)

ولاختيار قاعدة البيانات tablesDB، نفّذ تعليمة USE التالية:

mysql> USE tablesDB;

الخرج
Database changed

وبذلك تغدو جاهزًا لتجربة الخطوات التالية من مقالنا هذا لتنطلق في تعلّم كيفية إنشاء وإدارة الجداول في SQL.

إنشاء الجداول

لإنشاء جدول في SQL، استخدم الأمر CREATE TABLE متبوعًا بالاسم الذي ترغب بتسمية الجدول به:

mysql> CREATE TABLE table_name;

وكما هو الحال مع كل تعليمات SQL، انتبه إلى وجوب انتهاء تعليمات CREATE TABLE برمز الفاصلة المنقوطة ;.

تُنشئ الصيغة في المثال السابق جدولًا فارغًا بدون أي أعمدة. أمّا لإنشاء جدول يتضمّن أعمدة محددة، فيجب أن نُتبع اسم الجدول بقائمة تتضمن أسماء الأعمدة وأنماط البيانات الموافقة لكل منها والقيود المتعلقة بها، محصورةً بين أقواس هلالية ومفصولة برمز الفاصلة، على النحو التالي:

mysql> CREATE TABLE table_name (
mysql> column1_name column1_data_type,
mysql> column2_name column2_data_type,
mysql> . . .
mysql> columnN_name columnN_data_type
mysql> );

كمثال، لنفترض أنك ترغب بإنشاء جدول لتسجيل بعض المعلومات حول المنتزهات التي تفضلها في مدينة نيويورك. فبعد اتخاذ قرار بشأن السمات التي تود تسجيلها حول كل منتزه، ستحدّد أسماء الأعمدة لكل من تلك السمات وكذلك نمط البيانات المناسب لكل منها:

• parkName: اسم كل منتزه. ونظرًا لوجود تباين واسع في أطوال أسماء المنتزهات، سيكون استخدام نمط البيانات varchar بطول أعظمي يبلغ 30 محرفًا مناسبًا.
• yearBuilt: السنة التي بُني فيها المنتزه. على الرغم من أنّ MySQL تتضمّن نمط بيانات يُسمّى year (لتخزين السنوات الميلادية)، إلّا أنّه يسمح فقط بقيم تتراوح بين 1901 و 2155. ولأن هناك عدة منتزهات في مدينة نيويورك بُنيت قبل عام 1901، لذلك من الأفضل استخدام نمط بيانات الأعداد الصحيحة int كبديل.
• firstVisit: تاريخ أول زيارة لك لكل منتزه. تتضمّن MySQL نمط بيانات date لتخزين التواريخ، ومن المناسب استخدامه لهذا العمود، إذ يُخزّن البيانات بالتنسيق YYYY-MM-DD (اليوم بخانتين-الشهر بخانتين-السنة بأربع خانات).
• lastVisit: تاريخ زيارتك الأخيرة لكل منتزه. ويمكنك هنا استخدام نمط البيانات date مجددًا.

ولإنشاء جدول باسم faveParks يحتوي على أعمدة بهذه الأسماء وأنماط البيانات، نفّذ الأمر التالي:

mysql> CREATE TABLE faveParks (
mysql> parkName varchar(30),
mysql> yearBuilt int,
mysql> firstVisit date,
mysql> lastVisit date
mysql> );

الخرج
Query OK, 0 rows affected (0.01 sec)

ومن الجدير بالملاحظة أن الأمر أعلاه يُنشئ هيكلية الجدول فقط، إذ أنّك لم تُضف أي بيانات إلى الجدول بعد.

كما يمكنك إنشاء جداول جديدة استنادًا إلى جداول موجودة أصلًا باستخدام الصيغة CREATE TABLE AS على النحو التالي:

mysql> CREATE TABLE new_table_name AS (
mysql> SELECT column1, column2, . . . columnN
mysql> FROM old_table_name
mysql> );

فبدلًا من إلحاق اسم الجدول الجديد (new_table_name) بقائمة من أسماء الأعمدة وأنماط البيانات الموافقة، نُتبعه بتعليمه AS ومن ثم تعليمة SELECT بين قوسين هلاليين والتي تُرجع الأعمدة والبيانات التي نرغب في نسخها من الجدول الأصلي (old_table_name) إلى الجدول الجديد.

ومن الجدير بالملاحظة أنّه إذا كانت أعمدة الجدول الأصلي تتضمّن أي بيانات، فسيتم نسخ تلك البيانات إلى الجدول الجديد أيضًا. وللتوضيح، تشمل صيغة المثال أعلاه استعلام باستخدام SELECT والذي يحتوي فقط على بنية FROM المطلوبة. ولكن أي تعليمة صحيحة من تعليمات SELECT ستعمل على نحوٍ سليم في هذا المكان.

ولمزيد من التوضيح، يُنشئ الأمر التالي جدولًا باسم parkInfo من خلال استخدام عمودين من الجدول faveParks المُنشأ سابقًا:

mysql> CREATE TABLE parkInfo AS (
mysql> SELECT parkName, yearBuilt
mysql> FROM faveParks
mysql> );

الخرج
Query OK, 0 rows affected (0.02 sec)
Records: 0  Duplicates: 0  Warnings: 0

فإذا كان الجدول faveParks يحتوي على أي بيانات، فستنسخ البيانات الموجودة في أعمدة parkName وyearBuilt إلى جدول parkInfo أيضًا. ولكن في حالتنا، كلا الجدولين سيكون فارغًا.

أمّا إذا حاولت إنشاء جدول مُستخدمًا اسم جدول موجود مُسبقًا من خلال التعليمات التالية:

mysql> CREATE TABLE parkInfo (
mysql> name varchar(30),
mysql> squareFootage int,
mysql> designer varchar(30)
mysql> );

الخرج
ERROR 1050 (42S01): Table 'parkInfo' already exists

فسيؤدي ذلك إلى وقوع خطأ يشير إلى أنّ الاسم parkinfo موجود أصلًا.

ولتجنب هذا الخطأ، يمكنك إضافة الخيار IF NOT EXISTS ضمن أمر CREATE TABLE الخاص بك. إذ سيُخبر هذا الخيار قاعدة البيانات بالتحقق من وجود جدول موجود مسبقًا بنفس الاسم المحدد، ففي حال كان موجودًا، سيظهر تحذير بدلًا من رسالة الخطأ.

mysql> CREATE TABLE IF NOT EXISTS parkInfo (
mysql> name varchar(30),
mysql> squareFootage int,
mysql> designer varchar(30)
mysql> );

الخرج
Query OK, 0 rows affected, 1 warning (0.00 sec)

سيفشل هذا الأمر في إنشاء جدول جديد، إذ أنّ الجدول بالاسم parkInfo ما زال موجودًا أصلًا. ولكن نلاحظ أن الخرج يشير إلى كون تعليمة CREATE TABLE أدت إلى ظهور تحذير. ولعرض رسالة التحذير، نفّذ الأمر التشخيصي SHOW WARNINGS كالتالي:

mysql> SHOW WARNINGS;

الخرج
| Level | Code | Message                         |
+-------+------+---------------------------------+
| Note  | 1050 | Table 'parkInfo' already exists |
+-------+------+---------------------------------+
1 row in set (0.00 sec)

وكما يشير هذا الخرج، فقد سُجّل نفس الخطأ الذي تلقيته سابقًا على أنه تحذير، ذلك لأنك قد ضمّنت الخيار IF NOT EXISTS. وهذا الأمر قد يكون مفيدًا في بعض الحالات، كما هو الحال عند تنفيذ المعاملات Transactions التي تمثل سلسلة من عمليات SQL تُجرى على قاعدة بيانات وتعامل كما لو كانت عملية واحدة، بحيث إما أن تُنفَّذ جميعها أو لا تنفذ بأكملها، في حين يشير التحذير إلى فشل التعليمة الذي تسببت به فقط.

تعديل الجداول

قد تضطر في بعض الحالات إلى تغيير تعريف جدول معين وهذا الأمر مختلف عن تحديث البيانات ضمن الجدول فهو يعني تغيير هيكلية الجدول نفسه. وللقيام بذلك، يمكنك استخدام الصيغة ALTER TABLE على النحو التالي:

mysql> ALTER TABLE table_name ALTER_OPTION sub_options . . . ;

وبعد تضمين تعليمة ALTER TABLE، حدّد اسم الجدول الذي تود تعديله. ومن ثم مرّر الخيارات المتاحة بناءً على نظام إدارة قواعد البيانات الخاص بك لإجراء التعديل المطلوب.

على سبيل المثال، قد ترغب في تغيير اسم الجدول أو إضافة عمود جديد أو حذف عمود قديم أو تغيير تعريف أحد الأعمدة.

لنطبق بعض الأمثلة على جدول المنتزهات المُفضّلة faveParks الذي أنشأناه سابقًا في قسم إنشاء الجداول لمزيد من التدريب على كتابة تعليمات التعامل مع الجداول.

لتغيير اسم الجدول faveParks، يمكنك استخدام صيغة RENAME TO. يغير المثال التالي اسم جدول faveParks إلى faveNYCParks:

تحذير: كن حذرًا عند تغيير اسم جدول. فالقيام بذلك قد يسبب مشكلات في حال كان هناك تطبيق يستخدم الجدول أو إذا كانت هناك جداول أخرى في قاعدة البيانات تشير إليه.

mysql> ALTER TABLE faveParks RENAME TO faveNYCParks;

الخرج
Query OK, 0 rows affected (0.01 sec)

لإضافة عمود جديد للجدول، استخدم الخيار ADD COLUMN. يضيف المثال التالي عمود بالاسم borough، والذي يُخزّن بيانات من النمط varchar، ولكن بطول أقصى يبلغ 20 محرفًا إلى الجدول faveNYCParks:

mysql> ALTER TABLE faveNYCParks ADD COLUMN borough varchar(20);

الخرج
Query OK, 0 rows affected (0.01 sec)
Records: 0  Duplicates: 0  Warnings: 0

لحذف عمود من جدول مع أي بيانات يحتوي عليها، يمكنك استخدام الصيغة DROP TABLE. يحذف الأمر في المثال التالي العمود borough:

mysql> ALTER TABLE faveNYCParks DROP COLUMN borough;

تسمح العديد من تقديمات SQL بتغيير تعريف العمود باستخدام الصيغة ALTER TABLE. ويستخدم المثال التالي بنية MODIFY COLUMN في MySQL، إذ يقوم بتغيير العمود yearBuilt لاستخدام بيانات من النمط smallint بدلًا من النمط int الأصلي:

mysql> ALTER TABLE faveNYCParks MODIFY COLUMN yearBuilt smallint;

ومما يجب أخذه في الحسبان أنّ كل نظام إدارة قواعد بيانات يتضمّن خيارات مختلفة بخصوص ما يمكنك تغييره باستخدام تعليمة ALTER TABLE. ولتحقيق فهمٍ كامل حول ما يمكنك تنفيذه باستخدام ALTER TABLE, راجع التوثيق الرسمي لنظام إدارة قواعد البيانات الذي تستخدمه لمعرفة الخيارات المتاحة للتعليمة.

إليك التوثيق الرسمي حول هذا الموضوع لبعضٍ من أشهر قواعد البيانات مفتوحة المصدر:

• توثيق ALTER TABLE في MySQL
• توثيق ALTER TABLE في PostgreSQL
• توثيق ALTER TABLE في SQLite

حذف الجداول

لحذف جدول وجميع البيانات الموجودة فيه، استخدم الصيغة DROP TABLE:

تحذير: كن حذرًا عند تنفيذ الأمر DROP TABLE، إذ سيقوم بحذف الجدول وجميع بياناته نهائيًا.

mysql> DROP TABLE table_name;

كما يمكنك حذف عدة جداول باستخدام تعليمة DROP واحدة وذلك بفصل أسماء الجداول برمز فاصلة ومحرف مسافة، كما في المثال التالي:

mysql> DROP TABLE table1, table2, table3;

للتوضيح، سيحذف الأمر التالي كل من جدولي faveNYCParks و parkInfo المُنشأين سابقًا في هذا المقال:

mysql> DROP TABLE IF EXISTS faveNYCParks, parkInfo;

لاحظ أن هذا المثال يتضمن الخيار IF EXISTS، والذي يؤدي الوظيفة المعاكسة لخيار IF NOT EXISTS المتاح لأمر إنشاء الجداول CREATE TABLE. إذ سيجعل خيار IF EXISTS تعليمة DROP TABLE تعيد تحذيرًا بدلًا من رسالة خطأ في حال لم يكن أحد الجداول المُحدّدة موجودًا.

الخلاصة

تعلمت في هذا المقال كيفية إنشاء وتغيير وحذف الجداول في قواعد البيانات المبنية على SQL. ومن الجدير بالذكر أن الأوامر التي شرحناها هنا يجب أن تعمل على أي نظام لإدارة قواعد البيانات يستخدم SQL. لكن عليك مراعاة أن كل قاعدة بيانات SQL تستخدم تقديمًا فريدًا للّغة، لذلك يُفضّل الرجوع إلى التوثيقات الرسمية لنظام إدارة قواعد البيانات الخاص بك للحصول على توصيف أدق لكل أمر والخيارات المتاحة.

للمزيد حول كيفية التعامل مع SQL، ننصحك بالاطلاع على سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال How To Create and Manage Tables in SQL لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: فهم قيود SQL
• المرجع المتقدم إلى لغة SQL
• تصميم الجداول ومعلومات المخطط وترتيب تنفيذ الاستعلامات في SQL
• حذف الجداول وقواعد البيانات في SQL
• أهمية قواعد البيانات

لدى تصميمك لقاعدة بيانات، قد تحتاج أحيانًا إلى وضع قيود على البيانات المسموح إدخالها ضمن أعمدة معينة في هذه القاعدة. على سبيل المثال، إذا كنت تنوي تصميم جدول لتخزين معلومات حول ناطحات سحاب، فلا بدّ من أنك سترغب في منع إدخال قيم سالبة في العمود الخاص بارتفاع كل مبنى.

تُمكنّك أنظمة إدارة قواعد البيانات العلاقية RDBMSs من التحكّم بالبيانات التي يُسمح بإضافتها إلى الجدول من خلال ما يُسمّى بالقيود constraints. والقيد عبارة عن قاعدة خاصة تُفرض على عمود واحد أو أكثر، أو حتى على الجدول كاملًا، وتحدد هذه القاعدة التغييرات المتاح إجراؤها على بيانات الجدول، سواء كان هذا التغيير من هو أمر إدراج بيانات جديدة INSERT، أو تحديث بيانات موجوة UPDATE، أو حذف بيانات معينة DELETE.

سنعرض في هذا المقال مفهوم القيود وكيفية استخدامها في أنظمة RDBMS بالتفصيل، كما سنستعرض القيود الخمسة المُعرفّة في معايير SQL ونشرح الوظيفة الأساسية لكل منها.

ما هي القيود؟

القيد constraint في SQL هو أي قاعدة تُطبق على عمود أو جدول بهدف تحديد طبيعة البيانات التي يمكن إدخالها فيه. فعند كل محاولة لإجراء عملية من شأنها تغيير البيانات الموجودة في جدول – من خلال أمر إدراج INSERT أو تحديث UPDATE أو حذف DELETE للبيانات مثلًا – ستتحقق نظم إدارة قواعد البيانات العلاقية فيما إذا كانت هذه البيانات تخالف أي من القيود الموجودة أم لا، وستعيد خطأ إذا كانت تخالفها بالفعل أو ستنفذها في حال كانت تحقق المعايير المطلوبة.

يعتمد مسؤولو قواعد البيانات على القيود لضمان اتباع قاعدة البيانات لمجموعة مُحددة من قواعد وتوجيهات العمل، وفي إطار قواعد البيانات، تُعرّف القاعدة بأنها أي سياسة أو إجراء تتبعه الشركة أو أي منظمة أخرى لتحدد من خلالها كيفية تخزين البيانات في قاعدة البيانات، إذ يجب أن تتوافق بياناتها مع هذه القواعد تمامًا.

على سبيل المثال، إذا كنت تعمل على تطوير قاعدة بيانات لرصد مخزون متجر لأحد العملاء وطلب منك هذا العميل التأكد من وجود رقم تعريف فريد لكل سجل (منتج)، فبإمكانك وضع القيد UNIQUE (المُعبّر عن كون كل سجل في العمود المعني فريد) على العمود المُخصص للرقم التعريفي لضمان عدم وجود أي تكرار في القيم المدخلة لأرقام المنتجات المختلفة.

تلعب القيود دورًا مهمًا في الحفاظ على دقة وصحة البيانات أو ما يعرف بسلامة البيانات data integrity. إذ يُشير مصطلح سلامة البيانات إلى مدى دقة واتساق ومنطقية البيانات المحفوظة في قاعدة البيانات وفقًا لسياق استخدامها. فغالبًا ما تكون الجداول ضمن قاعدة البيانات مرتبطة ببعضها البعض، فقد تعتمد بعض الأعمدة في جدول معين على القيم الموجودة في جدول آخر. ونظرًا لأن الأخطاء البشرية واردة الحدوث أثناء إدخال البيانات، فإن وضع القيود أمر أساسي في مثل هذه الحالات، إذ أنها تضمن عدم تأثير البيانات المُدخلة على نحوٍ خاطئ على هذه العلاقات بما قد يؤثّر سلبًا بالنتيجة على سلامة البيانات.

بفرض أنك تُصمّم قاعدة بيانات تتضمّن جدولين: الأول لإدراج الطلاب الحاليين في مدرسة ما، والثاني لإدراج أعضاء فريق كرة السلة في تلك المدرسة. يمكنك في هذه الحالة تطبيق قيد FOREIGN KEY (قيد المفتاح الخارجي) على أحد أعمدة جدول فريق كرة السلة ليشير إلى أحد أعمدة جدول الطلاب. وهذا ما سينشئ علاقة بين الجدولين، إذ يتطلب أي إدخال جديد في جدول الفريق أن يشير إلى إدخال موجود بالفعل في جدول الطلاب.

ولدى تصميم جدول في قاعدة البيانات، يمكن للمستخدمين تحديد القيود أثناء إنشاء هذا الجدول أو إضافتها لاحقًا باستخدام إحدى تعليمات ALTER TABLE، بشرط ألّا تتعارض هذه القيود المُضافة مع البيانات الموجودة أصلًا في الجدول. وعند إنشاء قيد جديد، سيولّد نظام قاعدة البيانات تلقائيًا اسمًا له، ولكن وفي العديد من تطبيقات SQL يمكنك تحديد اسم مُخصّص للقيد. إذ يُستخدم هذا الاسم للإشارة إلى القيد ضمن مجموعة التعليمات ALTER TABLE المُتعلّقة بتعديل القيد أو إزالته.

يُعرّف المعيار الرسمي للغة SQL خمس قيود فقط وهي:

• قيد المفتاح الأساسي PRIMARY KEY
• قيد المفتاح الخارجي FOREIGN KEY
• قيد القيم الفريدة UNIQUE
• قيد التحقق CHECK
• القيد غير فارغ NOT NULL

ملاحظة: تتضمّن العديد من نظم إدارة قواعد البيانات العلاقية الكلمة المفتاحية DEFAULT لتحديد قيمة ابتدائية افتراضية غير فارغة NULL تسند لسجلات العمود في حال عدم تحديد قيمة لحظة إضافة السجل. وتصف توثيقات بعض قواعد البيانات DEFAULT على أنها قيد، نظرًا لأن طريقة استخدامها تشابه لطريقة استخدام القيود الأخرى مثل UNIQUE أو CHECK. ولكن ومن الناحية التقنية، لا تعدّ DEFAULT قيدًا حقيقيًا لأنها لا تُحدّد أو تقيّد القيم التي يمكن إدخالها في العمود.

بالعودة إلى موضوعنا، وبعد حصولك على فهمٍ عام حول كيفية استخدام القيود، لنلقِ نظرة أعمق على كل من هذه القيود الخمسة.

القيد PRIMARY KEY

يتطلب قيد المفتاح الأساسي PRIMARY KEY أن يكون كل مُدخل في العمود المعني غير فارغ وغير مكرر، سامحًا لك باستخدام هذا العمود لتعريف كل سجل في الجدول على نحوٍ فريد.

والمفتاح key عمومًا في النموذج العلاقي عبارة عن عمود أو مجموعة من الأعمدة في جدول تضمن أن كل قيمة فيها فريدة وغير فارغة. أمّا المفتاح الأساسي فهو مفتاح خاص يستخدم لتعريف وتمييز سجلات الجدول على نحوٍ فردي، ويمكن استخدام العمود أو الأعمدة التي تكوّن مفتاح أساسي لتعريف الجدول وتحديده في باقي أجزاء قاعدة البيانات.

وهذا جانب مهم في قواعد البيانات العلاقية فبوجود المفتاح الأساسي، لا يُضطر المستخدمون لمعرفة مكان تخزين البيانات فيزيائيًا على الجهاز، إذ يمكن لنظام إدارة قاعدة البيانات أن يتتبّع كل سجل ويسترجعه حسب الطلب. ما يعني بدوره عدم وجود ترتيب منطقي محدد للسجلات، وبالتالي يتمكّن المستخدمون من استرجاع بياناتهم بأي ترتيب يفضلونه أو وفق أي مُرشحات (عوامل تصفية) يختارونها.

يمكنك إنشاء مفتاح أساسي في SQL باستخدام القيد PRIMARY KEY، والذي يُعدّ بالأصل مزيجًا من القيدين UNIQUE و NOT NULL. وبعد تعريف مفتاح أساسي، يُنشئ نظام إدارة قاعدة البيانات تلقائيًا فهرس index مرتبط به. والفهرس هو هيكلية في قاعدة البيانات تساعد في استرجاع البيانات من جدول ما بسرعة أكبر، وما على الاستعلامات إلّا استعراض الإدخالات الموافقة للعمود المُفهرس للعثور على القيم المترابطة (التابعة لسجل واحد) بآلية مُشابهة لاستخدام الفهرس في الكتب النصيّة العادية. الأمر الذي يسمح للمفتاح الأساسي بلعب دور المُعرّف لكل سجل في الجدول.

يمكن لكل جدول أن يتضمّن مفتاح أساسي واحد فقط، والذي قد يشتمل على عدّة أعمدة كما هو الحال بالنسبة للمفاتيح النمطية regular keys، ولكن من مميزات المفاتيح الأساسية هو استعانتها بأقل عدد ممكن من السمات لتمييز كل سجل في الجدول على نحوٍ فريد. ولتبسيط هذه الفكرة، تخيل جدولًا يُخزّن معلومات الطلاب في مدرسة ما من خلال ثلاثة أعمدة كالتالي:

• studentID: يُستخدم لتخزين رقم التعريف (مُعرّف) الخاص بكل طالب.
• firstName: يُستخدم لتخزين الاسم الأول لكل طالب.
• lastName: يُستخدم لتخزين اسم العائلة لكل طالب.

ولكن قد تتطابق الأسماء الأولى لبعض الطلاب في المدرسة، ما يجعل من العمود firstName خيارًا غير مناسب للاستخدام كمفتاح أساسي. وينطبق الأمر نفسه على العمود lastName. وبالتالي، قد يكون من المناسب استخدام مفتاح أساسي يتكون من الاسم الأول والأخير معًا، ولكن يبقى احتمال وجود طلاب بنفس الاسم الكامل قائمًا.

وبالتالي، يمكن الاعتماد على مفتاح أساسي يتألف من عمود رقم تعريف الطالب studentID بالإضافة إلى عمود الاسم الأول firstName أو عمود الاسم الأخير lastName. ولكن وبما أنّ رقم تعريف كل طالب هو قيمة فريدة، فإنّ إضافة أحد أعمدة الأسماء للمفتاح الأساسي لا يُمثّل أي قيمة مُضافة. ولهذا، يعدّ استخدام عمود رقم تعريف الطالب وحده الخيار الأمثل ليكون المفتاح الأساسي لهذا الجدول.

إذا كان المفتاح مكوّنًا من بيانات تطبيقية واقعية (أي بيانات تُمثّل كيانات أو أحداث أو سمات من العالم الواقعي)، فيُطلق عليه اسم مفتاح طبيعي natural key. أمّا إذا أُنشئ المفتاح داخليًا دون أن يُمثّل أي شيء خارج قاعدة البيانات، فيُعرف حينها باسم مفتاح بديل surrogate أو مفتاح مُصنّع synthetic key. تُوصي بعض أنظمة قواعد البيانات بتجنب استخدام المفاتيح الطبيعية، فحتى البيانات التي تبدو ثابتة قد تتغير بطرق غير متوقعة.

القيد FOREIGN KEY

يفرض القيد FOREIGN KEY أن تكون كل قيمة في العمود المعني موجودة بالفعل في عمود معين من جدول آخر.

بفرض لديك جدولين، ووددت ربطهما ببعضهما البعض، فإحدى الطرق التي يمكنك استخدامها لهذا الغرض هي تعريف مفتاح خارجي باستخدام القيد FOREIGN KEY. والمفتاح الخارجي هو عمود في جدول معين (ويطلق عليه الجدول "الابن") تأتي قيمه من مفتاح في جدول آخر (ويطلق عليه "الأب" أو الجدول الرئيسي). وهذا ما يُعبّر عن علاقة بين الجدولين: فالقيد FOREIGN KEY يفرض أن تكون القيم في العمود المعني موجودة بالفعل في العمود المُشار إليه من الجدول الآخر.

يُظهر المخطط التالي هذا النوع من العلاقة بين جدولين: إذ يُستخدم الأول لتسجيل معلومات حول الموظفين في شركة، ويُستخدم الثاني لتتبع مبيعات الشركة، وقد استخدمنا في هذا المثال مفتاح خارجي في جدول المبيعات SALES يشير إلى المفتاح الأساسي من جدول الموظفين EMPLOYEES:

فإذا حاولت إضافة سجل إلى الجدول الابن مع كون القيمة المُدخلة في عمود المفتاح الخارجي من هذا السجل غير موجودة في عمود المفتاح الأساسي للجدول الأب فستكون تعليمة الإدراج هذه غير صالحة. الأمر الذي يضمن الحفاظ على نزاهة مستوى العلاقة بين الجدولين، بضمان ربط السجلات في الجدولين على النحو الصحيح دائمًا.

فغالبًا ما يكون المفتاح الخارجي للجدول الابن هو المفتاح الأساسي للجدول الأب، ولكن الحال ليس على هذا النحو دائمًا. ففي معظم أنظمة إدارة قواعد البيانات العلاقية يمكن للمفتاح الخارجي في الجدول الابن الإشارة إلى أي عمود مُطبّق عليه أحد القيدين PRIMARY KEY أو UNIQUE في الجدول الأب.

القيد UNIQUE

يمنع القيد UNIQUE إضافة قيم مكررة إلى العمود المعني، وكما يوحي اسمه، يتطلب هذا القيد أن تكون كل قيمة تقوم بإدخالها في العمود المعني فريدةـ وأي محاولة لإضافة قيمة موجودة بالفعل فيه ستؤدي إلى ظهور خطأ.

تفيد القيود UNIQUE في فرض علاقات من نوع واحد-إلى-واحد one-to-one بين الجداول. فرغم إمكانية تكوين علاقات بين الجداول باستخدام المفتاح الخارجي كما أشرنا سابقًا، إلّا أنّ هناك عدّة أنواع من العلاقات التي قد تظهر بين الجداول:

• واحد-إلى-واحد: نقول بأنّ علاقة من نوع واحد-إلى-واحد تربط بين جدولين إذا كان كل سجل في الجدول الأب مرتبط بسجل واحد فقط في الجدول الابن.
• واحد-إلى-عديد: في علاقة واحد-إلى-عديد، يمكن أن يرتبط كل سجل في الجدول الأب مع عدة سجلات في الجدول الابن، لكن كل سجل في الجدول الابن يمكن أن يرتبط بسجل واحد فقط من الجدول الأب.
• عديد-إلى-عديد: نقول بأنّ علاقة من نوع عديد-إلى-عديد تربط بين الجدولين إذا كان بإمكان السجلات في الجدول الأب أن ترتبط مع عدّة سجلات من الجدول الابن، والعكس صحيح.

بإضافة القيد UNIQUE إلى عمود قد طُبّق عليه القيد FOREIGN KEY أيضًا، يمكنك التأكد من أن كل مُدخل في الجدول الأب يظهر مرة واحدة فقط في الجدول الابن، وبذلك تكون قد أنشأت علاقة من نوع واحد-إلى-واحد بين الجدولين.

ومن الجدير بالذكر أنّه يمكن تعريف القيود UNIQUE على مستوى الجدول أو على مستوى العمود. فعند تعريف القيد UNIQUE على مستوى الجدول، يمكن أن يشمل حينها أكثر من عمود. وفي مثل هذه الحالات، يمكن لكل عمود مُدرج ضمن القيد أن يحتوي على قيم مكررة، ولكن يجب أن تكون لكل سجل مجموعة فريدة من القيم في الأعمدة الخاضعة للقيد.

القيد CHECK

يُعرّف القيد CHECK قاعدة يجب أن تُطبق على عمود معين على هيئة عبارة شرطية predicate ويجب أن تُحقق جميع القيم المُدخلة في ذلك العمود الشرط المسند لهذا العمود. حيث تُكتب شروط القيد CHECK بشكل تعبير شرطي يأخذ القيمة TRUE (صحيح/مُحقق) أو FALSE (خاطئ/غير مُحقق)، أو حتى UNKNOWN (غير معروف وهو ما يحدث في حالة وجود قيم فارغة NULL في العمود). فإذا حاولت إدخال قيمة في عمود خاضع للقيد CHECK وتسببت هذه القيمة في تقييم الشرط إلى TRUE أو UNKNOWN فستنجح العملية وتخزن القيمة في العمود، وإذا تم تقييم التعبير إلى FALSE ستفشل ولن يسمح لك بإدخالها.

وتعتمد شروط القيد CHECK في كثير من الأحيان على عامل مقارنة رياضي (من قبيل <، >، <=، أو >=) لتحديد نطاق البيانات المسموح بإدخالها في العمود المُحدّد. فعلى سبيل المثال، من الاستخدامات الشائعة للقيود CHECK هي منع استقبال قيم سالبة في بعض الأعمدة وذلك في الحالات التي لا تكون فيها القيم السالبة مقبولة، كما سنوضح في المثال التالي.

سنكتب تعليمة CREATE TABLE لإنشاء جدول يخزن بيانات المنتجات وسنطلق عليه اسم productInfo، يحتوي هذا الجدول على أعمدة لتخزين اسم كل منتج ورقم التعريف الخاص به وسعره. ونظرًا لأن سعر المنتج لا يمكن أن يكون سالبًا من الناحية المنطقية، فنكتب قيد CHECK على عمود السعر price لضمان احتوائه على قيم موجبة فقط بالشكل التالي:

mysql> CREATE TABLE productInfo (
mysql> productID int,
mysql> name varchar(30),
mysql> price decimal(4,2)
mysql> CHECK (price > 0)
mysql> );

لا يُشترط استخدام عامل مقارنة رياضي في كل شرط من الشروط المنطقية الإسنادية الخاصة بالقيد CHECK. إذ يُمكنك استخدام أي معامل من معاملات SQL التي يمكن تقييمها في عبارة الشرط المنطقي إلى TRUE أو FALSE أو UNKNOWN، مثل LIKE و BETWEEN و IS NOT NULL وغيرها. وتسمح بعض تقديمات SQL -ولكن ليس كلها- بإضافة استعلام فرعي داخل العبارة الشرطية. في حين لا تسمح معظم التقديمات بالإشارة إلى جدول آخر داخل هذه العبارة الشرطية.

القيد NOT NULL

يحظرك القيد NOT NULL من إضافة أي قيم فارغة NULL إلى العمود المعني، فإذا أضفت سجل من البيانات ولم تُحدد فيه قيمة لعمود معين، فسوف يُمثّل نظام قواعد البيانات في معظم تقديمات SQL البيانات المفقودة افتراضيًا على أنها قيمة فارغة NULL. وفي لغة SQL تعد كلمة NULL مصطلحًا خاصًّا يُستخدم لتمثيل قيمة مجهولة أو مفقودة أو غير مُحددة. ولكن NULL ليست قيمة بحد ذاتها، بل هي حالة تُعبّر عن قيمة مجهولة أو غير متوفرة.

ولتوضيح هذا الفارق، تخيل جدولًا يُستخدم لتتبع العملاء في شركة لاستقطاب المواهب ويحتوي هذا الجدول على أعمدة لأسماء العملاء الأولى والأخيرة. فإذا كان العميل معروفًا باسمٍ واحدٍ فقط، فسيُدخل مدير قاعدة البيانات هذا الاسم في عمود الاسم الأول فقط، مما يتسبب في إدخال قيمة فارغة NULL في عمود الاسم الأخير.

في مثل هذه الحالة لا تعدّ قاعدة البيانات أن الاسم الأخير للعميل هو حرفيًا "فارغ". بل يعني ذلك فقط أن القيمة الموجودة في عمود الاسم الأخير لذلك السجل مجهولة أو غير متوفرة.

وبالتالي، وكما يوحي اسمه، يمنعك القيد NOT NULL من إدخال قيم فارغة NULL أو تجاهل إدخال قيمة في العمود المعني. وبالتالي ستكون مجبورًا على تحديد قيمة لأي عمود طُبِّق عليه قيد NOT NULL عند إضافة سجل جديد، وإلا ستفشل عملية الإدراج.

الخلاصة

تعرفنا في مقال اليوم على مفهوم القيود التي تعد أحد المفاهيم الأساسية لأي شخص يرغب في تصميم قاعدة بيانات بمستوى عالٍ من نزاهة وأمان البيانات وسلامتها. إذ يمكنك التأكد من الحفاظ على العلاقات بين الجداول على النحو الصحيح من خلال تحديد البيانات التي يُسمح بإدخالها ضمن عمود معين، ما يضمن توافق قاعدة البيانات مع القواعد المطلوبة التي تحدد الغرض من إنشائها.

للمزيد حول كيفية إنشاء وإدارة القيود في SQL، يمكنك مراجعة مقالنا كيفية استخدام القيود في SQL. وللمزيد حول SQL عمومًا، نشجعك على متابعة سلسلة تعلم SQL في أكاديمية حسوب.

ترجمة -وبتصرف- للمقال Understanding SQL Constraints لصاحبه Mark Drake.

اقرأ أيضًا

• المقال السابق: لماذا يجب عليك تعلم SQL؟
• المفاهيم الأساسية في قواعد البيانات وتصميمها
• دليلك الشامل إلى قواعد البيانات DataBase
• البيانات في SQL: أنواعها والقيود عليها
• ما هي محركات قواعد البيانات؟

قد تبدو لغة SQL أو لغة الاستعلام الهيكلية مُعقدة ومربكة للبعض في البداية، لكن مع التعلم والتعمق في اللغة ستصبح الأمور أوضح وأبسط فلغة SQL هي لغة سهلة التعلم بالعموم، وهي تُستخدم بشكل أساسي لتعريف ومعالجة والاستعلام عن البيانات المُخزنّة في قواعد البيانات العلاقية Relational، التي تعد أحد أشهر أنواع قواعد البيانات والتي تُنظّم البيانات فيها بدقة لتُناسب هيكلية أسطر (سجلات) وأعمدة (حقول) مُحدّدة مُسبقًا بشكل محدد وواضح.

ملاحظة: يمكنك الاطلاع على تفاصيل أكثر حول قواعد البيانات العلاقية، بما في ذلك تاريخها والمفاهيم الرئيسية المُتعلّقة بها واستخداماتها الشائعة، بالعودة إلى المقال السابق فهم قواعد البيانات العلاقية.

وبالعودة إلى موضوعنا، فقد ازدادت شهرة وشعبية لغة SQL منذ ظهورها في السبعينيات، وتوسّعت مجالات استخدامها على نحوٍ كبير منذ ذلك الحين. وتعدّ SQL في أيامنا من أبرز وأنضج اللغات المستخدمة في الاستعلام عن البيانات ومعالجتها في معظم القطاعات ومن أكثر الأدوات شهرةً. وبالتالي، فإن فرصة استخدام لغة SQL في مجال وظيفتك البرمجية كبيرة، فسواء كنت تعمل كمدير لقاعدة بيانات أو مصممًا لها أو مهندس برمجيات أو محلل بيانات، وحتى لو لم تكن تعمل في أي من الوظائف آنفة الذكر فستستفيد بالفعل من فهمك لأساسيات هذه اللغة وإن لم تستخدمها بشكل مباشر.

يُبرز هذا المقال أهمية تعلم لغة SQL، ويشرح كيف وأين يمكنك تطبيق معرفتك لهذه اللغة والاستفادة منها.

لغة SQL منتشرة بشكل واسع في عالم قواعد البيانات العلاقية

إذا تعاملت مع أي قاعدة بيانات علاقية مثل MySQL أو PostgreSQL أو Microsoft SQL أو Oracle SQL أو غيرها الكثير، فستصادف بالتأكيد تعليمات SQL. إذ تُستخدم هذه اللغة على نطاق واسع لتعريف ومعالجة والاستعلام عن البيانات في هذا النوع من قواعد البيانات، فهي الوسيلة الأساسية للتفاعل مع محرك قاعدة البيانات.

وبالرغم من أنّ العديد من أنظمة قواعد البيانات تُقدّم واجهات رسومية سهلة الاستخدام للتعامل مع بنية قاعدة البيانات وتعديل البيانات المُخزّنة فيها، إلا أن هذا لا يقلل من أهمية تقنية SQL أو يجعلها غير ضرورية. فبالرغم من إمكانية إنجاز المهام البسيطة بسرعة دون الحاجة إلى كتابة تعليمات SQL، ستتطلّب المهام الأعقد في معالجة البيانات أو الاستعلام عنها استخدام لغة SQL لبناء الاستعلامات وجلب البيانات التي تحتاجها بكفاءة مستفيدًا من قوة محرك قاعدة البيانات.

وبالتالي بفهمك للغة SQL، ستتمكن من التعامل بسرعة مع أي نظام قاعدة بيانات علاقية مُستخدم اليوم تقريبًا، ولن تقتصر مهاراتك على برنامج محدد أو جهة عمل معينة.

SQL مُستخدمة أيضًا على نحو واسع في مجالات عديدة أخرى

استطاعت SQL بفضل شهرتها واستخدامها في أنظمة قواعد البيانات العلاقية المُعتَمَدة على نحوٍ متزايد، أن تجد طريقها إلى أنظمة قواعد بيانات وأدوات تحليل بيانات أخرى.

إذ تتمتّع SQL والعديد من اللغات المُشتقّة منها بالدعم في العديد من أنظمة التخزين ومحركات تحليل البيانات وأدوات ذكاء الأعمال وأدوات التنقيب عن البيانات، وحتى في العديد من قواعد البيانات غير العلاقية وقواعد البيانات التحليلية Online analytical processing - OLAP وحلول البيانات الضخمة.

وبغض النظر عن البرمجيات التي قد تصادفها لدى تحليل مجموعات البيانات الكبيرة، فهناك احتمالية عالية بأن تستفيد من معرفتك بلغة SQL للتعامل مع البيانات ضمن تلك الأدوات. إذ ستتمكن من اتباع منهجية مشابهة مع قواعد البيانات المتنوعة، الأمر الذي سيسهل عليك العمل ويجعله أشمل عبر مصادر البيانات المختلفة. وبالتالي تعدّ معرفة SQL من الأدوات الأساسية والضرورية التي يعتمد عليها محللو البيانات وعلماء البيانات على الدوام.

كما تُعد لغة SQL ضمن أول عشر لغات برمجة وفق مؤشر مجتمع البرمجة TIOBE، وهو مؤشر يُظهر شعبية لغات البرمجة وانتشارها.

تساعدك لغة SQL في التواصل مع الآخرين بخصوص البيانات

لربما تُمثّل مناقشة البيانات تحديًا في العديد من الأحيان، فقد يفهم الأشخاص اللغة المحكية بطرق مختلفة قليلًا عما هو مطلوب، ما يُنشئ غموضًا قد يؤدي بدوره إلى سوء الفهم وأخطاء في التواصل. ولكن بمعرفتك لأساسيات SQL، كفهم كيفية هيكلة البيانات وكيفية الاستعلام عنها بنفسك، وستكون أدق لدى التواصل مع زملائك وأعضاء فريقك.

فحتى إن لم تكن تنوي كتابة تعليمات SQL بنفسك، يمكنك استخدام خبرتك فيها لتوضيح متطلباتك وتوقعاتك بدقة. كما ستكون قادرًا على تحديد المشكلات المتعلقة بالبيانات التي تتلقاها، وتقديم تغذية راجعة واضحة وعملية لمحللي البيانات الذين يساعدونك في إعداد تلك البيانات.

وبالتالي، يمكنك النظر إلى SQL على أنها لغة مشتركة يفهمها الجميع في عالم البيانات. فحتى إن لم تستخدمها على نحوٍ مباشر، فإن الاستناد إلى المفاهيم المُستمدّة منها ستجعل تواصلك بخصوص البيانات أدق وأوضح.

تساعدك لغة SQL في تصميم قواعد بيانات أفضل

من الضروري لدى تكليفك بتصميم قاعدة بيانات، أن تأخذ أنماط البيانات التي ستُخزّن وكيفية الوصول إليها أو التعامل معها مُستقبلًا في الحسبان. فبالرغم أنّه من الممكن بالطبع تصميم قواعد البيانات اعتمادًا على الفهم الجيد لنظرية تصميم قواعد البيانات فقط، إلّا أنّ الانتقال من التصميم النظري إلى قاعدة البيانات الفعلية قد يكون صعبًا، وستعترض المصمم مفاجآت غير متوقعة في الغالب.

إذ سيُستخدم نوع من استعلامات SQL مع كل عملية استرجاع بيانات من قاعدة البيانات، وسواءً كتبت هذه الاستعلامات من قبل مُحلل البيانات أو أُنشئت عبر برمجيات مُتخصّصة. فإن فهمك لأنماط الاستخدام المطلوبة ومعرفتك لكيفية ترجمتها إلى استعلامات SQL قابلة للتنفيذ، سيمكنك من فهم كيفية وصول SQL إلى قاعدة البيانات الأساسية لاسترداد البيانات، وما الذي سيتعين على محرّك قاعدة البيانات إنجازه كاستجابةً لهذا الاستعلام.

وبالتالي، يمكنك تصميم قواعد بيانات تلبي الغرض المطلوب باستخدام المعرفة التي اكتسبتها. وبمراعاتك لحالات الاستخدام التي يجب أن تدعمها قاعدة البيانات، يمكنك اختيار هيكلية لها تُسهّل إجراء استعلامات أبسط وأكفأ تُناسب سيناريوهات الاستخدام الشائعة.

كما يمكنك هيكلة الجداول على نحوٍ مدروس، مُسهلًا الوصول إلى البيانات باستخدام أنماط البيانات والعلاقات المُعتمدة على المفاتيح الخارجية والفهارس. بمعنى أنّك ستتعلم كيفية تصميم قواعد بيانات تُناسب أهدافك على نحوٍ أفضل.

تساعدك لغة SQL في كتابة تطبيقات أفضل

تستفيد العديد من أطُر التطوير الحديثة مثل أطُر تطوير الويب المشهورة لارافيل Laravel أو Symfony أو جانغو Django أو Ruby on Rails من طبقات تجريد البيانات، لاسيما أدوات التخطيط بين الكائنات وقواعد البيانات العلاقيَّة object-relational mappers إذ تهدف هذه الأدوات إلى تبسيط عملية الوصول إلى البيانات وتقديمها بشكل مبسّط للمبرمج. فبينما توفر هذه الأطُر طرقًا بديلة للتفاعل مع البيانات اعتمادًا على التعليمات البرمجية البسيطة الخاصّة بها موفرّةً البيانات التي تطلبها بسلاسة، إلا أن فهمك للغة SQL سيمكّنك من التعامل مع البيانات بشكل أكثر فعالية ودقة، حتى وإن لم تستخدم SQL مباشرة في عملية التطوير.

فبغض النظر عن العديد من الاختصارات والسهولة الكبيرة التي تقدمها أطر العمل، فإنها تُبنى استعلامات في محرك قاعدة البيانات الأساسي باستخدام جمل SQL خلف الكواليس من المدخلات الخاصة بك. وبالتالي فإن فهم كيفية عمل SQL يمكن أن يساعدك في استخدام ميزات الإطار البرمجي الذي اخترته لجعل الاستعلامات أسرع وأكثر فعالية، وبهذا يمكنك الاعتماد على معرفتك بكيفية بناء الإطار للاستعلامات في توجيه بنائها وتنفيذها على نحوٍ أمثل وصولًا إلى البيانات المطلوبة.

ناهيك عن إمكانية تصحيح أي مشكلات في الاستعلام عن البيانات ومعالجتها على نحوٍ أسهل. فغالبًا ما تُعيد محركات قواعد البيانات أخطاء تُشير إلى الجزء الذي فشل من الاستعلام المُنفّذ فعليًا باستخدام SQL. وبالرغم من دقة هذه الأخطاء، يبقى تحديد مصدر المشكلة ضمن الصياغة الخاصة بالإطار المستخدم أمرًا صعبًا، ولكن فهمك لأخطاء قواعد البيانات سيمكنك من تحديد المشكلة بدقة.

وأخيرًا وليس آخرًا، ستكون أكثر وعيًا بالمخاطر الأمنية الناتجة عن استخدام استعلامات SQL على نحوٍ غير صحيح وخطير، مثل هجمات حقن SQL، كما ستكون قادرًا على مواجهتها والتصدي لها.

فبفضل معرفتك بلغة SQL، ستمتلك السيطرة الكاملة على كيفية الوصول إلى البيانات، سواء قررت استخدام SQL مباشرةً أو اخترت العمل مع طبقات التجريد وأدوات التخطيط بين الكائنات وقواعد البيانات العلاقية ضمن الأطُر البرمجية.

لغة SQL سهلة التعلم للمبتدئين

هناك العديد من الفوائد المرتبطة بفهم وتطبيق لغة الاستعلام الهيكلية في الواقع العملي. ولعلّ أحد أبرز ما يميزها هو سهولة تعلمها للمبتدئين. إذ تمتاز هذه اللغة بوضوحها ودقتها واستخدامها لكلمات إنجليزية شائعة كأسماء للعمليات والمُرشحات (عوامل التصفية) وغيرها من الواصفات (العناصر التي تغير أو تحدد سلوك الاستعلام). فيمكنك قراءة استعلامات SQL في كثير من الأحيان على هيئة جمل مكتوبة باللغة الإنجليزية، ما يجعلها مفهومة حتى دون وجود خلفية برمجية.

ربما تجد بعض الجوانب الصعبة والمعقدة في اللغة والتي تحتاج إلى جهد لفهمها والتمرن عليها. ولكن بالمقابل يمكنك فهم وتعلم أساسيات لغة SQL بشكل ميسر. ومع استخدامك المتواصل لها في عملك اليومي، ستصبح عملية تعلم الأمور الأصعب أكثر فعالية لأنها تتم وفقًا لاحتياجاتك الفعلية للبيانات. وبالتالي يمكنك البدء مع أساسيات SQL، ومن ثم تطوير فهمك للغة تدريجيًا كلما احتجت لاستخدام طرق استعلام جديدة. والجيد في الأمر أنّ إجراء التجارب والتعامل مع SQL أثناء الاستعلام عن البيانات أمر سهل وخالٍ من المخاطر من ناحية فقدان البيانات، ما يوفّر لك الشعور بالأمان والراحة أثناء رحلة التعلّم.

ستحصل بتعلمك للغة SQL على فوائد تتجاوز بكثير الوقت المستغرق في ذلك، وتكتسب طرقًا جديدة لاسترجاع البيانات من عدة المصادر وتحليلها وتحقق الاكتفاء الذاتي في حاجتك لتحليل البيانات، ما يفتح آفاق وظيفية جديدة في مجالات متعددة.

الخلاصة

غدت لغة SQL أكثر لغات الاستعلام عن البيانات ومعالجتها شيوعًا وشهرة بفضل مرونتها وسهولة استخدامها وتطبيقها في مجالات متعددة ذات صلة بالبيانات. وبالتالي، سيوفر لك تعلمها العديد من الفوائد الجليّة، حتى وإن لم تكن وظيفتك الرئيسية مرتبطة مباشرةً بقواعد البيانات أو بتطوير البرمجيات.

ترجمة -وبتصرف- للمقال Why You Should Learn SQL لصاحبه Mateusz Papiernik.

اقرأ أيضًا

• المقال السابق: فهم قواعد البيانات العلاقية
• ما هي تقنية SQL؟
• أهمية قواعد البيانات
• أنواع قواعد البيانات وأهم مميزاتها واستخداماتها
• تعرف على مكونات قاعدة البيانات
• ما هي محركات قواعد البيانات؟

تعدّ أنظمة إدارة قواعد البيانات Relational database management system أو اختصارًا DMBS برامج حاسوبية تسمح للمستخدمين بالتفاعل مع قاعدة البيانات وتتيح لهم إمكانية التحكّم بالوصول إلى قاعدة البيانات وكتابة البيانات فيها وتنفيذ الاستعلامات Queries التي تستخلص البيانات أو تعدلها وإنجاز أي مهمّة أخرى ذات صلة بإدارة قواعد البيانات.

وبالتالي كي تتمكن من إنجاز أي من هذه المهام، يجب أن تمتلك أنظمة DMBS نموذجًا أساسيًا يُعرّف كيفية تنظيم البيانات. وإحدى منهجيات تنظيم البيانات التي لاقت استخدامًا واسعًا في برمجيات قواعد البيانات منذ ابتكارها في أواخر ستينيات القرن الماضي هي النموذج العلاقيّ أو العلائقي Relational، لدرجة أنّه وحتى وقت كتابة هذا المقال فإنّ أربعة من بين أكثر خمسة أنظمة لإدارة قواعد البيانات شيوعًا هي من النمط العلاقيّ.

يوضّح هذا المقال المفاهيمي النظري تاريخ النموذج العلاقيّ وكيفية تنظيم البيانات في قواعد البيانات العلاقيَّة وكيفية استخدامها في تطبيقاتنا المختلفة.

تاريخ النموذج العلاقي

قواعد البيانات عبارة عن مجموعات من المعلومات أو البيانات المُنظّمة منطقيًا. إذ تُعدّ أي مجموعة من البيانات كقاعدة بيانات، بغض النظر عن كيفية أو مكان تخزينها. فحتى درج الملفات المُتضمّنة لمعلومات الرواتب يُعدّ قاعدة بيانات، كذلك الأمر بالنسبة لأي مجموعة مُكدّسة من البيانات مثل نماذج المرضى في مستشفى، أو معلومات مجموعة من عملاء شركة موزعة عبر عدّة مواقع. فقبل أن تغدو عملية تخزين وإدارة البيانات باستخدام الحواسيب شائعة، كانت قواعد البيانات المادية كهذه في الأمثلة السابقة هي الوحيدة المتاحة للحكومات والمنظمات التجارية التي كانت بحاجة لتخزين المعلومات.

وفي منتصف القرن العشرين تقريبًا، شهدت علوم الحاسوب تطورات كبيرة أفضت إلى ظهور أجهزة ذات قدرة معالجة أعلى وسعات تخزين محلية وخارجية أكبر. جعلت هذه التطورات علماء الحاسوب يُدركون القدرات الهائلة لهذه الأجهزة في تخزين وإدارة كميات أكبر من البيانات.

ولكن لم تكن هناك حينها نظريات مُحدّدة حول كيفية تنظيم البيانات في الحواسيب بطرق منطقية ذات معنى فقد كان من السهل تخزين البيانات عشوائيًا على جهاز ما، لكن تصميم أنظمة قواعد البيانات سيتيح إمكانية إضافة واسترجاع وترتيب وإدارة هذه البيانات بطرق عملية وثابتة هو تحدٍ أكبر. فقد أسفرت الحاجة إلى وجود نظام منطقي لتخزين وتنظيم البيانات إلى ظهور العديد من الاقتراحات حول كيفية استخدام الحواسيب في إدارة البيانات.

ولعلّ أحد النماذج الأولية لقواعد البيانات كان النموذج الهرمي، حيث تنظم البيانات وفق هذا النموذج ضمن هيكلية أو بنية شبيهة بالشجرة بأسلوب مماثل لأنظمة الملفات. ويوضّح المثال التالي الشكل الذي قد يبدو عليه جزء من مخطط قاعدة بيانات هرمية تستخدم لتصنيف الحيوانات:

لقد طُبِّق النموذج الهرمي على نحوٍ واسع في أنظمة إدارة قواعد البيانات الأولية، لكنه أظهر بالمقابل بعض الصعوبات من حيث المرونة. ففي هذا النموذج يمكن للسجل الواحد امتلاك عدّة أبناء Children، لكن لا يمكنه أن يتبع سوى لأب Parent واحد ضمن الهيكلية الهرمية، الأمر الذي يجعل قواعد البيانات الهرمية قادرة على التعبير فقط عن علاقات من نوع "واحد-إلى-واحد (one-to-one)" و"واحد-إلى-عديد (one-to-many)" ولا يسمح بالتعبير عن العلاقات من نوع "عديد-إلى-عديد (many-to-many)"، وهذا القصور قد يفضي إلى حدوث مشاكل لدى التعامل مع نقاط بيانات تتبع لأكثر من أب.

إلى أن ابتكر عالم الحاسوب إدجار فرانك كود Edgar F. Codd والذي كان يعمل في شركة IBM النموذج العلاقيّ لإدارة قواعد البيانات وذلك في أواخر ستينيات القرن الماضي. إذ سمح نموذج Codd العلاقيّ هذا بربط السجل الواحد بأكثر من جدول، ما سمح بإمكانية التعبير عن العلاقات من نوع "عديد-إلى-عديد" بين نقاط البيانات ممكنة، بالإضافة إلى إمكانية التعبير عن العلاقات من نوع "واحد-إلى-عديد". الأمر الذي أتاح المزيد من المرونة مقارنةً بالنماذج الموجودة حينها لتصميم هياكل قواعد البيانات وأثبت قدرة أنظمة إدارة قواعد البيانات العِلاقيَّة (RDBMSs) على تلبية مجموعة أوسع بكثير من احتياجات الأعمال.

كما اقترح العالم كود Codd لغة لإدارة البيانات العلاقيَّة عُرِفت باسم ألفا (Alpha)، والتي أثّرت في تطوير لغات قواعد البيانات اللاحقة. فقد أنشأ اثنان من زملائه في IBM وهما دونالد تشامبرلين Donald Chamberlin وريمون بويس Raymond Boyce لغة مستوحاة من لغة ألفا، أطلقا عليها اسم SEQUEL اختصارًا لعبارة Structured English Query Language (لغة الاستعلام الهيكلية بالإنجليزية)، ولكن بسبب وجود علامة تجارية موجودة مسبقًا بنفس الاسم، اختصروا اسم لغتهم إلى SQL والتي يُشار إليها على نحوٍ أكثر رسمية باسم لغة الاستعلام الهيكلية Structured Query Language.

كانت قواعد البيانات العلاقيَّة الأولية بطيئة للغاية وغير عملية بسبب قيود العتاد، واحتاجت بعض الوقت حتى تنتشر، ولكن ومع حلول منتصف الثمانينات، طُبّق نموذج Codd العِلاقيّ في العديد من المنتجات التجارية لإدارة قواعد البيانات، سواء من قبل شركة IBM أو منافسيها.

إذ قام هؤلاء المُصنعّون أيضًا باتباع خطى IBM من خلال تطوير وتنفيذ لهجاتهم الخاصة من لغة SQL. وبحلول عام 1987، صادق كل من المعهد الوطني الأمريكي للمعايير American National Standards Institute والمنظمة الدولية للمعايير International Organization for Standardization على معايير لغة SQL ونشروها، ما جعل منها اللغة المعترف بها لإدارة أنظمة قواعد البيانات العلاقيَّة.

ولعلّ انتشار استخدام النموذج العلاقيّ في مجموعة متنوعة من المجالات جعل منه النموذج المعياري لإدارة البيانات. وحتى مع ظهور العديد من قواعد البيانات غير العلاقية NoSQL في السنوات الأخيرة، تبقى قواعد البيانات العلاقية هي السائدة لتخزين وتنظيم البيانات.

كيف تنظم قواعد البيانات العلاقية البيانات

الآن وبعد حصولك على فهمٍ عام لتاريخ النموذج العلاقيّ، لنلقِ نظرة أعمق على كيفية تنظيم البيانات وفق هذا النموذج.

لعلّ أهم عناصر النموذج العلاقيّ هي العلاقات Relations، والتي تُعرف لدى المستخدمين وفي أنظمة إدارة قواعد البيانات العِلاقيَّة المعاصرة بمسمى الجداول Tabels. فالعلاقة هي مجموعة من الصفوف أو السجلات في جدول، ويشترك كل صف بمجموعة من السمات أو الأعمدة (الحقول):

العمود هو أصغر هيكل تنظيمي في قاعدة البيانات العلاقيَّة، وهو يُمثّل الخصائص المختلفة التي تُعرّف السجلات ضمن الجدول. ولذا، تُعرف هذه الخصائص رسميًا باسم السمات. يمكن فهم كل صف على أنّه نسخة فريدة تًمثّل نوع ما من الأشخاص أو الكائنات أو الأحداث أو الروابط المحفوظة في الجدول. وقد تُمثّل هذه النسخ موظفي شركة أو مبيعات شركة تجارية عبر الإنترنت أو نتائج اختبارات مخبرية. على سبيل المثال، في جدول يحتوي على سجلات المدرسين في مدرسة ما، قد تتضمن الصفوف سمات مثل: الاسم name والمقررات الدراسية subjects وتاريخ بدء العمل start_date، وما إلى ذلك.

ولدى إنشاء الأعمدة، يتعيّن عليك تحديد نمط البيانات الخاص بكل عمود، وهو ما يُحدّد القيم التي يمكن استقبالها فيه. وعادةً ما تُقدّم أنظمة إدارة قواعد البيانات العِلاقيَّة أنماطًا فريدة خاصة بها من البيانات والتي قد لا تكون متوافقة مباشرةً مع مثيلاتها في الأنظمة الأخرى. ومن أنماط البيانات شائعة الاستخدام كل من التواريخ، والسلاسل النصية، والأعداد الصحيحة، والقيم المنطقية.

يتضمّن كل جدول في النموذج العِلاقيّ عمودًا واحدًا على الأقل يُستخدم لتمييز كل سجل على نحوٍ فريد، ويُعرف باسم المفتاح الأساسي Primary Key. وهو عمود مهم جدًا، إذ لا يحتاج المستخدمون لمعرفة مكان تخزين بياناتهم فيزيائيًا داخل الجهاز. وبدلاً من ذلك، يتولى نظام إدارة قواعد البيانات متابعة وتعقّب كل سجل واسترجاعه حسب الطلب. وبالتالي، لا يوجد ترتيب منطقي مُحدّد للسجلات، ويتمتّع المستخدمون بالحرية في استرجاع بياناتهم بالترتيب الذي يرغبون به أو باستخدام عوامل التصفية التي يختارونها.

فبفرض كان لديك جدولين وتود ربطهما ببعضهما البعض، فإحدى الطرق لإنجاز ذلك هي باستخدام المفتاح الخارجي Foreign key، وهو نسخة من المفتاح الأساسي لجدول (يُعرف بالجدول "الأب") تُدرج في عمود داخل جدول آخر (يُعرف بالجدول "الابن").
يُظهر المثال التالي العلاقة بين جدولين، الأول يُستخدم لتسجيل المعلومات حول الموظفين في شركة، والثاني لتتبع مبيعات الشركة. وفي هذا المثال، يُستخدم المفتاح الأساسي لجدول الموظفين EMPLOYEES كمفتاح أجنبي لجدول المبيعات SALES:

فإذا حاولت إضافة سجل إلى الجدول الابن وكانت القيمة المُدخلة في عمود المفتاح الأجنبي غير موجودة في المفتاح الأساسي للجدول الأب، فإن تعليمة الإدراج ستكون غير صالحة، وهذا يساعد في الحفاظ على صحّة مستوى العلاقة بين الجدولين (أو نزاهة العلاقة إن صح التعبير)، وبهذا ستكون السجلات في الجدولين مرتبطة على النحو الصحيح دائمًا.

لقد ساعدت عناصر النموذج العلاقيّ الهيكلية في الحفاظ على تنظيم البيانات أثناء تخزينها، ولكن تخزين البيانات لن يكون مفيدًا إلا إذا كان من الممكن استرجاعها. ولاسترجاع البيانات من RDBMS، يُمكنك إنشاء ما يُسمّى بالاستعلام query وهو عبارة عن طلب منظّم لمجموعة من المعلومات. وتستخدم معظم قواعد البيانات العِلاقيَّة لغة SQL لإدارة البيانات والاستعلام عنها كما أشرنا سابقًا. إذ تتيح لغة SQL إمكانية تصفية نتائج الاستعلام ومعالجتها باستخدام مجموعة من البنى clauses، والجمل الشرطية predicates التي تقيم كصحيح TRUE أو خاطئ  FALSE أو غير معروف، والتعبيرات expressions، ما يمنحك التحكم الدقيق في البيانات التي ستظهر ضمن نتائج الاستعلام.

مزايا وقيود قواعد البيانات العلاقية

لنفكّر في بعض مزايا وعيوب قواعد البيانات العلاقيَّة بأخذ هيكلها التنظيمي الأساسي في الحسبان.

إنّ لغة SQL وقواعد البيانات التي تستخدمها في أيامنا هذه تختلف عما قدمه العالم كود Codd في نموذجه العلاقيّ الأول في عدة نواحٍ. فعلى سبيل المثال، يملي نموذج كود Codd بأنّ كل سجل في الجدول يجب أن يكون فريدًا. في حين تسمح العديد من قواعد البيانات العلاقيَّة المعاصرة بوجود سجلات مكررة. وهناك بالمقابل من يرى أن قواعد البيانات التي تستخدم لغة SQL ولا تتبع جميع مواصفات نموذج Codd لا يمكن عدها قواعد بيانات علاقيَّة حقيقية. ولكن وفي الواقع، أي نظام يستخدم SQL ويتبع نموذج Codd إلى حد معين يعدّ عادةً نظامًا لإدارة قواعد بيانات علاقيَّة.

ورغم شهرة قواعد البيانات العِلاقيَّة التي ازدادت بسرعة، إلا أنّ بعض أوجه القصور المتعلقة في النموذج العِلاقيّ بدأت بالظهور مع تزايد قيمة البيانات وتوجه الشركات لتخزين كميات أكبر منها. ومن هذه التحديات والمعوقات، صعوبة توسيع قاعدة البيانات العلاقيَّة أفقيًا. والمقصود بالتوسع الأفقي أو الخارجي عملية إضافة المزيد من الأجهزة إلى نظام حالي لتوزيع الحمولة واستيعاب حركة مرور أكبر وتحقيق معالجة أسرع. وغالبًا ما تُقارن هذه العملية بالتوسع العمودي، الذي يتضمن تحسين مواصفات الخادم الحالي من خلال توسيع ذاكرة الوصول العشوائي RAM أو وحدة المعالجة المركزية CPU.

والسبب وراء صعوبة توسيع قاعدة البيانات العلاقيَّة أفقيًا يعود إلى أنّ النموذج العلاقيّ مصمم لضمان الاتساق أو انسجام البيانات consistency، ما يعني أنّه عند استعلام العملاء ضمن قاعدة البيانات نفسها سيحصلون دائمًا على البيانات نفسها. فإذا قمت بتوسيع قاعدة البيانات العلاقيَّة أفقيًا عبر عدة أجهزة، سيصبح من الصعب ضمان هذا الاتساق، إذ قد يقوم العملاء بكتابة البيانات على عقدة معينة أو (جهاز) دون الباقي، وقد يكون هناك تأخير بين لحظة الكتابة الأولية والوقت الذي تُحدّث فيه العقد الأخرى لتعكس هذه التغييرات، ما يؤدي إلى عدم اتساق بينها.

لقد واجهت أنظمة إدارة قواعد البيانات العلاقيَّة بعض التحديات، من بينها أن النموذج العلاقيّ قد صُمّم خصيصًا للتعامل مع البيانات المهيكلة structured data، أي البيانات التي تتوافق مع نمط بيانات مُحدد مسبقًا أو على الأقل تلك المُنظمّة على نحوٍ مُحدد. لكن مع انتشار الحواسيب الشخصية وظهور الإنترنت في أوائل التسعينات، أصبحت البيانات غير المهيكلة unstructured data، كالرسائل الإلكترونية والصور والفيديوهات أكثر شيوعًا.

لا يعني كل ذلك أن قواعد البيانات العلاقيَّة باتت غير مفيدة. بل على العكس تمامًا، فالنموذج العلاقيّ ما زال هو الإطار السائد لإدارة البيانات منذ أكثر من 40 عامًا. وتدلّ شهرتها واستمراريتها على أنّ قواعد البيانات العلاقيَّة تقنية ناضجة، وهذا بحد ذاته من أبرز مزاياها.

هناك العديد من التطبيقات التي صُممت للعمل مع النموذج العِلاقيّ، بالإضافة إلى وجود العديد من مدراء قواعد البيانات المحترفين الخبراء في مجال قواعد البيانات العلاقيَّة. كما تتوفر مجموعة واسعة من الموارد المطبوعة والإلكترونية متاحة لكل من يرغب في بدء التعامل مع قواعد البيانات العِلاقيَّة.

ومن مميزات قواعد البيانات العلاقيَّة دعم معظمها لمجموعة من التعاملات transactions التي تضمن سلامة البيانات وتكاملها. والمعاملة transaction هي مجموعة من أوامر SQL التي تُنفذ وفق تسلسل معيّن كوحدة عمل مُنفصلة. إذ تعتمد المعاملات على مبدأ الكل أو لا شيء، بمعنى أنّ كل أمر في المعاملة يجب أن يكون صحيحًا، وإلا ستُلغى المعاملة بالكامل وبهذا نضمن صحّة البيانات ودقتها (نزاهة البيانات) عند التعديل على عدة سجلات أو جداول في الوقت نفسه.

وأخيرًا، تعدّ قواعد البيانات العلاقيَّة مرنة للغاية. فقد استُخدمت في تطوير مجموعة واسعة من التطبيقات المختلفة، وتستمر في العمل بكفاءة حتى مع كميات ضخمة من البيانات. كما تعدّ لغة SQL قوية جدًا، إذ تتيح لك إمكانية إضافة وتعديل البيانات على نحوٍ فوري، بالإضافة إلى تغيير هيكلية تخطيط قواعد البيانات والجداول دون التأثير على البيانات الموجودة.

الخلاصة

تعرفنا في مقال اليوم على قواعد البيانات العلاقيَّة التي لا تزال وسيلة أساسية لإدارة وتخزين البيانات بعد أكثر من خمسين عامًا على وضع التصور الأولي لها، وذلك بفضل مرونتها وتصميمها الذي يضمن صحة البيانات ودقتها. وحتى مع ظهور قواعد البيانات غير العِلاقيَّة NoSQL في السنوات الأخيرة، لا زال فهم النموذج العلاقيّ ومعرفة كيفية التعامل مع أنظمة إدارة قواعد البيانات العلاقيَّة أمر أساسي لأي شخص يرغب في بناء التطبيقات المُعتمدة على قوة البيانات.

وللتعرّف على المزيد حول بعض من أنظمة إدارة قواعد البيانات العِلاقيَّة الأشهر، وقواعد البيانات عمومًا، ننصحكم بالرجوع إلى قسم قواعد البيانات من أكاديمية حسوب.

ترجمة -وبتصرف- للمقال Understanding Relational Databases لصاحبه Mark Drake.

اقرأ أيضًا

• مدخل إلى تصميم قواعد البيانات
• تعرف على مكونات قاعدة البيانات
• نموذج الكيان والعلاقة ER لتمثيل البيانات وتخزينها في قاعدة البيانات
• ما هي محركات قواعد البيانات؟
• أنواع قواعد البيانات وأهم مميزاتها واستخداماتها

لكي تستطيع استخدام قاعدة البيانات الأنسب لمشروعك، عليك أن تعرف ما هو الفرق بين قواعد بيانات العلائقية SQL، وقواعد بيانات NoSQL. ولهذا، سنستكشف معًا في هذا الفيديو الفروقات بينهما، وسنتحدث عن كيفية اختيار التقنية الأنسب لمشروعك.

إذا أردت التعرف أكثر على قواعد البيانات، فننصحك بالانضمام إلى دورة علوم الحاسوب، ولا تنسَ الاستعانة خلال رحلة تعلمك وعملك بتوثيقات موسوعة حسوب المجانية. وإذا أردت متابعة المعلومات البرمجية العلمية مكتوبة فيمكنك الاطلاع على قسم البرمجة في أكاديمية حسوب، كما يمكنك متابعة جديد الفيديوهات التقنية المتاحة على يوتيوب أكاديمية حسوب مجانًا.

سنشرح في هذا الفيديو SQL أو مايعرف بـ Structured Query Language أي لغة الاستعلام الهيكلية، حيث سنشرح لماذا نستخدم SQL ومالفائدة منها، مع تبيان أهم الخصائص التي تتميز بها لغة SQL وكيفية عملها.

يمكنك تعلم المزيد حول هذه اللغة عبر المقالات المتاحة على الأكاديمية بقسم SQL، كما يمكنك الاستفادة من المزيد من المعلومات المتاحة على كتاب ملاحظات للعاملين بلغة SQL. يمكنك أيضًا البدء بتعلم لغة SQL وأنظمة إدارة قواعد البيانات باحترافية أكبر في دورة علوم الحاسوب المقدمة من أكاديمية حسوب، ولا تنسى تدعيم معلوماتك عبر توثيق اللغة المتاح على موسوعة حسوب.

تُستخدَم لغة معالجة البيانات Data Manipulation Language -أو DML اختصارًا- الخاصة بلغة SQL للاستعلام عن البيانات في قاعدة البيانات وتعديلها، وسنشرح في هذا المقال كيفية استخدام تعليمات أوامر لغة SQL DML والتي هي SELECT وINSERT وUPDATE، وDELETE المُعرَّفة كما يلي:

• SELECT: للاستعلام عن بيانات في قاعدة البيانات.
• INSERT: لإدخال بيانات في جدول.
• UPDATE: لتحديث بيانات في جدول.
• DELETE: لحذف بيانات من جدول.

في تعليمة SQL DML:

• يجب بدأ كل شرط في عبارة بسطر جديد.
• يجب انتظام بداية كل شرط مع بداية الشروط الأخرى.
• إذا تألّف شرط من عدة أجزاء، فيجب توضُّع هذه الأجزاء على سطور منفصلة، كما يجب إضافة مسافة بادئة لها تحت بداية الشرط لإظهار العلاقة.
• تُستخدَم الأحرف الكبيرة لتمثيل الكلمات المحجوزة.
• تُستخدَم الحروف الصغيرة لتمثيل الكلمات التي يُعرِّفها المستخدِم.

تعليمة SELECT

تسمح التعليمة أو الأمر SELECT للمستخدِم باستخراج البيانات من الجداول، بناءً على معايير محدَّدة، حيث تُعالَج وفقًا للتسلسل التالي:

• SELECT DISTINCT اختيار عنصر أو مجموعة عناصر.
• FROM من جدول أو مجموعة جداول.
• WHERE يليها تعبير شرطي.
• GROUP BY يليها حقل أو مجموعة حقول.
• ORDER BY يليها مجموعة حقول.

يمكننا استخدام تعليمة SELECT لإنشاء قائمة بهواتف الموظفين من جدول الموظفين Employees كما يلي:

SELECT  FirstName, LastName, phone
FROM Employees
ORDER BY LastName

سيعرض هذا الإجراء اسم عائلة last name الموظف، واسمه الأول first name، ورقم هاتفه phone number من جدول الموظفين Employees كما في الجدول التالي:

سنستخدم في المثال التالي جدول الناشرين Publishers table الذي يمثِّله الجدول الآتي، حيث ستلاحظ أنّ كندا Canada مكتوبة بطريقة خاطئة في حقل بلد الناشر Publisher Country المقابل لحقل اسم الناشر Example Publishing، ومدينة الناشر ABC Publishing.

استخدم تعليمة UPDATE لتصحيح الأخطاء وتوحيد حقل البلد ليصبح Canada، -كما سنتكلم لاحقًا عن تعليمة UPDATE في هذا المقال.

إذا أضفتَ اسم الناشر Publisher Name، ومدينة الناشر Publisher City، فستستخدِم تعليمة SELECT، ويتبعها اسم الحقول التي يُفصَل بينها بفاصلة أجنبية comma، أي كما يلي:

SELECT PubName, city
FROM Publishers

سيؤدي هذا الإجراء إلى عرض اسم الناشر ومدينته من جدول الناشرين.

إذا أردت عرض حقل اسم الناشر باسم حقل المدينة -أي تبديل اسم الحقل PubName ليصبح city-، فاستخدِم تعليمة SELECT مع عدم وضع فاصلة أجنبية بين Pub_Name وcity، أي كما يلي:

SELECT PubName city
FROM Publishers

سيعرض تنفيذ هذا الإجراء فقط الحقل PUB_NAME من جدول الناشرين، بحيث يكون له العنوان city.

يفترض SQL Server أنك تريد وضع اسم عمود جديد للحقل PUB_NAME إذا لم تضمّن الفاصلة الأجنبية.

تعليمة SELECT مع معيار WHERE

قد ترغب أحيانًا في التركيز على جزء من جدول الناشرين، مثل الناشرين الموجودين في مدينة فانكوفر Vancouver فقط، إذ ستستخدم في هذه الحالة عبارة SELECT مع معيار WHERE، أي كما يلي: 'WHERE city = 'Vancouver.

يوضِّح المثالان الأوليّان التاليان كيفية تحديد اختيار سجل مع المعيار WHERE باستخدام BETWEEN، إذ يعطي كل من هذين المثالَين نتائج تخزين العناصر نفسها التي عددها بين 20 و50 عنصر في المخزن.

يستخدم المثال رقم 1 الكمية التي قيمتها بين 20 و50 عنصر مع تضمين العنصرين 20 و50 بالصورة التالية: qty BETWEEN 20 and 50.

SELECT StorID, qty, TitleID
FROM Sales
WHERE qty BETWEEN 20 and 50

يستخدِم المثال رقم 2 الشرط qty >=20 and qty <=50.

SELECT StorID, qty, TitleID
FROM Sales
WHERE qty >= 20 and qty  <= 50

يوضِّح المثال رقم 3 كيفية تحديد اختيار سجل مع المعيار WHERE باستخدام NOT BETWEEN.

SELECT StorID, qty, TitleID
FROM Sales
WHERE qty NOT BETWEEN 20 and 50

يظهر المثالان التاليان طريقتَين مختلفتَين لتحديد اختيار سجل مع المعيار WHERE باستخدام IN مع النتائج نفسها.

يوضح المثال رقم 4 كيفية اختيار السجلات باستخدام حقل المقاطعة province من جدول Publishers -أي =province- على أساس جزء من تعليمة WHERE.

SELECT *
FROM Publishers
WHERE province = 'BC' OR province = 'AB' OR province = 'ON'

يوضِّح المثال رقم 5 كيفية اختيار السجلات باستخدام المقاطعة province مع IN على أساس جزء من تعليمة WHERE:

SELECT *
FROM Publishers
WHERE province IN (‘BC’, ‘AB’, ‘ON’)

يوضِّح المثالان الأخيران كيف يمكن استخدام NULL وNOT NULL لتحديد السجلات، ولكن سنستخدم في هذين المثالين جدول الكتب Books table الغير موضَّح هنا، والذي يحتوي على حقول، وهي: العنوان Title، والكمية Quantity، وسعر الكتاب Price، وكل ناشر لديه جدول كتب يعطي قائمةً بجميع كتب الناشر.

يستخدِم المثال رقم 6 القيمة NULL:

SELECT price, title
FROM Books
WHERE price IS NULL

يستخدِم المثال رقم 7 القيمة NOT NULL:

SELECT price, title
FROM Books
WHERE price IS NOT NULL

استخدام محارف البدل wildcards في شرط LIKE

يحدِّد الشرط LIKE الصفوف التي تحتوي على الحقول التي تطابق أجزاءً محددة من سلاسل محرفية، كما يُستخدَم LIKE مع البيانات التي من النوع char وvarchar وtext وdatetime وsmalldatetime.

يسمح محرف البدل wildcard للمستخدِم بمطابقة الحقول التي تحتوي على محارف معينة، حيث سيعطي محرف البدل '%province = 'N جميع المقاطعات التي تبدأ بالمحرف N.

يوضِّح الجدول التالي أربعة طرق لتحديد محارف البدل في تعليمة SELECT في صيغة التعبير المنتظم:

تبحث التعليمة '%LIKE 'Mc في المثال رقم 1 عن جميع أسماء العائلة last names التي تبدأ بالمحرفين Mc مثل McBadden:

SELECT LastName
FROM Employees
WHERE LastName LIKE 'Mc%'

تبحث التعليمة 'LIKE '%inger في المثال رقم 2 عن جميع أسماء العائلة التي تنتهي بالمحارف inger، مثل Ringer وStringer:

SELECT LastName
FROM Employees
WHERE LastName LIKE '%inger'

تبحث التعليمة '%LIKE '%en عن جميع أسماء العائلة التي تحتوي على المحرفين en، مثل Bennett وGreen وMcBadden:

SELECT LastName
FROM Employees
WHERE LastName LIKE '%en%'

تعليمة SELECT مع الشرط ORDER BY

يُستخدَم الشرط ORDER BY لترتيب السجلات في القائمة الناتجة، ويمكنك استخدام ASC لترتيب النتائج تصاعديًا، وDESC لترتيب النتائج تنازليًا.

يستخدِم المثال التالي ASC:

SELECT *
FROM Employees
ORDER BY HireDate ASC

يستخدم المثال التالي DESC:

SELECT *
FROM Books
ORDER BY type, price DESC

تعليمة SELECT مع الشرط GROUP BY

يُستخدَم الشرط GROUP BY لإنشاء خرج هو عبارة عن صف واحد لكل مجموعة، وينتج قيمًا موجِزةً للأعمدة المحدَّدة، كما هو موضَّح أدناه:

SELECT type
FROM Books
GROUP BY type

يستخدم المثال التالي التعليمة السابقة:

SELECT type AS 'Type', MIN(price) AS 'Minimum Price'
FROM Books
WHERE royalty > 10
GROUP BY type

إذا تضمنت تعليمة SELECT معيار WHERE ليكون السعر price قيمةً غير فارغة not null كما يلي:

SELECT type, price
FROM Books
WHERE price is not null

فستكون التعليمة التي تحتوي على شرط GROUP BY كما يلي:

SELECT type AS 'Type', MIN(price) AS 'Minimum Price'
FROM Books
WHERE price is not null
GROUP BY type

استخدام COUNT مع GROUP BY

يمكننا استخدام COUNT لإحصاء عدد العناصر الموجودة في حاوية container، ولكن إذا أردت حساب عدد عناصر مختلفة في مجموعات منفصلة مثل رخام ذي ألوان مختلفة، فسنستخدِم دالة COUNT مع الأمر GROUP BY.

توضح تعليمة SELECT أدناه كيفية حساب عدد مجموعات من البيانات باستخدام دالة COUNT مع الشرط أو الأمر GROUP BY:

SELECT COUNT(*)
FROM Books
GROUP BY type

استخدام AVG وSUM مع GROUP BY

يمكننا استخدام دالة AVG لتعطينا متوسط أي مجموعة، وتُستخدَم الدالة SUM لإعطاء المجموع.

يستخدِم المثال رقم 1 التالي دالة AVG مع الشرط GROUP BY type:

SELECT AVG(qty)
FROM Books
GROUP BY type

يستخدِم المثال رقم 2 التالي دالة SUM مع الشرط GROUP BY type:

SELECT SUM(qty)
FROM Books
GROUP BY type

يستخدِم المثال رقم 3 كلًا من الدالتين AVG، وSUM مع الشرط GROUP BY type في تعليمة SELECT:

SELECT 'Total Sales' = SUM(qty), 'Average Sales' = AVG(qty), stor_id
FROM Sales
GROUP BY StorID ORDER BY  'Total Sales'

تقييد الصفوف مع HAVING

يمكن استخدام الشرط HAVING لتقييد الصفوف، فهو يشبه شرط WHERE باستثناء أنه يتضمّن دالة تجميع aggregate function؛ إذ لا يستطيع الشرط WHERE فعل ذلك، أي يتصرّف الشرط HAVING مثل الشرط WHERE، ولكنه قابل للتطبيق على المجموعات.

نستخدم في هذا المثال الشرط HAVING لاستبعاد المجموعات التي مقاطعتها 'BC'.

SELECT au_fname AS 'Author"s First Name', province as 'Province'
FROM Authors
GROUP BY au_fname, province
HAVING province <> 'BC'

تعليمة INSERT

تضيف تعليمة INSERT صفوفًا إلى جدول، وأيضًا ما يلي:

• تحدِّد تعليمة INSERT الجدول أو العرض view التي ستُدخَل البيانات فيه.
• تعرض Column List قائمةً بالأعمدة التي ستتأثر بتعليمة INSERT.
• يجب توفير كل قيمة إذا حُذِف عمود.
• يمكن وضع الأعمدة في قائمة ضمن أي ترتيب إذا ضمّنتها.
• تحدِّد الكلمة VALUES البيانات التي تريد إدخالها في الجدول، وتكون VALUES إلزامية).

يجب عدم إدراج الأعمدة ذات الخاصية IDENTITY بصورة صريحة في column_list أو value_sclause.

صيغة تعليمة INSERT هي:

INSERT [INTO] Table_name | view name [column_list]
DEFAULT VALUES | values_list | select statement

تُطبَّق القواعد التالية عند إدخال صفوف باستخدام تعليمة INSERT:

• يؤدي إدخال سلسلة فارغة (' ') في عمود من النوع varchar، أو text إلى إدخال مسافة واحدة.
• تُحشَى جميع الأعمدة ذات النوع char على اليمين right-padded حتى تصل إلى الطول المحدد.
• تُزال جميع المسافات الزائدة من البيانات المدرجة في أعمدة من النوع varchar، باستثناء السلاسل التي تحتوي على مسافات فقط، إذ تُختصَر هذه السلاسل إلى مسافة واحدة فقط.
• إذا أخلَّت تعليمة INSERT بالقيد، أو الافتراض، أو القاعدة، أو إذا كان نوع البيانات خاطئًا، فستفشل هذه التعليمة، وسيعرض خادم SQL Server رسالة خطأ.

يمكن حدوث أحد الأشياء الثلاثة التالية للأعمدة التي لا تحتوي على قيم عند تحديد قيم بعض الأعمدة في column_list فقط:

1. تُدخَل قيمة افتراضية إذا كان للعمود قيد DEFAULT، أو إذا كان الافتراض مرتبط بالعمود، أو إذا كان الافتراض مرتبط بنوع البيانات التي يعرِّفها المستخدم.
2. تُدخَل القيمة الفارغة NULL إذا سمح العمود بالقيم الفارغة، ولا توجد قيمة افتراضية موجودة للعمود.
3. تُعرَض رسالة خطأ ويُرفَض الصف إذا عُرَِف العمود بأنه غير فارغ NOT NULL، ولا توجد قيمة افتراضية.

يستخدِم المثال التالي تعليمة INSERT لإضافة سجل إلى جدول الكتّاب Authors:

INSERT INTO Authors
VALUES('555-093-467', 'Martin', 'April', '281 555-5673', '816 Market St.,' , 'Vancouver', 'BC', 'V7G3P4', 0)

يوضِّح المثال التالي كيفية إدخال صف جزئي partial row في جدول الناشرِين Publishers مع قائمة أعمدة.

يملك عمود الدولة country قيمة افتراضية هي Canada، لذلك لا يلزمك تضمينه في قيمك.

INSERT INTO Publishers (PubID, PubName, city, province)
VALUES ('9900', 'Acme Publishing', 'Vancouver', 'BC')

اتبع المثال التالي لإدخال صفوف في جدول مع عمود IDENTITY، ولا تعطي قيمةً للعمود IDENTITY، ولا قيمةً لاسم العمود ضمن قائمة الأعمدة.

INSERT INTO jobs
VALUES ('DBA', 100, 175)

إدخال قيم محددة ضمن عمود IDENTITY

لا يمكن إدخال البيانات مباشرة في عمود IDENTITY افتراضيًا، ولكن إذا حُذِف صف خطأً، أو إذا كانت هناك ثغرات في قيم عمود IDENTITY، فيمكنك إدخال صف وتحديد قيمة العمود IDENTITY.

IDENTITY_INSERT option

يمكن استخدام خيار IDENTITY_INSERT على النحو التالي للسماح بإدخال قيمة هوية identity محدَّدة:

SET IDENTITY_INSERT jobs ON
INSERT INTO jobs  (job_id, job_desc, min_lvl, max_lvl)
VALUES (19, 'DBA2', 100, 175)
SET IDENTITY_INSERT jobs OFF

إدخال صفوف باستخدام عبارة SELECT

يمكننا أحيانًا إنشاء جدول مؤقت صغير من جدول كبير، لذلك يمكننا إدخال صفوف مع تعليمة SELECT.

لا يوجد تحقق لصحة التفرد uniqueness عند استخدام هذا الأمر، وبالتالي، قد يكون هناك العديد من الصفوف بالمعرّف pub_id نفسه في المثال التالي.

ينشِئ هذا المثال جدول ناشرِين Publishers مؤقت هو tmpPublishers أصغر باستخدام تعليمة إنشاء جدول CREATE TABLE، ثم تُستخدَم تعليمة INSERT مع تعليمة SELECT لإضافة سجلات إلى جدول الناشرِين المؤقت من جدول الناشرين Publishers.

CREATE TABLE dbo.tmpPublishers (
PubID char (4) NOT NULL ,
PubName varchar (40) NULL ,
city varchar (20) NULL ,
province char (2) NULL ,
country varchar (30) NULL  DEFAULT ('Canada')
)
INSERT  tmpPublishers
SELECT * FROM Publishers

ننسخ في هذا المثال مجموعةً فرعيةً من البيانات:

INSERT tmpPublishers (pub_id, pub_name)
SELECT PubID, PubName
FROM Publishers

تُنسَخ بيانات الناشرين في هذا المثال إلى جدول tmpPublishers ويُضبَط عمود الدولة country إلى القيمة Canada:

INSERT tmpPublishers (PubID, PubName, city, province, country)
SELECT PubID, PubName, city, province, ‘Canada’
FROM Publishers

تعليمة UPDATE

تغيّر تعليمة UPDATE البيانات في الصفوف الموجودة إما بإضافة بيانات جديدة أو بتعديل البيانات الموجودة.

يستخدِم المثال التالي تعليمة UPDATE لتوحيد حقل الدولة country ليكون Canada لجميع السجلات في جدول Publishers:

UPDATE Publishers
SET country = 'Canada'

يزيد المثال التالي مبالغ حقوق المؤلف royalty التي قيمتها بين 10 و20 بنسبة 10%:

UPDATE roysched
SET royalty = royalty + (royalty * .10)
WHERE royalty BETWEEN 10 and 20

تضمين استعلامات فرعية subqueries ضمن عبارة UPDATE

يُمنَح الموظفون في جدول الموظفين Employees الذين وظّفهم الناشر في عام 2010 ترقيةً إلى أعلى مستوى وظيفي حسب نوع عملهم كما يلي:

UPDATE Employees
SET job_lvl =
(SELECT max_lvl FROM jobs
WHERE employee.job_id = jobs.job_id)
WHERE DATEPART(year, employee.hire_date) = 2010

تعليمة DELETE

تزيل تعليمة DELETE صفوفًا من مجموعة سجلات، كما تحدِّد عبارة DELETE الجدول أو العرض view الذي يحوي الصفوف التي ستُحذَف، ويمكن إدراج جدول أو صف واحد فقط في الوقت نفسه.

يُعَدّ الشرط WHERE المعيار الذي يحدِّد السجلات المراد حذفها، وتكون صيغة تعليمة DELETE كما يلي:

DELETE [FROM] {table_name | view_name }
[WHERE clause]

قواعد تعليمة DELETE هي:

1. إذا حُذِف شرط WHERE فستُزال جميع الصفوف الموجودة في الجدول باستثناء الفهارس indexes، والجدول، والقيود.
2. لا يمكن استخدام عبارة DELETE بعرض view يحتوي على شرط FROM يسمّي أكثر من جدول واحد، فتعليمة DELETE يمكن أن تؤثر على جدول أساسي فقط في الوقت نفسه.

فيما يلي ثلاث تعليمات DELETE مختلفة يمكن استخدامها:

1. حذف جميع الصفوف من جدول:

DELETE
FROM Discounts

2. حذف صفوف محدَّدة:

DELETE
FROM Sales
WHERE stor_id = '6380'

3. حذف صفوف بناءً على قيمة ضمن استعلام فرعي:

DELETE FROM Sales
WHERE title_id IN
(SELECT title_id FROM Books WHERE type = 'mod_cook')

الدوال المبنية مسبقا Built-in Functions

يوجد العديد من الدوال المبنية مسبقًا في SQL Server، مثل:

1. دوال التجميع Aggregate: ترجع قيمًا موجِزة summary values.
2. دوال التحويل Conversion: تحوِّل نوع بيانات معين إلى نوع آخر.
3. دوال التاريخ Date: تعرض معلومات عن التواريخ والأوقات.
4. الدوال الرياضية Mathematical: تجري عمليات على البيانات العددية.
5. الدوال المتعلِّقة بالسلاسل String: تجري عمليات على سلاسل المحارف، أو البيانات الثنائية، أو التعابير.
6. الدوال المتعلِّقة بالنظام System: ترجع معلومات من قاعدة البيانات.
7. الدوال المتعلِّقة بالنصوص Text، والصور image: تجري عمليات على بيانات نصية، أو على بيانات الصور.

سنشرح أدناه الدوال الأربع الأولى شرحًا مفصَّلًا مع أمثلة عنها.

دوال التجميع Aggregate functions

تجري دوال التجميع حسابات على مجموعة من القيم، وترجع قيمةً واحدةً أو قيمةً موجِزةً.

يعرض الجدول التالي هذه الدوال:

سنعرض فيما يلي أمثلةً عن كل من دوال التجميع الموجودة في الجدول السابق.

• المثال الأول: الدالة AVG

SELECT AVG (price) AS 'Average Title Price'
FROM Books

• المثال الثاني: الدالة COUNT

SELECT COUNT(PubID) AS 'Number of Publishers'
FROM Publishers

• المثال الثالث: الدالة COUNT

SELECT COUNT(province) AS 'Number of Publishers'
FROM Publishers

• المثال الرابع: الدالة (*) COUNT

SELECT COUNT(*)
FROM Employees
WHERE job_lvl = 35

• المثال الخامس: الدالة MAX

SELECT MAX (HireDate)
FROM Employees

• المثال السادس: الدالة MIN

SELECT MIN (price)
FROM Books

• المثال السابع: الدالة SUM

SELECT SUM(discount) AS 'Total Discounts'
FROM Discounts

دالة التحويل Conversion function

تحوّل دالة التحويل نوع بيانات معين إلى نوع بيانات آخر.

يُحوَّل السعر price الذي يحتوي ضمنه على تسعتين 99 إلى خمسة محارف في المثال الآتي، حيث تكون صيغة التعليمة بالصورة التالية:

SELECT 'The date is ' + CONVERT(varchar(12), getdate())

إليك مثال:

SELECT CONVERT(int, 10.6496)
SELECT title_id, price
FROM Books
WHERE CONVERT(char(5), price) LIKE '%99%'

مثال آخر عن تغيِّر دالة التحويل في المثال التالي البيانات إلى نوع بيانات بحجم مختلف:

SELECT title_id, CONVERT(char(4), ytd_sales) as 'Sales'
FROM Books
WHERE type LIKE '%cook'

دالة التاريخ Date function

تُنتج دالة التاريخ تاريخًا عن طريق إضافة فاصل زمني إلى تاريخ محدَّد، والنتيجة هي قيمة لها نوع datetime، وتساوي التاريخ مضافًا إليه عدد أجزاء التاريخ date parts.

إذا كان معامل دالة التاريخ قيمةً من النوع smalldatetime، فستكون النتيجة قيمةً من النوع smalldatetime أيضًا.

تُستخدَم الدالة DATEADD لإضافة وزيادة قيم التاريخ، وصيغة هذه الدالة هي: (DATEADD(datepart, number, date.

SELECT DATEADD(day, 3, hire_date)
FROM Employees

يستخدِم المثال الآتي الدالة (DATEDIFF(datepart, date1, date2، ويعيد هذا الأمر عدد أجزاء التاريخ أو الحدود boundaries المتقاطعة بين تاريخَين محددين.

تجعل طريقة حساب الحدود المتقاطعة النتيجة التي أعطتها الدالة DATEDIFF متوافقة مع جميع أنواع البيانات، مثل الدقائق، والثواني، والميلي ثانية.

SELECT DATEDIFF(day, HireDate, 'Nov 30 1995')
FROM Employees

يمكننا فحص أي جزء من تاريخ معيَّن من السنة إلى الميلي ثانية.

يعرض الجدول التالي أجزاء التاريخ DATEPART، واختصاراتها، وقيمها المقبولة التي يعترف بها خادم SQL Server.

الدوال الرياضية Mathematical functions

تجري الدوال الرياضية عمليات على البيانات العددية، ويعرض المثال التالي السعر الحالي لكل كتاب يبيعه الناشر، كما يعرض ما سيكون عليه الأمر إذا ارتفعت جميع الأسعار بنسبة 10%:

SELECT Price, (price * 1.1) AS 'New Price', title
FROM Books
SELECT 'Square Root' = SQRT(81)
SELECT 'Rounded' = ROUND(4567.9876,2)
SELECT FLOOR (123.45)

ربط الجداول Joining Tables

يُعَدّ ربط جدولين أو أكثر مثل عملية موازنة بيانات ضمن أعمدة محدَّدة، واستخدام نتائج الموازنة لتشكيل جدول جديد من الصفوف المؤهلة لذلك.

تقوم عبارة الربط join بما يلي:

• تحدِّد عمودًا من كل جدول.
• توازن القيم الموجودة في تلك الأعمدة صفًا صفًا.
• تدمج الصفوف ذات القيم المؤهلة ضمن صف جديد.

تكون الموازنة عادةً مساواةً -أي القيم التي تتطابق مع بعضها البعض تمامًا-، ولكن يمكن تحديد أنواع ربط أخرى أيضًا.

سنشرح جميع أنواع الربط المختلفة أدناه، مثل: الربط الداخلي inner، واليساري (الخارجي)، واليميني (الخارجي)، والربط المتقاطع cross join (التام).

الربط الداخلي Inner join

يربط جدولين في عمود له نفس نوع البيانات، وينتج الصفوف التي تتطابق فيها قيم العمود فقط، حيث يجري تجاهل الصفوف التي لا مثيل لها.

• المثال الأول:

SELECT jobs.job_id, job_desc
FROM jobs
INNER JOIN Employees ON emp
loyee.job_id = jobs.job_id
WHERE jobs.job_id < 7

• المثال الثاني:

SELECT authors.au_fname, authors.au_lname, books.royalty, title
FROM authorsINNER JOIN titleauthor ON authors.au_id=titleauthor.au_id
INNER JOIN books ON titleauthor.title_id=books.title_id
GROUP BY authors.au_lname, authors.au_fname, title, title.royalty
ORDER BY authors.au_lname

الربط اليساري الخارجي Left outer join

ينتج عن الربط الخارجي اليساري كل الصفوف الخارجية اليسرى، إذ تُضمَّن جميع الصفوف من الجدول الأيسر التي لا تحقّق الشرط المحدّد في مجموعة النتائج، وتُضبَط أعمدة الخرج من الجدول الآخر على القيمة الفارغة NULL.

يستخدِم المثال التالي الصيغة الجديدة للربط اليساري الخارجي:

SELECT publishers.pub_name, books.title
FROM Publishers
LEFT OUTER JOIN Books On publishers.pub_id = books.pub_id

بينما يستخدِم المثال التالي الصيغة القديمة للربط الخارجي اليساري:

SELECT publishers.pub_name, books.title
FROM Publishers, Books
WHERE publishers.pub_id *= books.pub_id

الربط الخارجي الأيمن Right outer join

يتضّمن الربط الخارجي الأيمن في مجموعة النتائج الخاصة به كافة الصفوف من الجدول الأيمن التي لا تحقّق الشرط المحدّد، وتُضبَط أعمدة الخرج المقابلة من الجدول الآخر على القيمة الفارغة NULL.

يستخدِم المثال التالي الصيغة الجديدة للربط الخارجي الأيمن:

SELECT titleauthor.title_id, authors.au_lname, authors.au_fname
FROM titleauthor
RIGHT OUTER JOIN authors ON titleauthor.au_id = authors.au_id
ORDERY BY au_lname

بينما يوضِّح المثال التالي الصيغة القديمة المستخدَمة للربط الخارجي الأيمن:

SELECT titleauthor.title_id, authors.au_lname, authors.au_fname
FROM titleauthor, authors
WHERE titleauthor.au_id =* authors.au_id
ORDERY BY au_lname

الربط الخارجي الكامل Full outer join

يحدِّد الربط الخارجي الكامل أنه في حالة عدم تطابق صف من أي من الجدولين مع معايير التحديد، فسيُضمَّن الصف في مجموعة النتائج، وتُضبَط أعمدة الخرج الخاصة به التي تتوافق مع الجدول الآخر إلى القيمة الفارغة NULL.

فيما يلي مثال عن ربط خارجي كامل:

SELECT books.title, publishers.pub_name, publishers.province
FROM Publishers
FULL OUTER JOIN Books ON books.pub_id = publishers.pub_id
WHERE (publishers.province <> "BC" and publishers.province <> "ON")
ORDER BY books.title_id

الربط المتقاطع Cross join

الربط المتقاطع هو ناتج دمج جدولين، وينتج عن هذا الربط صفوف حالة عدم استخدام الشرط WHERE نفسها، أي كما يلي:

SELECT au_lname, pub_name,
FROM Authors CROSS JOIN Publishers

للمزيد من المعلومات، انظر توثيق SQL في موسوعة حسوب.

ترجمة -وبتصرّف- للمقال SQL Data Manipulation Language لصاحبَيه Adrienne Watt و Nelson Eng.

اقرأ أيضًا

• المقال التالي: أمثلة عملية عن كيفية تصميم قواعد البيانات
• المقال السابق: نظرة سريعة على لغة الاستعلامات الهيكلية SQL
• الاعتماديات الوظيفية المستخدمة في تصميم قواعد البيانات
• قواعد السلامة وقيودها لضمان سلامة البيانات في قواعد البيانات
• الاستعلامات الفرعية والإجراءات في SQL
• البحث والتنقيب والترشيح في SQL
• معالجة الأخطاء والتعديل على قواعد البيانات في SQL
• النسخة العربية الكاملة لكتاب تصميم قواعد البيانات

لغة الاستعلامات الهيكلية Structured Query Language -أو SQL اختصارًا- هي لغة قاعدة بيانات مصمَّمة لإدارة البيانات الموجودة في نظام إدارة قواعد البيانات العلائقية.

طوّرت شركة IBM لغة SQL في أوائل السبعينات -عُرِفت بالإصدار 1986-، حيث صُمِّم الإصدار الأولي المسمَّى بلغة الاستعلامات الهيكلية الإنجليزية SEQUEL -اختصارًا للعبارة Structured English Query Language- لمعالجة واسترداد البيانات المخزَّنة في نظام خاص بشركة IBM وشبه علائقي لإدارة قواعد البيانات، ويُسمَّى نظام R.

قدّمت بعد ذلك شركة Relational Software Inc -والتي أصبحت الآن شركة Oracle Corporation- أول تطبيق متاح تجاريًا للغة SQL والمسمَّى بـ Oracle V2 لحواسيب VAX في أواخر السبعينات.

تُستخدَم العديد من أنظمة DBMS العلائقية المتاحة حاليًا، مثل: Oracle Database، وMicrosoft SQL Server -الموضَّح في الشكل التالي-، وMySQL، وIBM DB2، وIBM Informix، وMicrosoft Access، لغة SQL.

تُستخدَم لغة قاعدة بيانات SQL في نظام DBMS من أجل:

• إنشاء بنى قواعد البيانات والجداول.
• إجراء الأعمال الأساسية لإدارة البيانات، مثل الإضافة والحذف والتعديل.
• إجراء استعلامات معقَّدة لتحويل البيانات الأولية إلى معلومات مفيدة.

سوف نركز في هذا المقال على استخدام لغة SQL لإنشاء بنى قواعد البيانات والجداول، باستخدام لغة SQL على أساس لغة تعريف بيانات data definition language -أو DDL اختصارًا- بصورة أساسية.

سنستخدم لغة SQL في مقال لاحق على أساس لغة معالجة بيانات data manipulation language -أو DML اختصارًا- لإدخال البيانات، وحذفها، واختيارها، وتحديثها في جداول قاعدة البيانات.

إنشاء قاعدة بيانات Create Database

تتكوّن عبارات لغة SQL DDL الرئيسية من: CREATE DATABASE وCREATE/DROP/ALTER TABLE، إذ تُستخدَم عبارة CREATE في لغة SQL لإنشاء بنى قواعد البيانات والجداول.

إنشاء قاعدة بيانات

تُنشَأ قاعدة بيانات جديدة تسمَّى SW باستخدام العبارة CREATE DATABASE SW بلغة SQL. الخطوة التالية بعد إنشاء قاعدة البيانات هي إنشاء جداول قاعدة البيانات.

التنسيق العام للأمر CREATE TABLE هو:

CREATE TABLE <tablename>
(
ColumnName, Datatype, Optional Column Constraint,
ColumnName, Datatype, Optional Column Constraint,
Optional table Constraints
);

يكون Tablename اسم جدول قاعدة البيانات مثل جدول الموظف Employee، كما يتكون كل حقل من الأمر CREATE TABLE من ثلاثة أجزا، هي:

1. اسم العمود ColumnName.
2. نوع البيانات Data type.
3. قيد عمود اختياري Optional Column Constraint.

يجب أن يكون اسم العمود ColumnName فريدًا في الجدول، وبعض الأمثلة على أسماء الأعمدة هي FirstName وLastName.

أما نوع البيانات Data Type، فيجب أن يكون نوع بيانات نظام أو نوع بيانات يعرِّفه المستخدِم، كما تملك العديد من أنواع البيانات حجمًا، مثل (CHAR(35 أو (Numeric(8,2 وإليك قائمة بأشهر أنواع البيانات:

• النوع Bit: بيانات أعداد صحيحة Integer لها قيمة 1 أو 0.
• النوع Int: بيانات أعداد صحيحة Integer لها القيم من ‎-2^31 أي (‎-2,147,483,648) حتى ‎2^31 – 1، أي (‎2,147,483,647).
• النوع Smallint: بيانات أعداد صحيحة Integer لها القيم من ‎(-32,768) 2^15 أي حتى ‎ 2^15 – 1أي 32,767.
• النوع Tinyint: بيانات أعداد صحيحة Integer لها القيم من 0 حتى 255.
• النوع Decimal: بيانات ذات دقة ثابتة وقياس رقمي لها القيم من ‎-10^38 -1 إلى‎ 10^38.
• النوع Numeric: مرادف للنوع decimal.
• النوع Timestamp: رقم فريد على مستوى قاعدة البيانات.
• النوع Uniqueidentifier: معرَّف فريد عالميًا globally unique identifier -أو GUID اختصارًا-.
• النوع Money: تتراوح قيم البيانات النقدية من ‎-2^63 أي ‎-922,337,203,685,477.5808 حتى ‎2^63 – 1 أي ‎922,337,203,685,477.5807 بدقة تصل إلى واحد من عشرة آلاف من الوحدة النقدية.
• النوع Smallmoney: تتراوح قيم البيانات النقدية من ‎-214,748.3648إلى ‎+214,748.3647 بدقة تصل إلى واحد من عشرة آلاف من الوحدة النقدية.
• النوع Float: بيانات أرقام ذات دقة عشرية تتراوح قيمها بين ‎ -1.79E + 308و ‎1.79E + 308.
• النوع Real: بيانات أرقام ذات دقة عشرية قيمها تتراوح من ‎-3.40E + 38 حتى ‎3.40E + 38.
• النوع Datetime: بيانات التاريخ والوقت تتراوح قيمها من January 1, 1753 إلى December 31, 9999 بدقة تبلغ واحد إلى ثلاثة أجزاء من مئة من الثانية، أو 3.33 ميلي ثانية.
• النوع Smalldatetime: بيانات التاريخ والوقت تتراوح قيمها من January 1, 1900 حتى June 6, 2079 بدقة تبلغ دقيقة واحدة.
• النوع Char: بيانات محارف ثابتة الطول وليست يونيكود بطول أقصى 8000 محرف.
• النوع Varchar: بيانات متغيرة الطول وليست يونيكود بحد أقصى 8000 محرف.
• النوع Text: بيانات متغيرة الطول وليست يونيكود بطول أقصى يبلغ ‎2^31 – 1 أي ‎2,147,483,647 محرفًا.
• النوع Binary: بيانات ثنائية ذات طول ثابت بطول أقصى 8000 بايت.
• النوع Varbinary: بيانات ثنائية متغيرة الطول بطول أقصى يبلغ 8000 بايت.
• النوع Image: بيانات ثنائية متغيرة الطول بطول أقصى ‎2^31 – 1 أي‎ 2,147,483,647بايت.

أخيرًا في ما يتعلق بقيود العمود الاختيارية Optional Column Constraints، فهي الآتي:

• NULL.
• NOT NULL.
• UNIQUE.
• PRIMARY KEY.
• DEFAULT.

وتُستخدَم لتهيئة قيمة لسجل جديد.

يشير قيد العمود NULL إلى أن القيمة الفارغة null مسموح بها، مما يعني أنه يمكن إنشاء صف بدون قيمة لهذا العمود؛ كما يشير قيد العمود NOT NULL إلى وجوب توفير قيمة عند إنشاء صف جديد.

سنستخدم تعليمة لغة SQL للتوضيح والتي هي CREATE TABLE EMPLOYEES لإنشاء جدول موظفين يحتوي على 16 سمة attributes أو حقل fields.

USE SW
CREATE TABLE EMPLOYEES
(
EmployeeNo      CHAR(10)  NOT NULL  UNIQUE,
DepartmentName  CHAR(30)  NOT NULL  DEFAULT "Human Resources",
FirstName       CHAR(25)  NOT NULL,
LastName        CHAR(25)  NOT NULL,
Category        CHAR(20)  NOT NULL,
HourlyRate      CURRENCY  NOT NULL,
TimeCard        LOGICAL   NOT NULL,
HourlySalaried  CHAR(1)   NOT NULL,
EmpType         CHAR(1)   NOT NULL,
Terminated      LOGICAL   NOT NULL,
ExemptCode      CHAR(2)   NOT NULL,
Supervisor      LOGICAL   NOT NULL,
SupervisorName  CHAR(50)  NOT NULL,
BirthDate       DATE      NOT NULL,
CollegeDegree   CHAR(5)   NOT NULL,
CONSTRAINT      Employee_PK PRIMARY KEY(EmployeeNo)
);

الحقل الأول هو EmployeeNo من النوع CHAR، ويبلغ طول هذا الحقل 10 محارف، ولا يمكن للمستخدِم ترك هذا الحقل فارغًا NOT NULL، والحقل الثاني هو DepartmentName من النوع CHAR بطول 30.

يُستخدَم قيد الجدول المعرَّف بواسطة الكلمة CONSTRAINT لإنشاء المفتاح الأساسي primary key، وذلك بعد تعريف جميع أعمدة الجدول، أي كما يلي:

CONSTRAINT     EmployeePK      PRIMARY KEY(EmployeeNo)

يمكننا إنشاء جدول أقسام Department، وجدول مشاريع Project، وجدول مهام Assignment باستخدام الأمر CREATE TABLE بلغة SQL DDL، كما هو موضَّح في المثال التالي:

USE SW
CREATE TABLE DEPARTMENT
(
DepartmentName Char(35)  NOT NULL,
BudgetCode     Char(30)  NOT NULL,
OfficeNumber   Char(15)  NOT NULL,
Phone          Char(15)  NOT NULL,
CONSTRAINT DEPARTMENT_PK PRIMARY KEY(DepartmentName)
);

أُنشِئ جدول المشاريع project التالي بسبعة حقول هي: معرِّف المشروع ProjectID، واسم المشروع ProjectName، والقسم Department، والحد الأقصى للساعات MaxHours، وتاريخ البدء StartDate، وتاريخ الانتهاء EndDate.

USE SW
CREATE TABLE PROJECT
(
ProjectID       Int  NOT NULL IDENTITY (1000,100),
ProjectName     Char(50) NOT NULL,
Department      Char(35) NOT NULL,
MaxHours        Numeric(8,2)  NOT NULL DEFAULT 100,
StartDate       DateTime NULL,
EndDate         DateTime NULL,
CONSTRAINT      ASSIGNMENT_PK  PRIMARY KEY(ProjectID)
);

بينما أُنشِئ جدول المهام assignment بثلاثة حقول، هي: معرِّف المشروع ProjectID، ورقم الموظف EmployeeNumber، وساعات العمل HoursWorked.

يُستخدَم جدول المهام لتسجيل الموظف باستخدام الحقل EmployeeNumber، ومقدار الوقت باستخدام الحقل HoursWorked الذي عمل فيه الموظف في مشروع معين باستخدام الحقل ProjectID، أي كما يلي:

USE SW
CREATE TABLE ASSIGNMENT
(
ProjectID       Int  NOT NULL,
EmployeeNumber  Int  NOT NULL,
HoursWorked     Numeric(6,2)  NULL,
);

قيود الجدول Table Constraints

تُعرَّف قيود الجدول بواسطة الكلمة المفتاحية CONSTRAINT ويمكن استخدامها لتطبيق العديد من القيود الموضَّحة أدناه.

القيد IDENTITY

يمكننا استخدام قيد العمود الاختياري IDENTITY لتوفير قيمة فريدة تزايدية لهذا العمود، إذ تُستخدَم أعمدة الهوية Identity مع قيود المفتاح الرئيسي PRIMARY KEY لتكون بمثابة معرِّف صف فريد للجدول، كما يمكن إسناد الخاصية IDENTITY إلى عمود له نوع بيانات tinyint، أو smallint، أو int، أو decimal، أو numeric، وهذا القيد:

• يولِّد أرقامًا متسلسلةً.
• لا يفرض سلامة الكيان entity integrity.
• يمكن أن يحتوي عمود واحد فقط على الخاصية IDENTITY.
• يجب تعريفه على أساس نوع بيانات integer أو numeric أو decimal.
• لا يمكن تحديث عمود له الخاصية IDENTITY.
• لا يمكن أن يحتوي على قيم فارغة NULL.
• لا يمكنه ربط الافتراضات والقيود الافتراضية بالعمود.

بالنسبة للقيد [(IDENTITY[(seed, increment:

• Seed: هي القيمة الأولية لعمود الهوية identity.
• Increment: هي القيمة المطلوب إضافتها إلى عمود الزيادة increment الأخير.

سنستخدم مثال قاعدة بيانات آخر لتوضيح عبارات لغة SQL DDL بصورة أكبر من خلال إنشاء الجدول tblHotel في قاعدة بيانات الفندق HOTEL كما يلي:

CREATE TABLE  tblHotel
(
HotelNo   Int         IDENTITY (1,1),
Name      Char(50)    NOT NULL,
Address   Char(50)    NULL,
City      Char(25)    NULL,
)

القيد UNIQUE

يمنع القيد UNIQUE من إدخال قيم مكررة في عمود، حيث:

• يُستخدَم القيدان PK، و UNIQUE لفرض سلامة الكيان.
• يمكن تعريف قيود UNIQUE متعددة للجدول.
• يجري دائمًا التحقق من صحة البيانات الموجودة عند إضافة قيد UNIQUE إلى جدول موجود.
• يمكن وضع القيد UNIQUE على الأعمدة التي تقبل القيم الفارغة، حيث يمكن أن يكون صفٌ واحد فقط NULL.
• ينشِئ القيد UNIQUE دليلًا فريدًا للعمود المُختار تلقائيًا.

الصيغة التالية هي الصيغة العامة للقيد UNIQUE:

[CONSTRAINT constraint_name]
UNIQUE [CLUSTERED | NONCLUSTERED]
(col_name [, col_name2 […, col_name16]])
[ON segment_name]

يستخدم المثال التالي القيد UNIQUE كما يلي:

CREATE TABLE EMPLOYEES
(
EmployeeNo  CHAR(10)    NOT NULL    UNIQUE,
)

القيد FOREIGN KEY المفتاح الخارجي

يعرِّف القيد FOREIGN KEY -أو FK اختصارًا- عمودًا، أو مجموعة من الأعمدة التي تتطابق قيمها مع المفتاح الرئيسي PRIMARY KEY -أو PK اختصارًا- لجدول آخر، بحيث:

• تُحدَّث القيم في المفتاح الخارجي FK تلقائيًا عند تحديث أو تغيير قيم المفتاح الرئيسي PK في الجدول المرتبط.
• يجب أن تشير قيود المفتاح الخارجي FK إلى القيد المفتاح الرئيسي PK، أو القيد UNIQUE لجدول آخر.
• يجب أن يكون عدد أعمدة المفتاح الخارجي FK هو نفسه قيد المفتاح الرئيسي PK، أو قيد UNIQUE.
• إذا اُستخدِم الخيار WITH NOCHECK، فلن يتحقق قيد المفتاح الخارجي FK من صحة البيانات الموجودة في الجدول.
• لا يوجد دليل index للأعمدة التي تشارك في قيد المفتاح الخارجي FK.

الصيغة التالية هي الصيغة العامة لقيد المفتاح الخارجي FOREIGN KEY:

[CONSTRAINT constraint_name]
[FOREIGN KEY (col_name [, col_name2 […, col_name16]])]
REFERENCES [owner.]ref_table [(ref_col [, ref_col2 […, ref_col16]])]

يكون الحقل HotelNo في المثال التالي في الجدول tblRoom مفتاحًا خارجيًا FK للحقل HotelNo في الجدول tblHotel الموضَّح سابقًا:

USE HOTEL
GO
CREATE TABLE  tblRoom
(
HotelNo Int        NOT NULL ,
RoomNo  Int        NOT NULL,
Type    Char(50)   NULL,
Price   Money      NULL,
PRIMARY KEY (HotelNo, RoomNo),
FOREIGN KEY (HotelNo) REFERENCES tblHotel
)

القيد CHECK

يقيِّد القيد CHECK القيم التي يمكن إدخالها في جدول، بحيث:

• يمكن أن يحتوي على شروط بحث مشابهة لعبارة WHERE.
• يمكنه الربط بين الأعمدة في نفس الجدول.
• يجب تقييم قاعدة التحقق من صحة البيانات للقيد CHECK من خلال تعبير بولياني boolean expression.
• يمكن تعريفه لعمود له قاعدة مرتبطة به.

الصيغة التالية هي الصيغة العامة للقيد CHECK:

[CONSTRAINT constraint_name]
CHECK [NOT FOR REPLICATION] (expression)

يقتصر حقل النوع Type في المثال التالي على الأنواع "Single"، أو "Double"، أو "Suite"، أو "Executive".

USE HOTEL
GO
CREATE TABLE  tblRoom
(
HotelNo Int      NOT NULL,
RoomNo  Int      NOT NULL,
Type    Char(50) NULL,
Price   Money    NULL,
PRIMARY KEY (HotelNo, RoomNo),
FOREIGN KEY (HotelNo) REFERENCES tblHotel
CONSTRAINT Valid_Type
CHECK (Type IN ('Single', 'Double', 'Suite', 'Executive'))
)

يجب في المثال التالي أن يكون تاريخ تعيين الموظف قبل January 1, 2004، أو يجب أن يكون الحد الأقصى للراتب 300 ألف دولار:

GO
CREATE TABLE SALESREPS
(
Empl_num Int Not Null
CHECK (Empl_num BETWEEN 101 and 199),
Name     Char (15),
Age      Int     CHECK (Age >= 21),
Quota    Money   CHECK (Quota >= 0.0),
HireDate DateTime,
CONSTRAINT  QuotaCap CHECK ((HireDate < "01-01-2004") OR (Quota <=300000))
)

القيد DEFAULT

يُستخدَم القيد DEFAULT لتوفير قيمة تُضاف تلقائيًا لعمود ما إذا لم يوفّرها المستخدم، بحيث:

• يمكن احتواء العمود على قيد DEFAULT واحد فقط.
• لا يمكن استخدام القيد DEFAULT في الأعمدة التي لها نوع البيانات timestamp، أو الخاصية identity.
• ترتبط القيود DEFAULT تلقائيًا بعمود عند إنشائها.

الصيغة العامة للقيد DEFAULT هي:

[CONSTRAINT constraint_name]
DEFAULT {constant_expression | niladic-function | NULL}
[FOR col_name]

يضبط المثال التالي القيمة الافتراضية default لحقل المدينة city field على القيمة "Vancouver":

USE HOTEL
ALTER TABLE tblHotel
Add CONSTRAINT df_city DEFAULT ‘Vancouver’ FOR City

الأنواع التي يعرفها المستخدم User Defined Types

تعتمد الأنواع التي يعرِّفها المستخدِم دائمًا على نوع البيانات التي يوفرها النظام، فيمكن لهذه الأنواع فرض سلامة البيانات والسماح بالقيم الفارغة nulls.

اختر الأنواع التي تكون تحت الكلمة "Programmability" في قاعدة البيانات الخاصة بك، لإنشاء نوع بيانات يعرِّفه المستخدِم في خادم SQL Server، ثم انقر بزر الماوس الأيمن واختر المسار New’ –>‘User-defined data type’، أو نفّذ إجراء النظام sp_addtype المخزّن system stored procedure، ثم اكتب ما يلي:

sp_addtype ssn, 'varchar(11)', 'NOT NULL'

سيؤدي هذا إلى إضافة نوع بيانات جديد عرّفه المستخدم يسمى SIN بتسعة محارف.

يستخدم الحقل EmployeeSIN نوع البيانات SIN الذي عرّفه المستخدم في المثال التالي:

CREATE TABLE SINTable
(
EmployeeID     INT Primary Key,
EmployeeSIN    SIN,
CONSTRAINT CheckSIN
CHECK (EmployeeSIN LIKE
' [0-9][0-9][0-9] – [0-9][0-9] [0-9] – [0-9][0-9][0-9] ')
)

التعليمة ALTER TABLE

يمكن استخدام تعليمات ALTER TABLE لإضافة وحذف القيود، بحيث:

• تسمح تعليمة ALTER TABLE بإزالة الأعمدة.
• يُتحقق من جميع البيانات الموجودة عند إضافة قيد للتأكد من عدم وجود انتهاكات.

نستخدم في المثال التالي تعليمة ALTER TABLE للخاصية IDENTITY في الحقل ColumnName:

USE HOTEL
GO
ALTER TABLE  tblHotel
ADD CONSTRAINT unqName UNIQUE (Name)

استخدم تعليمة ALTER TABLE لإضافة عمود مع الخاصية IDENTITY مثل التعليمة ALTER TABLE TableName.

ADD
ColumnName  int IDENTITY(seed, increment)

التعليمة DROP TABLE

تزيل التعليمة DROP TABLE جدولًا من قاعدة البيانات، لذلك تأكد من تحديد قاعدة البيانات الصحيحة.

DROP TABLE tblHotel

سيؤدي تنفيذ عبارة DROP TABLE السابقة بلغة SQL إلى إزالة الجدول tblHotel من قاعدة البيانات.

تمارين

1. باستخدام المعلومات الخاصة بالتمرين الموجود في المقال قواعد السلامة والقيود المُطبَّقة عند تصميم قواعد البيانات، طبّق التخطيط باستخدام لغة Transact SQL -أي اعرض تعليمات SQL لكل جدول-، وطبّق القيود أيضًا.
2. أنشئ الجدول الموضَّح أدناه في خاوم SQL Server، واعرض التعليمات التي استخدمتها.

الجدول: Employee

3. اكتب شيفرة لغة SQL لإدخال صفوف الجدول السابق، بعد إنشاء بنيته.

استخدم الشكل السابق للإجابة على الأسئلة من 4 إلى 10.

4. اكتب شيفرة لغة SQL لتغيير رمز الوظيفة job code إلى 501 للموظف الذي رقمه 107، وافحص النتائج بعد الانتهاء من المهمة، ثم أعد ضبط رمز الوظيفة إلى قيمته الأصلية.
5. اكتب شيفرة لغة SQL لإعطاء قائمة بجميع السمات الخاصة برمز الوظيفة 502، بافتراض إدخال البيانات الموضَّحة في جدول الموظف Employee.
6. اكتب شيفرة لغة SQL لحذف الصف الخاص بالشخص الذي اسمه "William Smithfield"، والذي وُظِّف في June 22, 2004، والذي تصنيف رمز وظيفته هو 500.

اقتباس

تلميح: استخدم المعاملات المنطقية لتضمين جميع المعلومات الواردة في هذه المسألة.

7. أضف السمتين EMP_PCT، وPROJ_NUM إلى جدول الموظف، بحيث تكون السمة EMP_PCT هي نسبة المكافأة المدفوعة لكل موظف.
8. اكتب شيفرة لغة SQL باستخدام أمر واحد لإدخال رقم المشروع PROJ_NUM = 18 لجميع الموظفين الذين تصنيف الوظيفة JOB_CODE الخاص بهم هو 500.
9. اكتب شيفرة لغة SQL باستخدام أمر واحد لإدخال رقم المشروع PROJ_NUM = 25 لجميع الموظفين الذين تصنيف الوظيفة JOB_CODE الخاص بهم يساوي 502 أو أعلى.
10. اكتب شيفرة لغة SQL لتغيير رقم المشروع PROJ_NUM إلى 14 للموظفين الذين تعيّنوا قبل January 1, 1994، ورمز الوظيفة الخاصة بهم يساوي 501 على الأقل. (قد تفترض أن الجدول سيعاد إلى حالته الأصلية التي سبقت هذا السؤال).

ترجمة -وبتصرّف- للمقال SQL Structured Query Language لصاحبَيه Adrienne Watt وNelson Eng.

اقرأ أيضًا

• المقال التالي: لغة معالجة البيانات DML الخاصة بلغة SQL
• المقال السابق: عملية تطوير قواعد البيانات Database Development
• النسحة الكاملة من كتاب ملاحظات للعاملين بلغة SQL
• الاستعلامات الفرعية والإجراءات في SQL
• قواعد السلامة وقيودها لضمان سلامة البيانات في قواعد البيانات
• الاعتماديات الوظيفية المستخدمة في تصميم قواعد البيانات

SQL أو لغة الاستعلامات البنيوية (Structured Query Language) هي لغة برمجة متخصصة تُستخدَم لمعالجة وإدارة قواعد البيانات. وتُنطق سي كويل (See-Quel). تعد اللغة القياسية لأنظمة إدارة قواعد البيانات (RDBMS)، وتُستخدم تعليمات وأوامر SQL لإجراء عمليات مباشرة على البيانات، مثل:

• تحديث البيانات
• إدراج سجلات جديدة في قاعدة البيانات
• حذف السجلات
• استخلاص البيانات والتنقيب عنها
• إنشاء جداول لتخزين البيانات
• إنجاز مهام إدارية على قاعدة البيانات، مثل تأمين قاعدة البيانات وإنشاء النسخ الاحتياطية وإدارة المستخدمين.

تاريخ SQL

طوّرت شركة IBM لغة SQL في بداية السبعينات بإسهام من بويس رايموند (Raymond Boyce) ودونالد شامبرلين (Donald Chamberlin)، وكانت تُسمى آنذاك SEQUEL. كان الهدف من تطويرها هو إدارة ومعالجة نظام R، وهو نظام شبه علائقي لمعالجة قواعد البيانات (quasi-relational database management system).

سنة 1986، اعتمدت كل من المنظمة الأمريكية للمقاييس (ANSI) والمنظمة الدولية للمقاييس (ISO) لغة SQL كمقياس مرجعي، وقد تعاقبت بعد ذلك 9 إصدارات جديدة من المعيار، سنوات: 1989 و 1992 و 1996 و 1999 و 2003 و 2006 و 2008 و 2011 و 2016.

ما هي أنظمة معالجة قواعد البيانات العلائقية RDBMS؟

أنظمة معالجة قواعد البيانات العلائقية (Relational Database Management System) هي برامج تُستخدَم لمعالجة وإدارة قواعد البيانات العلائقية (Relational Database)، وهي قواعد تخزِّن البيانات وفق بنية مهيكلة في جداول تتألف من صفوف وأعمدة لتسهيل الوصول إلى القيم المخزنة. لكل جدول مفتاح فريد يميز كل صف من الجدول. وتُسمى "علائقية" (relational) لأنّ القيم المُخزّنة في الجداول متعلقة ببعضها بعضًا.

تجري أنظمة قواعد البيانات العديد من المهام، مثل:

• تأمين البيانات
• إنشاء النسخ الاحتياطية
• إدارة ومعالجة كميات ضخمة من البيانات
• تصدير البيانات أو استيرادها
• العمل على عدة جداول تزامنيا

هناك العديد من أنظمة معالجة قواعد البيانات، من أشهرها: Oracle و MySQL و Microsoft SQL Server و DB2. ورغم أنّ أكثرها تستخدم SQL، إلا أنّ لكل منها بعض الإضافات والصياغات الخاصة بها التي لا تُستخدم في الأنظمة الأخرى، بيْد أنّها تدعم جميعا الأوامر الأساسية للغة (SELECT و UPDATE و DELETE و INSERT و WHERE).

لماذا عليك تعلم SQL‎‎؟

إن كنت تتساءل عما إذا كانت SQL تستحق أن تتعلمها، فالنقاط التالية ستوضح لك بعض مزايا هذه اللغة:

1. سهولة التعلم: لغة SQL سهلة موازنة مع بقية لغات البرمجة، ذلك أنّها مخصصة لغرض واحد، وهو معالجة البيانات
2. معالجة البيانات الكبيرة: نحن نعيش في عصر الثورة الرقمية، ومن نتائج ذلك أنّ البيانات أصبحت متاحة بكميات ضخمة. ففي كل يوم تُنتج عدة تيرابايت من البيانات. بالطبع، يمكنك استخدام جداول البيانات العادية، مثل EXCEL وجداول جوجل، ولكنها مخصّصة لمعالجة كمية صغيرة أو متوسطة من البيانات. وهنا يأتي دور SQL، لأنها مصممة لمعالجة كميات ضخمة من البيانات بأداء وكفاءة عالية.
3. تطوير الويب: SQL هي إحدى المهارات الضرورية لكل مبرمجي الواجهة الخلفية للخادم، لأنها تُستخدم لمعالجة واسترجاع البيانات المُخزّنة في الخادم، بما فيها بيانات المستخدمين.
4. السرعة: لا تفعل SQL إلا شيئا واحدا فقط، وهو معالجة البيانات وإدارتها، وهي ممتازة فيما تفعله. فهي مُحسَّنة للدخول إلى البيانات بسرعة فائقة، ما يجعلها مثالية لتطبيقات الوقت الحقيقي.
5. فرص العمل: هناك طلب كبير على مبرمجي SQL في القطاع الخاص، ويُتوقع أن يزداد هذا الطلب في السنوات القادمة، خصوصا في العالم العربي الذي يعرف ازدهارا سريعا للاقتصاد الرقمي في السنوات الأخيرة.
6. الشهرة: في استطلاع stackoverflow لسنة 2019، حلت SQL في المرتبة الثالثة في قائمة أكثر تقنيات البرمجة استخداما من قبل المبرمجين على مستوى العالم. بعد جافاسكربت و HTML و CSS. إذ يستخدمها أكثر من نصف المبرمجين. هذا أمر طبيعي، لأنّ SQL هي إحدى أركان تقنيات الويب، ولا يمكن تطوير أي موقع ويب أو تطبيق بدون معرفة ولو بسيطة بها.
7. مفتوحة المصدر: SQL مفتوحة المصدر، كما أنّ لديها مجتمعا كبيرا، إن اعترضتك مشكلة أثناء تعلم SQL، فيمكن أن تطرح سؤالك على stackoverflow أو في قسم الأسئلة في أكاديمية حسوب.

المصدر

كيف أتعلم SQL؟

قد تسأل: كيف أتعلم SQL؟ شبكة الإنترنت غنية بالكتب والمراجع والمقالات عن SQL باللغة الإنجليزية، للأسف، من الصعب أن تجد محتوى عربيا عالي الجودة لتعلم SQL، أو أيّ مجال تقني آخر.

لمعالجة هذا الأمر وإثراء المكتبة العربية، أطلقت حسوب مشروعا لترجمة بعض أفضل الكتب التقنية في مجال البرمجة. ونظرا لأهمية SQL للمبرمجين، وحتى لغير المبرمجين من العاملين في القطاعات التقنية، كالصناعة والمحاسبة والصيرفة وتحليل البيانات، أو للمهتمين بقواعد البيانات عموما، قررنا ترجمة أحد أفضل الكتب الإنجليزية عن SQL، وهو كتاب SQL Notes For Professionals. لقد نشرنا سلسلة تضمّ كافة فصول الكتاب، وهي معروضة في القسم التالي. يمكنك أيضًا تنزيل الكتاب جملة واحدة على هيئة كتاب إلكتروني اطلقنا عليه، ملاحظات للعاملين بلغة SQL.

سلسلة "SQL للمحترفين"

تغطي هذه السلسلة -المبنية على كتاب «ملاحظات للعاملين بلغة SQL»- كافَّة المفاهيم الأساسية للغة SQL، مثل العمليات الأولية، كإدراج البيانات وحذفها واستخلاصها وتحديثها، وأنواع البيانات، وتصميم الجداول وتنفيذ الاستعلامات، إضافة إلى مفاهيم متقدمة، مثل المعارض والدوال، وإدارة المستخدمين، وكيفية تأمين الشيفرة وغيرها من المواضيع. كما أنّها غنية بالأمثلة التطبيقية التي تشرح كل هذه المواضيع لترسيخ فهمها.

هذه السلسلة ليست مثل غيرها من السلاسل والشروحات التي تشرح لغة SQL من البداية شرحًا مُبسَّطًا ومتسلسلًا وإنَّما تعتمد على مبدأ خير الكلام ما قل ودل في الشرح وترك الشيفرة تشرح نفسها بنفسها، فتحوي على كم كبير من الشيفرات بالموازنة مع الشرح. وُجِّهت هذه السلسلة لمن لديه معرفة بسيطة بلغة SQL، لذا يفضَّل أن تمتلك معرفة بلغة SQL لتستفيد أكبر استفادة منها وتقرأ الشيفرات وتفهمها وتتعلَّم منها. في هذه الحالة، ستساهم هذه السلسلة في رفع مستواك في لغة SQL وستُملِّكك مهارات متقدمة في استعمال لغة SQL بالإضافة إلى بعض الخدع والالتفافات المتقدمة أيضًا. قد تسأل نفسك، هل ينفع أن اقرأ السلسلة دون معرفة مسبقة بلغة SQL؟ سأقول، نعم، ولكن يجب أن تتحلى بالصبر في قراءة الشيفرة وتحليلها وفهمها والبحث عن أي موضوع لم تفهمه والسؤال عن شرح لأي شيفرة غامضة، إذ لن تجد كلامًا وشرحًا كبيرًا للمواضع التي تتحدث عنه السلسلة، كما أن تسلسل المواضيع فيها لا تراعي عدم امتلاك القارئ معرفة بلغة SQL، إذ رُتِّبت ترتيبًا عشوائيًا في العمل الأصلي.

بذكر ترتيب عناوين ومواضيع السلسلة، حاولت ترتيب عناوينها بأنسب شكل لتكون متدرِّجة في الصعوبة وحاولت جمع المواضيع المتشابهة في فصل واحد رغم تشرذمها وتفرقها في العمل الأصلي فلا تشبه النسخة العربية المترجمة النسخة الأجنبية مطلقًا، إذ حاولت أن تكون أفضل منها وأرجو أن نكون قد حققنا ذلك. فإن كنت على معرفة بأحد المواضيع، فلا تتخطاها بل اقرأها، فقد تمر معك إشارة لموضوع متقدم أو ملاحظة مهمة لم تكن تعرفها (تذكر أنَّ اسم الكتاب العربي ملاحظات متقدمة للعاملية بلغة SQL ;-) ). يمكنك أيضًا أن تقرأ السلسلة من أي قسم تريد فهي من الأساس غير مُرتَّبة ترتيبًا متدرجًا ومتسلسلًا كما أشرت إلى ذلك، رغم محاولتي في ترتيبها لك أنسب ترتيب من البداية للنهاية؛ أرجو لك قراءة ممتعة!

1. مدخل إلى SQL

هذه المقالة هي مدخل عام إلى لغة الاستعلامات SQL، وفيها توطئة لبعض المفاهيم الأساسية لهذه اللغة، مثل المعرّفات و أنواع البيانات، كالأعداد والحروف والقيم المالية، إضافة إلى مجموعة من الأمثلة العملية على بعض الجداول وقواعد البيانات.

2. جلب الاستعلامات عبر SELECT في SQL

تستعرض هذه المقالة كيفية استخدَام العبارة SELECT في استعلامات SQL لاختيار واستخلاص النتائج من قاعدة البيانات، تشمل هذه الفقرة العديد من تقنيات الاختيار، مثل حرف البدل والاختيار وفق كُنى الأعمدة، وتحديد عدد السجلات المُختارة والاختيار الشرطي، والاختيار باستخدام الدوال التجميعية، واختيار صفوف من عدة جداول.

3. التجميع والترتيب في SQL

تتحدث هذه المقالة عن كيفية استخدام العبارتين GROUP BY و ORDER BY لتجميع نتائج الاستعلامات في SQL وترتيبها. إضافة إلى التقنيات المُستخدمة لتصنيف النتائج وفق شروط معينة، وعدّ الصفوف في الجدول، والتنقيب عن البيانات أو ترتيبها بحسب عدة أعمدة.

4. تنفيذ تعليمات شرطية عبر CASE في SQL

تستعرض هذه المقالة العبارة CASE، والتي تُستخدم لكتابة الشيفرات الشرطية (if-then)، وعد الصفوف التي تحقق شرطا معينا، إضافة إلى كيفية استخدام CASE لتحديث البيانات، أو ترتيبها تصاعديا أو تنازليا.

5. البحث والتنقيب والترشيح في SQL

تستعرض هذه المقالة بعض معاملات SQL المتخصصة في البحث والتنقيب وترشيح النتائج، مثل المعامل LIKE، الذي يبحث عن التطابقات مع نمط نصي معين، و WHERE و HAVING، اللتان تُستخدمان لترشيح النتائج وفق شروط معينة، إضافة إلى بعض تقنيات التحكم في النتائج المُعادة، واستعراض بعض البيانات الوصفية المتعلقة بالاستعلامات.

6. الدمج بين الجداول في SQL

سنستعرض في هذه المقالة كيفية استخدام العبارة JOIN، وأنواعها، وكيفية إجراء الدمج العودي والدمج في الاستعلامات الفرعية، وذلك كله من أجل إجراء عملية الدمج بين الجداول والحصول على النتائج المرجوة.

7. تحديث الجداول في SQL

تستعرض هذه المقالة كيفية استخدام العبارات UPDATE و CREATE لتحديث وإنشاء قواعد البيانات والجداول، إضافة إلى كيفية إنشاء دوال جديدة.

8. معالجة الأخطاء والتعديل على قواعد البيانات في SQL

تستعرض هذه المقالة كيفية معالجة الأخطاء باستخدام العبارة TRY / CATCH، وكيفية حساب الاتحاد (UNION) وبعض العمليات الأخرى التي تمكّن من تعديل قواعد البيانات، وإدراج بيانات جديدة في الجداول

9. حذف الجداول وقواعد البيانات في SQL

تتحدّث هذه المقالة عن كيفية حذف الجداول وقواعد البيانات (DROP و DELETE)، واقتطاع الجداول (TRUNCATE TABLE)، وكيفية استخدام الحذف المتفشي أو المتسلسل (Cascading Delete) في SQL.

10. مواضيع متقدمة في SQL

تستعرض هذه المقالة عددًا من المواضيع المتقدمة في SQL، مثل إدارة صلاحيات المستخدمين، واستخدام ملفات XML في الاستعلامات، والمفاتيح الرئيسية وأرقام الصفوف، إضافة إلى مفهوم الفهارس، وكيفية إنشائها أو حذفها وتعطيلها.

11. دوال التعامل مع البيانات في SQL

تستعرض هذه المقالة بعض أنواع الدوال، مثل الدوال التجميعية (Aggregate Functions) التي تُطبَّق على الصفوف، والدوال التحليلية (Analytic Functions) والدوال العددية ودوال النافذة (window function).

12. دوال التعامل مع النصوص في SQL

 تستعرض هذه المقالة مفهوم الدوال النصية String Functions، وهي دوال تُنفَّذ على قيم نصية، وتعيد إمّا قيمًا عددية أو قيمًا نصية. مثلًا، يمكن استخدام الدوال النصية لدمج البيانات، أو استخراج أجزاء من السلاسل النصية، أو موازنة السلاسل النصية أو تحويلها من الأحرف الكبيرة إلى الصغيرة، أو العكس.

13. التعبيرات الجدولية الشائعة Common Table Expressions

تستعرض هذه المقالة مفهوم التعبيرات الجدولية (Common Table Expressions) في SQL، والتي يمكن استخدامها مع الاستعلامات المؤقتة والعوديّة لتوليد سلاسل القيم وتسلق الأشجار (trees).

14. مواضيع متفرقة في SQL

تستعرض هذه المقالة مجموعة من المواضيع الإضافية في SQL، مثل المعارض (Views)، وكيفية كتابة التعليقات، وكيفية التعامل مع المفاتيح الخارجية (Foreign Keys) وإنشاء تسلسلات العناصر.

15. الاستعلامات الفرعية والإجراءات في SQL

تستعرض هذه المقالة بعض المواضيع المتقدمة عن تنفيذ الشيفرات في SQL، مثل الاستعلامات الفرعية (Subqueries)، وكتل التنفيذ، والإجراءات المُخزّنة، والزنادات (triggers)، وكيفية إنشاء المُعامَلات (transactions) وتنفيذها.

16. تصميم الجداول وترتيب تنفيذ الاستعلامات ومعلومات المخطط في SQL

تستعرض هذه المقالة عددا من مواضيع SQL المتفرقة، مثل كيفية تصميم جداول قواعد البيانات، واستخدام المرادفات، وكيفية استخلاص المعلومات المتعلقة بقاعدة البيانات عبر معلومات المخطط، والترتيب الذي تُنفّذ وفقه عبارات واستعلامات SQL التي من المفيد تعلمها والإلمام بها.

17. تنظيم وتأمين شيفرات SQL

تتحدث هذه المقالة عن أفضل الممارسات المُتعارف عليها بين المبرمجين، والتي تساعد على كتابة شيفرات SQL نظيفة وعالية المقروئية، وكذلك تأمين الشيفرات عبر التحوّط من أحد أشهر أنواع هجمات SQL، وهو حقن شيفرات SQL ‏(SQL Injection)‏‏.

دروس ومقالات إضافية

هذه بعض المقالات الإضافية التي يمكن أن تساعدك على ترسيخ فهمك لبعض مفاهيم SQL وقواعد البيانات.

مقدمة عن قواعد البيانات

هذا هو المقال الأول من سلسلة دروس عن لغة الاستعلام البنائية Structured Query language، ويشرح مفهوم قواعد البيانات، وأنظمة إدارة قواعد البيانات، والجداول، وخصائص قواعد البيانات العلاقية.

أساسيّات لغة SQL

يعطي هذا المقال لمحة عامة عن لغة الاستعلامات SQL، وعن دورها وعلاقتها بقاعدة البيانات، مع شرح أساسيات وصياغة قواعد البيانات والجداول.

البيانات في SQL: أنواعها والقيود عليها

يتطرق هذا المقال لأحد المفاهيم الأساسية في قواعد البيانات وفي لغة الاستعلامات SQL، وهو مفهوم القيود، إذ يعرض هذا المفهوم مع أمثلة عملية لتوضيحه. إضافة إلى عرض مفصَّل لمختلف أنواع البيانات المُستخدمة في قواعد البيانات.

التعامل مع البيانات (الإدخال، الحذف والتعديل) في SQL

يشرح هذا المقال موضوع لغة التعامل مع البيانات Data Manipulation Language، سوف تملك في نهاية هذا المقال المعرفة اللازمة لإضافة سجلات بيانات إلى الجداول، وتعديلها، وحذفها باستخدام عبارات SQL الأساسية، مثل: UPDATE وINSERT وDELETE.

الاستعلام عن البيانات في SQL

هذا المقال تتمة للمقال السابق، ستتعلم فيه إحدى أشهر عبارات لغة الاستعلام البنائية، وهي Select، يتكلم المقال عن كيفية صياغة هذه العبارة، وأشكالها، وكيفية ترشيح البيانات واختيار الأعمدة.

الفهارس Indexes في SQL

يتناول هذا المقال موضوع الفهارس Indexes في SQL، وما تمثله في قاعدة البيانات، وما هي الفائدة منها، وكيفية استخدامها في شيفرات SQL.

العلاقات بين الجداول في SQL

SQL مُتخصَّصة أساسًا في قواعد البيانات العلائقية، لهذا فإنّ فهم موضوع العلاقات بين الجداول ضروري لكل مبرمج يريد احتراف هذه اللغة واستنفاذ إمكانياتها. ستتعلم في هذا المقال مفهوم العلاقات بين جداول قاعدة البيانات، وأنواع هذه العلاقات، وكيف تُمثَّل وتطبق بين الجداول.

تعلم لغة الاستعلام SQL بالأمثلة العملية

أفضل طريقة لتعلم أيّ لغة برمجة هي بتطبيق المعارف على أمثلة عملية. يشرح هذا الدرس المُصوّر أساسيات لغة الاستعلامات SQL عبر أمثلة عملية، وذلك باستخدام لوحة التحكم phpMyAdmin.

خاتمة

تُضاف مزيد من المقالات والدروس إلى الأكاديمية حول SQL‎ وقواعد البيانات باستمرار، لذلك تابع مستجدات أكاديمية حسوب. وإن أشكل عليك شيء فيمكنك أن تسأل عنه في قسم الأسئلة والأجوبة الخاص بالأكاديمية. يمكنك أيضا الاشتراك في قناة حسوب على اليوتوب، هذه القناة تحتوي دروسًا قصيرةً عن العديد من مواضيع البرمجة. تابع أيضًا قسم الكتب والملفات للاطلاع على أحد الكتب التي ننشرها.

إن كنت مهتما بتعلم لغات برمجة أخرى، فيمكنك زيارة قسم البرمجة في الأكاديمية، أيضًا لا تنس زيارة موسوعة حسوب، التي تضم توثيقات الكثير من لغات البرمجة، بما في ذلك توثيق SQL. وفّقك الله تعالى.

تستعرض هذه المقالة أفضل الممارسات المُتعارف عليها لكتابة شيفرات SQL نظيفة، وكذلك تأمين الشيفرات عبر التحوّط من هجمات حقن SQL.

الشيفرات البرمجية النظيفة في SQL

هذه بعض النصائح والقواعد حول كيفية كتابة استعلامات SQL تراعي أفضل الممارسات، وذات مقروئية عالية.

تنسيق وتهجئة الكلمات المفتاحية والأسماء

أسماء الجداول والأعمدة

هناك طريقتان شائعتان لكتابة أسماء الجداول والأعمدة، وهما ‎CamelCase‎ و ‎snake_case‎ كما يوضح المثال التالي:

SELECT FirstName, LastName
FROM Employees
WHERE Salary > 500;
SELECT first_name, last_name
FROM employees
WHERE salary > 500;

يجب أن تعطي الأسماء فكرة عمّا هو مُخزّن في الكائن المُسمّى. هناك نقاش محتدم حول ما إذا كان الأفضل أن تكون أسماء الجداول بصيغة المفرد أو الجمع، ولكنّ الشائع استخدام صيغة الجمع.

تُنقِص إضافة سابقات أو لاحقات، مثل ‎tbl‎ أو ‎col‎، إلى الأسماء مقروئية الشيفرة، لذلك يُفضل تجنبها. إلا أنّها قد تكون ضرورية في بعض الأحيان لتجنّب التداخل مع الكلمات المفتاحية في SQL، وغالبًا ما تُستخدم مع الزنادات (triggers) والفهارس (والتي لا تُذكر أسماؤها في الاستعلامات عادةً).

الكلمات المفتاحية

الكلمات المفتاحية في SQL ليست حسّاسة لحالة الأحرف. ولكن تغلُب كتابتها بأحرف كبيرة.

المسافات البادئة Indenting

لا يوجد معيار مقبول ومُوحّد للمسافات البادئة. لكنّ الجميع يتفق على أنّ حشر كل شيء في سطر واحد أمر سيء مثل:

SELECT d.Name, COUNT(*) AS Employees FROM Departments AS d JOIN Employees AS e ON d.ID =
e.DepartmentID WHERE d.Name != 'HR' HAVING COUNT(*) > 10 ORDER BY COUNT(*) DESC;

أضعف الإيمان أن تضع كل عبارة في سطر جديد، مع تقسيم السطور الطويلة:

SELECT d.Name,
 COUNT(*) AS Employees
FROM Departments AS d
JOIN Employees AS e ON d.ID = e.DepartmentID
WHERE d.Name != 'HR'
HAVING COUNT(*) > 10
ORDER BY COUNT(*) DESC;

في بعض الأحيان، تُوضع نفس المسافة البادئة قبل الأسطر التي تعقُب الكلمات المفتاحية في SQL:

SELECT   d.Name,
 COUNT(*) AS Employees
FROM     Departments AS d
JOIN     Employees AS e ON d.ID = e.DepartmentID
WHERE    d.Name != 'HR'
HAVING COUNT(*) > 10
ORDER BY COUNT(*) DESC;

(يمكن القيام بذلك أيضًا عند محاذاة الكلمات المفتاحية في SQL إلى اليمين.)

هناك طريقة شائعة أخرى، وهي وضع الكلمات المفتاحية المهمّة في سطور خاصّة على النحو التالي:

SELECT
    d.Name,
 COUNT(*) AS Employees
FROM
    Departments AS d
JOIN
    Employees AS e
 ON d.ID = e.DepartmentID
WHERE
    d.Name != 'HR'
HAVING
    COUNT(*) > 10
ORDER BY
    COUNT(*) DESC;

تُحسّن المحاذاة الرأسية للعبارات المتماثلة مقروئية الشيفرة:

SELECT Model,
       EmployeeID
FROM Cars
WHERE CustomerID = 42
   AND Status = 'READY';

استخدام عدّة أسطر يصعّب تضمين أوامر SQL في لغات البرمجة الأخرى. إلا أنّ العديد من اللغات لديها آلية للتعامل مع السلاسل النصية متعددة الأسطر، مثل ‎@"..."‎ في C#‎‎ أو ‎"""..."""‎ في Python أو ‎R"(...)"‎ في C++‎‎‎.

SELECT *‎‎

تعيد العبارة ‎SELECT *‎ جميع الأعمدة بنفس ترتيب ظهورها في الجدول. عند استخدام ‎SELECT *‎، فقد تتغيّر البيانات المُعادة من الاستعلام كلّما تغيّر تعريف الجدول. وهذا يضعف توافقية الإصدارات المختلفة من التطبيق أو قاعدة البيانات مع بعضها بعضًا.

علاوة على ذلك، فإنّ قراءة الأعمدة غير الضرورية قد يرفع من مساحة القرص المُستخدَمة، والدخل / الخرج الشبكي (network I/O). لذا عليك دائمًا تحديد العمود (أو الأعمدة) الذي تريد استردادها صراحة:

SELECT *                              --  تجنّب هذا
SELECT ID, FName, LName, PhoneNumber  -- هذا أفضل
FROM Emplopees;

(لا تنطبق هذه الاعتبارات عند إجراء استعلامات تفاعلية - interactive queries.)

بالمقابل، ليس هناك ضرر من استخدام ‎SELECT *‎ في استعلام فرعي لعبارة EXISTS، ذلك أنّ EXISTS تتجاهل البيانات الفعلية على أيّ حال (إذ تكتفي بالتحقق من أنّه تمّ العثور على صفّ واحد على الأقل). للسبب نفسه، لا فائدة من إدراج أيّ عمود (أو أعمدة) معيّنة في عبارة EXISTS، لذلك يُفضّل استخدام ‎SELECT *‎:

-- سرد الأقسام التي لم يُعيّن فيها أيّ موظف حديثا
SELECT ID,
       Name
FROM Departments
WHERE NOT EXISTS (SELECT *
 FROM Employees
 WHERE DepartmentID = Departments.ID
 AND HireDate >= '2015-01-01');

عمليات الضمّ Joins

يجب دائمًا استخدام عمليات الضمّ الصريحة (Explicit joins)؛ لأنّ عمليات الضمّ الضمنية (implicit joins) تطرح العديد من المشاكل، مثلًا:

• في عمليات الضمّ الضمنية، يكون شرط الضمّ داخل عبارة WHERE مخلوطًا مع شروط أخرى. وذلك يصعّب معرفة الجداول المضمومة، وكيفية ضمّها.
• بسبب النقطة أعلاه، يتعاظم خطر حدوث أخطاء.
• في SQL القياسية، عمليات الضمّ الصريحة هي الطريقة الوحيدة لاستخدام الضمّ الخارجي:

SELECT d.Name,
e.Fname || e.LName AS EmpName
FROM Departments AS d
LEFT JOIN Employees AS e ON d.ID = e.DepartmentID;

• يتيح الضمّ الصريح استخدام عبارة USING كما يوضّح المثال التالي:

SELECT RecipeID,
Recipes.Name,
COUNT(*) AS NumberOfIngredients
FROM Recipes
LEFT JOIN Ingredients USING (RecipeID);

(يتطلب هذا أن يستخدم كلا الجدولين اسم العمود نفسه. تزيل USING تلقائيًا العمود المكرّر من النتيجة، وهكذا سيُعيد الضم في الاستعلام أعلاه عمودًا ‎RecipeID‎ واحدا.)

حقن SQL

حقن SQL هي تقنية يستخدمها القراصنة للوصول إلى جداول قاعدة بيانات موقع معيّن عن طريق حقن تعليمات SQL في حقل إدخال.

إذا لم يكن خادم الويب مُجهّزا للتعامل مع هجمات حقن SQL، فيمكن للمخترقين خداع قاعدة البيانات، وجعلها تنفّذ شيفرة SQL إضافية. والتي قد تمكّنهم من ترقية صلاحيات حساباتهم، أو الوصول إلى المعلومات الشخصية لحساب آخر، أو إجراء أيّ تعديلات أخرى على قاعدة البيانات.

لنفترض أنّ استدعاء معالج تسجيل الدخول إلى موقعك يبدو كما يلي:

https://somepage.com/ajax/login.ashx?username=admin&password=123

الآن في login.ashx، ستقرأ القيم التالية:

strUserName = getHttpsRequestParameterString("username");
strPassword = getHttpsRequestParameterString("password");

يمكنك استعلام قاعدة البيانات للتحقق ممّا إذا كان هناك مستخدم له كلمة المرور هذه. لذا ستنشئ استعلام SQL التالي:

txtSQL = "SELECT * FROM Users WHERE username = '" + strUserName + "' AND password = '"+ strPassword +"'";

سيعمل هذا الاستعلام بلا مشاكل إذا لم يحتو اسم المستخدم وكلمة المرور على علامات اقتباس. ولكن إن احتوى أحد المعاملات على علامات اقتباس، فإنّ شيفرة SQL المُرسلة إلى قاعدة البيانات ستبدو كما يلي:

-- strUserName = "d'Alambert";
txtSQL = "SELECT * FROM Users WHERE username = 'd'Alambert' AND password = '123'";

سينتج عن هذا خطأ في الصياغة، لأنّ علامة الاقتباس بعد ‎d‎ في ‎d'Alambert‎ تنتهي بشيفرة SQL.

يمكنك تصحيح هذا عن طريق تهريب (escaping) علامات الاقتباس في اسم المستخدم وكلمة المرور على النحو التالي:

strUserName = strUserName.Replace("'", "''");
strPassword = strPassword.Replace("'", "''");

هناك حلّ آخر أفضل، وهو استخدام المعاملات:

cmd.CommandText = "SELECT * FROM Users WHERE username = @username AND password = @password";
cmd.Parameters.Add("@username", strUserName);
cmd.Parameters.Add("@password", strPassword);

إذا لم تستخدم المعاملات، ونسيت استبدال علامات الاقتباس ولو في قيمة واحدة، فيمكن للقرصان استخدام هذا لتنفيذ أوامر SQL في قاعدة البيانات الخاصة بك. على سبيل المثال، يمكن للقرصان أن يعيّن كلمة المرور التالية:

lol'; DROP DATABASE master; --

وبعدها ستبدو SQL كالتالي:

"SELECT * FROM Users WHERE username = 'somebody' AND password = 'lol'; DROP DATABASE master; --'";

لسوء الحظ، هذه شيفرة SQL صحيحة، وستنفّذها قاعدة البيانات DB! هذا النوع من الهجمات يسمّى حقن SQL.

هناك أشياء أخرى كثيرة يمكن أن يقوم بها القرصان، مثل سرقة عناوين البريد الإلكتروني الخاصة بالمستخدمين، أو سرقة كلمات المرور خاصتهم، أو سرقة أرقام بطاقات الائتمان، أو سرقة أيّ نوع من البيانات في قاعدة البيانات. لهذا السبب، عليك دائمًا تهريب السلاسل النصية.

لمّا كان النسيان طبيعة في الإنسان، ينصح الكثيرون باستخدام المعاملات دائمًا. لأنّ إطارات لغة البرمجة المُستخدمة تتكفّل بتهريبها نيابة عنك.

مثال على حقن بسيط

إذا تم إنشاء عبارة SQL على النحو التالي:

SQL = "SELECT * FROM Users WHERE username = '" + user + "' AND password ='" + pw + "'"; 
db.execute(SQL);

سيكون بمقدور القرصان سرقة بياناتك عن طريق إعطاء كلمة مرور من هذا القبيل ‎pw' or '1'='1‎؛ وهكذا تصبح عبارة SQL الناتجة على النحو التالي:

SELECT * FROM Users WHERE username = 'somebody' AND password ='pw' or '1'='1'

العبارة ‎'1'='1'‎ صحيحة دائمًا، لذلك سيتم اختيار كل الصفوف. لمنع هذا، استخدم معاملات SQL على النحو التالي:

SQL = "SELECT * FROM Users WHERE username = ? AND password = ?";
db.execute(SQL, [user, pw]);

ترجمة -وبتصرّف- للفصلين من 61 إلى 62 من الكتاب SQL Notes for Professionals

اقرأ أيضًا:

• المقال السابق: تصميم الجداول ومعلومات المخطط وترتيب تنفيذ الاستعلامات في SQL
• النسخة العربية الكاملة من كتاب ملاحظات للعاملين بلغة SQL 1.0.0

تستعرض هذه المقالة عددا من مواضيع SQL، مثل كيفية تصميم جداول قواعد البيانات، واستخدام المرادفات، وكيفية استخلاص المعلومات المتعلقة بقاعدة البيانات عبر معلومات المخطط، والترتيب الذي تُنفّذ وفقه عبارات واستعلامات SQL.

تصميم الجداول Table Design

لا تنحصر وظائف أنظمة قواعد البيانات العلائقية في عرض البيانات في الجداول، وكتابة عبارات SQL لسحب تلك البيانات.

إن كان تصميم الجداول سيئًا، فقد يؤدي ذلك إلى إبطاء تنفيذ الاستعلامات، ويمكن أن يؤثر على عمل قاعدة البيانات، بحيث لا تعمل كما هو متوقع. لذا لا ينبغي النظر إلى جداول قاعدة البيانات كما لو كانت مجرد جداول عادية؛ إذ يتوجّب أن تتّبع مجموعة من القواعد حتى تكون علائقية حقًّا.

هذه هي القواعد الخمسة التي ينبغي أن تتوفّر في أيّ جدول علائقي:

1. أن تكون كل القيم ذرّية (atomic)، أي يجب أن تكون قيمة كل حقل من كل صفّ قيمة واحدة.
2. يجب أن تنتمي بيانات كل حقل إلى نفس نوع البيانات.
3. يجب أن يكون لكل حقل اسمًا فريدًا.
4. يجب أن يحتوي كل صفّ في الجدول على قيمة واحدة على الأقل تجعله متفرّدًا عن السجلات الأخرى في الجدول.
5. لا ينبغي أن يكون لترتيب الصفوف والأعمدة أيّ تأثير.

هذا مثال على جدول يتوافق مع القواعد الخمس أعلاه:

لنتحقق من القواعد السابقة:

• القاعدة 1: كل القيم ذرّية. إذ لا تحتوِي الحقول ‎Id‎ و ‎Name‎ و ‎DOB‎ و ‎Manager‎ إلّا قيمًا مُنفردة (single) فقط.
• القاعدة 2: لا يحتوي الحقل ‎Id‎ إلّا على الأعداد الصحيحة، فيما يحتوي الحقل ‎Name‎ حصرًا على القيم النصية (يمكننا إضافة أنها جميعًا تتألف من أربعة أحرف أو أقل)، فيما يحتوي الحقل ‎DOB‎ على تواريخ من نوع صالح، ويحتوي الحقل ‎Manager‎ على أعداد صحيحة (يمكننا إضافة أنّها تتوافق مع حقل المفاتيح الرئيسية في جدول المدراء managers).
• القاعدة 3: ‎Id‎ و ‎Name‎ و ‎DOB‎ و ‎Manager‎ هي أسماء عناوين فريدة للحقول داخل الجدول.
• القاعدة 4: يميّز الحقل ‎Id‎ كلّ السجلّات، ويجعل كلّ سجلّ مختلفًا عن السجلات الأخرى داخل الجدول.

هذا مثال على جدول ذي تصميم سيء:

لنتحقق من القواعد السابقة:

• القاعدة 1: يحتوي الحقل الثاني على قيمتين، 2 و 1.
• القاعدة 2: يحتوي الحقل DOB على نوعي بيانات مختلفين، نوع التاريخ، ونوع النصوص.
• القاعدة 3: هناك حقلان لهما الاسم نفسه ("name").
• القاعدة 4: السجل الأول والثاني متماثلان تمامًا.
• القاعدة 5: هذه القاعدة مُستوفاة.

المرادفات Synonyms

المرادف (Synonym) هو كُنية أو اسم بديل لكائن في قاعدة بيانات، هذا الكائن قد يكون جدولًا أو معرضًا أو إجراءًا مُخزّنًا، أو سلسلة …إلخ.

يوضّح المثال التالي كيفية إنشاء المرادفات:

CREATE SYNONYM EmployeeData
FOR MyDatabase.dbo.Employees

مخطط المعلومات Information Schema

مخطّط المعلومات (Information Schema) هو استعلام يوفّر معلومات مفيدة للمستخدمين النهائيين عن أنظمة إدارة قواعد البيانات (RDBMS).

تتيح مثل هذه الاستعلامات للمستخدمين إمكانية العثور السريع على جداول قاعدة البيانات التي تحتوي أعمدة معيّنة، كما يحدث عندما ترغب في ربط البيانات من جدولين بشكل غير مباشر عبر جدول ثالث دون معرفة مُسبقة بالجداول التي قد تحتوي على مفاتيح أو أعمدة أخرى مشتركة مع الجداول المستهدفة.

يستخدم المثال التالي تعبيرًا T-SQL، ويبحث عن مخطّط المعلومات الخاصّ بقاعدة البيانات:

SELECT *
FROM INFORMATION_SCHEMA.COLUMNS
WHERE COLUMN_NAME LIKE '%Institution%'

تحتوي النتيجة على قائمة بالأعمدة المُطابقة، وأسماء جداولها، ومعلومات أخرى مفيدة.

ترتيب التنفيذ Order of Execution

تُنفّذ عبارات استعلامات SQL وفق ترتيب محدّد. تستعرض هذه الفقرة هذا الترتيب:

/*(8)*/ SELECT /*9*/ DISTINCT /*11*/ TOP 
/*(1)*/ FROM
/*(3)*/ JOIN
/*(2)*/ ON
/*(4)*/ WHERE
/*(5)*/ GROUP BY
/*(6)*/ WITH {CUBE | ROLLUP}
/*(7)*/ HAVING
/*(10)*/ ORDER BY
/*(11)*/ LIMIT

إليك الترتيب الذي تتم به معالجة الاستعلامات، مع وصف مختصر لكلّ منها (تشير VT إلى "Virtual Table" أي جدول وهمي، وتوضّح كيف يتم إنتاج مختلف البيانات أثناء معالجة الاستعلام):

1. FROM: تنفّذ جداء ديكارتي (ضمّ متقاطع cross join) بين الجدولين الأولين في عبارة FROM، ونتيجة لذلك، يُنشأ جدول وهمي VT1
2. ON: ترشِّح الجدول الوهمي VT1. ولا تُدرج إلا الصفوف التي تعيد TRUE إلى الجدول الوهمي VT2.
3. OUTER: في حال الضمّ الخارجي OUTER JOIN (على عكس الضمّ المتقاطع CROSS JOIN أو الضمّ الداخلي INNER JOIN)، تُضاف صفوف الجدول أو الجداول المحفوظة (preserved table) التي لم يُعثَر فيها على تطابق إلى صفوف الجدول الوهمي VT2 كصفوف خارجية، وينتُج عن ذلك الجدول VT3. في حال كان هناك أكثر من جدولين في عبارة FROM، تُطبَّق الخطوات من 1 إلى 3 بشكل متكرر بين نتيجة عملية الضمّ الأخيرة والجدول التالي في عبارة FROM إلى أن تُعالج جميع الجداول.
4. WHERE: ترشِّح الجدول VT3. ولا تُدرج إلا الصفوف التي تعيد TRUE إلى الجدول VT4
5. GROUP BY: تُقسّم صفوف الجدول الوهمي VT4 إلى مجموعات بناءً على قائمة الأعمدة المحدّدة في عبارة GROUP BY. وينجم عن ذلك إنشاء جدول VT5.
6. CUBE | ROLLUP: تُضاف مجموعات أجزاء - Supergroups - (مجموعات مؤلّفة من مجموعات) إلى صفوف VT5، وينتُج الجدول الوهمي VT6.
7. HAVING: ترشِّح الجدول VT6. ولا تُدرج إلا المجموعات التي تعيد القيمة TRUE إلى الجدول VT7.
8. SELECT: تُعالج قائمة SELECT، ويُنشأ الجدول VT8.
9. DISTINCT: تُزال الصفوف المكرّرة من VT8. ويُنشأ الجدول VT9.
10. ORDER BY: تُرتَّب صفوف الجدول VT9 وفقًا لقائمة الأعمدة المحدّدة في عبارة ORDER BY، كما يُنشأ مُؤشّر - cursor - ‏(VC10).
11. TOP: يُختار العدد أو النّسبة المئوية المحدّدة من الصفوف من بداية الجدول VC10. ويُنشأ الجدول VT11 ثُم يُعاد إلى المُستدعي - caller - (العبارة LIMIT لها نفس وظيفة TOP في بعض لهجات SQL، مثل Postgres و Netezza.)

ترجمة -وبتصرّف- للفصول من 57 إلى 60 من الكتاب SQL Notes for Professionals

اقرأ أيضًا:

• المقال التالي: تنظيم شيفرات SQL وتأمينها
• المقال السابق: الاستعلامات الفرعية والإجراءات في SQL
• النسخة العربية الكاملة من كتاب ملاحظات للعاملين بلغة SQL 1.0.0

تستعرض هذه المقالة بعض المواضيع المتقدمة عن تنفيذ الشيفرات في SQL، مثل الاستعلامات الفرعية، وكتل التنفيذ، والإجراءات المُخزّنة، والزنادات، والمُعاملات.

الاستعلامات الفرعية Subqueries

الاستعلامات الفرعية هي استعلامات داخلية أو متشعّبة داخل استعلام آخر في SQL. يُمكن أن تُضمّن الاستعلامات الفرعية داخل ‎FROM‎ أو SELECT أو WHERE.

الاستعلامات الفرعية في عبارة FROM

تتصرّف الاستعلامات الفرعية في عبارة ‎FROM‎ بشكل مشابه للجداول المؤقتة المُنشأة أثناء تنفيذ استعلام، والمفقودة إثر ذلك.

SELECT Managers.Id, Employees.Salary
FROM (
    SELECT Id
    FROM Employees
    WHERE ManagerId IS NULL
) AS Managers
JOIN Employees ON Managers.Id = Employees.Id

الاستعلامات الفرعية في عبارة SELECT

إليك مثال على استعلام فرعي في SELECT:

SELECT
     Id,
     FName,
     LName,
    (SELECT COUNT(*) FROM Cars WHERE Cars.CustomerId = Customers.Id) AS NumberOfCars
FROM Customers

الاستعلامات الفرعية في عبارة WHERE

يمكنك استخدام استعلام فرعي لترشيح مجموعة النتائج. على سبيل المثال، تعيد الشيفرة التالية الموظفين الأعلى أجرًا فقط:

SELECT *
FROM Employees
WHERE Salary = (SELECT MAX(Salary) FROM Employees)

الاستعلامات الفرعية المرتبطة Correlated Subqueries

الاستعلامات الفرعية المرتبطة (والمعروفة أيضًا باسم المتزامنة أو المتّسقة) هي استعلامات متشعّبة تحتوي مرجعًا يشير إلى الصفّ الحالي في الاستعلام الخارجي:

SELECT EmployeeId
     FROM Employee AS eOuter
     WHERE Salary > (
       SELECT AVG(Salary)
       FROM Employee eInner
       WHERE eInner.DepartmentId = eOuter.DepartmentId
 )

الاستعلام الفرعي ‎SELECT AVG(Salary) ...‎ مرتبط لأنّه يشير إلى الصفّ ‎Employee‎ من الجدول ‎eOuter‎ من الاستعلام الخارجي.

ترشيح نتائج الاستعلام باستخدام استعلام مُنفَّذ على جدول آخر

يختار الاستعلام التالي جميع الموظفين غير الموجودين في جدول المشرفين Supervisors:

SELECT *
FROM Employees
WHERE EmployeeID not in (SELECT EmployeeID
 FROM Supervisors)

يمكن تحقيق النتائج نفسها باستخدام الضم اليساري LEFT JOIN:

SELECT *
FROM Employees AS e
LEFT JOIN Supervisors AS s ON s.EmployeeID=e.EmployeeID
WHERE s.EmployeeID is NULL

الاستعلامات الفرعية في عبارة FROM

يمكنك استخدام الاستعلامات الفرعية لتعريف جدول مؤقّت واستخدامه في عبارة FROM الخاصّة بالاستعلام الخارجي.

تبحث الشيفرة التالية عن المدن في جدول الطقس weather التي تتغيّر درجات الحرارة اليومية الخاصّة بها بأكثر من 20 درجة: