diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalEntity.java b/driver/src/main/java/org/neo4j/driver/internal/InternalEntity.java index 5f761e51b0..254a776c25 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalEntity.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalEntity.java @@ -26,7 +26,7 @@ import org.neo4j.driver.v1.Entity; import org.neo4j.driver.v1.Function; import org.neo4j.driver.v1.Identity; -import org.neo4j.driver.v1.Property; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; @@ -50,12 +50,7 @@ public Identity identity() } @Override - public Property property( String key ) - { - return InternalProperty.of( key, value( key ) ); - } - - public int propertyCount() + public int size() { return properties.size(); } @@ -130,13 +125,13 @@ public Iterable values( Function mapFunction ) } @Override - public Iterable> properties() + public Iterable> properties() { return properties( valueAsIs() ); } @Override - public Iterable> properties( final Function Function ) + public Iterable> properties( final Function Function ) { return Extract.properties( this, Function ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalField.java b/driver/src/main/java/org/neo4j/driver/internal/InternalField.java deleted file mode 100644 index 0474d353c6..0000000000 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalField.java +++ /dev/null @@ -1,110 +0,0 @@ -/** - * Copyright (c) 2002-2015 "Neo Technology," - * Network Engine for Objects in Lund AB [http://neotechnology.com] - * - * This file is part of Neo4j. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.neo4j.driver.internal; - -import java.util.Objects; - -import org.neo4j.driver.v1.Field; -import org.neo4j.driver.v1.Function; -import org.neo4j.driver.v1.Property; - -public class InternalField implements Field -{ - private final int index; - private final String key; - private final V value; - - public InternalField( String key, int index, V value ) - { - if ( key == null ) - { - throw new IllegalArgumentException( "null key" ); - } - if ( value == null ) - { - throw new IllegalArgumentException( "null value" ); - } - this.index = index; - this.key = key; - this.value = value; - } - - public String key() - { - return key; - } - - public V value() - { - return value; - } - - @Override - public int index() - { - return index; - } - - @Override - public Property asProperty() - { - return InternalProperty.of( key, value ); - } - - @Override - public String toString() - { - return String.format( "%s: %s", key, Objects.toString( value ) ); - } - - public String toString( Function printValue ) - { - return String.format( "%s: %s", key, printValue.apply( value ) ); - } - - @Override - public boolean equals( Object o ) - { - if ( this == o ) - { - return true; - } - if ( o == null || getClass() != o.getClass() ) - { - return false; - } - - InternalField that = (InternalField) o; - return index == that.index && key.equals( that.key ) && value.equals( that.value ); - } - - @Override - public int hashCode() - { - int result = index; - result = 31 * result + key.hashCode(); - result = 31 * result + value.hashCode(); - return result; - } - - public static Field of( String key, int index, V value ) - { - return new InternalField<>( key, index, value ); - } -} diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalProperty.java b/driver/src/main/java/org/neo4j/driver/internal/InternalPair.java similarity index 71% rename from driver/src/main/java/org/neo4j/driver/internal/InternalProperty.java rename to driver/src/main/java/org/neo4j/driver/internal/InternalPair.java index 28c4f04692..a0287ded32 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalProperty.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalPair.java @@ -21,28 +21,22 @@ import java.util.Objects; import org.neo4j.driver.v1.Function; -import org.neo4j.driver.v1.Property; +import org.neo4j.driver.v1.Pair; -public class InternalProperty implements Property +public class InternalPair implements Pair { - private final String key; + private final K key; private final V value; - protected InternalProperty( String key, V value ) + protected InternalPair( K key, V value ) { - if ( key == null ) - { - throw new IllegalArgumentException( "null key" ); - } - if ( value == null ) - { - throw new IllegalArgumentException( "null value" ); - } + Objects.requireNonNull( key ); + Objects.requireNonNull( value ); this.key = key; this.value = value; } - public String key() + public K key() { return key; } @@ -52,15 +46,15 @@ public V value() return value; } - public static Property of( String key, V value ) + public static Pair of( K key, V value ) { - return new InternalProperty<>( key, value ); + return new InternalPair<>( key, value ); } @Override public String toString() { - return String.format( "%s: %s", key, Objects.toString( value ) ); + return String.format( "%s: %s", Objects.toString( key ), Objects.toString( value ) ); } public String toString( Function printValue ) @@ -80,7 +74,7 @@ public boolean equals( Object o ) return false; } - InternalProperty that = (InternalProperty) o; + InternalPair that = (InternalPair) o; return key.equals( that.key ) && value.equals( that.value ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalRecord.java b/driver/src/main/java/org/neo4j/driver/internal/InternalRecord.java index 5d07d2e06b..895cc0d52b 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalRecord.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalRecord.java @@ -24,15 +24,14 @@ import java.util.NoSuchElementException; import org.neo4j.driver.internal.util.Extract; -import org.neo4j.driver.v1.Function; +import org.neo4j.driver.internal.value.InternalValue; import org.neo4j.driver.v1.Record; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; import static java.lang.String.format; -import static org.neo4j.driver.internal.util.Format.formatFields; -import static org.neo4j.driver.internal.value.InternalValue.Format.VALUE_WITH_TYPE; +import static org.neo4j.driver.internal.util.Format.formatPairs; import static org.neo4j.driver.v1.Values.valueAsIs; public class InternalRecord extends InternalRecordAccessor implements Record @@ -49,18 +48,6 @@ public InternalRecord( List keys, Map keyIndexLookup, V this.values = values; } - @Override - public Value value( int index ) - { - return index >= 0 && index < values.length ? values[index] : Values.NULL; - } - - @Override - public String key( int index ) - { - return keys.get( index ); - } - @Override public List keys() { @@ -103,26 +90,39 @@ public Value value( String key ) } @Override - public Record record() + public Value value( int index ) { - return this; + return index >= 0 && index < values.length ? values[index] : Values.NULL; } @Override - public Map asMap() + public int size() { - return asMap( valueAsIs() ); + return values.length; } - public Map asMap( Function mapFunction ) + @Override + public boolean hasRecord() + { + return true; + } + + @Override + public Record record() + { + return this; + } + + @Override + public Map asMap() { - return Extract.map( this, mapFunction ); + return Extract.map( this, valueAsIs() ); } @Override public String toString() { - return format( "Record<%s>", formatFields( VALUE_WITH_TYPE, fieldCount(), fields() ) ); + return format( "Record<%s>", formatPairs( InternalValue.Format.VALUE_WITH_TYPE, size(), fields() ) ); } public boolean equals( Object other ) @@ -134,8 +134,8 @@ public boolean equals( Object other ) else if ( other instanceof Record ) { Record otherRecord = (Record) other; - int size = fieldCount(); - if ( ! ( size == otherRecord.fieldCount() ) ) + int size = size(); + if ( ! ( size == otherRecord.size() ) ) { return false; } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalRecordAccessor.java b/driver/src/main/java/org/neo4j/driver/internal/InternalRecordAccessor.java index 9b00da71e8..d3bcecffcc 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalRecordAccessor.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalRecordAccessor.java @@ -21,8 +21,7 @@ import java.util.List; import org.neo4j.driver.internal.util.Extract; -import org.neo4j.driver.v1.Field; -import org.neo4j.driver.v1.Function; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.RecordAccessor; import org.neo4j.driver.v1.Value; @@ -31,33 +30,8 @@ public abstract class InternalRecordAccessor implements RecordAccessor { @Override - public int fieldCount() + public List> fields() { - return keys().size(); - } - - @Override - public Field field( String key ) - { - int index = index( key ); - return InternalField.of( key, index, value( index ) ); - } - - @Override - public Field field( int index ) - { - return InternalField.of( key( index ), index, value( index) ); - } - - @Override - public List> fields() - { - return fields( valueAsIs() ); - } - - @Override - public List> fields( final Function mapFunction ) - { - return Extract.fields( this, mapFunction ); + return Extract.fields( this, valueAsIs() ); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java b/driver/src/main/java/org/neo4j/driver/internal/InternalResultCursor.java similarity index 54% rename from driver/src/main/java/org/neo4j/driver/internal/InternalResult.java rename to driver/src/main/java/org/neo4j/driver/internal/InternalResultCursor.java index 607b263745..74fd672a5f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalResult.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalResultCursor.java @@ -19,35 +19,38 @@ package org.neo4j.driver.internal; import java.util.ArrayList; -import java.util.Iterator; import java.util.List; import org.neo4j.driver.v1.Function; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.Record; import org.neo4j.driver.v1.RecordAccessor; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.ResultSummary; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.exceptions.ClientException; +import org.neo4j.driver.v1.exceptions.NoRecordException; +import static java.lang.String.format; import static java.util.Collections.emptyList; import static org.neo4j.driver.v1.Records.recordAsIs; -public class InternalResult extends InternalRecordAccessor implements Result +public class InternalResultCursor extends InternalRecordAccessor implements ResultCursor { private final List keys; - private final Iterator iter; + private final PeekingIterator iter; private final ResultSummary summary; private boolean open = true; private Record current = null; private long position = -1; + private long limit = -1; - public InternalResult( List keys, List body, ResultSummary summary ) + public InternalResultCursor( List keys, List body, ResultSummary summary ) { this.keys = keys; - this.iter = body.iterator(); + this.iter = new PeekingIterator<>( body.iterator() ); this.summary = summary; } @@ -73,12 +76,6 @@ public boolean containsKey( String key ) return keys.contains( key ); } - @Override - public String key( int index ) - { - return record().key( index ); - } - @Override public int index( String key ) { @@ -90,23 +87,33 @@ public List keys() return keys; } - private Value throwNoRecord() + @Override + public int size() { - throw new ClientException( - "In order to access fields of a record in a result, " + - "you must first call next() to point the result to the next record in the result stream." - ); + return keys.size(); } @Override - public Record record() + public boolean hasRecord() { assertOpen(); - if ( current == null ) + return current != null && current.hasRecord(); + } + + @Override + public Record record() + { + if ( hasRecord() ) + { + return current; + } + else { - throwNoRecord(); + throw new NoRecordException( + "In order to access the fields of a record in a result, " + + "you must first call next() to point the result to the next record in the result stream." + ); } - return current; } @Override @@ -131,6 +138,10 @@ public boolean next() { current = iter.next(); position += 1; + if ( position == limit ) + { + discard(); + } return true; } else @@ -144,7 +155,7 @@ public long skip( long elements ) { if ( elements < 0 ) { - throw new IllegalArgumentException( "Cannot skip negative number of elements" ); + throw new ClientException( "Cannot skip negative number of elements" ); } else { @@ -157,6 +168,22 @@ public long skip( long elements ) } } + @Override + public long limit( long records ) + { + if ( records < 0 ) + { + throw new ClientException( "Cannot limit negative number of elements" ); + } + else if ( records == 0) { + this.limit = position; + discard(); + } else { + this.limit = records + position; + } + return this.limit; + } + @Override public boolean first() { @@ -170,6 +197,12 @@ public boolean single() return first() && atEnd(); } + @Override + public RecordAccessor peek() + { + return new PeekingRecordAccessor(); + } + @Override public List retain() { @@ -192,14 +225,14 @@ else if ( first() ) result.add( mapFunction.apply( this ) ); } while ( next() ); + discard(); return result; } else { - throw new - ClientException( String.format( - "Can't retain records when cursor is not pointing at the first record (currently at position %d)", - position ) ); + throw new ClientException( + format( "Can't retain records when cursor is not pointing at the first record (currently at position %d)", position ) + ); } } @@ -208,6 +241,7 @@ else if ( first() ) public ResultSummary summarize() { while ( next() ) ; + discard(); return summary; } @@ -216,11 +250,20 @@ public void close() { if ( open ) { + discard(); open = false; } else { - throw new IllegalStateException( "Already closed" ); + throw new ClientException( "Already closed" ); + } + } + + private void assertOpen() + { + if ( !open ) + { + throw new ClientException( "Cursor already closed" ); } } @@ -229,11 +272,73 @@ private boolean isEmpty() return position == -1 && !iter.hasNext(); } - private void assertOpen() + private void discard() { - if ( !open ) + iter.discard(); + } + + private class PeekingRecordAccessor implements RecordAccessor + { + @Override + public List keys() + { + return InternalResultCursor.this.keys(); + } + + @Override + public boolean containsKey( String key ) + { + return InternalResultCursor.this.containsKey( key ); + } + + @Override + public int index( String key ) + { + return InternalResultCursor.this.index( key ); + } + + @Override + public Value value( String key ) + { + return record().value( key ); + } + + @Override + public int size() + { + return InternalResultCursor.this.size(); + } + + @Override + public List> fields() + { + return record().fields(); + } + + @Override + public boolean hasRecord() + { + return iter.hasNext(); + } + + @Override + public Record record() + { + Record record = iter.peek(); + if ( record == null ) + { + throw new NoRecordException( "Cannot peek past last record" ); + } + else + { + return record; + } + } + + @Override + public Value value( int index ) { - throw new IllegalStateException( "Cursor already closed" ); + return record().value( index ); } } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java index 180450aff2..b2ad521483 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalSession.java @@ -23,7 +23,7 @@ import org.neo4j.driver.internal.spi.Connection; import org.neo4j.driver.internal.summary.ResultBuilder; import org.neo4j.driver.internal.types.InternalTypeSystem; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Statement; import org.neo4j.driver.v1.Transaction; @@ -54,7 +54,7 @@ public InternalSession( Connection connection ) } @Override - public Result run( String statementText, Map statementParameters ) + public ResultCursor run( String statementText, Map statementParameters ) { ensureNoOpenTransaction(); ResultBuilder resultBuilder = new ResultBuilder( statementText, statementParameters ); @@ -66,13 +66,13 @@ public Result run( String statementText, Map statementParameters ) } @Override - public Result run( String statementTemplate ) + public ResultCursor run( String statementTemplate ) { return run( statementTemplate, ParameterSupport.NO_PARAMETERS ); } @Override - public Result run( Statement statement ) + public ResultCursor run( Statement statement ) { return run( statement.template(), statement.parameters() ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java index 79da7d8d4d..6a3070853e 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java +++ b/driver/src/main/java/org/neo4j/driver/internal/InternalTransaction.java @@ -24,7 +24,7 @@ import org.neo4j.driver.internal.spi.Connection; import org.neo4j.driver.internal.summary.ResultBuilder; import org.neo4j.driver.internal.types.InternalTypeSystem; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Statement; import org.neo4j.driver.v1.Transaction; import org.neo4j.driver.v1.TypeSystem; @@ -120,7 +120,7 @@ else if ( state == State.MARKED_FAILED || state == State.ACTIVE ) @Override @SuppressWarnings( "unchecked" ) - public Result run( String statementText, Map statementParameters ) + public ResultCursor run( String statementText, Map statementParameters ) { ensureNotFailed(); @@ -140,13 +140,13 @@ public Result run( String statementText, Map statementParameters ) } @Override - public Result run( String statementTemplate ) + public ResultCursor run( String statementTemplate ) { return run( statementTemplate, ParameterSupport.NO_PARAMETERS ); } @Override - public Result run( Statement statement ) + public ResultCursor run( Statement statement ) { return run( statement.template(), statement.parameters() ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/PeekingIterator.java b/driver/src/main/java/org/neo4j/driver/internal/PeekingIterator.java new file mode 100644 index 0000000000..3a8019113c --- /dev/null +++ b/driver/src/main/java/org/neo4j/driver/internal/PeekingIterator.java @@ -0,0 +1,93 @@ +/** + * Copyright (c) 2002-2015 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal; + +import java.util.Iterator; +import java.util.NoSuchElementException; + +public class PeekingIterator implements Iterator +{ + private Iterator iterator; + private T cached; + + public PeekingIterator( Iterator iterator ) + { + this.iterator = iterator.hasNext() ? iterator : null; + + } + + public T peek() + { + return cacheNext() ? cached : null; + } + + public boolean hasNext() + { + return cacheNext(); + } + + public T next() + { + if ( cacheNext() ) + { + T result = cached; + cached = null; + return result; + } + else + { + throw new NoSuchElementException(); + } + } + + @Override + public void remove() + { + throw new UnsupportedOperationException(); + } + + private boolean cacheNext() + { + if ( cached == null ) + { + if ( iterator == null ) + { + return false; + } + else + { + cached = iterator.next(); + if (! iterator.hasNext()) { + this.iterator = null; + } + return true; + } + } + else + { + return true; + } + } + + public void discard() + { + this.cached = null; + this.iterator = null; + } +} diff --git a/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java b/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java index e9b31909c4..1789e1898a 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java +++ b/driver/src/main/java/org/neo4j/driver/internal/messaging/PackStreamMessageFormatV1.java @@ -367,7 +367,7 @@ private void packNode( Node node ) throws IOException private void packProperties( Entity entity ) throws IOException { Iterable keys = entity.keys(); - packer.packMapHeader( entity.propertyCount() ); + packer.packMapHeader( entity.size() ); for ( String propKey : keys ) { packer.pack( propKey ); diff --git a/driver/src/main/java/org/neo4j/driver/internal/summary/ResultBuilder.java b/driver/src/main/java/org/neo4j/driver/internal/summary/ResultBuilder.java index d47e787446..dab1c75758 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/summary/ResultBuilder.java +++ b/driver/src/main/java/org/neo4j/driver/internal/summary/ResultBuilder.java @@ -25,13 +25,13 @@ import java.util.Map; import org.neo4j.driver.internal.InternalRecord; -import org.neo4j.driver.internal.InternalResult; +import org.neo4j.driver.internal.InternalResultCursor; import org.neo4j.driver.internal.spi.StreamCollector; import org.neo4j.driver.v1.Notification; import org.neo4j.driver.v1.Plan; import org.neo4j.driver.v1.ProfiledPlan; import org.neo4j.driver.v1.Record; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Statement; import org.neo4j.driver.v1.StatementType; import org.neo4j.driver.v1.UpdateStatistics; @@ -124,8 +124,8 @@ public void notifications( List notifications ) summaryBuilder.notifications( notifications ); } - public Result build() + public ResultCursor build() { - return new InternalResult( keys, body, summaryBuilder.build() ); + return new InternalResultCursor( keys, body, summaryBuilder.build() ); } } diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/Extract.java b/driver/src/main/java/org/neo4j/driver/internal/util/Extract.java index 892f1098c8..9fd42ad3e5 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/Extract.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/Extract.java @@ -21,16 +21,13 @@ import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; -import org.neo4j.driver.internal.InternalField; -import org.neo4j.driver.internal.InternalProperty; -import org.neo4j.driver.v1.Field; +import org.neo4j.driver.internal.InternalPair; import org.neo4j.driver.v1.Function; import org.neo4j.driver.v1.MapAccessor; -import org.neo4j.driver.v1.Property; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.RecordAccessor; import org.neo4j.driver.v1.Value; @@ -117,7 +114,7 @@ public static Map map( Map data, Function Map map( RecordAccessor record, Function mapFunction ) { - int size = record.keys().size(); + int size = record.size(); switch ( size ) { case 0: @@ -137,41 +134,35 @@ public static Map map( RecordAccessor record, Function } } - public static Iterable> properties( final MapAccessor map, final Function mapFunction ) + public static Iterable> properties( final MapAccessor map, final Function mapFunction ) { - return new Iterable>() + int size = map.size(); + switch ( size ) { - @Override - public Iterator> iterator() + case 0: + return emptyList(); + + case 1: + { + String key = map.keys().iterator().next(); + Value value = map.value( key ); + return singletonList( InternalPair.of( key, mapFunction.apply( value ) ) ); + } + + default: { - final Iterator keys = map.keys().iterator(); - return new Iterator>() + List> list = new ArrayList<>( size ); + for ( String key : map.keys() ) { - @Override - public boolean hasNext() - { - return keys.hasNext(); - } - - @Override - public Property next() - { - String key = keys.next(); - Value value = map.value( key ); - return InternalProperty.of( key, mapFunction.apply( value ) ); - } - - @Override - public void remove() - { - keys.remove(); - } - }; + Value value = map.value( key ); + list.add( InternalPair.of( key, mapFunction.apply( value ) ) ); + } + return unmodifiableList( list ); } - }; + } } - public static List> fields( final RecordAccessor map, final Function mapFunction ) + public static List> fields( final RecordAccessor map, final Function mapFunction ) { int size = map.keys().size(); switch ( size ) @@ -183,18 +174,18 @@ public static List> fields( final RecordAccessor map, final Functio { String key = map.keys().iterator().next(); Value value = map.value( key ); - return singletonList( InternalField.of( key, 0, mapFunction.apply( value ) ) ); + return singletonList( InternalPair.of( key, mapFunction.apply( value ) ) ); } default: { - List> list = new ArrayList<>( size ); + List> list = new ArrayList<>( size ); List keys = map.keys(); for ( int i = 0; i < size; i++ ) { String key = keys.get( i ); Value value = map.value( i ); - list.add( InternalField.of( key, i, mapFunction.apply( value ) ) ); + list.add( InternalPair.of( key, mapFunction.apply( value ) ) ); } return unmodifiableList( list ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/util/Format.java b/driver/src/main/java/org/neo4j/driver/internal/util/Format.java index 225b7cc44c..4be5a1eb3f 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/util/Format.java +++ b/driver/src/main/java/org/neo4j/driver/internal/util/Format.java @@ -20,11 +20,9 @@ import java.util.Iterator; -import org.neo4j.driver.internal.InternalField; -import org.neo4j.driver.internal.InternalProperty; -import org.neo4j.driver.v1.Field; +import org.neo4j.driver.internal.InternalPair; import org.neo4j.driver.v1.Function; -import org.neo4j.driver.v1.Property; +import org.neo4j.driver.v1.Pair; public abstract class Format { @@ -33,9 +31,9 @@ private Format() throw new UnsupportedOperationException(); } - public static String formatProperties( Function printValue, - int propertyCount, - Iterable> properties ) + public static String formatPairs( Function printValue, + int propertyCount, + Iterable> Entries ) { switch ( propertyCount ) { case 0: @@ -43,20 +41,20 @@ public static String formatProperties( Function printValue, case 1: { - return String.format( "{%s}", internalProperty( properties.iterator().next() ).toString( printValue ) ); + return String.format( "{%s}", internalPair( Entries.iterator().next() ).toString( printValue ) ); } default: { StringBuilder builder = new StringBuilder(); builder.append( "{" ); - Iterator> iterator = properties.iterator(); - builder.append( internalProperty( iterator.next() ).toString( printValue ) ); + Iterator> iterator = Entries.iterator(); + builder.append( internalPair( iterator.next() ).toString( printValue ) ); while ( iterator.hasNext() ) { builder.append( ',' ); builder.append( ' ' ); - builder.append( internalProperty( iterator.next() ).toString( printValue ) ); + builder.append( internalPair( iterator.next() ).toString( printValue ) ); } builder.append( "}" ); return builder.toString(); @@ -65,46 +63,9 @@ public static String formatProperties( Function printValue, } @SuppressWarnings("unchecked") - private static InternalProperty internalProperty( Property property ) + private static InternalPair internalPair( Pair property ) { - return (InternalProperty) property; - } - - public static String formatFields( Function printValue, - int propertyCount, - Iterable> fields ) - { - switch ( propertyCount ) { - case 0: - return "{}"; - - case 1: - { - return String.format( "{%s}", internalField( fields.iterator().next() ).toString( printValue ) ); - } - - default: - { - StringBuilder builder = new StringBuilder(); - builder.append( "{" ); - Iterator> iterator = fields.iterator(); - builder.append( internalField( iterator.next() ).toString( printValue ) ); - while ( iterator.hasNext() ) - { - builder.append( ',' ); - builder.append( ' ' ); - builder.append( internalField( iterator.next() ).toString( printValue ) ); - } - builder.append( "}" ); - return builder.toString(); - } - } - } - - @SuppressWarnings("unchecked") - private static InternalField internalField( Field property ) - { - return (InternalField) property; + return (InternalPair) property; } public static String formatElements( Function printValue, V[] elements ) diff --git a/driver/src/main/java/org/neo4j/driver/internal/value/EntityValueAdapter.java b/driver/src/main/java/org/neo4j/driver/internal/value/EntityValueAdapter.java index aa24474c41..f31fb7fa7d 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/value/EntityValueAdapter.java +++ b/driver/src/main/java/org/neo4j/driver/internal/value/EntityValueAdapter.java @@ -34,9 +34,9 @@ public V asEntity() } @Override - public int propertyCount() + public int size() { - return asEntity().propertyCount(); + return asEntity().size(); } @Override diff --git a/driver/src/main/java/org/neo4j/driver/internal/value/GraphValueAdapter.java b/driver/src/main/java/org/neo4j/driver/internal/value/GraphValueAdapter.java index 5c3f14b64d..ee27bb7f3c 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/value/GraphValueAdapter.java +++ b/driver/src/main/java/org/neo4j/driver/internal/value/GraphValueAdapter.java @@ -33,12 +33,6 @@ protected GraphValueAdapter( V adapted ) this.adapted = adapted; } - @Override - public int size() - { - return propertyCount(); - } - @Override public V asObject() { diff --git a/driver/src/main/java/org/neo4j/driver/internal/value/MapValue.java b/driver/src/main/java/org/neo4j/driver/internal/value/MapValue.java index db9ab1f183..b50ab84825 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/value/MapValue.java +++ b/driver/src/main/java/org/neo4j/driver/internal/value/MapValue.java @@ -27,7 +27,7 @@ import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; -import static org.neo4j.driver.internal.util.Format.formatProperties; +import static org.neo4j.driver.internal.util.Format.formatPairs; import static org.neo4j.driver.internal.value.InternalValue.Format.VALUE_ONLY; import static org.neo4j.driver.v1.Values.valueAsObject; @@ -70,12 +70,6 @@ public Map asMap( Function mapFunction ) @Override public int size() - { - return propertyCount(); - } - - @Override - public int propertyCount() { return val.size(); } @@ -122,7 +116,7 @@ public String toString( Format valueFormat ) { return maybeWithType( valueFormat.includeType(), - formatProperties( valueFormat.inner(), propertyCount(), properties() ) + formatPairs( valueFormat.inner(), size(), properties() ) ); } diff --git a/driver/src/main/java/org/neo4j/driver/internal/value/ValueAdapter.java b/driver/src/main/java/org/neo4j/driver/internal/value/ValueAdapter.java index 44336cad75..064eb8d881 100644 --- a/driver/src/main/java/org/neo4j/driver/internal/value/ValueAdapter.java +++ b/driver/src/main/java/org/neo4j/driver/internal/value/ValueAdapter.java @@ -21,7 +21,6 @@ import java.util.List; import java.util.Map; -import org.neo4j.driver.internal.InternalProperty; import org.neo4j.driver.internal.types.TypeConstructor; import org.neo4j.driver.internal.types.TypeRepresentation; import org.neo4j.driver.internal.util.Extract; @@ -29,8 +28,8 @@ import org.neo4j.driver.v1.Function; import org.neo4j.driver.v1.Identity; import org.neo4j.driver.v1.Node; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.Path; -import org.neo4j.driver.v1.Property; import org.neo4j.driver.v1.Relationship; import org.neo4j.driver.v1.Type; import org.neo4j.driver.v1.Value; @@ -303,25 +302,13 @@ public Iterable values( Function mapFunction ) } @Override - public int propertyCount() - { - throw new NotMultiValued( type().name() + " is not a property map" ); - } - - @Override - public Property property( String key ) - { - return InternalProperty.of( key, value( key ) ); - } - - @Override - public Iterable> properties() + public Iterable> properties() { return properties( valueAsIs() ); } @Override - public Iterable> properties( final Function mapFunction ) + public Iterable> properties( final Function mapFunction ) { return Extract.properties( this, mapFunction ); } diff --git a/driver/src/main/java/org/neo4j/driver/v1/Driver.java b/driver/src/main/java/org/neo4j/driver/v1/Driver.java index 5b529135cd..98e500efcb 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Driver.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Driver.java @@ -48,11 +48,11 @@ * } * * // Retrieve results - * Result result = session.run( "MATCH (n) RETURN n.name" ); + * ResultCursor cursor = session.run( "MATCH (n) RETURN n.name" ); * List names = new LinkedList<>(); - * while( result.next() ) + * while( cursor.next() ) * { - * names.add( result.value("n.name").asString() ); + * names.add( cursor.value("n.name").asString() ); * } * * // Sessions are pooled, to avoid the overhead of creating new connections - this means diff --git a/driver/src/main/java/org/neo4j/driver/v1/Entity.java b/driver/src/main/java/org/neo4j/driver/v1/Entity.java index 0a703380f9..5387233a6d 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Entity.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Entity.java @@ -22,7 +22,7 @@ * A uniquely identifiable property container that can form part of a Neo4j graph. */ @Immutable -public interface Entity extends PropertyMapAccessor +public interface Entity extends MapAccessor { /** * A unique {@link Identity identity} for this Entity. Identities are guaranteed diff --git a/driver/src/main/java/org/neo4j/driver/v1/Immutable.java b/driver/src/main/java/org/neo4j/driver/v1/Immutable.java index ed5bb43d1f..28bb04f3f6 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Immutable.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Immutable.java @@ -26,7 +26,8 @@ import java.lang.annotation.Target; /** - * Indicates that instances of an annotated class are immutable + * Indicates that instances of the annotated class or of its subclasses are immutable, i.e. + * do not provide any means of mutating their state */ @Inherited @Retention(RetentionPolicy.RUNTIME) diff --git a/driver/src/main/java/org/neo4j/driver/v1/ListAccessor.java b/driver/src/main/java/org/neo4j/driver/v1/ListAccessor.java index 15fd74c4ff..84749e4527 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/ListAccessor.java +++ b/driver/src/main/java/org/neo4j/driver/v1/ListAccessor.java @@ -38,6 +38,13 @@ public interface ListAccessor * @throws ClientException if record has not been initialized */ Value value( int index ); + + /** + * Retrieve the number of elements in this list + * + * @return the number of elements in this list + */ + int size(); } diff --git a/driver/src/main/java/org/neo4j/driver/v1/MapAccessor.java b/driver/src/main/java/org/neo4j/driver/v1/MapAccessor.java index 2962060efa..ba1dade4e0 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/MapAccessor.java +++ b/driver/src/main/java/org/neo4j/driver/v1/MapAccessor.java @@ -52,4 +52,47 @@ public interface MapAccessor * @throws ClientException if record has not been initialized */ Value value( String key ); + + /** + * Retrieve the number of entries in this map + * + * @return the number of entries in this map + */ + int size(); + + /** + * Retrieve all values of the underlying collection + * + * @return all values in unspecified order + */ + Iterable values(); + + /** + * Map and retrieve all values of the underlying collection + * + * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such + * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. + * @param the target type of mapping + * @return the result of mapping all values in unspecified order + */ + Iterable values( Function mapFunction ); + + /** + * Retrieve all properties of the underlying map + * + * @see Pair + * @return all properties in unspecified order + */ + Iterable> properties(); + + /** + * Retrieve all properties of the underlying map + * + * @see Pair + * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such + * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. + * @param the target type of mapping + * @return all mapped properties in unspecified order + */ + Iterable> properties( Function mapFunction ); } diff --git a/driver/src/main/java/org/neo4j/driver/v1/Property.java b/driver/src/main/java/org/neo4j/driver/v1/Pair.java similarity index 92% rename from driver/src/main/java/org/neo4j/driver/v1/Property.java rename to driver/src/main/java/org/neo4j/driver/v1/Pair.java index 57dd57abe5..2a7267d516 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Property.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Pair.java @@ -21,16 +21,17 @@ /** * Immutable pair of a key and a value * - * @see PropertyMapAccessor + * @see MapAccessor + * @see RecordAccessor * @param the Java type of the contained value */ @Immutable -public interface Property +public interface Pair { /** * @return the property key */ - String key(); + K key(); /** * @return the property value diff --git a/driver/src/main/java/org/neo4j/driver/v1/PropertyMapAccessor.java b/driver/src/main/java/org/neo4j/driver/v1/PropertyMapAccessor.java deleted file mode 100644 index 0995cf61cd..0000000000 --- a/driver/src/main/java/org/neo4j/driver/v1/PropertyMapAccessor.java +++ /dev/null @@ -1,77 +0,0 @@ -/** - * Copyright (c) 2002-2015 "Neo Technology," - * Network Engine for Objects in Lund AB [http://neotechnology.com] - * - * This file is part of Neo4j. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.neo4j.driver.v1; - -/** - * Access the properties of an underlying unordered map - * - * This provides only read methods. Subclasses may chose to provide additional methods - * for changing the underlying map. - */ -public interface PropertyMapAccessor extends MapAccessor -{ - /** - * Retrieve all values of the underlying collection - * - * @return all values in unspecified order - */ - Iterable values(); - - /** - * Map and retrieve all values of the underlying collection - * - * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such - * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. - * @param the target type of mapping - * @return the result of mapping all values in unspecified order - */ - Iterable values( Function mapFunction ); - - /** - * @return number of properties in this property map - */ - int propertyCount(); - - /** - * Retrieve the property for the given key - * - * @param key the key of the property - * @return the property for the given key or a property with a null value if the key is unknown - */ - Property property( String key ); - - /** - * Retrieve all properties of the underlying map - * - * @see Property - * @return all properties in unspecified order - */ - Iterable> properties(); - - /** - * Retrieve all properties of the underlying map - * - * @see Property - * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such - * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. - * @param the target type of mapping - * @return all mapped properties in unspecified order - */ - Iterable> properties( Function mapFunction ); -} diff --git a/driver/src/main/java/org/neo4j/driver/v1/Record.java b/driver/src/main/java/org/neo4j/driver/v1/Record.java index 6e7ffe40ec..81d5ff7e91 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Record.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Record.java @@ -23,25 +23,18 @@ /** * A record is an immutable copy of an ordered map * - * @see Result#record() - * @see Result#retain() + * @see ResultCursor#record() + * @see ResultCursor#retain() */ @Immutable public interface Record extends RecordAccessor { /** - * @return the value as a value map + * Return this record as a value map, e.g. for use as parameters for executing a follow-up statement + * @return this record as a value map */ Map asMap(); - /** - * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such - * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. - * @param the type of map values - * @return the value as a map from string keys to values of type T - */ - Map asMap( Function mapFunction ); - // Force implementation @Override boolean equals( Object other ); diff --git a/driver/src/main/java/org/neo4j/driver/v1/RecordAccessor.java b/driver/src/main/java/org/neo4j/driver/v1/RecordAccessor.java index dc41225d4e..3bb71b0b56 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/RecordAccessor.java +++ b/driver/src/main/java/org/neo4j/driver/v1/RecordAccessor.java @@ -20,7 +20,8 @@ import java.util.List; -import org.neo4j.driver.v1.exceptions.ClientException; +import org.neo4j.driver.internal.value.NullValue; +import org.neo4j.driver.v1.exceptions.NoRecordException; /** * Access an underlying record (which is an ordered map of fields) @@ -28,20 +29,24 @@ * This provides only read methods. Subclasses may chose to provide additional methods * for changing the underlying record. * - * @see Field + * @see Pair */ -public interface RecordAccessor extends ListAccessor, MapAccessor +public interface RecordAccessor extends ListAccessor { - @Override + /** + * Retrieve the keys of the underlying map + * + * @return all map keys in unspecified order + */ List keys(); /** - * Retrieve the key of the field for the given index + * Check if the list of keys contains the given key * - * @param index the index of the key - * @return the key of the field for the given index + * @param key the key + * @return true if this map keys contains the given key otherwise false */ - String key( int index ); + boolean containsKey( String key ); /** * Retrieve the index of the field with the given key @@ -53,47 +58,38 @@ public interface RecordAccessor extends ListAccessor, MapAccessor int index( String key ); /** - * Retrieve the field for the given key + * Retrieve the value of the property with the given key * - * @param key the key - * @return the field for the given key + * @param key the key of the property + * @return the property's value or a {@link NullValue} if no such key exists + * @throws NoRecordException if the associated underlying record is not available */ - Field field( String key ); + Value value( String key ); /** - * Retrieve the field at the given index + * Retrieve the number of fields in this record * - * @param index the index - * @return the field at the given index + * @return the number of fields in this record */ - Field field( int index ); - - /** - * @return number of fields in this record - */ - int fieldCount(); + @Override + int size(); /** * Retrieve all record fields * * @return all fields in key order - * @throws ClientException if record has not been initialized. + * @throws NoRecordException if the associated underlying record is not available */ - List> fields(); + List> fields(); /** - * Map and retrieve all record fields - * - * @param the target type of the map function - * @param mapFunction a function to map from Value to T. See {@link Values} for some predefined functions, such - * as {@link Values#valueAsBoolean()}, {@link Values#valueAsList(Function)}. - * @return the result of mapping all record fields in key order - * @throws ClientException if record has not been initialized. + * @return if this record accessor is currently associated with an underlying record */ - List> fields( Function mapFunction ); + boolean hasRecord(); /** - * @return an immutable copy of the currently viewed record + * @throws NoRecordException if the associated underlying record is not available + * @return an immutable copy of the currently associated underlying record */ Record record(); } diff --git a/driver/src/main/java/org/neo4j/driver/v1/Records.java b/driver/src/main/java/org/neo4j/driver/v1/Records.java index 7323b80405..a9ac00a8ef 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Records.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Records.java @@ -21,7 +21,7 @@ /** * Static utility methods for retaining records * - * @see Result#retain() + * @see ResultCursor#retain() */ public abstract class Records { diff --git a/driver/src/main/java/org/neo4j/driver/v1/Result.java b/driver/src/main/java/org/neo4j/driver/v1/ResultCursor.java similarity index 82% rename from driver/src/main/java/org/neo4j/driver/v1/Result.java rename to driver/src/main/java/org/neo4j/driver/v1/ResultCursor.java index dd281ddaf5..76dd580409 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Result.java +++ b/driver/src/main/java/org/neo4j/driver/v1/ResultCursor.java @@ -37,7 +37,7 @@ * To keep a result around while further statements are run, or to use a result outside the scope * of the current transaction, see {@link #retain()}. */ -public interface Result extends RecordAccessor, Resource +public interface ResultCursor extends RecordAccessor, Resource { /** * @return an immutable copy of the currently viewed record @@ -72,12 +72,23 @@ public interface Result extends RecordAccessor, Resource /** * Advance the cursor as if calling next multiple times. * - * @throws IllegalArgumentException if records is negative + * @throws ClientException if records is negative * @param records amount of records to be skipped * @return the actual number of records successfully skipped */ long skip( long records ); + /** + * Limit this cursor to return no more than the given number of records after the current record. + * As soon as the described amount of records have been returned, all further records are discarded. + * Calling limit again before the described amount of records have been returned, replaces the limit (overwriting the previous limit). + * + * @throws ClientException if records is negative + * @param records the maximum number of records to return from future calls to {@link #next()} + * @return the actual position of the last record to be returned + */ + long limit( long records ); + /** * Move to the first record if possible, otherwise do nothing. * @@ -92,6 +103,16 @@ public interface Result extends RecordAccessor, Resource */ boolean single(); + /** + * Investigate the next upcoming record. + * + * The returned {@link RecordAccessor} is updated consistently whenever this associated cursor + * is moved. + * + * @return a view on the next record + */ + RecordAccessor peek(); + /** * Retrieve and store the entire result stream. * This can be used if you want to iterate over the stream multiple times or to store the diff --git a/driver/src/main/java/org/neo4j/driver/v1/Statement.java b/driver/src/main/java/org/neo4j/driver/v1/Statement.java index 06eb9ac27b..aaa8ddaf8b 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Statement.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Statement.java @@ -31,8 +31,8 @@ * * @see Session * @see Transaction - * @see Result - * @see Result#summarize() + * @see ResultCursor + * @see ResultCursor#summarize() * @see ResultSummary */ @Immutable diff --git a/driver/src/main/java/org/neo4j/driver/v1/StatementRunner.java b/driver/src/main/java/org/neo4j/driver/v1/StatementRunner.java index e5fc57a1a4..65e779bcfe 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/StatementRunner.java +++ b/driver/src/main/java/org/neo4j/driver/v1/StatementRunner.java @@ -39,8 +39,8 @@ public interface StatementRunner *

Example

* 
      * {@code
-     * Result cursor = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
-     *                              Values.parameters( "myNameParam", "Bob" ) );
+     * ResultCursor cursor = session.run( "MATCH (n) WHERE n.name = {myNameParam} RETURN (n)",
+     *                                    Values.parameters( "myNameParam", "Bob" ) );
      * }
      *
* @@ -48,7 +48,7 @@ public interface StatementRunner * @param statementParameters input data for the statement, see {@link Values#parameters(Object...)} * @return a stream of result values and associated metadata */ - Result run( String statementTemplate, Map statementParameters ); + ResultCursor run( String statementTemplate, Map statementParameters ); /** * Run a statement and return a result stream. @@ -56,7 +56,7 @@ public interface StatementRunner * @param statementTemplate template of a Neo4j statement * @return a stream of result values and associated metadata */ - Result run( String statementTemplate ); + ResultCursor run( String statementTemplate ); /** * Run a statement and return a result stream. @@ -64,14 +64,14 @@ public interface StatementRunner * 
      * {@code
      * Statement statement = new Statement( "MATCH (n) WHERE n.name={myNameParam} RETURN n.age" );
-     * Result cursor = session.run( statement.withParameters( Values.parameters( "myNameParam", "Bob" )  ) );
+     * ResultCursor cursor = session.run( statement.withParameters( Values.parameters( "myNameParam", "Bob" )  ) );
      * }
      *
* * @param statement a Neo4j statement * @return a stream of result values and associated metadata */ - Result run( Statement statement ); + ResultCursor run( Statement statement ); /** * @return type system used by this statement runner for classifying values diff --git a/driver/src/main/java/org/neo4j/driver/v1/Value.java b/driver/src/main/java/org/neo4j/driver/v1/Value.java index afc9e126f8..810bd4f16f 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Value.java +++ b/driver/src/main/java/org/neo4j/driver/v1/Value.java @@ -74,7 +74,7 @@ * */ @Immutable -public interface Value extends PropertyMapAccessor, ListAccessor +public interface Value extends MapAccessor, ListAccessor { /** * If the underlying value is a collection type, return the number of values in the collection. diff --git a/driver/src/main/java/org/neo4j/driver/v1/Field.java b/driver/src/main/java/org/neo4j/driver/v1/exceptions/NoRecordException.java similarity index 59% rename from driver/src/main/java/org/neo4j/driver/v1/Field.java rename to driver/src/main/java/org/neo4j/driver/v1/exceptions/NoRecordException.java index 86a60402d2..718004bf78 100644 --- a/driver/src/main/java/org/neo4j/driver/v1/Field.java +++ b/driver/src/main/java/org/neo4j/driver/v1/exceptions/NoRecordException.java @@ -16,34 +16,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -package org.neo4j.driver.v1; +package org.neo4j.driver.v1.exceptions; -/** - * A field is a property of an ordered map or record - * - * @param the type of value stored - * - * @see Property - * @see PropertyMapAccessor - * @see RecordAccessor - */ -@Immutable -public interface Field +public class NoRecordException extends ClientException { - /** - * @return the property key - */ - String key(); - - /** - * @return the property value - */ - V value(); + private static final long serialVersionUID = 9091962868264042491L; - /** - * @return the index of the field in the original record - */ - int index(); + public NoRecordException( String message ) + { + super( message ); + } - Property asProperty(); + public NoRecordException( String message, Throwable cause ) + { + super( message, cause ); + } } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalFieldTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java similarity index 77% rename from driver/src/test/java/org/neo4j/driver/internal/InternalFieldTest.java rename to driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java index e23bd754b8..68ebff3314 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalFieldTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalPairTest.java @@ -20,7 +20,7 @@ import org.junit.Test; -import org.neo4j.driver.v1.Field; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.Value; import static org.hamcrest.CoreMatchers.equalTo; @@ -29,15 +29,13 @@ import static org.neo4j.driver.v1.Values.value; -public class InternalFieldTest +public class InternalPairTest { @Test public void testMethods() { - Field field = InternalField.of( "k", 42, value( "v" ) ); - assertThat(field.key(), equalTo("k")); - assertThat(field.index(), equalTo(42)); - assertThat(field.value(), equalTo(value("v"))); + Pair pair = InternalPair.of( "k", value( "v" ) ); + assertThat( pair.key(), equalTo("k")); + assertThat( pair.value(), equalTo(value("v"))); } - } diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalRecordTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalRecordTest.java index f1a8adb2d6..b9efba18db 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalRecordTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalRecordTest.java @@ -26,6 +26,7 @@ import org.junit.Test; +import org.neo4j.driver.internal.util.Extract; import org.neo4j.driver.internal.value.NullValue; import org.neo4j.driver.v1.Function; import org.neo4j.driver.v1.Value; @@ -52,10 +53,10 @@ public void accessingUnknownKeyShouldBeNull() } @Test - public void shouldHaveCorrectFieldCount() + public void shouldHaveCorrectSize() { InternalRecord record = createRecord(); - assertThat( record.fieldCount(), equalTo( 2 ) ); + assertThat( record.size(), equalTo( 2 ) ); } @Test @@ -111,15 +112,6 @@ public void testIndex() assertThat( record.index( "k2" ), equalTo( 1 ) ); } - @Test - public void testField() - { - InternalRecord record = createRecord(); - - assertThat( record.field( "k1" ), equalTo( record.field( 0 ) ) ); - assertThat( record.field( "k2" ), equalTo( record.field( 1 ) ) ); - } - @Test public void testAsMap() { @@ -150,7 +142,7 @@ public Integer apply( Value value ) }; // WHEN - Map map = record.asMap( addOne ); + Map map = Extract.map( record, addOne ); // THEN assertThat( map.keySet(), containsInAnyOrder( "k1", "k2" ) ); diff --git a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java b/driver/src/test/java/org/neo4j/driver/internal/InternalResultCursorTest.java similarity index 65% rename from driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java rename to driver/src/test/java/org/neo4j/driver/internal/InternalResultCursorTest.java index eb2a734a08..6ba4393e1a 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/InternalResultTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/InternalResultCursorTest.java @@ -29,22 +29,25 @@ import org.neo4j.driver.internal.summary.ResultBuilder; import org.neo4j.driver.internal.value.NullValue; -import org.neo4j.driver.v1.Field; +import org.neo4j.driver.v1.Pair; import org.neo4j.driver.v1.Record; +import org.neo4j.driver.v1.RecordAccessor; import org.neo4j.driver.v1.Records; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.exceptions.ClientException; +import org.neo4j.driver.v1.exceptions.NoRecordException; import static org.hamcrest.CoreMatchers.equalTo; import static org.hamcrest.collection.IsCollectionWithSize.hasSize; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertThat; import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; import static org.neo4j.driver.v1.Values.value; -public class InternalResultTest +public class InternalResultCursorTest { @Rule public ExpectedException expectedException = ExpectedException.none(); @@ -53,7 +56,7 @@ public class InternalResultTest public void iterationShouldWorksAsExpected() { // GIVEN - Result result = createResult( 3 ); + ResultCursor result = createResult( 3 ); // WHEN assertThat( result.position(), equalTo( -1L ) ); @@ -89,7 +92,7 @@ public void firstFalseOnEmptyStream() public void firstMovesCursorOnce() { // GIVEN - Result result = createResult( 3 ); + ResultCursor result = createResult( 3 ); // WHEN assertThat( result.position(), equalTo( -1L ) ); @@ -111,7 +114,7 @@ public void singleShouldWorkAsExpected() public void skipShouldWorkAsExpected() { // GIVEN - Result result = createResult( 42 ); + ResultCursor result = createResult( 42 ); // WHEN assertThat(result.skip( 22 ), equalTo(22L)); @@ -125,7 +128,7 @@ public void skipShouldWorkAsExpected() public void skipBeyondNumberOfRecords() { // GIVEN - Result result = createResult( 10 ); + ResultCursor result = createResult( 10 ); // WHEN assertThat(result.skip( 20 ), equalTo(10L)); @@ -137,18 +140,76 @@ public void skipBeyondNumberOfRecords() @Test public void skipThrowsIfNegativeNumber() { - Result result = createResult( 10 ); + ResultCursor result = createResult( 10 ); result.skip( 5 ); - expectedException.expect( IllegalArgumentException.class ); + expectedException.expect( ClientException.class ); result.skip( -1 ); } + @Test + public void limitShouldWorkAsExpected() + { + // GIVEN + ResultCursor result = createResult( 42 ); + result.limit( 10 ); + + // THEN + assertThat( result.retain().size(), equalTo( 10 ) ); + } + + @Test + public void limitZeroShouldWorkAsExpected1() + { + // GIVEN + ResultCursor result = createResult( 42 ); + result.limit( 0 ); + + // THEN + assertThat( result.retain().size(), equalTo( 0 ) ); + } + + @Test + public void limitZeroShouldWorkAsExpected2() + { + // GIVEN + ResultCursor result = createResult( 10 ); + result.skip( 4 ); + result.limit( 0 ); + + // THEN + assertTrue( result.atEnd() ); + assertFalse( result.next() ); + } + + @Test + public void limitOnEmptyResultShouldWorkAsExpected() + { + // GIVEN + ResultCursor result = createResult( 0 ); + result.limit( 10 ); + + // THEN + assertThat( result.retain().size(), equalTo( 0 ) ); + } + + @Test + public void changingLimitShouldWorkAsExpected() + { + // GIVEN + ResultCursor result = createResult( 6 ); + result.limit( 1 ); + result.limit( 60 ); + + // THEN + assertThat( result.retain().size(), equalTo( 6 ) ); + } + @Test public void retainShouldWorkAsExpected() { // GIVEN - Result result = createResult( 3 ); + ResultCursor result = createResult( 3 ); // WHEN List records = result.retain(); @@ -162,7 +223,7 @@ public void retainShouldWorkAsExpected() public void retainAndMapByKeyShouldWorkAsExpected() { // GIVEN - Result result = createResult( 3 ); + ResultCursor result = createResult( 3 ); // WHEN List records = result.retain( Records.columnAsIs( "k1" ) ); @@ -176,7 +237,7 @@ public void retainAndMapByKeyShouldWorkAsExpected() public void retainAndMapByIndexShouldWorkAsExpected() { // GIVEN - Result result = createResult( 3 ); + ResultCursor result = createResult( 3 ); // WHEN List records = result.retain( Records.columnAsIs( 0 ) ); @@ -189,7 +250,7 @@ public void retainAndMapByIndexShouldWorkAsExpected() @Test public void retainFailsIfItCannotRetainEntireResult() { - Result result = createResult( 17 ); + ResultCursor result = createResult( 17 ); result.skip( 5 ); expectedException.expect( ClientException.class ); @@ -200,7 +261,7 @@ public void retainFailsIfItCannotRetainEntireResult() public void accessingOutOfBoundsShouldBeNull() { // GIVEN - Result result = createResult( 1 ); + ResultCursor result = createResult( 1 ); // WHEN result.first(); @@ -216,7 +277,7 @@ public void accessingOutOfBoundsShouldBeNull() public void accessingRecordsWithoutCallingNextShouldFail() { // GIVEN - Result result = createResult( 11 ); + ResultCursor result = createResult( 11 ); // WHEN // not calling next, first, nor skip @@ -230,7 +291,7 @@ public void accessingRecordsWithoutCallingNextShouldFail() public void accessingValueWithoutCallingNextShouldFail() { // GIVEN - Result result = createResult( 11 ); + ResultCursor result = createResult( 11 ); // WHEN // not calling next, first, nor skip @@ -244,7 +305,7 @@ public void accessingValueWithoutCallingNextShouldFail() public void accessingFieldsWithoutCallingNextShouldFail() { // GIVEN - Result result = createResult( 11 ); + ResultCursor result = createResult( 11 ); // WHEN // not calling next, first, nor skip @@ -258,7 +319,7 @@ public void accessingFieldsWithoutCallingNextShouldFail() public void accessingKeysWithoutCallingNextShouldNotFail() { // GIVEN - Result result = createResult( 11 ); + ResultCursor result = createResult( 11 ); // WHEN // not calling next, first, nor skip @@ -268,12 +329,65 @@ public void accessingKeysWithoutCallingNextShouldNotFail() } @Test - public void shouldHaveCorrectFieldCount() + public void shouldHaveCorrectSize() + { + assertThat( createResult( 4 ).size(), equalTo( 2 ) ); + } + + @Test + public void shouldPeekIntoTheFuture() + { + // GIVEN + ResultCursor result = createResult( 2 ); + + // WHEN + RecordAccessor future = result.peek(); + + // THEN + assertTrue( future.hasRecord() ); + assertThat( future.value( "k1" ), equalTo( value( "v1-1" ) ) ); + + // WHEN + result.next(); + + // THEN + assertTrue( future.hasRecord() ); + assertThat( result.value( "k1" ), equalTo( value( "v1-1" ) ) ); + assertThat( future.value( "k1" ), equalTo( value( "v1-2" ) ) ); + + // WHEN + result.next(); + + // THEN + assertFalse( future.hasRecord() ); + assertThat( result.value( "k1" ), equalTo( value( "v1-2" ) ) ); + + // AND THEN + try + { + future.value( "k1" ); + fail( "Expected NoRecordException" ); + } + catch ( NoRecordException e ) + { + // yay + } + + } + + @Test + public void shouldNotPeekIntoTheFutureWhenResultIsEmpty() { - assertThat( createResult( 4 ).fieldCount(), equalTo( 2 ) ); + // GIVEN + ResultCursor result = createResult( 0 ); + RecordAccessor future = result.peek(); + + // WHEN + assertFalse( result.hasRecord() ); + assertFalse( future.hasRecord() ); } - private Result createResult( int numberOfRecords ) + private ResultCursor createResult( int numberOfRecords ) { ResultBuilder builder = new ResultBuilder( "", ParameterSupport.NO_PARAMETERS ); builder.keys( new String[]{"k1", "k2"} ); @@ -287,7 +401,7 @@ private Result createResult( int numberOfRecords ) private List values( Record record ) { List result = new ArrayList<>( record.keys().size() ); - for ( Field property : record.fields() ) + for ( Pair property : record.fields() ) { result.add( property.value() ); } diff --git a/driver/src/test/java/org/neo4j/driver/internal/PeekingIteratorTest.java b/driver/src/test/java/org/neo4j/driver/internal/PeekingIteratorTest.java new file mode 100644 index 0000000000..6b57829005 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/internal/PeekingIteratorTest.java @@ -0,0 +1,108 @@ +/** + * Copyright (c) 2002-2015 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.internal; + +import java.util.Collections; +import java.util.NoSuchElementException; + +import org.junit.Test; + +import static java.util.Arrays.asList; + +import static org.hamcrest.Matchers.equalTo; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +public class PeekingIteratorTest +{ + @Test + public void shouldSupportDiscard() + { + // GIVEN + PeekingIterator iter = new PeekingIterator<>( asList( 1, 2, 3 ).iterator() ); + iter.next(); + + // WHEN + iter.discard(); + + // THEN + assertFalse( iter.hasNext() ); + assertNull( iter.peek() ); + assertNoNext( iter ); + } + + @Test + public void shouldNotPeekEmptyIterator() + { + // GIVEN + PeekingIterator iter = new PeekingIterator<>( Collections.emptyIterator() ); + + // THEN + assertFalse( iter.hasNext() ); + assertNull( iter.peek() ); + assertNoNext( iter ); + } + + @Test + public void shouldPeekNonEmptyIterator() + { + // GIVEN + PeekingIterator iter = new PeekingIterator<>( asList( 1, 2, 3 ).iterator() ); + + // THEN + assertTrue( iter.hasNext() ); + assertThat( iter.peek(), equalTo( (Object) 1 ) ); + + // WHEN + iter.next(); + + // THEN + assertTrue( iter.hasNext() ); + assertThat( iter.peek(), equalTo( (Object) 2 ) ); + + // WHEN + iter.next(); + + // THEN + assertTrue( iter.hasNext() ); + assertThat( iter.peek(), equalTo( (Object) 3 ) ); + + // WHEN + iter.next(); + assertFalse( iter.hasNext() ); + assertNull( iter.peek() ); + assertNoNext( iter ); + } + + private void assertNoNext( PeekingIterator iter ) + { + try + { + iter.next(); + fail( "Expected NoSuchElementException" ); + } + catch ( NoSuchElementException e ) + { + // yay + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/internal/util/ExtractTest.java b/driver/src/test/java/org/neo4j/driver/internal/util/ExtractTest.java index f87a56fa58..80785c1f17 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/util/ExtractTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/util/ExtractTest.java @@ -30,15 +30,13 @@ import org.junit.Test; import org.junit.rules.ExpectedException; -import org.neo4j.driver.internal.InternalField; import org.neo4j.driver.internal.InternalNode; -import org.neo4j.driver.internal.InternalProperty; +import org.neo4j.driver.internal.InternalPair; import org.neo4j.driver.internal.ParameterSupport; import org.neo4j.driver.internal.summary.ResultBuilder; -import org.neo4j.driver.v1.Field; import org.neo4j.driver.v1.Function; -import org.neo4j.driver.v1.Property; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.Pair; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Value; import static java.util.Arrays.asList; @@ -138,12 +136,12 @@ public void testProperties() throws Exception InternalNode node = new InternalNode( 42L, Collections.singletonList( "L" ), props ); // WHEN - Iterable> properties = Extract.properties( node, integerExtractor() ); + Iterable> properties = Extract.properties( node, integerExtractor() ); // THEN - Iterator> iterator = properties.iterator(); - assertThat( iterator.next(), equalTo( InternalProperty.of( "k1", 43 ) ) ); - assertThat( iterator.next(), equalTo( InternalProperty.of( "k2", 42 ) ) ); + Iterator> iterator = properties.iterator(); + assertThat( iterator.next(), equalTo( InternalPair.of( "k1", 43 ) ) ); + assertThat( iterator.next(), equalTo( InternalPair.of( "k2", 42 ) ) ); assertFalse( iterator.hasNext() ); } @@ -154,15 +152,15 @@ public void testFields() throws Exception ResultBuilder builder = new ResultBuilder( "", ParameterSupport.NO_PARAMETERS ); builder.keys( new String[]{"k1"} ); builder.record( new Value[]{value(42)} ); - Result result = builder.build(); + ResultCursor result = builder.build(); result.first(); // WHEN - List> fields = Extract.fields( result, integerExtractor() ); + List> fields = Extract.fields( result, integerExtractor() ); // THEN - assertThat( fields, equalTo( Collections.singletonList( InternalField.of( "k1", 0, 42 ) ) ) ); + assertThat( fields, equalTo( Collections.singletonList( InternalPair.of( "k1", 42 ) ) ) ); } private Function integerExtractor() diff --git a/driver/src/test/java/org/neo4j/driver/internal/value/MapValueTest.java b/driver/src/test/java/org/neo4j/driver/internal/value/MapValueTest.java index 30eba08015..9672278f66 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/value/MapValueTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/value/MapValueTest.java @@ -44,7 +44,7 @@ public void shouldHaveSensibleToString() throws Throwable public void shouldHaveCorrectPropertyCount() throws Throwable { MapValue mapValue = mapValue(); - assertThat( mapValue.propertyCount(), equalTo( 2 ) ); + assertThat( mapValue.size(), equalTo( 2 ) ); } @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/value/NodeValueTest.java b/driver/src/test/java/org/neo4j/driver/internal/value/NodeValueTest.java index 15f8393486..7c5c20408e 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/value/NodeValueTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/value/NodeValueTest.java @@ -49,8 +49,8 @@ public void shouldHaveSensibleToString() throws Throwable @Test public void shouldHaveCorrectPropertyCount() throws Throwable { - assertEquals( 0, emptyNodeValue().propertyCount()) ; - assertEquals( 1, filledNodeValue().propertyCount()) ; + assertEquals( 0, emptyNodeValue().size()) ; + assertEquals( 1, filledNodeValue().size()) ; } @Test diff --git a/driver/src/test/java/org/neo4j/driver/internal/value/RelationshipValueTest.java b/driver/src/test/java/org/neo4j/driver/internal/value/RelationshipValueTest.java index 56a541f6a8..0e08687cde 100644 --- a/driver/src/test/java/org/neo4j/driver/internal/value/RelationshipValueTest.java +++ b/driver/src/test/java/org/neo4j/driver/internal/value/RelationshipValueTest.java @@ -45,8 +45,8 @@ public void shouldHaveSensibleToString() throws Throwable @Test public void shouldHaveCorrectPropertyCount() throws Throwable { - assertEquals( 0, emptyRelationshipValue().propertyCount()) ; - assertEquals( 1, filledRelationshipValue().propertyCount()) ; + assertEquals( 0, emptyRelationshipValue().size()) ; + assertEquals( 1, filledRelationshipValue().size()) ; } @Test diff --git a/driver/src/test/java/org/neo4j/driver/v1/DriverDocIT.java b/driver/src/test/java/org/neo4j/driver/v1/DriverDocIT.java index 8bcb847368..4fc7fd4449 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/DriverDocIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/DriverDocIT.java @@ -53,7 +53,7 @@ public void exampleUsage( DocSnippet snippet ) snippet.run(); // then it should've created a bunch of data - Result result = session.run( "MATCH (n) RETURN count(n)" ); + ResultCursor result = session.run( "MATCH (n) RETURN count(n)" ); assertTrue( result.single() ); assertEquals( 3, result.value( 0 ).asInt() ); assertThat( (List)snippet.get( "names" ), equalTo( asList("Bob", "Alice", "Tina")) ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/ResultDocIT.java b/driver/src/test/java/org/neo4j/driver/v1/ResultDocIT.java index b1790bd062..8082b6e880 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/ResultDocIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/ResultDocIT.java @@ -33,7 +33,7 @@ public class ResultDocIT @Rule public TestNeo4jSession session = new TestNeo4jSession(); - /** @see Result */ + /** @see ResultCursor */ public void summarizeUsage( DocSnippet snippet ) { // Given diff --git a/driver/src/test/java/org/neo4j/driver/v1/TransactionDocIT.java b/driver/src/test/java/org/neo4j/driver/v1/TransactionDocIT.java index 60eac5f4b7..2bacef8511 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/TransactionDocIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/TransactionDocIT.java @@ -44,7 +44,7 @@ public void classDoc( DocSnippet snippet ) snippet.run(); // Then a node should've been created - Result cursor = session.run( "MATCH (n) RETURN count(n)" ); + ResultCursor cursor = session.run( "MATCH (n) RETURN count(n)" ); assertTrue( cursor.single() ); assertEquals( 1, cursor.value( "count(n)" ).asInt() ); } @@ -59,7 +59,7 @@ public void failure( DocSnippet snippet ) snippet.run(); // Then a node should've been created - Result cursor = session.run( "MATCH (n) RETURN count(n)" ); + ResultCursor cursor = session.run( "MATCH (n) RETURN count(n)" ); assertTrue( cursor.single() ); assertEquals( 0, cursor.value( "count(n)" ).asInt() ); } diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/EntityTypeIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/EntityTypeIT.java index b58c1703fa..c7fa18037d 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/EntityTypeIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/EntityTypeIT.java @@ -24,7 +24,7 @@ import org.neo4j.driver.v1.Node; import org.neo4j.driver.v1.Path; import org.neo4j.driver.v1.Relationship; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.util.TestNeo4jSession; import static org.junit.Assert.assertTrue; @@ -38,7 +38,7 @@ public class EntityTypeIT public void shouldReturnIdentitiesOfNodes() throws Throwable { // When - Result cursor = session.run( "CREATE (n) RETURN n" ); + ResultCursor cursor = session.run( "CREATE (n) RETURN n" ); assertTrue( cursor.single() ); Node node = cursor.value( "n" ).asNode(); @@ -50,7 +50,7 @@ public void shouldReturnIdentitiesOfNodes() throws Throwable public void shouldReturnIdentitiesOfRelationships() throws Throwable { // When - Result cursor = session.run( "CREATE ()-[r:T]->() RETURN r" ); + ResultCursor cursor = session.run( "CREATE ()-[r:T]->() RETURN r" ); assertTrue( cursor.single() ); Relationship rel = cursor.value( "r" ).asRelationship(); @@ -64,7 +64,7 @@ public void shouldReturnIdentitiesOfRelationships() throws Throwable public void shouldReturnIdentitiesOfPaths() throws Throwable { // When - Result cursor = session.run( "CREATE p=()-[r:T]->() RETURN p" ); + ResultCursor cursor = session.run( "CREATE p=()-[r:T]->() RETURN p" ); assertTrue( cursor.single() ); Path path = cursor.value( "p" ).asPath(); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/ErrorIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/ErrorIT.java index cbc53ba516..e9680f37f2 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/ErrorIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/ErrorIT.java @@ -24,7 +24,7 @@ import org.neo4j.driver.v1.Driver; import org.neo4j.driver.v1.GraphDatabase; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Transaction; import org.neo4j.driver.v1.exceptions.ClientException; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -69,7 +69,7 @@ public void shouldNotAllowMoreTxAfterClientException() throws Throwable "because previous statements in the" ); // When - Result cursor = tx.run( "RETURN 1" ); + ResultCursor cursor = tx.run( "RETURN 1" ); assertTrue( cursor.single() ); cursor.value( "1" ).asInt(); } @@ -81,7 +81,7 @@ public void shouldAllowNewStatementAfterRecoverableError() throws Throwable try { session.run( "invalid" ); } catch ( ClientException e ) {} // When - Result cursor = session.run( "RETURN 1" ); + ResultCursor cursor = session.run( "RETURN 1" ); assertTrue( cursor.single() ); int val = cursor.value( "1" ).asInt(); @@ -102,7 +102,7 @@ public void shouldAllowNewTransactionAfterRecoverableError() throws Throwable // When try ( Transaction tx = session.beginTransaction() ) { - Result cursor = tx.run( "RETURN 1" ); + ResultCursor cursor = tx.run( "RETURN 1" ); assertTrue( cursor.single() ); int val = cursor.value( "1" ).asInt(); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/LoadCSVIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/LoadCSVIT.java index 8a7cc03599..d2aef74ff6 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/LoadCSVIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/LoadCSVIT.java @@ -25,7 +25,7 @@ import org.neo4j.driver.v1.Driver; import org.neo4j.driver.v1.GraphDatabase; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.util.TestNeo4j; @@ -50,7 +50,7 @@ public void shouldLoadCSV() throws Throwable String csvFileUrl = createLocalIrisData( session ); // When - Result result = session.run( + ResultCursor result = session.run( "USING PERIODIC COMMIT 40\n" + "LOAD CSV WITH HEADERS FROM {csvFileUrl} AS l\n" + "MATCH (c:Class {name: l.class_name})\n" + @@ -79,7 +79,7 @@ private String createLocalIrisData( Session session ) throws IOException } @SuppressWarnings("StatementWithEmptyBody") - private static void consume( Result result ) + private static void consume( ResultCursor result ) { while ( result.next() ) { diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/ParametersIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/ParametersIT.java index 2e1ba7e533..12258f7290 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/ParametersIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/ParametersIT.java @@ -23,7 +23,7 @@ import org.junit.rules.ExpectedException; import org.neo4j.driver.v1.Record; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.exceptions.ClientException; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -45,7 +45,7 @@ public class ParametersIT public void shouldBeAbleToSetAndReturnBooleanProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", true ) ); // Then @@ -61,7 +61,7 @@ public void shouldBeAbleToSetAndReturnBooleanProperty() public void shouldBeAbleToSetAndReturnByteProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", (byte) 1 ) ); // Then @@ -77,7 +77,7 @@ public void shouldBeAbleToSetAndReturnByteProperty() public void shouldBeAbleToSetAndReturnShortProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", (short) 1 ) ); // Then @@ -93,7 +93,7 @@ public void shouldBeAbleToSetAndReturnShortProperty() public void shouldBeAbleToSetAndReturnIntegerProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", 1 ) ); // Then @@ -110,7 +110,7 @@ public void shouldBeAbleToSetAndReturnIntegerProperty() public void shouldBeAbleToSetAndReturnLongProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", 1L ) ); // Then @@ -127,7 +127,7 @@ public void shouldBeAbleToSetAndReturnLongProperty() public void shouldBeAbleToSetAndReturnDoubleProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", 6.28 ) ); // Then @@ -144,7 +144,7 @@ public void shouldBeAbleToSetAndReturnDoubleProperty() public void shouldBeAbleToSetAndReturnCharacterProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", 'ö' ) ); // Then @@ -162,7 +162,7 @@ public void shouldBeAbleToSetAndReturnCharacterArrayProperty() { // When char[] arrayValue = new char[]{'M', 'j', 'ö', 'l', 'n', 'i', 'r'}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -179,7 +179,7 @@ public void shouldBeAbleToSetAndReturnCharacterArrayProperty() public void shouldBeAbleToSetAndReturnStringProperty() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", "Mjölnir" ) ); // Then @@ -197,7 +197,7 @@ public void shouldBeAbleToSetAndReturnBooleanArrayProperty() { // When boolean[] arrayValue = new boolean[]{true, true, true}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -220,7 +220,7 @@ public void shouldBeAbleToSetAndReturnIntegerArrayProperty() { // When int[] arrayValue = new int[]{42, 42, 42}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -243,7 +243,7 @@ public void shouldBeAbleToSetAndReturnDoubleArrayProperty() { // When double[] arrayValue = new double[]{6.28, 6.28, 6.28}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -266,7 +266,7 @@ public void shouldBeAbleToSetAndReturnSpecialStringArrayProperty() // When String[] arrayValue = new String[]{"Mjölnir", "Mjölnir", "Mjölnir"}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -288,7 +288,7 @@ public void shouldBeAbleToSetAndReturnStringArrayProperty() { // When String[] arrayValue = new String[]{"cat", "cat", "cat"}; - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}}) RETURN a.value", parameters( "value", arrayValue ) ); // Then @@ -310,7 +310,7 @@ public void shouldBeAbleToSetAndReturnStringArrayProperty() public void shouldBeAbleToSetAndReturnBooleanPropertyWithinMap() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}.v}) RETURN a.value", parameters( "value", parameters( "v", true ) ) ); @@ -328,7 +328,7 @@ public void shouldBeAbleToSetAndReturnBooleanPropertyWithinMap() public void shouldBeAbleToSetAndReturnIntegerPropertyWithinMap() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}.v}) RETURN a.value", parameters( "value", parameters( "v", 42 ) ) ); @@ -346,7 +346,7 @@ public void shouldBeAbleToSetAndReturnIntegerPropertyWithinMap() public void shouldBeAbleToSetAndReturnDoublePropertyWithinMap() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}.v}) RETURN a.value", parameters( "value", parameters( "v", 6.28 ) ) ); @@ -364,7 +364,7 @@ public void shouldBeAbleToSetAndReturnDoublePropertyWithinMap() public void shouldBeAbleToSetAndReturnStringPropertyWithinMap() { // When - Result result = session.run( + ResultCursor result = session.run( "CREATE (a {value:{value}.v}) RETURN a.value", parameters( "value", parameters( "v", "Mjölnir" ) ) ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/ResultStreamIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/ResultStreamIT.java index d55b5ea5eb..f5cebfe362 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/ResultStreamIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/ResultStreamIT.java @@ -21,7 +21,7 @@ import org.junit.Rule; import org.junit.Test; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.exceptions.ClientException; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -40,7 +40,7 @@ public class ResultStreamIT public void shouldAllowIteratingOverResultStream() throws Throwable { // When - Result res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" ); + ResultCursor res = session.run( "UNWIND [1,2,3,4] AS a RETURN a" ); // Then I should be able to iterate over the result int idx = 1; @@ -54,7 +54,7 @@ public void shouldAllowIteratingOverResultStream() throws Throwable public void shouldHaveFieldNamesInResult() { // When - Result res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" ); + ResultCursor res = session.run( "CREATE (n:TestNode {name:'test'}) RETURN n" ); // Then assertEquals( "[n]", res.keys().toString() ); @@ -66,7 +66,7 @@ public void shouldHaveFieldNamesInResult() public void shouldGiveHelpfulFailureMessageWhenCurrentRecordHasNotBeenSet() throws Throwable { // Given - Result rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); + ResultCursor rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); // When & Then try @@ -77,7 +77,7 @@ public void shouldGiveHelpfulFailureMessageWhenCurrentRecordHasNotBeenSet() thro catch( ClientException e ) { assertEquals( - "In order to access fields of a record in a result, " + + "In order to access the fields of a record in a result, " + "you must first call next() to point the result to the next record in the result stream.", e.getMessage() ); @@ -88,7 +88,7 @@ public void shouldGiveHelpfulFailureMessageWhenCurrentRecordHasNotBeenSet() thro public void shouldGiveHelpfulFailureMessageWhenAccessNonExistingField() throws Throwable { // Given - Result rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); + ResultCursor rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); // When assertTrue( rs.single() ); @@ -101,7 +101,7 @@ public void shouldGiveHelpfulFailureMessageWhenAccessNonExistingField() throws T public void shouldGiveHelpfulFailureMessageWhenAccessNonExistingPropertyOnNode() throws Throwable { // Given - Result rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); + ResultCursor rs = session.run( "CREATE (n:Person {name:{name}}) RETURN n", parameters( "name", "Tom Hanks" ) ); // When assertTrue( rs.single() ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/SSLSocketChannelIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/SSLSocketChannelIT.java index f0f29509c3..2040b85bdf 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/SSLSocketChannelIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/SSLSocketChannelIT.java @@ -41,7 +41,7 @@ import org.neo4j.driver.v1.Config; import org.neo4j.driver.v1.Driver; import org.neo4j.driver.v1.GraphDatabase; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.util.CertificateToolTest; import org.neo4j.driver.v1.util.Neo4jRunner; import org.neo4j.driver.v1.util.Neo4jSettings; @@ -228,7 +228,7 @@ public void shouldEstablishTLSConnection() throws Throwable URI.create( Neo4jRunner.DEFAULT_URL ), config ); - Result result = driver.session().run( "RETURN 1" ); + ResultCursor result = driver.session().run( "RETURN 1" ); assertTrue( result.next() ); assertEquals( 1, result.value( 0 ).asInt() ); assertFalse( result.next() ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/ScalarTypeIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/ScalarTypeIT.java index b25f2149ef..ee032de31b 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/ScalarTypeIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/ScalarTypeIT.java @@ -29,7 +29,7 @@ import org.neo4j.driver.internal.value.ListValue; import org.neo4j.driver.internal.value.MapValue; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -71,7 +71,7 @@ public static Collection typesToTest() public void shouldHandleType() throws Throwable { // When - Result cursor = session.run( statement ); + ResultCursor cursor = session.run( statement ); // Then assertTrue( cursor.next() ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/StatementIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/StatementIT.java index ea36ef2e60..186e781346 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/StatementIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/StatementIT.java @@ -24,7 +24,7 @@ import org.junit.Test; import org.neo4j.driver.v1.Record; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -99,14 +99,14 @@ public void shouldRunParameterizedWithResult() throws Throwable public void shouldRunSimpleStatement() throws Throwable { // When I run a simple write statement - Result result1 = session.run( "CREATE (a {name:'Adam'})" ); + ResultCursor result1 = session.run( "CREATE (a {name:'Adam'})" ); while ( result1.next() ) { // ignored } // And I run a read statement - Result result2 = session.run( "MATCH (a) RETURN a.name" ); + ResultCursor result2 = session.run( "MATCH (a) RETURN a.name" ); // Then I expect to value the name back Value name = null; diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/SummaryIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/SummaryIT.java index 55d467f093..facfe9aaf4 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/SummaryIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/SummaryIT.java @@ -27,7 +27,7 @@ import org.neo4j.driver.v1.Notification; import org.neo4j.driver.v1.Plan; import org.neo4j.driver.v1.ProfiledPlan; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.ResultSummary; import org.neo4j.driver.v1.StatementType; import org.neo4j.driver.v1.Value; @@ -56,7 +56,7 @@ public void shouldContainBasicMetadata() throws Throwable String statementText = "UNWIND [1, 2, 3, 4] AS n RETURN n AS number LIMIT {limit}"; // When - Result result = session.run( statementText, statementParameters ); + ResultCursor result = session.run( statementText, statementParameters ); // Then assertTrue( result.next() ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/integration/TransactionIT.java b/driver/src/test/java/org/neo4j/driver/v1/integration/TransactionIT.java index da2e6a6f2a..332107c775 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/integration/TransactionIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/integration/TransactionIT.java @@ -22,7 +22,7 @@ import org.junit.Test; import org.junit.rules.ExpectedException; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Transaction; import org.neo4j.driver.v1.exceptions.ClientException; import org.neo4j.driver.v1.util.TestNeo4jSession; @@ -51,7 +51,7 @@ public void shouldRunAndCommit() throws Throwable } // Then the outcome of both statements should be visible - Result result = session.run( "MATCH (n) RETURN count(n)" ); + ResultCursor result = session.run( "MATCH (n) RETURN count(n)" ); assertTrue( result.single() ); long nodes = result.value( "count(n)" ).asLong(); assertThat( nodes, equalTo( 2l ) ); @@ -68,7 +68,7 @@ public void shouldRunAndRollbackByDefault() throws Throwable } // Then there should be no visible effect of the transaction - Result cursor = session.run( "MATCH (n) RETURN count(n)" ); + ResultCursor cursor = session.run( "MATCH (n) RETURN count(n)" ); assertTrue( cursor.single() ); long nodes = cursor.value( "count(n)" ).asLong(); assertThat( nodes, equalTo( 0l ) ); @@ -83,7 +83,7 @@ public void shouldRetrieveResults() throws Throwable // When try ( Transaction tx = session.beginTransaction() ) { - Result res = tx.run( "MATCH (n) RETURN n.name" ); + ResultCursor res = tx.run( "MATCH (n) RETURN n.name" ); // Then assertTrue( res.single() ); diff --git a/driver/src/test/java/org/neo4j/driver/v1/stress/DriverStresser.java b/driver/src/test/java/org/neo4j/driver/v1/stress/DriverStresser.java index 6dc94b3d24..2828f80b65 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/stress/DriverStresser.java +++ b/driver/src/test/java/org/neo4j/driver/v1/stress/DriverStresser.java @@ -29,7 +29,7 @@ import org.neo4j.driver.v1.Driver; import org.neo4j.driver.v1.GraphDatabase; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.util.Neo4jRunner; @@ -76,7 +76,7 @@ public int operation() Map parameters = parameters(); // = Values.parameters( "n", "Bob" ); int total = 0; - Result result = session.run( statement, parameters ); + ResultCursor result = session.run( statement, parameters ); while ( result.next() ) { total += result.value( "n" ).asInt(); diff --git a/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4j.java b/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4j.java index 8321967b05..3bf3286479 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4j.java +++ b/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4j.java @@ -28,7 +28,7 @@ import org.junit.runners.model.Statement; import org.neo4j.driver.v1.Driver; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Session; public class TestNeo4j implements TestRule @@ -134,7 +134,7 @@ static void clearDatabaseContents( Session session, String reason ) // Note - this hangs for extended periods some times, because there are tests that leave sessions running. // Thus, we need to wait for open sessions and transactions to time out before this will go through. // This could be helped by an extension in the future. - Result result = session.run( "MATCH (n) DETACH DELETE n RETURN count(*)" ); + ResultCursor result = session.run( "MATCH (n) DETACH DELETE n RETURN count(*)" ); while ( result.next() ) { // consume diff --git a/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java b/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java index 907cafafcd..cc782f0d1c 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java +++ b/driver/src/test/java/org/neo4j/driver/v1/util/TestNeo4jSession.java @@ -23,7 +23,7 @@ import org.junit.runner.Description; import org.junit.runners.model.Statement; -import org.neo4j.driver.v1.Result; +import org.neo4j.driver.v1.ResultCursor; import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Transaction; import org.neo4j.driver.v1.TypeSystem; @@ -100,19 +100,19 @@ public Transaction beginTransaction() } @Override - public Result run( String statementText, Map statementParameters ) + public ResultCursor run( String statementText, Map statementParameters ) { return realSession.run( statementText, statementParameters ); } @Override - public Result run( String statementTemplate ) + public ResultCursor run( String statementTemplate ) { return realSession.run( statementTemplate ); } @Override - public Result run( org.neo4j.driver.v1.Statement statement ) + public ResultCursor run( org.neo4j.driver.v1.Statement statement ) { return realSession.run( statement.template(), statement.parameters() ); }