diff --git a/docs-2.0/3.ngql-guide/3.data-types/1.numeric.md b/docs-2.0/3.ngql-guide/3.data-types/1.numeric.md index e0c89c86470..ea4ad317040 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/1.numeric.md +++ b/docs-2.0/3.ngql-guide/3.data-types/1.numeric.md @@ -2,15 +2,12 @@ ## Integer -An integer is declared with keyword `int` , which is 64-bit *signed*. The supported range is [-9223372036854775808, 9223372036854775807]. Integer constants support multiple formats: +An integer is declared with the keyword `int`, which is 64-bit *signed*. The supported range is [-9223372036854775808, 9223372036854775807]. Integer constants support multiple formats: -1. Decimal, for example `123456`. -2. Hexadecimal, for example `0xdeadbeaf`. -3. Octal, for example `01234567`. +1. Decimal, such as `123456`. +2. Hexadecimal, such as `0x1e240`. +3. Octal, such as `0361100`. ## Double-precision floating-point -double-precision floating-point values is used for storing double precision floating point values. E.g., 1.2, -3.0000001. -The keyword used for double floating point data type is `double`. - -Scientific notation is also supported. For example, `1e2, 1.1e2, .3e4, 1.e4, -1234E-10`. +Double-precision floating-point values are declared with the keyword `double`, such as `1.2` and `-3.0000001`. Scientific notation is also supported, such as `1e2`, `1.1e2`, `.3e4`, `1.e4` and `-1234E-10`. diff --git a/docs-2.0/3.ngql-guide/3.data-types/3.string.md b/docs-2.0/3.ngql-guide/3.data-types/3.string.md index 82e9c479e5d..b726301d844 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/3.string.md +++ b/docs-2.0/3.ngql-guide/3.data-types/3.string.md @@ -1,26 +1,37 @@ # String -The string type is used to store a sequence of characters (text). The literal constant is a sequence of characters of any length surrounded by double or single quotes. For example `"Shaquille O'Neal"` or `'"This is a double-quoted literal string"'`. Line breaks are not allowed in a string. Embedded escape sequences are supported within strings, for example: +The string type is declared with the keywords of `string` or `fixed_string()`. A string type is used to store a sequence of characters (text). The literal constant is a sequence of characters of any length surrounded by double or single quotes. For example `"Shaquille O'Neal"` or `'This is a double-quoted literal string'`. -- `"\n\t\r\b\f"` -- `"\110ello world"` +## String types -Nebula Graph supports two kind of strings: fixed length string and variable length string. For example: +Nebula Graph supports two string types as follows: -```ngql -nebula> CREATE TAG t1 (p1 FIXED_STRING(10)); -- Fixed length string type +- Fixed-length string type -nebula> CREATE TAG t2 (p2 string); -- Variable length string type -``` + ```ngql + nebula> CREATE TAG t1 (p1 fixed_string(10)); + ``` -## OpenCypher Compatibility +- Variable-length string type + + ```ngql + nebula> CREATE TAG t2 (p2 string); + ``` + +## Escape Characters -Here is a tiny difference between openCypher and Cypher, as well as nGQL. +Line breaks are not allowed in a string. Escape characters are supported within strings, for example: + +- `"\n\t\r\b\f"` + +- `"\110ello world"` + +## OpenCypher Compatibility -The following is what openCypher requires. Single-quotes can't be converted to double-quotes. +There is some tiny differences between openCypher and Cypher, as well as nGQL. The following is what openCypher requires. Single quotes cannot be converted to double quotes. ```ngql - #File: Literals.feature +# File: Literals.feature Feature: Literals Background: @@ -36,7 +47,7 @@ Background: And no side effects ``` -While Cypher accepts both single-quotes and double quotes as the return results. nGQL follows the Cypher way. +While Cypher accepts both single quotes and double quotes as the return results. nGQL follows the Cypher way. ```ngql nebula > YIELD '' AS quote1, "" AS quote2, "'" AS quote3, '"' AS quote4 diff --git a/docs-2.0/3.ngql-guide/3.data-types/4.date-and-time.md b/docs-2.0/3.ngql-guide/3.data-types/4.date-and-time.md index 77ffb7947a5..d2bd77b3f34 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/4.date-and-time.md +++ b/docs-2.0/3.ngql-guide/3.data-types/4.date-and-time.md @@ -1,24 +1,24 @@ # Date and time types -This document describes the `DATE`, `TIME`, `DATETIME`, and `TIMESTAMP` types. Nebula Graph converts the `DATE`, `TIME`, `DATETIME`, and `TIMESTAMP` values from the current time zone to **UTC** for storage. Nebula Graph converts back from UTC to the current time zone for retrieval. +This topic will describe the `DATE`, `TIME`, `DATETIME`, and `TIMESTAMP` types. -While inserting time-type property values, except for timestamps, Nebula Graph transforms them to a UTC time according to the time zone specified with the `timezone_name` parameter in the [configuration files](../../5.configurations-and-logs/1.configurations/1.configurations.md). The time-type values returned by nGQL queries are all UTC time. +While inserting time-type property values, except for `TIMESTAMP`, Nebula Graph transforms them to a UTC time according to the time zone specified with the `timezone_name` parameter in the [configuration files](../../5.configurations-and-logs/1.configurations/1.configurations.md). The time-type values returned by nGQL queries are all UTC time. !!! note To change the time zone, modify the `timezone_name` value in the configuration files of all Nebula Graph services. -Combined with `RETURN`, functions `date()`, `time()`, `datetime()` all accept empty parameters to return the current date, time and datetime. +Combined with `RETURN` clauses, `date()`, `time()`, and `datetime()` all accept empty parameters to return the current date, time and datetime. ## OpenCypher Compatibility In nGQL: -- Year, month, day, hour, minute, and second are supported. The millisecond field is displayed in `000`. +- Year, month, day, hour, minute, and second are supported, while the millisecond is not supported. -- `localdatetime()`, `duration()` are not supported. +- `localdatetime()` and `duration()` are not supported. -- Most string time formats are not supported. The only exception is `2017-03-04T22:30:40`. +- Most string time formats are not supported. The only exception is `YYYY-MM-DDThh:mm:ss`. ## DATE @@ -26,55 +26,87 @@ The `DATE` type is used for values with a date part but no time part. Nebula Gr ## TIME -The `TIME` type is used for values with a time part but no date part. Nebula Graph retrieves and displays `TIME` values in `hh:mm:ss:usus` format. The supported range is `0:0:0:0` to `23:59:59:999999`. +The `TIME` type is used for values with a time part but no date part. Nebula Graph retrieves and displays `TIME` values in `hh:mm:ss.msmsmsususus` format. The supported range is `00:00:00.000000` to `23:59:59.999999`. ## DATETIME -The `DATETIME` type is used for values that contain both date and time parts. Nebula Graph retrieves and displays `DATETIME` values in `YYYY-MM-DD hh:mm:ss:ususus` format. The supported range is `-32768-01-01 00:00:00:00` to `32767-12-31 23:59:59:999999`. +The `DATETIME` type is used for values that contain both date and time parts. Nebula Graph retrieves and displays `DATETIME` values in `YYYY-MM-DDThh:mm:ss.msmsmsususus` format. The supported range is `-32768-01-01T00:00:00.000000` to `32767-12-31T23:59:59.999999`. ## TIMESTAMP -The `TIMESTAMP` data type is used for values that contain both date and time parts. +The `TIMESTAMP` data type is used for values that contain both date and time parts. It has a range of `1970-01-01T00:00:01` UTC to `2262-04-11T23:47:16` UTC. -- `TIMESTAMP` has a range of `1970-01-01 00:00:01` UTC to `2262-04-11 23:47:16` UTC. -- Timestamp is measured in units of seconds. -- Supported `TIMESTAMP` inserting methods: - - Call the `now()` function. - - Input `TIMESTAMP` by using a string. For example: `2019-10-01 10:00:00`. - - Input `TIMESTAMP` directly, namely the number of seconds from `1970-01-01 00:00:00`. -- The underlying storage data type is: **int64**. +`TIMESTAMP` has the following features: + +- Stored and displayed in the form of a timestamp, such as `1615974839`, which means `2021-03-17T17:53:59`. + +- Supported `TIMESTAMP` querying methods: timestamp and `timestamp()` function. + +- Supported `TIMESTAMP` inserting methods: timestamp, `timestamp()` function, and `now()` function. + +- `timestamp()` function accepts empty parameters to get the timestamp of the current time zone and also accepts a string type parameter. + + ```ngql + # Return the current time. + nebula> return timestamp(); + +-------------+ + | timestamp() | + +-------------+ + | 1625469277 | + +-------------+ + + # Return the specified time. + nebula> return timestamp("2021-07-05T06:18:43.984000"); + +-----------------------------------------+ + | timestamp("2021-07-05T06:18:43.984000") | + +-----------------------------------------+ + | 1625465923 | + +-----------------------------------------+ + ``` + +- The underlying storage data type is **int64**. ## Examples -Create a tag named date. +1. Create a tag named `date1` with three properties: `DATE`, `TIME`, and `DATETIME`. -```ngql -nebula> CREATE TAG date(p1 date, p2 time, p3 datetime); -``` + ```ngql + nebula> CREATE TAG date1(p1 date, p2 time, p3 datetime); + ``` -Insert a vertex named Date1. +2. Insert a vertex named `test1`. -```ngql -nebula> INSERT VERTEX date(p1, p2, p3) VALUES "Date1":(date("2017-03-04"), time("23:01:00"), datetime("2017-03-04T22:30:40")); -``` + ```ngql + nebula> INSERT VERTEX date1(p1, p2, p3) VALUES "test1":(date("2021-03-17"), time("17:53:59"), datetime("2021-03-17T17:53:59")); + ``` -Create a tag named school. +3. Create a tag named `school` with the property of `TIMESTAMP`. -```ngql -nebula> CREATE TAG school(name string , found_time timestamp); -``` + ```ngql + nebula> CREATE TAG school(name string , found_time timestamp); + ``` -Insert a vertex named "stanford" with the foundation date `"1885-10-01T08:00:00"`. +4. Insert a vertex named `DUT` with a found-time timestamp of `"1988-03-01T08:00:00"`. -```ngql -nebula> INSERT VERTEX school(name, found_time) VALUES "Stanford":("Stanford", timestamp("1885-10-01T08:00:00")); -``` + ```ngql + # Insert as a timestamp. The corresponding timestamp of 1988-03-01T08:00:00 is 573177600, or 573206400 UTC. + nebula> INSERT VERTEX school(name, found_time) VALUES "DUT":("DUT", 573206400); -Insert a vertex named "dut" with the foundation date now. + # Insert in the form of date and time. + nebula> INSERT VERTEX school(name, found_time) VALUES "DUT":("DUT", timestamp("1988-03-01T08:00:00")); + ``` -```ngql -nebula> INSERT VERTEX school(name, found_time) VALUES "dut":("dut", now()); -``` +5. Insert a vertex named `dut` and store time with `now()` or `timestamp()` functions. + + ```ngql + # Use now() function to store time + nebula> INSERT VERTEX school(name, found_time) VALUES "dut":("dut", now()); + + # Use timestamp() function to store time + nebula> INSERT VERTEX school(name, found_time) VALUES "dut":("dut", timestamp()); + ``` + +You can also use `WITH` statement to set a specific date and time. For example: ```ngql nebula> WITH time({hour: 12, minute: 31, second: 14}) AS d RETURN d; @@ -90,12 +122,4 @@ nebula> WITH date({year: 1984, month: 10, day: 11}) AS x RETURN x + 1; +------------+ | 1984-10-12 | +------------+ - -nebula> WITH datetime({year: 1984, month: 10, day: 11, hour: 12, minute: 31, second: 14}) AS d \ - RETURN toString(d) AS ts, datetime(toString(d)) == d AS b -+-------------------------+------+ -| ts | b | -+-------------------------+------+ -| "1984-10-11T12:31:14.0" | true | -+-------------------------+------+ ``` diff --git a/docs-2.0/3.ngql-guide/3.data-types/5.null.md b/docs-2.0/3.ngql-guide/3.data-types/5.null.md index 4d8c881381a..7b9a1f8c8b2 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/5.null.md +++ b/docs-2.0/3.ngql-guide/3.data-types/5.null.md @@ -1,16 +1,12 @@ # NULL -You can set the properties for vertices or edges to `NULL`. Also, you can set `NOT NULL` constraint to make sure that the property values are `NOT NULL`. - -If not specified, the property is set to `NULL` by default. +You can set the properties for vertices or edges to `NULL`. Also, you can set the `NOT NULL` constraint to make sure that the property values are `NOT NULL`. If not specified, the property is set to `NULL` by default. ## Logical operations with NULL -The logical operations with NULL is the same as openCypher. - -Here is the truth table for AND, OR, XOR, and NOT. +Here is the truth table for `AND`, `OR`, `XOR`, and `NOT`. -| a | b | a AND b | a OR b | a XOR b | NOT a | +| a | b | a AND b | a OR b | a XOR | NOT a | | - | - | - | - | - | - | | false | false | false | false | false | true | | false| null| false | null | null | true | @@ -24,28 +20,27 @@ Here is the truth table for AND, OR, XOR, and NOT. ## OpenCypher compatibility -The comparisons and operations about NULL are different from openCypher. - -The behavior may change later. +The comparisons and operations about NULL are different from openCypher. There may be changes later. ### Comparisons with NULL -The comparison operations with NULL is incompatible with openCypher. +The comparison operations with NULL are incompatible with openCypher. -### Operations and expression with NULL +### Operations and RETURN with NULL -The NULL operations and RETURN with NULL is incompatible with openCypher. +The NULL operations and RETURN with NULL are incompatible with openCypher. ## Examples -Create a tag named player. Specify the property name with `NOT NULL`. Ignore the property age constraint. +### Use NOT NULL + +Create a tag named `player`. Specify the property `name` as `NOT NULL`. ```ngql nebula> CREATE TAG player(name string NOT NULL, age int); -Execution succeeded (time spent 5001/5980 us) ``` -The property `name` is `NOT NULL`. The property `age` is `NULL` by default. +Use `SHOW` to create tag statements. The property `name` is `NOT NULL`. The property `age` is `NULL` by default. ```ngql nebula> SHOW CREATE TAG player; @@ -59,7 +54,33 @@ nebula> SHOW CREATE TAG player; +-----------+-----------------------------------+ ``` +Insert the vertex `Kobe`. The property `age` can be `NULL`. + ```ngql nebula> INSERT VERTEX player(name, age) VALUES "Kobe":("Kobe",null); -Execution succeeded (time spent 6367/7357 us) +``` + +### Use NOT NULL and set the default + +Create a tag named `player`. Specify the property `age` as `NOT NULL`. The default value is `18`. + +```ngql +nebula> CREATE TAG player(name string, age int NOT NULL DEFAULT 18); +``` + +Insert the vertex `Kobe`. Specify the property `name` only. + +```ngql +nebula> INSERT VERTEX player(name) VALUES "Kobe":("Kobe"); +``` + +Query the vertex `Kobe`. The property `age` is `18` by default. + +```ngql +nebula> FETCH PROP ON player "Kobe" ++-----------------------------------------+ +| vertices_ | ++-----------------------------------------+ +| ("Kobe" :player{age: 18, name: "Kobe"}) | ++-----------------------------------------+ ``` diff --git a/docs-2.0/3.ngql-guide/3.data-types/6.list.md b/docs-2.0/3.ngql-guide/3.data-types/6.list.md index ad9f1f91154..9e2b579d1d9 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/6.list.md +++ b/docs-2.0/3.ngql-guide/3.data-types/6.list.md @@ -1,12 +1,39 @@ # Lists -The list is a composite data type. A list is a sequence of values. Individual list elements can be accessed by their positions. +The list is a composite data type. A list is a sequence of values. Individual elements in a list can be accessed by their positions. -A list starts with a left square bracket `[` and ends with a right square bracket `]`. A list contains zero, one, or more expressions. List elements are separated from each other with commas (`,`). Whitespace around elements is ignored in list, thus line breaks, tab stops, and blanks can be used for formatting. +A list starts with a left square bracket `[` and ends with a right square bracket `]`. A list contains zero, one, or more expressions. List elements are separated from each other with commas (`,`). Whitespace around elements is ignored in the list, thus line breaks, tab stops, and blanks can be used for formatting. + +## List operations + +You can use the preset [list function](../6.functions-and-expressions/6.list.md) to operate the list, or use the index to filter the elements in the list. + +### Index syntax + +```ngql +[M] +[M..N] +[M..] +[..N] +``` + +The index of nGQL supports queries from front to back, starting from 0. 0 means the first element, 1 means the second element, and so on. It also supports queries from back to front, starting from -1. -1 means the last element, -2 means the penultimate element, and so on. + +- [M]: represents the element whose index is M. +- [M..N]: represents the elements whose indexes are `greater or equal to M but smaller than N`. Return empty when `N` is 0. +- [M..]: represents the elements whose indexes are `greater or equal to M`. +- [..N]: represents the elements whose indexes are `smaller than N`. Return empty when `N` is 0. + +!!! note + + - Return empty if the index is out of bounds, while return normally if the index is within the bound. + - Return empty if `M`≥`N`. + - When querying a single element, if `M` is null，return `BAD_TYPE`. When conducting a range query, if `M` or `N` is null, return `null`. ## Examples ```ngql +# The following query returns the list [1,2,3]. nebula> RETURN [1, 2, 3] AS List; +-----------+ | List | @@ -14,6 +41,7 @@ nebula> RETURN [1, 2, 3] AS List; | [1, 2, 3] | +-----------+ +# The following query returns the element whose index is 3 in the list [1,2,3,4,5]. In a list, the index starts from 0, and thus the return element is 4. nebula> RETURN range(1,5)[3]; +---------------+ | range(1,5)[3] | @@ -21,6 +49,7 @@ nebula> RETURN range(1,5)[3]; | 4 | +---------------+ +# The following query returns the element whose index is -2 in the list [1,2,3,4,5]. The index of the last element in a list is -1, and thus the return element is 4. nebula> RETURN range(1,5)[-2]; +------------------+ | range(1,5)[-(2)] | @@ -28,6 +57,7 @@ nebula> RETURN range(1,5)[-2]; | 4 | +------------------+ +# The following query returns the elements whose indexes are from 0 to 3 (not including 3) in the list [1,2,3,4,5]. nebula> RETURN range(1,5)[0..3]; +------------------+ | range(1,5)[0..3] | @@ -35,13 +65,24 @@ nebula> RETURN range(1,5)[0..3]; | [1, 2, 3] | +------------------+ -nebula> RETURN [n IN range(1,5) WHERE n > 2] AS a; +# The following query returns the elements whose indexes are greater than 2 in the list [1,2,3,4,5]. +nebula> RETURN range(1,5)[3..] AS a; ++--------+ +| a | ++--------+ +| [4, 5] | ++--------+ + +# The following query returns the elements whose indexes are smaller than 3. +nebula> WITH [1, 2, 3, 4, 5] AS list \ + RETURN list[..3] AS r; +-----------+ -| a | +| r | +-----------+ -| [3, 4, 5] | +| [1, 2, 3] | +-----------+ +# The following query filters the elements whose indexes are greater than 2 in the list [1,2,3,4,5], calculate them respectively, and returns them. nebula> RETURN [n IN range(1,5) WHERE n > 2 | n + 10] AS a; +--------------+ | a | @@ -49,13 +90,72 @@ nebula> RETURN [n IN range(1,5) WHERE n > 2 | n + 10] AS a; | [13, 14, 15] | +--------------+ -nebula> RETURN [n IN range(1,5) | n + 10] AS a; -+----------------------+ -| a | -+----------------------+ -| [11, 12, 13, 14, 15] | -+----------------------+ +# The following query returns the elements from the first to the penultimate (inclusive) in the list [1, 2, 3]. +nebula> YIELD [1, 2, 3][0..-1] AS a; ++--------+ +| a | ++--------+ +| [1, 2] | ++--------+ + +# The following query returns the elements from the first (exclusive) to the third backward in the list [1, 2, 3, 4, 5]. +nebula> YIELD [1, 2, 3, 4, 5][-3..-1] AS a; ++--------+ +| a | ++--------+ +| [3, 4] | ++--------+ + +# The following query sets the variables and returns the elements whose indexes are 1 and 2. +nebula> $var = YIELD 1 AS f, 3 AS t; \ + YIELD [1, 2, 3][$var.f..$var.t] AS a; ++--------+ +| a | ++--------+ +| [2, 3] | ++--------+ + +# The following query returns empty because the index is out of bound. It will return normally when the index is within the bound. +nebula> RETURN [1, 2, 3, 4, 5] [0..10] AS a; ++-----------------+ +| a | ++-----------------+ +| [1, 2, 3, 4, 5] | ++-----------------+ +nebula> RETURN [1, 2, 3] [-5..5] AS a; ++-----------+ +| a | ++-----------+ +| [1, 2, 3] | ++-----------+ + +# The following query returns empty because there is a [0..0]. +nebula> RETURN [1, 2, 3, 4, 5] [0..0] AS a; ++----+ +| a | ++----+ +| [] | ++----+ + +# The following query returns empty because of M ≥ N. +nebula> RETURN [1, 2, 3, 4, 5] [3..1] AS a; ++----+ +| a | ++----+ +| [] | ++----+ + +# When conduct a range query, if `M` or `N` is null, return `null`. +nebula> WITH [1,2,3] AS list \ + RETURN list[0..null] as a; ++----------+ +| a | ++----------+ +| __NULL__ | ++----------+ + +# The following query calculates the elements in the list [1,2,3,4,5] respectively and returns them without the list head. nebula> RETURN tail([n IN range(1, 5) | 2 * n - 10]) AS a; +-----------------+ | a | @@ -63,6 +163,7 @@ nebula> RETURN tail([n IN range(1, 5) | 2 * n - 10]) AS a; | [-6, -4, -2, 0] | +-----------------+ +# The following query takes the elements in the list [1,2,3] as true and return. nebula> RETURN [n IN range(1, 3) WHERE true | n] AS r; +-----------+ | r | @@ -70,6 +171,15 @@ nebula> RETURN [n IN range(1, 3) WHERE true | n] AS r; | [1, 2, 3] | +-----------+ +# The following query returns the length of the list [1,2,3]. +nebula> RETURN size([1,2,3]); ++---------------+ +| size([1,2,3]) | ++---------------+ +| 3 | ++---------------+ + +# The following query calculates the elements in the list [92,90] and runs a conditional judgment in a where clause. nebula> GO FROM "player100" OVER follow WHERE follow.degree NOT IN [x IN [92, 90] | x + $$.player.age] \ YIELD follow._dst AS id, follow.degree AS degree; +-------------+--------+ @@ -80,6 +190,7 @@ nebula> GO FROM "player100" OVER follow WHERE follow.degree NOT IN [x IN [92, 90 | "player102" | 90 | +-------------+--------+ +# The following query takes the query result of the MATCH statement as the elements in a list. Then it calculates and returns them. nebula> MATCH p = (n:player{name:"Tim Duncan"})-[:follow]->(m) \ RETURN [n IN nodes(p) | n.age + 100] AS r; +------------+ @@ -89,26 +200,23 @@ nebula> MATCH p = (n:player{name:"Tim Duncan"})-[:follow]->(m) \ +------------+ | [142, 133] | +------------+ - -nebula> RETURN size([1,2,3]); -+---------------+ -| size([1,2,3]) | -+---------------+ -| 3 | -+---------------+ ``` ## OpenCypher compatibility +- In openCypher, return `null` when querying a single out-of-bound element. However, in nGQL, return `OUT_OF_RANGE` when querying a single out-of-bound element. + + ```ngql + nebula> RETURN range(0,5)[-12]; + +-------------------+ + | range(0,5)[-(12)] | + +-------------------+ + | OUT_OF_RANGE | + +-------------------+ + ``` + - A composite data type (i.e., set, map, and list) **CAN NOT** be stored as properties for vertices or edges. -- In openCypher, out-of-bound single elements returns `null`. However, in nGQL, out-of-bound single elements returns `OUT_OF_RANGE`. + + It is recommended to modify the graph modeling method. The composite data type should be modeled as an adjacent edge of a vertex, rather than its property. Each adjacent edge can be dynamically added or deleted. The rank values of the adjacent edges can be used for sequencing. -```ngql -nebula> RETURN range(0,5)[-12]; -+-------------------+ -| range(0,5)[-(12)] | -+-------------------+ -| OUT_OF_RANGE | -+-------------------+ -``` +- Patterns are not supported in the list. For example, `[(src)-[]->(m) | m.name]`. diff --git a/docs-2.0/3.ngql-guide/3.data-types/7.set.md b/docs-2.0/3.ngql-guide/3.data-types/7.set.md index 9c78177a649..fe2b0681417 100644 --- a/docs-2.0/3.ngql-guide/3.data-types/7.set.md +++ b/docs-2.0/3.ngql-guide/3.data-types/7.set.md @@ -1,10 +1,10 @@ # Sets -Set is a composite data type. +The set is a composite data type. ## OpenCypher compatibility -Set is not a data type in openCypher. The behavior of set in nGQL is not determined yet. +A set is not a data type in openCypher. The behavior of a set in nGQL is not determined yet.