Merge branch 'main' into integ-datetime-calculations

Author: Yury-Fridlyand

MAINTAINERS.md

@@ -1,14 +1,16 @@
-# OpenSearch SQL Maintainers
+## Overview
 
-## Maintainers
+This document contains a list of maintainers in this repo. See [opensearch-project/.github/RESPONSIBILITIES.md](https://github.com/opensearch-project/.github/blob/main/RESPONSIBILITIES.md#maintainer-responsibilities) that explains what the role of maintainer means, what maintainers do in this and other repos, and how they should be doing it. If you're interested in contributing, and becoming a maintainer, see [CONTRIBUTING](CONTRIBUTING.md).
 
-| Maintainer | GitHub ID | Affiliation |
-| --------------- | --------- | ----------- |
-| Anirudha (Ani) Jadhav | [anirudha](https://github.com/anirudha) | Amazon |
-| Peng Huo | [penghuo](https://github.com/penghuo) | Amazon |
-| Chen Dai | [dai-chen](https://github.com/dai-chen) | Amazon |
-| Chloe Zhang | [chloe-zh](https://github.com/chloe-zh) | Amazon |
-| Nick Knize | [nknize](https://github.com/nknize) | Amazon |
-| Charlotte Henkle | [CEHENKLE](https://github.com/CEHENKLE) | Amazon |
-| Max Ksyunz |  [MaxKsyunz](https://github.com/MaxKsyunz) | BitQuill |
-| Yury Fridlyand | [Yury-Fridlyand](https://github.com/Yury-Fridlyand) | BitQuill |
+## Current Maintainers
+
+| Maintainer            | GitHub ID                                           | Affiliation |
+| --------------------- | --------------------------------------------------- | ----------- |
+| Anirudha (Ani) Jadhav | [anirudha](https://github.com/anirudha)             | Amazon      |
+| Peng Huo              | [penghuo](https://github.com/penghuo)               | Amazon      |
+| Chen Dai              | [dai-chen](https://github.com/dai-chen)             | Amazon      |
+| Chloe Zhang           | [chloe-zh](https://github.com/chloe-zh)             | Amazon      |
+| Nick Knize            | [nknize](https://github.com/nknize)                 | Amazon      |
+| Charlotte Henkle      | [CEHENKLE](https://github.com/CEHENKLE)             | Amazon      |
+| Max Ksyunz            | [MaxKsyunz](https://github.com/MaxKsyunz)           | BitQuill    |
+| Yury Fridlyand        | [Yury-Fridlyand](https://github.com/Yury-Fridlyand) | BitQuill    |

core/src/main/java/org/opensearch/sql/expression/datetime/DateTimeFunction.java

@@ -6,6 +6,7 @@
 
 package org.opensearch.sql.expression.datetime;
 
+import static java.time.temporal.ChronoUnit.DAYS;
 import static java.time.temporal.ChronoUnit.MINUTES;
 import static java.time.temporal.ChronoUnit.MONTHS;
 import static org.opensearch.sql.data.type.ExprCoreType.DATE;
@@ -27,13 +28,15 @@
 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 static org.opensearch.sql.utils.DateTimeUtils.extractDate;
 import static org.opensearch.sql.utils.DateTimeUtils.extractDateTime;
 
 import java.math.BigDecimal;
 import java.math.RoundingMode;
 import java.text.DecimalFormat;
 import java.time.Clock;
 import java.time.DateTimeException;
+import java.time.Duration;
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
@@ -107,6 +110,7 @@ public void register(BuiltinFunctionRepository repository) {
     repository.register(current_time());
     repository.register(current_timestamp());
     repository.register(date());
+    repository.register(datediff());
     repository.register(datetime());
     repository.register(date_add());
     repository.register(date_sub());
@@ -138,6 +142,7 @@ public void register(BuiltinFunctionRepository repository) {
     repository.register(sysdate());
     repository.register(time());
     repository.register(time_to_sec());
+    repository.register(timediff());
     repository.register(timestamp());
     repository.register(utc_date());
     repository.register(utc_time());
@@ -298,6 +303,46 @@ private DefaultFunctionResolver date() {
         impl(nullMissingHandling(DateTimeFunction::exprDate), DATE, TIMESTAMP));
   }
 
+  /*
+   * Calculates the difference of date part of given values.
+   * (DATE/DATETIME/TIMESTAMP/TIME, DATE/DATETIME/TIMESTAMP/TIME) -> LONG
+   */
+  private DefaultFunctionResolver datediff() {
+    return define(BuiltinFunctionName.DATEDIFF.getName(),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATE, DATE),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATETIME, DATE),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATE, DATETIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATETIME, DATETIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATE, TIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIME, DATE),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIME, TIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIMESTAMP, DATE),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATE, TIMESTAMP),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIMESTAMP, TIMESTAMP),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIMESTAMP, TIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIME, TIMESTAMP),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIMESTAMP, DATETIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATETIME, TIMESTAMP),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, TIME, DATETIME),
+        implWithProperties(nullMissingHandlingWithProperties(DateTimeFunction::exprDateDiff),
+            LONG, DATETIME, TIME));
+  }
+
   /**
    * Specify a datetime with time zone field and a time zone to convert to.
    * Returns a local date time.
@@ -557,6 +602,22 @@ private DefaultFunctionResolver time() {
         impl(nullMissingHandling(DateTimeFunction::exprTime), TIME, TIMESTAMP));
   }
 
+  /**
+   * Returns different between two times as a time.
+   * (TIME, TIME) -> TIME
+   * MySQL has these signatures too
+   * (DATE, DATE) -> TIME                      // result is > 24 hours
+   * (DATETIME, DATETIME) -> TIME              // result is > 24 hours
+   * (TIMESTAMP, TIMESTAMP) -> TIME            // result is > 24 hours
+   * (x, x) -> NULL                            // when args have different types
+   * (STRING, STRING) -> TIME                  // argument strings contain same types only
+   * (STRING, STRING) -> NULL                  // argument strings are different types
+   */
+  private DefaultFunctionResolver timediff() {
+    return define(BuiltinFunctionName.TIMEDIFF.getName(),
+        impl(nullMissingHandling(DateTimeFunction::exprTimeDiff), TIME, TIME, TIME));
+  }
+
   /**
    * TIME_TO_SEC(STRING/TIME/DATETIME/TIMESTAMP). return the time argument, converted to seconds.
    */
@@ -792,6 +853,22 @@ private ExprValue exprDate(ExprValue exprValue) {
     }
   }
 
+  /**
+   * Calculate the value in days from one date to the other.
+   * Only the date parts of the values are used in the calculation.
+   *
+   * @param first The first value.
+   * @param second The second value.
+   * @return The diff.
+   */
+  private ExprValue exprDateDiff(FunctionProperties functionProperties,
+                                 ExprValue first, ExprValue second) {
+    // java inverses the value, so we have to swap 1 and 2
+    return new ExprLongValue(DAYS.between(
+        extractDate(second, functionProperties),
+        extractDate(first, functionProperties)));
+  }
+
   /**
    * DateTime implementation for ExprValue.
    *
@@ -1151,6 +1228,19 @@ private ExprValue exprTime(ExprValue exprValue) {
     }
   }
 
+  /**
+   * Calculate the time difference between two times.
+   *
+   * @param first The first value.
+   * @param second The second value.
+   * @return The diff.
+   */
+  private ExprValue exprTimeDiff(ExprValue first, ExprValue second) {
+    // java inverses the value, so we have to swap 1 and 2
+    return new ExprTimeValue(LocalTime.MIN.plus(
+        Duration.between(second.timeValue(), first.timeValue())));
+  }
+
   /**
    * Timestamp implementation for ExprValue.
    *

core/src/main/java/org/opensearch/sql/expression/function/BuiltinFunctionName.java

@@ -61,6 +61,7 @@ public enum BuiltinFunctionName {
   ADDDATE(FunctionName.of("adddate")),
   CONVERT_TZ(FunctionName.of("convert_tz")),
   DATE(FunctionName.of("date")),
+  DATEDIFF(FunctionName.of("datediff")),
   DATETIME(FunctionName.of("datetime")),
   DATE_ADD(FunctionName.of("date_add")),
   DATE_SUB(FunctionName.of("date_sub")),
@@ -87,6 +88,7 @@ public enum BuiltinFunctionName {
   SECOND(FunctionName.of("second")),
   SUBDATE(FunctionName.of("subdate")),
   TIME(FunctionName.of("time")),
+  TIMEDIFF(FunctionName.of("timediff")),
   TIME_TO_SEC(FunctionName.of("time_to_sec")),
   TIMESTAMP(FunctionName.of("timestamp")),
   DATE_FORMAT(FunctionName.of("date_format")),

core/src/main/java/org/opensearch/sql/utils/DateTimeUtils.java

@@ -6,6 +6,7 @@
 package org.opensearch.sql.utils;
 
 import java.time.Instant;
+import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.ZoneId;
 import java.time.ZonedDateTime;
@@ -139,4 +140,15 @@ public static LocalDateTime extractDateTime(ExprValue value,
         ? ((ExprTimeValue) value).datetimeValue(functionProperties)
         : value.datetimeValue();
   }
+
+  /**
+   * Extracts LocalDate from a datetime ExprValue.
+   * Uses `FunctionProperties` for `ExprTimeValue`.
+   */
+  public static LocalDate extractDate(ExprValue value,
+                                      FunctionProperties functionProperties) {
+    return value instanceof ExprTimeValue
+        ? ((ExprTimeValue) value).dateValue(functionProperties)
+        : value.dateValue();
+  }
 }

core/src/test/java/org/opensearch/sql/expression/datetime/DateDiffTest.java

@@ -0,0 +1,77 @@
+/*
+ * Copyright OpenSearch Contributors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+package org.opensearch.sql.expression.datetime;
+
+import static java.time.temporal.ChronoUnit.DAYS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.ZoneId;
+import java.time.temporal.Temporal;
+import java.util.TimeZone;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class DateDiffTest extends DateTimeTestBase {
+
+  private static final LocalTime timeSample1 = LocalTime.of(12, 42);
+  private static final LocalTime timeSample2 = LocalTime.of(7, 40);
+  private static final LocalDate dateSample1 = LocalDate.of(2022, 6, 6);
+  private static final LocalDate dateSample2 = LocalDate.of(1961, 4, 12);
+  private static final LocalDate dateSample3 = LocalDate.of(1993, 3, 4);
+  private static final LocalDate epochStart = LocalDate.of(1970, 1, 1);
+  private static final LocalDate dateNow = LocalDate.now();
+  private static final LocalDateTime dateTimeSample1 = LocalDateTime.of(1961, 4, 12, 9, 7);
+  private static final LocalDateTime dateTimeSample2 = LocalDateTime.of(1993, 3, 4, 5, 6);
+
+  // Function signature is:
+  // (DATE/DATETIME/TIMESTAMP/TIME, DATE/DATETIME/TIMESTAMP/TIME) -> LONG
+  private static Stream<Arguments> getTestData() {
+    // Arguments are: first argument for `DATE_DIFF` function, second argument and expected result.
+    return Stream.of(
+        Arguments.of(timeSample1, timeSample2, 0L),
+        Arguments.of(timeSample1, dateNow, 0L),
+        Arguments.of(timeSample1, LocalDateTime.now(), 0L),
+        Arguments.of(timeSample1,
+            Instant.now().plusMillis(TimeZone.getDefault().getRawOffset()), 0L),
+        Arguments.of(dateSample1, timeSample1,
+            -DAYS.between(dateSample1, dateNow)),
+        Arguments.of(dateSample1, dateSample3,
+            -DAYS.between(dateSample1, dateSample3)),
+        Arguments.of(dateSample1, dateTimeSample1,
+            -DAYS.between(dateSample1, dateSample2)),
+        Arguments.of(dateSample1, Instant.ofEpochSecond(42),
+            -DAYS.between(dateSample1, epochStart)),
+        Arguments.of(dateTimeSample1, LocalTime.now(),
+            -DAYS.between(dateSample2, dateNow)),
+        Arguments.of(dateTimeSample1, dateSample3,
+            -DAYS.between(dateSample2, dateSample3)),
+        Arguments.of(dateTimeSample1, dateTimeSample2,
+            -DAYS.between(dateSample2, dateSample3)),
+        Arguments.of(dateTimeSample1, Instant.ofEpochSecond(0),
+            -DAYS.between(dateSample2, epochStart)),
+        Arguments.of(Instant.ofEpochSecond(0), LocalTime.MAX,
+            -DAYS.between(epochStart, dateNow)),
+        Arguments.of(Instant.ofEpochSecond(0), dateSample3,
+            -DAYS.between(epochStart, dateSample3)),
+        Arguments.of(Instant.ofEpochSecond(0), dateTimeSample2,
+            -DAYS.between(epochStart, dateSample3)),
+        Arguments.of(Instant.ofEpochSecond(0), Instant.now(),
+            -DAYS.between(epochStart, LocalDateTime.now(ZoneId.of("UTC"))))
+      );
+  }
+
+  @ParameterizedTest
+  @MethodSource("getTestData")
+  public void try_different_data(Temporal arg1, Temporal arg2, Long expectedResult) {
+    assertEquals(expectedResult, datediff(arg1, arg2));
+  }
+}

core/src/test/java/org/opensearch/sql/expression/datetime/DateTimeTestBase.java

@@ -6,16 +6,19 @@
 package org.opensearch.sql.expression.datetime;
 
 import static org.opensearch.sql.data.model.ExprValueUtils.fromObjectValue;
+import static org.opensearch.sql.data.type.ExprCoreType.DOUBLE;
 
 import java.time.Instant;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.time.LocalTime;
+import java.time.temporal.Temporal;
 import java.util.List;
 import org.opensearch.sql.data.model.ExprDateValue;
 import org.opensearch.sql.data.model.ExprDatetimeValue;
 import org.opensearch.sql.data.model.ExprMissingValue;
 import org.opensearch.sql.data.model.ExprNullValue;
+import org.opensearch.sql.data.model.ExprTimeValue;
 import org.opensearch.sql.data.model.ExprTimestampValue;
 import org.opensearch.sql.data.model.ExprValue;
 import org.opensearch.sql.expression.DSL;
@@ -68,6 +71,17 @@ protected ExprValue date_sub(Object first, Object second) {
         .valueOf(null);
   }
 
+  protected FunctionExpression datediff(Expression first, Expression second) {
+    return (FunctionExpression) functionRepository.compile(
+        functionProperties,
+        BuiltinFunctionName.DATEDIFF.getName(), List.of(first, second));
+  }
+
+  protected Long datediff(Temporal first, Temporal second) {
+    return datediff(DSL.literal(fromObjectValue(first)), DSL.literal(fromObjectValue(second)))
+        .valueOf(null).longValue();
+  }
+
   protected LocalDateTime fromUnixTime(Double value) {
     return fromUnixTime(DSL.literal(value)).valueOf().datetimeValue();
   }
@@ -106,7 +120,6 @@ protected FunctionExpression maketime(Expression hour, Expression minute, Expres
             BuiltinFunctionName.MAKETIME.getName(), List.of(hour, minute, second));
   }
 
-
   protected LocalTime maketime(Double hour, Double minute, Double second) {
     return maketime(DSL.literal(hour), DSL.literal(minute), DSL.literal(second))
         .valueOf().timeValue();
@@ -154,6 +167,17 @@ protected ExprValue subdate(Object first, Object interval) {
         .valueOf(null);
   }
 
+  protected FunctionExpression timediff(Expression first, Expression second) {
+    return (FunctionExpression) functionRepository.compile(
+        functionProperties,
+        BuiltinFunctionName.TIMEDIFF.getName(), List.of(first, second));
+  }
+
+  protected LocalTime timediff(LocalTime first, LocalTime second) {
+    return timediff(DSL.literal(new ExprTimeValue(first)), DSL.literal(new ExprTimeValue(second)))
+        .valueOf(null).timeValue();
+  }
+
   protected FunctionExpression unixTimeStampExpr() {
     return (FunctionExpression) functionRepository.compile(
         functionProperties, BuiltinFunctionName.UNIX_TIMESTAMP.getName(), List.of());