كيفية التعامل مع التواريخ والأوقات في SQL

مقدمة

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

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

المتطلبات الأساسية

لإكمال هذا البرنامج التعليمي، ستحتاج إلى:

• خادم يعمل بنظام التشغيل Ubuntu 20.04، مع مستخدم غير جذر يتمتع بامتيازات إدارية sudo وجدار حماية ممكّن.
• تم تثبيت MySQL وتأمينه على الخادم.

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

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

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

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

ssh sammy@your_server_ip

بعد ذلك، افتح موجه MySQL واستبدل Sami بمعلومات حساب MySQL الخاص بك:

mysql -u sammy -p

إنشاء قاعدة بيانات تسمى datetimeDB:

CREATE DATABASE datetimeDB;

إذا تم إنشاء قاعدة البيانات بنجاح، فسوف تتلقى الإخراج التالي:

Output
Query OK, 1 row affected (0.01 sec)

لتحديد قاعدة بيانات datetimeDB، قم بتشغيل العبارة USE التالية:

USE datetimeDB;

Output
Database changed

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

• race_id: يمثل قيم نوع البيانات int ويعمل كمفتاح أساسي للجدول، أي أن كل قيمة في هذا العمود تعمل كمعرف فريد للصف المقابل.
• runner_name: يستخدم نوع البيانات varchar بحد أقصى 30 حرفًا لأسماء العدائين Bolt وFelix.
• race_name: يحتوي على أنواع السباق مع نوع بيانات varchar يصل إلى 20 حرفًا.
• start_day: يستخدم نوع البيانات DATE لتتبع تاريخ مباراة محددة بناءً على السنة والشهر واليوم. يتوافق هذا النوع من البيانات مع المعايير التالية: أربعة أرقام للسنة، وبحد أقصى رقمين للشهر واليوم (YYYY-MM-DD).
• وقت البدء: يُمثل وقت بدء المباراة بنوع بيانات الوقت (TIME) بالساعات والدقائق والثواني (HH:MM:SS). يتبع هذا النوع من البيانات تنسيق الساعة ٢٤ ساعة، مثل ١٥:٠٠ الذي يُعادل ٣:٠٠ مساءً.
• إجمالي الأميال: يعرض إجمالي الأميال لكل سباق باستخدام نوع البيانات العشري، لأن العديد من إجمالي الأميال لكل سباق ليست أعدادًا صحيحة. في هذه الحالة، يُحدد النوع العشري دقة ثلاثة بمقياس واحد، مما يعني أن كل قيمة في هذا العمود يمكن أن تتكون من ثلاثة أرقام، بحيث يكون أحد هذه الأرقام على يمين الفاصلة العشرية.
• end_time: يستخدم نوع بيانات TIMESTAMP لتتبع وقت المتسابقين في نهاية السباق. يجمع هذا النوع من البيانات التاريخ والوقت في سلسلة نصية، ويكون تنسيقه مزيجًا من DATE وTIME: (YYYY-MM-DD HH:MM:SS).

قم بإنشاء الجدول عن طريق تشغيل الأمر CREATE TABLE:

CREATE TABLE race_results (
race_id int, 
runner_name varchar(30),
race_name varchar(20), 
start_day DATE,
start_time TIME, 
total_miles decimal(3, 1),
end_time TIMESTAMP,
PRIMARY KEY (race_id)
); 

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

INSERT INTO race_results
(race_id, runner_name, race_name, start_day, start_time, total_miles, end_time)
VALUES
(1, 'bolt', '1600_meters', '2022-09-18', '7:00:00', 1.0, '2022-09-18 7:06:30'),
(2, 'bolt', '5K', '2022-10-19', '11:00:00', 3.1, '2022-10-19 11:22:31'),
(3, 'bolt', '10K', '2022-11-20', '10:00:00', 6.2, '2022-11-20 10:38:05'),
(4, 'bolt', 'half_marathon', '2022-12-21', '6:00:00', 13.1, '2022-12-21 07:39:04'),
(5, 'bolt', 'full_marathon', '2023-01-22', '8:00:00', 26.2, '2023-01-22 11:23:10'),
(6, 'felix', '1600_meters', '2022-09-18', '7:00:00', 1.0, '2022-09-18 7:07:15'),
(7, 'felix', '5K', '2022-10-19', '11:00:00', 3.1, '2022-10-19 11:30:50'),
(8, 'felix', '10K', '2022-11-20', '10:00:00', 6.2, '2022-11-20 11:10:17'),
(9, 'felix', 'half_marathon', '2022-12-21', '6:00:00', 13.1, '2022-12-21 08:11:57'),
(10, 'felix', 'full_marathon', '2023-01-22', '8:00:00', 26.2, '2023-01-22 12:02:10');

Output
Query OK, 10 rows affected (0.00 sec)
Records: 10 Duplicates: 0 Warnings: 0

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

استخدام الحساب مع التاريخ والوقت

في SQL، يمكنك معالجة قيم التاريخ والوقت باستخدام تعبيرات رياضية. كل ما تحتاجه هو مُعامل رياضي والقيم التي تريد حسابها.

على سبيل المثال، لنفترض أنك تريد العثور على تاريخ يتأخر بأيام محددة عن تاريخ آخر. يأخذ الاستعلام التالي قيمة تاريخ (2022-10-05) ويضيف إليها 17 لإرجاع قيمة تاريخ بعد سبعة عشر يومًا من التاريخ المحدد في الاستعلام. تجدر الإشارة إلى أن هذا المثال يحدد 2022-10-05 كقيمة DATE لضمان عدم تفسير نظام إدارة قواعد البيانات لها كسلسلة نصية أو نوع بيانات آخر:

SELECT DATE '2022-10-05' + 17 AS new_date;

Output
+----------+
| new_date |
+----------+
| 20221022 |
+----------+
1 row in set (0.01 sec)

كما يظهر هذا الناتج، فإن 17 يومًا بعد 2022-10-05 هو 2022-10-22، أو 22 أكتوبر 2022.

كمثال آخر، لنفترض أنك تريد حساب إجمالي الساعات بين وقتين مختلفين. يمكنك القيام بذلك بطرح وقتين من بعضهما. في الاستعلام التالي، 11:00 هي قيمة الوقت الأولى و3:00 هي قيمة الوقت الثانية. هنا، يجب تحديد أن كلتا القيمتين TIME لإرجاع الفرق بالساعات:

SELECT TIME '11:00' - TIME '3:00' AS time_diff;

Output
+-----------+
| time_diff |
+-----------+
| 80000 |
+-----------+
1 row in set (0.00 sec)

يخبرك هذا الناتج أن الفرق بين الساعة 11:00 والساعة 3:00 هو 80,000، أو 8 ساعات.

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

SELECT runner_name, race_name, end_time - start_time 
AS total_time 
FROM race_results;

Output
+-------------+---------------+----------------+
| runner_name | race_name | total_time |
+-------------+---------------+----------------+
| bolt | 1600_meters | 20220918000630 |
| bolt | 5K | 20221019002231 |
| bolt | 10K | 20221120003805 |
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | 1600_meters | 20220918000715 |
| felix | 5K | 20221019003050 |
| felix | 10K | 20221120011017 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+----------------+
10 rows in set (0.00 sec)

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

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

SELECT runner_name, race_name, end_time - start_time AS half_full_results
FROM race_results 
WHERE total_miles > 12;

Output
+-------------+---------------+-------------------+
| runner_name | race_name | half_full_results |
+-------------+---------------+-------------------+
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+-------------------+
4 rows in set (0.00 sec)

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

استخدام وظائف التاريخ والوقت وتعبيرات النطاق

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

للعثور على تاريخ اليوم، على سبيل المثال، يكون بناء الجملة قصيرًا ويتكون فقط من عبارة SELECT ووظيفة current_date، مثل هذا:

SELECT current_date;

Output
+--------------+
| current_date |
+--------------+
| 2022-02-15 |
+--------------+
1 row in set (0.00 sec)

باستخدام نفس بناء الجملة، يمكنك العثور على الوقت الحالي باستخدام الدالة current_time:

SELECT current_time;

Output
+--------------+
| current_time |
+--------------+
| 17:10:20 |
+--------------+
1 row in set (0.00 sec)

إذا كنت تفضل الاستعلام عن التاريخ والوقت في الإخراج، فاستخدم الدالة current_timestamp:

SELECT current_timestamp;

Output
+---------------------+
| current_timestamp |
+---------------------+
| 2022-02-15 19:09:58 |
+---------------------+
1 row in set (0.00 sec)

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

SELECT current_date - 11;

Output
+-------------------+
| current_date - 11 |
+-------------------+
| 20220206 |
+-------------------+
1 row in set (0.01 sec)

كما يوضح هذا الناتج، قبل 11 يومًا من current_date (في وقت كتابة هذه المقالة) كان 2022-02-06، أو 6 فبراير 2022. حاول الآن نفس العملية، ولكن استبدل current_date بوظيفة current_time:

SELECT current_time - 11;

Output
+-------------------+
| current_time - 11 |
+-------------------+
| 233639 |
+-------------------+
1 row in set (0.00 sec)

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

تسمح لك تعبيرات الفاصلة بتحديد تاريخ أو وقت قبل أو بعد فترة زمنية محددة من تعبير تاريخ أو وقت. يجب أن يكون لها الشكل التالي:

INTERVAL value unit

على سبيل المثال، للعثور على التاريخ بعد خمسة أيام من الآن، يمكنك تشغيل الاستعلام التالي:

SELECT current_date + INTERVAL '5' DAY AS "5_days_from_today";

هذا المثال يبحث عن قيمة التاريخ الحالي، ثم يضيف إليها تعبير الفاصلة INTERVAL '5' DAY. هذا يُرجع التاريخ بعد 5 أيام:

Output
+-------------------+
| 5_days_from_today |
+-------------------+
| 2022-03-06 |
+-------------------+
1 row in set (0.00 sec)

وهذا أقل غموضًا بكثير من الاستعلام التالي، والذي ينتج مخرجات مماثلة، رغم أنها ليست متطابقة:

SELECT current_date + 5 AS "5_days_from_today";

Output
+-------------------+
| 5_days_from_today |
+-------------------+
| 20220306 |
+-------------------+
1 row in set (0.00 sec)

لاحظ أنه يمكنك طرح فترات زمنية من التواريخ أو الأوقات للعثور على القيم قبل قيمة تاريخ محددة:

SELECT current_date - INTERVAL '7' MONTH AS "7_months_ago";

Output
+--------------+
| 7_months_ago |
+--------------+
| 2021-08-01 |
+--------------+
1 row in set (0.00 sec)

تعتمد الوحدات المتاحة للاستخدام في عبارات INTERVAL على نظام إدارة قواعد البيانات الذي تختاره، على الرغم من أن معظمها سيكون لديه خيارات مثل HOUR وMINUTE وSECOND:

SELECT current_time + INTERVAL '6' HOUR AS "6_hours_from_now",
current_time - INTERVAL '5' MINUTE AS "5_minutes_ago",
current_time + INTERVAL '20' SECOND AS "20_seconds_from_now";

Output
+------------------+---------------+---------------------+
| 6_hours_from_now | 5_minutes_ago | 20_seconds_from_now |
+------------------+---------------+---------------------+
| 07:51:43 | 01:46:43 | 01:52:03.000000 |
+------------------+---------------+---------------------+
1 row in set (0.00 sec)

الآن بعد أن تعلمت عن تعبيرات الفاصل الزمني وبعض وظائف التاريخ والوقت، استمر في التدرب على العمل مع بيانات العينة التي أدخلتها في الخطوة الأولى.

استخدام وظائف CAST و Aggregate مع التواريخ والأوقات

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

SELECT runner_name, race_name, end_time - start_time 
AS total_time 
FROM race_results;

Output
+-------------+---------------+----------------+
| runner_name | race_name | total_time |
+-------------+---------------+----------------+
| bolt | 1600_meters | 20220918000630 |
| bolt | 5K | 20221019002231 |
| bolt | 10K | 20221120003805 |
| bolt | half_marathon | 20221221013904 |
| bolt | full_marathon | 20230122032310 |
| felix | 1600_meters | 20220918000715 |
| felix | 5K | 20221019003050 |
| felix | 10K | 20221120011017 |
| felix | half_marathon | 20221221021157 |
| felix | full_marathon | 20230122040210 |
+-------------+---------------+----------------+
10 rows in set (0.00 sec)

لأنك تُجري عملية على عمودين مختلفين في نوع البيانات (يحتوي عمود end_time على قيم TIMESTAMP وعمود start_time على قيم TIME)، فإن قاعدة البيانات لا تعرف نوع البيانات المُستخدم عند طباعة نتيجة العملية. بدلاً من ذلك، تُحوّل القيمتين إلى أعداد صحيحة لتنفيذ العملية، مما ينتج عنه أرقام طويلة في عمود total_time.

لتسهيل قراءة هذه البيانات وتفسيرها، يمكنك استخدام دالة CAST لتحويل قيم الأعداد الصحيحة الطويلة هذه إلى نوع بيانات TIME. للقيام بذلك، ابدأ بـ CAST، ثم اتبعها مباشرةً بقوس مفتوح، ثم القيم التي تريد تحويلها، ثم كلمة AS ونوع البيانات الذي تريد التحويل إليه.

الاستعلام التالي مماثل للمثال السابق، لكنه يستخدم دالة CAST لتحويل عمود total_time إلى نوع بيانات الوقت:

SELECT runner_name, race_name, CAST(end_time - start_time AS time)
AS total_time 
FROM race_results;

Output
+-------------+---------------+------------+
| runner_name | race_name | total_time |
+-------------+---------------+------------+
| bolt | 1600_meters | 00:06:30 |
| bolt | 5K | 00:22:31 |
| bolt | 10K | 00:38:05 |
| bolt | half_marathon | 01:39:04 |
| bolt | full_marathon | 03:23:10 |
| felix | 1600_meters | 00:07:15 |
| felix | 5K | 00:30:50 |
| felix | 10K | 01:10:17 |
| felix | half_marathon | 02:11:57 |
| felix | full_marathon | 04:02:10 |
+-------------+---------------+------------+
10 rows in set (0.00 sec)

قام CAST بتحويل قيم البيانات في هذا الإخراج إلى TIME، مما يجعله سهل الهضم للقراءة والفهم.

الآن، لنستخدم بعض الدوال التجميعية مع دالة CAST لإيجاد أقصر وأطول وإجمالي وقت لكل عدّاء. أولًا، ابحث عن الحد الأدنى (أو الأقصر) للوقت المستغرق باستخدام دالة MIN. وللتوضيح، يُنصح باستخدام دالة CAST لتحويل قيم بيانات TIMESTAMP إلى قيم بيانات TIME. يُرجى ملاحظة أنه عند استخدام دالتين كما في هذا المثال، يلزم وجود زوجين من الأقواس، ويجب وضع حساب إجمالي الساعات (وقت النهاية - وقت البدء) في أحدهما. وأخيرًا، أضف عبارة GROUP BY لتنظيم هذه القيم حسب عمود runner_name لعرض نتائج سباق العدّاء:

SELECT runner_name, MIN(CAST(end_time - start_time AS time)) AS min_time
FROM race_results GROUP BY runner_name;

Output
+-------------+----------+
| runner_name | min_time |
+-------------+----------+
| bolt | 00:06:30 |
| felix | 00:07:15 |
+-------------+----------+
2 rows in set (0.00 sec)

يُظهر هذا الناتج أقصر وقت للعداء، في هذه الحالة ست دقائق و30 ثانية على الأقل بالنسبة لبولت وسبع دقائق و15 ثانية بالنسبة لفيليكس.

بعد ذلك، ابحث عن أطول مدة تنفيذ لكل مُشغِّل. يمكنك استخدام نفس صيغة العبارة السابقة، ولكن هذه المرة استبدل MIN بـ MAX:

SELECT runner_name, MAX(CAST(end_time - start_time AS time)) AS max_time
FROM race_results GROUP BY runner_name;

Output
+-------------+----------+
| runner_name | max_time |
+-------------+----------+
| bolt | 03:23:10 |
| felix | 04:02:10 |
+-------------+----------+
2 rows in set (0.00 sec)

يُظهر هذا الناتج أن أطول مدة ركض لبولت كانت ثلاث ساعات و23 دقيقة وعشر ثوانٍ. بينما كانت أطول مدة ركض لفيليكس أربع ساعات ودقيقتين وعشر ثوانٍ.

لنبدأ الآن بالاستعلام عن معلومات دقيقة حول إجمالي ساعات الجري لكل عدّاء. في هذا الاستعلام، اجمع دالة SUM لحساب إجمالي الساعات بناءً على وقت البدء ووقت النهاية، واستخدم CAST لتحويل قيم البيانات هذه إلى الوقت. لا تنسَ إضافة GROUP BY لتنظيم قيم النتائج لكل عدّاء:

SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;

Output
+-------------+-------------+
| runner_name | total_hours |
+-------------+-------------+
| bolt | 52880 |
| felix | 76149 |
+-------------+-------------+
2 rows in set (0.00 sec)

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

SELECT runner_name, SUM(CAST(end_time - start_time AS time))
AS total_hours FROM race_results GROUP BY runner_name;

Output
runner_name | total_hours
-------------+-------------
felix | 10:01:44
bolt | 06:09:20
(2 rows)

في هذه الحالة، يُفسّر الاستعلام في PostgreSQL القيم كأوقات ويحسبها على هذا الأساس، فتُقسّم نتائج فيليكس إلى ١٠ ساعات ودقيقة واحدة و٤٤ ثانية. أما بولت، فتُقسّم إلى ست ساعات وتسع دقائق و٢٠ ثانية. هذا مثال على كيفية اختلاف تفسير تطبيقات أنظمة إدارة قواعد البيانات المختلفة لقيم البيانات، حتى مع استخدام نفس الاستعلام ومجموعة البيانات.

نتيجة

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