Add duration.

src/common/datatypes/CMakeLists.txt

@@ -14,6 +14,7 @@ nebula_add_library(
  List.cpp
  Set.cpp
  Geography.cpp
+ Duration.cpp
 )
 
 nebula_add_subdirectory(test)

src/common/datatypes/CommonCpp2Ops.h

@@ -28,6 +28,7 @@ struct Point;
 struct LineString;
 struct Polygon;
 struct Geography;
+struct Duration;
 } // namespace nebula
 
 namespace apache::thrift {
@@ -52,6 +53,7 @@ SPECIALIZE_CPP2OPS(nebula::Point);
 SPECIALIZE_CPP2OPS(nebula::LineString);
 SPECIALIZE_CPP2OPS(nebula::Polygon);
 SPECIALIZE_CPP2OPS(nebula::Geography);
+SPECIALIZE_CPP2OPS(nebula::Duration);
 
 } // namespace apache::thrift
 

src/common/datatypes/Date.cpp

@@ -15,6 +15,11 @@ namespace nebula {
 const int64_t kDaysSoFar[] = {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365};
 const int64_t kLeapDaysSoFar[] = {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366};
 
+int8_t dayOfMonth(int16_t year, int8_t month) {
+ return isLeapYear(year) ? kLeapDaysSoFar[month] - kLeapDaysSoFar[month - 1]
+ : kDaysSoFar[month] - kDaysSoFar[month - 1];
+}
+
 Date::Date(uint64_t days) { fromInt(days); }
 
 int64_t Date::toInt() const {
@@ -92,16 +97,224 @@ Date Date::operator-(int64_t days) const {
  return Date(daysSince - days);
 }
 
+void Date::addDuration(const Duration& duration) {
+ int64_t tmp{0}, carry{0};
+ tmp = month + duration.months;
+ if (std::abs(tmp) > 12) {
+ carry = tmp / 12;
+ month = tmp % 12;
+ } else {
+ month = tmp;
+ }
+ if (month <= 0) {
+ carry--;
+ month += 12;
+ }
+ year += carry;
+
+ tmp = day + duration.days();
+ if (tmp > 0) {
+ int8_t dom = dayOfMonth(year, month);
+ while (tmp > dom) {
+ tmp -= dom;
+ month += 1;
+ if (month > 12) {
+ year += 1;
+ month = 1;
+ }
+ dom = dayOfMonth(year, month);
+ }
+ } else {
+ int8_t dom = (month == 1 ? dayOfMonth(year - 1, 12) : dayOfMonth(year, month - 1));
+ while (tmp <= 0) {
+ tmp += dom;
+ month -= 1;
+ if (month <= 0) {
+ year--;
+ month += 12;
+ }
+ dom = (month == 1 ? dayOfMonth(year - 1, 12) : dayOfMonth(year, month - 1));
+ }
+ }
+ day = tmp;
+}
+
+void Date::subDuration(const Duration& duration) { return addDuration(-duration); }
+
 std::string Date::toString() const {
  // It's in current timezone already
  return folly::stringPrintf("%d-%02d-%02d", year, month, day);
 }
 
+void Time::addDuration(const Duration& duration) {
+ int64_t tmp{0}, carry{0};
+ tmp = microsec + duration.microsecondsInSecond();
+ if (std::abs(tmp) >= 1000000) {
+ carry = tmp / 1000000;
+ microsec = tmp % 1000000;
+ } else {
+ microsec = tmp;
+ }
+ if (microsec < 0) {
+ carry--;
+ microsec += 1000000;
+ }
+ tmp = sec + duration.seconds + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 60) {
+ carry = tmp / 60;
+ sec = tmp % 60;
+ } else {
+ sec = tmp;
+ }
+ if (sec < 0) {
+ carry--;
+ sec += 60;
+ }
+ tmp = minute + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 60) {
+ carry = tmp / 60;
+ minute = tmp % 60;
+ } else {
+ minute = tmp;
+ }
+ if (minute < 0) {
+ carry--;
+ minute += 60;
+ }
+ tmp = hour + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 24) {
+ carry = tmp / 24;
+ hour = tmp % 24;
+ } else {
+ hour = tmp;
+ }
+ if (hour < 0) {
+ carry--;
+ hour += 24;
+ }
+}
+
+void Time::subDuration(const Duration& duration) { addDuration(-duration); }
+
 std::string Time::toString() const {
  // It's in current timezone already
  return folly::stringPrintf("%02d:%02d:%02d.%06d", hour, minute, sec, microsec);
 }
 
+void DateTime::addDuration(const Duration& duration) {
+ // The origin fields of DateTime is unsigned, but there will be some negative intermediate results
+ // so I define some variable(field, tYear, tMonth) for this.
+ int64_t tmp{0}, carry{0}, field{0};
+ tmp = month + duration.months;
+ if (std::abs(tmp) > 12) {
+ carry = tmp / 12;
+ /*month*/ field = tmp % 12;
+ } else {
+ /*month*/ field = tmp;
+ }
+ if (/*month*/ field <= 0) {
+ carry--;
+ /*month*/ field += 12;
+ }
+ year += carry;
+ carry = 0;
+ month = field;
+ field = 0;
+
+ tmp = microsec + duration.microsecondsInSecond();
+ if (std::abs(tmp) >= 1000000) {
+ carry = tmp / 1000000;
+ /*microsec*/ field = tmp % 1000000;
+ } else {
+ /*microsec*/ field = tmp;
+ }
+ if (/*microsec*/ field < 0) {
+ carry--;
+ /*microsec*/ field += 1000000;
+ }
+ microsec = field;
+ field = 0;
+ tmp = sec + duration.seconds + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 60) {
+ carry = tmp / 60;
+ /*sec*/ field = tmp % 60;
+ } else {
+ /*sec*/ field = tmp;
+ }
+ if (/*sec*/ field < 0) {
+ carry--;
+ /*sec*/ field += 60;
+ }
+ sec = field;
+ field = 0;
+ tmp = minute + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 60) {
+ carry = tmp / 60;
+ /*minute*/ field = tmp % 60;
+ } else {
+ /*minute*/ field = tmp;
+ }
+ if (/*minute*/ field < 0) {
+ carry--;
+ /*minute*/ field += 60;
+ }
+ minute = field;
+ field = 0;
+ tmp = hour + carry;
+ carry = 0;
+ if (std::abs(tmp) >= 24) {
+ carry = tmp / 24;
+ /*hour*/ field = tmp % 24;
+ } else {
+ /*hour*/ field = tmp;
+ }
+ if (/*hour*/ field < 0) {
+ carry--;
+ /*hour*/ field += 24;
+ }
+ hour = field;
+ field = 0;
+
+ tmp = day + carry;
+ carry = 0;
+ if (tmp > 0) {
+ int8_t dom = dayOfMonth(year, month);
+ while (tmp > dom) {
+ tmp -= dom;
+ month += 1;
+ if (month > 12) {
+ year += 1;
+ month = 1;
+ }
+ dom = dayOfMonth(year, month);
+ }
+ } else {
+ int8_t dom = (month == 1 ? dayOfMonth(year - 1, 12) : dayOfMonth(year, month - 1));
+ int64_t tMonth = month;
+ int64_t tYear = year;
+ while (tmp <= 0) {
+ tmp += dom;
+ /*month*/ tMonth -= 1;
+ if (/*month*/ tMonth <= 0) {
+ /*year*/ tYear--;
+ /*month*/ tMonth += 12;
+ }
+ dom = (/*month*/ tMonth == 1 ? dayOfMonth(/*year*/ tYear - 1, 12)
+ : dayOfMonth(/*year*/ tYear, /*month*/ tMonth - 1));
+ }
+ month = tMonth;
+ year = tYear;
+ }
+ day = tmp;
+}
+
+void DateTime::subDuration(const Duration& duration) { return addDuration(-duration); }
+
 std::string DateTime::toString() const {
  // It's in current timezone already
  return folly::stringPrintf(

src/common/datatypes/Date.h

@@ -10,6 +10,8 @@
 
 #include <string>
 
+#include "common/datatypes/Duration.h"
+
 namespace nebula {
 
 // In nebula only store UTC time, and the interpretation of time value based on
@@ -18,6 +20,21 @@ namespace nebula {
 extern const int64_t kDaysSoFar[];
 extern const int64_t kLeapDaysSoFar[];
 
+// https://en.wikipedia.org/wiki/Leap_year#Leap_day
+static inline bool isLeapYear(int16_t year) {
+ if (year % 4 != 0) {
+ return false;
+ } else if (year % 100 != 0) {
+ return true;
+ } else if (year % 400 != 0) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
+int8_t dayOfMonth(int16_t year, int8_t month);
+
 struct Date {
  int16_t year; // Any integer
  int8_t month; // 1 - 12
@@ -62,6 +79,9 @@ struct Date {
  Date operator+(int64_t days) const;
  Date operator-(int64_t days) const;
 
+ void addDuration(const Duration& duration);
+ void subDuration(const Duration& duration);
+
  std::string toString() const;
  folly::dynamic toJson() const { return toString(); }
 
@@ -71,6 +91,18 @@ struct Date {
  void fromInt(int64_t days);
 };
 
+inline Date operator+(const Date& l, const Duration& r) {
+ Date d = l;
+ d.addDuration(r);
+ return d;
+}
+
+inline Date operator-(const Date& l, const Duration& r) {
+ Date d = l;
+ d.subDuration(r);
+ return d;
+}
+
 inline std::ostream& operator<<(std::ostream& os, const Date& d) {
  os << d.toString();
  return os;
@@ -114,6 +146,9 @@ struct Time {
  return false;
  }
 
+ void addDuration(const Duration& duration);
+ void subDuration(const Duration& duration);
+
  std::string toString() const;
  // 'Z' representing UTC timezone
  folly::dynamic toJson() const { return toString() + "Z"; }
@@ -124,6 +159,18 @@ inline std::ostream& operator<<(std::ostream& os, const Time& d) {
  return os;
 }
 
+inline Time operator+(const Time& l, const Duration& r) {
+ Time t = l;
+ t.addDuration(r);
+ return t;
+}
+
+inline Time operator-(const Time& l, const Duration& r) {
+ Time t = l;
+ t.subDuration(r);
+ return t;
+}
+
 struct DateTime {
 #if defined(__GNUC__)
 #pragma GCC diagnostic push
@@ -206,6 +253,9 @@ struct DateTime {
  return false;
  }
 
+ void addDuration(const Duration& duration);
+ void subDuration(const Duration& duration);
+
  std::string toString() const;
  // 'Z' representing UTC timezone
  folly::dynamic toJson() const { return toString() + "Z"; }
@@ -216,6 +266,18 @@ inline std::ostream& operator<<(std::ostream& os, const DateTime& d) {
  return os;
 }
 
+inline DateTime operator+(const DateTime& l, const Duration& r) {
+ DateTime dt = l;
+ dt.addDuration(r);
+ return dt;
+}
+
+inline DateTime operator-(const DateTime& l, const Duration& r) {
+ DateTime dt = l;
+ dt.subDuration(r);
+ return dt;
+}
+
 } // namespace nebula
 
 namespace std {

src/common/datatypes/Duration.cpp

@@ -0,0 +1,15 @@
+/* Copyright (c) 2021 vesoft inc. All rights reserved.
+ *
+ * This source code is licensed under Apache 2.0 License.
+ */
+
+#include "common/datatypes/Duration.h"
+
+#include <folly/String.h>
+#include <folly/hash/Hash.h>
+
+#include <sstream>
+
+namespace nebula {} // namespace nebula
+
+namespace std {} // namespace std