Examples with DateTimeFormatterBuilder org.joda.time.format.DateTimeFormatterBuilder used on opensource projects

Example 6 with DateTimeFormatterBuilder

use of org.joda.time.format.DateTimeFormatterBuilder in project presto by prestodb.

the class DateTimeFunctions method createDateTimeFormatter.

@SuppressWarnings("fallthrough")
public static DateTimeFormatter createDateTimeFormatter(Slice format) {
    DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
    String formatString = format.toStringUtf8();
    boolean escaped = false;
    for (int i = 0; i < formatString.length(); i++) {
        char character = formatString.charAt(i);
        if (escaped) {
            switch(character) {
                case // %a Abbreviated weekday name (Sun..Sat)
                'a':
                    builder.appendDayOfWeekShortText();
                    break;
                case // %b Abbreviated month name (Jan..Dec)
                'b':
                    builder.appendMonthOfYearShortText();
                    break;
                case // %c Month, numeric (0..12)
                'c':
                    builder.appendMonthOfYear(1);
                    break;
                case // %d Day of the month, numeric (00..31)
                'd':
                    builder.appendDayOfMonth(2);
                    break;
                case // %e Day of the month, numeric (0..31)
                'e':
                    builder.appendDayOfMonth(1);
                    break;
                case // %f Microseconds (000000..999999)
                'f':
                    builder.appendFractionOfSecond(6, 9);
                    break;
                case // %H Hour (00..23)
                'H':
                    builder.appendHourOfDay(2);
                    break;
                // %h Hour (01..12)
                case 'h':
                case // %I Hour (01..12)
                'I':
                    builder.appendClockhourOfHalfday(2);
                    break;
                case // %i Minutes, numeric (00..59)
                'i':
                    builder.appendMinuteOfHour(2);
                    break;
                case // %j Day of year (001..366)
                'j':
                    builder.appendDayOfYear(3);
                    break;
                case // %k Hour (0..23)
                'k':
                    builder.appendHourOfDay(1);
                    break;
                case // %l Hour (1..12)
                'l':
                    builder.appendClockhourOfHalfday(1);
                    break;
                case // %M Month name (January..December)
                'M':
                    builder.appendMonthOfYearText();
                    break;
                case // %m Month, numeric (00..12)
                'm':
                    builder.appendMonthOfYear(2);
                    break;
                case // %p AM or PM
                'p':
                    builder.appendHalfdayOfDayText();
                    break;
                case // %r Time, 12-hour (hh:mm:ss followed by AM or PM)
                'r':
                    builder.appendClockhourOfHalfday(2).appendLiteral(':').appendMinuteOfHour(2).appendLiteral(':').appendSecondOfMinute(2).appendLiteral(' ').appendHalfdayOfDayText();
                    break;
                // %S Seconds (00..59)
                case 'S':
                case // %s Seconds (00..59)
                's':
                    builder.appendSecondOfMinute(2);
                    break;
                case // %T Time, 24-hour (hh:mm:ss)
                'T':
                    builder.appendHourOfDay(2).appendLiteral(':').appendMinuteOfHour(2).appendLiteral(':').appendSecondOfMinute(2);
                    break;
                case // %v Week (01..53), where Monday is the first day of the week; used with %x
                'v':
                    builder.appendWeekOfWeekyear(2);
                    break;
                case // %x Year for the week, where Monday is the first day of the week, numeric, four digits; used with %v
                'x':
                    builder.appendWeekyear(4, 4);
                    break;
                case // %W Weekday name (Sunday..Saturday)
                'W':
                    builder.appendDayOfWeekText();
                    break;
                case // %Y Year, numeric, four digits
                'Y':
                    builder.appendYear(4, 4);
                    break;
                case // %y Year, numeric (two digits)
                'y':
                    builder.appendTwoDigitYear(PIVOT_YEAR);
                    break;
                // %w Day of the week (0=Sunday..6=Saturday)
                case 'w':
                // %U Week (00..53), where Sunday is the first day of the week
                case 'U':
                // %u Week (00..53), where Monday is the first day of the week
                case 'u':
                // %V Week (01..53), where Sunday is the first day of the week; used with %X
                case 'V':
                // %X Year for the week where Sunday is the first day of the week, numeric, four digits; used with %V
                case 'X':
                case // %D Day of the month with English suffix (0th, 1st, 2nd, 3rd, …)
                'D':
                    throw new PrestoException(INVALID_FUNCTION_ARGUMENT, String.format("%%%s not supported in date format string", character));
                case // %% A literal “%” character
                '%':
                    builder.appendLiteral('%');
                    break;
                default:
                    // %<x> The literal character represented by <x>
                    builder.appendLiteral(character);
                    break;
            }
            escaped = false;
        } else if (character == '%') {
            escaped = true;
        } else {
            builder.appendLiteral(character);
        }
    }
    try {
        return builder.toFormatter();
    } catch (UnsupportedOperationException e) {
        throw new PrestoException(INVALID_FUNCTION_ARGUMENT, e);
    }
}

Example 7 with DateTimeFormatterBuilder

use of org.joda.time.format.DateTimeFormatterBuilder in project ETSMobile-Android2 by ApplETS.

the class Helper method ConvertFromWebService.

public static DateTime ConvertFromWebService(String strDate) {
    DateTimeFormatter parser1 = new DateTimeFormatterBuilder().append(ISODateTimeFormat.date()).appendLiteral('T').append(ISODateTimeFormat.hourMinuteSecond()).appendOptional(fractionElement()).appendOptional(offsetElement()).toFormatter().withZone(DateTimeZone.UTC);
    parser1.withChronology(ISOChronology.getInstanceUTC());
    return parser1.parseDateTime(strDate);
}

Example 8 with DateTimeFormatterBuilder

use of org.joda.time.format.DateTimeFormatterBuilder in project druid by druid-io.

the class TimestampParseExprMacro method createDefaultParser.

/**
 * Default formatter that parses according to the docs for this method: "If the pattern is not provided, this parses
 * time strings in either ISO8601 or SQL format."
 */
private static DateTimes.UtcFormatter createDefaultParser(final DateTimeZone timeZone) {
    final DateTimeFormatter offsetElement = new DateTimeFormatterBuilder().appendTimeZoneOffset("Z", true, 2, 4).toFormatter();
    DateTimeParser timeOrOffset = new DateTimeFormatterBuilder().append(null, new DateTimeParser[] { new DateTimeFormatterBuilder().appendLiteral('T').toParser(), new DateTimeFormatterBuilder().appendLiteral(' ').toParser() }).appendOptional(ISODateTimeFormat.timeElementParser().getParser()).appendOptional(offsetElement.getParser()).toParser();
    return DateTimes.wrapFormatter(new DateTimeFormatterBuilder().append(ISODateTimeFormat.dateElementParser()).appendOptional(timeOrOffset).toFormatter().withZone(timeZone));
}

Example 9 with DateTimeFormatterBuilder

use of org.joda.time.format.DateTimeFormatterBuilder in project crate by crate.

the class Joda method getStrictStandardDateFormatter.

public static FormatDateTimeFormatter getStrictStandardDateFormatter() {
    // 2014/10/10
    DateTimeFormatter shortFormatter = new DateTimeFormatterBuilder().appendFixedDecimal(DateTimeFieldType.year(), 4).appendLiteral('/').appendFixedDecimal(DateTimeFieldType.monthOfYear(), 2).appendLiteral('/').appendFixedDecimal(DateTimeFieldType.dayOfMonth(), 2).toFormatter().withZoneUTC();
    // 2014/10/10 12:12:12
    DateTimeFormatter longFormatter = new DateTimeFormatterBuilder().appendFixedDecimal(DateTimeFieldType.year(), 4).appendLiteral('/').appendFixedDecimal(DateTimeFieldType.monthOfYear(), 2).appendLiteral('/').appendFixedDecimal(DateTimeFieldType.dayOfMonth(), 2).appendLiteral(' ').appendFixedSignedDecimal(DateTimeFieldType.hourOfDay(), 2).appendLiteral(':').appendFixedSignedDecimal(DateTimeFieldType.minuteOfHour(), 2).appendLiteral(':').appendFixedSignedDecimal(DateTimeFieldType.secondOfMinute(), 2).toFormatter().withZoneUTC();
    DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder().append(longFormatter.withZone(DateTimeZone.UTC).getPrinter(), new DateTimeParser[] { longFormatter.getParser(), shortFormatter.getParser(), new EpochTimeParser(true) });
    return new FormatDateTimeFormatter("yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis", builder.toFormatter().withZone(DateTimeZone.UTC), Locale.ROOT);
}

Example 10 with DateTimeFormatterBuilder

use of org.joda.time.format.DateTimeFormatterBuilder in project crate by crate.

the class Joda method forPattern.

/**
 * Parses a joda based pattern, including some named ones (similar to the built in Joda ISO ones).
 */
public static FormatDateTimeFormatter forPattern(String input, Locale locale) {
    if (Strings.hasLength(input)) {
        input = input.trim();
    }
    if (input == null || input.length() == 0) {
        throw new IllegalArgumentException("No date pattern provided");
    }
    DateTimeFormatter formatter;
    if ("basicDate".equals(input) || "basic_date".equals(input)) {
        formatter = ISODateTimeFormat.basicDate();
    } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTime();
    } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTimeNoMillis();
    } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDate();
    } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTime();
    } else if ("basicOrdinalDateTimeNoMillis".equals(input) || "basic_ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
    } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
        formatter = ISODateTimeFormat.basicTime();
    } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTimeNoMillis();
    } else if ("basicTTime".equals(input) || "basic_t_time".equals(input)) {
        formatter = ISODateTimeFormat.basicTTime();
    } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTTimeNoMillis();
    } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDate();
    } else if ("basicWeekDateTime".equals(input) || "basic_week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTime();
    } else if ("basicWeekDateTimeNoMillis".equals(input) || "basic_week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("date".equals(input)) {
        formatter = ISODateTimeFormat.date();
    } else if ("dateHour".equals(input) || "date_hour".equals(input)) {
        formatter = ISODateTimeFormat.dateHour();
    } else if ("dateHourMinute".equals(input) || "date_hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinute();
    } else if ("dateHourMinuteSecond".equals(input) || "date_hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecond();
    } else if ("dateHourMinuteSecondFraction".equals(input) || "date_hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("dateHourMinuteSecondMillis".equals(input) || "date_hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("dateOptionalTime".equals(input) || "date_optional_time".equals(input)) {
        // this sucks we should use the root local by default and not be dependent on the node
        return new FormatDateTimeFormatter(input, ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC), ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
    } else if ("dateTime".equals(input) || "date_time".equals(input)) {
        formatter = ISODateTimeFormat.dateTime();
    } else if ("dateTimeNoMillis".equals(input) || "date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateTimeNoMillis();
    } else if ("hour".equals(input)) {
        formatter = ISODateTimeFormat.hour();
    } else if ("hourMinute".equals(input) || "hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.hourMinute();
    } else if ("hourMinuteSecond".equals(input) || "hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecond();
    } else if ("hourMinuteSecondFraction".equals(input) || "hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("hourMinuteSecondMillis".equals(input) || "hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("ordinalDate".equals(input) || "ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDate();
    } else if ("ordinalDateTime".equals(input) || "ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTime();
    } else if ("ordinalDateTimeNoMillis".equals(input) || "ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("time".equals(input)) {
        formatter = ISODateTimeFormat.time();
    } else if ("timeNoMillis".equals(input) || "time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.timeNoMillis();
    } else if ("tTime".equals(input) || "t_time".equals(input)) {
        formatter = ISODateTimeFormat.tTime();
    } else if ("tTimeNoMillis".equals(input) || "t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.tTimeNoMillis();
    } else if ("weekDate".equals(input) || "week_date".equals(input)) {
        formatter = ISODateTimeFormat.weekDate();
    } else if ("weekDateTime".equals(input) || "week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTime();
    } else if ("weekDateTimeNoMillis".equals(input) || "week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTimeNoMillis();
    } else if ("weekyear".equals(input) || "week_year".equals(input)) {
        formatter = ISODateTimeFormat.weekyear();
    } else if ("weekyearWeek".equals(input) || "weekyear_week".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeek();
    } else if ("weekyearWeekDay".equals(input) || "weekyear_week_day".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeekDay();
    } else if ("year".equals(input)) {
        formatter = ISODateTimeFormat.year();
    } else if ("yearMonth".equals(input) || "year_month".equals(input)) {
        formatter = ISODateTimeFormat.yearMonth();
    } else if ("yearMonthDay".equals(input) || "year_month_day".equals(input)) {
        formatter = ISODateTimeFormat.yearMonthDay();
    } else if ("epoch_second".equals(input)) {
        formatter = new DateTimeFormatterBuilder().append(new EpochTimePrinter(false), new EpochTimeParser(false)).toFormatter();
    } else if ("epoch_millis".equals(input)) {
        formatter = new DateTimeFormatterBuilder().append(new EpochTimePrinter(true), new EpochTimeParser(true)).toFormatter();
    // strict date formats here, must be at least 4 digits for year and two for months and two for day
    } else if ("strictBasicWeekDate".equals(input) || "strict_basic_week_date".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDate();
    } else if ("strictBasicWeekDateTime".equals(input) || "strict_basic_week_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDateTime();
    } else if ("strictBasicWeekDateTimeNoMillis".equals(input) || "strict_basic_week_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("strictDate".equals(input) || "strict_date".equals(input)) {
        formatter = StrictISODateTimeFormat.date();
    } else if ("strictDateHour".equals(input) || "strict_date_hour".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHour();
    } else if ("strictDateHourMinute".equals(input) || "strict_date_hour_minute".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinute();
    } else if ("strictDateHourMinuteSecond".equals(input) || "strict_date_hour_minute_second".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecond();
    } else if ("strictDateHourMinuteSecondFraction".equals(input) || "strict_date_hour_minute_second_fraction".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("strictDateHourMinuteSecondMillis".equals(input) || "strict_date_hour_minute_second_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("strictDateOptionalTime".equals(input) || "strict_date_optional_time".equals(input)) {
        // this sucks we should use the root local by default and not be dependent on the node
        return new FormatDateTimeFormatter(input, StrictISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC), StrictISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
    } else if ("strictDateTime".equals(input) || "strict_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.dateTime();
    } else if ("strictDateTimeNoMillis".equals(input) || "strict_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.dateTimeNoMillis();
    } else if ("strictHour".equals(input) || "strict_hour".equals(input)) {
        formatter = StrictISODateTimeFormat.hour();
    } else if ("strictHourMinute".equals(input) || "strict_hour_minute".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinute();
    } else if ("strictHourMinuteSecond".equals(input) || "strict_hour_minute_second".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecond();
    } else if ("strictHourMinuteSecondFraction".equals(input) || "strict_hour_minute_second_fraction".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("strictHourMinuteSecondMillis".equals(input) || "strict_hour_minute_second_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("strictOrdinalDate".equals(input) || "strict_ordinal_date".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDate();
    } else if ("strictOrdinalDateTime".equals(input) || "strict_ordinal_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDateTime();
    } else if ("strictOrdinalDateTimeNoMillis".equals(input) || "strict_ordinal_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("strictTime".equals(input) || "strict_time".equals(input)) {
        formatter = StrictISODateTimeFormat.time();
    } else if ("strictTimeNoMillis".equals(input) || "strict_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.timeNoMillis();
    } else if ("strictTTime".equals(input) || "strict_t_time".equals(input)) {
        formatter = StrictISODateTimeFormat.tTime();
    } else if ("strictTTimeNoMillis".equals(input) || "strict_t_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.tTimeNoMillis();
    } else if ("strictWeekDate".equals(input) || "strict_week_date".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDate();
    } else if ("strictWeekDateTime".equals(input) || "strict_week_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDateTime();
    } else if ("strictWeekDateTimeNoMillis".equals(input) || "strict_week_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDateTimeNoMillis();
    } else if ("strictWeekyear".equals(input) || "strict_weekyear".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyear();
    } else if ("strictWeekyearWeek".equals(input) || "strict_weekyear_week".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyearWeek();
    } else if ("strictWeekyearWeekDay".equals(input) || "strict_weekyear_week_day".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyearWeekDay();
    } else if ("strictYear".equals(input) || "strict_year".equals(input)) {
        formatter = StrictISODateTimeFormat.year();
    } else if ("strictYearMonth".equals(input) || "strict_year_month".equals(input)) {
        formatter = StrictISODateTimeFormat.yearMonth();
    } else if ("strictYearMonthDay".equals(input) || "strict_year_month_day".equals(input)) {
        formatter = StrictISODateTimeFormat.yearMonthDay();
    } else if (Strings.hasLength(input) && input.contains("||")) {
        String[] formats = Strings.delimitedListToStringArray(input, "||");
        DateTimeParser[] parsers = new DateTimeParser[formats.length];
        if (formats.length == 1) {
            formatter = forPattern(input, locale).parser();
        } else {
            DateTimeFormatter dateTimeFormatter = null;
            for (int i = 0; i < formats.length; i++) {
                FormatDateTimeFormatter currentFormatter = forPattern(formats[i], locale);
                DateTimeFormatter currentParser = currentFormatter.parser();
                if (dateTimeFormatter == null) {
                    dateTimeFormatter = currentFormatter.printer();
                }
                parsers[i] = currentParser.getParser();
            }
            assert dateTimeFormatter != null;
            DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder().append(dateTimeFormatter.withZone(DateTimeZone.UTC).getPrinter(), parsers);
            formatter = builder.toFormatter();
        }
    } else {
        try {
            formatter = DateTimeFormat.forPattern(input);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid format: [" + input + "]: " + e.getMessage(), e);
        }
    }
    return new FormatDateTimeFormatter(input, formatter.withZone(DateTimeZone.UTC), locale);
}