下面列出了怎么用org.joda.time.chrono.ISOChronology的API类实例代码及写法，或者点击链接到github查看源代码。
private static DateTimeField getDateField(ISOChronology chronology, Slice unit)
{
String unitString = unit.toStringUtf8().toLowerCase(ENGLISH);
switch (unitString) {
case "day":
return chronology.dayOfMonth();
case "week":
return chronology.weekOfWeekyear();
case "month":
return chronology.monthOfYear();
case "quarter":
return QUARTER_OF_YEAR.getField(chronology);
case "year":
return chronology.year();
}
throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "'" + unitString + "' is not a valid DATE field");
}
public static DateTimeField getTimestampField(ISOChronology chronology, Slice unit)
{
String unitString = unit.toStringUtf8().toLowerCase(ENGLISH);
switch (unitString) {
case "millisecond":
return chronology.millisOfSecond();
case "second":
return chronology.secondOfMinute();
case "minute":
return chronology.minuteOfHour();
case "hour":
return chronology.hourOfDay();
case "day":
return chronology.dayOfMonth();
case "week":
return chronology.weekOfWeekyear();
case "month":
return chronology.monthOfYear();
case "quarter":
return QUARTER_OF_YEAR.getField(chronology);
case "year":
return chronology.year();
}
throw new PrestoException(INVALID_FUNCTION_ARGUMENT, "'" + unitString + "' is not a valid Timestamp field");
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* Creates a new instance representing the number of complete standard length units
* in the specified period.
* <p>
* This factory method converts all fields from the period to hours using standardised
* durations for each field. Only those fields which have a precise duration in
* the ISO UTC chronology can be converted.
* <ul>
* <li>One week consists of 7 days.
* <li>One day consists of 24 hours.
* <li>One hour consists of 60 minutes.
* <li>One minute consists of 60 seconds.
* <li>One second consists of 1000 milliseconds.
* </ul>
* Months and Years are imprecise and periods containing these values cannot be converted.
*
* @param period the period to get the number of hours from, must not be null
* @param millisPerUnit the number of milliseconds in one standard unit of this period
* @throws IllegalArgumentException if the period contains imprecise duration values
*/
protected static int standardPeriodIn(ReadablePeriod period, long millisPerUnit) {
if (period == null) {
return 0;
}
Chronology iso = ISOChronology.getInstanceUTC();
long duration = 0L;
for (int i = 0; i < period.size(); i++) {
int value = period.getValue(i);
if (value != 0) {
DurationField field = period.getFieldType(i).getField(iso);
if (field.isPrecise() == false) {
throw new IllegalArgumentException(
"Cannot convert period to duration as " + field.getName() +
" is not precise in the period " + period);
}
duration = FieldUtils.safeAdd(duration, FieldUtils.safeMultiply(field.getUnitMillis(), value));
}
}
return FieldUtils.safeToInt(duration / millisPerUnit);
}
public void testGetInstantChronology_RI() {
DateTime dt = new DateTime(123L, BuddhistChronology.getInstance());
assertEquals(BuddhistChronology.getInstance(), DateTimeUtils.getInstantChronology(dt));
Instant i = new Instant(123L);
assertEquals(ISOChronology.getInstanceUTC(), DateTimeUtils.getInstantChronology(i));
AbstractInstant ai = new AbstractInstant() {
public long getMillis() {
return 0L;
}
public Chronology getChronology() {
return null; // testing for this
}
};
assertEquals(ISOChronology.getInstance(), DateTimeUtils.getInstantChronology(ai));
assertEquals(ISOChronology.getInstance(), DateTimeUtils.getInstantChronology(null));
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
public static long parseInstant(String input, long now) {
if (input.charAt(0) == '+') {
return now + Long.parseLong(input.substring(1));
}
if (input.charAt(0) == '-') {
return now - Long.parseLong(input.substring(1));
}
// try to parse just milliseconds
try {
return Long.parseLong(input);
} catch (IllegalArgumentException e) {
// pass-through
}
final Chronology chrono = ISOChronology.getInstanceUTC();
if (input.indexOf('/') >= 0) {
return parseFullInstant(input, chrono);
}
return parseTodayInstant(input, chrono, now);
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
public void testEqualsHashCode_Strict() {
Chronology chrono1 = StrictChronology.getInstance(ISOChronology.getInstanceUTC());
Chronology chrono2 = StrictChronology.getInstance(ISOChronology.getInstanceUTC());
Chronology chrono3 = StrictChronology.getInstance(ISOChronology.getInstance());
assertEquals(true, chrono1.equals(chrono2));
assertEquals(false, chrono1.equals(chrono3));
DateTime dt1 = new DateTime(0L, chrono1);
DateTime dt2 = new DateTime(0L, chrono2);
DateTime dt3 = new DateTime(0L, chrono3);
assertEquals(true, dt1.equals(dt2));
assertEquals(false, dt1.equals(dt3));
assertEquals(true, chrono1.hashCode() == chrono2.hashCode());
assertEquals(false, chrono1.hashCode() == chrono3.hashCode());
}
public void testToMutableDateTime_Chronology() {
MutableDateTime test = new MutableDateTime(TEST_TIME1);
MutableDateTime result = test.toMutableDateTime(ISOChronology.getInstance());
assertTrue(test != result);
assertEquals(test.getMillis(), result.getMillis());
assertEquals(ISOChronology.getInstance(), result.getChronology());
test = new MutableDateTime(TEST_TIME1);
result = test.toMutableDateTime(GregorianChronology.getInstance(PARIS));
assertTrue(test != result);
assertEquals(test.getMillis(), result.getMillis());
assertEquals(GregorianChronology.getInstance(PARIS), result.getChronology());
test = new MutableDateTime(TEST_TIME1, GregorianChronology.getInstance(PARIS));
result = test.toMutableDateTime((Chronology) null);
assertTrue(test != result);
assertEquals(test.getMillis(), result.getMillis());
assertEquals(ISOChronology.getInstance(), result.getChronology());
test = new MutableDateTime(TEST_TIME1);
result = test.toMutableDateTime((Chronology) null);
assertTrue(test != result);
assertEquals(test.getMillis(), result.getMillis());
assertEquals(ISOChronology.getInstance(), result.getChronology());
}
/**
* @param standardOffset standard offset just before instant
*/
public long setInstant(int year, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
Chronology chrono = ISOChronology.getInstanceUTC();
long millis = chrono.year().set(0, year);
millis = chrono.monthOfYear().set(millis, iMonthOfYear);
millis = chrono.millisOfDay().set(millis, iMillisOfDay);
millis = setDayOfMonth(chrono, millis);
if (iDayOfWeek != 0) {
millis = setDayOfWeek(chrono, millis);
}
// Convert from local time to UTC.
return millis - offset;
}
public void testGetMethods() {
MutableDateTime test = new MutableDateTime();
assertEquals(ISOChronology.getInstance(), test.getChronology());
assertEquals(LONDON, test.getZone());
assertEquals(TEST_TIME_NOW, test.getMillis());
assertEquals(1, test.getEra());
assertEquals(20, test.getCenturyOfEra());
assertEquals(2, test.getYearOfCentury());
assertEquals(2002, test.getYearOfEra());
assertEquals(2002, test.getYear());
assertEquals(6, test.getMonthOfYear());
assertEquals(9, test.getDayOfMonth());
assertEquals(2002, test.getWeekyear());
assertEquals(23, test.getWeekOfWeekyear());
assertEquals(7, test.getDayOfWeek());
assertEquals(160, test.getDayOfYear());
assertEquals(1, test.getHourOfDay());
assertEquals(0, test.getMinuteOfHour());
assertEquals(60, test.getMinuteOfDay());
assertEquals(0, test.getSecondOfMinute());
assertEquals(60 * 60, test.getSecondOfDay());
assertEquals(0, test.getMillisOfSecond());
assertEquals(60 * 60 * 1000, test.getMillisOfDay());
}
public void testConstructor_RI_RD4() throws Throwable {
long result = TEST_TIME_NOW;
result = ISOChronology.getInstance().monthOfYear().add(result, 6);
result = ISOChronology.getInstance().hourOfDay().add(result, 1);
Duration dur = new Duration(result - TEST_TIME_NOW);
Interval test = new Interval((ReadableInstant) null, dur);
assertEquals(TEST_TIME_NOW, test.getStartMillis());
assertEquals(result, test.getEndMillis());
}
public void testConstructor_Object_Chronology2() throws Throwable {
DateTime dt1 = new DateTime(2004, 6, 9, 0, 0, 0, 0);
DateTime dt2 = new DateTime(2005, 7, 10, 1, 1, 1, 1);
Interval base = new Interval(dt1, dt2);
MutableInterval test = new MutableInterval(base, null);
assertEquals(dt1.getMillis(), test.getStartMillis());
assertEquals(dt2.getMillis(), test.getEndMillis());
assertEquals(ISOChronology.getInstance(), test.getChronology());
}
@Description("Current time without time zone")
@ScalarFunction("localtime")
@SqlType(StandardTypes.TIME)
public static long localTime(ConnectorSession session)
{
ISOChronology localChronology = getChronology(session.getTimeZoneKey());
if (session.isLegacyTimestamp()) {
// It is ok for this method to use the Object interfaces because it is constant folded during plan optimization
return new DateTime(session.getStart().toEpochMilli(), localChronology)
.withDate(new LocalDate(1970, 1, 1))
.getMillis();
}
return localChronology.millisOfDay().get(session.getStart().toEpochMilli());
}
@Description("Add the specified amount of time to the given time")
@LiteralParameters("x")
@ScalarFunction("date_add")
@SqlType(StandardTypes.TIME_WITH_TIME_ZONE)
public static long addFieldValueTimeWithTimeZone(
@SqlType("varchar(x)") Slice unit,
@SqlType(StandardTypes.BIGINT) long value,
@SqlType(StandardTypes.TIME_WITH_TIME_ZONE) long timeWithTimeZone)
{
ISOChronology chronology = unpackChronology(timeWithTimeZone);
long millis = modulo24Hour(chronology, getTimeField(chronology, unit).add(unpackMillisUtc(timeWithTimeZone), toIntExact(value)));
return updateMillisUtc(millis, timeWithTimeZone);
}
@Description("Difference of the given times in the given unit")
@ScalarFunction("date_diff")
@LiteralParameters("x")
@SqlType(StandardTypes.BIGINT)
public static long diffTime(ConnectorSession session, @SqlType("varchar(x)") Slice unit, @SqlType(StandardTypes.TIME) long time1, @SqlType(StandardTypes.TIME) long time2)
{
if (session.isLegacyTimestamp()) {
// Session zone could have policy change on/around 1970-01-01, so we cannot use UTC
ISOChronology chronology = getChronology(session.getTimeZoneKey());
return getTimeField(chronology, unit).getDifferenceAsLong(time2, time1);
}
return getTimeField(UTC_CHRONOLOGY, unit).getDifferenceAsLong(time2, time1);
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
public void testConstructor_RD_RI4() throws Throwable {
long result = TEST_TIME_NOW;
result = ISOChronology.getInstance().monthOfYear().add(result, -6);
result = ISOChronology.getInstance().hourOfDay().add(result, -1);
Duration dur = new Duration(TEST_TIME_NOW - result);
Interval test = new Interval(dur, (ReadableInstant) null);
assertEquals(result, test.getStartMillis());
assertEquals(TEST_TIME_NOW, test.getEndMillis());
}
/**
* @param standardOffset standard offset just before previous recurrence
*/
public long previous(long instant, int standardOffset, int saveMillis) {
int offset;
if (iMode == 'w') {
offset = standardOffset + saveMillis;
} else if (iMode == 's') {
offset = standardOffset;
} else {
offset = 0;
}
// Convert from UTC to local time.
instant += offset;
Chronology chrono = ISOChronology.getInstanceUTC();
long prev = chrono.monthOfYear().set(instant, iMonthOfYear);
// Be lenient with millisOfDay.
prev = chrono.millisOfDay().set(prev, 0);
prev = chrono.millisOfDay().add(prev, iMillisOfDay);
prev = setDayOfMonthPrevious(chrono, prev);
if (iDayOfWeek == 0) {
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = setDayOfMonthPrevious(chrono, prev);
}
} else {
prev = setDayOfWeek(chrono, prev);
if (prev >= instant) {
prev = chrono.year().add(prev, -1);
prev = chrono.monthOfYear().set(prev, iMonthOfYear);
prev = setDayOfMonthPrevious(chrono, prev);
prev = setDayOfWeek(chrono, prev);
}
}
// Convert from local time to UTC.
return prev - offset;
}
public void testConstructor_ObjectString7() throws Throwable {
DateTime test = new DateTime("10");
assertEquals(ISOChronology.getInstance(), test.getChronology());
assertEquals(10, test.getYear());
assertEquals(1, test.getMonthOfYear());
assertEquals(1, test.getDayOfMonth());
assertEquals(0, test.getHourOfDay());
assertEquals(0, test.getMinuteOfHour());
assertEquals(0, test.getSecondOfMinute());
assertEquals(0, test.getMillisOfSecond());
}
@Override
protected void setUp() throws Exception {
super.setUp();
JULIAN = JulianChronology.getInstance();
ISO = ISOChronology.getInstance();
zone = DateTimeZone.getDefault();
DateTimeZone.setDefault(PARIS);
}
@LiteralParameters("p")
@SqlType(StandardTypes.BIGINT)
public static long extract(@LiteralParameter("p") long precision, ConnectorSession session, @SqlType("timestamp(p)") long timestamp)
{
if (precision > 3) {
timestamp = scaleEpochMicrosToMillis(timestamp);
}
ISOChronology chronology = ISOChronology.getInstanceUTC();
if (session.isLegacyTimestamp()) {
chronology = getChronology(session.getTimeZoneKey());
}
return QUARTER_OF_YEAR.getField(chronology).get(timestamp);
}
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);
}
public void testToPeriod_Chronology() {
long length =
(4L + (3L * 7L) + (2L * 30L) + 365L) * DateTimeConstants.MILLIS_PER_DAY +
5L * DateTimeConstants.MILLIS_PER_HOUR +
6L * DateTimeConstants.MILLIS_PER_MINUTE +
7L * DateTimeConstants.MILLIS_PER_SECOND + 8L;
Duration test = new Duration(length);
Period result = test.toPeriod(ISOChronology.getInstanceUTC());
assertEquals(new Period(test, ISOChronology.getInstanceUTC()), result);
assertEquals(new Period(test.getMillis(), ISOChronology.getInstanceUTC()), result);
}
public void testGetMethods() {
Instant test = new Instant();
assertEquals(ISOChronology.getInstanceUTC(), test.getChronology());
assertEquals(DateTimeZone.UTC, test.getZone());
assertEquals(TEST_TIME_NOW, test.getMillis());
}