Merge pull request #160 from neo4j/1.0-doc-examples

Stefan Plantikow · Stefan Plantikow · commit dbea6ffe1e11 · 2016-04-20T10:43:47.000+02:00
Updated doc example to use king-arthur story
diff --git a/examples/src/main/java/org/neo4j/docs/driver/Examples.java b/examples/src/main/java/org/neo4j/docs/driver/Examples.java
@@ -19,28 +19,29 @@
 package org.neo4j.docs.driver;
 
 import java.io.File;
+import java.util.ArrayList;
 import java.util.List;
 
+import org.neo4j.driver.v1.AuthTokens;
 import org.neo4j.driver.v1.Config;
 import org.neo4j.driver.v1.Driver;
 import org.neo4j.driver.v1.GraphDatabase;
-import org.neo4j.driver.v1.StatementResult;
-import org.neo4j.driver.v1.summary.Notification;
-import org.neo4j.driver.v1.util.Pair;
 import org.neo4j.driver.v1.Record;
-import org.neo4j.driver.v1.summary.ResultSummary;
 import org.neo4j.driver.v1.Session;
+import org.neo4j.driver.v1.StatementResult;
 import org.neo4j.driver.v1.Transaction;
-import org.neo4j.driver.v1.Value;
 import org.neo4j.driver.v1.Values;
+import org.neo4j.driver.v1.exceptions.ClientException;
+import org.neo4j.driver.v1.summary.Notification;
+import org.neo4j.driver.v1.summary.ResultSummary;
 
 public class Examples
 {
 
     public static Driver constructDriver() throws Exception
     {
         // tag::construct-driver[]
-        Driver driver = GraphDatabase.driver( "bolt://localhost" );
+        Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic("neo4j", "neo4j") );
         // end::construct-driver[]
 
         return driver;
@@ -49,8 +50,10 @@ public static Driver constructDriver() throws Exception
     public static Driver configuration() throws Exception
     {
         // tag::configuration[]
-        Driver driver =
-                GraphDatabase.driver( "bolt://localhost", Config.build().withMaxSessions( 10 ).toConfig() );
+        Driver driver = GraphDatabase.driver(
+                "bolt://localhost",
+                AuthTokens.basic("neo4j", "neo4j"),
+                Config.build().withMaxSessions( 10 ).toConfig() );
         // end::configuration[]
 
         return driver;
@@ -60,82 +63,111 @@ public static void statement( Session session ) throws Exception
     {
         // tag::statement[]
         StatementResult result =
-                session.run( "CREATE (p:Person { name: {name} })", Values.parameters( "name", "The One" ) );
-
+                session.run( "CREATE (person:Person {name: {name}})", Values.parameters( "name", "Arthur" ) );
+        // end::statement[]
         int theOnesCreated = result.consume().counters().nodesCreated();
         System.out.println( "There were " + theOnesCreated + " the ones created." );
-        // end::statement[]
     }
 
     public static void statementWithoutParameters( Session session ) throws Exception
     {
         // tag::statement-without-parameters[]
-        StatementResult result = session.run( "CREATE (p:Person { name: 'The One' })" );
-
+        StatementResult result = session.run( "CREATE (p:Person { name: 'Arthur' })" );
+        // end::statement-without-parameters[]
         int theOnesCreated = result.consume().counters().nodesCreated();
         System.out.println( "There were " + theOnesCreated + " the ones created." );
-        // end::statement-without-parameters[]
     }
 
-    public static void resultCursor( Session session ) throws Exception
+    public static void resultTraversal( Session session ) throws Exception
+    {
+        // tag::result-traversal[]
+        String searchTerm = "Sword";
+        StatementResult result = session.run( "MATCH (weapon:Weapon) WHERE weapon.name CONTAINS {term} RETURN weapon.name",
+                Values.parameters( "term", searchTerm ) );
+
+        System.out.println("List of weapons called " + searchTerm + ":");
+        while ( result.hasNext() )
+        {
+            Record record = result.next();
+            System.out.println(record.get("weapon.name").asString());
+        }
+        // end::result-traversal[]
+    }
+
+    public static void accessRecord( Session session ) throws Exception
     {
-        // tag::result-cursor[]
-        StatementResult result = session.run( "MATCH (p:Person { name: {name} }) RETURN p.age",
-                Values.parameters( "name", "The One" ) );
+        // tag::access-record[]
+        String searchTerm = "Arthur";
+        StatementResult result = session.run( "MATCH (weapon:Weapon) WHERE weapon.owner CONTAINS {term} RETURN weapon.name, weapon.material, weapon.size",
+                Values.parameters( "term", searchTerm ) );
 
+        System.out.println("List of weapons owned by " + searchTerm + ":");
         while ( result.hasNext() )
         {
             Record record = result.next();
-            for ( Pair<String,Value> fieldInRecord : record.fields() )
+            List<String> sword = new ArrayList<>();
+            for ( String key : record.keys() )
             {
-                System.out.println( fieldInRecord.key() + " = " + fieldInRecord.value() );
+                sword.add( key + ": " + record.get(key) );
             }
+            System.out.println(sword);
         }
-        // end::result-cursor[]
+        // end::access-record[]
     }
 
     public static void retainResultsForNestedQuerying( Session session ) throws Exception
     {
-        // tag::retain-result-query[]
-        StatementResult result = session.run( "MATCH (p:Person { name: {name} }) RETURN id(p)",
-                Values.parameters( "name", "The One" ) );
+        // tag::nested-statements[]
+        StatementResult result = session.run( "MATCH (knight:Person:Knight) WHERE knight.castle = {castle} RETURN id(knight) AS knight_id",
+                Values.parameters( "castle", "Camelot" ) );
 
         for ( Record record : result.list() )
         {
-            session.run( "MATCH (p) WHERE id(p) = {id} " + "CREATE (p)-[:HAS_TRAIT]->(:Trait {type:'Immortal'})",
-                    Values.parameters( "id", record.get( "id(p)" ) ) );
+            session.run( "MATCH (knight) WHERE id(knight) = {id} " +
+                    "MATCH (king:Person) WHERE king.name = {king} " +
+                    "CREATE (knight)-[:DEFENDS]->(king)",
+                    Values.parameters( "id", record.get( "knight_id" ), "king", "Arthur" ) );
         }
-        // end::retain-result-query[]
+        // end::nested-statements[]
     }
 
     public static void retainResultsForLaterProcessing( Driver driver ) throws Exception
     {
-        // tag::retain-result-process[]
         Session session = driver.session();
-
-        StatementResult result = session.run( "MATCH (p:Person { name: {name} }) RETURN p.age",
-                Values.parameters( "name", "The One" ) );
+        // tag::retain-result[]
+        StatementResult result = session.run( "MATCH (knight:Person:Knight) WHERE knight.castle = {castle} RETURN knight.name AS name",
+                Values.parameters( "castle", "Camelot" ) );
 
         List<Record> records = result.list();
-
         session.close();
 
         for ( Record record : records )
         {
-            for ( Pair<String,Value> fieldInRecord : record.fields() )
-            {
-                System.out.println( fieldInRecord.key() + " = " + fieldInRecord.value() );
-            }
+            System.out.println( record.get("name").asString() + " is a knight of Camelot" );
         }
-        // end::retain-result-process[]
+        // end::retain-result[]
+    }
+
+    public static void handleCypherError( Session session ) throws Exception
+    {
+        // tag::handle-cypher-error[]
+        try
+        {
+            session.run( "This will cause a syntax error" ).consume();
+        }
+        catch ( ClientException e )
+        {
+            throw new RuntimeException("Something really bad has happened!");
+        }
+        // end::handle-cypher-error[]
     }
 
     public static void transactionCommit( Session session ) throws Exception
     {
         // tag::transaction-commit[]
         try ( Transaction tx = session.beginTransaction() )
         {
-            tx.run( "CREATE (p:Person { name: 'The One' })" );
+            tx.run( "CREATE (:Person {name: 'Guinevere'})" );
             tx.success();
         }
         // end::transaction-commit[]
@@ -146,7 +178,7 @@ public static void transactionRollback( Session session ) throws Exception
         // tag::transaction-rollback[]
         try ( Transaction tx = session.beginTransaction() )
         {
-            tx.run( "CREATE (p:Person { name: 'The One' })" );
+            tx.run( "CREATE (:Person {name: 'Merlin'})" );
             tx.failure();
         }
         // end::transaction-rollback[]
@@ -156,7 +188,7 @@ public static void resultSummary( Session session ) throws Exception
     {
         // tag::result-summary-query-profile[]
         StatementResult result = session.run( "PROFILE MATCH (p:Person { name: {name} }) RETURN id(p)",
-                Values.parameters( "name", "The One" ) );
+                Values.parameters( "name", "Arthur" ) );
 
         ResultSummary summary = result.consume();
 
@@ -168,7 +200,7 @@ public static void resultSummary( Session session ) throws Exception
     public static void notifications( Session session ) throws Exception
     {
         // tag::result-summary-notifications[]
-        ResultSummary summary = session.run( "EXPLAIN MATCH (a), (b) RETURN a,b" ).consume();
+        ResultSummary summary = session.run( "EXPLAIN MATCH (king), (queen) RETURN king, queen" ).consume();
 
         for ( Notification notification : summary.notifications() )
         {
@@ -180,7 +212,7 @@ public static void notifications( Session session ) throws Exception
     public static Driver requireEncryption() throws Exception
     {
         // tag::tls-require-encryption[]
-        Driver driver = GraphDatabase.driver( "bolt://localhost",
+        Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic("neo4j", "neo4j"),
                 Config.build().withEncryptionLevel( Config.EncryptionLevel.REQUIRED ).toConfig() );
         // end::tls-require-encryption[]
 
@@ -190,8 +222,8 @@ public static Driver requireEncryption() throws Exception
     public static Driver trustOnFirstUse() throws Exception
     {
         // tag::tls-trust-on-first-use[]
-        Driver driver = GraphDatabase.driver( "bolt://localhost", Config.build()
-                .withEncryptionLevel( Config.EncryptionLevel.NONE )
+        Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic("neo4j", "neo4j"), Config.build()
+                .withEncryptionLevel( Config.EncryptionLevel.REQUIRED )
                 .withTrustStrategy( Config.TrustStrategy.trustOnFirstUse( new File( "/path/to/neo4j_known_hosts" ) ) )
                 .toConfig() );
         // end::tls-trust-on-first-use[]
@@ -202,12 +234,22 @@ public static Driver trustOnFirstUse() throws Exception
     public static Driver trustSignedCertificates() throws Exception
     {
         // tag::tls-signed[]
-        Driver driver = GraphDatabase.driver( "bolt://localhost", Config.build()
-                .withEncryptionLevel( Config.EncryptionLevel.NONE )
+        Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic("neo4j", "neo4j"), Config.build()
+                .withEncryptionLevel( Config.EncryptionLevel.REQUIRED )
                 .withTrustStrategy( Config.TrustStrategy.trustSignedBy( new File( "/path/to/ca-certificate.pem") ) )
                 .toConfig() );
         // end::tls-signed[]
 
         return driver;
     }
+
+    public static Driver connectWithAuthDisabled() throws Exception
+    {
+        // tag::connect-with-auth-disabled[]
+        Driver driver = GraphDatabase.driver( "bolt://localhost",
+                Config.build().withEncryptionLevel( Config.EncryptionLevel.REQUIRED ).toConfig() );
+        // end::connect-with-auth-disabled[]
+
+        return driver;
+    }
 }
diff --git a/examples/src/main/java/org/neo4j/docs/driver/MinimalWorkingExample.java b/examples/src/main/java/org/neo4j/docs/driver/MinimalWorkingExample.java
@@ -20,28 +20,24 @@
 
 // NOTE: Be careful about auto-formatting here: All imports should be between the tags below.
 // tag::minimal-example-import[]
-import org.neo4j.driver.v1.Driver;
-import org.neo4j.driver.v1.GraphDatabase;
-import org.neo4j.driver.v1.Record;
-import org.neo4j.driver.v1.StatementResult;
-import org.neo4j.driver.v1.Session;
+import org.neo4j.driver.v1.*;
 // end::minimal-example-import[]
 
 public class MinimalWorkingExample
 {
     public static void minimalWorkingExample() throws Exception
     {
         // tag::minimal-example[]
-        Driver driver = GraphDatabase.driver( "bolt://localhost" );
+        Driver driver = GraphDatabase.driver( "bolt://localhost", AuthTokens.basic( "neo4j", "neo4j" ) );
         Session session = driver.session();
 
-        session.run( "CREATE (neo:Person {name:'Neo', age:23})" );
+        session.run( "CREATE (a:Person {name:'Arthur', title:'King'})" );
 
-        StatementResult result = session.run( "MATCH (p:Person) WHERE p.name = 'Neo' RETURN p.age" );
+        StatementResult result = session.run( "MATCH (a:Person) WHERE a.name = 'Arthur' RETURN a.name AS name, a.title AS title" );
         while ( result.hasNext() )
         {
             Record record = result.next();
-            System.out.println( "Neo is " + record.get( "p.age" ).asInt() + " years old." );
+            System.out.println( record.get( "title" ).asString() + " " + record.get("name").asString() );
         }
 
         session.close();
diff --git a/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java b/examples/src/test/java/org/neo4j/docs/driver/ExamplesIT.java
