more

Author: JPryce-Aklundh

modules/ROOT/content-nav.adoc

@@ -40,15 +40,26 @@
 ** **Read/Write**
 ** xref:clauses/merge.adoc[]
 
-** **Procedure invocation**
+** **Invocation**
 ** xref:clauses/call.adoc[]
+** xref:subqueries/call-subquery.adoc[]
+** xref:subqueries/subqueries-in-transactions.adoc[]
 
 ** **Import**
 ** xref:clauses/load-csv.adoc[]
 
 ** **Graph selection**
 ** xref:clauses/use.adoc[]
 
+** **Schema**
+** xref:constraints/managing-constraints.adoc#create-constraint[CREATE CONSTRAINT]
+** xref:constraints/managing-constraints.adoc#list-constraints[SHOW CONSTRAINTS]
+** xref:constraints/managing-constraints.adoc#drop-constraint[DROP CONSTRAINTS]
+** xref:indexes/search-performance-indexes/managing-indexes.adoc#create-range-index[CREATE INDEX]
+** xref:indexes/search-performance-indexes/managing-indexes.adoc#list-indexes[SHOW INDEXES]
+** xref:indexes/search-performance-indexes/managing-indexes.adoc#drop-indexes[DROP INDEX]
+
+
 ** **Metadata**
 ** xref:clauses/listing-functions.adoc[]
 ** xref:clauses/listing-procedures.adoc[]

modules/ROOT/pages/subqueries/collect.adoc

@@ -63,7 +63,7 @@ RETURN person.name as name,
          MATCH (person)-[r:HAS_DOG]->(dog:Dog)
            WHERE r.since > 2017
          RETURN dog.name
-} as youngDogs
+       } AS youngDogs
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]
@@ -120,15 +120,14 @@ The below example shows the collection of pet names each person has by using a `
 [source, cypher]
 ----
 MATCH (person:Person)
-RETURN
-    person.name AS name,
-    COLLECT {
-        MATCH (person)-[:HAS_DOG]->(dog:Dog)
-        RETURN dog.name AS petName
-        UNION
-        MATCH (person)-[:HAS_CAT]->(cat:Cat)
-        RETURN cat.name AS petName
-    } AS petNames
+RETURN person.name AS name,
+       COLLECT {
+         MATCH (person)-[:HAS_DOG]->(dog:Dog)
+         RETURN dog.name AS petName
+         UNION
+         MATCH (person)-[:HAS_CAT]->(cat:Cat)
+         RETURN cat.name AS petName
+      } AS petNames
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]
@@ -154,10 +153,10 @@ In the example below, the outer variable `name` is shadowed and will therefore t
 WITH 'Peter' as name
 MATCH (person:Person {name: name})
 RETURN COLLECT {
-    WITH 'Ozzy' AS name
-    MATCH (person)-[r:HAS_DOG]->(d:Dog {name: name})
-    RETURN d.name
-} as dogsOfTheYear
+        WITH 'Ozzy' AS name
+        MATCH (person)-[r:HAS_DOG]->(d:Dog {name: name})
+        RETURN d.name
+       } AS dogsOfTheYear
 ----
 
 .Error message
@@ -173,12 +172,13 @@ Note that the outer scope variable `person` referenced in the main query is stil
 [source, cypher]
 ----
 MATCH (person:Person)
-RETURN person.name AS name, COLLECT {
-    WITH 2018 AS yearOfTheDog
-    MATCH (person)-[r:HAS_DOG]->(d:Dog)
-      WHERE r.since = yearOfTheDog
-    RETURN d.name
-} as dogsOfTheYear
+RETURN person.name AS name,
+       COLLECT {
+         WITH 2018 AS yearOfTheDog
+         MATCH (person)-[r:HAS_DOG]->(d:Dog)
+           WHERE r.since = yearOfTheDog
+         RETURN d.name
+       } AS dogsOfTheYear
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]
@@ -206,10 +206,10 @@ See a few examples below of how `COLLECT` can be used in different positions wit
 MATCH (person:Person)
 RETURN person.name,
        COLLECT {
-            MATCH (person)-[:HAS_DOG]->(d:Dog)
-            MATCH (d)-[:HAS_TOY]->(t:Toy)
-            RETURN t.name
-       } as toyNames
+         MATCH (person)-[:HAS_DOG]->(d:Dog)
+         MATCH (d)-[:HAS_TOY]->(t:Toy)
+         RETURN t.name
+       } AS toyNames
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]
@@ -230,7 +230,7 @@ RETURN person.name,
 MATCH (person:Person)
   WHERE person.name = "Peter"
 SET person.dogNames = COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog) RETURN d.name }
-RETURN person.dogNames as dogNames
+RETURN person.dogNames AS dogNames
 ----
 
 [role="queryresult",options="header,footer",cols="1*<m"]
@@ -274,9 +274,10 @@ and then calculates the average age for each group.
 [source, cypher]
 ----
 MATCH (person:Person)
-RETURN COLLECT { MATCH (person)-[:HAS_DOG]->(d:Dog)
-       RETURN d.name } AS dogNames,
-       avg(person.age) AS averageAge
+RETURN COLLECT {
+         MATCH (person)-[:HAS_DOG]->(d:Dog)
+         RETURN d.name } AS dogNames,
+         avg(person.age) AS averageAge
   ORDER BY dogNames
 ----
 

modules/ROOT/pages/subqueries/count.adoc

@@ -125,11 +125,11 @@ MATCH (person:Person)
 RETURN
     person.name AS name,
     COUNT {
-        MATCH (person)-[:HAS_DOG]->(dog:Dog)
-        RETURN dog.name AS petName
-        UNION
-        MATCH (person)-[:HAS_CAT]->(cat:Cat)
-        RETURN cat.name AS petName
+      MATCH (person)-[:HAS_DOG]->(dog:Dog)
+      RETURN dog.name AS petName
+      UNION
+      MATCH (person)-[:HAS_CAT]->(cat:Cat)
+      RETURN cat.name AS petName
     } AS numPets
 ----
 
@@ -205,8 +205,8 @@ See a few examples below:
 [source, cypher]
 ----
 MATCH (person:Person)
-RETURN person.name, COUNT { (person)-[:HAS_DOG]->(:Dog) } as howManyDogs
-
+RETURN person.name,
+       COUNT { (person)-[:HAS_DOG]->(:Dog) } AS howManyDogs
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]
@@ -229,7 +229,6 @@ MATCH (person:Person)
   WHERE person.name ="Andy"
 SET person.howManyDogs = COUNT { (person)-[:HAS_DOG]->(:Dog) }
 RETURN person.howManyDogs as howManyDogs
-
 ----
 
 [role="queryresult",options="header,footer",cols="1*<m"]
@@ -252,7 +251,6 @@ RETURN
      WHEN COUNT { (person)-[:HAS_DOG]->(:Dog) } > 1 THEN "Doglover " + person.name
      ELSE person.name
    END AS result
-
 ----
 
 [role="queryresult",options="header,footer",cols="1*<m"]
@@ -278,7 +276,6 @@ MATCH (person:Person)
 RETURN COUNT { (person)-[:HAS_DOG]->(:Dog) } AS numDogs,
        avg(person.age) AS averageAge
   ORDER BY numDogs
-
 ----
 
 [role="queryresult",options="header,footer",cols="2*<m"]

modules/ROOT/pages/subqueries/existential.adoc

@@ -152,8 +152,9 @@ Here the result is a boolean that shows whether the subquery can find the given
 [source, cypher]
 ----
 MATCH (person:Person)
-RETURN person.name AS name, EXISTS {
-  MATCH (person)-[:HAS_DOG]->(:Dog)
+RETURN person.name AS name,
+       EXISTS {
+        MATCH (person)-[:HAS_DOG]->(:Dog)
 } AS hasDog
 ----