conflicts and cypher 25 removals

JPryce-Aklundh · JPryce-Aklundh · commit af663566ad7e · 2025-04-24T10:51:35.000+02:00
diff --git a/modules/ROOT/content-nav.adoc b/modules/ROOT/content-nav.adoc
@@ -51,17 +51,18 @@
 ** xref:patterns/reference.adoc[]
 
 * xref:values-and-types/index.adoc[]
-** xref:values-and-types/property-structural-constructed.adoc[]
-** xref:values-and-types/temporal.adoc[]
-** xref:values-and-types/spatial.adoc[]
-** xref:values-and-types/working-with-null.adoc[]
-** xref:values-and-types/lists.adoc[]
-** xref:values-and-types/maps.adoc[]
-** xref:values-and-types/casting-data.adoc[]
+** xref::values-and-types/property-structural-constructed.adoc[]
+** xref:values-and-types/boolean-numeric-string.adoc[]
+** xref::values-and-types/temporal.adoc[]
+** xref::values-and-types/spatial.adoc[]
+** xref::values-and-types/lists.adoc[]
+** xref::values-and-types/maps.adoc[]
+** xref:values-and-types/graph-references.adoc[]
+** xref::values-and-types/working-with-null.adoc[]
+** xref::values-and-types/casting-data.adoc[]
 ** xref:values-and-types/ordering-equality-comparison.adoc[]
 
 * xref:expressions/index.adoc[]
-** xref:expressions/expressions-overview.adoc[]
 ** xref:expressions/predicates/index.adoc[]
 *** xref:expressions/predicates/boolean-operators.adoc[]
 *** xref:expressions/predicates/comparison-operators.adoc[]
diff --git a/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc b/modules/ROOT/pages/appendix/gql-conformance/additional-cypher.adoc
@@ -622,7 +622,7 @@ GQL supports `GRAPH TYPES` as a way of constraining a graph schema, but does not
 | Cypher feature
 | Description
 
-| xref:syntax/operators.adoc#query-operator-comparison-string-specific[`STARTS WITH`, `CONTAINS`, `ENDS WITH`, and regular expressions].
+| xref:expressions/predicates/string-operators.adoc[`STARTS WITH`, `CONTAINS`, `ENDS WITH`, and regular expressions].
 | `STRING` comparison operators.
 
 | xref:expressions/predicates/list-operators.adoc[`IN`]
diff --git a/modules/ROOT/pages/appendix/gql-conformance/supported-mandatory.adoc b/modules/ROOT/pages/appendix/gql-conformance/supported-mandatory.adoc
@@ -128,7 +128,7 @@ This is currently not available in Cypher.
 
 | 19.3
 | <comparison predicate>
-| xref:syntax/operators.adoc##query-operators-comparison[Comparison operators]
+| xref:expressions/predicates/comparison-operators.adoc[Comparison operators]
 |
 
 | 19.4
@@ -148,12 +148,12 @@ This is currently not available in Cypher.
 
 | 19.7
 | <normalized predicate>
-| xref:syntax/operators.adoc#match-string-is-normalized[`IS NORMALIZED`], xref:syntax/operators.adoc#match-string-is-not-normalized[`IS NOT NORMALIZED`]
+| xref:expressions/predicates/string-operators.adoc#string-normalization-operators[`IS NORMALIZED`,`IS NOT NORMALIZED`]
 |
 
 | 20.2
 | <value expression primary>
-| xref:expressions/expressions-overview.adoc[]
+| xref:expressions/index.adoc[]
 |
 
 | 20.3
@@ -190,7 +190,7 @@ For example, `RETURN sum(<expr>)` on an empty table returns `NULL` in GQL, but i
 
 | 20.23
 | <string value expression>
-| xref:syntax/operators.adoc#syntax-concatenating-two-strings-doublebar[`STRING` concatenation operator (`\|\|`)]
+| xref:expressions/string-operators.adoc[`STRING` concatenation operator (`\|\|`)]
 |
 
 | 20.24
diff --git a/modules/ROOT/pages/appendix/gql-conformance/supported-optional.adoc b/modules/ROOT/pages/appendix/gql-conformance/supported-optional.adoc
@@ -116,7 +116,7 @@ Cypher only supports xref:functions/mathematical-numeric.adoc#functions-ceil[`ce
 | Note the following exceptions:
 
  * Cypher uses the xref:functions/mathematical-logarithmic.adoc#functions-log[`log()`] function instead of GQL's `LN()` function.
-* Cypher uses the xref:syntax/operators.adoc#syntax-using-the-exponentiation-operator[exponentiation operator (`^`)] instead of GQL's `POWER()` function.
+* Cypher uses the xref:expressions/mathematical-operators.adoc[exponentiation operator (`^`)] instead of GQL's `POWER()` function.
 
 | GF05
 | Multi-character trim functions
diff --git a/modules/ROOT/pages/clauses/match.adoc b/modules/ROOT/pages/clauses/match.adoc
@@ -387,7 +387,7 @@ RETURN p.name AS actor, r.role AS role
 ----
 
 [NOTE]
-The above query uses the xref:syntax/operators.adoc#query-operator-comparison-string-specific[`CONTAINS` operator].
+The above query uses the xref:expressions/predicates/string-operators.adoc[`CONTAINS` operator].
 
 .Result
 [role="queryresult",options="header,footer",cols="2*<m"]
diff --git a/modules/ROOT/pages/clauses/order-by.adoc b/modules/ROOT/pages/clauses/order-by.adoc
@@ -7,7 +7,7 @@
 It be used as a sub-clause following `RETURN` or `WITH`.
 As of Neo4j 5.24, it can also be used as a standalone clause, either on its own or in combination with `SKIP`/`OFFSET` or `LIMIT`.
 
-`ORDER BY` relies on comparisons to sort the output, see xref::syntax/operators.adoc#cypher-ordering[Ordering and comparison of values].
+`ORDER BY` relies on comparisons to sort the output, see xref:values-and-types/ordering-equality-comparison.adoc[Ordering and comparison of values].
 You can sort on many different values, e.g. node/relationship properties, the node/relationship ids, or on most expressions.
 
 [NOTE]
diff --git a/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc b/modules/ROOT/pages/deprecations-additions-removals-compatibility.adoc
@@ -837,7 +837,7 @@ RETURN "Hello" \|\| " " \|\| "World";
 
 RETURN [1, 2] \|\| [3, 4, 5];
 ----
-| Added a new `STRING` and `LIST` xref:syntax/operators.adoc[concatenation operator].
+| Added a new `STRING` and `LIST` xref:expressions/string-operators.adoc[concatenation operator].
 
 a|
 label:functionality[]
@@ -1038,7 +1038,7 @@ IS [NOT] [NFC \| NFD \| NFKC \| NFKD] NORMALIZED
 RETURN "string" IS NORMALIZED
 ----
 
-| Introduction of an xref::syntax/operators.adoc#match-string-is-normalized[IS NORMALIZED] operator.
+| Introduction of an xref::expressions/predicates/string-operators.adoc#string-normalization-operator[IS NORMALIZED] operator.
 The operator can be used to check if a `STRING` is normalized according to the specified normalization form, which can be of type `NFC`, `NFD`, `NFKC`, or `NFKD`.
 
 a|
diff --git a/modules/ROOT/pages/expressions/conditional-expressions.adoc b/modules/ROOT/pages/expressions/conditional-expressions.adoc
@@ -106,11 +106,12 @@ implied equals (`=`) comparator.
 
 The supported comparators are:
 
-* xref::syntax/operators.adoc#query-operators-comparison[Regular Comparison Operators]: `+=+`, `+<>+`, `+<+`, `+>+`, `+<=+`, `+>=+`
-* xref:values-and-types/working-with-null.adoc#is-null-is-not-null[`IS NULL` Operator]: `IS [NOT] NULL`
-* xref:expressions/predicates/type-predicate-expressions.adoc[Type Predicate Expression]: `IS [NOT] TYPED <TYPE>` (Note that the form `IS [NOT] :: <TYPE>` is not accepted)
-* xref::syntax/operators.adoc#match-string-is-normalized[Normalization Predicate Expression]: `IS [NOT] NORMALIZED`
-* xref::syntax/operators.adoc#query-operator-comparison-string-specific[String Comparison Operators]: `STARTS WITH`, `ENDS WITH`, `=~` (regex matching)
+* xref:expressions/predicates/comparison-operators.adoc[Regular Comparison Operators]: `+=+`, `+<>+`, `+<+`, `+>+`, `+<=+`, `+>=+`
+* xref:expressions/predicates/comparison-operators.adoc[`IS [NOT] NULL`]
+* xref:expressions/predicates/type-predicate-expressions.adoc[Type predicate expressions]: `IS [NOT] TYPED <TYPE>` (Note that the form `IS [NOT] :: <TYPE>` is not accepted)
+* xref:expressions/predicates/string-operators.adoc[Normalization Predicate Expression]: `IS [NOT] NORMALIZED`
+* xref:expressions/predicates/string-operators.adoc[String Comparison Operators]: `STARTS WITH`, `ENDS WITH`, `=~` (regex matching)
+
 
 === Syntax
 
diff --git a/modules/ROOT/pages/expressions/index.adoc b/modules/ROOT/pages/expressions/index.adoc
@@ -2,11 +2,9 @@
 :description: Information about the expressions available in Cypher.
 :page-aliases: syntax/operators.adoc
 
-
 A Cypher expression is any part of a query that evaluates to a value.
 For details and examples of specific expressions, see the following sections:
 
-* xref:expressions/expressions-overview.adoc[]
 * xref:expressions/predicates/index.adoc[]
 ** xref:expressions/predicates/boolean-operators.adoc[]: `AND`, `OR`, `XOR`, `NOT`
 ** xref:expressions/predicates/comparison-operators.adoc[]: `=`, `<>`, `<`, `>`, `\<=`, `>=`, `IS NULL`, `IS NOT NULL`
@@ -21,3 +19,16 @@ For details and examples of specific expressions, see the following sections:
 * xref:expressions/list-expressions.adoc[]: information about list concatenation operators (`||`, `+`), list element access, list slicing, and list as well as pattern comprehensions.
 * xref:expressions/map-expressions.adoc[]: information about map operators (`.`, `[]`) and map projection.
 * xref:expressions/conditional-expressions.adoc[]
+
+The following expressions are documented elsewhere in the Cypher Manual:
+
+* xref:patterns/reference.adoc#label-expressions[Label expressions]
+* xref:functions/index.adoc[Function calls]
+* Subquery expressions: xref:subqueries/collect.adoc[`COLLECT`], xref:subqueries/count.adoc[`COUNT`], and xref:subqueries/existential.adoc[`EXISTS`]
+* Value literals (see xref:values-and-types/index.adoc[])
+
+[NOTE]
+Expressions containing unsanitized user input may make your application vulnerable to Cypher injection.
+Consider using xref:syntax/parameters.adoc[parameters] instead.
+For more information, see link:https://neo4j.com/developer/kb/protecting-against-cypher-injection/[Neo4j Knowledge Base -> Protecting against Cypher Injection].
+
diff --git a/modules/ROOT/pages/expressions/predicates/path-pattern-expressions.adoc b/modules/ROOT/pages/expressions/predicates/path-pattern-expressions.adoc
@@ -2,7 +2,7 @@
 :table-caption!:
 :description: Information about path pattern expressions in Cypher.
 
-Similar to xref::subqueries/existential.adoc[existential subqueries], path pattern expressions can be used to assert whether a specified path exists at least once in a graph.
+Similar to xref::subqueries/existential.adoc[`EXISTS` subqueries], path pattern expressions can be used to assert whether a specified path exists at least once in a graph.
 While existential subqueries are more powerful and capable of performing anything achievable with path pattern expressions, path pattern expressions are more concise.
 
 For more information about graph pattern matching in Cypher, see xref:patterns/index.adoc[].
@@ -20,7 +20,7 @@ In other words, it must contain at least one xref::patterns/reference.adoc#relat
 * Path pattern expressions may not declare new variables.
 They can only reference existing variables.
 
-* Path pattern expressions may only be used in positions where a xref:expressions/expressions-overview.adoc#boolean[boolean expression] is expected.
+* Path pattern expressions may only be used in positions where a xref:expressions/predicates/boolean-operators.adoc[boolean expression] is expected.
 The following sections will demonstrate how to use path pattern expressions in a `WHERE` clause.
 
 [[example-graph]]
diff --git a/modules/ROOT/pages/expressions/predicates/string-operators.adoc b/modules/ROOT/pages/expressions/predicates/string-operators.adoc
@@ -185,7 +185,7 @@ RETURN n.name AS name, n.email AS email
 |===
 
 Note that the regular expression constructs in
-link:https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html[Java regular expressions] are applied only after resolving the escaped character sequences in the given xref::expressions/expressions-overview.adoc#expressions-string-literals[string literal].
+link:https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/regex/Pattern.html[Java regular expressions] are applied only after resolving the escaped character sequences in the given xref::values-and-types/boolean-numeric-string.adoc#string[string literal].
 It is sometimes necessary to add additional backslashes to express regular expression constructs.
 This list clarifies the combination of these two definitions, containing the original escape sequence and the resulting character in the regular expression:
 
diff --git a/modules/ROOT/pages/functions/predicate.adoc b/modules/ROOT/pages/functions/predicate.adoc
@@ -196,7 +196,7 @@ RETURN any(i IN emptyList WHERE true) as anyTrue, any(i IN emptyList WHERE false
 
 [NOTE]
 ====
-To check if a property is not `null` use the xref::syntax/operators.adoc#cypher-comparison[`IS NOT NULL` predicate].
+To check if a property is not `null` use the xref:expressions/predicates/comparison-operators.adoc[`IS NOT NULL` predicate].
 ====
 
 .+exists()+
@@ -330,7 +330,7 @@ The `name` property of each node that has an empty `STRING` `address` property i
 The function `isEmpty()`, like most other Cypher functions, returns `null` if `null` is passed in to the function.
 That means that a predicate `isEmpty(n.address)` will filter out all nodes where the `address` property is not set.
 Thus, `isEmpty()` is not suited to test for `null`-values.
-xref:syntax/operators.adoc#cypher-comparison[`IS NULL` or `IS NOT NULL`] should be used for that purpose.
+xref:expressions/predicates/comparison-operators.adoc[`IS NULL` or `IS NOT NULL`] should be used for that purpose.
 ====
 
 
diff --git a/modules/ROOT/pages/functions/string.adoc b/modules/ROOT/pages/functions/string.adoc
@@ -270,7 +270,7 @@ RETURN normalize('\u212B') = '\u00C5' AS result
 
 ======
 
-To check if a `STRING` is normalized, use the xref:syntax/operators.adoc#match-string-is-normalized[`IS NORMALIZED`] operator.
+To check if a `STRING` is normalized, use the xref:expressions/predicates/string-operators.adoc#string-normalization-operators[`IS NORMALIZED`] operator.
 
 [[functions-normalize-with-normal-form]]
 === normalize() with specified normal form
diff --git a/modules/ROOT/pages/patterns/reference.adoc b/modules/ROOT/pages/patterns/reference.adoc
@@ -344,7 +344,7 @@ is equivalent to the following node pattern with a `WHERE` clause:
 (n WHERE n.p = valueExp1 AND n.q = valueExp2)
 ----
 
-The value expression can be any expression as listed in the section on xref:expressions/expressions-overview.adoc[expressions], except for path patterns (which will throw a syntax error) and regular expressions (which will be treated as string literals).
+The value expression can be any expression as listed in the section on xref:expressions/index.adoc[expressions], except for path patterns (which will throw a syntax error) and regular expressions (which will be treated as string literals).
 An empty property key-value expression matches all elements.
 Property key-value expressions can be combined with a `WHERE` clause.
 
@@ -860,7 +860,7 @@ It is equivalent to the syntax for quantified relationships, with the following
 
 * Position and syntax of quantifier.
 * Semantics of the asterisk symbol.
-* Type expressions are limited to the xref::syntax/operators.adoc#query-operators-boolean[disjunction operator].
+* Type expressions are limited to the xref:expressions/predicates/boolean-operators.adoc[disjunction operator].
 * The xref:clauses/where.adoc[WHERE] clause is not allowed.
 
 [[variable-length-relationships-syntax]]
diff --git a/modules/ROOT/pages/queries/basic.adoc b/modules/ROOT/pages/queries/basic.adoc
@@ -743,7 +743,7 @@ There are several ways in which Cypher can be used to search a graph for paths b
 
 To search for patterns of a fixed length, specify the distance (hops) between the nodes in the pattern by using a xref::patterns/reference.adoc#quantifiers[quantifier] (`\{n}`). 
 For example, the following query matches all `Person` nodes exactly 2 hops away from `Tom Hanks` and returns the first five rows.
-The xref:syntax/operators.adoc#syntax-using-the-distinct-operator[DISTINCT] operator ensures that the result contain no duplicate values. 
+The ``DISTINCT` operator ensures that the result contain no duplicate values. 
 
 .Query
 [source, cypher]
diff --git a/modules/ROOT/pages/queries/concepts.adoc b/modules/ROOT/pages/queries/concepts.adoc
@@ -68,7 +68,7 @@ RETURN DISTINCT friend.name AS olderConnections
 ----
 
 This example uses a xref:patterns/variable-length-patterns.adoc#quantified-relationships[quantified relationship] to find all paths up to `5` hops away, traversing only relationships of type `KNOWS` from the start node `Anna` to other older `Person` nodes (as defined by the xref:clauses/where.adoc[] clause).
-The xref:syntax/operators.adoc#syntax-using-the-distinct-operator[DISTINCT] operator is used to ensure that the `RETURN` clause only returns unique nodes.
+The `DISTINCT` operator is used to ensure that the `RETURN` clause only returns unique nodes.
 
 Paths can also be assigned variables.
 For example, the below query binds a whole path pattern, which matches the xref:patterns/shortest-paths.adoc[`SHORTEST`] path from `Anna` to another `Person` node in the graph with a `nationality` property set to `Canadian`.
diff --git a/modules/ROOT/pages/syntax/parsing.adoc b/modules/ROOT/pages/syntax/parsing.adoc
@@ -23,7 +23,7 @@ RETURN r
 
 Additional documentation on escaping rules for `STRING` literals, names and regular expressions can be found here:
 
-* xref::expressions/expressions-overview.adoc#expressions-string-literals[String literal escape sequences]
+* xref::values-and-types/boolean-numeric-string.adoc#string-literal-escape-sequences[String literal escape sequences]
 * xref::syntax/naming.adoc#symbolic-names-escaping-rules[Using special characters in names]
 * xref:expressions/predicates/string-operators.adoc#regular-expressions[Regular expressions]
 
diff --git a/modules/ROOT/pages/values-and-types/boolean-numeric-string.adoc b/modules/ROOT/pages/values-and-types/boolean-numeric-string.adoc
@@ -0,0 +1,72 @@
+= Boolean, numeric, and string literals
+:description: Information about Cypher's boolean, numeric, and string literals.
+
+This page describes the literal forms of numerical (`INTEGER` and `FLOAT`), `STRING`, and `BOOLEAN` values in xref:expressions/index.adoc[expressions].
+
+[NOTE]
+Expressions containing unsanitized user input may make your application vulnerable to Cypher injection.
+Consider using xref:syntax/parameters.adoc[parameters] instead.
+For more information, see link:https://neo4j.com/developer/kb/protecting-against-cypher-injection/[Neo4j Knowledge Base -> Protecting against Cypher Injection].
+
+[[boolean]]
+== Boolean
+
+Boolean literals represent `BOOLEAN` values.
+A boolean literal may be written as:
+
+* The literal `true`
+* The literal `false`
+
+[[numerical]]
+== Numerical
+
+Numerical literals can represent `INTEGER` or `FLOAT` values.
+A numerical literal may be written as:
+
+* A decimal `INTEGER` literal: `13`, `-40000`
+* A hexadecimal `INTEGER` literal (prefix `0x`): `0x13af`, `0xFC3A9`, `-0x66eff`
+* An octal `INTEGER` literal (prefix `0o`): `0o1372`, `-0o5671`
+
+//
+
+* A `FLOAT` literal in common notation: `3.14`
+* A `FLOAT` literal in scientific notation: `6.022E23`, `1e-9`
+* Literals for special `FLOAT` values: `Inf`, `Infinity`, `NaN`
+
+[NOTE]
+Any numeric literal may contain an underscore `_` between digits.
+There may be an underscore between the `0x` or `0o` and the digits for hexadecimal and octal literals.
+For example: `1_000_000`, `0x_FC3A9`, and `0o_1372`.
+
+[[string]]
+== String
+
+String literals represent `STRING` values.
+They are written using single(`'`) or double quotes (`"`) and may contain escape sequences using a backslash (`\`).
+A string literal may be written as:
+
+* A `STRING` quoted with single quotes: `'Hello, 42'`
+* A `STRING` quoted with double quotes: `"Hello, 42"`
+* A `STRING` with whitespace: `'    hello   '`
+* A `STRING` with escape sequences: `'Line 1\nLine 2'`, `'Tab\tseparated'`
+* A `STRING` containing Unicode characters: `'그래프는 어디에나 있다'` 
+* A `STRING` using a Unicode code point: `'Name: \u004Aohn'` (produces `'Name: John'`)
+
+[[string-literal-escape-sequences]]
+=== String literal escape sequences
+
+String literals can contain the following escape sequences:
+
+[options="header", cols=">1,<2"]
+|===
+|Escape sequence|Character
+|`\t`|Tab
+|`\b`|Backspace
+|`\n`|Newline
+|`\r`|Carriage return
+|`\f`|Form feed
+|`\'`|Single quote
+|`\"`|Double quote
+|`\\`|Backslash
+|`\uxxxx`|Unicode UTF-16 code point (4 hex digits must follow the `\u`)
+|===
diff --git a/modules/ROOT/pages/values-and-types/index.adoc b/modules/ROOT/pages/values-and-types/index.adoc
@@ -8,11 +8,12 @@ Rather, Cypher will automatically infer the data type of a given value.
 More information about the data values and types supported by Cypher can be found in the following sections:
 
 * xref::values-and-types/property-structural-constructed.adoc[]
+* xref:values-and-types/boolean-numeric-string.adoc[]
 * xref::values-and-types/temporal.adoc[]
 * xref::values-and-types/spatial.adoc[]
-* xref::values-and-types/working-with-null.adoc[]
 * xref::values-and-types/lists.adoc[]
 * xref::values-and-types/maps.adoc[]
+* xref::values-and-types/working-with-null.adoc[]
 * xref::values-and-types/casting-data.adoc[]
 * xref:values-and-types/ordering-equality-comparison.adoc[]
 
diff --git a/modules/ROOT/pages/values-and-types/ordering-equality-comparison.adoc b/modules/ROOT/pages/values-and-types/ordering-equality-comparison.adoc
@@ -55,9 +55,9 @@ Values of different types are ordered based on a predefined hierarchy, from leas
 * xref::values-and-types/temporal.adoc[`LOCAL TIME`]
 * xref::values-and-types/temporal.adoc[`DURATION`]
 * xref::values-and-types/spatial.adoc[`POINT`]
-* xref::expressions/expressions-overview.adoc#string[`STRING`]
-* xref::expressions/expressions-overview.adoc#boolean[`BOOLEAN`]
-* Numbers: xref::expressions/expressions-overview.adoc#numerical[`INTEGER`, `FLOAT`]
+* xref::values-and-types/property-structural-constructed.adoc[`STRING`]
+* xref::values-and-types/property-structural-constructed.adoc[`BOOLEAN`]
+* Numbers: xref:values-and-types/property-structural-constructed.adoc[`INTEGER`, `FLOAT`]
 
 [NOTE]
 `NULL` is ordered after all other values.
diff --git a/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc b/modules/ROOT/pages/values-and-types/property-structural-constructed.adoc
diff --git a/modules/ROOT/pages/values-and-types/spatial.adoc b/modules/ROOT/pages/values-and-types/spatial.adoc
diff --git a/modules/ROOT/pages/values-and-types/working-with-null.adoc b/modules/ROOT/pages/values-and-types/working-with-null.adoc

Original file line number	Diff line number	Diff line change
`@@ -128,7 +128,7 @@ This is currently not available in Cypher.`
`128`	`128`
`129`	`129`	`\| 19.3`
`130`	`130`	`\| <comparison predicate>`
`131`		`-\| xref:syntax/operators.adoc##query-operators-comparison[Comparison operators]`
	`131`	`+\| xref:expressions/predicates/comparison-operators.adoc[Comparison operators]`
`132`	`132`	`\|`
`133`	`133`
`134`	`134`	`\| 19.4`
`@@ -148,12 +148,12 @@ This is currently not available in Cypher.`
`148`	`148`
`149`	`149`	`\| 19.7`
`150`	`150`	`\| <normalized predicate>`
`151`		-\| xref:syntax/operators.adoc#match-string-is-normalized[`IS NORMALIZED`], xref:syntax/operators.adoc#match-string-is-not-normalized[`IS NOT NORMALIZED`]
	`151`	+\| xref:expressions/predicates/string-operators.adoc#string-normalization-operators[`IS NORMALIZED`,`IS NOT NORMALIZED`]
`152`	`152`	`\|`
`153`	`153`
`154`	`154`	`\| 20.2`
`155`	`155`	`\| <value expression primary>`
`156`		`-\| xref:expressions/expressions-overview.adoc[]`
	`156`	`+\| xref:expressions/index.adoc[]`
`157`	`157`	`\|`
`158`	`158`
`159`	`159`	`\| 20.3`
@@ -190,7 +190,7 @@ For example, `RETURN sum(<expr>)` on an empty table returns `NULL` in GQL, but i
`190`	`190`
`191`	`191`	`\| 20.23`
`192`	`192`	`\| <string value expression>`
`193`		-\| xref:syntax/operators.adoc#syntax-concatenating-two-strings-doublebar[`STRING` concatenation operator (`\\|\\|`)]
	`193`	+\| xref:expressions/string-operators.adoc[`STRING` concatenation operator (`\\|\\|`)]
`194`	`194`	`\|`
`195`	`195`
`196`	`196`	`\| 20.24`