Light
Dark
System

Generic Functions and Operators

anytype = anytype

Compares two values for equality.

anytype != anytype

Compares two values for inequality.

anytype ?= anytype

Compares two (potentially empty) values for equality.

anytype ?!= anytype

Compares two (potentially empty) values for inequality.

anytype < anytype

Less than operator.

anytype > anytype

Greater than operator.

anytype <= anytype

Less or equal operator.

anytype >= anytype

Greater or equal operator.

len()

Returns the number of elements of a given value.

contains()

Returns true if the given sub-value exists within the given value.

find()

Returns the index of a given sub-value in a given value.

In EdgeQL, any value can be compared to another as long as their types are compatible.

operator
anytype = anytype
anytype = anytype -> bool

Compares two values for equality.

Copy
db> 
select 3 = 3.0;
{true}
Copy
db> 
select 3 = 3.14;
{false}
Copy
db> 
select [1, 2] = [1, 2];
{true}
Copy
db> 
select (1, 2) = (x := 1, y := 2);
{true}
Copy
db> 
select (x := 1, y := 2) = (a := 1, b := 2);
{true}
Copy
db> 
select 'hello' = 'world';
{false}
operator
anytype != anytype
anytype != anytype -> bool

Compares two values for inequality.

Copy
db> 
select 3 != 3.0;
{false}
Copy
db> 
select 3 != 3.14;
{true}
Copy
db> 
select [1, 2] != [2, 1];
{false}
Copy
db> 
select (1, 2) != (x := 1, y := 2);
{false}
Copy
db> 
select (x := 1, y := 2) != (a := 1, b := 2);
{false}
Copy
db> 
select 'hello' != 'world';
{true}
operator
anytype ?= anytype
optional anytype ?= optional anytype -> bool

Compares two (potentially empty) values for equality.

This works the same as a regular = operator, but also allows comparing an empty {} set. Two empty sets are considered equal.

Copy
db> 
select {1} ?= {1.0};
{true}
Copy
db> 
select {1} ?= <int64>{};
{false}
Copy
db> 
select <int64>{} ?= <int64>{};
{true}
operator
anytype ?!= anytype
optional anytype ?!= optional anytype -> bool

Compares two (potentially empty) values for inequality.

This works the same as a regular = operator, but also allows comparing an empty {} set. Two empty sets are considered equal.

Copy
db> 
select {2} ?!= {2};
{false}
Copy
db> 
select {1} ?!= <int64>{};
{true}
Copy
db> 
select <bool>{} ?!= <bool>{};
{false}
operator
anytype < anytype
anytype < anytype -> bool

Less than operator.

The operator returns true if the value of the left expression is less than the value of the right expression:

Copy
db> 
select 1 < 2;
{true}
Copy
db> 
select 2 < 2;
{false}
Copy
db> 
select 'hello' < 'world';
{true}
Copy
db> 
select (1, 'hello') < (1, 'world');
{true}
operator
anytype > anytype
anytype > anytype -> bool

Greater than operator.

The operator returns true if the value of the left expression is greater than the value of the right expression:

Copy
db> 
select 1 > 2;
{false}
Copy
db> 
select 3 > 2;
{true}
Copy
db> 
select 'hello' > 'world';
{false}
Copy
db> 
select (1, 'hello') > (1, 'world');
{false}
operator
anytype <= anytype
anytype <= anytype -> bool

Less or equal operator.

The operator returns true if the value of the left expression is less than or equal to the value of the right expression:

Copy
db> 
select 1 <= 2;
{true}
Copy
db> 
select 2 <= 2;
{true}
Copy
db> 
select 3 <= 2;
{false}
Copy
db> 
select 'hello' <= 'world';
{true}
Copy
db> 
select (1, 'hello') <= (1, 'world');
{true}
operator
anytype >= anytype
anytype >= anytype -> bool

Greater or equal operator.

The operator returns true if the value of the left expression is greater than or equal to the value of the right expression:

Copy
db> 
select 1 >= 2;
{false}
Copy
db> 
select 2 >= 2;
{true}
Copy
db> 
select 3 >= 2;
{true}
Copy
db> 
select 'hello' >= 'world';
{false}
Copy
db> 
select (1, 'hello') >= (1, 'world');
{false}
function
len()
std::len(value: str) -> int64std::len(value: bytes) -> int64std::len(value: array<anytype>) -> int64

Returns the number of elements of a given value.

This function works with the str, bytes and array types:

Copy
db> 
select len('foo');
{3}
Copy
db> 
select len(b'bar');
{3}
Copy
db> 
select len([2, 5, 7]);
{3}
function
contains()
std::contains(haystack: str, needle: str) -> boolstd::contains(haystack: bytes, needle: bytes) -> boolstd::contains(haystack: array<anytype>, needle: anytype) -> boolstd::contains(haystack: range<anypoint>, needle: range<anypoint>) -> std::boolstd::contains(haystack: range<anypoint>, needle: anypoint) -> std::bool

Returns true if the given sub-value exists within the given value.

When haystack is a str or a bytes value, this function will return true if it contains needle as a subsequence within it or false otherwise:

Copy
db> 
select contains('qwerty', 'we');
{true}
Copy
db> 
select contains(b'qwerty', b'42');
{false}

When haystack is an array, the function will return true if the array contains the element specified as needle or false otherwise:

Copy
db> 
select contains([2, 5, 7, 2, 100], 2);
{true}

When haystack is a range, the function will return true if it contains either the specified sub-range or element. The function will return false otherwise.

Copy
db> 
select contains(range(1, 10), range(2,5));
{true}
Copy
db> 
select contains(range(1, 10), range(2,15));
{false}
Copy
db> 
select contains(range(1, 10), 2);
{true}
Copy
db> 
select contains(range(1, 10), 10);
{false}
function
find()
std::find(haystack: str, needle: str) -> int64std::find(haystack: bytes, needle: bytes) -> int64std::find(haystack: array<anytype>, needle: anytype, from_pos: int64=0) -> int64

Returns the index of a given sub-value in a given value.

When haystack is a str or a bytes value, the function will return the index of the first occurrence of needle in it.

When haystack is an array, this will return the index of the the first occurrence of the element passed as needle. For array inputs it is also possible to provide an optional from_pos argument to specify the position from which to start the search.

If the needle is not found, return -1.

Copy
db> 
select find('qwerty', 'we');
{1}
Copy
db> 
select find(b'qwerty', b'42');
{-1}
Copy
db> 
select find([2, 5, 7, 2, 100], 2);
{0}
Copy
db> 
select find([2, 5, 7, 2, 100], 2, 1);
{3}
Light
Dark
System