Bit-Quill
diff --git a/‎core/src/main/java/org/opensearch/sql/data/model/ExprDatetimeValue.java
Lines changed: 1 addition & 1 deletion b/‎core/src/main/java/org/opensearch/sql/data/model/ExprDatetimeValue.java
Lines changed: 1 addition & 1 deletion
diff --git a/‎core/src/main/java/org/opensearch/sql/expression/DSL.java
Lines changed: 8 additions & 0 deletions b/‎core/src/main/java/org/opensearch/sql/expression/DSL.java
Lines changed: 8 additions & 0 deletions
diff --git a/‎core/src/main/java/org/opensearch/sql/expression/datetime/DateTimeFunction.java
Lines changed: 130 additions & 1 deletion b/‎core/src/main/java/org/opensearch/sql/expression/datetime/DateTimeFunction.java
Lines changed: 130 additions & 1 deletion
diff --git a/‎core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java
Lines changed: 2 additions & 0 deletions b/‎core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java
Lines changed: 2 additions & 0 deletions
diff --git a/‎core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java
Lines changed: 6 additions & 0 deletions b/‎core/src/main/java/org/opensearch/sql/utils/DateTimeFormatters.java
Lines changed: 6 additions & 0 deletions
diff --git a/‎core/src/main/java/org/opensearch/sql/utils/DateTimeUtils.java
Lines changed: 31 additions & 0 deletions b/‎core/src/main/java/org/opensearch/sql/utils/DateTimeUtils.java
Lines changed: 31 additions & 0 deletions
@@ -33,7 +33,7 @@ public class ExprDatetimeValue extends AbstractExprValue {
 
   static {
     FORMATTER_VARIABLE_NANOS = new DateTimeFormatterBuilder()
-        .appendPattern("yyyy-MM-dd HH:mm:ss")
+        .appendPattern("uuuu-MM-dd HH:mm:ss[xxx]")
         .appendFraction(
             ChronoField.NANO_OF_SECOND,
             MIN_FRACTION_SECONDS,
 
@@ -271,10 +271,18 @@ public FunctionExpression adddate(Expression... expressions) {
     return function(BuiltinFunctionName.ADDDATE, expressions);
   }
 
+  public FunctionExpression convert_tz(Expression... expressions) {
+    return function(BuiltinFunctionName.CONVERT_TZ, expressions);
+  }
+
   public FunctionExpression date(Expression... expressions) {
     return function(BuiltinFunctionName.DATE, expressions);
   }
 
+  public FunctionExpression datetime(Expression... expressions) {
+    return function(BuiltinFunctionName.DATETIME, expressions);
+  }
+
   public FunctionExpression date_add(Expression... expressions) {
     return function(BuiltinFunctionName.DATE_ADD, expressions);
   }
 
@@ -22,20 +22,24 @@
 import static org.opensearch.sql.utils.DateTimeFormatters.DATE_FORMATTER_SHORT_YEAR;
 import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_LONG_YEAR;
 import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_SHORT_YEAR;
+import static org.opensearch.sql.utils.DateTimeFormatters.DATE_TIME_FORMATTER_STRICT_WITH_TZ;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.text.DecimalFormat;
+import java.time.DateTimeException;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
 import java.time.ZoneId;
 import java.time.ZoneOffset;
+import java.time.ZonedDateTime;
 import java.time.format.DateTimeFormatter;
 import java.time.format.DateTimeParseException;
 import java.time.format.TextStyle;
 import java.util.Locale;
+import java.util.TimeZone;
 import java.util.concurrent.TimeUnit;
 import javax.annotation.Nullable;
 import lombok.experimental.UtilityClass;
@@ -50,11 +54,13 @@
 import org.opensearch.sql.data.model.ExprTimestampValue;
 import org.opensearch.sql.data.model.ExprValue;
 import org.opensearch.sql.data.type.ExprCoreType;
+import org.opensearch.sql.exception.ExpressionEvaluationException;
 import org.opensearch.sql.expression.function.BuiltinFunctionName;
 import org.opensearch.sql.expression.function.BuiltinFunctionRepository;
 import org.opensearch.sql.expression.function.DefaultFunctionResolver;
 import org.opensearch.sql.expression.function.FunctionName;
 import org.opensearch.sql.expression.function.FunctionResolver;
+import org.opensearch.sql.utils.DateTimeUtils;
 
 /**
  * The definition of date and time functions.
@@ -63,7 +69,6 @@
  */
 @UtilityClass
 public class DateTimeFunction {
-
   // The number of days from year zero to year 1970.
   private static final Long DAYS_0000_TO_1970 = (146097 * 5L) - (30L * 365L + 7L);
 
@@ -78,7 +83,9 @@ public class DateTimeFunction {
    */
   public void register(BuiltinFunctionRepository repository) {
     repository.register(adddate());
+    repository.register(convert_tz());
     repository.register(date());
+    repository.register(datetime());
     repository.register(date_add());
     repository.register(date_sub());
     repository.register(day());
@@ -214,6 +221,21 @@ private DefaultFunctionResolver adddate() {
     return add_date(BuiltinFunctionName.ADDDATE.getName());
   }
 
+  /**
+   * Converts date/time from a specified timezone to another specified timezone.
+   * The supported signatures:
+   * (DATETIME, STRING, STRING) -> DATETIME
+   * (STRING, STRING, STRING) -> DATETIME
+   */
+  private DefaultFunctionResolver convert_tz() {
+    return define(BuiltinFunctionName.CONVERT_TZ.getName(),
+        impl(nullMissingHandling(DateTimeFunction::exprConvertTZ),
+            DATETIME, DATETIME, STRING, STRING),
+        impl(nullMissingHandling(DateTimeFunction::exprConvertTZ),
+            DATETIME, STRING, STRING, STRING)
+    );
+  }
+
   /**
    * Extracts the date part of a date and time value.
    * Also to construct a date type. The supported signatures:
@@ -227,6 +249,21 @@ private DefaultFunctionResolver date() {
         impl(nullMissingHandling(DateTimeFunction::exprDate), DATE, TIMESTAMP));
   }
 
+  /**
+   * Specify a datetime with time zone field and a time zone to convert to.
+   * Returns a local date time.
+   * (STRING, STRING) -> DATETIME
+   * (STRING) -> DATETIME
+   */
+  private FunctionResolver datetime() {
+    return define(BuiltinFunctionName.DATETIME.getName(),
+        impl(nullMissingHandling(DateTimeFunction::exprDateTime),
+            DATETIME, STRING, STRING),
+        impl(nullMissingHandling(DateTimeFunction::exprDateTimeNoTimezone),
+            DATETIME, STRING)
+    );
+  }
+
   private DefaultFunctionResolver date_add() {
     return add_date(BuiltinFunctionName.DATE_ADD.getName());
   }
@@ -570,6 +607,42 @@ private ExprValue exprAddDateDays(ExprValue date, ExprValue days) {
         : exprValue);
   }
 
+  /**
+   * CONVERT_TZ function implementation for ExprValue.
+   * Returns null for time zones outside of +13:00 and -12:00.
+   *
+   * @param startingDateTime ExprValue of DateTime that is being converted from
+   * @param fromTz           ExprValue of time zone, representing the time to convert from.
+   * @param toTz             ExprValue of time zone, representing the time to convert to.
+   * @return DateTime that has been converted to the to_tz timezone.
+   */
+  private ExprValue exprConvertTZ(ExprValue startingDateTime, ExprValue fromTz, ExprValue toTz) {
+    if (startingDateTime.type() == ExprCoreType.STRING) {
+      startingDateTime = exprDateTimeNoTimezone(startingDateTime);
+    }
+    try {
+      ZoneId convertedFromTz = ZoneId.of(fromTz.stringValue());
+      ZoneId convertedToTz = ZoneId.of(toTz.stringValue());
+
+      // isValidMySqlTimeZoneId checks if the timezone is within the range accepted by
+      // MySQL standard.
+      if (!DateTimeUtils.isValidMySqlTimeZoneId(convertedFromTz)
+          || !DateTimeUtils.isValidMySqlTimeZoneId(convertedToTz)) {
+        return ExprNullValue.of();
+      }
+      ZonedDateTime zonedDateTime =
+          startingDateTime.datetimeValue().atZone(convertedFromTz);
+      return new ExprDatetimeValue(
+          zonedDateTime.withZoneSameInstant(convertedToTz).toLocalDateTime());
+
+
+      // Catches exception for invalid timezones.
+      // ex. "+0:00" is an invalid timezone and would result in this exception being thrown.
+    } catch (ExpressionEvaluationException | DateTimeException e) {
+      return ExprNullValue.of();
+    }
+  }
+
   /**
    * Date implementation for ExprValue.
    *
@@ -584,6 +657,62 @@ private ExprValue exprDate(ExprValue exprValue) {
     }
   }
 
+  /**
+   * DateTime implementation for ExprValue.
+   *
+   * @param dateTime ExprValue of String type.
+   * @param timeZone ExprValue of String type (or null).
+   * @return ExprValue of date type.
+   */
+  private ExprValue exprDateTime(ExprValue dateTime, ExprValue timeZone) {
+    String defaultTimeZone = TimeZone.getDefault().getID();
+
+
+    try {
+      LocalDateTime ldtFormatted =
+          LocalDateTime.parse(dateTime.stringValue(), DATE_TIME_FORMATTER_STRICT_WITH_TZ);
+      if (timeZone.isNull()) {
+        return new ExprDatetimeValue(ldtFormatted);
+      }
+
+      // Used if datetime field is invalid format.
+    } catch (DateTimeParseException e) {
+      return ExprNullValue.of();
+    }
+
+    ExprValue convertTZResult;
+    ExprDatetimeValue ldt;
+    String toTz;
+
+    try {
+      ZonedDateTime zdtWithZoneOffset =
+          ZonedDateTime.parse(dateTime.stringValue(), DATE_TIME_FORMATTER_STRICT_WITH_TZ);
+      ZoneId fromTZ = zdtWithZoneOffset.getZone();
+
+      ldt = new ExprDatetimeValue(zdtWithZoneOffset.toLocalDateTime());
+      toTz = String.valueOf(fromTZ);
+    } catch (DateTimeParseException e) {
+      ldt = new ExprDatetimeValue(dateTime.stringValue());
+      toTz = defaultTimeZone;
+    }
+    convertTZResult = exprConvertTZ(
+        ldt,
+        new ExprStringValue(toTz),
+        timeZone);
+
+    return convertTZResult;
+  }
+
+  /**
+   * DateTime implementation for ExprValue without a timezone to convert to.
+   *
+   * @param dateTime ExprValue of String type.
+   * @return ExprValue of date type.
+   */
+  private ExprValue exprDateTimeNoTimezone(ExprValue dateTime) {
+    return exprDateTime(dateTime, ExprNullValue.of());
+  }
+
   /**
    * Name of the Weekday implementation for ExprValue.
    *
 
@@ -58,7 +58,9 @@ public enum BuiltinFunctionName {
    * Date and Time Functions.
    */
   ADDDATE(FunctionName.of("adddate")),
+  CONVERT_TZ(FunctionName.of("convert_tz")),
   DATE(FunctionName.of("date")),
+  DATETIME(FunctionName.of("datetime")),
   DATE_ADD(FunctionName.of("date_add")),
   DATE_SUB(FunctionName.of("date_sub")),
   DAY(FunctionName.of("day")),
 
@@ -162,4 +162,10 @@ public class DateTimeFormatters {
           .appendPattern("MMddHHmmss")
           .toFormatter()
           .withResolverStyle(ResolverStyle.STRICT);
+
+  public static final DateTimeFormatter DATE_TIME_FORMATTER_STRICT_WITH_TZ =
+      new DateTimeFormatterBuilder()
+          .appendPattern("uuuu-MM-dd HH:mm:ss[xxx]")
+          .toFormatter()
+          .withResolverStyle(ResolverStyle.STRICT);
 }
@@ -6,6 +6,7 @@
 package org.opensearch.sql.utils;
 
 import java.time.Instant;
+import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
 import lombok.experimental.UtilityClass;
@@ -84,4 +85,34 @@ public static long roundYear(long utcMillis, int interval) {
     return initDateTime.plusYears(yearToAdd).toInstant().toEpochMilli();
   }
 
+
+  /**
+   * isValidMySqlTimeZoneId for timezones which match timezone the range set by MySQL.
+   *
+   * @param zone ZoneId of ZoneId type.
+   * @return Boolean.
+   */
+  public Boolean isValidMySqlTimeZoneId(ZoneId zone) {
+    String timeZoneMax = "+14:00";
+    String timeZoneMin = "-13:59";
+    String timeZoneZero = "+00:00";
+
+    ZoneId maxTz = ZoneId.of(timeZoneMax);
+    ZoneId minTz = ZoneId.of(timeZoneMin);
+    ZoneId defaultTz = ZoneId.of(timeZoneZero);
+
+    ZonedDateTime defaultDateTime = LocalDateTime.of(2000, 1, 2, 12, 0).atZone(defaultTz);
+
+    ZonedDateTime maxTzValidator =
+        defaultDateTime.withZoneSameInstant(maxTz).withZoneSameLocal(defaultTz);
+    ZonedDateTime minTzValidator =
+        defaultDateTime.withZoneSameInstant(minTz).withZoneSameLocal(defaultTz);
+    ZonedDateTime passedTzValidator =
+        defaultDateTime.withZoneSameInstant(zone).withZoneSameLocal(defaultTz);
+
+    return (passedTzValidator.isBefore(maxTzValidator)
+        || passedTzValidator.isEqual(maxTzValidator))
+        && (passedTzValidator.isAfter(minTzValidator)
+        || passedTzValidator.isEqual(minTzValidator));
+  }
 }
Original file line number	Diff line number	Diff line change
`@@ -271,10 +271,18 @@ public FunctionExpression adddate(Expression... expressions) {`
`271`	`271`	`return function(BuiltinFunctionName.ADDDATE, expressions);`
`272`	`272`	`}`
`273`	`273`
	`274`	`+ public FunctionExpression convert_tz(Expression... expressions) {`
	`275`	`+ return function(BuiltinFunctionName.CONVERT_TZ, expressions);`
	`276`	`+ }`
	`277`	`+`
`274`	`278`	`public FunctionExpression date(Expression... expressions) {`
`275`	`279`	`return function(BuiltinFunctionName.DATE, expressions);`
`276`	`280`	`}`
`277`	`281`
	`282`	`+ public FunctionExpression datetime(Expression... expressions) {`
	`283`	`+ return function(BuiltinFunctionName.DATETIME, expressions);`
	`284`	`+ }`
	`285`	`+`
`278`	`286`	`public FunctionExpression date_add(Expression... expressions) {`
`279`	`287`	`return function(BuiltinFunctionName.DATE_ADD, expressions);`
`280`	`288`	`}`