/** * Get the number of nanoseconds past epoch of the given {@link LocalDate}. * * @param date the Java date value * @return the epoch nanoseconds */ static long toEpochNanos(LocalDate date) { long epochDay = date.toEpochDay(); return epochDay * Conversions.NANOSECONDS_PER_DAY; }
@Override public Integer toDatabaseType(LocalDate value) { return value == null ? null : (int) value.toEpochDay(); }
@Override public void writeDate( LocalDate localDate ) { buf.putLong( localDate.toEpochDay() ); }
@Override protected int computeHash() { return Long.hashCode( value.toEpochDay() ); }
private static double toDouble(Object value, Type columnType) { if (value instanceof String && columnType.equals(DATE)) { return LocalDate.parse((CharSequence) value).toEpochDay(); } if (columnType.equals(BIGINT) || columnType.equals(INTEGER) || columnType.equals(DATE)) { return ((Number) value).longValue(); } if (columnType.equals(DOUBLE)) { return ((Number) value).doubleValue(); } throw new IllegalArgumentException("unsupported column type " + columnType); }
public static Date toMetastoreDate(LocalDate date) { return new Date(date.toEpochDay()); }
@Override public void write( Object value, FlushableChannel into ) throws IOException { into.putLong( ((LocalDate) value).toEpochDay() ); } } );
@Override public final void writeDate( LocalDate localDate ) throws E { writeDate( localDate.toEpochDay() ); }
private LocalDate nextDateRaw() { return ofEpochDay( longBetween( LocalDate.MIN.toEpochDay(), LocalDate.MAX.toEpochDay() ) ); }
@Override public boolean serialize(final JsonContext jsonContext, final LocalDate value) { jsonContext.writeNumber(value.toEpochDay()); return true; }
private static Optional<DoubleRange> createDateRange(DateStatistics statistics) { if (statistics.getMin().isPresent() && statistics.getMax().isPresent()) { return Optional.of(new DoubleRange(statistics.getMin().get().toEpochDay(), statistics.getMax().get().toEpochDay())); } return Optional.empty(); }
/** * Constructs standard (non-legacy) TIMESTAMP value corresponding to argument */ public static SqlTimestamp sqlTimestampOf(LocalDateTime dateTime) { return new SqlTimestamp(DAYS.toMillis(dateTime.toLocalDate().toEpochDay()) + NANOSECONDS.toMillis(dateTime.toLocalTime().toNanoOfDay())); }
@Override public void writeDate( LocalDate localDate ) throws IOException { long epochDay = localDate.toEpochDay(); packStructHeader( DATE_SIZE, DATE ); pack( epochDay ); }
public static byte[] encodeDateArray( LocalDate[] dates ) { long[] data = new long[dates.length]; for ( int i = 0; i < data.length; i++ ) { data[i] = dates[i].toEpochDay(); } TemporalHeader header = new TemporalHeader( TemporalType.TEMPORAL_DATE.temporalType ); byte[] bytes = DynamicArrayStore.encodeFromNumbers( data, DynamicArrayStore.TEMPORAL_HEADER_SIZE ); header.writeArrayHeaderTo( bytes ); return bytes; }
private static double toDouble(Object value, Type type) { if (value instanceof String && type.equals(DATE)) { return LocalDate.parse((CharSequence) value).toEpochDay(); } if (type.equals(BIGINT) || type.equals(INTEGER) || type.equals(DATE)) { return ((Number) value).doubleValue(); } if (type instanceof DecimalType) { DecimalType decimalType = (DecimalType) type; if (isShortDecimal(decimalType)) { return parseDouble(Decimals.toString(((Number) value).longValue(), decimalType.getScale())); } if (isLongDecimal(decimalType)) { return parseDouble(Decimals.toString((Slice) value, decimalType.getScale())); } throw new IllegalArgumentException("Unexpected decimal type: " + decimalType); } if (type.equals(DOUBLE)) { return ((Number) value).doubleValue(); } throw new IllegalArgumentException("unsupported column type " + type); } }
private static long epochDaysInZone(TimeZoneKey timeZoneKey, long instant) { return LocalDate.from(Instant.ofEpochMilli(instant).atZone(ZoneId.of(timeZoneKey.getId()))).toEpochDay(); }
@Override public void serialize(LocalDate date, JsonGenerator g, SerializerProvider provider) throws IOException { if (useTimestamp(provider)) { if (_shape == JsonFormat.Shape.NUMBER_INT) { g.writeNumber(date.toEpochDay()); } else { g.writeStartArray(); _serializeAsArrayContents(date, g, provider); g.writeEndArray(); } } else { g.writeString((_formatter == null) ? date.toString() : date.format(_formatter)); } }
@Test public void shouldReturnLocalDateInstanceWhenConvertingLongToLocalDate() { LocalDate now = LocalDate.now(); long epochDay = now.toEpochDay(); assertThat(Conversions.toLocalDate(epochDay)).isEqualTo(now); }
@Override public void serializeWithType(LocalDate value, JsonGenerator g, SerializerProvider provider, TypeSerializer typeSer) throws IOException { WritableTypeId typeIdDef = typeSer.writeTypePrefix(g, typeSer.typeId(value, serializationShape(provider))); // need to write out to avoid double-writing array markers switch (typeIdDef.valueShape) { case START_ARRAY: _serializeAsArrayContents(value, g, provider); break; case VALUE_NUMBER_INT: g.writeNumber(value.toEpochDay()); break; default: g.writeString((_formatter == null) ? value.toString() : value.format(_formatter)); } typeSer.writeTypeSuffix(g, typeIdDef); }
@Test void shouldReportTooHighDateRecord() { // given PropertyRecord property = inUse( new PropertyRecord( 42 ) ); final int keyId = 6; add( inUse( new PropertyKeyTokenRecord( keyId ) ) ); final long[] longs = TemporalType.encodeDate( keyId, LocalDate.MAX.toEpochDay() + 1 ); expectInvalidPropertyValue( property, longs ); }