Numerical Types, Functions, and Operators​

A 16-bit signed integer.

int16 is capable of representing values from -32768 to +32767 (inclusive).

A 32-bit signed integer.

int32 is capable of representing values from -2147483648 to +2147483647 (inclusive).

A 64-bit signed integer.

int64 is capable of representing values from -9223372036854775808 to +9223372036854775807 (inclusive).

A variable precision, inexact number.

The minimal guaranteed precision is at least 6 decimal digits. The approximate range of a float32 spans from -3.4e+38 to +3.4e+38.

A variable precision, inexact number.

The minimal guaranteed precision is at least 15 decimal digits. The approximate range of a float64 spans from -1.7e+308 to +1.7e+308.

An arbitrary precision integer.

Our philosophy is that use of bigint should always be an explicit opt-in and should never be implicit. Once used, these values should not be accidentally cast to a different numerical type that could lead to a loss of precision.

In keeping with this philosophy, our mathematical functions are designed to maintain separation between big integer values and the rest of our numeric types.

All of the following types can be explicitly cast into a bigint type:

• str

• json

• int16

• int32

• int64

• float32

• float64

• decimal

A bigint literal is an integer literal, followed by ‘n’:

db> 

select 42n is bigint;

{true}

To represent really big integers, it is possible to use the exponent notation (e.g. 1e20n instead of 100000000000000000000n) as long as the exponent is positive and there is no dot anywhere:

db> 

select 1e+100n is bigint;

{true}

When a float literal is followed by n it will produce a decimal value instead:

db> 

select 1.23n is decimal;

{true}

db> 

select 1.0e+100n is decimal;

{true}

Any number of arbitrary precision.

Our philosophy is that use of decimal should always be an explicit opt-in and should never be implicit. Once used, these values should not be accidentally cast to a different numerical type that could lead to a loss of precision.

In keeping with this philosophy, our mathematical functions are designed to maintain separation between decimal values and the rest of our numeric types.

All of the following types can be explicitly cast into decimal:

• str

• json

• int16

• int32

• int64

• float32

• float64

• bigint

A decimal literal is a float literal, followed by n:

The EdgeDB philosophy is that using a decimal type should be an explicit opt-in, but once used, the values should not be accidentally cast into a numeric type with less precision.

In accordance with this the mathematical functions are designed to keep the separation between decimal values and the rest of the numeric types.

All of the following types can be explicitly cast into decimal: str, json, int16, int32, int64, float32, float64, and bigint.

A decimal literal is a float literal followed by ‘n’:

db> 

select 1.23n is decimal;

{true}

db> 

select 1.0e+100n is decimal;

{true}

Note that an integer literal (without a dot or exponent) followed by n produces a bigint value. A literal without a dot and with a positive exponent makes a bigint, too:

db> 

select 42n is bigint;

{true}

db> 

select 12e+34n is bigint;

{true}

Arithmetic addition.

db> 

select 2 + 2;

{4}

Arithmetic subtraction.

db> 

select 3 - 2;

{1}

Arithmetic negation.

db> 

select -5;

{-5}

Arithmetic multiplication.

db> 

select 2 * 10;

{20}

Arithmetic division.

db> 

select 10 / 4;

{2.5}

Division by zero will result in an error:

db> 

select 10 / 0;

DivisionByZeroError: division by zero

Floor division.

In floor-based division, the result of a standard division operation is rounded down to its nearest integer. It is the equivalent to using regular division and then applying math::floor() to the result.

db> 

select 10 // 4;

{2}

db> 

select math::floor(10 / 4);

{2}

db> 

select -10 // 4;

{-3}

It also works on float, bigint, and decimal types. The type of the result corresponds to the type of the operands:

db> 

select 3.7 // 1.1;

{3.0}

db> 

select 3.7n // 1.1n;

{3.0n}

db> 

select 37 // 11;

{3}

Regular division, floor division, and % operations are related in the following way: A // B = (A - (A % B)) / B.

Remainder from division (modulo).

This is commonly referred to as a “modulo” operation.

This is the remainder from floor division. Just as is the case with // the result type of the remainder operator corresponds to the operand type:

db> 

select 10 % 4;

{2}

db> 

select 10n % 4;

{2n}

db> 

select -10 % 4;

{2}

db> 
... 
... 

# floating arithmetic is inexact, so
# we get 0.3999999999999999 instead of 0.4
select 3.7 % 1.1;

{0.3999999999999999}

db> 

select 3.7n % 1.1n;

{0.4n}

db> 

select 37 % 11;

{4}

Regular division, // and % operations are related in the following way: A // B = (A - (A % B)) / B.

Modulo division by zero will result in an error:

db> 

select 10 % 0;

DivisionByZeroError: division by zero

Power operation.

db> 

select 2 ^ 4;

{16}

Rounds a given number to the nearest value.

The function will round a .5 value differently depending on the type of the parameter passed.

The float64 tie is rounded to the nearest even number:

db> 

select round(1.2);

{1}

db> 

select round(1.5);

{2}

db> 

select round(2.5);

{2}

But the decimal tie is rounded away from zero:

db> 

select round(1.2n);

{1n}

db> 

select round(1.5n);

{2n}

db> 

select round(2.5n);

{3n}

Additionally, when rounding a decimal value, you may pass the optional argument d to specify the precision of the rounded result:

db> 

select round(163.278n, 2);

{163.28n}

db> 

select round(163.278n, 1);

{163.3n}

db> 

select round(163.278n, 0);

{163n}

db> 

select round(163.278n, -1);

{160n}

db> 

select round(163.278n, -2);

{200n}

Returns a pseudo-random number in the range of 0.0 <= x < 1.0.

db> 

select random();

{0.62649393780157}

Bitwise AND operator for 2 intergers.

db> 

select bit_and(17, 3);

{1}

Bitwise OR operator for 2 intergers.

db> 

select bit_or(17, 3);

{19}

Bitwise exclusive OR operator for 2 intergers.

db> 

select bit_xor(17, 3);

{18}

Bitwise negation operator for 2 intergers.

Bitwise negation for integers ends up similar to mathematical negation because typically the signed integers use “two’s complement” representation. In this represenation mathematical negation is achieved by aplying bitwise negation and adding 1.

db> 

select bit_not(17);

{-18}

db> 

select -17 = bit_not(17) + 1;

{true}

Bitwise left-shift operator for intergers.

The integer val is shifted by n bits to the left. The rightmost added bits are all 0. Shifting an integer by a number of bits greater than the bit size of the integer results in 0.

db> 

select bit_lshift(123, 2);

{492}

db> 

select bit_lshift(123, 65);

{0}

Left-shifting an integer can change the sign bit:

db> 

select bit_lshift(123, 60);

{-5764607523034234880}

In general, left-shifting an integer in small increments produces the same result as shifting it in one step:

db> 

select bit_lshift(bit_lshift(123, 1), 3);

{1968}

db> 

select bit_lshift(123, 4);

{1968}

It is an error to attempt to shift by a negative number of bits:

db> 

select bit_lshift(123, -2);

edgedb error: InvalidValueError: bit_lshift(): cannot shift by
negative amount

Bitwise arithemtic right-shift operator for intergers.

The integer val is shifted by n bits to the right. In the arithmetic right-shift, the sign is preserved. This means that the leftmost added bits are 1 or 0 depending on the sign bit. Shifting an integer by a number of bits greater than the bit size of the integer results in 0 for positive numbers or -1 for negative numbers.

db> 

select bit_rshift(123, 2);

{30}

db> 

select bit_rshift(123, 65);

{0}

db> 

select bit_rshift(-123, 2);

{-31}

db> 

select bit_rshift(-123, 65);

{-1}

In general, right-shifting an integer in small increments produces the same result as shifting it in one step:

db> 

select bit_rshift(bit_rshift(123, 1), 3);

{7}

db> 

select bit_rshift(123, 4);

{7}

db> 

select bit_rshift(bit_rshift(-123, 1), 3);

{-8}

db> 

select bit_rshift(-123, 4);

{-8}

It is an error to attempt to shift by a negative number of bits:

db> 

select bit_rshift(123, -2);

edgedb error: InvalidValueError: bit_rshift(): cannot shift by
negative amount

Returns a bigint value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

db> 

select to_bigint('-000,012,345', 'S099,999,999,999');

{-12345n}

db> 

select to_bigint('31st', '999th');

{31n}

Returns a decimal value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

db> 

select to_decimal('-000,012,345', 'S099,999,999,999');

{-12345.0n}

db> 

select to_decimal('-012.345');

{-12.345n}

db> 

select to_decimal('31st', '999th');

{31.0n}

Returns an int16 value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

Returns an int32 value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

Returns an int64 value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

Returns a float32 value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.

Returns a float64 value parsed from the given string.

The function will use an optional format string passed as fmt. See the number formatting options for help writing a format string.