mirror of
https://github.com/ClickHouse/ClickHouse.git
synced 2024-11-13 19:14:30 +00:00
502 lines
16 KiB
C++
502 lines
16 KiB
C++
#pragma once
|
||
|
||
#include <common/Common.h>
|
||
#include <common/singleton.h>
|
||
#include <common/likely.h>
|
||
#include <common/strong_typedef.h>
|
||
|
||
#include <iostream>
|
||
#include <vector>
|
||
#include <unordered_map>
|
||
#include <ctime>
|
||
|
||
#define DATE_LUT_MIN 0
|
||
#define DATE_LUT_MAX (0x7FFFFFFF - 86400)
|
||
#define DATE_LUT_MAX_DAY_NUM (0x7FFFFFFF / 86400)
|
||
#define DATE_LUT_MIN_YEAR 1970
|
||
#define DATE_LUT_MAX_YEAR 2037 /// Последний полный год
|
||
#define DATE_LUT_YEARS 68 /// Количество лет в lookup таблице
|
||
|
||
|
||
STRONG_TYPEDEF(UInt16, DayNum_t);
|
||
|
||
|
||
/** Lookup таблица для преобразования времени в дату, а также в месяц или в год или в день недели или в день месяца.
|
||
* Сейчас она используется для ускорения OLAPServer-а, который делает такие преобразования миллиардами.
|
||
*/
|
||
class DateLUTImpl
|
||
{
|
||
public:
|
||
DateLUTImpl(const std::string & time_zone);
|
||
|
||
public:
|
||
struct Values
|
||
{
|
||
/// 32 бита из time_t начала дня.
|
||
/// Знаковость важна, чтобы поддержать начало 1970-01-01 MSK, которое имело time_t == -10800.
|
||
/// Измените на time_t, если надо поддержать времена после 2038 года.
|
||
Int32 date;
|
||
|
||
UInt16 year;
|
||
UInt8 month;
|
||
UInt8 day_of_month;
|
||
UInt8 day_of_week;
|
||
};
|
||
|
||
private:
|
||
/// Сравнительно много данных. То есть, лучше не класть объект на стек.
|
||
/// По сравнению с std::vector, на один indirection меньше.
|
||
Values lut[DATE_LUT_MAX_DAY_NUM + 1];
|
||
|
||
/// lookup таблица начал годов
|
||
DayNum_t years_lut[DATE_LUT_YEARS];
|
||
|
||
/// Смещение от UTC в начале Unix эпохи.
|
||
time_t offset_at_start_of_epoch;
|
||
|
||
|
||
inline size_t findIndex(time_t t) const
|
||
{
|
||
/// первое приближение
|
||
size_t precision = t / 86400;
|
||
if (precision >= DATE_LUT_MAX_DAY_NUM)
|
||
return 0;
|
||
if (t >= lut[precision].date && t < lut[precision + 1].date)
|
||
return precision;
|
||
|
||
for (size_t i = 1;; ++i)
|
||
{
|
||
if (precision + i >= DATE_LUT_MAX_DAY_NUM)
|
||
return 0;
|
||
if (t >= lut[precision + i].date && t < lut[precision + i + 1].date)
|
||
return precision + i;
|
||
if (precision < i)
|
||
return 0;
|
||
if (t >= lut[precision - i].date && t < lut[precision - i + 1].date)
|
||
return precision - i;
|
||
}
|
||
}
|
||
|
||
inline const Values & find(time_t t) const
|
||
{
|
||
return lut[findIndex(t)];
|
||
}
|
||
|
||
static inline DayNum_t fixDay(DayNum_t day)
|
||
{
|
||
return day > DATE_LUT_MAX_DAY_NUM ? static_cast<DayNum_t>(0) : day;
|
||
}
|
||
|
||
public:
|
||
/// всё ниже thread-safe; корректность входных данных не проверяется
|
||
|
||
inline time_t toDate(time_t t) const { return find(t).date; }
|
||
inline unsigned toMonth(time_t t) const { return find(t).month; }
|
||
inline unsigned toYear(time_t t) const { return find(t).year; }
|
||
inline unsigned toDayOfWeek(time_t t) const { return find(t).day_of_week; }
|
||
inline unsigned toDayOfMonth(time_t t) const { return find(t).day_of_month; }
|
||
|
||
/// номер недели, начиная с какой-то недели в прошлом; неделя начинается с понедельника
|
||
/// (переводим к понедельнику и делим DayNum на 7; будем исходить из допущения,
|
||
/// что в области применения этой функции не было и не будет недель, состоящих не из семи дней)
|
||
inline unsigned toRelativeWeekNum(DayNum_t d) const
|
||
{
|
||
return (d - (lut[d].day_of_week - 1)) / 7;
|
||
}
|
||
|
||
inline unsigned toRelativeWeekNum(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return (index - (lut[index].day_of_week - 1)) / 7;
|
||
}
|
||
|
||
/// номер месяца, начиная с какого-то месяца в прошлом (год * 12 + номер месяца в году)
|
||
inline unsigned toRelativeMonthNum(DayNum_t d) const
|
||
{
|
||
return lut[d].year * 12 + lut[d].month;
|
||
}
|
||
|
||
inline unsigned toRelativeMonthNum(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return lut[index].year * 12 + lut[index].month;
|
||
}
|
||
|
||
/// делим unix timestamp на 3600;
|
||
/// (таким образом, учитываются прошедшие интервалы времени длительностью в час, не зависимо от перевода стрелок;
|
||
/// поддерживаются только часовые пояса, в которых перевод стрелок осуществлялся только на целое число часов)
|
||
inline time_t toRelativeHourNum(time_t t) const
|
||
{
|
||
return t / 3600;
|
||
}
|
||
|
||
/// делим unix timestamp на 60
|
||
inline time_t toRelativeMinuteNum(time_t t) const
|
||
{
|
||
return t / 60;
|
||
}
|
||
|
||
/// округление вниз до понедельника
|
||
inline time_t toFirstDayOfWeek(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return lut[index - (lut[index].day_of_week - 1)].date;
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfWeek(DayNum_t d) const
|
||
{
|
||
return DayNum_t(d - (lut[d].day_of_week - 1));
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfWeek(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return DayNum_t(index - (lut[index].day_of_week - 1));
|
||
}
|
||
|
||
/// округление вниз до первого числа месяца
|
||
inline time_t toFirstDayOfMonth(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return lut[index - (lut[index].day_of_month - 1)].date;
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfMonth(DayNum_t d) const
|
||
{
|
||
return DayNum_t(d - (lut[fixDay(d)].day_of_month - 1));
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfMonth(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
return DayNum_t(index - (lut[index].day_of_month - 1));
|
||
}
|
||
|
||
/// округление до первого числа квартала
|
||
inline time_t toFirstDayOfQuarter(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
switch (lut[index].month % 3)
|
||
{
|
||
case 0:
|
||
index = index - lut[index].day_of_month;
|
||
case 2:
|
||
index = index - lut[index].day_of_month;
|
||
case 1:
|
||
index = index - lut[index].day_of_month + 1;
|
||
}
|
||
return DayNum_t(index);
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfQuarter(DayNum_t d) const
|
||
{
|
||
size_t index = fixDay(d);
|
||
switch (lut[index].month % 3)
|
||
{
|
||
case 0:
|
||
index = index - lut[index].day_of_month;
|
||
case 2:
|
||
index = index - lut[index].day_of_month;
|
||
case 1:
|
||
index = index - lut[index].day_of_month + 1;
|
||
}
|
||
return DayNum_t(index);
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfQuarter(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
switch (lut[index].month % 3)
|
||
{
|
||
case 0:
|
||
index = index - lut[index].day_of_month;
|
||
case 2:
|
||
index = index - lut[index].day_of_month;
|
||
case 1:
|
||
index = index - lut[index].day_of_month + 1;
|
||
}
|
||
return DayNum_t(index);
|
||
}
|
||
|
||
/// округление вниз до первого числа года
|
||
inline time_t toFirstDayOfYear(time_t t) const
|
||
{
|
||
return lut[years_lut[lut[findIndex(t)].year - DATE_LUT_MIN_YEAR]].date;
|
||
}
|
||
|
||
inline DayNum_t toFirstDayNumOfYear(DayNum_t d) const
|
||
{
|
||
return years_lut[lut[fixDay(d)].year - DATE_LUT_MIN_YEAR];
|
||
}
|
||
|
||
inline time_t toFirstDayNumOfYear(time_t t) const
|
||
{
|
||
return lut[years_lut[lut[findIndex(t)].year - DATE_LUT_MIN_YEAR]].date;
|
||
}
|
||
|
||
/// первое число следующего месяца
|
||
inline time_t toFirstDayOfNextMonth(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
index += 32 - lut[index].day_of_month;
|
||
return lut[index - (lut[index].day_of_month - 1)].date;
|
||
}
|
||
|
||
/// первое число предыдущего месяца
|
||
inline time_t toFirstDayOfPrevMonth(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
index -= lut[index].day_of_month;
|
||
return lut[index - (lut[index].day_of_month - 1)].date;
|
||
}
|
||
|
||
/// количество дней в месяце
|
||
inline size_t daysInMonth(time_t t) const
|
||
{
|
||
size_t today = findIndex(t);
|
||
size_t start_of_month = today - (lut[today].day_of_month - 1);
|
||
size_t next_month = start_of_month + 31;
|
||
size_t start_of_next_month = next_month - (lut[next_month].day_of_month - 1);
|
||
return start_of_next_month - start_of_month;
|
||
}
|
||
|
||
/** Округление до даты; затем сдвиг на указанное количество дней.
|
||
* Замечание: результат сдвига должен находиться в пределах LUT.
|
||
*/
|
||
inline time_t toDateAndShift(time_t t, int days = 1) const
|
||
{
|
||
return lut[findIndex(t) + days].date;
|
||
}
|
||
|
||
/** функции ниже исходят из допущения, что перевод стрелок вперёд, если осуществляется, то на час, в два часа ночи,
|
||
* а перевод стрелок назад, если осуществляется, то на час, в три часа ночи.
|
||
* (что, в общем, не верно, так как в Москве один раз перевод стрелок был осуществлён в другое время)
|
||
*/
|
||
|
||
inline time_t toTimeInaccurate(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
time_t day_length = lut[index + 1].date - lut[index].date;
|
||
|
||
time_t res = t - lut[index].date;
|
||
|
||
if (unlikely(day_length == 90000 && res >= 10800)) /// был произведён перевод стрелок назад
|
||
res -= 3600;
|
||
else if (unlikely(day_length == 82800 && res >= 7200)) /// был произведён перевод стрелок вперёд
|
||
res += 3600;
|
||
|
||
return res - offset_at_start_of_epoch; /// Отсчёт от 1970-01-01 00:00:00 по локальному времени
|
||
}
|
||
|
||
inline unsigned toHourInaccurate(time_t t) const
|
||
{
|
||
size_t index = findIndex(t);
|
||
time_t day_length = lut[index + 1].date - lut[index].date;
|
||
unsigned res = (t - lut[index].date) / 3600;
|
||
|
||
if (unlikely(day_length == 90000 && res >= 3)) /// был произведён перевод стрелок назад
|
||
--res;
|
||
else if (unlikely(day_length == 82800 && res >= 2)) /// был произведён перевод стрелок вперёд
|
||
++res;
|
||
|
||
return res;
|
||
}
|
||
|
||
inline unsigned toMinute(time_t t) const { return ((t - find(t).date) % 3600) / 60; }
|
||
inline unsigned toSecond(time_t t) const { return (t - find(t).date) % 60; }
|
||
|
||
inline unsigned toStartOfMinute(time_t t) const
|
||
{
|
||
time_t date = find(t).date;
|
||
return date + (t - date) / 60 * 60;
|
||
}
|
||
|
||
inline unsigned toStartOfHour(time_t t) const
|
||
{
|
||
time_t date = find(t).date;
|
||
return date + (t - date) / 3600 * 3600;
|
||
}
|
||
|
||
/** Только для часовых поясов, отличающихся от UTC на значение, кратное часу и без перевода стрелок не значение не кратное часу */
|
||
|
||
inline unsigned toMinuteInaccurate(time_t t) const { return (t / 60) % 60; }
|
||
inline unsigned toSecondInaccurate(time_t t) const { return t % 60; }
|
||
|
||
inline unsigned toStartOfMinuteInaccurate(time_t t) const { return t / 60 * 60; }
|
||
inline unsigned toStartOfFiveMinuteInaccurate(time_t t) const { return t / 300 * 300; }
|
||
inline unsigned toStartOfHourInaccurate(time_t t) const { return t / 3600 * 3600; }
|
||
|
||
/// Номер дня в пределах UNIX эпохи (и немного больше) - позволяет хранить дату в двух байтах
|
||
|
||
inline DayNum_t toDayNum(time_t t) const { return static_cast<DayNum_t>(findIndex(t)); }
|
||
inline time_t fromDayNum(DayNum_t d) const { return lut[fixDay(d)].date; }
|
||
|
||
inline time_t toDate(DayNum_t d) const { return lut[fixDay(d)].date; }
|
||
inline unsigned toMonth(DayNum_t d) const { return lut[fixDay(d)].month; }
|
||
inline unsigned toYear(DayNum_t d) const { return lut[fixDay(d)].year; }
|
||
inline unsigned toDayOfWeek(DayNum_t d) const { return lut[fixDay(d)].day_of_week; }
|
||
inline unsigned toDayOfMonth(DayNum_t d) const { return lut[fixDay(d)].day_of_month; }
|
||
|
||
inline const Values & getValues(DayNum_t d) const { return lut[fixDay(d)]; }
|
||
inline const Values & getValues(time_t t) const { return lut[findIndex(t)]; }
|
||
|
||
/// получает DayNum_t из года, месяца, дня
|
||
inline DayNum_t makeDayNum(short year, char month, char day_of_month) const
|
||
{
|
||
if (unlikely(year < DATE_LUT_MIN_YEAR || year > DATE_LUT_MAX_YEAR || month < 1 || month > 12 || day_of_month < 1 || day_of_month > 31))
|
||
return DayNum_t(0);
|
||
DayNum_t any_day_of_month(years_lut[year - DATE_LUT_MIN_YEAR] + 31 * (month - 1));
|
||
return DayNum_t(any_day_of_month - toDayOfMonth(any_day_of_month) + day_of_month);
|
||
}
|
||
|
||
inline time_t makeDate(short year, char month, char day_of_month) const
|
||
{
|
||
return lut[makeDayNum(year, month, day_of_month)].date;
|
||
}
|
||
|
||
/** Функция ниже исходит из допущения, что перевод стрелок вперёд, если осуществляется, то на час, в два часа ночи,
|
||
* а перевод стрелок назад, если осуществляется, то на час, в три часа ночи.
|
||
* (что, в общем, не верно, так как в Москве один раз перевод стрелок был осуществлён в другое время).
|
||
* Также, выдаётся лишь один из двух возможных вариантов при переводе стрелок назад.
|
||
*/
|
||
inline time_t makeDateTime(short year, char month, char day_of_month, char hour, char minute, char second) const
|
||
{
|
||
size_t index = makeDayNum(year, month, day_of_month);
|
||
time_t res = lut[index].date + hour * 3600 + minute * 60 + second;
|
||
time_t day_length = lut[index + 1].date - lut[index].date;
|
||
|
||
if (unlikely(day_length == 90000 && hour >= 3)) /// был произведён перевод стрелок назад
|
||
res += 3600;
|
||
else if (unlikely(day_length == 82800 && hour >= 2)) /// был произведён перевод стрелок вперёд
|
||
res -= 3600;
|
||
|
||
return res;
|
||
}
|
||
|
||
|
||
inline UInt32 toNumYYYYMMDD(time_t t) const
|
||
{
|
||
const Values & values = find(t);
|
||
return values.year * 10000 + values.month * 100 + values.day_of_month;
|
||
}
|
||
|
||
inline UInt32 toNumYYYYMMDD(DayNum_t d) const
|
||
{
|
||
const Values & values = lut[fixDay(d)];
|
||
return values.year * 10000 + values.month * 100 + values.day_of_month;
|
||
}
|
||
|
||
inline time_t YYYYMMDDToDate(UInt32 num) const
|
||
{
|
||
return makeDate(num / 10000, num / 100 % 100, num % 100);
|
||
}
|
||
|
||
inline DayNum_t YYYYMMDDToDayNum(UInt32 num) const
|
||
{
|
||
return makeDayNum(num / 10000, num / 100 % 100, num % 100);
|
||
}
|
||
|
||
|
||
inline UInt64 toNumYYYYMMDDhhmmss(time_t t) const
|
||
{
|
||
const Values & values = find(t);
|
||
return
|
||
toSecondInaccurate(t)
|
||
+ toMinuteInaccurate(t) * 100
|
||
+ toHourInaccurate(t) * 10000
|
||
+ UInt64(values.day_of_month) * 1000000
|
||
+ UInt64(values.month) * 100000000
|
||
+ UInt64(values.year) * 10000000000;
|
||
}
|
||
|
||
inline time_t YYYYMMDDhhmmssToTime(UInt64 num) const
|
||
{
|
||
return makeDateTime(
|
||
num / 10000000000,
|
||
num / 100000000 % 100,
|
||
num / 1000000 % 100,
|
||
num / 10000 % 100,
|
||
num / 100 % 100,
|
||
num % 100);
|
||
}
|
||
|
||
|
||
inline std::string timeToString(time_t t) const
|
||
{
|
||
const Values & values = find(t);
|
||
|
||
std::string s {"0000-00-00 00:00:00"};
|
||
|
||
s[0] += values.year / 1000;
|
||
s[1] += (values.year / 100) % 10;
|
||
s[2] += (values.year / 10) % 10;
|
||
s[3] += values.year % 10;
|
||
s[5] += values.month / 10;
|
||
s[6] += values.month % 10;
|
||
s[8] += values.day_of_month / 10;
|
||
s[9] += values.day_of_month % 10;
|
||
|
||
auto hour = toHourInaccurate(t);
|
||
auto minute = toMinuteInaccurate(t);
|
||
auto second = toSecondInaccurate(t);
|
||
|
||
s[11] += hour / 10;
|
||
s[12] += hour % 10;
|
||
s[14] += minute / 10;
|
||
s[15] += minute % 10;
|
||
s[17] += second / 10;
|
||
s[18] += second % 10;
|
||
|
||
return s;
|
||
}
|
||
|
||
inline std::string dateToString(time_t t) const
|
||
{
|
||
const Values & values = find(t);
|
||
|
||
std::string s {"0000-00-00"};
|
||
|
||
s[0] += values.year / 1000;
|
||
s[1] += (values.year / 100) % 10;
|
||
s[2] += (values.year / 10) % 10;
|
||
s[3] += values.year % 10;
|
||
s[5] += values.month / 10;
|
||
s[6] += values.month % 10;
|
||
s[8] += values.day_of_month / 10;
|
||
s[9] += values.day_of_month % 10;
|
||
|
||
return s;
|
||
}
|
||
|
||
inline std::string dateToString(DayNum_t d) const
|
||
{
|
||
const Values & values = lut[fixDay(d)];
|
||
|
||
std::string s {"0000-00-00"};
|
||
|
||
s[0] += values.year / 1000;
|
||
s[1] += (values.year / 100) % 10;
|
||
s[2] += (values.year / 10) % 10;
|
||
s[3] += values.year % 10;
|
||
s[5] += values.month / 10;
|
||
s[6] += values.month % 10;
|
||
s[8] += values.day_of_month / 10;
|
||
s[9] += values.day_of_month % 10;
|
||
|
||
return s;
|
||
}
|
||
};
|
||
|
||
|
||
namespace std
|
||
{
|
||
template<>
|
||
struct hash<DayNum_t>
|
||
{
|
||
size_t operator() (DayNum_t x) const
|
||
{
|
||
return x;
|
||
}
|
||
};
|
||
}
|