Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.facebook.presto.util;
 
 
 import java.util.List;
 
 import static com.facebook.presto.spi.type.DateTimeEncoding.unpackMillisUtc;
 import static com.facebook.presto.util.DateTimeZoneIndex.getDateTimeZone;
 import static com.facebook.presto.util.DateTimeZoneIndex.packDateTimeWithZone;
 import static com.facebook.presto.util.DateTimeZoneIndex.unpackDateTimeZone;
 
 public final class DateTimeUtils
 {
     private DateTimeUtils()
     {
     }
 
     private static final DateTimeFormatter DATE_FORMATTER = ISODateTimeFormat.date().withZoneUTC();
 
     public static int parseDate(String value)
     {
         return (int..toDays(.parseMillis(value));
     }
 
     public static String printDate(int days)
     {
         return .print(..toMillis(days));
     }
 
     private static final DateTimeFormatter TIMESTAMP_FORMATTER;
     private static final DateTimeFormatter TIMESTAMP_WITH_TIME_ZONE_FORMATTER;
 
     static {
         DateTimeParser[] timestampWithoutTimeZoneParser = {
                 DateTimeFormat.forPattern("yyyy-M-d").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s.SSS").getParser()};
         DateTimePrinter timestampWithoutTimeZonePrinter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.SSS").getPrinter();
          = new DateTimeFormatterBuilder().append(timestampWithoutTimeZonePrintertimestampWithoutTimeZoneParser).toFormatter().withZoneUTC();
 
         DateTimeParser[] timestampWithTimeZoneParser = {
                 DateTimeFormat.forPattern("yyyy-M-dZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d Z").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:mZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m Z").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:sZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s Z").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s.SSSZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s.SSS Z").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-dZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d ZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:mZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m ZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:sZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s ZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s.SSSZZZ").getParser(),
                 DateTimeFormat.forPattern("yyyy-M-d H:m:s.SSS ZZZ").getParser()};
         DateTimePrinter timestampWithTimeZonePrinter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss.SSS ZZZ").getPrinter();
          = new DateTimeFormatterBuilder().append(timestampWithTimeZonePrintertimestampWithTimeZoneParser).toFormatter().withOffsetParsed();
     }
 
     public static long parseTimestamp(TimeZoneKey timeZoneKeyString value)
     {
         try {
             return parseTimestampWithTimeZone(value);
        }
        catch (Exception e) {
            return parseTimestampWithoutTimeZone(timeZoneKeyvalue);
        }
    }
    public static long parseTimestampWithTimeZone(String timestampWithTimeZone)
    {
        DateTime dateTime = .parseDateTime(timestampWithTimeZone);
        return packDateTimeWithZone(dateTime);
    }
    public static long parseTimestampWithoutTimeZone(TimeZoneKey timeZoneKeyString value)
    {
        return .withZone(getDateTimeZone(timeZoneKey)).parseMillis(value);
    }
    public static String printTimestampWithTimeZone(long timestampWithTimeZone)
    {
        DateTimeZone timeZone = unpackDateTimeZone(timestampWithTimeZone);
        long millis = unpackMillisUtc(timestampWithTimeZone);
        return .withZone(timeZone).print(millis);
    }
    public static String printTimestampWithoutTimeZone(TimeZoneKey timeZoneKeylong timestamp)
    {
        return .withZone(getDateTimeZone(timeZoneKey)).print(timestamp);
    }
    public static boolean timestampHasTimeZone(String value)
    {
        try {
            parseTimestampWithTimeZone(value);
            return true;
        }
        catch (Exception e) {
            return false;
        }
    }
    private static final DateTimeFormatter TIME_FORMATTER;
    private static final DateTimeFormatter TIME_WITH_TIME_ZONE_FORMATTER;
    static {
        DateTimeParser[] timeWithoutTimeZoneParser = {
                DateTimeFormat.forPattern("H:m").getParser(),
                DateTimeFormat.forPattern("H:m:s").getParser(),
                DateTimeFormat.forPattern("H:m:s.SSS").getParser()};
        DateTimePrinter timeWithoutTimeZonePrinter = DateTimeFormat.forPattern("HH:mm:ss.SSS").getPrinter();
         = new DateTimeFormatterBuilder().append(timeWithoutTimeZonePrintertimeWithoutTimeZoneParser).toFormatter().withZoneUTC();
        DateTimeParser[] timeWithTimeZoneParser = {
                DateTimeFormat.forPattern("H:mZ").getParser(),
                DateTimeFormat.forPattern("H:m Z").getParser(),
                DateTimeFormat.forPattern("H:m:sZ").getParser(),
                DateTimeFormat.forPattern("H:m:s Z").getParser(),
                DateTimeFormat.forPattern("H:m:s.SSSZ").getParser(),
                DateTimeFormat.forPattern("H:m:s.SSS Z").getParser(),
                DateTimeFormat.forPattern("H:mZZZ").getParser(),
                DateTimeFormat.forPattern("H:m ZZZ").getParser(),
                DateTimeFormat.forPattern("H:m:sZZZ").getParser(),
                DateTimeFormat.forPattern("H:m:s ZZZ").getParser(),
                DateTimeFormat.forPattern("H:m:s.SSSZZZ").getParser(),
                DateTimeFormat.forPattern("H:m:s.SSS ZZZ").getParser()};
        DateTimePrinter timeWithTimeZonePrinter = DateTimeFormat.forPattern("HH:mm:ss.SSS ZZZ").getPrinter();
         = new DateTimeFormatterBuilder().append(timeWithTimeZonePrintertimeWithTimeZoneParser).toFormatter().withOffsetParsed();
    }
    public static long parseTime(TimeZoneKey timeZoneKeyString value)
    {
        try {
            return parseTimeWithTimeZone(value);
        }
        catch (Exception e) {
            return parseTimeWithoutTimeZone(timeZoneKeyvalue);
        }
    }
    public static long parseTimeWithTimeZone(String timeWithTimeZone)
    {
        DateTime dateTime = .parseDateTime(timeWithTimeZone);
        return packDateTimeWithZone(dateTime);
    }
    public static long parseTimeWithoutTimeZone(TimeZoneKey timeZoneKeyString value)
    {
        return .withZone(getDateTimeZone(timeZoneKey)).parseMillis(value);
    }
    public static String printTimeWithTimeZone(long timeWithTimeZone)
    {
        DateTimeZone timeZone = unpackDateTimeZone(timeWithTimeZone);
        long millis = unpackMillisUtc(timeWithTimeZone);
        return .withZone(timeZone).print(millis);
    }
    public static String printTimeWithoutTimeZone(TimeZoneKey timeZoneKeylong value)
    {
        return .withZone(getDateTimeZone(timeZoneKey)).print(value);
    }
    public static boolean timeHasTimeZone(String value)
    {
        try {
            parseTimeWithTimeZone(value);
            return true;
        }
        catch (Exception e) {
            return false;
        }
    }
    private static final int YEAR_FIELD = 0;
    private static final int MONTH_FIELD = 1;
    private static final int DAY_FIELD = 3;
    private static final int HOUR_FIELD = 4;
    private static final int MINUTE_FIELD = 5;
    private static final int SECOND_FIELD = 6;
    private static final int MILLIS_FIELD = 7;
    public static long parseDayTimeInterval(String valueIntervalField startFieldOptional<IntervalFieldendField)
    {
        IntervalField end = endField.orElse(startField);
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMillis(valuestartFieldend);
        }
        throw new IllegalArgumentException("Invalid day second interval qualifier: " + startField + " to " + end);
    }
    public static long parsePeriodMillis(PeriodFormatter periodFormatterString valueIntervalField startFieldIntervalField endField)
    {
        Period period = parsePeriod(periodFormattervaluestartFieldendField);
        return SqlIntervalDayTime.toMillis(
                period.getValue(),
                period.getValue(),
                period.getValue(),
                period.getValue(),
                period.getValue());
    }
    public static String printDayTimeInterval(long millis)
    {
        return SqlIntervalDayTime.formatMillis(millis);
    }
    public static long parseYearMonthInterval(String valueIntervalField startFieldOptional<IntervalFieldendField)
    {
        IntervalField end = endField.orElse(startField);
        if (startField == . && end == .) {
            PeriodFormatter periodFormatter = ;
            return parsePeriodMonths(valueperiodFormatterstartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMonths(valuestartFieldend);
        }
        if (startField == . && end == .) {
            return parsePeriodMonths(valuestartFieldend);
        }
        throw new IllegalArgumentException("Invalid year month interval qualifier: " + startField + " to " + end);
    }
    private static long parsePeriodMonths(String valuePeriodFormatter periodFormatterIntervalField startFieldIntervalField endField)
    {
        Period period = parsePeriod(periodFormattervaluestartFieldendField);
        return period.getValue() * 12 +
                period.getValue();
    }
    public static String printYearMonthInterval(long months)
    {
        return (months / 12) + "-" + (months % 12);
    }
    private static Period parsePeriod(PeriodFormatter periodFormatterString valueIntervalField startFieldIntervalField endField)
    {
        try {
            return periodFormatter.parsePeriod(value);
        }
        catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid INTERVAL " + startField + " to " + endField + " value: " + valuee);
        }
    }
    private static PeriodFormatter cretePeriodFormatter(IntervalField startFieldIntervalField endField)
    {
        if (endField == null) {
            endField = startField;
        }
        List<PeriodParserparsers = new ArrayList<>();
        PeriodFormatterBuilder builder = new PeriodFormatterBuilder();
        //CHECKSTYLE.OFF
        switch (startField) {
            case :
                builder.appendYears();
                parsers.add(builder.toParser());
                if (endField == .) {
                    break;
                }
                builder.appendLiteral("-");
            case :
                builder.appendMonths();
                parsers.add(builder.toParser());
                if (endField != .) {
                    throw new IllegalArgumentException("Invalid interval qualifier: " + startField + " to " + endField);
                }
                break;
            case :
                builder.appendDays();
                parsers.add(builder.toParser());
                if (endField == .) {
                    break;
                }
                builder.appendLiteral(" ");
            case :
                builder.appendHours();
                parsers.add(builder.toParser());
                if (endField == .) {
                    break;
                }
                builder.appendLiteral(":");
            case :
                builder.appendMinutes();
                parsers.add(builder.toParser());
                if (endField == .) {
                    break;
                }
                builder.appendLiteral(":");
            case :
                builder.appendSecondsWithOptionalMillis();
                parsers.add(builder.toParser());
        }
        //CHECKSTYLE.ON
        return new PeriodFormatter(builder.toPrinter(), new OrderedPeriodParser(parsers));
    }
    private static class OrderedPeriodParser
            implements PeriodParser
    {
        private final List<PeriodParserparsers;
        private OrderedPeriodParser(List<PeriodParserparsers)
        {
            this. = parsers;
        }
        @Override
        public int parseInto(ReadWritablePeriod periodString textint positionLocale locale)
        {
            int bestValidPos = position;
            ReadWritablePeriod bestValidPeriod = null;
            int bestInvalidPos = position;
            for (PeriodParser parser : ) {
                ReadWritablePeriod parsedPeriod = new MutablePeriod();
                int parsePos = parser.parseInto(parsedPeriodtextpositionlocale);
                if (parsePos >= position) {
                    if (parsePos > bestValidPos) {
                        bestValidPos = parsePos;
                        bestValidPeriod = parsedPeriod;
                        if (parsePos >= text.length()) {
                            break;
                        }
                    }
                }
                else if (parsePos < 0) {
                    parsePos = ~parsePos;
                    if (parsePos > bestInvalidPos) {
                        bestInvalidPos = parsePos;
                    }
                }
            }
            if (bestValidPos > position || (bestValidPos == position)) {
                // Restore the state to the best valid parse.
                if (bestValidPeriod != null) {
                    period.setPeriod(bestValidPeriod);
                }
                return bestValidPos;
            }
            return ~bestInvalidPos;
        }
    }
New to GrepCode? Check out our FAQ X