تقبل معظم الدوال في هذا القسم وسيطة اختيارية للمنطقة الزمنية، مثل Europe/Amsterdam. وفي هذه الحالة، تكون المنطقة الزمنية المستخدمة هي المنطقة المحددة بدلًا من المنطقة الزمنية المحلية (الافتراضية).
مثال
SELECT
toDateTime('2016-06-15 23:00:00') AS time,
toDate(time) AS date_local,
toDate(time, 'Asia/Yekaterinburg') AS date_yekat,
toString(time, 'US/Samoa') AS time_samoa
┌────────────────time─┬─date_local─┬─date_yekat─┬─time_samoa──────────┐
│ 2016-06-15 23:00:00 │ 2016-06-15 │ 2016-06-16 │ 2016-06-15 09:00:00 │
└─────────────────────┴────────────┴────────────┴─────────────────────┘
لتحقيق التوافق مع معيار SQL، يمكن استخدام الدوال التالية دون أقواس: NOW وCURRENT_TIMESTAMP وLOCALTIME وLOCALTIMESTAMP وTODAY وCURRENT_DATE.
now('UTC'). وقد أُضيفت فقط لدعم MySQL. ويُعد now الخيار المفضّل.
الصياغة
الأسماء المستعارة: UTC_timestamp
المعاملات
القيمة المُعادة
تعيد التاريخ والوقت الحاليين عند لحظة تحليل الاستعلام. DateTime
أمثلة
الحصول على الطابع الزمني الحالي بتوقيت UTC
┌──────UTCTimestamp()─┐
│ 2024-05-28 08:32:09 │
└─────────────────────┘
Date.
هذه الدالة هي عكس الدالة toYYYYMMDD().
تكون النتيجة غير معرّفة إذا كان الإدخال لا يمثّل قيمة Date صالحة.
البنية
الوسائط
القيمة المُعادة
يُرجع قيمة من نوع Date من الوسائط المقدَّمة Date
أمثلة
مثال
SELECT YYYYMMDDToDate(20230911);
┌─toYYYYMMDD(20230911)─┐
│ 2023-09-11 │
└──────────────────────┘
Date32.
هذه الدالة هي عكس الدالة toYYYYMMDD().
يكون الناتج غير معرّف إذا لم يُشفِّر الإدخال قيمة Date32 صالحة.
الصيغة
YYYYMMDDToDate32(YYYYMMDD)
Date32 من الوسائط المُدخلة Date32
أمثلة
مثال
SELECT YYYYMMDDToDate32(20000507);
┌─YYYYMMDDToDate32(20000507)─┐
│ 2000-05-07 │
└────────────────────────────┘
DateTime.
هذه الدالة هي عكس الدالة toYYYYMMDDhhmmss().
يكون الناتج غير معرّف إذا كان الإدخال لا يمثّل قيمة DateTime صالحة.
البنية
YYYYMMDDhhmmssToDateTime(YYYYMMDDhhmmss[, timezone])
YYYYMMDDhhmmss — رقم يحتوي على السنة والشهر واليوم والساعة والدقيقة والثانية. (U)Int* أو Float* أو Decimaltimezone — اسم المنطقة الزمنية. String
القيمة المعادة
تُرجع قيمة DateTime من الوسائط المحددة DateTime
أمثلة
مثال
SELECT YYYYMMDDToDateTime(20230911131415);
┌──────YYYYMMDDhhmmssToDateTime(20230911131415)─┐
│ 2023-09-11 13:14:15 │
└───────────────────────────────────────────────┘
YYYYMMDDhhmmssToDateTime64
DateTime64.
هذه الدالة هي عكس الدالة toYYYYMMDDhhmmss().
يكون الناتج غير معرّف إذا كان الإدخال لا يرمّز قيمة DateTime64 صالحة.
الصيغة
YYYYMMDDhhmmssToDateTime64(YYYYMMDDhhmmss[, precision[, timezone]])
YYYYMMDDhhmmss — رقم يحتوي على السنة والشهر واليوم والساعة والدقيقة والثانية. (U)Int* أو Float* أو Decimalprecision — دقة الجزء الكسري (0-9). UInt8timezone — اسم المنطقة الزمنية. String
القيمة المُعادة
تعيد قيمة DateTime64 من المعاملات المحددة DateTime64
أمثلة
مثال
SELECT YYYYMMDDhhmmssToDateTime64(20230911131415, 3, 'Asia/Istanbul');
┌─YYYYMMDDhhmm⋯/Istanbul')─┐
│ 2023-09-11 13:14:15.000 │
└──────────────────────────┘
addDate(datetime, interval)
interval إلى datetime. Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة فترة زمنية إلى تاريخ
SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─addDate(toDa⋯valYear(3))─┐
│ 2021-01-01 │
└──────────────────────────┘
datetime بعد إضافة num يومًا إليه. Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة أيام إلى أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addDays(date, 5) AS add_days_with_date,
addDays(date_time, 5) AS add_days_with_date_time,
addDays(date_time_string, 5) AS add_days_with_date_time_string
┌─add_days_with_date─┬─add_days_with_date_time─┬─add_days_with_date_time_string─┐
│ 2024-01-06 │ 2024-01-06 00:00:00 │ 2024-01-06 00:00:00.000 │
└────────────────────┴─────────────────────────┴────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 day)
┌─plus(CAST('1⋯valDay(10))─┐
│ 1998-06-26 │
└──────────────────────────┘
datetime بعد إضافة num ساعة إليه. DateTime أو DateTime64(3)
أمثلة
إضافة ساعات إلى أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addHours(date, 12) AS add_hours_with_date,
addHours(date_time, 12) AS add_hours_with_date_time,
addHours(date_time_string, 12) AS add_hours_with_date_time_string
┌─add_hours_with_date─┬─add_hours_with_date_time─┬─add_hours_with_date_time_string─┐
│ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00 │ 2024-01-01 12:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 hour)
┌─plus(CAST('1⋯alHour(10))─┐
│ 1998-06-16 10:00:00 │
└──────────────────────────┘
ستُدمج الفترات الزمنية من النوع نفسه في فترة زمنية واحدة. على سبيل المثال، إذا تم تمرير toIntervalDay(1) و toIntervalDay(2)، فستكون النتيجة (3) بدلًا من (1,1).
addInterval(interval_1, interval_2)
Tuple من قيم Interval Tuple(Interval)
أمثلة
إضافة فواصل زمنية
SELECT addInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT addInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT addInterval(INTERVAL 2 DAY, INTERVAL 1 DAY)
┌─addInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,1) │
└───────────────────────────────────────────────────┘
┌─addInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,1) │
└────────────────────────────────────────────────────────────────────────┘
┌─addInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (3) │
└─────────────────────────────────────────────────┘
addMicroseconds(datetime, num)
date_time بعد إضافة num من الميكروثواني DateTime64
أمثلة
إضافة ميكروثوانٍ إلى أنواع مختلفة من التاريخ والوقت
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMicroseconds(date_time, 1000000) AS add_microseconds_with_date_time,
addMicroseconds(date_time_string, 1000000) AS add_microseconds_with_date_time_string
┌─add_microseconds_with_date_time─┬─add_microseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000000 │ 2024-01-01 00:00:01.000000 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─plus(CAST('19⋯osecond(10))─┐
│ 1998-06-16 00:00:00.000010 │
└────────────────────────────┘
addMilliseconds(datetime, num)
datetime بعد إضافة num مللي ثانية إليه DateTime64
أمثلة
إضافة مللي ثانية إلى أنواع مختلفة من التاريخ والوقت
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMilliseconds(date_time, 1000) AS add_milliseconds_with_date_time,
addMilliseconds(date_time_string, 1000) AS add_milliseconds_with_date_time_string
┌─add_milliseconds_with_date_time─┬─add_milliseconds_with_date_time_string─┐
│ 2024-01-01 00:00:01.000 │ 2024-01-01 00:00:01.000 │
└─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─plus(CAST('1⋯second(10))─┐
│ 1998-06-16 00:00:00.010 │
└──────────────────────────┘
addMinutes(datetime, num)
datetime بعد إضافة num دقيقةً إليه. DateTime أو DateTime64(3)
أمثلة
إضافة دقائق إلى أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMinutes(date, 20) AS add_minutes_with_date,
addMinutes(date_time, 20) AS add_minutes_with_date_time,
addMinutes(date_time_string, 20) AS add_minutes_with_date_time_string
┌─add_minutes_with_date─┬─add_minutes_with_date_time─┬─add_minutes_with_date_time_string─┐
│ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00 │ 2024-01-01 00:20:00.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 minute)
┌─plus(CAST('1⋯Minute(10))─┐
│ 1998-06-16 00:10:00 │
└──────────────────────────┘
datetime بعد إضافة num من الأشهر إليه Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة أشهر إلى أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addMonths(date, 6) AS add_months_with_date,
addMonths(date_time, 6) AS add_months_with_date_time,
addMonths(date_time_string, 6) AS add_months_with_date_time_string
┌─add_months_with_date─┬─add_months_with_date_time─┬─add_months_with_date_time_string─┐
│ 2024-07-01 │ 2024-07-01 00:00:00 │ 2024-07-01 00:00:00.000 │
└──────────────────────┴───────────────────────────┴──────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 month)
┌─plus(CAST('1⋯lMonth(10))─┐
│ 1999-04-16 │
└──────────────────────────┘
addNanoseconds(datetime, num)
datetime بعد إضافة num من النانوثواني إليه من النوع DateTime64
أمثلة
إضافة نانوثوانٍ إلى أنواع مختلفة من التاريخ والوقت
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addNanoseconds(date_time, 1000) AS add_nanoseconds_with_date_time,
addNanoseconds(date_time_string, 1000) AS add_nanoseconds_with_date_time_string
┌─add_nanoseconds_with_date_time─┬─add_nanoseconds_with_date_time_string─┐
│ 2024-01-01 00:00:00.000001000 │ 2024-01-01 00:00:00.000001000 │
└────────────────────────────────┴───────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::DateTime, INTERVAL 1000 nanosecond)
┌─plus(CAST('199⋯osecond(1000))─┐
│ 1998-06-16 00:00:00.000001000 │
└───────────────────────────────┘
addQuarters(datetime, num)
datetime بعد إضافة num من أرباع السنة إليه Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة أرباع السنة إلى أنواع مختلفة من التاريخ
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addQuarters(date, 1) AS add_quarters_with_date,
addQuarters(date_time, 1) AS add_quarters_with_date_time,
addQuarters(date_time_string, 1) AS add_quarters_with_date_time_string
┌─add_quarters_with_date─┬─add_quarters_with_date_time─┬─add_quarters_with_date_time_string─┐
│ 2024-04-01 │ 2024-04-01 00:00:00 │ 2024-04-01 00:00:00.000 │
└────────────────────────┴─────────────────────────────┴────────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 quarter)
┌─plus(CAST('1⋯uarter(10))─┐
│ 2000-12-16 │
└──────────────────────────┘
addSeconds(datetime, num)
datetime بعد إضافة num ثانية إليه. DateTime أو DateTime64(3)
أمثلة
إضافة ثوانٍ إلى أنواع تاريخ متعددة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addSeconds(date, 30) AS add_seconds_with_date,
addSeconds(date_time, 30) AS add_seconds_with_date_time,
addSeconds(date_time_string, 30) AS add_seconds_with_date_time_string
┌─add_seconds_with_date─┬─add_seconds_with_date_time─┬─add_seconds_with_date_time_string─┐
│ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30 │ 2024-01-01 00:00:30.000 │
└───────────────────────┴────────────────────────────┴───────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 second)
┌─dateAdd('1998-06-16'::Date, INTERVAL 10 second)─┐
│ 1998-06-16 00:00:10 │
└─────────────────────────────────────────────────┘
addTupleOfIntervals(datetime, intervals)
date بعد إضافة intervals Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة Tuple من الفترات إلى تاريخ
WITH toDate('2018-01-01') AS date
SELECT addTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 MONTH, INTERVAL 1 YEAR))
┌─addTupleOfIntervals(date, (toIntervalDay(1), toIntervalMonth(1), toIntervalYear(1)))─┐
│ 2019-02-02 │
└──────────────────────────────────────────────────────────────────────────────────────┘
datetime بعد إضافة num من الأسابيع إليه Date or Date32 or DateTime or DateTime64
أمثلة
إضافة أسابيع إلى أنواع مختلفة من التواريخ
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addWeeks(date, 5) AS add_weeks_with_date,
addWeeks(date_time, 5) AS add_weeks_with_date_time,
addWeeks(date_time_string, 5) AS add_weeks_with_date_time_string
┌─add_weeks_with_date─┬─add_weeks_with_date_time─┬─add_weeks_with_date_time_string─┐
│ 2024-02-05 │ 2024-02-05 00:00:00 │ 2024-02-05 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 week)
┌─plus(CAST('1⋯alWeek(10))─┐
│ 1998-08-25 │
└──────────────────────────┘
datetime بعد إضافة num سنة إليه. Date أو Date32 أو DateTime أو DateTime64
أمثلة
إضافة سنوات إلى أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
addYears(date, 1) AS add_years_with_date,
addYears(date_time, 1) AS add_years_with_date_time,
addYears(date_time_string, 1) AS add_years_with_date_time_string
┌─add_years_with_date─┬─add_years_with_date_time─┬─add_years_with_date_time_string─┐
│ 2025-01-01 │ 2025-01-01 00:00:00 │ 2025-01-01 00:00:00.000 │
└─────────────────────┴──────────────────────────┴─────────────────────────────────┘
SELECT dateAdd('1998-06-16'::Date, INTERVAL 10 year)
┌─plus(CAST('1⋯alYear(10))─┐
│ 2008-06-16 │
└──────────────────────────┘
startdate وenddate.
ويُحسب الفرق باستخدام دقة مقدارها 1 نانوثانية.
على سبيل المثال، يكون الفرق بين 2021-12-29 و2022-01-01 هو 3 أيام لوحدة اليوم،
و0 شهرًا لوحدة الشهر، و0 سنة لوحدة السنة.
كبديل للدالة age، راجع الدالة dateDiff.
البنية
age('unit', startdate, enddate[, timezone])
unit — نوع الفاصل الزمني للنتيجة.
| Unit | القيم الممكنة |
|---|
| nanosecond | nanosecond, nanoseconds, ns |
| microsecond | microsecond, microseconds, us, u |
| millisecond | millisecond, milliseconds, ms |
| second | second, seconds, ss, s |
| minute | minute, minutes, mi, n |
| hour | hour, hours, hh, h |
| day | day, days, dd, d |
| week | week, weeks, wk, ww |
| month | month, months, mm, m |
| quarter | quarter, quarters, qq, q |
| year | year, years, yyyy, yy |
startdate — أول قيمة زمنية للطرح (المطروح). Date أو Date32 أو DateTime أو DateTime64enddate — ثاني قيمة زمنية يُطرح منها (المطروح منه). Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. اسم المنطقة الزمنية. إذا تم تحديده، فسيُطبَّق على كلٍّ من startdate و enddate. وإذا لم يتم تحديده، فستُستخدم المنطقتان الزمنيتان لـ startdate و enddate. وإذا لم تكونا متماثلتين، فالنتيجة غير محددة. String
القيمة المعادة
تعيد الفرق بين enddate و startdate معبَّرًا عنه بوحدة unit. Int32
أمثلة
حساب العمر بالساعات
SELECT age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))
┌─age('hour', toDateTime('2018-01-01 22:30:00'), toDateTime('2018-01-02 23:00:00'))─┐
│ 24 │
└───────────────────────────────────────────────────────────────────────────────────┘
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
age('day', s, e) AS day_age,
age('month', s, e) AS month_age,
age('year', s, e) AS year_age
┌──────────e─┬──────────s─┬─day_age─┬─month_age─┬─year_age─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 0 │ 0 │
└────────────┴────────────┴─────────┴───────────┴──────────┘
changeDay(date_or_datetime, value)
date_or_datetime مع تعديل مكوّن اليوم. Date أو Date32 أو DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT changeDay('2024-01-31'::DateTime, 15)
changeHour(date_or_datetime, value)
date_or_datetime مع تعديل مكوّن الساعة. DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT changeHour('2024-01-01 12:00:00'::DateTime, 5)
date or date time.
البنية
changeMinute(date_or_datetime, value)
date_or_datetime بعد تعديل مكوّن الدقيقة. DateTime أو DateTime64
أمثلة
مثال للاستخدام
SELECT changeMinute('2024-01-01 12:30:00'::DateTime, 45)
changeMonth(date_or_datetime, value)
date_or_datetime مع تعديل مكوّن الشهر. Date أو Date32 أو DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT changeMonth('2024-01-01'::DateTime, 12)
changeSecond(date_or_datetime, value)
date_or_datetime مع تعديل مكوّن الثواني. DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT changeSecond('2024-01-01 12:30:45'::DateTime, 15)
changeYear(date_or_datetime, value)
date_or_datetime مع تعديل مكوّن السنة. Date أو Date32 أو DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT changeYear('2024-01-01'::DateTime, 2023)
unit المحددة التي جرى تجاوزها بين startdate وenddate.
يُحسب الفرق باستخدام الوحدات النسبية. على سبيل المثال، الفرق بين 2021-12-29 و2022-01-01 هو 3 أيام للوحدة day
(راجع toRelativeDayNum)، وشهر واحد للوحدة month (راجع toRelativeMonthNum)، وسنة واحدة للوحدة year
(راجع toRelativeYearNum).
إذا جرى تحديد الوحدة week، فإن dateDiff يفترض أن الأسابيع تبدأ يوم الاثنين.
لاحظ أن هذا السلوك يختلف عن سلوك الدالة toWeek()، حيث تبدأ الأسابيع افتراضيًا يوم الأحد.
كبديل لـ dateDiff، راجع الدالة age.
البنية
dateDiff(unit, startdate, enddate[, timezone])
timestampDiff, TIMESTAMP_DIFF, DATE_DIFF, date_diff, timestamp_diff
المعاملات
unit — نوع الفاصل الزمني المستخدم في النتيجة.
| الوحدة | القيم الممكنة |
|---|
| نانوثانية | nanosecond, nanoseconds, ns |
| ميكروثانية | microsecond, microseconds, us, u |
| مللي ثانية | millisecond, milliseconds, ms |
| ثانية | second, seconds, ss, s |
| دقيقة | minute, minutes, mi, n |
| ساعة | hour, hours, hh, h |
| يوم | day, days, dd, d |
| أسبوع | week, weeks, wk, ww |
| شهر | month, months, mm, m |
| ربع سنة | quarter, quarters, qq, q |
| سنة | year, years, yyyy, yy |
startdate — القيمة الزمنية الأولى التي تُطرح (المطروح). Date أو Date32 أو DateTime أو DateTime64enddate — القيمة الزمنية الثانية التي يُطرح منها (المطروح منه). Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. اسم المنطقة الزمنية. إذا تم تحديده، فسيُطبَّق على كلٍّ من startdate وenddate. وإذا لم يتم تحديده، فستُستخدم المنطقتان الزمنيتان لـ startdate وenddate. وإذا لم تكونا متماثلتين، فستكون النتيجة غير محددة. String
القيمة المعادة
تعيد الفرق بين enddate وstartdate معبَّرًا عنه بوحدة unit. Int64
أمثلة
حساب فرق التاريخ بالساعات
SELECT dateDiff('hour', toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
SELECT
toDate('2022-01-01') AS e,
toDate('2021-12-29') AS s,
dateDiff('day', s, e) AS day_diff,
dateDiff('month', s, e) AS month_diff,
dateDiff('year', s, e) AS year_diff
┌──────────e─┬──────────s─┬─day_diff─┬─month_diff─┬─year_diff─┐
│ 2022-01-01 │ 2021-12-29 │ 3 │ 1 │ 1 │
└────────────┴────────────┴──────────┴────────────┴───────────┘
- ‘year’
- ‘quarter’
- ‘month’
- ‘week’
- ‘dayofyear’
- ‘day’
- ‘weekday’
- ‘hour’
- ‘minute’
- ‘second’
البنية
dateName(date_part, date[, timezone])
String
أمثلة
استخراج أجزاء مختلفة من التاريخ
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT
dateName('year', date_value),
dateName('month', date_value),
dateName('day', date_value)
┌─dateName('year', date_value)─┬─dateName('month', date_value)─┬─dateName('day', date_value)─┐
│ 2021 │ April │ 14 │
└──────────────────────────────┴───────────────────────────────┴─────────────────────────────┘
dateTrunc(unit, datetime[, timezone])
DATE_TRUNC
الوسيطات
unit —
وحدة الفترة الزمنية المراد اقتطاع النتيجة إليها. القيم الممكنة: nanosecond (فقط DateTime64)، microsecond (فقط DateTime64)، millisecond (فقط DateTime64)، second، minute، hour، day، week، month، quarter، year.
Stringdatetime — التاريخ والوقت. Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. اسم المنطقة الزمنية لقيمة التاريخ والوقت المعادة. إذا لم يتم تحديده، تستخدم الدالة المنطقة الزمنية الخاصة بالوسيطة datetime. String
القيمة المعادة
تعيد قيمة التاريخ والوقت بعد اقتطاعها.
وسيطة unit | وسيطة datetime | نوع الإرجاع |
|---|
| Year, Quarter, Month, Week | Date32 أو DateTime64 أو Date أو DateTime | Date32 أو Date |
| Day, Hour, Minute, Second | Date32، DateTime64، Date، أو DateTime | DateTime64 أو DateTime |
| Millisecond, Microsecond, | أي قيمة | DateTime64 |
| Nanosecond | | بمقياس 3 أو 6 أو 9 |
SELECT now(), dateTrunc('hour', now());
┌───────────────now()─┬─dateTrunc('hour', now())──┐
│ 2020-09-28 10:40:45 │ 2020-09-28 10:00:00 │
└─────────────────────┴───────────────────────────┘
SELECT now(), dateTrunc('hour', now(), 'Asia/Istanbul');
┌───────────────now()─┬─dateTrunc('hour', now(), 'Asia/Istanbul')──┐
│ 2020-09-28 10:46:26 │ 2020-09-28 13:00:00 │
└─────────────────────┴────────────────────────────────────────────┘
format تعبيرًا ثابتًا، لذا لا يمكنك استخدام عدة تنسيقات لعمود نتيجة واحد.
تستخدم formatDateTime أسلوب تنسيق datetime الخاص بـ MySQL، راجع وثائق MySQL.
العملية العكسية لهذه الدالة هي parseDateTime.
باستخدام حقول الاستبدال، يمكنك تحديد نمط للسلسلة الناتجة.
يوضح عمود المثال في الجدول أدناه نتيجة التنسيق للقيمة 2018-01-02 22:33:44.
حقول الاستبدال:
| العنصر النائب | الوصف | مثال |
|---|
| %a | الاسم المختصر ليوم الأسبوع (Mon-Sun) | Mon |
| %b | الاسم المختصر للشهر (Jan-Dec) | Jan |
| %c | الشهر كرقم صحيح (01-12) | 01 |
| %C | السنة مقسومة على 100 ومحوّلة إلى عدد صحيح (00-99) | 20 |
| %d | يوم الشهر مع أصفار بادئة (01-31) | 02 |
| %D | تاريخ قصير بصيغة MM/DD/YY، ويكافئ %m/%d/%y | 01/02/18 |
| %e | يوم الشهر مع مسافات بادئة (1-31) | 2 |
| %f | الجزء الكسري من الثانية | 123456 |
| %F | تاريخ قصير بصيغة YYYY-MM-DD، ويكافئ %Y-%m-%d | 2018-01-02 |
| %g | تنسيق سنة من رقمين، متوافق مع ISO 8601 | 18 |
| %G | تنسيق سنة من أربعة أرقام لرقم الأسبوع وفق ISO | 2018 |
| %h | الساعة بتنسيق 12 ساعة (01-12) | 09 |
| %H | الساعة بتنسيق 24 ساعة (00-23) | 22 |
| %i | الدقيقة (00-59) | 33 |
| %I | الساعة بتنسيق 12 ساعة (01-12) | 10 |
| %j | يوم السنة (001-366) | 002 |
| %k | الساعة بتنسيق 24 ساعة (00-23) | 14 |
| %l | الساعة بتنسيق 12 ساعة (01-12) | 09 |
| %m | الشهر كرقم صحيح (01-12) | 01 |
| %M | الاسم الكامل للشهر (January-December) | January |
| %n | محرف سطر جديد | |
| %p | مؤشر AM أو PM | PM |
| %Q | الربع (1-4) | 1 |
| %r | وقت 12 ساعة بصيغة HH:MM AM/PM، ويكافئ %h:%i %p | 10:30 PM |
| %R | وقت 24 ساعة بصيغة HH:MM، ويكافئ %H:%i | 22:33 |
| %s | الثانية (00-59) | 44 |
| %S | الثانية (00-59) | 44 |
| %t | محرف tab أفقي | |
| %T | تنسيق الوقت ISO 8601 (HH:MM:SS)، ويكافئ %H:%i:%S | 22:33:44 |
| %u | يوم الأسبوع في ISO 8601 كرقم يبدأ فيه الاثنين من 1 (1-7) | 2 |
| %V | رقم الأسبوع وفق ISO 8601 (01-53) | 01 |
| %w | يوم الأسبوع كرقم صحيح يبدأ فيه الأحد من 0 (0-6) | 2 |
| %W | الاسم الكامل ليوم الأسبوع (Monday-Sunday) | Monday |
| %y | السنة، آخر رقمين (00-99) | 18 |
| %Y | السنة | 2018 |
| %z | إزاحة الوقت عن UTC بصيغة +HHMM أو -HHMM | -0500 |
| %% | علامة % | % |
- في إصدارات ClickHouse الأقدم من v23.4، تطبع
%f صفرًا واحدًا (0) إذا كانت القيمة المنسّقة من النوع Date أو Date32 أو DateTime (التي لا تحتوي على أجزاء كسرية من الثانية) أو من النوع DateTime64 بدقة تساوي 0.
- في إصدارات ClickHouse الأقدم من v25.1، تطبع
%f عددًا من الخانات يساوي precision الخاصة بـ DateTime64 بدلًا من 6 خانات ثابتة.
- في إصدارات ClickHouse الأقدم من v23.4، تطبع
%M الدقيقة (00-59) بدلًا من الاسم الكامل للشهر (January-December).
البنية
formatDateTime(datetime, format[, timezone])
DATE_FORMAT
الوسيطات
datetime — تاريخ أو تاريخ ووقت المراد تنسيقه. Date أو Date32 أو DateTime أو DateTime64format — سلسلة تنسيق تحتوي على حقول استبدال. Stringtimezone — اختياري. اسم المنطقة الزمنية للوقت المنسَّق. String
القيمة المُعادة
يعيد قيم التاريخ والوقت وفقًا للتنسيق المحدد. String
أمثلة
تنسيق التاريخ باستخدام العنصر النائب للسنة
SELECT formatDateTime(toDate('2010-01-04'), '%g')
┌─formatDateTime(toDate('2010-01-04'), '%g')─┐
│ 10 │
└────────────────────────────────────────────┘
SELECT formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')
┌─formatDateTime(toDateTime64('2010-01-04 12:34:56.123456', 7), '%f')─┐
│ 1234560 │
└─────────────────────────────────────────────────────────────────────┘
SELECT
now() AS ts,
time_zone,
formatDateTime(ts, '%T', time_zone) AS str_tz_time
FROM system.time_zones
WHERE time_zone LIKE 'Europe%'
LIMIT 10
┌──────────────────ts─┬─time_zone─────────┬─str_tz_time─┐
│ 2023-09-08 19:13:40 │ Europe/Amsterdam │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Andorra │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Astrakhan │ 23:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Athens │ 22:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belfast │ 20:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Belgrade │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Berlin │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bratislava │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Brussels │ 21:13:40 │
│ 2023-09-08 19:13:40 │ Europe/Bucharest │ 22:13:40 │
└─────────────────────┴───────────────────┴─────────────┘
formatDateTime، إلا أنها تنسّق قيم التاريخ والوقت بأسلوب Joda بدلًا من أسلوب MySQL. راجع توثيق Joda Time.
العملية العكسية لهذه الدالة هي parseDateTimeInJodaSyntax.
باستخدام حقول الاستبدال، يمكنك تحديد نمط للسلسلة الناتجة.
حقول الاستبدال:
| العنصر النائب | الوصف | العرض | أمثلة |
|---|
| G | العصر | نص | AD |
| C | قرن العصر (>=0) | رقم | 20 |
| Y | سنة العصر (>=0) | سنة | 1996 |
| x | سنة الأسبوع (غير مدعومة بعد) | سنة | 1996 |
| w | أسبوع سنة الأسبوع (غير مدعوم بعد) | رقم | 27 |
| e | يوم الأسبوع | رقم | 2 |
| E | يوم الأسبوع | نص | Tuesday; Tue |
| y | السنة | سنة | 1996 |
| D | اليوم من السنة | رقم | 189 |
| M | شهر السنة | شهر | July; Jul; 07 |
| d | يوم الشهر | رقم | 10 |
| a | نصف اليوم | نص | PM |
| K | ساعة نصف اليوم (0~11) | رقم | 0 |
| h | ساعة نصف اليوم بنظام الساعة (1~12) | رقم | 12 |
| H | ساعة اليوم (0~23) | رقم | 0 |
| k | ساعة اليوم بنظام الساعة (1~24) | رقم | 24 |
| m | دقيقة الساعة | رقم | 30 |
| s | ثانية الدقيقة | رقم | 55 |
| S | جزء من الثانية | رقم | 978 |
| z | المنطقة الزمنية | نص | Eastern Standard Time; EST |
| Z | إزاحة المنطقة الزمنية | منطقة | -0800; -0812 |
| ’ | إفلات للنص | فاصل | |
| ” | علامة اقتباس مفردة | قيمة حرفية | ’ |
formatDateTimeInJodaSyntax(datetime, format[, timezone])
datetime — تاريخ أو تاريخ ووقت لتنسيقه. DateTime أو Date أو Date32 أو DateTime64format — سلسلة تنسيق تتضمن حقول استبدال بنمط Joda. Stringtimezone — اختياري. اسم المنطقة الزمنية للوقت المنسَّق. String
القيمة المُعادة
يعرض قيم الوقت والتاريخ وفقًا للتنسيق المحدد. String
أمثلة
تنسيق التاريخ والوقت باستخدام بنية Joda
SELECT formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')
┌─formatDateTimeInJodaSyntax(toDateTime('2010-01-04 12:34:56'), 'yyyy-MM-dd HH:mm:ss')─┐
│ 2010-01-04 12:34:56 │
└─────────────────────────────────────────────────────────────────────────────────────────┘
FROM_DAYS() في MySQL. وتكون النتيجة غير معرّفة إذا تعذّر تمثيلها ضمن حدود النوع Date.
الصيغة
fromDaysSinceYearZero(days)
FROM_DAYS
الوسائط
days — عدد الأيام المنقضية منذ العام صفر. UInt32
القيمة المُعادة
تعيد التاريخ الموافق لعدد الأيام المنقضية منذ العام صفر. Date
أمثلة
تحويل الأيام منذ العام صفر إلى تواريخ
SELECT
fromDaysSinceYearZero(739136) AS date1,
fromDaysSinceYearZero(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
FROM_DAYS() في MySQL. وتكون النتيجة غير معرّفة إذا تعذّر تمثيلها ضمن حدود النوع Date32.
البنية
fromDaysSinceYearZero32(days)
days — عدد الأيام المنقضية منذ السنة صفر. UInt32
القيمة المُعادة
تُرجِع التاريخ الموافق لعدد الأيام المنقضية منذ السنة صفر. Date32
أمثلة
تحويل الأيام منذ السنة صفر إلى تواريخ
SELECT
fromDaysSinceYearZero32(739136) AS date1,
fromDaysSinceYearZero32(toDaysSinceYearZero(toDate('2023-09-08'))) AS date2
┌──────date1─┬──────date2─┐
│ 2023-09-08 │ 2023-09-08 │
└────────────┴────────────┘
YYYY-MM-DD. تدعم هذه الدالة أرقام الأيام من -678941 إلى 2973483 (وهي تمثل 0000-01-01 و9999-12-31 على التوالي). وتُطلق استثناءً إذا كان رقم اليوم خارج النطاق المدعوم.
البنية
fromModifiedJulianDay(day)
day — رقم اليوم اليولياني المُعدَّل. (U)Int*
القيمة المُرجَعة
تعيد التاريخ بصيغة نصية. String
أمثلة
تحويل اليوم اليولياني المُعدَّل إلى تاريخ
SELECT fromModifiedJulianDay(58849)
┌─fromModifiedJulianDay(58849)─┐
│ 2020-01-01 │
└──────────────────────────────┘
fromModifiedJulianDayOrNull
fromModifiedJulianDay()، لكنه يعيد NULL بدلًا من إطلاق استثناءات.
الصيغة
fromModifiedJulianDayOrNull(day)
day — رقم اليوم اليولياني المعدّل. (U)Int*
القيمة المُعادة
يعيد التاريخ بصيغة نصية إذا كانت قيمة الوسيط day صالحة، وإلا فستكون null. Nullable(String)
أمثلة
تحويل اليوم اليولياني المعدّل إلى تاريخ مع التعامل مع القيم null
SELECT fromModifiedJulianDayOrNull(58849);
SELECT fromModifiedJulianDayOrNull(60000000); -- invalid argument, returns NULL
┌─fromModified⋯Null(58849)─┐
│ 2020-01-01 │
└──────────────────────────┘
┌─fromModified⋯l(60000000)─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
fromUTCTimestamp(datetime, time_zone)
from_utc_timestamp
الوسيطات
datetime — قيمة ثابتة من نوع تاريخ أو تاريخ مع وقت، أو تعبير. DateTime أو DateTime64time_zone — قيمة ثابتة من نوع String أو تعبير يمثّل المنطقة الزمنية. String
القيمة المعادة
يعيد قيمة من نوع DateTime/DateTime64 في المنطقة الزمنية المحددة. DateTime أو DateTime64
أمثلة
تحويل المنطقة الزمنية UTC إلى المنطقة الزمنية المحددة
SELECT fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00', 3), 'Asia/Shanghai')
┌─fromUTCTimestamp(toDateTime64('2023-03-16 10:00:00',3), 'Asia/Shanghai')─┐
│ 2023-03-16 18:00:00.000 │
└─────────────────────────────────────────────────────────────────────────┘
fromUnixTimestamp(timestamp)
fromUnixTimestamp(timestamp[, format[, timezone]])
FROM_UNIXTIME
الوسائط
القيمة المُعادة
يعيد قيمة DateTime للطابع الزمني عند استدعائه بوسيطة واحدة، أو قيمة String عند استدعائه بوسيطتين أو ثلاث وسيطات. DateTime أو String
أمثلة
تحويل طابع زمني لـ Unix إلى DateTime
SELECT fromUnixTimestamp(423543535)
┌─fromUnixTimestamp(423543535)─┐
│ 1983-06-04 10:58:55 │
└──────────────────────────────┘
SELECT fromUnixTimestamp(1234334543, '%Y-%m-%d %R:%S') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 14:42:23 │
└─────────────────────┘
fromUnixTimestampInJodaSyntax
Integer، فإنها تُرجع قيمة من النوع DateTime، أي إنها تعمل مثل toDateTime.
عند تمرير وسيطين أو ثلاثة وسائط، بحيث تكون قيمة الوسيط الأول من النوع Integer أو Date أو Date32 أو DateTime أو DateTime64، ويكون الوسيط الثاني سلسلة تنسيق ثابتة، ويكون الوسيط الثالث سلسلة منطقة زمنية ثابتة اختيارية، فإن الدالة تُرجع قيمة من النوع String، أي إنها تعمل مثل formatDateTimeInJodaSyntax. في هذه الحالة، يُستخدم نمط تنسيق التاريخ والوقت في Joda.
البنية
fromUnixTimestampInJodaSyntax(timestamp)
fromUnixTimestampInJodaSyntax(timestamp, format[, timezone])
timestamp — طابع زمني بنظام Unix أو قيمة تاريخ/وقت. (U)Int* أو Date أو Date32 أو DateTime أو DateTime64format — اختياري. سلسلة تنسيق ثابتة تستخدم بناء جملة Joda لتنسيق الإخراج. Stringtimezone — اختياري. سلسلة ثابتة للمنطقة الزمنية. String
القيمة المعادة
يعيد قيمة تاريخ مع وقت عند استدعائه بوسيطة واحدة، أو قيمة من النوع String عند استدعائه بوسيطتين أو ثلاث وسيطات.} DateTime أو String
أمثلة
تحويل طابع زمني بنظام Unix باستخدام تنسيق Joda
SELECT fromUnixTimestampInJodaSyntax(1234334543, 'yyyy-MM-dd HH:mm:ss', 'UTC') AS DateTime
┌─DateTime────────────┐
│ 2009-02-11 06:42:23 │
└─────────────────────┘
LOCALTIME القياسية في SQL / PostgreSQL، وتكافئ CAST(now() AS Time).
البنية
المعاملات
القيمة المُعادة
يعيد الوقت الحالي. Time
أمثلة
صيغة SQL القياسية من دون أقواس
┌───────LOCALTIME─┐
│ 07:42:09 │
└─────────────────┘
Date من أحد الخيارين التاليين:
- سنة وشهر ويوم
- سنة ورقم اليوم في السنة
الصيغة
makeDate(year, month, day)
makeDate(year, day_of_year)
Date مُنشأة من الوسيطات المقدَّمة Date
أمثلة
إنشاء Date من سنة وشهر ويوم
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
Date32 من أحد الخيارين التاليين:
- سنة وشهر ويوم
- سنة ويوم من أيام السنة
الصياغة
makeDate32(year, month, day)
makeDate32(year, day_of_year)
Date32 مُنشأة من الوسائط المقدَّمة Date32
أمثلة
Date32 من سنة وشهر ويوم
SELECT makeDate(2023, 2, 28) AS date;
┌───────date─┐
│ 2023-02-28 │
└────────────┘
SELECT makeDate(2023, 42) AS date;
┌───────date─┐
│ 2023-02-11 │
└────────────┘
DateTime من السنة والشهر واليوم والساعة والدقيقة والثانية، مع timezone اختياري.
الصيغة
makeDateTime(year, month, day, hour, minute, second[, timezone])
DateTime مُنشأة من الوسيطات المقدَّمة DateTime
أمثلة
DateTime من السنة والشهر واليوم والساعة والدقيقة والثانية
SELECT makeDateTime(2023, 2, 28, 17, 12, 33) AS DateTime;
┌────────────DateTime─┐
│ 2023-02-28 17:12:33 │
└─────────────────────┘
DateTime64 من السنة والشهر واليوم والساعة والدقيقة والثانية، مع جزء كسري اختياري، ودقة، ومنطقة زمنية.
البنية
makeDateTime64(year, month, day, hour, minute, second[, fraction[, precision[, timezone]]])
DateTime64 مُنشأة من الوسائط المُعطاة DateTime64
أمثلة
DateTime64 من السنة والشهر واليوم والساعة والدقيقة والثانية
SELECT makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5);
┌─makeDateTime64(2023, 5, 15, 10, 30, 45, 779, 5)─┐
│ 2023-05-15 10:30:45.00779 │
└─────────────────────────────────────────────────┘
String
أمثلة
الحصول على اسم الشهر من التاريخ
WITH toDateTime('2021-04-14 11:22:33') AS date_value
SELECT monthName(date_value)
┌─monthName(date_value)─┐
│ April │
└───────────────────────┘
localtimestamp, current_timestamp
الوسائط
timezone — اختياري. اسم المنطقة الزمنية للقيمة المُعادة. String
القيمة المُعادة
يعيد التاريخ والوقت الحاليَّين. DateTime
أمثلة
استعلام بدون منطقة زمنية
┌───────────────now()─┐
│ 2020-10-17 07:42:09 │
└─────────────────────┘
SELECT now('Asia/Istanbul')
┌─now('Asia/Istanbul')─┐
│ 2020-10-17 10:42:23 │
└──────────────────────┘
SELECT NOW, CURRENT_TIMESTAMP
┌─────────────────NOW─┬───CURRENT_TIMESTAMP─┐
│ 2020-10-17 07:42:19 │ 2020-10-17 07:42:19 │
└─────────────────────┴─────────────────────┘
now64([scale[, timezone]])
scale — اختياري. حجم الخطوة (الدقة): 10^-precision ثانية. النطاق الصالح: [0 : 9]. تُستخدم عادةً القيم 3 (افتراضي) (مللي ثانية)، و6 (ميكروثانية)، و9 (نانوثانية). UInt8timezone — اختياري. اسم المنطقة الزمنية للقيمة المُعادة. String
القيمة المُعادة
تعيد التاريخ والوقت الحاليين بدقة أجزاء من الثانية. DateTime64
أمثلة
استعلام بدقة افتراضية ومخصّصة
SELECT now64(), now64(9, 'Asia/Istanbul')
┌─────────────────now64()─┬─────now64(9, 'Asia/Istanbul')─┐
│ 2022-08-21 19:34:26.196 │ 2022-08-21 22:34:26.196542766 │
└─────────────────────────┴───────────────────────────────┘
now، فهي ليست تعبيرًا ثابتًا، وستختلف القيمة المعادة من كتلة إلى أخرى في الاستعلامات طويلة التشغيل.
من المنطقي استخدام هذه الدالة لتوليد الوقت الحالي في استعلامات INSERT SELECT طويلة التشغيل.
البنية
الوسيطات
timezone — اختياري. اسم المنطقة الزمنية للقيمة المعادة. String
القيمة المعادة
تعيد التاريخ والوقت الحاليين في لحظة معالجة كل كتلة من البيانات. DateTime
أمثلة
الفرق عن الدالة now()
SELECT
now(),
nowInBlock(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌───────────────now()─┬────────nowInBlock()─┬─sleep(1)─┐
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:19 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:20 │ 0 │
│ 2022-08-21 19:41:19 │ 2022-08-21 19:41:21 │ 0 │
└─────────────────────┴─────────────────────┴──────────┘
INSERT SELECT طويلة التشغيل.
الصياغة
nowInBlock64([scale[, timezone]])
scale — اختياري. حجم الـ tick (الدقة): 10^-precision ثانية. النطاق الصالح: [0 : 9]. تُستخدم عادةً القيم: 3 (افتراضيًا) (ميلي ثانية)، 6 (ميكروثانية)، 9 (نانوثانية). UInt8timezone — اختياري. اسم المنطقة الزمنية للقيمة المعادة. String
القيمة المعادة
تعيد التاريخ والوقت الحاليين عند معالجة كل كتلة من البيانات، مع دقة أقل من الثانية. DateTime64
أمثلة
الفرق مع الدالة now64()
SELECT
now64(),
nowInBlock64(),
sleep(1)
FROM numbers(3)
SETTINGS max_block_size = 1
FORMAT PrettyCompactMonoBlock
┌─────────────────now64()─┬──────────nowInBlock64()─┬─sleep(1)─┐
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:29.534 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:30.535 │ 0 │
│ 2025-07-29 17:07:29.526 │ 2025-07-29 17:07:31.535 │ 0 │
└─────────────────────────┴─────────────────────────┴──────────┘
timezone.
إذا نُفِّذت الدالة في سياق جدول موزّع، فإنها تُنشئ عمودًا عاديًا بقيم تخص كل shard. وإلا، فإنها تُنتج قيمة ثابتة.
الصيغة
الأسماء المستعارة: serverTimeZone
الوسائط
القيمة المُعادة
تُرجع المنطقة الزمنية للخادم على هيئة String
أمثلة
مثال على الاستخدام
┌─serverTimeZone()─┐
│ UTC │
└──────────────────┘
subDate(datetime, interval)
interval من datetime. Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح فاصل زمني من تاريخ
SELECT subDate(toDate('2018-01-01'), INTERVAL 3 YEAR)
┌─subDate(toDate('2018-01-01'), toIntervalYear(3))─┐
│ 2015-01-01 │
└──────────────────────────────────────────────────┘
subtractDays(datetime, num)
datetime بعد طرح num يومًا منه. Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح الأيام من أنواع التاريخ المختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractDays(date, 31) AS subtract_days_with_date,
subtractDays(date_time, 31) AS subtract_days_with_date_time,
subtractDays(date_time_string, 31) AS subtract_days_with_date_time_string
┌─subtract_days_with_date─┬─subtract_days_with_date_time─┬─subtract_days_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└─────────────────────────┴──────────────────────────────┴─────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 day)
┌─minus(CAST('⋯valDay(10))─┐
│ 1998-06-06 │
└──────────────────────────┘
subtractHours(datetime, num)
datetime بعد طرح num ساعة منه DateTime أو DateTime64(3)
أمثلة
طرح الساعات من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractHours(date, 12) AS subtract_hours_with_date,
subtractHours(date_time, 12) AS subtract_hours_with_date_time,
subtractHours(date_time_string, 12) AS subtract_hours_with_date_time_string
┌─subtract_hours_with_date─┬─subtract_hours_with_date_time─┬─subtract_hours_with_date_time_string─┐
│ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00 │ 2023-12-31 12:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 hour)
┌─minus(CAST('⋯alHour(10))─┐
│ 1998-06-15 14:00:00 │
└──────────────────────────┘
toIntervalDay(2) و toIntervalDay(1)
فستكون النتيجة (1) بدلًا من (2,1).
الصياغة
subtractInterval(interval_1, interval_2)
Tuple(T)
أمثلة
طرح الفواصل الزمنية
SELECT subtractInterval(INTERVAL 1 DAY, INTERVAL 1 MONTH);
SELECT subtractInterval((INTERVAL 1 DAY, INTERVAL 1 YEAR), INTERVAL 1 MONTH);
SELECT subtractInterval(INTERVAL 2 DAY, INTERVAL 1 DAY);
┌─subtractInterval(toIntervalDay(1), toIntervalMonth(1))─┐
│ (1,-1) │
└────────────────────────────────────────────────────────┘
┌─subtractInterval((toIntervalDay(1), toIntervalYear(1)), toIntervalMonth(1))─┐
│ (1,1,-1) │
└─────────────────────────────────────────────────────────────────────────────┘
┌─subtractInterval(toIntervalDay(2), toIntervalDay(1))─┐
│ (1) │
└──────────────────────────────────────────────────────┘
subtractMicroseconds(datetime, num)
datetime بعد طرح num ميكروثانية منه DateTime64
أمثلة
طرح الميكروثواني من أنواع مختلفة من قيم التاريخ والوقت
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMicroseconds(date_time, 1000000) AS subtract_microseconds_with_date_time,
subtractMicroseconds(date_time_string, 1000000) AS subtract_microseconds_with_date_time_string
┌─subtract_microseconds_with_date_time─┬─subtract_microseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000000 │ 2023-12-31 23:59:59.000000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 microsecond)
┌─minus(CAST('1⋯osecond(10))─┐
│ 1998-06-15 23:59:59.999990 │
└────────────────────────────┘
subtractMilliseconds(datetime, num)
datetime بعد طرح num مللي ثانية منه DateTime64
أمثلة
طرح المللي ثانية من أنواع مختلفة من التاريخ والوقت
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMilliseconds(date_time, 1000) AS subtract_milliseconds_with_date_time,
subtractMilliseconds(date_time_string, 1000) AS subtract_milliseconds_with_date_time_string
┌─subtract_milliseconds_with_date_time─┬─subtract_milliseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.000 │ 2023-12-31 23:59:59.000 │
└──────────────────────────────────────┴─────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 millisecond)
┌─minus(CAST('⋯second(10))─┐
│ 1998-06-15 23:59:59.990 │
└──────────────────────────┘
subtractMinutes(datetime, num)
datetime بعد طرح num دقيقة منه من النوع DateTime أو DateTime64(3)
أمثلة
طرح الدقائق من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMinutes(date, 30) AS subtract_minutes_with_date,
subtractMinutes(date_time, 30) AS subtract_minutes_with_date_time,
subtractMinutes(date_time_string, 30) AS subtract_minutes_with_date_time_string
┌─subtract_minutes_with_date─┬─subtract_minutes_with_date_time─┬─subtract_minutes_with_date_time_string─┐
│ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00 │ 2023-12-31 23:30:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 minute)
┌─minus(CAST('⋯Minute(10))─┐
│ 1998-06-15 23:50:00 │
└──────────────────────────┘
subtractMonths(datetime, num)
datetime بعد طرح num شهرًا منه Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح الأشهر من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractMonths(date, 1) AS subtract_months_with_date,
subtractMonths(date_time, 1) AS subtract_months_with_date_time,
subtractMonths(date_time_string, 1) AS subtract_months_with_date_time_string
┌─subtract_months_with_date─┬─subtract_months_with_date_time─┬─subtract_months_with_date_time_string─┐
│ 2023-12-01 │ 2023-12-01 00:00:00 │ 2023-12-01 00:00:00.000 │
└───────────────────────────┴────────────────────────────────┴───────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 month)
┌─minus(CAST('⋯lMonth(10))─┐
│ 1997-08-16 │
└──────────────────────────┘
subtractNanoseconds(datetime, num)
datetime بعد طرح num نانوثانية منها، من النوع DateTime64
أمثلة
طرح النانوثواني من أنواع التاريخ والوقت المختلفة
WITH
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractNanoseconds(date_time, 1000) AS subtract_nanoseconds_with_date_time,
subtractNanoseconds(date_time_string, 1000) AS subtract_nanoseconds_with_date_time_string
┌─subtract_nanoseconds_with_date_time─┬─subtract_nanoseconds_with_date_time_string─┐
│ 2023-12-31 23:59:59.999999000 │ 2023-12-31 23:59:59.999999000 │
└─────────────────────────────────────┴────────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::DateTime, INTERVAL 10 nanosecond)
┌─minus(CAST('19⋯anosecond(10))─┐
│ 1998-06-15 23:59:59.999999990 │
└───────────────────────────────┘
subtractQuarters(datetime, num)
datetime بعد طرح num من أرباع السنة. Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح أرباع السنة من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractQuarters(date, 1) AS subtract_quarters_with_date,
subtractQuarters(date_time, 1) AS subtract_quarters_with_date_time,
subtractQuarters(date_time_string, 1) AS subtract_quarters_with_date_time_string
┌─subtract_quarters_with_date─┬─subtract_quarters_with_date_time─┬─subtract_quarters_with_date_time_string─┐
│ 2023-10-01 │ 2023-10-01 00:00:00 │ 2023-10-01 00:00:00.000 │
└─────────────────────────────┴──────────────────────────────────┴─────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 quarter)
┌─minus(CAST('1⋯Quarter(10))─┐
│ 1996-09-16 │
└───────────────────────────┘
subtractSeconds(datetime, num)
datetime بعد طرح num ثانية منه DateTime أو DateTime64(3)
أمثلة
طرح الثواني من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractSeconds(date, 60) AS subtract_seconds_with_date,
subtractSeconds(date_time, 60) AS subtract_seconds_with_date_time,
subtractSeconds(date_time_string, 60) AS subtract_seconds_with_date_time_string
┌─subtract_seconds_with_date─┬─subtract_seconds_with_date_time─┬─subtract_seconds_with_date_time_string─┐
│ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00 │ 2023-12-31 23:59:00.000 │
└────────────────────────────┴─────────────────────────────────┴────────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 second)
┌─minus(CAST('⋯Second(10))─┐
│ 1998-06-15 23:59:50 │
└──────────────────────────┘
subtractTupleOfIntervals(datetime, intervals)
date بعد طرح intervals منه Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح Tuple من الفواصل الزمنية من التاريخ
WITH toDate('2018-01-01') AS date SELECT subtractTupleOfIntervals(date, (INTERVAL 1 DAY, INTERVAL 1 YEAR))
┌─subtractTupl⋯alYear(1)))─┐
│ 2016-12-31 │
└──────────────────────────┘
subtractWeeks(datetime, num)
datetime بعد طرح num أسبوعًا منه Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح أسابيع من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractWeeks(date, 1) AS subtract_weeks_with_date,
subtractWeeks(date_time, 1) AS subtract_weeks_with_date_time,
subtractWeeks(date_time_string, 1) AS subtract_weeks_with_date_time_string
┌─subtract_weeks_with_date─┬─subtract_weeks_with_date_time─┬─subtract_weeks_with_date_time_string─┐
│ 2023-12-25 │ 2023-12-25 00:00:00 │ 2023-12-25 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 week)
┌─minus(CAST('⋯alWeek(10))─┐
│ 1998-04-07 │
└──────────────────────────┘
subtractYears(datetime, num)
datetime بعد طرح num سنة منه. Date أو Date32 أو DateTime أو DateTime64
أمثلة
طرح السنوات من أنواع تاريخ مختلفة
WITH
toDate('2024-01-01') AS date,
toDateTime('2024-01-01 00:00:00') AS date_time,
'2024-01-01 00:00:00' AS date_time_string
SELECT
subtractYears(date, 1) AS subtract_years_with_date,
subtractYears(date_time, 1) AS subtract_years_with_date_time,
subtractYears(date_time_string, 1) AS subtract_years_with_date_time_string
┌─subtract_years_with_date─┬─subtract_years_with_date_time─┬─subtract_years_with_date_time_string─┐
│ 2023-01-01 │ 2023-01-01 00:00:00 │ 2023-01-01 00:00:00.000 │
└──────────────────────────┴───────────────────────────────┴──────────────────────────────────────┘
SELECT dateSub('1998-06-16'::Date, INTERVAL 10 year)
┌─minus(CAST('⋯alYear(10))─┐
│ 1988-06-16 │
└──────────────────────────┘
enddate - startdate.
هذه الدالة مكافئة لـ dateDiff('second', startdate, enddate).
لحساب الفروق الزمنية بوحدات أخرى (مثل الساعات والأيام والأشهر وما إلى ذلك)، استخدم الدالة dateDiff بدلًا من ذلك.
البنية
timeDiff(startdate, enddate)
enddate وstartdate معبَّرًا عنه بالثواني. Int64
أمثلة
حساب الفرق الزمني بالثواني
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) AS res
┌───res─┐
│ 90000 │
└───────┘
SELECT timeDiff(toDateTime('2018-01-01 22:00:00'), toDateTime('2018-01-02 23:00:00')) / 3600 AS hours
┌─hours─┐
│ 25 │
└───────┘
SELECT
timeDiff(toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS time_diff_result,
dateDiff('second', toDateTime('2021-12-29'), toDateTime('2022-01-01')) AS date_diff_result
┌─time_diff_result─┬─date_diff_result─┐
│ 259200 │ 259200 │
└──────────────────┴──────────────────┘
على الرغم من أن هذه الدالة يمكن أن تأخذ قيماً من النوعين الموسّعين Date32 وDateTime64 كوسيط،
فإن تمرير قيمة وقت تقع خارج النطاق المعتاد إليها (من عام 1970 إلى 2149 بالنسبة إلى Date / وحتى 2106 بالنسبة إلى DateTime) سيؤدي إلى نتائج غير صحيحة.
timeSlot(time[, time_zone])
time — الوقت المطلوب تقريبه إلى بداية فاصل زمني مدته نصف ساعة. DateTime أو Date32 أو DateTime64time_zone — اختياري. قيمة ثابتة من نوع String أو تعبير يمثّل المنطقة الزمنية. String
القيمة المعادة
يعيد الوقت بعد تقريبه إلى بداية فاصل زمني مدته نصف ساعة. DateTime
أمثلة
تقريب الوقت إلى فاصل زمني مدته نصف ساعة
SELECT timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))
┌─timeSlot(toDateTime('2000-01-02 03:04:05', 'UTC'))─┐
│ 2000-01-02 03:00:00 │
└────────────────────────────────────────────────────┘
StartTime وتستمر لمدة Duration ثانية، تُرجِع الدالة مصفوفة من اللحظات الزمنية تتكوّن من نقاط ضمن هذه الفترة بعد تقريبها نزولًا إلى Size بالثواني. Size وسيط اختياري مضبوط افتراضيًا على 1800 (30 دقيقة).
وهذا ضروري، على سبيل المثال، عند البحث عن مرات عرض الصفحة في الجلسة المقابلة.
بالنسبة إلى DateTime64، قد يختلف المقياس الخاص بالقيمة المُعادة عن مقياس StartTime. ويُؤخذ أعلى مقياس من بين جميع الوسيطات المُعطاة.
البنية
timeSlots(StartTime, Duration[, Size])
StartTime). بالنسبة إلى DateTime64، قد يختلف مقياس القيمة المُعادة عن مقياس StartTime — إذ يُعتمد أعلى مقياس بين جميع الوسيطات المُعطاة. Array(DateTime) أو Array(DateTime64)
أمثلة
إنشاء فترات زمنية لفاصل زمني
SELECT timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600));
SELECT timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299);
SELECT timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))
┌─timeSlots(toDateTime('2012-01-01 12:20:00'), toUInt32(600))─┐
│ ['2012-01-01 12:00:00','2012-01-01 12:30:00'] │
└─────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime('1980-12-12 21:01:02', 'UTC'), toUInt32(600), 299)─┐
│ ['1980-12-12 20:56:13','1980-12-12 21:01:12','1980-12-12 21:06:11'] │
└─────────────────────────────────────────────────────────────────────────┘
┌─timeSlots(toDateTime64('1980-12-12 21:01:02.1234', 4, 'UTC'), toDecimal64(600.1, 1), toDecimal64(299, 0))─┐
│ ['1980-12-12 20:56:13.0000','1980-12-12 21:01:12.0000','1980-12-12 21:06:11.0000'] │
└───────────────────────────────────────────────────────────────────────────────────────────────────────────┘
expr إلى النوع DateTime64(6).
إذا تم توفير وسيط ثانٍ expr_time، فإنه يضيف الوقت المحدد إلى القيمة بعد تحويلها.
البنية
timestamp(expr[, expr_time])
expr — تاريخ أو تاريخ متضمّن للوقت. Stringexpr_time — اختياري. الوقت المراد إضافته إلى القيمة المُحوَّلة. String
القيمة المعادة
تُعيد القيمة المُحوَّلة لـ expr، أو expr بعد إضافة وقت إليه DateTime64(6)
أمثلة
تحويل سلسلة تاريخ إلى DateTime64(6)
SELECT timestamp('2023-12-31') AS ts;
┌─────────────────────────ts─┐
│ 2023-12-31 00:00:00.000000 │
└────────────────────────────┘
SELECT timestamp('2023-12-31 12:00:00', '12:00:00.11') AS ts;
┌─────────────────────────ts─┐
│ 2024-01-01 00:00:00.110000 │
└────────────────────────────┘
timeZone
الوسائط
القيمة المُعادة
يُرجع اسم المنطقة الزمنية المعياري على هيئة String
أمثلة
مثال على الاستخدام
┌─timezone()───────┐
│ Europe/Amsterdam │
└──────────────────┘
DateTime أو DateTime64.
الصياغة
الأسماء البديلة: timeZoneOf
الوسائط
datetime — قيمة من النوع DateTime أو DateTime64timezone — اختياري. اسم المنطقة الزمنية المطلوب تحويل قيمة datetime إليها. String
القيمة المعادة
يرجع اسم المنطقة الزمنية لـ datetime من النوع String
أمثلة
مثال للاستخدام
SELECT timezoneOf(now());
┌─timezoneOf(now())─┐
│ Europe/Amsterdam │
└───────────────────┘
timeZoneOffset
الوسائط
datetime — قيمة DateTime المطلوب الحصول على إزاحة المنطقة الزمنية الخاصة بها. DateTime أو DateTime64
القيمة المُعادة
تعيد إزاحة UTC بالثواني Int32
أمثلة
مثال على الاستخدام
SELECT toDateTime('2021-04-21 10:20:30', 'America/New_York') AS Time,
toTypeName(Time) AS Type,
timezoneOffset(Time) AS Offset_in_seconds,
(Offset_in_seconds / 3600) AS Offset_in_hours;
┌────────────────Time─┬─Type─────────────────────────┬─Offset_in_seconds─┬─Offset_in_hours─┐
│ 2021-04-21 10:20:30 │ DateTime('America/New_York') │ -14400 │ -4 │
└─────────────────────┴──────────────────────────────┴───────────────────┴─────────────────┘
Date أو DateTime.
البنية
الأسماء البديلة: DAY, DAYOFMONTH
الوسائط
القيمة المعادة
تعيد يوم الشهر من التاريخ/الوقت المحدد UInt8
أمثلة
مثال على الاستخدام
SELECT toDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 21 │
└─────────────────────────────────────────────────┘
Date أو DateTime.
تتيح لك الصيغة ذات الوسيطتين للدالة toDayOfWeek() تحديد ما إذا كان الأسبوع يبدأ يوم الاثنين أو يوم الأحد،
وما إذا كانت القيمة المعادة يجب أن تكون ضمن النطاق من 0 إلى 6 أو من 1 إلى 7.
| الوضع | أول يوم في الأسبوع | النطاق |
|---|
| 0 | الاثنين | 1-7: الاثنين = 1، الثلاثاء = 2، …، الأحد = 7 |
| 1 | الاثنين | 0-6: الاثنين = 0، الثلاثاء = 1، …، الأحد = 6 |
| 2 | الأحد | 0-6: الأحد = 0، الاثنين = 1، …، السبت = 6 |
| 3 | الأحد | 1-7: الأحد = 1، الاثنين = 2، …، السبت = 7 |
toDayOfWeek(datetime[, mode[, timezone]])
DAYOFWEEK
الوسيطات
datetime — تاريخ أو تاريخ مع وقت لاستخراج يوم الأسبوع منه. Date أو Date32 أو DateTime أو DateTime64mode — اختياري. عدد صحيح يحدد وضع الأسبوع (0-3). تكون القيمة الافتراضية 0 إذا لم يتم تحديده. UInt8timezone — اختياري. المنطقة الزمنية المستخدمة في التحويل. String
القيمة المعادة
تعيد يوم الأسبوع للقيمة Date أو DateTime المحددة. UInt8
أمثلة
مثال على الاستخدام
-- The following date is April 21, 2023, which was a Friday:
SELECT
toDayOfWeek(toDateTime('2023-04-21')),
toDayOfWeek(toDateTime('2023-04-21'), 1)
┌─toDayOfWeek(toDateTime('2023-04-21'))─┬─toDayOfWeek(toDateTime('2023-04-21'), 1)─┐
│ 5 │ 4 │
└───────────────────────────────────────┴──────────────────────────────────────────┘
Date أو DateTime.
الصياغة
الأسماء المستعارة: DAYOFYEAR
الوسيطات
القيمة المعادة
تعيد يوم السنة لقيمة Date أو DateTime المُعطاة UInt16
أمثلة
مثال على الاستخدام
SELECT toDayOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toDayOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 111 │
└────────────────────────────────────────────────┘
Date أو DateTime.
تكون القيمة المُعادة ضمن النطاق من 28 إلى 31.
البنية
الوسائط
القيمة المُعادة
تعيد عدد الأيام في شهر التاريخ/الوقت المحدد. UInt8
أمثلة
مثال على الاستخدام
SELECT toDaysInMonth(toDate('2023-02-01')), toDaysInMonth(toDate('2024-02-01')), toDaysInMonth(toDate('2023-01-01'))
┌─toDaysInMonth(toDate('2023-02-01'))─┬─toDaysInMonth(toDate('2024-02-01'))─┬─toDaysInMonth(toDate('2023-01-01'))─┐
│ 28 │ 29 │ 31 │
└─────────────────────────────────────┴─────────────────────────────────────┴─────────────────────────────────────┘
TO_DAYS في MySQL.
البنية
toDaysSinceYearZero(date[, time_zone])
TO_DAYS
الوسيطات
القيمة المُعادة
تعيد عدد الأيام المنقضية منذ التاريخ 0000-01-01. UInt32
أمثلة
احسب الأيام منذ السنة صفر
SELECT toDaysSinceYearZero(toDate('2023-09-08'))
┌─toDaysSinceYearZero(toDate('2023-09-08')))─┐
│ 713569 │
└────────────────────────────────────────────┘
DateTime أو DateTime64.
البنية
الأسماء البديلة: HOUR
الوسائط
القيمة المُعادة
تُرجِع قيمة الساعة (0-23) من datetime. UInt8
أمثلة
مثال للاستخدام
SELECT toHour(toDateTime('2023-04-21 10:20:30'))
┌─toHour(toDateTime('2023-04-21 10:20:30'))─┐
│ 10 │
└───────────────────────────────────────────┘
toWeek(date, 3).
تبدأ أسابيع ISO يوم الاثنين، ويشمل الأسبوع الأول من السنة يوم 4 يناير.
وفقًا للمعيار ISO 8601، تتراوح أرقام الأسابيع من 1 إلى 53.
لاحظ أن التواريخ القريبة من بداية السنة أو نهايتها قد تُرجع رقم أسبوع من السنة السابقة أو التالية. على سبيل المثال،
يعيد 29 ديسمبر 2025 الأسبوع 1 لأنه يقع ضمن أول أسبوع يشمل 4 يناير 2026.
الصيغة
toISOWeek(datetime[, timezone])
UInt8
أمثلة
الحصول على أرقام أسابيع ISO
SELECT toDate('2016-12-27') AS date, toISOWeek(date) AS isoWeek
┌───────date─┬─isoWeek─┐
│ 2016-12-27 │ 52 │
└────────────┴─────────┘
SELECT toDate('2025-12-29') AS date, toISOWeek(date) AS isoWeek, toYear(date) AS year
┌───────date─┬─isoWeek─┬─year─┐
│ 2025-12-29 │ 1 │ 2025 │
└────────────┴─────────┴──────┘
UInt16
أمثلة
استخراج سنة ISO من قيم التاريخ
SELECT
toISOYear(toDate('2024/10/02')) as year1,
toISOYear(toDateTime('2024-10-02 01:30:00')) as year2
┌─week1─┬─week2─┐
│ 40 │ 40 │
└───────┴───────┘
LAST_DAY
الوسائط
القيمة المعادة
يعيد تاريخ آخر يوم من الشهر للتاريخ أو التاريخ مع الوقت المحدد. Date
أمثلة
التقريب للأعلى إلى آخر يوم من الشهر
SELECT toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toLastDayOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-30 │
└─────────────────────────────────────────────────────┘
toLastDayOfWeek(datetime[, mode[, timezone]])
datetime — تاريخ أو تاريخ ووقت لتحويله. Date أو DateTime أو Date32 أو DateTime64mode — يحدد أول يوم في الأسبوع كما هو موضح في الدالة toWeek(). القيمة الافتراضية 0. UInt8timezone — اختياري. المنطقة الزمنية المستخدمة في التحويل. إذا لم يتم تحديدها، تُستخدم المنطقة الزمنية الخاصة بالخادم. String
القيمة المعادة
تعيد تاريخ أقرب يوم سبت أو أحد، في يوم التاريخ المحدد نفسه أو بعده، وذلك حسب الوضع. Date أو Date32
أمثلة
التقريب للأعلى إلى أقرب يوم سبت أو أحد
SELECT
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
toLastDayOfWeek(toDate('2023-04-23')), /* a Sunday */
toLastDayOfWeek(toDate('2023-04-23'), 1) /* a Sunday */
FORMAT Vertical
Row 1:
──────
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-23
toLastDayOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-22
toLastDayOfWeek(toDate('2023-04-23')): 2023-04-23
toLastDayOfWeek(toDate('2023-04-23'), 1): 2023-04-23
DateTime64.
الصياغة
الأسماء المستعارة: MICROSECOND
الوسيطات
datetime — تاريخ ووقت لاستخراج الميكروثانية منه. DateTime64
القيمة المُعادة
تعيد قيمة الميكروثانية ضمن الثانية (0 - 999999) في datetime. UInt32
أمثلة
مثال على الاستخدام
SELECT toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6));
┌─toMicrosecond(toDateTime64('2023-04-21 10:20:30.456789', 6))─┐
│ 456789 │
└──────────────────────────────────────────────────────────────┘
DateTime أو DateTime64.
البنية
الأسماء البديلة: MILLISECOND
الوسيطات
القيمة المُعادة
تعيد قيمة الملّي ثانية ضمن الدقيقة (0 - 59) من datetime. UInt16
أمثلة
مثال على الاستخدام
SELECT toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3));
┌──toMillisecond(toDateTime64('2023-04-21 10:20:30.456', 3))─┐
│ 456 │
└────────────────────────────────────────────────────────────┘
Date أو DateTime.
البنية
الأسماء البديلة: MINUTE
الوسائط
القيمة المُعادة
يُرجع دقيقة الساعة (0 - 59) من datetime. UInt8
أمثلة
مثال على الاستخدام
SELECT toMinute(toDateTime('2023-04-21 10:20:30'))
┌─toMinute(toDateTime('2023-04-21 10:20:30'))─┐
│ 20 │
└─────────────────────────────────────────────┘
YYYY-MM-DD وفق التقويم الغريغوري الاستباقي إلى رقم اليوم اليولياني المعدّل من النوع Int32. تدعم هذه الدالة التواريخ من 0000-01-01 إلى 9999-12-31. وتُثير استثناءً إذا تعذّر تحليل الوسيطة كتاريخ، أو كان التاريخ غير صالح.
الصياغة
toModifiedJulianDay(date)
Int32
أمثلة
تحويل التاريخ إلى رقم اليوم اليولياني المعدّل
SELECT toModifiedJulianDay('2020-01-01')
┌─toModifiedJulianDay('2020-01-01')─┐
│ 58849 │
└───────────────────────────────────┘
toModifiedJulianDayOrNull
toModifiedJulianDay()، ولكن بدلًا من إطلاق استثناءات، تُرجع NULL.
البنية
toModifiedJulianDayOrNull(date)
date صالحة، وإلا تُعيد null. Nullable(Int32)
أمثلة
تحويل التاريخ إلى رقم اليوم اليولياني المعدّل مع معالجة null
SELECT toModifiedJulianDayOrNull('2020-01-01');
SELECT toModifiedJulianDayOrNull('0000-00-00'); -- invalid date, returns NULL
┌─toModifiedJu⋯020-01-01')─┐
│ 58849 │
└──────────────────────────┘
┌─toModifiedJu⋯000-00-00')─┐
│ ᴺᵁᴸᴸ │
└──────────────────────────┘
Date
أمثلة
التقريب إلى يوم الاثنين من الأسبوع
SELECT
toMonday(toDateTime('2023-04-21 10:20:30')), -- A Friday
toMonday(toDate('2023-04-24')); -- Already a Monday
┌─toMonday(toDateTime('2023-04-21 10:20:30'))─┬─toMonday(toDate('2023-04-24'))─┐
│ 2023-04-17 │ 2023-04-24 │
└─────────────────────────────────────────────┴────────────────────────────────┘
Date أو DateTime.
الصيغة
الأسماء البديلة: MONTH
الوسائط
القيمة المعادة
تعيد رقم شهر التاريخ/الوقت المحدد من النوع UInt8
أمثلة
مثال على الاستخدام
SELECT toMonth(toDateTime('2023-04-21 10:20:30'))
┌─toMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 4 │
└────────────────────────────────────────────┘
toMonthNumSinceEpoch(date)
SELECT toMonthNumSinceEpoch(toDate('2024-10-01'))
DateTime64.
الصياغة
الأسماء البديلة: NANOSECOND
الوسيطات
datetime — قيمة تاريخ ووقت يُستخرج منها جزء النانوثانية. DateTime64
القيمة المعادة
تُرجع النانوثانية ضمن الثانية (0 - 999999999) من datetime. UInt32
أمثلة
مثال على الاستخدام
SELECT toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9));
┌─toNanosecond(toDateTime64('2023-04-21 10:20:30.123456789', 9))─┐
│ 123456789 │
└────────────────────────────────────────────────────────────────┘
Date أو DateTime معيّنة.
الصياغة
الأسماء البديلة: QUARTER
الوسيطات
القيمة المعادة
تعيد ربع السنة للتاريخ/الوقت المحدد UInt8
أمثلة
مثال على الاستخدام
SELECT toQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2 │
└──────────────────────────────────────────────┘
toRelativeDayNum(dt1) - toRelativeDayNum(dt2).
البنية
الوسائط
القيمة المعادة
يعيد عدد الأيام بدءًا من نقطة مرجعية ثابتة في الماضي. UInt32
أمثلة
الحصول على أرقام الأيام النسبية
SELECT toRelativeDayNum(toDate('2023-04-01')) - toRelativeDayNum(toDate('2023-01-01'))
┌─minus(toRela⋯3-01-01')))─┐
│ 90 │
└──────────────────────────┘
toRelativeHourNum(dt1) - toRelativeHourNum(dt2).
البنية
الوسائط
القيمة المُعادة
يُرجع عدد الساعات منذ نقطة مرجعية ثابتة في الماضي. UInt32
أمثلة
استخراج أرقام الساعات النسبية
SELECT toRelativeHourNum(toDateTime('2023-01-01 12:00:00')) - toRelativeHourNum(toDateTime('2023-01-01 00:00:00')) AS hours_difference
┌─hours_difference─┐
│ 12 │
└──────────────────┘
toRelativeMinuteNum(dt1) - toRelativeMinuteNum(dt2).
الصيغة
toRelativeMinuteNum(date)
UInt32
أمثلة
الحصول على أرقام الدقائق النسبية
SELECT toRelativeMinuteNum(toDateTime('2023-01-01 00:30:00')) - toRelativeMinuteNum(toDateTime('2023-01-01 00:00:00')) AS minutes_difference
┌─minutes_difference─┐
│ 30 │
└────────────────────┘
toRelativeMonthNum(dt1) - toRelativeMonthNum(dt2).
الصياغة
الوسائط
القيمة المعادة
يُرجع عدد الأشهر منذ نقطة مرجعية ثابتة في الماضي. UInt32
أمثلة
الحصول على أرقام الأشهر النسبية
SELECT toRelativeMonthNum(toDate('2023-04-01')) - toRelativeMonthNum(toDate('2023-01-01')) AS months_difference
┌─months_difference─┐
│ 3 │
└───────────────────┘
toRelativeQuarterNum(dt1) - toRelativeQuarterNum(dt2).
الصيغة
toRelativeQuarterNum(date)
UInt32
أمثلة
الحصول على أرقام أرباع السنة النسبية
SELECT toRelativeQuarterNum(toDate('2023-04-01')) - toRelativeQuarterNum(toDate('2023-01-01')) AS quarters_difference
┌─quarters_difference─┐
│ 1 │
└─────────────────────┘
toRelativeSecondNum(dt1) - toRelativeSecondNum(dt2).
الصياغة
toRelativeSecondNum(date)
UInt32
أمثلة
الحصول على أرقام الثواني النسبية
SELECT toRelativeSecondNum(toDateTime('2023-01-01 00:01:00')) - toRelativeSecondNum(toDateTime('2023-01-01 00:00:00')) AS seconds_difference
┌─seconds_difference─┐
│ 60 │
└────────────────────┘
toRelativeWeekNum(dt1) - toRelativeWeekNum(dt2).
البنية
الوسيطات
القيمة المعادة
تعيد عدد الأسابيع بدءًا من نقطة مرجعية ثابتة في الماضي. UInt32
أمثلة
الحصول على أرقام الأسابيع النسبية
SELECT toRelativeWeekNum(toDate('2023-01-08')) - toRelativeWeekNum(toDate('2023-01-01')) AS weeks_difference
┌─weeks_difference─┐
│ 1 │
└──────────────────┘
toRelativeYearNum(dt1) - toRelativeYearNum(dt2).
البنية
الوسائط
القيمة المُعادة
يعيد عدد السنوات بدءًا من نقطة مرجعية ثابتة في الماضي. UInt16
أمثلة
الحصول على أرقام السنوات النسبية
SELECT toRelativeYearNum('2010-10-01'::DateTime) - toRelativeYearNum('2000-01-01'::DateTime)
┌─minus(toRela⋯ateTime')))─┐
│ 10 │
└──────────────────────────┘
DateTime أو DateTime64.
البنية
الأسماء البديلة: SECOND
الوسائط
القيمة المُعادة
تُرجع الثانية ضمن الدقيقة (0 - 59) من datetime. UInt8
أمثلة
مثال على الاستخدام
SELECT toSecond(toDateTime('2023-04-21 10:20:30'))
┌─toSecond(toDateTime('2023-04-21 10:20:30'))─┐
│ 30 │
└─────────────────────────────────────────────┘
DateTime أو DateTime64
أمثلة
التقريب نزولًا إلى بداية اليوم
SELECT toStartOfDay(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfDay(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-21 00:00:00 │
└─────────────────────────────────────────────────┘
toStartOfFifteenMinutes(datetime)
DateTime أو DateTime64
أمثلة
مثال
SELECT
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
Row 1:
──────
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:15:00
toStartOfFifteenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(datetime)
toStartOfFiveMinute
الوسيطات
القيمة المُعادة
تعيد التاريخ والوقت بعد تقريبهما إلى بداية أقرب فاصل زمني مدته خمس دقائق. DateTime أو DateTime64
أمثلة
مثال
SELECT
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
Row 1:
──────
toStartOfFiveMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:15:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfFiveMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
DateTime أو DateTime64
أمثلة
التقريب نزولًا إلى بداية الساعة
SELECT
toStartOfHour(toDateTime('2023-04-21 10:20:30'));
┌─────────────────res─┬─toTypeName(res)─┐
│ 2023-04-21 10:00:00 │ DateTime │
└─────────────────────┴─────────────────┘
Date
أمثلة
التقريب نزولًا إلى اليوم الأول من سنة ISO
SELECT toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfISOYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-02 │
└─────────────────────────────────────────────────────┘
toStartOf*() الأخرى باستخدام البنية toStartOfInterval(date_or_date_with_time, INTERVAL x unit [, time_zone]).
على سبيل المثال،
- تُرجع
toStartOfInterval(t, INTERVAL 1 YEAR) النتيجة نفسها التي تُرجعها toStartOfYear(t),
- تُرجع
toStartOfInterval(t, INTERVAL 1 MONTH) النتيجة نفسها التي تُرجعها toStartOfMonth(t),
- تُرجع
toStartOfInterval(t, INTERVAL 1 DAY) النتيجة نفسها التي تُرجعها toStartOfDay(t),
- تُرجع
toStartOfInterval(t, INTERVAL 15 MINUTE) النتيجة نفسها التي تُرجعها toStartOfFifteenMinutes(t).
يُجرى الحساب بالاستناد إلى نقاط زمنية محددة:
| Interval | Start |
|---|
| YEAR | السنة 0 |
| QUARTER | 1900 Q1 |
| MONTH | يناير 1900 |
| WEEK | 1970، الأسبوع الأول (01-05) |
| DAY | 1970-01-01 |
| HOUR | (*) |
| MINUTE | 1970-01-01 00:00:00 |
| SECOND | 1970-01-01 00:00:00 |
| MILLISECOND | 1970-01-01 00:00:00 |
| MICROSECOND | 1970-01-01 00:00:00 |
| NANOSECOND | 1970-01-01 00:00:00 |
| (*) فترات الساعات حالة خاصة: يُجرى الحساب دائمًا بالاستناد إلى 00:00:00 (منتصف الليل) من اليوم الحالي. ونتيجةً لذلك، فإن | |
| قيم الساعات من 1 إلى 23 فقط هي المفيدة. | |
WEEK، فإن toStartOfInterval يفترض أن الأسابيع تبدأ يوم الاثنين. لاحظ أن هذا السلوك يختلف عن سلوك الدالة toStartOfWeek، حيث تبدأ الأسابيع افتراضيًا يوم الأحد.
تحاكي صيغة التحميل الزائد الثانية الدالة time_bucket() في TimescaleDB، وكذلك الدالة date_bin() في PostgreSQL.
البنية
toStartOfInterval(value, INTERVAL x unit[, time_zone])
toStartOfInterval(value, INTERVAL x unit[, origin[, time_zone]])
time_bucket, date_bin
المعاملات
value — قيمة تاريخ أو تاريخ مع وقت تُقرَّب نزولًا. Date أو DateTime أو DateTime64x — رقم يمثّل طول الفاصل الزمني. - unit — وحدة الفاصل الزمني: YEAR, QUARTER, MONTH, WEEK, DAY, HOUR, MINUTE, SECOND, MILLISECOND, MICROSECOND, NANOSECOND. - time_zone — اختياري. اسم المنطقة الزمنية كسلسلة نصية. - origin — اختياري. نقطة بدء الحساب (في التوقيع الثاني فقط).
القيمة المُعادة
تعيد بداية الفاصل الزمني الذي تقع ضمنه قيمة الإدخال. DateTime
أمثلة
تقريب الفاصل الزمني الأساسي
SELECT toStartOfInterval(toDateTime('2023-01-15 14:30:00'), INTERVAL 1 MONTH)
┌─toStartOfInt⋯alMonth(1))─┐
│ 2023-01-01 │
└──────────────────────────┘
SELECT toStartOfInterval(toDateTime('2023-01-01 14:45:00'), INTERVAL 1 MINUTE, toDateTime('2023-01-01 14:35:30'))
┌─toStartOfInt⋯14:35:30'))─┐
│ 2023-01-01 14:44:30 │
└──────────────────────────┘
toStartOfMicrosecond(datetime[, timezone])
datetime — التاريخ والوقت. DateTime64timezone — اختياري. المنطقة الزمنية للقيمة المُعادة. إذا لم يتم تحديدها، تستخدم الدالة المنطقة الزمنية للمعامل value. String
القيمة المُعادة
قيمة الإدخال بعد إزالة الأجزاء الأقل من الميكروثانية DateTime64
أمثلة
استعلام من دون منطقة زمنية
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64);
┌────toStartOfMicrosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMicrosecond(dt64, 'Asia/Istanbul');
┌─toStartOfMicrosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999000 │
└─────────────────────────────────────────────┘
toStartOfMillisecond(datetime[, timezone])
datetime — التاريخ والوقت. DateTime64timezone — اختياري. المنطقة الزمنية للقيمة المُعادة. إذا لم يتم تحديدها، تستخدم الدالة المنطقة الزمنية للمعلَمة value. String
القيمة المُعادة
قيمة الإدخال مع أجزاء أصغر من المللي ثانية. DateTime64
أمثلة
استعلام بدون منطقة زمنية
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64);
┌────toStartOfMillisecond(dt64)─┐
│ 2020-01-01 10:20:30.999000000 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfMillisecond(dt64, 'Asia/Istanbul');
┌─toStartOfMillisecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999000000 │
└─────────────────────────────────────────────┘
toStartOfMinute(datetime)
DateTime أو DateTime64
أمثلة
التقريب نزولًا إلى بداية الدقيقة
SELECT
toStartOfMinute(toDateTime('2023-04-21 10:20:30')),
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8))
FORMAT Vertical
Row 1:
──────
toStartOfMinute(toDateTime('2023-04-21 10:20:30')): 2023-04-21 10:20:00
toStartOfMinute(toDateTime64('2023-04-21 10:20:30.5300', 8)): 2023-04-21 10:20:00
Date
أمثلة
التقريب نزولًا إلى اليوم الأول من الشهر
SELECT toStartOfMonth(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfMonth(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└───────────────────────────────────────────────────┘
toStartOfNanosecond(datetime[, timezone])
datetime — التاريخ والوقت. DateTime64timezone — اختياري. المنطقة الزمنية للقيمة المعادة. إذا لم يتم تحديدها، تستخدم الدالة المنطقة الزمنية للمعامل value. String
القيمة المعادة
قيمة الإدخال بدقة النانوثانية. DateTime64
أمثلة
استعلام بدون منطقة زمنية
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64);
┌─────toStartOfNanosecond(dt64)─┐
│ 2020-01-01 10:20:30.999999999 │
└───────────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999999999', 9) AS dt64
SELECT toStartOfNanosecond(dt64, 'Asia/Istanbul');
┌─toStartOfNanosecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 12:20:30.999999999 │
└────────────────────────────────────────────┘
Date
أمثلة
التقريب نزولًا إلى اليوم الأول من الربع
SELECT toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfQuarter(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-04-01 │
└─────────────────────────────────────────────────────┘
toStartOfSecond(datetime[, timezone])
datetime — التاريخ والوقت المراد حذف الأجزاء من الثانية منه. DateTime64timezone — اختياري. المنطقة الزمنية للقيمة المُعادة. إذا لم يتم تحديدها، تستخدم الدالة المنطقة الزمنية الخاصة بالمعامل value. String
القيمة المُعادة
تعيد قيمة الإدخال من دون الأجزاء من الثانية. DateTime64
أمثلة
استعلام بدون منطقة زمنية
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64);
┌───toStartOfSecond(dt64)─┐
│ 2020-01-01 10:20:30.000 │
└─────────────────────────┘
WITH toDateTime64('2020-01-01 10:20:30.999', 3) AS dt64
SELECT toStartOfSecond(dt64, 'Asia/Istanbul');
┌─toStartOfSecond(dt64, 'Asia/Istanbul')─┐
│ 2020-01-01 13:20:30.000 │
└────────────────────────────────────────┘
toStartOfTenMinutes(datetime)
DateTime أو DateTime64
أمثلة
مثال
SELECT
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')),
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00'))
FORMAT Vertical
Row 1:
──────
toStartOfTenMinutes(toDateTime('2023-04-21 10:17:00')): 2023-04-21 10:10:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:20:00')): 2023-04-21 10:20:00
toStartOfTenMinutes(toDateTime('2023-04-21 10:23:00')): 2023-04-21 10:20:00
toStartOfWeek(datetime[, mode[, timezone]])
datetime — تاريخ أو تاريخ ووقت للتحويل. Date أو DateTime أو Date32 أو DateTime64mode — يحدد أول يوم في الأسبوع كما هو موضح في الدالة toWeek(). القيمة الافتراضية 0. UInt8timezone — المنطقة الزمنية المستخدمة في التحويل. إذا لم يتم تحديدها، فستُستخدم المنطقة الزمنية الخاصة بـ الخادم. String
القيمة المعادة
يعيد تاريخ أقرب يوم أحد أو اثنين يوافق التاريخ المحدد أو يسبقه، وذلك حسب الوضع. Date أو Date32
أمثلة
التقريب لأسفل إلى أقرب يوم أحد أو اثنين
SELECT
toStartOfWeek(toDateTime('2023-04-21 10:20:30')), /* a Friday */
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1), /* a Friday */
toStartOfWeek(toDate('2023-04-24')), /* a Monday */
toStartOfWeek(toDate('2023-04-24'), 1) /* a Monday */
FORMAT Vertical
Row 1:
──────
toStartOfWeek(toDateTime('2023-04-21 10:20:30')): 2023-04-17
toStartOfWeek(toDateTime('2023-04-21 10:20:30'), 1): 2023-04-17
toStartOfWeek(toDate('2023-04-24')): 2023-04-24
toStartOfWeek(toDate('2023-04-24'), 1): 2023-04-24
Date.
البنية
المعاملات
القيمة المعادة
اليوم الأول من السنة للتاريخ/الوقت المحدد Date
أمثلة
التقريب لأسفل إلى أول يوم من السنة
SELECT toStartOfYear(toDateTime('2023-04-21 10:20:30'))
┌─toStartOfYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023-01-01 │
└──────────────────────────────────────────────────┘
1970-01-02،
لكن النقطة الزمنية الدقيقة هي تفصيل تنفيذي قد يتغير مستقبلًا.
لذلك، لا ينبغي استخدام toTime بشكل مستقل.
الغرض الرئيسي من هذه الدالة هو حساب فرق الوقت بين تاريخين أو قيمتين من نوع تاريخ ووقت، مثل: toTime(dt1) - toTime(dt2).
البنية
toTimeWithFixedDate(date[, timezone])
DateTime
أمثلة
احسب الفرق الزمني بين تاريخين
SELECT toTimeWithFixedDate('2025-06-15 12:00:00'::DateTime) - toTimeWithFixedDate('2024-05-10 11:00:00'::DateTime) AS result, toTypeName(result)
┌─result─┬─toTypeName(result)─┐
│ 3600 │ Int32 │
└────────┴────────────────────┘
DateTime أو DateTime64 إلى المنطقة الزمنية المحددة.
لا تتغير القيمة الداخلية للبيانات (عدد ثواني Unix).
يتغير فقط سِمة المنطقة الزمنية للقيمة وتمثيلها النصي.
البنية
toTimezone(datetime, timezone)
toTimeZone
المعاملات
القيمة المُعادة
تُرجع نفس الطابع الزمني المُدخل، ولكن مع المنطقة الزمنية المحددة DateTime أو DateTime64
أمثلة
مثال على الاستخدام
SELECT toDateTime('2019-01-01 00:00:00', 'UTC') AS time_utc,
toTypeName(time_utc) AS type_utc,
toInt32(time_utc) AS int32utc,
toTimezone(time_utc, 'Asia/Yekaterinburg') AS time_yekat,
toTypeName(time_yekat) AS type_yekat,
toInt32(time_yekat) AS int32yekat,
toTimezone(time_utc, 'US/Samoa') AS time_samoa,
toTypeName(time_samoa) AS type_samoa,
toInt32(time_samoa) AS int32samoa
FORMAT Vertical;
Row 1:
──────
time_utc: 2019-01-01 00:00:00
type_utc: DateTime('UTC')
int32utc: 1546300800
time_yekat: 2019-01-01 05:00:00
type_yekat: DateTime('Asia/Yekaterinburg')
int32yekat: 1546300800
time_samoa: 2018-12-31 13:00:00
type_samoa: DateTime('US/Samoa')
int32samoa: 1546300800
toUTCTimestamp(datetime, time_zone)
to_utc_timestamp
المعاملات
datetime — قيمة ثابتة من نوع تاريخ أو تاريخ ووقت، أو تعبير. DateTime أو DateTime64time_zone — قيمة ثابتة من نوع String أو تعبير يمثّل المنطقة الزمنية. String
القيمة المُعادة
تعيد قيمة تاريخ أو تاريخ ووقت في المنطقة الزمنية UTC. DateTime أو DateTime64
أمثلة
تحويل المنطقة الزمنية إلى UTC
SELECT toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')
┌─toUTCTimestamp(toDateTime('2023-03-16'), 'Asia/Shanghai')─┐
│ 2023-03-15 16:00:00 │
└─────────────────────────────────────────────────────────┘
String أو Date أو DateTime إلى طابع زمني Unix (عدد الثواني منذ 1970-01-01 00:00:00 UTC) بصيغة UInt32.
الصياغة
toUnixTimestamp(date[, timezone])
UInt32
أمثلة
مثال على الاستخدام
SELECT
'2017-11-05 08:07:47' AS dt_str,
toUnixTimestamp(dt_str) AS from_str,
toUnixTimestamp(dt_str, 'Asia/Tokyo') AS from_str_tokyo,
toUnixTimestamp(toDateTime(dt_str)) AS from_datetime,
toUnixTimestamp(toDateTime64(dt_str, 0)) AS from_datetime64,
toUnixTimestamp(toDate(dt_str)) AS from_date,
toUnixTimestamp(toDate32(dt_str)) AS from_date32
FORMAT Vertical;
Row 1:
──────
dt_str: 2017-11-05 08:07:47
from_str: 1509869267
from_str_tokyo: 1509836867
from_datetime: 1509869267
from_datetime64: 1509869267
from_date: 1509840000
from_date32: 1509840000
toWeek() تحديد ما إذا كان الأسبوع يبدأ
يوم الأحد أو يوم الاثنين، وما إذا كانت القيمة المُعادة يجب أن تكون ضمن النطاق من 0 إلى 53 أو من 1 إلى 53.
تُعد toISOWeek() دالة توافقية مكافئة لـ toWeek(date,3).
يوضح الجدول التالي كيفية عمل وسيطة mode.
| Mode | اليوم الأول من الأسبوع | النطاق | الأسبوع 1 هو أول أسبوع … |
|---|
| 0 | الأحد | 0-53 | يحتوي على يوم أحد في هذه السنة |
| 1 | الاثنين | 0-53 | يحتوي على 4 أيام أو أكثر في هذه السنة |
| 2 | الأحد | 1-53 | يحتوي على يوم أحد في هذه السنة |
| 3 | الاثنين | 1-53 | يحتوي على 4 أيام أو أكثر في هذه السنة |
| 4 | الأحد | 0-53 | يحتوي على 4 أيام أو أكثر في هذه السنة |
| 5 | الاثنين | 0-53 | يحتوي على يوم اثنين في هذه السنة |
| 6 | الأحد | 1-53 | يحتوي على 4 أيام أو أكثر في هذه السنة |
| 7 | الاثنين | 1-53 | يحتوي على يوم اثنين في هذه السنة |
| 8 | الأحد | 1-53 | يتضمن 1 يناير |
| 9 | الاثنين | 1-53 | يتضمن 1 يناير |
- إذا كان الأسبوع الذي يتضمن 1 يناير يحتوي على 4 أيام أو أكثر في السنة الجديدة، فهو الأسبوع 1.
- وإلا، فهو الأسبوع الأخير من السنة السابقة، ويكون الأسبوع التالي هو الأسبوع 1.
بالنسبة إلى قيم mode التي يكون معناها “يتضمن 1 يناير”، فإن الأسبوع الذي يتضمن 1 يناير هو الأسبوع 1.
ولا يهم عدد الأيام من السنة الجديدة التي يتضمنها ذلك الأسبوع، حتى لو كان يتضمن يومًا واحدًا فقط.
أي إذا كان الأسبوع الأخير من ديسمبر يتضمن 1 يناير من السنة التالية، فسيكون هو الأسبوع 1 من السنة التالية.
يمكن أيضًا تحديد الوسيطة الأولى على أنها String بتنسيق تدعمه parseDateTime64BestEffort(). يوجد دعم لوسائط السلاسل النصية فقط لأسباب تتعلق بالتوافق مع MySQL، كما تتطلبه بعض أدوات الجهات الخارجية. ونظرًا إلى أن دعم وسائط السلاسل النصية قد يصبح في المستقبل معتمدًا على إعدادات جديدة للتوافق مع MySQL، ولأن تحليل السلاسل النصية بطيء عمومًا، يُوصى بعدم استخدامه.
الصياغة
toWeek(datetime[, mode[, time_zone]])
week
الوسيطات
datetime — Date أو تاريخ مع وقت لاستخراج رقم الأسبوع منه. Date أو DateTimemode — اختياري. يحدد النمط من 0 إلى 9 اليوم الأول من الأسبوع ونطاق رقم الأسبوع. القيمة الافتراضية هي 0. - time_zone — اختياري. المنطقة الزمنية. String
القيمة المُعادة
يعيد رقم الأسبوع وفقًا للنمط المحدد. UInt32
أمثلة
الحصول على أرقام الأسابيع باستخدام أنماط مختلفة
SELECT toDate('2016-12-27') AS date, toWeek(date) AS week0, toWeek(date,1) AS week1, toWeek(date,9) AS week9
┌───────date─┬─week0─┬─week1─┬─week9─┐
│ 2016-12-27 │ 52 │ 52 │ 1 │
└────────────┴───────┴───────┴───────┘
UInt32 يحتوي على السنة ورقم الشهر (YYYY * 100 + MM).
وتقبل وسيطة ثانية اختيارية للمنطقة الزمنية. وإذا قُدِّمت، فيجب أن تكون قيمة المنطقة الزمنية ثابتًا نصيًا.
هذه الدالة هي عكس الدالة YYYYMMDDToDate().
الصيغة
toYYYYMM(datetime[, timezone])
datetime — تاريخ أو تاريخ يتضمن وقتًا لتحويله. Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. المنطقة الزمنية للتحويل. إذا جرى توفيرها، فيجب أن تكون المنطقة الزمنية ثابتًا نصيًا. String
القيمة المُعادة
يعيد رقمًا من النوع UInt32 يحتوي على رقمَي السنة والشهر (YYYY * 100 + MM). UInt32
أمثلة
تحويل التاريخ الحالي إلى تنسيق YYYYMM
SELECT toYYYYMM(now(), 'US/Eastern')
┌─toYYYYMM(now(), 'US/Eastern')─┐
│ 202303 │
└───────────────────────────────┘
UInt32 يحتوي على السنة والشهر واليوم (YYYY * 10000 + MM * 100 + DD). ويقبل وسيطة ثانية اختيارية هي timezone. وإذا تم توفيرها، فيجب أن تكون timezone قيمة string constant.
البنية
toYYYYMMDD(datetime[, timezone])
datetime — تاريخ أو تاريخ ووقت للتحويل. Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. المنطقة الزمنية المستخدمة في التحويل. إذا تم تحديدها، فيجب أن تكون المنطقة الزمنية ثابتًا نصيًا. String
القيمة المعادة
يعيد قيمة من النوع UInt32 تحتوي على السنة والشهر واليوم (YYYY * 10000 + MM * 100 + DD). UInt32
أمثلة
حوّل التاريخ الحالي إلى تنسيق YYYYMMDD
SELECT toYYYYMMDD(now(), 'US/Eastern')
┌─toYYYYMMDD(now(), 'US/Eastern')─┐
│ 20230302 │
└─────────────────────────────────┘
UInt64 يحتوي على السنة ورقم الشهر (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss).
تقبل وسيطًا اختياريًا ثانيًا للمنطقة الزمنية. وإذا تم توفيره، فيجب أن تكون المنطقة الزمنية ثابتًا نصيًا.
البنية
toYYYYMMDDhhmmss(datetime[, timezone])
datetime — Date أو تاريخ أو تاريخ مع وقت للتحويل. Date أو Date32 أو DateTime أو DateTime64timezone — اختياري. المنطقة الزمنية للتحويل. إذا تم توفيرها، فيجب أن تكون المنطقة الزمنية ثابتًا نصيًا. String
القيمة المُعادة
يعيد عددًا من النوع UInt64 يحتوي على السنة والشهر واليوم والساعة والدقيقة والثانية (YYYY * 10000000000 + MM * 100000000 + DD * 1000000 + hh * 10000 + mm * 100 + ss). UInt64
أمثلة
حوّل التاريخ والوقت الحاليين إلى تنسيق YYYYMMDDhhmmss
SELECT toYYYYMMDDhhmmss(now(), 'US/Eastern')
┌─toYYYYMMDDhhmmss(now(), 'US/Eastern')─┐
│ 20230302112209 │
└───────────────────────────────────────┘
Date أو DateTime.
البنية
الأسماء البديلة: YEAR
الوسيطات
القيمة المُعادة
تعيد سنة قيمة Date أو DateTime المُعطاة UInt16
أمثلة
مثال على الاستخدام
SELECT toYear(toDateTime('2023-04-21 10:20:30'))
┌─toYear(toDateTime('2023-04-21 10:20:30'))─┐
│ 2023 │
└───────────────────────────────────────────┘
toYearNumSinceEpoch(date)
SELECT toYearNumSinceEpoch(toDate('2024-10-01'))
toWeek().
تحذير: قد يختلف رقم الأسبوع الذي تُعيده toYearWeek() عن الرقم الذي تُعيده toWeek(). إذ تُعيد toWeek() دائمًا رقم الأسبوع ضمن سياق السنة المحددة، وإذا أعادت toWeek() القيمة 0، فإن toYearWeek() تُعيد القيمة المقابلة لآخر أسبوع من السنة السابقة. راجع prev_yearWeek في المثال أدناه.
يمكن أيضًا تحديد الوسيطة الأولى على أنها String بتنسيق تدعمه parseDateTime64BestEffort(). ولا يوجد دعم لوسيطات السلاسل النصية إلا لأسباب تتعلق بالتوافق مع MySQL، كما تتطلبه بعض الأدوات الخارجية. ونظرًا إلى أن دعم وسائط السلاسل النصية قد يصبح في المستقبل معتمدًا على إعدادات جديدة للتوافق مع MySQL، ولأن تحليل السلاسل النصية بطيء عمومًا، يُوصى بعدم استخدامها.
الصياغة
toYearWeek(datetime[, mode[, timezone]])
yearweek
الوسائط
datetime — التاريخ أو التاريخ مع الوقت المراد استخراج السنة ورقم الأسبوع منه. Date أو DateTimemode — اختياري. يحدد النمط من 0 إلى 9 اليوم الأول من الأسبوع ونطاق رقم الأسبوع. القيمة الافتراضية 0. - timezone — اختياري. المنطقة الزمنية. String
القيمة المعادة
تعيد السنة ورقم الأسبوع كقيمة عددية صحيحة مدمجة. UInt32
أمثلة
الحصول على تركيبات السنة-الأسبوع باستخدام أنماط مختلفة
SELECT toDate('2016-12-27') AS date, toYearWeek(date) AS yearWeek0, toYearWeek(date,1) AS yearWeek1, toYearWeek(date,9) AS yearWeek9, toYearWeek(toDate('2022-01-01')) AS prev_yearWeek
┌───────date─┬─yearWeek0─┬─yearWeek1─┬─yearWeek9─┬─prev_yearWeek─┐
│ 2016-12-27 │ 201652 │ 201652 │ 201701 │ 202152 │
└────────────┴───────────┴───────────┴───────────┴───────────────┘
toDate(now()).
الصياغة
الأسماء البديلة: curdate, current_date
المعاملات
القيمة المُعادة
تعيد التاريخ الحالي Date
أمثلة
مثال على الاستخدام
SELECT today() AS today, curdate() AS curdate, current_date() AS current_date FORMAT Pretty
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ today ┃ curdate ┃ current_date ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-03 │ 2025-03-03 │ 2025-03-03 │
└────────────┴────────────┴──────────────┘
SELECT TODAY, CURDATE,CURRENT_DATE
┏━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━━━━━━━━━━┓
┃ TODAY ┃ CURDATE ┃ CURRENT_DATE ┃
┡━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━━━━━━━━━━┩
│ 2025-03-04 │ 2025-03-04 │ 2025-03-04 │
└────────────┴────────────┴──────────────┘
Date
أمثلة
الحصول على تاريخ الأمس
SELECT yesterday();
SELECT today() - 1;
┌─yesterday()─┐
│ 2025-06-09 │
└─────────────┘
┌─minus(today(), 1)─┐
│ 2025-06-09 │
└───────────────────┘
