Extend the date rounding logic to be conditional

Date rounding logic should take into account the fields that will be
parsed be a parser. If a parser has a DayOfYear field, the rounding logic
should not try to default DayOfMonth as it will conflict with DayOfYear

However the DateTimeFormatter does not have a public method to return
information of fields that will be parsed. The hacky workaround is
to rely on toString() implementation that will return a field info when
it was defined with textual pattern.

This commits introduced conditional logic for DayOfYear, ClockHourOfAMPM and HourOfAmPM

closes elastic#89096
closes elastic#58986

Author: pgomulka

server/src/main/java/org/elasticsearch/common/time/EpochTime.java

@@ -252,15 +252,15 @@ public long getFrom(TemporalAccessor temporal) {
     static final DateFormatter SECONDS_FORMATTER = new JavaDateFormatter(
         "epoch_second",
         SECONDS_FORMATTER1,
-        builder -> builder.parseDefaulting(ChronoField.NANO_OF_SECOND, 999_999_999L),
+        (builder, parser) -> builder.parseDefaulting(ChronoField.NANO_OF_SECOND, 999_999_999L),
         SECONDS_FORMATTER1,
         SECONDS_FORMATTER2
     );
 
     static final DateFormatter MILLIS_FORMATTER = new JavaDateFormatter(
         "epoch_millis",
         MILLISECONDS_FORMATTER1,
-        builder -> builder.parseDefaulting(EpochTime.NANOS_OF_MILLI, 999_999L),
+        (builder, parser) -> builder.parseDefaulting(EpochTime.NANOS_OF_MILLI, 999_999L),
         MILLISECONDS_FORMATTER1,
         MILLISECONDS_FORMATTER2
     );

server/src/main/java/org/elasticsearch/common/time/JavaDateFormatter.java

@@ -22,10 +22,43 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Objects;
-import java.util.function.Consumer;
+import java.util.function.BiConsumer;
 import java.util.function.UnaryOperator;
 
 class JavaDateFormatter implements DateFormatter {
+    /**
+    * A default consumer that allows to round up fields (used for range searches, optional fields missing)
+    * it relies on toString implementation of DateTimeFormatter and ChronoField.
+    * For instance for pattern
+    * the parser would have a toString()
+    * <code>
+    *  Value(MonthOfYear,2)'/'Value(DayOfMonth,2)'/'Value(YearOfEra,4,19,EXCEEDS_PAD)'
+    * 'Value(ClockHourOfAmPm,2)':'Value(MinuteOfHour,2)' 'Text(AmPmOfDay,SHORT)
+    * </code>
+    * and ChronoField.CLOCK_HOUR_OF_AMPM would have toString() ClockHourOfAmPm
+    * this allows the rounding logic to default CLOCK_HOUR_OF_AMPM field instead of HOUR_OF_DAY
+    * without this logic, the rounding would result in a conflict as HOUR_OF_DAY would be missing, but CLOCK_HOUR_OF_AMPM would be provided
+    */
+    private static final BiConsumer<DateTimeFormatterBuilder, DateTimeFormatter> DEFAULT_ROUND_UP = (builder, parser) -> {
+        if (parser.toString().contains(ChronoField.DAY_OF_YEAR.toString())) {
+            builder.parseDefaulting(ChronoField.DAY_OF_YEAR, 1L);
+        } else {
+            builder.parseDefaulting(ChronoField.MONTH_OF_YEAR, 1L);
+            builder.parseDefaulting(ChronoField.DAY_OF_MONTH, 1L);
+        }
+        if (parser.toString().contains(ChronoField.CLOCK_HOUR_OF_AMPM.toString())) {
+            builder.parseDefaulting(ChronoField.CLOCK_HOUR_OF_AMPM, 11L);
+            builder.parseDefaulting(ChronoField.AMPM_OF_DAY, 1L);
+        } else if (parser.toString().contains(ChronoField.HOUR_OF_AMPM.toString())) {
+            builder.parseDefaulting(ChronoField.HOUR_OF_AMPM, 11L);
+            builder.parseDefaulting(ChronoField.AMPM_OF_DAY, 1L);
+        } else {
+            builder.parseDefaulting(ChronoField.HOUR_OF_DAY, 23L);
+        }
+        builder.parseDefaulting(ChronoField.MINUTE_OF_HOUR, 59L);
+        builder.parseDefaulting(ChronoField.SECOND_OF_MINUTE, 59L);
+        builder.parseDefaulting(ChronoField.NANO_OF_SECOND, 999_999_999L);
+    };
 
     private final String format;
     private final DateTimeFormatter printer;
@@ -50,12 +83,7 @@ JavaDateFormatter getRoundupParser() {
             format,
             printer,
             // set up base fields which should be used for default parsing, when we round up for date math
-            builder -> builder.parseDefaulting(ChronoField.MONTH_OF_YEAR, 1L)
-                .parseDefaulting(ChronoField.DAY_OF_MONTH, 1L)
-                .parseDefaulting(ChronoField.HOUR_OF_DAY, 23L)
-                .parseDefaulting(ChronoField.MINUTE_OF_HOUR, 59L)
-                .parseDefaulting(ChronoField.SECOND_OF_MINUTE, 59L)
-                .parseDefaulting(ChronoField.NANO_OF_SECOND, 999_999_999L),
+            DEFAULT_ROUND_UP,
             parsers
         );
     }
@@ -64,7 +92,7 @@ JavaDateFormatter getRoundupParser() {
     JavaDateFormatter(
         String format,
         DateTimeFormatter printer,
-        Consumer<DateTimeFormatterBuilder> roundupParserConsumer,
+        BiConsumer<DateTimeFormatterBuilder, DateTimeFormatter> roundupParserConsumer,
         DateTimeFormatter... parsers
     ) {
         if (printer == null) {
@@ -105,15 +133,15 @@ private static DateTimeFormatter[] parsersArray(DateTimeFormatter printer, DateT
      */
     private static RoundUpFormatter createRoundUpParser(
         String format,
-        Consumer<DateTimeFormatterBuilder> roundupParserConsumer,
+        BiConsumer<DateTimeFormatterBuilder, DateTimeFormatter> roundupParserConsumer,
         Locale locale,
         DateTimeFormatter[] parsers
     ) {
         if (format.contains("||") == false) {
             return new RoundUpFormatter(format, mapParsers(parser -> {
                 DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
                 builder.append(parser);
-                roundupParserConsumer.accept(builder);
+                roundupParserConsumer.accept(builder, parser);
                 return builder.toFormatter(locale);
             }, parsers));
         }

server/src/test/java/org/elasticsearch/common/time/JavaDateMathParserTests.java

@@ -85,6 +85,32 @@ public void testOverridingLocaleOrZoneAndCompositeRoundUpParser() {
         assertDateEquals(gotMillis, "297276785531", "297276785531");
     }
 
+    public void testDayOfYear() {
+        DateFormatter formatter = DateFormatter.forPattern("yyyy-DDD'T'HH:mm:ss.SSS");
+        assertDateMathEquals(formatter.toDateMathParser(), "2022-104T14:08:30.293", "2022-04-14T14:08:30.293", 0, true, ZoneOffset.UTC);
+    }
+
+    public void testDayOfYearWithMissingFields() {
+        DateFormatter formatter = DateFormatter.forPattern("yyyy[-DDD'T'HH:mm:ss.SSS]");
+        assertDateMathEquals(formatter.toDateMathParser(), "2022", "2022-01-01T23:59:59.999Z", 0, true, ZoneOffset.UTC);
+    }
+
+    public void testAMPM() {
+        DateFormatter formatter = DateFormatter.forPattern("MM/dd/yyyy hh:mm a"); // h clock-hour-of-am-pm (1-12)
+        assertDateMathEquals(formatter.toDateMathParser(), "04/30/2020 12:48 AM", "2020-04-30T00:48:59.999Z", 0, true, ZoneOffset.UTC);
+
+        formatter = DateFormatter.forPattern("MM/dd/yyyy KK:mm a"); // K hour-of-am-pm (0-11)
+        assertDateMathEquals(formatter.toDateMathParser(), "04/30/2020 00:48 AM", "2020-04-30T00:48:59.999Z", 0, true, ZoneOffset.UTC);
+    }
+
+    public void testAMPMWithTimeMissing() {
+        DateFormatter formatter = DateFormatter.forPattern("MM/dd/yyyy[ hh:mm a]"); // h clock-hour-of-am-pm (1-12)
+        assertDateMathEquals(formatter.toDateMathParser(), "04/30/2020", "2020-04-30T23:59:59.999Z", 0, true, ZoneOffset.UTC);
+
+        formatter = DateFormatter.forPattern("MM/dd/yyyy[ KK:mm a]"); // K hour-of-am-pm (0-11)
+        assertDateMathEquals(formatter.toDateMathParser(), "04/30/2020", "2020-04-30T23:59:59.999Z", 0, true, ZoneOffset.UTC);
+    }
+
     public void testWeekDates() {
         DateFormatter formatter = DateFormatter.forPattern("YYYY-ww");
         assertDateMathEquals(formatter.toDateMathParser(), "2016-01", "2016-01-04T23:59:59.999Z", 0, true, ZoneOffset.UTC);