Add implementation of now, sysdate, localtime and similar functions (#92)

Signed-off-by: Yury Fridlyand <[email protected]>

Author: Yury-Fridlyand

build.gradle

@@ -7,6 +7,8 @@
 buildscript {
     ext {
         opensearch_version = System.getProperty("opensearch.version", "2.2.0-SNAPSHOT")
+        spring_version = "5.3.22"
+        jackson_version = "2.13.3"
         isSnapshot = "true" == System.getProperty("build.snapshot", "true")
         buildVersionQualifier = System.getProperty("build.version_qualifier", "")
         version_tokens = opensearch_version.tokenize('-')

common/src/main/java/org/opensearch/sql/common/utils/LogUtils.java renamed to common/src/main/java/org/opensearch/sql/common/utils/QueryContext.java

@@ -6,20 +6,29 @@
 
 package org.opensearch.sql.common.utils;
 
+import java.time.LocalDateTime;
 import java.util.Map;
+import java.util.Optional;
 import java.util.UUID;
 import org.apache.logging.log4j.ThreadContext;
 
 /**
- * Utility class for generating/accessing the request id from logging context.
+ * Utility class for recording and accessing context for the query being executed.
+ * Implementation Details: context variables is being persisted statically in the thread context
+ * @see: @ThreadContext
  */
-public class LogUtils {
+public class QueryContext {
 
   /**
    * The key of the request id in the context map.
    */
   private static final String REQUEST_ID_KEY = "request_id";
 
+  /**
+   * Timestamp when SQL plugin started to process current request.
+   */
+  private static final String REQUEST_PROCESSING_STARTED = "request_processing_started";
+
   /**
    * Generates a random UUID and adds to the {@link ThreadContext} as the request id.
    * <p>
@@ -29,17 +38,38 @@ public class LogUtils {
    * call this method twice on the same thread within the lifetime of the request.
    * </p>
    */
-  public static void addRequestId() {
-    ThreadContext.put(REQUEST_ID_KEY, UUID.randomUUID().toString());
+  public static String addRequestId() {
+    var id = UUID.randomUUID().toString();
+    ThreadContext.put(REQUEST_ID_KEY, id);
+    return id;
   }
 
   /**
    * Get RequestID.
    * @return the current request id from {@link ThreadContext}.
    */
   public static String getRequestId() {
-    final String requestId = ThreadContext.get(REQUEST_ID_KEY);
-    return requestId;
+    var id = ThreadContext.get(REQUEST_ID_KEY);
+    if (null == id) {
+      id = addRequestId();
+    }
+    return id;
+  }
+
+  public static void recordProcessingStarted() {
+    ThreadContext.put(REQUEST_PROCESSING_STARTED, LocalDateTime.now().toString());
+  }
+
+  /**
+   * Get recorded previously time indicating when processing started for the current query.
+   * @return A LocalDateTime object
+   */
+  public static LocalDateTime getProcessingStartedTime() {
+    if (ThreadContext.containsKey(REQUEST_PROCESSING_STARTED)) {
+      return LocalDateTime.parse(ThreadContext.get(REQUEST_PROCESSING_STARTED));
+    }
+    // This shouldn't happen outside of unit tests
+    return LocalDateTime.now();
   }
 
   /**
@@ -57,7 +87,7 @@ public static Runnable withCurrentContext(final Runnable task) {
     };
   }
 
-  private LogUtils() {
+  private QueryContext() {
     throw new AssertionError(
         getClass().getCanonicalName() + " is a utility class and must not be initialized");
   }

core/build.gradle

@@ -40,16 +40,16 @@ repositories {
 
 dependencies {
     api group: 'com.google.guava', name: 'guava', version: '31.0.1-jre'
-    api group: 'org.springframework', name: 'spring-context', version: '5.3.22'
-    api group: 'org.springframework', name: 'spring-beans', version: '5.3.22'
+    api group: 'org.springframework', name: 'spring-context', version: "${spring_version}"
+    api group: 'org.springframework', name: 'spring-beans', version: "${spring_version}"
     api group: 'org.apache.commons', name: 'commons-lang3', version: '3.10'
     api group: 'com.facebook.presto', name: 'presto-matching', version: '0.240'
     api group: 'org.apache.commons', name: 'commons-math3', version: '3.6.1'
     api project(':common')
 
     testImplementation('org.junit.jupiter:junit-jupiter:5.6.2')
     testImplementation group: 'org.hamcrest', name: 'hamcrest-library', version: '2.1'
-    testImplementation group: 'org.springframework', name: 'spring-test', version: '5.3.22'
+    testImplementation group: 'org.springframework', name: 'spring-test', version: "${spring_version}"
     testImplementation group: 'org.mockito', name: 'mockito-core', version: '3.12.4'
     testImplementation group: 'org.mockito', name: 'mockito-junit-jupiter', version: '3.12.4'
 }

core/src/main/java/org/opensearch/sql/expression/DSL.java

@@ -682,6 +682,42 @@ public FunctionExpression match_bool_prefix(Expression... args) {
     return compile(BuiltinFunctionName.MATCH_BOOL_PREFIX, args);
   }
 
+  public FunctionExpression now(Expression... args) {
+    return compile(BuiltinFunctionName.NOW, args);
+  }
+
+  public FunctionExpression current_timestamp(Expression... args) {
+    return compile(BuiltinFunctionName.CURRENT_TIMESTAMP, args);
+  }
+
+  public FunctionExpression localtimestamp(Expression... args) {
+    return compile(BuiltinFunctionName.LOCALTIMESTAMP, args);
+  }
+
+  public FunctionExpression localtime(Expression... args) {
+    return compile(BuiltinFunctionName.LOCALTIME, args);
+  }
+
+  public FunctionExpression sysdate(Expression... args) {
+    return compile(BuiltinFunctionName.SYSDATE, args);
+  }
+
+  public FunctionExpression curtime(Expression... args) {
+    return compile(BuiltinFunctionName.CURTIME, args);
+  }
+
+  public FunctionExpression current_time(Expression... args) {
+    return compile(BuiltinFunctionName.CURRENT_TIME, args);
+  }
+
+  public FunctionExpression curdate(Expression... args) {
+    return compile(BuiltinFunctionName.CURDATE, args);
+  }
+
+  public FunctionExpression current_date(Expression... args) {
+    return compile(BuiltinFunctionName.CURRENT_DATE, args);
+  }
+
   private FunctionExpression compile(BuiltinFunctionName bfn, Expression... args) {
     return (FunctionExpression) repository.compile(bfn.getName(), Arrays.asList(args.clone()));
   }

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

@@ -18,11 +18,17 @@
 import static org.opensearch.sql.expression.function.FunctionDSL.impl;
 import static org.opensearch.sql.expression.function.FunctionDSL.nullMissingHandling;
 
+import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.time.LocalDate;
+import java.time.LocalDateTime;
 import java.time.format.TextStyle;
 import java.util.Locale;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
+import javax.annotation.Nullable;
 import lombok.experimental.UtilityClass;
+import org.opensearch.sql.common.utils.QueryContext;
 import org.opensearch.sql.data.model.ExprDateValue;
 import org.opensearch.sql.data.model.ExprDatetimeValue;
 import org.opensearch.sql.data.model.ExprIntegerValue;
@@ -78,6 +84,89 @@ public void register(BuiltinFunctionRepository repository) {
     repository.register(to_days());
     repository.register(week());
     repository.register(year());
+
+    repository.register(now());
+    repository.register(current_timestamp());
+    repository.register(localtimestamp());
+    repository.register(localtime());
+    repository.register(sysdate());
+    repository.register(curtime());
+    repository.register(current_time());
+    repository.register(curdate());
+    repository.register(current_date());
+  }
+
+  /**
+   * NOW() returns a constant time that indicates the time at which the statement began to execute.
+   */
+  private LocalDateTime now(@Nullable Integer fsp) {
+    return formatLocalDateTime(QueryContext::getProcessingStartedTime, fsp);
+  }
+
+  private FunctionResolver now(FunctionName functionName) {
+    return define(functionName,
+        impl(() -> new ExprDatetimeValue(now((Integer)null)), DATETIME),
+        impl((v) -> new ExprDatetimeValue(now(v.integerValue())), DATETIME, INTEGER)
+    );
+  }
+
+  private FunctionResolver now() {
+    return now(BuiltinFunctionName.NOW.getName());
+  }
+
+  private FunctionResolver current_timestamp() {
+    return now(BuiltinFunctionName.CURRENT_TIMESTAMP.getName());
+  }
+
+  private FunctionResolver localtimestamp() {
+    return now(BuiltinFunctionName.LOCALTIMESTAMP.getName());
+  }
+
+  private FunctionResolver localtime() {
+    return now(BuiltinFunctionName.LOCALTIME.getName());
+  }
+
+  /**
+   * SYSDATE() returns the time at which it executes.
+   */
+  private LocalDateTime sysDate(@Nullable Integer fsp) {
+    return formatLocalDateTime(LocalDateTime::now, fsp);
+  }
+
+  private FunctionResolver sysdate() {
+    return define(BuiltinFunctionName.SYSDATE.getName(),
+        impl(() -> new ExprDatetimeValue(sysDate(null)), DATETIME),
+        impl((v) -> new ExprDatetimeValue(sysDate(v.integerValue())), DATETIME, INTEGER)
+    );
+  }
+
+  private FunctionResolver curtime(FunctionName functionName) {
+    return define(functionName,
+        impl(() -> new ExprTimeValue(sysDate(null).toLocalTime()), TIME),
+        impl((v) -> new ExprTimeValue(sysDate(v.integerValue()).toLocalTime()), TIME, INTEGER)
+    );
+  }
+
+  private FunctionResolver curtime() {
+    return curtime(BuiltinFunctionName.CURTIME.getName());
+  }
+
+  private FunctionResolver current_time() {
+    return curtime(BuiltinFunctionName.CURRENT_TIME.getName());
+  }
+
+  private FunctionResolver curdate(FunctionName functionName) {
+    return define(functionName,
+        impl(() -> new ExprDateValue(sysDate(null).toLocalDate()), DATE)
+    );
+  }
+
+  private FunctionResolver curdate() {
+    return curdate(BuiltinFunctionName.CURDATE.getName());
+  }
+
+  private FunctionResolver current_date() {
+    return curdate(BuiltinFunctionName.CURRENT_DATE.getName());
   }
 
   /**
@@ -108,6 +197,10 @@ private FunctionResolver adddate() {
     return add_date(BuiltinFunctionName.ADDDATE.getName());
   }
 
+  private FunctionResolver date_add() {
+    return add_date(BuiltinFunctionName.DATE_ADD.getName());
+  }
+
   /**
    * Extracts the date part of a date and time value.
    * Also to construct a date type. The supported signatures:
@@ -121,10 +214,6 @@ private FunctionResolver date() {
         impl(nullMissingHandling(DateTimeFunction::exprDate), DATE, TIMESTAMP));
   }
 
-  private FunctionResolver date_add() {
-    return add_date(BuiltinFunctionName.DATE_ADD.getName());
-  }
-
   /**
    * Specify a start date and subtract a temporal amount to the date.
    * The return type depends on the date type and the interval unit. Detailed supported signatures:
@@ -679,4 +768,26 @@ private ExprValue exprYear(ExprValue date) {
     return new ExprIntegerValue(date.dateValue().getYear());
   }
 
+  /**
+   * Prepare LocalDateTime value.
+   * @param supplier A function which returns LocalDateTime to format.
+   * @param fsp argument is given to specify a fractional seconds precision from 0 to 6,
+   *            the return value includes a fractional seconds part of that many digits.
+   * @return LocalDateTime object.
+   */
+  private LocalDateTime formatLocalDateTime(Supplier<LocalDateTime> supplier,
+                                            @Nullable Integer fsp) {
+    var res = supplier.get();
+    if (fsp == null) {
+      return res;
+    }
+    var defaultPrecision = 9; // There are 10^9 nanoseconds in one second
+    if (fsp < 0 || fsp > 6) { // Check that the argument is in the allowed range [0, 6]
+      throw new IllegalArgumentException(
+          String.format("Invalid `fsp` value: %d, allowed 0 to 6", fsp));
+    }
+    var nano = new BigDecimal(res.getNano())
+        .setScale(fsp - defaultPrecision, RoundingMode.DOWN).intValue();
+    return res.withNano(nano);
+  }
 }

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

@@ -82,7 +82,16 @@ public enum BuiltinFunctionName {
   TO_DAYS(FunctionName.of("to_days")),
   WEEK(FunctionName.of("week")),
   YEAR(FunctionName.of("year")),
-
+  // `now`-like functions
+  NOW(FunctionName.of("now")),
+  CURDATE(FunctionName.of("curdate")),
+  CURRENT_DATE(FunctionName.of("current_date")),
+  CURTIME(FunctionName.of("curtime")),
+  CURRENT_TIME(FunctionName.of("current_time")),
+  LOCALTIME(FunctionName.of("localtime")),
+  CURRENT_TIMESTAMP(FunctionName.of("current_timestamp")),
+  LOCALTIMESTAMP(FunctionName.of("localtimestamp")),
+  SYSDATE(FunctionName.of("sysdate")),
   /**
    * Text Functions.
    */

core/src/main/java/org/opensearch/sql/planner/logical/LogicalPlanDSL.java

@@ -18,7 +18,6 @@
 import org.opensearch.sql.expression.Expression;
 import org.opensearch.sql.expression.LiteralExpression;
 import org.opensearch.sql.expression.NamedExpression;
-import org.opensearch.sql.expression.ParseExpression;
 import org.opensearch.sql.expression.ReferenceExpression;
 import org.opensearch.sql.expression.aggregation.NamedAggregator;
 import org.opensearch.sql.expression.window.WindowDefinition;