Return a set without repeating any elements. | |

Test the membership of an element in a set. | |

Merge two sets. | |

Test whether a set is not empty. | |

Conditionally provide one or the other result. | |

Coalesce. | |

Detaches the input set reference from the current scope. | |

Filter the set based on type. | |

Check that the input set contains only unique elements, i.e a proper set. | |

Check that the input set contains no more than one element. | |

Check that the input set contains at least one element. | |

Return the number of elements in a set. | |

Return an array made from all of the input set elements. | |

Return the sum of the set of numbers. | |

Generalized boolean AND applied to the set of values. | |

Generalized boolean OR applied to the set of values. | |

Return a set of tuples of the form (index, element). | |

Return the smallest value of the input set. | |

Return the greatest value of the input set. | |

Return the arithmetic mean of the input set. | |

Return the sample standard deviation of the input set. | |

Return the population standard deviation of the input set. | |

Return the sample variance of the input set. | |

Return the population variance of the input set. |

anytype IN SET OF anytype -> boolanytype NOT IN SET OF anytype -> bool

Test the membership of an element in a set.

Set membership operators `IN`

and `NOT IN`

that test for each element of `A`

whether it is present in `B`

.

Copy

db>

`SELECT 1 IN {1, 3, 5};`

{true}

Copy

db>

`SELECT 'Alice' IN User.name;`

{true}

Copy

db>

`SELECT {1, 2} IN {1, 3, 5};`

{true, false}

This operator can also be used to implement set intersection:

Copy

db> ... ... ...

```
WITH
A := {1, 2, 3, 4},
B := {2, 4, 6}
SELECT A FILTER A IN B;
```

{2, 4}

SET OF anytype UNION SET OF anytype -> SET OF anytype

Merge two sets.

Since EdgeDB sets are formally multisets, `UNION`

is a *multiset sum*,
so effectively it merges two multisets keeping all of their members.

For example, applying `UNION`

to `{1, 2, 2}`

and
`{2}`

, results in `{1, 2, 2, 2}`

.

If you need a distinct union, wrap it with `DISTINCT`

.

SET OF anytype IF bool ELSE SET OF anytype -> SET OF anytype

Conditionally provide one or the other result.

`left_expr IF condition ELSE right_expr`

If condition is `true`

, then the value of the
`IF..ELSE`

expression is the value of left_expr;
if condition is `false`

, the result is the value of
right_expr.

Copy

db>

`SELECT 'hello' IF 2 * 2 = 4 ELSE 'bye';`

{'hello'}

`IF..ELSE`

expressions can be chained when checking multiple conditions
is necessary:

Copy

db> ... ... ... ...

```
WITH color := 'yellow'
SELECT 'Apple' IF color = 'red' ELSE
'Banana' IF color = 'yellow' ELSE
'Orange' IF color = 'orange' ELSE
'Other';
```

{'Banana'}

OPTIONAL anytype ?? SET OF anytype -> SET OF anytype

Coalesce.

Evaluate to `A`

for non-empty `A`

, otherwise evaluate to `B`

.

A typical use case of the coalescing operator is to provide default values for optional properties.

Copy

```
# Get a set of tuples (<issue name>, <priority>)
# for all issues.
SELECT (Issue.name, Issue.priority.name ?? 'n/a');
```

Without the coalescing operator the above query would skip any
`Issue`

without priority.

DETACHED SET OF anytype -> SET OF anytype

Detaches the input set reference from the current scope.

A `DETACHED`

expression allows referring to some set as if it were
defined in the top-level `WITH`

block. `DETACHED`

expressions ignore all current scopes in which they are nested.
This makes it possible to write queries that reference the same set
reference in multiple places.

Copy

```
UPDATE User
FILTER .name = 'Dave'
SET {
friends := (SELECT DETACHED User FILTER .name = 'Alice'),
coworkers := (SELECT DETACHED User FILTER .name = 'Bob')
};
```

Without `DETACHED`

, the occurrences of `User`

inside the `SET`

shape
would be *bound* to the set of users named `"Dave"`

. However, in this
context we want to run an unrelated query on the “unbound” `User`

set.

Copy

```
# does not work!
UPDATE User
FILTER .name = 'Dave'
SET {
friends := (SELECT User FILTER .name = 'Alice'),
coworkers := (SELECT User FILTER .name = 'Bob')
};
```

Instead of explicitly detaching a set, you can create a reference to it in
a `WITH`

block. All declarations inside a `WITH`

block are implicitly
detached.

Copy

```
WITH U1 := User,
U2 := User
UPDATE User
FILTER .name = 'Dave'
SET {
friends := (SELECT U1 FILTER .name = 'Alice'),
coworkers := (SELECT U2 FILTER .name = 'Bob')
};
```

anytype [IS type] -> anytype

Filter the set based on type.

The type intersection operator removes all elements from the input set that aren’t of the specified type. Additionally, since it guarantees the type of the result set, all the links and properties associated with the specified type can now be used on the resulting expression. This is especially useful in combination with backlinks.

Consider the following types:

Copy

```
type User {
required property name -> str;
}
abstract type Owned {
required link owner -> User;
}
type Issue extending Owned {
required property title -> str;
}
type Comment extending Owned {
required property body -> str;
}
```

The following expression will get all `Objects`

owned by all users (if there are any):

Copy

`SELECT User.<owner;`

By default backlinks don’t infer any
type information beyond the fact that it’s an `Object`

.
To ensure that this path specifically reaches `Issue`

the type
intersection operator must be used:

Copy

```
SELECT User.<owner[IS Issue];
# With the use of type intersection it's possible to refer to
# specific property of Issue now:
SELECT User.<owner[IS Issue].title;
```

std::assert_distinct(s: SET OF anytype) -> SET OF anytype

Check that the input set contains only unique elements, i.e a *proper set*.

If the input set contains duplicate elements, `assert_distinct`

raises a
`ConstraintViolationError`

. This function is useful
as a runtime distinctness assertion in queries and computed
expressions that should always return proper sets, but where static
multiplicity inference is not capable enough or outright impossible.

Copy

db> ... ... ... ...

```
SELECT assert_distinct(
(SELECT User FILTER .groups.name = "Administrators")
UNION
(SELECT User FILTER .groups.name = "Guests")
)
```

{default::User {id: ...}}

Copy

db> ... ... ... ...

```
SELECT assert_distinct(
(SELECT User FILTER .groups.name = "Users")
UNION
(SELECT User FILTER .groups.name = "Guests")
)
```

ERROR: ConstraintViolationError: assert_distinct violation: expression returned a set with duplicate elements.

std::assert_single(s: SET OF anytype) -> anytype

Check that the input set contains no more than one element.

If the input set contains more than one element, `assert_single`

raises a `CardinalityViolationError`

. This function is useful
as a runtime cardinality assertion in queries and computed
expressions that should always return sets with at most a single
element, but where static cardinality inference is not capable
enough or outright impossible.

Copy

db>

`SELECT assert_single((SELECT User FILTER .name = "Unique"))`

{default::User {id: ...}}

Copy

db>

`SELECT assert_single((SELECT User))`

ERROR: CardinalityViolationError: assert_single violation: more than one element returned by an expression

std::assert_exists(s: SET OF anytype) -> SET OF anytype

Check that the input set contains at least one element.

If the input set is empty, `assert_exists`

raises a
`CardinalityViolationError`

. This function is useful
as a runtime existence assertion in queries and computed
expressions that should always return sets with at least a single
element, but where static cardinality inference is not capable
enough or outright impossible.

Copy

db>

`SELECT assert_exists((SELECT User FILTER .name = "Administrator"))`

{default::User {id: ...}}

Copy

db>

`SELECT assert_exists((SELECT User FILTER .name = "Nonexistent"))`

ERROR: CardinalityViolationError: assert_exists violation: expression returned an empty set.

std::sum(s: SET OF int32) -> int64std::sum(s: SET OF int64) -> int64std::sum(s: SET OF float32) -> float32std::sum(s: SET OF float64) -> float64std::sum(s: SET OF bigint) -> bigintstd::sum(s: SET OF decimal) -> decimal

Return the sum of the set of numbers.

The result type depends on the input set type. The general rule is
that the type of the input set is preserved (as if a simple
`+`

was used) while trying to reduce the chance of
an overflow (so all integers produce `int64`

sum).

Copy

db>

`SELECT sum({2, 3, 5});`

{10}

Copy

db>

`SELECT sum({0.2, 0.3, 0.5});`

{1.0}

std::all(values: SET OF bool) -> bool

Generalized boolean `AND`

applied to the set of *values*.

The result is `true`

if all of the *values* are `true`

or the
set of *values* is `{}`

. Return `false`

otherwise.

Copy

db>

`SELECT all(<bool>{});`

{true}

Copy

db>

`SELECT all({1, 2, 3, 4} < 4);`

{false}

std::any(values: SET OF bool) -> bool

Generalized boolean `OR`

applied to the set of *values*.

The result is `true`

if any of the *values* are `true`

. Return
`false`

otherwise.

Copy

db>

`SELECT any(<bool>{});`

{false}

Copy

db>

`SELECT any({1, 2, 3, 4} < 4);`

{true}

std::enumerate(values: SET OF anytype) -> SET OF tuple<int64, anytype>

Return a set of tuples of the form `(index, element)`

.

The `enumerate()`

function takes any set and produces a set of
tuples containing the zero-based index number and the value for each
element.

The ordering of the returned set is not guaranteed, however the assigned indexes are guaranteed to be in order of the original set.

Copy

db>

`SELECT enumerate({2, 3, 5});`

{(1, 3), (0, 2), (2, 5)}

Copy

db>

`SELECT enumerate(User.name);`

{(0, 'Alice'), (1, 'Bob'), (2, 'Dave')}