Generic Functions and Operators
.md
Copy page

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}

When either operand in an equality comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select true = <bool>{};

{}

If one of the operands in an equality comparison could be an empty set, you may want to use the coalescing equality operator (?=) instead.

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}

When either operand in an inequality comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select true != <bool>{};

{}

If one of the operands in an inequality comparison could be an empty set, you may want to use the coalescing inequality operator (?!=) instead.

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}

When either operand in a comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select 1 < <int16>{};

{}

If one of the operands in a comparison could be an empty set, you may want to coalesce the result of the comparison with false to ensure your result is boolean.

Copy

db>

select (1 < <int16>{}) ?? false;

{false}

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}

When either operand in a comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select 1 > <int16>{};

{}

If one of the operands in a comparison could be an empty set, you may want to coalesce the result of the comparison with false to ensure your result is boolean.

Copy

db>

select (1 > <int16>{}) ?? false;

{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}

When either operand in a comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select 1 <= <int16>{};

{}

If one of the operands in a comparison could be an empty set, you may want to coalesce the result of the comparison with false to ensure your result is boolean.

Copy

db>

select (1 <= <int16>{}) ?? false;

{false}

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}

When either operand in a comparison is an empty set, the result will not be a bool but instead an empty set.

Copy

db>

select 1 >= <int16>{};

{}

If one of the operands in a comparison could be an empty set, you may want to coalesce the result of the comparison with false to ensure your result is boolean.

Copy

db>

select (1 >= <int16>{}) ?? false;

{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::boolstd::contains(haystack: multirange<anypoint>, needle: multirange<anypoint>) -> std::boolstd::contains(haystack: multirange<anypoint>, needle: range<anypoint>) -> std::boolstd::contains(haystack: multirange<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}

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

Copy

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

select contains(
  multirange([
    range(1, 4), range(7),
  ]),
  multirange([
    range(1, 2), range(8, 10),
  ]),
);

{true}

Copy

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

select contains(
  multirange([
    range(1, 4), range(8, 10),
  ]),
  range(8),
);

{false}

Copy

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

select contains(
  multirange([
    range(1, 4), range(8, 10),
  ]),
  3,
);

{true}

When haystack is JSON, the function will return true if the json data contains the element specified as needle or false otherwise:

Copy

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

with haystack := to_json('{
  "city": "Baerlon",
  "city": "Caemlyn"
}'),
needle := to_json('{
  "city": "Caemlyn"
}'),
select contains(haystack, needle);

{true}

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}

Generic Functions and Operators​.mdCopy page

Generic Functions and Operators
.md
Copy page