Merge pull request #440 from ali-ince/1.5-add-passing-bookmarks-example

Add example for passing bookmarks

Author: lutovich

examples/src/main/java/org/neo4j/docs/driver/PassBookmarkExample.java

@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2002-2017 "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.docs.driver;
+
+// tag::pass-bookmarks-import[]
+import java.util.ArrayList;
+import java.util.List;
+
+import org.neo4j.driver.v1.AccessMode;
+import org.neo4j.driver.v1.Record;
+import org.neo4j.driver.v1.Session;
+import org.neo4j.driver.v1.StatementResult;
+import org.neo4j.driver.v1.Transaction;
+
+import static org.neo4j.driver.v1.Values.parameters;
+// end::pass-bookmarks-import[]
+
+public class PassBookmarkExample extends BaseApplication
+{
+
+    public PassBookmarkExample( String uri, String user, String password )
+    {
+        super( uri, user, password );
+    }
+
+    // tag::pass-bookmarks[]
+    // Create a company node
+    private StatementResult addCompany( final Transaction tx, final String name )
+    {
+        return tx.run( "CREATE (:Company {name: $name})", parameters( "name", name ) );
+    }
+
+    // Create a person node
+    private StatementResult addPerson( final Transaction tx, final String name )
+    {
+        return tx.run( "CREATE (:Person {name: $name})", parameters( "name", name ) );
+    }
+
+    // Create an employment relationship to a pre-existing company node.
+    // This relies on the person first having been created.
+    private StatementResult employ( final Transaction tx, final String person, final String company )
+    {
+        return tx.run( "MATCH (person:Person {name: $person_name}) " +
+                        "MATCH (company:Company {name: $company_name}) " +
+                        "CREATE (person)-[:WORKS_FOR]->(company)",
+                parameters( "person_name", person, "company_name", company ) );
+    }
+
+    // Create a friendship between two people.
+    private StatementResult makeFriends( final Transaction tx, final String person1, final String person2 )
+    {
+        return tx.run( "MATCH (a:Person {name: $person_1}) " +
+                        "MATCH (b:Person {name: $person_2}) " +
+                        "MERGE (a)-[:KNOWS]->(b)",
+                parameters( "person_1", person1, "person_2", person2 ) );
+    }
+
+    // Match and display all friendships.
+    private StatementResult printFriends( final Transaction tx )
+    {
+        StatementResult result = tx.run( "MATCH (a)-[:KNOWS]->(b) RETURN a.name, b.name" );
+        while ( result.hasNext() )
+        {
+            Record record = result.next();
+            System.out.println( String.format( "%s knows %s", record.get( "a.name" ).asString(), record.get( "b.name" ).toString() ) );
+        }
+        return result;
+    }
+
+    public void addEmployAndMakeFriends()
+    {
+        // To collect the session bookmarks
+        List<String> savedBookmarks = new ArrayList<>();
+
+        // Create the first person and employment relationship.
+        try ( Session session1 = driver.session( AccessMode.WRITE ) )
+        {
+            session1.writeTransaction( tx -> addCompany( tx, "Wayne Enterprises" ) );
+            session1.writeTransaction( tx -> addPerson( tx, "Alice" ) );
+            session1.writeTransaction( tx -> employ( tx, "Alice", "Wayne Enterprises" ) );
+
+            savedBookmarks.add( session1.lastBookmark() );
+        }
+
+        // Create the second person and employment relationship.
+        try ( Session session2 = driver.session( AccessMode.WRITE ) )
+        {
+            session2.writeTransaction( tx -> addCompany( tx, "LexCorp" ) );
+            session2.writeTransaction( tx -> addPerson( tx, "Bob" ) );
+            session2.writeTransaction( tx -> employ( tx, "Bob", "LexCorp" ) );
+
+            savedBookmarks.add( session2.lastBookmark() );
+        }
+
+        // Create a friendship between the two people created above.
+        try ( Session session3 = driver.session( AccessMode.WRITE, savedBookmarks ) )
+        {
+            session3.writeTransaction( tx -> makeFriends( tx, "Alice", "Bob" ) );
+
+            session3.readTransaction( this::printFriends );
+        }
+    }
+    // end::pass-bookmarks[]
+}

examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java

@@ -38,6 +38,7 @@
 import static org.hamcrest.Matchers.greaterThan;
 import static org.hamcrest.Matchers.greaterThanOrEqualTo;
 import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.is;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 import static org.neo4j.driver.v1.Values.parameters;
@@ -97,6 +98,11 @@ private int personCount( String name )
         return readInt( "MATCH (a:Person {name: $name}) RETURN count(a)", parameters( "name", name ) );
     }
 
+    private int companyCount( String name )
+    {
+        return readInt( "MATCH (a:Company {name: $name}) RETURN count(a)", parameters( "name", name ) );
+    }
+
     @Before
     public void setUp()
     {
@@ -345,4 +351,33 @@ public void testShouldRunTransactionFunctionExample() throws Exception
             assertThat( personCount( "Alice" ), greaterThan( 0 ) );
         }
     }
+
+    @Test
+    public void testPassBookmarksExample() throws Exception
+    {
+        try ( PassBookmarkExample example = new PassBookmarkExample( uri, USER, PASSWORD ) )
+        {
+            // When
+            example.addEmployAndMakeFriends();
+
+            // Then
+            assertThat( companyCount( "Wayne Enterprises" ), is( 1 ) );
+            assertThat( companyCount( "LexCorp" ), is( 1 ) );
+            assertThat( personCount( "Alice" ), is( 1 ) );
+            assertThat( personCount( "Bob" ), is( 1 ) );
+
+            int employeeCountOfWayne = readInt(
+                "MATCH (emp:Person)-[WORKS_FOR]->(com:Company) WHERE com.name = 'Wayne Enterprises' RETURN count(emp)" );
+            assertThat( employeeCountOfWayne, is( 1 ) );
+
+            int employeeCountOfLexCorp = readInt(
+                    "MATCH (emp:Person)-[WORKS_FOR]->(com:Company) WHERE com.name = 'LexCorp' RETURN count(emp)" );
+            assertThat( employeeCountOfLexCorp, is( 1 ) );
+
+            int friendCount = readInt(
+                    "MATCH (a:Person {name: 'Alice'})-[:KNOWS]->(b:Person {name: 'Bob'}) RETURN count(a)" );
+            assertThat( friendCount, is( 1 ) );
+        }
+    }
+
 }