diff --git a/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupport.scala b/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupport.scala index 52fd7809204d6..a56da1dc466d2 100644 --- a/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupport.scala +++ b/community/cypher/interpreted-runtime/src/main/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupport.scala @@ -19,8 +19,7 @@ */ package org.neo4j.cypher.internal.runtime.interpreted -import java.time.temporal.{Temporal, TemporalAmount} -import java.time.{ZoneId, ZoneOffset} +import java.time._ import org.neo4j.cypher.internal.util.v3_4.CypherTypeException import org.neo4j.graphdb.spatial.Point @@ -141,17 +140,17 @@ object CastSupport { case _: Point => Converter( transform(new ArrayConverterWriter(classOf[Point], a => Values.pointArray(a.asInstanceOf[Array[Point]])))) case _: DurationValue => Converter( - transform(new ArrayConverterWriter(classOf[DurationValue], a => Values.durationArray(a.asInstanceOf[Array[TemporalAmount]])))) + transform(new ArrayConverterWriter(classOf[DurationValue], a => Values.durationArray(a.asInstanceOf[Array[DurationValue]])))) + case _: DateTimeValue => Converter( + transform(new ArrayConverterWriter(classOf[ZonedDateTime], a => Values.dateTimeArray(a.asInstanceOf[Array[ZonedDateTime]])))) case _: DateValue => Converter( - transform(new ArrayConverterWriter(classOf[DateValue], a => Values.temporalArray(a.asInstanceOf[Array[Temporal]])))) + transform(new ArrayConverterWriter(classOf[LocalDate], a => Values.dateArray(a.asInstanceOf[Array[LocalDate]])))) case _: LocalTimeValue => Converter( - transform(new ArrayConverterWriter(classOf[LocalTimeValue], a => Values.temporalArray(a.asInstanceOf[Array[Temporal]])))) + transform(new ArrayConverterWriter(classOf[LocalTime], a => Values.localTimeArray(a.asInstanceOf[Array[LocalTime]])))) case _: TimeValue => Converter( - transform(new ArrayConverterWriter(classOf[TimeValue], a => Values.temporalArray(a.asInstanceOf[Array[Temporal]])))) + transform(new ArrayConverterWriter(classOf[OffsetTime], a => Values.timeArray(a.asInstanceOf[Array[OffsetTime]])))) case _: LocalDateTimeValue => Converter( - transform(new ArrayConverterWriter(classOf[LocalDateTimeValue], a => Values.temporalArray(a.asInstanceOf[Array[Temporal]])))) - case _: DateTimeValue => Converter( - transform(new ArrayConverterWriter(classOf[DateTimeValue], a => Values.temporalArray(a.asInstanceOf[Array[Temporal]])))) + transform(new ArrayConverterWriter(classOf[LocalDateTime], a => Values.localDateTimeArray(a.asInstanceOf[Array[LocalDateTime]])))) case _ => throw new CypherTypeException("Property values can only be of primitive types or arrays thereof") } diff --git a/community/cypher/interpreted-runtime/src/test/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupportTest.scala b/community/cypher/interpreted-runtime/src/test/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupportTest.scala index 42d68a8a32e87..c0b306f0e9e8f 100644 --- a/community/cypher/interpreted-runtime/src/test/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupportTest.scala +++ b/community/cypher/interpreted-runtime/src/test/scala/org/neo4j/cypher/internal/runtime/interpreted/CastSupportTest.scala @@ -21,6 +21,10 @@ package org.neo4j.cypher.internal.runtime.interpreted import org.neo4j.cypher.internal.util.v3_4.CypherTypeException import org.neo4j.cypher.internal.util.v3_4.test_helpers.CypherFunSuite +import org.neo4j.values.storable.DurationValue.duration +import org.neo4j.values.storable.LocalTimeValue.localTime +import org.neo4j.values.storable._ +import org.neo4j.values.virtual.VirtualValues class CastSupportTest extends CypherFunSuite { @@ -58,4 +62,36 @@ class CastSupportTest extends CypherFunSuite { val given: Any = Seq(1) intercept[CypherTypeException](CastSupport.castOrFail[Int](given)) } + + test("should convert string lists to arrays") { + val valueObj = Values.stringValue("test") + val list = VirtualValues.list(valueObj) + val array = CastSupport.getConverter(valueObj).arrayConverter(list) + array shouldBe a[StringArray] + array.asInstanceOf[StringArray].asObjectCopy()(0) should equal(valueObj.asObjectCopy()) + } + + test("should convert point lists to arrays") { + val valueObj = Values.pointValue(CoordinateReferenceSystem.Cartesian, 0.0, 1.0) + val list = VirtualValues.list(valueObj) + val array = CastSupport.getConverter(valueObj).arrayConverter(list) + array shouldBe a[PointArray] + array.asInstanceOf[PointArray].asObjectCopy()(0) should equal(valueObj) + } + + test("should convert local time lists to arrays") { + val valueObj = localTime(3, 20, 45, 0) + val list = VirtualValues.list(valueObj) + val array = CastSupport.getConverter(valueObj).arrayConverter(list) + array shouldBe a[LocalTimeArray] + array.asInstanceOf[LocalTimeArray].asObjectCopy()(0) should equal(valueObj.asObjectCopy()) + } + + test("should convert duration lists to arrays") { + val valueObj = duration(3, 20, 45, 0) + val list = VirtualValues.list(valueObj) + val array = CastSupport.getConverter(valueObj).arrayConverter(list) + array shouldBe a[DurationArray] + array.asInstanceOf[DurationArray].asObjectCopy()(0) should equal(valueObj.asObjectCopy()) + } } diff --git a/community/values/src/main/java/org/neo4j/values/ValueMapper.java b/community/values/src/main/java/org/neo4j/values/ValueMapper.java index e16157ad797c3..74787f20d3c00 100644 --- a/community/values/src/main/java/org/neo4j/values/ValueMapper.java +++ b/community/values/src/main/java/org/neo4j/values/ValueMapper.java @@ -37,10 +37,13 @@ import org.neo4j.values.storable.ByteValue; import org.neo4j.values.storable.CharArray; import org.neo4j.values.storable.CharValue; +import org.neo4j.values.storable.DateArray; +import org.neo4j.values.storable.DateTimeArray; import org.neo4j.values.storable.DateTimeValue; import org.neo4j.values.storable.DateValue; import org.neo4j.values.storable.DoubleArray; import org.neo4j.values.storable.DoubleValue; +import org.neo4j.values.storable.DurationArray; import org.neo4j.values.storable.DurationValue; import org.neo4j.values.storable.FloatArray; import org.neo4j.values.storable.FloatValue; @@ -50,7 +53,9 @@ import org.neo4j.values.storable.IntValue; import org.neo4j.values.storable.IntegralArray; import org.neo4j.values.storable.IntegralValue; +import org.neo4j.values.storable.LocalDateTimeArray; import org.neo4j.values.storable.LocalDateTimeValue; +import org.neo4j.values.storable.LocalTimeArray; import org.neo4j.values.storable.LocalTimeValue; import org.neo4j.values.storable.LongArray; import org.neo4j.values.storable.LongValue; @@ -64,6 +69,7 @@ import org.neo4j.values.storable.StringValue; import org.neo4j.values.storable.TextArray; import org.neo4j.values.storable.TextValue; +import org.neo4j.values.storable.TimeArray; import org.neo4j.values.storable.TimeValue; import org.neo4j.values.virtual.MapValue; import org.neo4j.values.virtual.PathValue; @@ -228,6 +234,36 @@ default Base mapPointArray( PointArray value ) return mapSequence( value ); } + default Base mapDateTimeArray( DateTimeArray value ) + { + return mapSequence( value ); + } + + default Base mapLocalDateTimeArray( LocalDateTimeArray value ) + { + return mapSequence( value ); + } + + default Base mapLocalTimeArray( LocalTimeArray value ) + { + return mapSequence( value ); + } + + default Base mapTimeArray( TimeArray value ) + { + return mapSequence( value ); + } + + default Base mapDateArray( DateArray value ) + { + return mapSequence( value ); + } + + default Base mapDurationArray( DurationArray value ) + { + return mapSequence( value ); + } + abstract class JavaMapper implements ValueMapper { @Override diff --git a/community/values/src/main/java/org/neo4j/values/storable/ArrayValue.java b/community/values/src/main/java/org/neo4j/values/storable/ArrayValue.java index a1957ce657134..09a5276819db6 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ArrayValue.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ArrayValue.java @@ -65,6 +65,21 @@ public AnyValue next() }; } + @Override + public final boolean eq( Object other ) + { + if ( other == null ) + { + return false; + } + + if ( other instanceof SequenceValue ) + { + return this.equals( (SequenceValue) other ); + } + return other instanceof Value && equals( (Value) other ); + } + @Override public boolean equals( boolean x ) { diff --git a/community/values/src/main/java/org/neo4j/values/storable/BooleanArray.java b/community/values/src/main/java/org/neo4j/values/storable/BooleanArray.java index a8587378c49c5..6119544df6a74 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/BooleanArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/BooleanArray.java @@ -19,34 +19,44 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; import java.util.Arrays; import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class BooleanArray extends ArrayValue +public class BooleanArray extends ArrayValue { - abstract boolean[] value(); + private final boolean[] value; + + BooleanArray( boolean[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } public boolean booleanValue( int offset ) { - return value()[offset]; + return value[offset]; } @Override public boolean equals( Value other ) { - return other.equals( this.value() ); + return other.equals( this.value ); } @Override @@ -88,7 +98,7 @@ public boolean equals( double[] x ) @Override public boolean equals( boolean[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override @@ -109,10 +119,46 @@ public boolean equals( Geometry[] x ) return false; } + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -124,20 +170,20 @@ public T map( ValueMapper mapper ) @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public boolean[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public boolean[] asObject() { - return value(); + return value; } public int compareTo( BooleanArray other ) @@ -160,22 +206,7 @@ public NumberType numberType() @Override public String prettyPrint() { - return Arrays.toString( value() ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return Arrays.toString( value ); } @Override @@ -184,26 +215,9 @@ public AnyValue value( int position ) return Values.booleanValue( booleanValue( position ) ); } - static final class Direct extends BooleanArray + @Override + public String toString() { - private final boolean[] value; - - Direct( boolean[] value ) - { - assert value != null; - this.value = value; - } - - @Override - boolean[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "BooleanArray%s", Arrays.toString( value() ) ); - } + return format( "BooleanArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/ByteArray.java b/community/values/src/main/java/org/neo4j/values/storable/ByteArray.java index 5acdd53121b23..e57390e52aba5 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ByteArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ByteArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class ByteArray extends IntegralArray +public class ByteArray extends IntegralArray { - abstract byte[] value(); + final byte[] value; + + ByteArray( byte[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public long longValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,111 +63,79 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( short[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( int[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( long[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( float[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( double[] x ) { - return PrimitiveArrayValues.equals( value(), x ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return PrimitiveArrayValues.equals( value, x ); } @Override public void writeTo( ValueWriter writer ) throws E { - writer.writeByteArray( value() ); + writer.writeByteArray( value ); } @Override public byte[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public byte[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override public AnyValue value( int offset ) { - return Values.byteValue( value()[offset] ); + return Values.byteValue( value[offset] ); } - static final class Direct extends ByteArray + @Override + public String toString() { - final byte[] value; - - Direct( byte[] value ) - { - assert value != null; - this.value = value; - } - - @Override - byte[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "ByteArray%s", Arrays.toString( value ) ); - } + return format( "ByteArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/CharArray.java b/community/values/src/main/java/org/neo4j/values/storable/CharArray.java index 2d186ae1b6f87..3388477f40028 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/CharArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/CharArray.java @@ -19,23 +19,33 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; import java.util.Arrays; import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class CharArray extends TextArray +public class CharArray extends TextArray { - abstract char[] value(); + final char[] value; + + CharArray( char[] value ) + { + assert value != null; + this.value = value; + } @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } // TODO: should we support this? @@ -48,13 +58,13 @@ public boolean equals( Value other ) @Override public boolean equals( char[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( String[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override @@ -64,67 +74,88 @@ public boolean equals( Geometry[] x ) } @Override - public final boolean eq( Object other ) + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) { - if ( other == null ) - { - return false; - } + return false; + } - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + @Override + public boolean equals( OffsetTime[] x ) + { + return false; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override public int length() { - return value().length; + return value.length; } @Override public String stringValue( int offset ) { - return Character.toString( value()[offset] ); + return Character.toString( value[offset] ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public char[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public char[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override public AnyValue value( int position ) { - return Values.charValue( value()[position] ); + return Values.charValue( value[position] ); } @Override @@ -133,26 +164,9 @@ public T map( ValueMapper mapper ) return mapper.mapCharArray( this ); } - static final class Direct extends CharArray + @Override + public String toString() { - final char[] value; - - Direct( char[] value ) - { - assert value != null; - this.value = value; - } - - @Override - char[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "CharArray%s", Arrays.toString( value() ) ); - } + return format( "CharArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/DateArray.java b/community/values/src/main/java/org/neo4j/values/storable/DateArray.java new file mode 100644 index 0000000000000..ba8c479a55499 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/DateArray.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.values.ValueMapper; + +public class DateArray extends TemporalArray +{ + final LocalDate[] value; + + DateArray( LocalDate[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected LocalDate[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapDateArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writeTo( writer, ValueWriter.ArrayType.DATE ,value ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.DATE_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/DateTimeArray.java b/community/values/src/main/java/org/neo4j/values/storable/DateTimeArray.java new file mode 100644 index 0000000000000..8d31b1425cc01 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/DateTimeArray.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.values.ValueMapper; + +public class DateTimeArray extends TemporalArray +{ + final ZonedDateTime[] value; + + DateTimeArray( ZonedDateTime[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected ZonedDateTime[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapDateTimeArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writeTo( writer, ValueWriter.ArrayType.ZONED_DATE_TIME ,value ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.ZONED_DATE_TIME_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/DoubleArray.java b/community/values/src/main/java/org/neo4j/values/storable/DoubleArray.java index 4527df21e9d09..cf0a5391a27b1 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/DoubleArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/DoubleArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class DoubleArray extends FloatingPointArray +public class DoubleArray extends FloatingPointArray { - abstract double[] value(); + final double[] value; + + DoubleArray( double[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public double doubleValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,83 +63,68 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( short[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( int[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( long[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( float[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( double[] x ) { - return Arrays.equals( x, value() ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return Arrays.equals( x, value ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public double[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public double[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override @@ -143,26 +133,9 @@ public AnyValue value( int position ) return Values.doubleValue( doubleValue( position ) ); } - static final class Direct extends DoubleArray + @Override + public String toString() { - final double[] value; - - Direct( double[] value ) - { - assert value != null; - this.value = value; - } - - @Override - double[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "DoubleArray%s", Arrays.toString( value() ) ); - } + return format( "DoubleArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/DurationArray.java b/community/values/src/main/java/org/neo4j/values/storable/DurationArray.java new file mode 100644 index 0000000000000..c335b352ccbf8 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/DurationArray.java @@ -0,0 +1,187 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.graphdb.spatial.Geometry; +import org.neo4j.values.AnyValue; +import org.neo4j.values.ValueMapper; + +import static java.lang.String.format; + +public class DurationArray extends NonPrimitiveArray +{ + final DurationValue[] value; + + DurationArray( DurationValue[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected DurationValue[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapDurationArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( DurationValue[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + + @Override + public boolean equals( byte[] x ) + { + return false; + } + + @Override + public boolean equals( short[] x ) + { + return false; + } + + @Override + public boolean equals( int[] x ) + { + return false; + } + + @Override + public boolean equals( long[] x ) + { + return false; + } + + @Override + public boolean equals( float[] x ) + { + return false; + } + + @Override + public boolean equals( double[] x ) + { + return false; + } + + @Override + public boolean equals( boolean[] x ) + { + return false; + } + + @Override + public boolean equals( char[] x ) + { + return false; + } + + @Override + public boolean equals( String[] x ) + { + return false; + } + + @Override + public boolean equals( Geometry[] x ) + { + return false; + } + + @Override + public NumberType numberType() + { + return NumberType.NO_NUMBER; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writer.beginArray( value.length, ValueWriter.ArrayType.DURATION ); + for ( DurationValue x : value ) + { + x.writeTo( writer ); + } + writer.endArray(); + } + + @Override + public AnyValue value( int offset ) + { + return Values.durationValue( value[offset] ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.DURATION_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/DurationValue.java b/community/values/src/main/java/org/neo4j/values/storable/DurationValue.java index a91f81cc5887a..f7e39360ed5de 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/DurationValue.java +++ b/community/values/src/main/java/org/neo4j/values/storable/DurationValue.java @@ -60,7 +60,7 @@ * {@link java.time.Duration} only works with seconds, assumes 24H days, and is unable to handle larger units than days. * {@link java.time.Period} only works with units from days or larger, and does not deal with time. */ -public final class DurationValue extends ScalarValue implements TemporalAmount +public final class DurationValue extends ScalarValue implements TemporalAmount, Comparable { public static DurationValue duration( Duration value ) { diff --git a/community/values/src/main/java/org/neo4j/values/storable/FloatArray.java b/community/values/src/main/java/org/neo4j/values/storable/FloatArray.java index 0d32c8d1bbdd7..49453d33698e7 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/FloatArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/FloatArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class FloatArray extends FloatingPointArray +public class FloatArray extends FloatingPointArray { - abstract float[] value(); + final float[] value; + + FloatArray( float[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public double doubleValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,111 +63,79 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( short[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( int[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( long[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( float[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( double[] x ) { - return PrimitiveArrayValues.equals( value(), x ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return PrimitiveArrayValues.equals( value, x ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public float[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public float[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override public AnyValue value( int offset ) { - return Values.floatValue( value()[offset] ); + return Values.floatValue( value[offset] ); } - static final class Direct extends FloatArray + @Override + public String toString() { - final float[] value; - - Direct( float[] value ) - { - assert value != null; - this.value = value; - } - - @Override - float[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "FloatArray%s", Arrays.toString( value() ) ); - } + return format( "FloatArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/IntArray.java b/community/values/src/main/java/org/neo4j/values/storable/IntArray.java index bf2e7a363f8b3..975eb36c50546 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/IntArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/IntArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class IntArray extends IntegralArray +public class IntArray extends IntegralArray { - abstract int[] value(); + final int[] value; + + IntArray( int[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public long longValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,111 +63,79 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( short[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( int[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( long[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( float[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( double[] x ) { - return PrimitiveArrayValues.equals( value(), x ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return PrimitiveArrayValues.equals( value, x ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public int[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public int[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override public AnyValue value( int offset ) { - return Values.intValue( value()[offset] ); + return Values.intValue( value[offset] ); } - static final class Direct extends IntArray + @Override + public String toString() { - final int[] value; - - Direct( int[] value ) - { - assert value != null; - this.value = value; - } - - @Override - int[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "IntArray%s", Arrays.toString( value() ) ); - } + return format( "IntArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/LocalDateTimeArray.java b/community/values/src/main/java/org/neo4j/values/storable/LocalDateTimeArray.java new file mode 100644 index 0000000000000..ca657be587815 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/LocalDateTimeArray.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.values.ValueMapper; + +public class LocalDateTimeArray extends TemporalArray +{ + final LocalDateTime[] value; + + LocalDateTimeArray( LocalDateTime[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected LocalDateTime[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapLocalDateTimeArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writeTo( writer, ValueWriter.ArrayType.LOCAL_DATE_TIME ,value ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.LOCAL_DATE_TIME_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/LocalTimeArray.java b/community/values/src/main/java/org/neo4j/values/storable/LocalTimeArray.java new file mode 100644 index 0000000000000..91d5105662d97 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/LocalTimeArray.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.values.ValueMapper; + +public class LocalTimeArray extends TemporalArray +{ + final LocalTime[] value; + + LocalTimeArray( LocalTime[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected LocalTime[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapLocalTimeArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( LocalTime[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writeTo( writer, ValueWriter.ArrayType.LOCAL_TIME ,value ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.LOCAL_TIME_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/LongArray.java b/community/values/src/main/java/org/neo4j/values/storable/LongArray.java index dd1e6f262e892..46853a0977722 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/LongArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/LongArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class LongArray extends IntegralArray +public class LongArray extends IntegralArray { - abstract long[] value(); + final long[] value; + + LongArray( long[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public long longValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,83 +63,68 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( short[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( int[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( long[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( float[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( double[] x ) { - return PrimitiveArrayValues.equals( value(), x ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return PrimitiveArrayValues.equals( value, x ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public long[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override @Deprecated public long[] asObject() { - return value(); + return value; } @Override @@ -143,26 +133,9 @@ public AnyValue value( int offset ) return Values.longValue( longValue( offset ) ); } - static final class Direct extends LongArray + @Override + public String toString() { - final long[] value; - - Direct( long[] value ) - { - assert value != null; - this.value = value; - } - - @Override - long[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "LongArray%s", Arrays.toString( value() ) ); - } + return format( "LongArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/NoValue.java b/community/values/src/main/java/org/neo4j/values/storable/NoValue.java index d8ed3d2284e45..8ae625283d3f2 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/NoValue.java +++ b/community/values/src/main/java/org/neo4j/values/storable/NoValue.java @@ -19,6 +19,12 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; + import org.neo4j.values.AnyValue; import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.ValueMapper; @@ -158,6 +164,42 @@ public boolean equals( Geometry[] x ) return false; } + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + @Override public void writeTo( ValueWriter writer ) throws E { diff --git a/community/values/src/main/java/org/neo4j/values/storable/NonPrimitiveArray.java b/community/values/src/main/java/org/neo4j/values/storable/NonPrimitiveArray.java new file mode 100644 index 0000000000000..b07b9dad9f40c --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/NonPrimitiveArray.java @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDateTime; +import java.util.Arrays; + +import org.neo4j.graphdb.spatial.Geometry; + +import static java.lang.String.format; + +public abstract class NonPrimitiveArray> extends ArrayValue +{ + protected abstract T[] value(); + + @Override + public boolean equals( boolean[] x ) + { + return false; + } + + @Override + public boolean equals( char[] x ) + { + return false; + } + + @Override + public boolean equals( String[] x ) + { + return false; + } + + @Override + public boolean equals( byte[] x ) + { + return false; + } + + @Override + public boolean equals( short[] x ) + { + return false; + } + + @Override + public boolean equals( int[] x ) + { + return false; + } + + @Override + public boolean equals( long[] x ) + { + return false; + } + + @Override + public boolean equals( float[] x ) + { + return false; + } + + @Override + public boolean equals( double[] x ) + { + return false; + } + + @Override + public NumberType numberType() + { + return NumberType.NO_NUMBER; + } + + public final int compareTo( NonPrimitiveArray other ) + { + int i = 0; + int x = 0; + int length = Math.min( this.length(), other.length() ); + + while ( x == 0 && i < length ) + { + x = this.value()[i].compareTo( other.value()[i] ); + i++; + } + if ( x == 0 ) + { + x = this.length() - other.length(); + } + return x; + } + + @Override + public final int computeHash() + { + return Arrays.hashCode( value() ); + } + + @Override + public final int length() + { + return value().length; + } + + @Override + public final T[] asObjectCopy() + { + return value().clone(); + } + + @Override + @Deprecated + public final T[] asObject() + { + return value(); + } + + @Override + public final String prettyPrint() + { + return Arrays.toString( value() ); + } + + @Override + public final String toString() + { + return getClass().getSimpleName() + Arrays.toString( value()); + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/NumberArray.java b/community/values/src/main/java/org/neo4j/values/storable/NumberArray.java index 3b18474f30bee..299c0547dbbdd 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/NumberArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/NumberArray.java @@ -19,6 +19,12 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; + import org.neo4j.graphdb.spatial.Geometry; public abstract class NumberArray extends ArrayValue @@ -51,6 +57,42 @@ public boolean equals( Geometry[] x ) return false; } + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } + @Override public ValueGroup valueGroup() { diff --git a/community/values/src/main/java/org/neo4j/values/storable/PointArray.java b/community/values/src/main/java/org/neo4j/values/storable/PointArray.java index b4383e2e766c8..1aef88aa93bc4 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/PointArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/PointArray.java @@ -19,23 +19,31 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; import java.util.Arrays; import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; -import static java.lang.String.format; - -public abstract class PointArray extends ArrayValue +public class PointArray extends NonPrimitiveArray { - abstract PointValue[] value(); + final PointValue[] value; + + PointArray( PointValue[] value ) + { + assert value != null; + this.value = value; + } @Override - public int length() + protected PointValue[] value() { - return value().length; + return value; } public PointValue pointValue( int offset ) @@ -110,113 +118,68 @@ public boolean equals( String[] x ) } @Override - public ValueGroup valueGroup() + public boolean equals( ZonedDateTime[] x ) { - return ValueGroup.GEOMETRY_ARRAY; + return false; } @Override - public NumberType numberType() + public boolean equals( LocalDate[] x ) { - return NumberType.NO_NUMBER; + return false; } @Override - public final boolean eq( Object other ) + public boolean equals( DurationValue[] x ) { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return false; } @Override - public int computeHash() + public boolean equals( LocalDateTime[] x ) { - return Arrays.hashCode( value() ); + return false; } @Override - public T map( ValueMapper mapper ) + public boolean equals( LocalTime[] x ) { - return mapper.mapPointArray( this ); + return false; } @Override - public void writeTo( ValueWriter writer ) throws E + public boolean equals( OffsetTime[] x ) { - PrimitiveArrayWriting.writeTo( writer, value() ); + return false; } @Override - public Object asObjectCopy() + public ValueGroup valueGroup() { - return value().clone(); + return ValueGroup.GEOMETRY_ARRAY; } @Override - @Deprecated - public Object asObject() + public NumberType numberType() { - return value(); + return NumberType.NO_NUMBER; } @Override - public String prettyPrint() + public T map( ValueMapper mapper ) { - return Arrays.toString( value() ); + return mapper.mapPointArray( this ); } - public int compareTo( PointArray other ) + @Override + public void writeTo( ValueWriter writer ) throws E { - int i = 0; - int x = 0; - int length = Math.min( this.length(), other.length() ); - - while ( x == 0 && i < length ) - { - x = this.pointValue( i ).compareTo( other.pointValue( i ) ); - i++; - } - if ( x == 0 ) - { - x = this.length() - other.length(); - } - return x; + PrimitiveArrayWriting.writeTo( writer, value() ); } - static final class Direct extends PointArray + @Override + public AnyValue value( int offset ) { - final PointValue[] value; - - Direct( PointValue[] value ) - { - assert value != null; - this.value = value; - } - - @Override - PointValue[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "PointArray%s", Arrays.toString( value() ) ); - } - - @Override - public AnyValue value( int offset ) - { - return Values.point( value[offset] ); - } + return Values.point( value[offset] ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/ScalarValue.java b/community/values/src/main/java/org/neo4j/values/storable/ScalarValue.java index 806d2b95d68d4..9d80afea64fa0 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ScalarValue.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ScalarValue.java @@ -19,6 +19,12 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; + import org.neo4j.graphdb.spatial.Geometry; /** @@ -85,4 +91,40 @@ public boolean equals( Geometry[] x ) { return false; } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return false; + } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/ShortArray.java b/community/values/src/main/java/org/neo4j/values/storable/ShortArray.java index f98e6e0e7352c..9ff21ea52db53 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ShortArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ShortArray.java @@ -22,31 +22,36 @@ import java.util.Arrays; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class ShortArray extends IntegralArray +public class ShortArray extends IntegralArray { - abstract short[] value(); + final short[] value; + + ShortArray( short[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public long longValue( int index ) { - return value()[index]; + return value[index]; } @Override public int computeHash() { - return NumberValues.hash( value() ); + return NumberValues.hash( value ); } @Override @@ -58,111 +63,79 @@ public T map( ValueMapper mapper ) @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( byte[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( short[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override public boolean equals( int[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( long[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( float[] x ) { - return PrimitiveArrayValues.equals( value(), x ); + return PrimitiveArrayValues.equals( value, x ); } @Override public boolean equals( double[] x ) { - return PrimitiveArrayValues.equals( value(), x ); - } - - @Override - public final boolean eq( Object other ) - { - if ( other == null ) - { - return false; - } - - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + return PrimitiveArrayValues.equals( value, x ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public short[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public short[] asObject() { - return value(); + return value; } @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override public AnyValue value( int offset ) { - return Values.shortValue( value()[offset] ); + return Values.shortValue( value[offset] ); } - static final class Direct extends ShortArray + @Override + public String toString() { - final short[] value; - - Direct( short[] value ) - { - assert value != null; - this.value = value; - } - - @Override - short[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "ShortArray%s", Arrays.toString( value() ) ); - } + return format( "ShortArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/StringArray.java b/community/values/src/main/java/org/neo4j/values/storable/StringArray.java index 5153b5edc6bce..46f341ffbcdf9 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/StringArray.java +++ b/community/values/src/main/java/org/neo4j/values/storable/StringArray.java @@ -19,47 +19,57 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; import java.util.Arrays; import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.AnyValue; -import org.neo4j.values.SequenceValue; import org.neo4j.values.ValueMapper; import static java.lang.String.format; -public abstract class StringArray extends TextArray +public class StringArray extends TextArray { - abstract String[] value(); + final String[] value; + + StringArray( String[] value ) + { + assert value != null; + this.value = value; + } @Override public int length() { - return value().length; + return value.length; } @Override public String stringValue( int offset ) { - return value()[offset]; + return value[offset]; } @Override public boolean equals( Value other ) { - return other.equals( value() ); + return other.equals( value ); } @Override public boolean equals( char[] x ) { - return PrimitiveArrayValues.equals( x, value() ); + return PrimitiveArrayValues.equals( x, value ); } @Override public boolean equals( String[] x ) { - return Arrays.equals( value(), x ); + return Arrays.equals( value, x ); } @Override @@ -69,43 +79,64 @@ public boolean equals( Geometry[] x ) } @Override - public final boolean eq( Object other ) + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) { - if ( other == null ) - { - return false; - } + return false; + } - if ( other instanceof SequenceValue ) - { - return this.equals( (SequenceValue) other ); - } - return other instanceof Value && equals( (Value) other ); + @Override + public boolean equals( OffsetTime[] x ) + { + return false; } @Override public int computeHash() { - return Arrays.hashCode( value() ); + return Arrays.hashCode( value ); } @Override public void writeTo( ValueWriter writer ) throws E { - PrimitiveArrayWriting.writeTo( writer, value() ); + PrimitiveArrayWriting.writeTo( writer, value ); } @Override public String[] asObjectCopy() { - return value().clone(); + return value.clone(); } @Override @Deprecated public String[] asObject() { - return value(); + return value; } @Override @@ -117,7 +148,7 @@ public int compareTo( TextArray other ) @Override public String prettyPrint() { - return Arrays.toString( value() ); + return Arrays.toString( value ); } @Override @@ -132,26 +163,9 @@ public T map( ValueMapper mapper ) return mapper.mapStringArray( this ); } - static final class Direct extends StringArray + @Override + public String toString() { - final String[] value; - - Direct( String[] value ) - { - assert value != null; - this.value = value; - } - - @Override - String[] value() - { - return value; - } - - @Override - public String toString() - { - return format( "StringArray%s", Arrays.toString( value() ) ); - } + return format( "StringArray%s", Arrays.toString( value ) ); } } diff --git a/community/values/src/main/java/org/neo4j/values/storable/TemporalArray.java b/community/values/src/main/java/org/neo4j/values/storable/TemporalArray.java new file mode 100644 index 0000000000000..06c71f9b5f17c --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/TemporalArray.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.temporal.Temporal; + +import org.neo4j.graphdb.spatial.Geometry; +import org.neo4j.values.AnyValue; + +public abstract class TemporalArray, V extends TemporalValue> extends NonPrimitiveArray +{ + + @Override + public boolean equals( Geometry[] x ) + { + return false; + } + + protected final void writeTo( ValueWriter writer, ValueWriter.ArrayType type, Temporal[] values ) throws E + { + writer.beginArray( values.length, type ); + for ( Temporal x : values ) + { + Value value = Values.temporalValue( x ); + value.writeTo( writer ); + } + writer.endArray(); + } + + @Override + public final AnyValue value( int offset ) + { + return Values.temporalValue( value()[offset] ); + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/TemporalValue.java b/community/values/src/main/java/org/neo4j/values/storable/TemporalValue.java index f4ba721795bcc..2c7fa813b159b 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/TemporalValue.java +++ b/community/values/src/main/java/org/neo4j/values/storable/TemporalValue.java @@ -45,7 +45,7 @@ import static org.neo4j.values.storable.NumberType.NO_NUMBER; public abstract class TemporalValue> - extends ScalarValue implements Temporal + extends ScalarValue implements Temporal, Comparable { TemporalValue() { diff --git a/community/values/src/main/java/org/neo4j/values/storable/TimeArray.java b/community/values/src/main/java/org/neo4j/values/storable/TimeArray.java new file mode 100644 index 0000000000000..fa5a1dc7fd6a1 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/storable/TimeArray.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002-2018 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values.storable; + +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.Arrays; + +import org.neo4j.values.ValueMapper; + +public class TimeArray extends TemporalArray +{ + final OffsetTime[] value; + + TimeArray( OffsetTime[] value ) + { + assert value != null; + this.value = value; + } + + @Override + protected OffsetTime[] value() + { + return value; + } + + @Override + public T map( ValueMapper mapper ) + { + return mapper.mapTimeArray( this ); + } + + @Override + public boolean equals( Value other ) + { + return other.equals( value ); + } + + @Override + public boolean equals( OffsetTime[] x ) + { + return Arrays.equals( value, x); + } + + @Override + public boolean equals( LocalDate[] x ) + { + return false; + } + + @Override + public boolean equals( DurationValue[] x ) + { + return false; + } + + @Override + public boolean equals( ZonedDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalDateTime[] x ) + { + return false; + } + + @Override + public boolean equals( LocalTime[] x ) + { + return false; + } + + @Override + public void writeTo( ValueWriter writer ) throws E + { + writeTo( writer, ValueWriter.ArrayType.ZONED_TIME ,value ); + } + + @Override + public ValueGroup valueGroup() + { + return ValueGroup.ZONED_TIME_ARRAY; + } +} diff --git a/community/values/src/main/java/org/neo4j/values/storable/Value.java b/community/values/src/main/java/org/neo4j/values/storable/Value.java index ac2096b709fac..76488b4cdf2ce 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/Value.java +++ b/community/values/src/main/java/org/neo4j/values/storable/Value.java @@ -19,6 +19,12 @@ */ package org.neo4j.values.storable; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; + import org.neo4j.graphdb.spatial.Geometry; import org.neo4j.values.AnyValue; import org.neo4j.values.AnyValueWriter; @@ -66,6 +72,18 @@ public boolean eq( Object other ) public abstract boolean equals( Geometry[] x ); + public abstract boolean equals( ZonedDateTime[] x ); + + public abstract boolean equals( LocalDate[] x ); + + public abstract boolean equals( DurationValue[] x ); + + public abstract boolean equals( LocalDateTime[] x ); + + public abstract boolean equals( LocalTime[] x ); + + public abstract boolean equals( OffsetTime[] x ); + @Override public Boolean ternaryEquals( AnyValue other ) { diff --git a/community/values/src/main/java/org/neo4j/values/storable/ValueComparator.java b/community/values/src/main/java/org/neo4j/values/storable/ValueComparator.java index f2858aa394742..c7cea3a8657f7 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ValueComparator.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ValueComparator.java @@ -119,6 +119,24 @@ public int compare( Value v1, Value v2 ) // Currently just Points return ((PointArray) v1).compareTo( (PointArray) v2); + case ZONED_DATE_TIME_ARRAY: + return ((DateTimeArray) v1).compareTo( (DateTimeArray) v2); + + case LOCAL_DATE_TIME_ARRAY: + return ((LocalDateTimeArray) v1).compareTo( (LocalDateTimeArray) v2); + + case LOCAL_TIME_ARRAY: + return ((LocalTimeArray) v1).compareTo( (LocalTimeArray) v2); + + case ZONED_TIME_ARRAY: + return ((TimeArray) v1).compareTo( (TimeArray) v2); + + case DATE_ARRAY: + return ((DateArray) v1).compareTo( (DateArray) v2); + + case DURATION_ARRAY: + return ((DurationArray) v1).compareTo( (DurationArray) v2); + default: throw new UnsupportedOperationException( format( "Cannot compare ValueGroup id '%s' using ValueComparator", id1 diff --git a/community/values/src/main/java/org/neo4j/values/storable/ValueGroup.java b/community/values/src/main/java/org/neo4j/values/storable/ValueGroup.java index bc71bf3de60e4..a2533c1806795 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ValueGroup.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ValueGroup.java @@ -31,6 +31,12 @@ public enum ValueGroup { UNKNOWN, GEOMETRY_ARRAY, + ZONED_DATE_TIME_ARRAY, + LOCAL_DATE_TIME_ARRAY, + DATE_ARRAY, + ZONED_TIME_ARRAY, + LOCAL_TIME_ARRAY, + DURATION_ARRAY, TEXT_ARRAY, BOOLEAN_ARRAY, NUMBER_ARRAY, diff --git a/community/values/src/main/java/org/neo4j/values/storable/ValueWriter.java b/community/values/src/main/java/org/neo4j/values/storable/ValueWriter.java index 8b5f2dac47f4c..88279932f928b 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/ValueWriter.java +++ b/community/values/src/main/java/org/neo4j/values/storable/ValueWriter.java @@ -41,7 +41,13 @@ enum ArrayType BOOLEAN, STRING, CHAR, - POINT + POINT, + ZONED_DATE_TIME, + LOCAL_DATE_TIME, + DATE, + ZONED_TIME, + LOCAL_TIME, + DURATION } void writeNull() throws E; diff --git a/community/values/src/main/java/org/neo4j/values/storable/Values.java b/community/values/src/main/java/org/neo4j/values/storable/Values.java index 1bcc6b95b04ce..198eb7b0356c9 100644 --- a/community/values/src/main/java/org/neo4j/values/storable/Values.java +++ b/community/values/src/main/java/org/neo4j/values/storable/Values.java @@ -247,47 +247,47 @@ public static FloatValue floatValue( float value ) public static TextArray stringArray( String... value ) { - return new StringArray.Direct( value ); + return new StringArray( value ); } public static ByteArray byteArray( byte[] value ) { - return new ByteArray.Direct( value ); + return new ByteArray( value ); } public static LongArray longArray( long[] value ) { - return new LongArray.Direct( value ); + return new LongArray( value ); } public static IntArray intArray( int[] value ) { - return new IntArray.Direct( value ); + return new IntArray( value ); } public static DoubleArray doubleArray( double[] value ) { - return new DoubleArray.Direct( value ); + return new DoubleArray( value ); } public static FloatArray floatArray( float[] value ) { - return new FloatArray.Direct( value ); + return new FloatArray( value ); } public static BooleanArray booleanArray( boolean[] value ) { - return new BooleanArray.Direct( value ); + return new BooleanArray( value ); } public static CharArray charArray( char[] value ) { - return new CharArray.Direct( value ); + return new CharArray( value ); } public static ShortArray shortArray( short[] value ) { - return new ShortArray.Direct( value ); + return new ShortArray( value ); } public static PointValue pointValue( CoordinateReferenceSystem crs, double... coordinate ) @@ -315,12 +315,12 @@ public static PointArray pointArray( Point[] points ) { values[i] = Values.point( points[i] ); } - return new PointArray.Direct( values ); + return new PointArray( values ); } public static PointArray pointArray( PointValue[] points ) { - return new PointArray.Direct( points ); + return new PointArray( points ); } public static CoordinateReferenceSystem crs( CRS crs ) @@ -388,14 +388,44 @@ public static DurationValue durationValue( TemporalAmount value ) return duration; } - public static ArrayValue temporalArray( Temporal[] temporals ) + public static ArrayValue dateTimeArray( ZonedDateTime[] values ) { - throw new UnsupportedOperationException( "TODO: add support for arrays of temporal values" ); + return new DateTimeArray( values ); } - public static ArrayValue durationArray( TemporalAmount[] amounts ) + public static ArrayValue localDateTimeArray( LocalDateTime[] values ) { - throw new UnsupportedOperationException( "TODO: add support for arrays of durations" ); + return new LocalDateTimeArray( values ); + } + + public static ArrayValue localTimeArray( LocalTime[] values ) + { + return new LocalTimeArray( values ); + } + + public static ArrayValue timeArray( OffsetTime[] values ) + { + return new TimeArray( values ); + } + + public static ArrayValue dateArray( LocalDate[] values ) + { + return new DateArray( values ); + } + + public static ArrayValue durationArray( DurationValue[] values ) + { + return new DurationArray( values ); + } + + public static ArrayValue durationArray( TemporalAmount[] values ) + { + DurationValue[] durations = new DurationValue[values.length]; + for(int i = 0; i < values.length; i++) + { + durations[i] = durationValue( values[i] ); + } + return new DurationArray( durations ); } // BOXED FACTORY METHODS @@ -592,10 +622,25 @@ private static Value arrayValue( Object[] value ) // no need to copy here, since the pointArray(...) method will copy into a PointValue[] return pointArray( (Point[])value ); } - if ( value instanceof Temporal[] ) + if ( value instanceof ZonedDateTime[] ) + { + return dateTimeArray( copy( value, new ZonedDateTime[value.length] ) ); + } + if ( value instanceof LocalDateTime[] ) + { + return localDateTimeArray( copy( value, new LocalDateTime[value.length] ) ); + } + if ( value instanceof LocalTime[] ) + { + return localTimeArray( copy( value, new LocalTime[value.length] ) ); + } + if ( value instanceof OffsetTime[] ) + { + return timeArray( copy( value, new OffsetTime[value.length] ) ); + } + if ( value instanceof LocalDate[] ) { - // no need to copy here, since the temporalArray(...) method will perform copying as appropriate - return temporalArray( (Temporal[]) value ); + return dateArray( copy( value, new LocalDate[value.length] ) ); } if ( value instanceof TemporalAmount[] ) { diff --git a/community/values/src/test/java/org/neo4j/values/storable/ValueComparisonTest.java b/community/values/src/test/java/org/neo4j/values/storable/ValueComparisonTest.java index a57e229f86c47..0bfa89267542b 100644 --- a/community/values/src/test/java/org/neo4j/values/storable/ValueComparisonTest.java +++ b/community/values/src/test/java/org/neo4j/values/storable/ValueComparisonTest.java @@ -23,6 +23,11 @@ import org.junit.Test; import org.junit.rules.ExpectedException; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; import java.util.Arrays; import java.util.Comparator; import java.util.List; @@ -52,6 +57,22 @@ public class ValueComparisonTest new PointValue[] { pointValue( WGS84, -1.0, -1.0 ) }, new PointValue[] { pointValue( WGS84, -1.0, -1.0 ), pointValue( WGS84, -1.0, -1.0 ) }, new PointValue[] { pointValue( WGS84, -1.0, -1.0 ), pointValue( Cartesian, 1.0, 2.0 ) }, + new ZonedDateTime[] { datetime(2018, 2, 2, 0, 0, 0, 0, "+00:00").asObjectCopy(), datetime(1991, 2, 2, 1, 30, 0, 0, "+00:00").asObjectCopy() }, + new ZonedDateTime[] { datetime(2018, 2, 2, 0, 0, 0, 0, "+00:00").asObjectCopy(), datetime(1992, 2, 2, 1, 30, 0, 0, "+00:00").asObjectCopy() }, + new ZonedDateTime[] { datetime(2019, 2, 2, 0, 0, 0, 0, "+00:00").asObjectCopy(), datetime(1991, 2, 2, 1, 30, 0, 0, "+00:00").asObjectCopy() }, + new LocalDateTime[] {}, + new LocalDateTime[] { localDateTime(2019, 2, 2, 0, 0, 0, 0).asObjectCopy(), localDateTime(1991, 2, 2, 1, 30, 0, 0).asObjectCopy() }, + new LocalDate[]{ date( 2018, 2, 1 ).asObjectCopy() }, + new LocalDate[]{ date( 2018, 2, 1 ).asObjectCopy(), date( 2019, 2, 1 ).asObjectCopy() }, + new OffsetTime[]{ time(0, 0, 0, 1, "+00:00").asObjectCopy() }, + new OffsetTime[]{ time(0, 0, 1, 0, "+00:00").asObjectCopy() }, + new OffsetTime[]{ time(0, 0, 1, 0, "+00:00").asObjectCopy(), time(0, 0, 1, 0, "+00:00").asObjectCopy() }, + new LocalTime[]{ localTime(0, 0, 0, 1).asObjectCopy() }, + new LocalTime[]{ localTime(0, 0, 1, 0).asObjectCopy() }, + new LocalTime[]{ localTime(0, 0, 1, 0).asObjectCopy(), localTime(0, 0, 1, 0).asObjectCopy() }, + new DurationValue[] { duration(0, 0, 0, 0) }, + new DurationValue[] { duration(0, 0, 0, 1) }, + new DurationValue[] { duration(0, 0, 0, 1), duration(0, 0, 1, 0) }, new String[]{}, new String[]{"a"}, new String[]{"a", "aa"},