تجميع البيانات باستخدام GROUP BY

المقدمة

لقد تعلمنا في المقالات السابقة الأوامر الأربعة الأساسية وهى كيفية إضافة البيانات باستخدام أمر INSERT
وكيفية قراءتها باستخدام أمر SELECT
وكيفية تعديلها بأمر UPDATE وحذفها عن طريق أمر DELETE

معظم تركيزنا سيتمحور على أمر SELECT مع أمر يدعى GROUP BY
وبعض الدوال المهمة والمشهورة التى ستساعدنا في تحليل البيانات

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

لاحظ أنني قلت في كل مستوى، لكل شهر، في كل قسم
بمعنى أننا نريد تجميع البيانات حسب فئة معينة

بمعنى لو لدينا 1000 طالب في مستويات مختلفة
نريد معرفة كم عدد الطلاب في مستوى Beginner، وكم في Intermediate، وكم في Advanced وهكذا
ونريد أن نقسم البيانات إلى مجموعات حسب المستوى
ثم نحسب عدد الطلاب في كل مجموعة

فكرة تقسيم البيانات إلى مجموعات حسب قيم معينة في عمود معين تسمى Grouping أي التجميع
وهنا يبرز لنا أمر الـ GROUP BY الذي يقوم بهذه المهمة
ثم نستخدم دوال تدعى الـ Aggregation أي دوال التجميع لإجراء عمليات حسابية على هذه المجموعات
مثل:

• COUNT(): لعد الصفوف في كل مجموعة
• SUM(): لحساب المجموع في كل مجموعة
• AVG(): لحساب المتوسط في كل مجموعة
• MAX(): لإيجاد أكبر قيمة في كل مجموعة
• MIN(): لإيجاد أصغر قيمة في كل مجموعة

في هذا المقال سنتعلم كل ما يتعلق بأمر GROUP BY ودوال التجميع مع أمثلة عملية كثيرة
على أي حال عليك معرفته هو أننا يمكننا استخدام الـ Aggregation Functions بدون GROUP BY أيضاً
في هذه الحالة ستعمل على جميع الصفوف في الجدول وترجع نتيجة واحدة
وسنرى ذلك في الأمثلة القادمة

تجهيز الجدول للأمثلة العملية

كالعادة قبل أن نبدأ أحتاج لتذكيرك بشكل جدول الـ Students الذي سنستخدمه في هذه المقالة
والبيانات التي يحتويها من المقالات السابقة

+----+-----------------+------+--------------+--------------------------+
| id | name            | age  | level        | email                    |
+----+-----------------+------+--------------+--------------------------+
| 1  | Ahmed Moustafa  | 21   | Intermediate | ahmed@university.edu     |
| 2  | Osama Ali       | 21   | Intermediate | osama.ali@university.edu |
| 3  | Mohamed Adel    | 23   | Advanced     | mohamed@university.edu   |
| 4  | Kamal Mahmoud   | 22   | Advanced     | kamal@university.edu     |
| 5  | Ayman Hassan    | 21   | Advanced     | ayman@university.edu     |
| 6  | Adam Ibrahim    | NULL | Beginner     | adam@university.edu      |
| 7  | Ismail Khaled   | 23   | Advanced     | ismail@university.edu    |
+----+-----------------+------+--------------+--------------------------+

الآن سنحتاج إلى إضافة عمودين جديدين هما grade و city لنستطيع تطبيق أمثلة GROUP BY بشكل أفضل

ALTER TABLE Students
ADD grade DECIMAL(5,2) AFTER level;

ALTER TABLE Students
ADD city VARCHAR(50) AFTER grade;

لاحظ أننا هنا عندما أضفنا الأعمدة استخدمنا AFTER لتحديد مكان العمود الجديد في الجدول
بحيث قلنا AFTER level ليتم إضافة عمود grade بعد عمود level
وAFTER grade ليتم إضافة عمود city بعد عمود grade
وهذا لتسهيل قراءة الجدول لاحقاً
وفي حالة عدم تحديد مكان العمود الجديد، سيتم إضافته في نهاية الجدول بشكل افتراضي

الآن سنقوم بتحديث البيانات الموجودة وإضافة قيم للأعمدة الجديدة:

UPDATE Students SET grade = 85.5, city = 'Cairo' WHERE id = 1;
UPDATE Students SET grade = 88.0, city = 'Cairo' WHERE id = 2;
UPDATE Students SET grade = 92.0, city = 'Alex' WHERE id = 3;
UPDATE Students SET grade = 90.0, city = 'Alex' WHERE id = 4;
UPDATE Students SET grade = 87.5, city = 'Giza' WHERE id = 5;
UPDATE Students SET grade = 75.0, city = 'Giza' WHERE id = 6;
UPDATE Students SET grade = 95.0, city = 'Cairo' WHERE id = 7;

لنرى شكل الجدول الآن بعد إضافة الأعمدة الجديدة وتحديث البيانات:

+----+-----------------+------+--------------+-------+-------+--------------------------+------------+
| id | name            | age  | level        | grade | city  | email                    | deleted_at |
+----+-----------------+------+--------------+-------+-------+--------------------------+------------+
| 1  | Ahmed Moustafa  | 21   | Intermediate | 85.5  | Cairo | ahmed@university.edu     | NULL       |
| 2  | Osama Ali       | 21   | Intermediate | 88.0  | Cairo | osama.ali@university.edu | NULL       |
| 3  | Mohamed Adel    | 23   | Advanced     | 92.0  | Alex  | mohamed@university.edu   | NULL       |
| 4  | Kamal Mahmoud   | 22   | Advanced     | 90.0  | Alex  | kamal@university.edu     | NULL       |
| 5  | Ayman Hassan    | 21   | Advanced     | 87.5  | Giza  | ayman@university.edu     | NULL       |
| 6  | Adam Ibrahim    | NULL | Beginner     | 75.0  | Giza  | adam@university.edu      | NULL       |
| 7  | Ismail Khaled   | 23   | Advanced     | 95.0  | Cairo | ismail@university.edu    | NULL       |
+----+-----------------+------+--------------+-------+-------+--------------------------+------------+

هذه البيانات التي سنستخدمها في جميع الأمثلة
الآن دعونا نبدأ في تعلم كيفية استخدام دوال التجميع

ما هي دوال التجميع Aggregation Functions ؟

لنبدأ أولاً بفهم ما هي دوال التجميع أو التى تسمى بالـ Aggregate Functions في الـ SQL
دوال التجميع هي دوال خاصة تقوم بإجراء حسابات على مجموعة من الصفوف وترجع نتيجة واحدة

أشهر دوال التجميع هي:

• COUNT(): لعد الصفوف
• SUM(): لحساب المجموع
• AVG(): لحساب المتوسط
• MAX(): لإيجاد أكبر قيمة
• MIN(): لإيجاد أصغر قيمة

هذه الدوال تعمل على جميع الصفوف في الجدول إذا لم نستخدم GROUP BY
أو تعمل على كل مجموعة منفصلة إذا استخدمنا GROUP BY

سنركز على أمثلة عملية لكل دالة بدون استخدام GROUP BY أولاً
ثم نشرح كيفية استخدامها مع GROUP BY في الأقسام التالية

دالة COUNT - عد الصفوف

دالة COUNT() هي أبسط دوال التجميع وتستخدم لعد الصفوف:

SELECT COUNT(*) FROM Students;

النتيحة ستكون جدول صغير يحتوي على عدد جميع الطلاب:

+----------+
| COUNT(*) |
+----------+
|        7 |
+----------+

لاحظ أننا حصلنا على جدول فيه صف واحد وعمود واحد يحتوي على العدد 7
واسم العمود هو COUNT(*)

وهذه شكل نواتج دوال التجميع دائماً
بحيث أنها تقوم بعمل عملية حسابية وترجع نتيجة واحدة في صف واحد

على أي حالة الـ * في COUNT(*) تعني أننا نريد عد جميع الصفوف بغض النظر عن القيم في الأعمدة

لكن عندما تحدد صف محدد من الأعمدة داخل COUNT(column_name)، فإنها تعد فقط الصفوف التي ليست NULL في هذا العمود المحدد

بمعنى لو قلنا نريد عد COUNT(age)، فسيتم عد الصفوف التي لديها قيمة في عمود age فقط، وتجاهل الصفوف التي فيها NULL في هذا العمود
وفي جدولنا الحالي لدينا طالب واحد وهو Adam Ibrahim الذي ليس لديه عمر محدد أي أن قيمة العمود age هي NULL

SELECT COUNT(age) FROM Students;

النتيجة ستكون 6 وهو عدد الطلاب الذين لديهم عمر باستثناء الطالب الذي عمره NULL في جدولنا الحالي

+-------------+
| COUNT(age)  |
+-------------+
|           6 |
+-------------+

إذا اردت اعطاء اسم مستعار للعمود الناتج بدلاً من الاسم الافتراضي COUNT(*) يمكنك استخدام AS:

SELECT COUNT(*) AS total_students FROM Students;

النتيجة:

+----------------+
| total_students |
+----------------+
|              7 |
+----------------+

يمكنك أيضاً استخدام WHERE لعد الصفوف التي تحقق شرط معين:

SELECT COUNT(*) AS advanced_students FROM Students WHERE level = 'Advanced';

النتيجة 4 عدد الطلاب في المستوى Advanced

+-------------------+
| advanced_students  |
+-------------------+
|                 4 |
+-------------------+

دالة SUM - حساب المجموع

دالة SUM() تستخدم لحساب مجموع القيم الرقمية:

SELECT SUM(grade) FROM Students;

النتيجة ستكون 613.0

+------------+
| SUM(grade) |
+------------+
|      613.0 |
+------------+

دالة AVG - حساب المتوسط

دالة AVG() تستخدم لحساب متوسط القيم الرقمية:

SELECT AVG(grade) FROM Students;

النتيجة ستكون 87.571429

+------------+
| AVG(grade) |
+------------+
|  87.571429 |
+------------+

تقريب الأرقام العشرية باستخدام ROUND() مع AVG()

يمكننا تقريب الأرقام العشرية باستخدام دالة ROUND() لتقريب الأرقام العشرية لجعلها أكثر وضوحاً
لنفترض أننا نريد عرض متوسط الدرجات لأقرب رقمين عشريين فقط:

SELECT ROUND(AVG(grade), 2)
FROM Students;

النتيجة ستكون 87.57 بدلاً من 87.571429

+---------------------+
| ROUND(AVG(grade), 2)|
+---------------------+
|               87.57 |
+---------------------+

بالطبع مشكلة اسم العمود الناتج هنا هو أنه طويل وغير واضح
لذلك يمكننا استخدام AS لإعطاء اسم مستعار للعمود الناتج

SELECT ROUND(AVG(grade), 2) AS average_grade
FROM Students;

النتيجة ستكون:

+---------------+
| average_grade |
+---------------+
|         87.57 |
+---------------+

دالة MAX - إيجاد أكبر قيمة

دالة MAX() تستخدم لإيجاد أكبر قيمة:

SELECT MAX(grade) FROM Students;

النتيجة ستكون 95.0 وهى أعلى درجة

+------------+
| MAX(grade) |
+------------+
|       95.0 |
+------------+

إيجاد اسم الطالب صاحب أعلى درجة

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

عن طريق استخدام ORDER BY مع LIMIT بالشكل التالي:

SELECT name, grade
FROM Students
ORDER BY grade DESC
LIMIT 1;

النتيجة:

+----------------+-------+
| name           | grade |
+----------------+-------+
| Ismail Khaled  |  95.0 |
+----------------+-------+

لاحظ أننا هنا ORDER BY grade DESC نرتب الطلاب من الأعلى إلى الأقل حسب الدرجة
ثم عن طريق LIMIT 1 نأخذ أول سطر فقط (الطالب صاحب أعلى درجة)

وبالطبع إذا كان هناك أكثر من طالب بنفس أعلى درجة، فإن LIMIT 1 ستعرض طالب واحد فقط من بينهم

على أي هذه الطريقة ليست مثالية لأننا إذا أردنا معرفة جميع الطلاب الذين حصلوا على أعلى درجة (في حالة وجود تعادل) فأننا لا نستطيع استخدام الـ LIMIT لأننا لا نعرف كم عدد الطلاب الذين حصلوا على أعلى درجة

الطريقة الأفضل هي استخدام دالة MAX() داخل subquery للحصول على أعلى درجة أولاً، ثم نستخدم هذه القيمة في استعلام رئيسي لجلب أسماء الطلاب الذين حصلوا على هذه الدرجة:

SELECT name, grade
FROM Students
WHERE grade = (SELECT MAX(grade) FROM Students);

لكننا لم نشرح الـ subqueries بعد، لذلك سنكتفي بالطريقة الأولى في الوقت الحالي
ثم سنتعلم الـ subqueries في مقالات لاحقة
سأترك مثال الـ subquery لتتأمل فيه وتجربه أو تفهمه بالنظر

دالة MIN - إيجاد أصغر قيمة

دالة MIN() تستخدم لإيجاد أصغر قيمة:

SELECT MIN(grade) FROM Students;

النتيجة ستكون 75.0 وهى أقل درجة

+------------+
| MIN(grade) |
+------------+
|       75.0 |
+------------+

دمج عدة دوال معًا

يمكنك استخدام أكثر من دالة في استعلام واحد:

SELECT
    COUNT(*) AS total_students,
    ROUND(AVG(grade), 2) AS average_grade,
    MAX(grade) AS highest_grade,
    MIN(grade) AS lowest_grade,
    SUM(grade) AS total_grades
FROM Students;

+----------------+---------------+---------------+--------------+--------------+
| total_students | average_grade | highest_grade | lowest_grade | total_grades |
+----------------+---------------+---------------+--------------+--------------+
|              7 |         87.57 |          95.0 |         75.0 |        613.0 |
+----------------+---------------+---------------+--------------+--------------+

ما هو أمر الـ GROUP BY ؟

أمر GROUP BY يستخدم لـ تجميع الصفوف التي لها نفس القيم في أعمدة معينة
وبعد التجميع يمكننا استخدام دوال الـ Aggregation لإجراء حسابات على كل مجموعة منفصلة

حاليًا لدينا طلاب من مستويات مختلفة: Beginner, Intermediate, Advanced
باستخدام GROUP BY level سنحصل على 3 مجموعات منفصلة

SELECT level
FROM Students
GROUP BY level;

النتيجة ستكون:

+--------------+
| level        |
+--------------+
| Intermediate |
| Advanced     |
| Beginner     |
+--------------+

لاحظ أن النتيجة تحتوي على 3 صفوف فقط، كل صف يمثل مستوى مختلف
ولدينا عمود واحد فقط وهو level لأننا طلبنا فقط هذا العمود في الـ SELECT
الآن إذا أردنا معرفة عدد الطلاب في كل مستوى، نستخدم دالة COUNT(*) كعمود إضافي إضافي في الـ SELECT بجانب الـ level:

SELECT level, COUNT(*) AS student_count
FROM Students
GROUP BY level;

لاحظ أننا أضفنا COUNT(*) AS student_count في الـ SELECT
الآن بما أننا قلنا GROUP BY level، فإن COUNT(*) ستحسب عدد الصفوف في كل مجموعة من المجموعات التي تم إنشاؤها حسب level

النتيجة ستكون:

+--------------+---------------+
| level        | student_count |
+--------------+---------------+
| Intermediate | 2             |
| Advanced     | 4             |
| Beginner     | 1             |
+--------------+---------------+

بالتالي لدينا هنا شخصين فقط في مستوى الـ Intermediate، وأربعة أشخاص في الـ Advanced وشخص واحد فقط في الـ Beginner

الشكل الأساسي لـ GROUP BY

SELECT column1, AGGREGATION_FUNCTION(column2)
FROM table_name
WHERE condition
GROUP BY column1;

لاحظ أن الأعمدة التي نحدد في الـ GROUP BY يجب أن تكون موجودة في الـ SELECT أيضاً
وأي عمود في الـ SELECT غير موجود في الـ GROUP BY يجب أن يكون داخل دالة من دوال التجميع مثل COUNT(), SUM(), AVG(), إلخ

استخدام GROUP BY مع دوال الـ Aggregation

الآن بعد أن فهمنا كيفية عمل دوال التجميع بشكل منفصل، دعونا نرى كيف يمكننا استخدامها مع GROUP BY لتحليل البيانات بشكل أكثر فائدة

لنفترض أننا نريد معرفة متوسط الدرجات لكل مستوى
يمكننا استخدام AVG(grade) مع GROUP BY level:

SELECT level, AVG(grade) AS average_grade
FROM Students
GROUP BY level;

النتيجة:

+--------------+---------------+
| level        | average_grade |
+--------------+---------------+
| Intermediate |         86.75 |
| Advanced     |        91.125 |
| Beginner     |          75.0 |
+--------------+---------------+

لاحظ أننا حصلنا على متوسط الدرجات لكل مستوى منفصل
طلاب الـ Advanced متوسط درجاتهم 91.125، بينما طلاب الـ Beginner متوسطهم 75.0
وطلاب الـ Intermediate متوسطهم 86.75

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

SELECT city, level, COUNT(*) AS student_count
FROM Students
GROUP BY city, level
ORDER BY city, level;

لاحظ أننا هنا قمنا بـ GROUP BY city, level
أي أننا قمنا بتجميع البيانات أولاً حسب city ثم داخل كل مدينة قمنا بالتجميع حسب level
فحصلنا على مجموعات بحسب المدينة والمستوى معاً
ولاحظ أيضاً أننا أضفنا ORDER BY city, level لترتيب النتيجة حسب المدينة ثم المستوى

النتيجة:

+-------+--------------+---------------+
| city  | level        | student_count |
+-------+--------------+---------------+
| Alex  | Advanced     | 2             |
| Cairo | Advanced     | 1             |
| Cairo | Intermediate | 2             |
| Giza  | Advanced     | 1             |
| Giza  | Beginner     | 1             |
+-------+--------------+---------------+

هنا قمنا بالتجميع حسب city و level معاً
هكذا دالة COUNT(*) تعمل على كل مجموعة من المجموعات الناتجة
فحصلنا على عدد الطلاب لكل مستوى في كل مدينة
مثلاً في القاهرة لدينا طالب واحد في Advanced وطالبين في Intermediate

استخدام HAVING لتصفية المجموعات

حتى الآن تعلمنا كيفية تجميع البيانات باستخدام GROUP BY وإجراء عمليات حسابية عليها
لكن ماذا لو أردنا تصفية هذه المجموعات بناءً على نتائج دوال التجميع ؟

مثلاً، لنفترض أننا نريد معرفة المستويات التي تحتوي على أكثر من طالبين
أو نريد معرفة المدن التي متوسط الدرجات فيها أكبر من 85

هنا لا نستطيع استخدام WHERE لأن WHERE يعمل على الصفوف الفردية قبل التجميع
بينما نحن نريد تصفية النواتج بعد التجميع وبناءً على نتائج دوال التجميع مثل COUNT() أو AVG()

هنا يأتي دور HAVING الذي يُستخدم لتصفية المجموعات بعد إجراء التجميع

الفرق بين WHERE و HAVING

الفرق الجوهري بينهما هو توقيت التطبيق:

• WHERE: بقوم بتصفية الصفوف قبل التجميع أي أنه يعمل على البيانات الأصلية
• HAVING: بقوم بتصفية المجموعات بعد التجميع أي أنه يعمل على نتائج دوال التجميع

مثال على أمر الـ WHERE:

SELECT level, COUNT(*) AS student_count
FROM Students
WHERE age > 20  -- تصفية قبل التجميع
GROUP BY level;

هنا WHERE age > 20 يصفي الطلاب أولاً أي أنه يستبعد الذين أعمارهم 20 أو أقل
ثم يتم تجميع الطلاب المتبقين حسب المستوى

النتيجة:

+--------------+---------------+
| level        | student_count |
+--------------+---------------+
| Intermediate | 2             |
| Advanced     | 4             |
+--------------+---------------+

مثال على أمر الـ HAVING:

SELECT level, COUNT(*) AS student_count
FROM Students
GROUP BY level
HAVING student_count > 2;  -- تصفية بعد التجميع

هنا يتم تجميع جميع الطلاب حسب المستوى أولاً
ثم HAVING student_count > 2 يعرض فقط المستويات التي تحتوي على أكثر من طالبين

النتيجة:

+--------------+---------------+
| level        | student_count |
+--------------+---------------+
| Advanced     | 4             |
+--------------+---------------+

لاحظ أننا حصلنا على مستوى Advanced فقط لأنه الوحيد الذي يحتوي على أكثر من طالبين حيث أنه يحتوي على أربع طلاب بينما Intermediate يحتوي على طالبين و Beginner يحتوي على طالب واحد

دمج WHERE و HAVING معاً

يمكننا بالطبع استخدام WHERE و HAVING في نفس الـ query في حالة أردنا تصفية البيانات قبل وبعد التجميع

لنرى مثال آخر، لنفترض أننا نريد معرفة المدن التي متوسط الدرجات فيها أكبر من 90 في مستوى Advanced فقط

SELECT city, AVG(grade) AS average_grade
FROM Students
WHERE level = 'Advanced'
GROUP BY city
HAVING average_grade > 90;

لاحظ هنا اننا استخدمنا WHERE level = 'Advanced' لتصفية الطلاب أولاً بحيث نأخذ فقط طلاب المستوى Advanced
ثم قمنا بتجميع هؤلاء الطلاب حسب city
ثم استخدمنا AVG(grade) لحساب متوسط الدرجات في كل مدينة
وأخيراً استخدمنا HAVING average_grade > 90 لتصفية المدن

النتيجة:

+-------+---------------+
| city  | average_grade |
+-------+---------------+
| Alex  |          91.0 |
| Cairo |          95.0 |
+-------+---------------+

هنا لدينا مدينتان فقط حيث متوسط درجات طلاب المستوى Advanced فيهما أكبر من 90 وهما Alex و Cairo

في حين ازالتنا لشرط الـ WHERE سيكون نتائج مختلفة لأنه هكذا درجات الطلاب من جميع المستويات سيتم أخذها في الاعتبار في دالة AVG() بالتالي سيتم تصفيته بشكل مختلف بعد التجميع في HAVING وسنحصل على نتائج مختلفة

SELECT city, AVG(grade) AS average_grade
FROM Students
GROUP BY city
HAVING average_grade > 90;

النتيجة ستكون:

+-------+---------------+
| city  | average_grade |
+-------+---------------+
| Alex  |          91.0 |
+-------+---------------+

لاحظ أن Cairo لم تعد موجودة في النتيجة لأن متوسط درجات طلاب Cairo من جميع المستويات هو 89.5 وهو أقل من 90

متى نستخدم WHERE ومتى نستخدم HAVING؟

استخدم WHERE عندما:

• تريد تصفية الصفوف قبل التجميع
• الشرط يعتمد على أعمدة عادية (ليست دوال تجميع)
• مثال: WHERE age > 21 أو WHERE city = 'Cairo'

استخدم HAVING عندما:

• تريد تصفية المجموعات بعد التجميع
• الشرط يعتمد على دوال التجميع
• مثال: HAVING COUNT(*) > 2 أو HAVING AVG(grade) > 85

من الأخطاء الشائعة التي يقع فيها البعض هو محاولة استخدام دوال التجميع داخل WHERE
أو العكس ياستخدام أعمدة عادية داخل HAVING

SELECT level, COUNT(*) AS student_count
FROM Students
WHERE student_count > 2 -- خطأ
GROUP BY level;
HAVING level = 'Advanced' -- خطأ

والصحيح هو استخدام HAVING مع دوال التجميع وWHERE مع الأعمدة العادية كما شرحنا سابقًاً

الخلاصة

في هذه المقالة تعلمنا كيفية استخدام أمر GROUP BY ودوال التجميع لتحليل البيانات بشكل فعال
تعلمنا كيفية استخدام دوال مثل COUNT(), SUM(), AVG(), MAX(), و MIN()
كما تعلمنا الفرق بين WHERE و HAVING ومتى نستخدم كل منهما

جدول مقارنة سريع

هذه الأوامر ستفتح لك آفاقاً واسعة في تحليل البيانات وستجدها مفيدة جداً في العمل اليومي مع قواعد البيانات

في المقالة القادمة سنتعلم عن الربط بين الجداول (JOINS) وكيفية استرجاع البيانات من عدة جداول مرتبطة