Add addDate function for compatibility with MySQL

docs/en/sql-reference/functions/date-time-functions.md

@@ -987,6 +987,10 @@ Result:
 └───────────────────────────────────────────────┘
 ```
 
+**See Also**
+
+- [addDate](#addDate)
+
 ## date\_sub
 
 Subtracts the time interval or date interval from the provided date or date with time.
@@ -1134,6 +1138,41 @@ Result:
 └──────────────────────────────────────────────────────────────┘
 ```
 
+## addDate
+
+Adds the time interval or date interval to the provided date or date with time.
+
+**Syntax**
+
+``` sql
+addDate(date, interval)
+```
+
+**Arguments**
+
+- `date` — The date or date with time to which `value` is added. [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
+- `interval` — Interval to add. [Interval](../../sql-reference/data-types/special-data-types/interval.md).
+
+**Returned value**
+
+Date or date with time obtained by adding `value`, expressed in `unit`, to `date`.
+
+Type: [Date](../../sql-reference/data-types/date.md) or [DateTime](../../sql-reference/data-types/datetime.md).
+
+**Example**
+
+```sql
+SELECT addDate(toDate('2018-01-01'), INTERVAL 3 YEAR);
+```
+
+Result:
+
+```text
+┌─addDate(toDate('2018-01-01'), toIntervalYear(3))─┐
+│                                       2021-01-01 │
+└──────────────────────────────────────────────────┘
+```
+
 ## now
 
 Returns the current date and time at the moment of query analysis. The function is a constant expression.

src/Functions/addDate.cpp

@@ -0,0 +1,88 @@
+#include <Functions/FunctionFactory.h>
+#include <Functions/FunctionDateOrDateTimeAddInterval.h>
+
+namespace DB
+{
+namespace ErrorCodes
+{
+    extern const int ILLEGAL_TYPE_OF_ARGUMENT;
+}
+
+namespace
+{
+
+class FunctionAddDate : public IFunction
+{
+public:
+    static constexpr auto name = "addDate";
+
+    explicit FunctionAddDate(ContextPtr context_) : context(context_) {}
+
+    static FunctionPtr create(ContextPtr context) { return std::make_shared<FunctionAddDate>(context); }
+
+    String getName() const override { return name; }
+
+    bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; }
+    size_t getNumberOfArguments() const override { return 2; }
+
+    DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override
+    {
+        if (!isDateOrDate32(arguments[0].type) && !isDateTime(arguments[0].type) && !isDateTime64(arguments[0].type))
+            throw Exception(
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of 1st argument of function {}. Should be a date or a date with time",
+                arguments[0].type->getName(),
+                getName());
+
+        if (!isInterval(arguments[1].type))
+            throw Exception(
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of 1st argument of function {}. Should be an interval",
+                arguments[0].type->getName(),
+                getName());
+
+        auto plus = FunctionFactory::instance().get("plus", context);
+        auto plus_build = plus->build(arguments);
+
+        return plus_build->getResultType();
+    }
+
+    bool useDefaultImplementationForConstants() const override { return true; }
+    ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {0, 2}; }
+
+    ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override
+    {
+        if (!isDateOrDate32(arguments[0].type) && !isDateTime(arguments[0].type) && !isDateTime64(arguments[0].type))
+            throw Exception(
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of 1st argument of function {}. Should be a date or a date with time",
+                arguments[0].type->getName(),
+                getName());
+
+        if (!isInterval(arguments[1].type))
+            throw Exception(
+                ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT,
+                "Illegal type {} of 1st argument of function {}. Should be an interval",
+                arguments[0].type->getName(),
+                getName());
+
+        auto plus = FunctionFactory::instance().get("plus", context);
+        auto plus_build = plus->build(arguments);
+
+        auto res_type = plus_build->getResultType();
+        return plus_build->execute(arguments, res_type, input_rows_count);
+    }
+
+private:
+    ContextPtr context;
+};
+
+}
+
+
+REGISTER_FUNCTION(AddInterval)
+{
+    factory.registerFunction<FunctionAddDate>();
+}
+
+}

tests/queries/0_stateless/02415_all_new_functions_must_be_documented.reference

@@ -68,6 +68,7 @@ accurateCastOrDefault
 accurateCastOrNull
 acos
 acosh
+addDate
 addDays
 addHours
 addMicroseconds

tests/queries/0_stateless/02834_add_date_function.reference

@@ -0,0 +1,4 @@
+2022-05-07 00:05:00
+2022-05-07 00:05:00.000
+2022-05-07 00:05:00
+2022-05-07 00:05:00.000

tests/queries/0_stateless/02834_add_date_function.sql

@@ -0,0 +1,9 @@
+SELECT addDate('2022-05-07'::Date, INTERVAL 5 MINUTE);
+SELECT addDate('2022-05-07'::Date32, INTERVAL 5 MINUTE);
+SELECT addDate('2022-05-07'::DateTime, INTERVAL 5 MINUTE);
+SELECT addDate('2022-05-07'::DateTime64, INTERVAL 5 MINUTE);
+
+SELECT addDate('2022-05-07'::Date); -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+SELECT addDate('2022-05-07'::Date, INTERVAL 5 MINUTE, 5);  -- { serverError NUMBER_OF_ARGUMENTS_DOESNT_MATCH }
+SELECT addDate('2022-05-07'::Date, 10); -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }
+SELECT addDate('1234', INTERVAL 5 MINUTE);  -- { serverError ILLEGAL_TYPE_OF_ARGUMENT }

utils/check-style/aspell-ignore/en/aspell-dict.txt

@@ -982,6 +982,7 @@ acos
 acosh
 activecube
 activerecord
+addDate
 addDays
 addHours
 addMinutes