Mathematical functions in GoogleSQL

GoogleSQL for Spanner supports mathematical functions. All mathematical functions have the following behaviors:

• They return NULL if any of the input parameters is NULL .
• They return NaN if any of the arguments is NaN .

Categories

Function list

ABS

  ABS 
 ( 
 X 
 ) 
 

Description

Computes absolute value. Returns an error if the argument is an integer and the output value can't be represented as the same type; this happens only for the largest negative input value, which has no positive representation.

Return Data Type

ACOS

  ACOS 
 ( 
 X 
 ) 
 

Description

Computes the principal value of the inverse cosine of X. The return value is in the range [0,π]. Generates an error if X is a value outside of the range [-1, 1].

If X is NUMERIC then, the output is FLOAT64 .

ACOSH

  ACOSH 
 ( 
 X 
 ) 
 

Description

Computes the inverse hyperbolic cosine of X. Generates an error if X is a value less than 1.

If X is NUMERIC then, the output is FLOAT64 .

APPROX_COSINE_DISTANCE

  APPROX_COSINE_DISTANCE 
 ( 
 vector1 
 , 
  
 vector2 
 , 
  
 options 
 = 
> value 
 ) 
 

Description

Computes the approximate cosine distance between two vectors.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

• options : A named argument with a value that represents a Spanner-specific optimization. value must be the following:

  • JSON'{"num_leaves_to_search": INT}'

  This option specifies the approximate nearest neighbors (ANN) algorithm configuration used in your query. The total number of leaves is specified when you create your vector index. For this argument, we recommend using a number that's 1% the total number of leaves defined in the CREATE VECTOR INDEX statement. The number of leaves to search is defined by the num_leaves_to_search option for both 2-level and 3-level trees.

  If an unsupported option is provided, an error is produced.

Details

APPROX_COSINE_DISTANCE approximates the COSINE_DISTANCE between the given vectors. Approximation typically occurs when using specific indexing strategies that precompute clustering.

Query results across invocations aren't guaranteed to repeat.

You can add a filter such as WHERE s.id = 42 to your query. However, that might lead to poor recall problems because the WHERE filter happens after internal limits are applied. To mitigate this issue, you can increase the value of the num_of_leaves_to_search option.

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can't be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] . If a zero vector is encountered, an error is produced.

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Limitations

• The function can only be used to sort vectors in a table with an ORDER BY clause.
• The function output must be the only ordering key in the ORDER BY clause.
• The ORDER BY clause must be followed by a LIMIT clause.
• One of the function arguments must directly reference an embedding column, and the other must be a constant expression, such as a query parameter reference.

• You can't use the function in the following ways:

  • In a WHERE , ON , or GROUP BY clause.

  • In a SELECT clause unless it's for ordering results in a later ORDER BY clause.

  • As the input of another expression.

Return type

FLOAT64

Examples

In the following example, vectors are used to compute the approximate cosine distance:

In the following example, up to 1000 leaves in the vector index are searched to produce the approximate nearest two vectors using cosine distance:

  SELECT 
  
 FirstName 
 , 
  
 LastName 
 FROM 
  
 Singers 
 @{ 
 FORCE_INDEX 
 = 
 Singer_vector_index 
 } 
  
 AS 
  
 s 
 ORDER 
  
 BY 
  
 APPROX_COSINE_DISTANCE 
 ( 
 @queryVector 
 , 
  
 s 
 . 
 embedding 
 , 
  
 options 
 = 
> JSON 
 '{"num_leaves_to_search": 1000}' 
 ) 
 LIMIT 
  
 2 
 ; 
 /*-----------+------------* 
 | FirstName | LastName   | 
 +-----------+------------+ 
 | Marc      | Richards   | 
 | Catalina  | Smith      | 
 *-----------+------------*/ 
 

APPROX_DOT_PRODUCT

  APPROX_DOT_PRODUCT 
 ( 
 vector1 
 , 
  
 vector2 
 , 
  
 options 
 = 
> value 
 ) 
 

Description

Computes the approximate dot product of two vectors.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

• options : A named argument with a value that represents a Spanner-specific optimization. value must be the following:

  • JSON'{"num_leaves_to_search": INT}'

  This option specifies the approximate nearest neighbors (ANN) algorithm configuration used in your query. The total number of leaves is specified when you create your vector index. For this argument, we recommend using a number that's 1% the total number of leaves defined in the CREATE VECTOR INDEX statement. The number of leaves to search is defined by the num_leaves_to_search option for both 2-level and 3-level trees.

  If an unsupported option is provided, an error is produced.

Details

APPROX_DOT_PRODUCT approximates the DOT_PRODUCT between two vectors. Approximation typically occurs when using specific indexing strategies that precompute clustering.

Query results across invocations aren't guaranteed to repeat.

You can add a filter such as WHERE s.id = 42 to your query. However, that might lead to poor recall problems because the WHERE filter happens after internal limits are applied. To mitigate this issue, you can increase the value of the num_of_leaves_to_search option.

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • INT64
  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] .

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Limitations

• The function can only be used to sort vectors in a table with an ORDER BY clause.
• The function output must be the only ordering key in the ORDER BY clause.
• The ORDER BY clause must be followed by a LIMIT clause.
• One of the function arguments must directly reference an embedding column, and the other must be a constant expression, such as a query parameter reference.

• You can't use the function in the following ways:

  • In a WHERE , ON , or GROUP BY clause.

  • In a SELECT clause unless it's for ordering results in a later ORDER BY clause.

  • As the input of another expression.

Return type

FLOAT64

Examples

In the following example, up to 1000 leaves in the vector index are searched to produce the approximate nearest two vectors using dot product distance:

  SELECT 
  
 FirstName 
 , 
  
 LastName 
 FROM 
  
 Singers 
 @{ 
 FORCE_INDEX 
 = 
 Singer_vector_index 
 } 
  
 AS 
  
 s 
 ORDER 
  
 BY 
  
 APPROX_DOT_PRODUCT 
 ( 
 @queryVector 
 , 
  
 s 
 . 
 embedding 
 , 
  
 options 
 = 
> JSON 
 '{"num_leaves_to_search": 1000}' 
 ) 
  
 DESC 
 LIMIT 
  
 2 
 ; 
 /*-----------+------------* 
 | FirstName | LastName   | 
 +-----------+------------+ 
 | Marc      | Richards   | 
 | Catalina  | Smith      | 
 *-----------+------------*/ 
 

APPROX_EUCLIDEAN_DISTANCE

  APPROX_EUCLIDEAN_DISTANCE 
 ( 
 vector1 
 , 
  
 vector2 
 , 
  
 options 
 = 
> value 
 ) 
 

Description

Computes the approximate Euclidean distance between two vectors.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

• options : A named argument with a value that represents a Spanner-specific optimization. value must be the following:

  • JSON'{"num_leaves_to_search": INT}'

  This option specifies the approximate nearest neighbors (ANN) algorithm configuration used in your query. The total number of leaves is specified when you create your vector index. For this argument, we recommend using a number that's 1% the total number of leaves defined in the CREATE VECTOR INDEX statement. The number of leaves to search is defined by the num_leaves_to_search option for both 2-level and 3-level trees.

  If an unsupported option is provided, an error is produced.

Details

APPROX_EUCLIDEAN_DISTANCE approximates the EUCLIDEAN_DISTANCE between two vectors. Approximation typically occurs when using specific indexing strategies that precompute clustering.

Query results across invocations aren't guaranteed to repeat.

You can add a filter such as WHERE s.id = 42 to your query. However, that might lead to poor recall problems because the WHERE filter happens after internal limits are applied. To mitigate this issue, you can increase the value of the num_of_leaves_to_search option.

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] .

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Limitations

• The function can only be used to sort vectors in a table with an ORDER BY clause.
• The function output must be the only ordering key in the ORDER BY clause.
• The ORDER BY clause must be followed by a LIMIT clause.
• One of the function arguments must directly reference an embedding column, and the other must be a constant expression, such as a query parameter reference.

• You can't use the function in the following ways:

  • In a WHERE , ON , or GROUP BY clause.

  • In a SELECT clause unless it's for ordering results in a later ORDER BY clause.

  • As the input of another expression.

Return type

FLOAT64

Examples

In the following example, vectors are used to compute the approximate Euclidean distance:

In the following example, up to 1000 leaves in the vector index are searched to produce the approximate nearest two vectors using Euclidean distance:

  SELECT 
  
 FirstName 
 , 
  
 LastName 
 FROM 
  
 Singers 
 @{ 
 FORCE_INDEX 
 = 
 Singer_vector_index 
 } 
  
 AS 
  
 s 
 ORDER 
  
 BY 
  
 APPROX_EUCLIDEAN_DISTANCE 
 ( 
 @queryVector 
 , 
  
 0.1 
 ] 
 , 
  
 s 
 . 
 embedding 
 , 
  
 options 
 = 
> JSON 
 '{"num_leaves_to_search": 1000}' 
 ) 
 LIMIT 
  
 2 
 ; 
 /*-----------+------------* 
 | FirstName | LastName   | 
 +-----------+------------+ 
 | Marc      | Richards   | 
 | Catalina  | Smith      | 
 *-----------+------------*/ 
 

ASIN

  ASIN 
 ( 
 X 
 ) 
 

Description

Computes the principal value of the inverse sine of X. The return value is in the range [-π/2,π/2]. Generates an error if X is outside of the range [-1, 1].

If X is NUMERIC then, the output is FLOAT64 .

ASINH

  ASINH 
 ( 
 X 
 ) 
 

Description

Computes the inverse hyperbolic sine of X. Doesn't fail.

If X is NUMERIC then, the output is FLOAT64 .

ATAN

  ATAN 
 ( 
 X 
 ) 
 

Description

Computes the principal value of the inverse tangent of X. The return value is in the range [-π/2,π/2]. Doesn't fail.

If X is NUMERIC then, the output is FLOAT64 .

ATAN2

  ATAN2 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Calculates the principal value of the inverse tangent of X/Y using the signs of the two arguments to determine the quadrant. The return value is in the range [-π,π].

If Y is NUMERIC then, the output is FLOAT64 .

ATANH

  ATANH 
 ( 
 X 
 ) 
 

Description

Computes the inverse hyperbolic tangent of X. Generates an error if X is outside of the range (-1, 1).

If X is NUMERIC then, the output is FLOAT64 .

CEIL

  CEIL 
 ( 
 X 
 ) 
 

Description

Returns the smallest integral value that isn't less than X.

Return Data Type

CEILING

  CEILING 
 ( 
 X 
 ) 
 

Description

Synonym of CEIL(X)

COS

  COS 
 ( 
 X 
 ) 
 

Description

Computes the cosine of X where X is specified in radians. Never fails.

COSH

  COSH 
 ( 
 X 
 ) 
 

Description

Computes the hyperbolic cosine of X where X is specified in radians. Generates an error if overflow occurs.

If X is NUMERIC then, the output is FLOAT64 .

COSINE_DISTANCE

  COSINE_DISTANCE 
 ( 
 vector1 
 , 
  
 vector2 
 ) 
 

Description

Computes the cosine distance between two vectors.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

Details

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can't be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] . If a zero vector is encountered, an error is produced.

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Return type

FLOAT64

Examples

In the following example,vectors are used to compute the cosine distance:

  SELECT 
  
 COSINE_DISTANCE 
 ( 
 [ 
 1.0 
 , 
  
 2.0 
 ] 
 , 
  
 [ 
 3.0 
 , 
  
 4.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 /*----------* 
 | results  | 
 +----------+ 
 | 0.016130 | 
 *----------*/ 
 

The ordering of numeric values in a vector doesn't impact the results produced by this function. For example these queries produce the same results even though the numeric values in each vector is in a different order:

  SELECT 
  
 COSINE_DISTANCE 
 ( 
 [ 
 1.0 
 , 
  
 2.0 
 ] 
 , 
  
 [ 
 3.0 
 , 
  
 4.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 

  SELECT 
  
 COSINE_DISTANCE 
 ( 
 [ 
 2.0 
 , 
  
 1.0 
 ] 
 , 
  
 [ 
 4.0 
 , 
  
 3.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 

   
 /*----------* 
 | results  | 
 +----------+ 
 | 0.016130 | 
 *----------*/ 
 

In the following example, the function can't compute cosine distance against the first vector, which is a zero vector:

  -- ERROR 
 SELECT 
  
 COSINE_DISTANCE 
 ( 
 [ 
 0.0 
 , 
  
 0.0 
 ] 
 , 
  
 [ 
 3.0 
 , 
  
 4.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 

Both vectors must have the same dimensions. If not, an error is produced. In the following example, the first vector has two dimensions and the second vector has three:

  -- ERROR 
 SELECT 
  
 COSINE_DISTANCE 
 ( 
 [ 
 9.0 
 , 
  
 7.0 
 ] 
 , 
  
 [ 
 8.0 
 , 
  
 4.0 
 , 
  
 5.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 

DIV

  DIV 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Returns the result of integer division of X by Y. Division by zero returns an error. Division by -1 may overflow. If both inputs are NUMERIC and the result is overflow, then it returns a numeric overflow error.

Return Data Type

The return data type is determined by the argument types with the following table.

DOT_PRODUCT

  DOT_PRODUCT 
 ( 
 vector1 
 , 
  
 vector2 
 ) 
 

Description

Computes the dot product of two vectors. The dot product is computed by summing the product of corresponding vector elements.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

Details

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • INT64
  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] .

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Return type

FLOAT64

Examples

  SELECT 
  
 DOT_PRODUCT 
 ( 
 [ 
 100 
 ] 
 , 
  
 [ 
 200 
 ] 
 ) 
  
 AS 
  
 results 
 /*---------* 
 | results | 
 +---------+ 
 | 20000   | 
 *---------*/ 
 

  SELECT 
  
 DOT_PRODUCT 
 ( 
 [ 
 100 
 , 
  
 10 
 ] 
 , 
  
 [ 
 200 
 , 
  
 6 
 ] 
 ) 
  
 AS 
  
 results 
 /*---------* 
 | results | 
 +---------+ 
 | 20060   | 
 *---------*/ 
 

  SELECT 
  
 DOT_PRODUCT 
 ( 
 [ 
 100 
 , 
  
 10 
 , 
  
 1 
 ] 
 , 
  
 [ 
 200 
 , 
  
 6 
 , 
  
 2 
 ] 
 ) 
  
 AS 
  
 results 
 /*---------* 
 | results | 
 +---------+ 
 | 20062   | 
 *---------*/ 
 

  SELECT 
  
 DOT_PRODUCT 
 ( 
 [] 
 , 
  
 [] 
 ) 
  
 AS 
  
 results 
 /*---------* 
 | results | 
 +---------+ 
 | 0       | 
 *---------*/ 
 

EXP

  EXP 
 ( 
 X 
 ) 
 

Description

Computes e to the power of X, also called the natural exponential function. If the result underflows, this function returns a zero. Generates an error if the result overflows.

Return Data Type

EUCLIDEAN_DISTANCE

  EUCLIDEAN_DISTANCE 
 ( 
 vector1 
 , 
  
 vector2 
 ) 
 

Description

Computes the Euclidean distance between two vectors.

Definitions

• vector1 : A vector that's represented by an ARRAY<T> value.
• vector2 : A vector that's represented by an ARRAY<T> value.

Details

• ARRAY<T> can be used to represent a vector. Each zero-based index in this array represents a dimension. The value for each element in this array represents a magnitude.

  T can represent the following and must be the same for both vectors:

  • FLOAT32
  • FLOAT64

  In the following example vector, there are four dimensions. The magnitude is 10.0 for dimension 0 , 55.0 for dimension 1 , 40.0 for dimension 2 , and 34.0 for dimension 3 :

    [ 
   10.0 
   , 
    
   55.0 
   , 
    
   40.0 
   , 
    
   34.0 
   ] 
   
  

• Both vectors in this function must share the same dimensions, and if they don't, an error is produced.

• A vector can be a zero vector. A vector is a zero vector if it has no dimensions or all dimensions have a magnitude of 0 , such as [] or [0.0, 0.0] .

• An error is produced if a magnitude in a vector is NULL .

• If a vector is NULL , NULL is returned.

Return type

FLOAT64

Examples

In the following example, vectors are used to compute the Euclidean distance:

  SELECT 
  
 EUCLIDEAN_DISTANCE 
 ( 
 [ 
 1.0 
 , 
  
 2.0 
 ] 
 , 
  
 [ 
 3.0 
 , 
  
 4.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 /*----------* 
 | results  | 
 +----------+ 
 | 2.828    | 
 *----------*/ 
 

The ordering of magnitudes in a vector doesn't impact the results produced by this function. For example these queries produce the same results even though the magnitudes in each vector is in a different order:

  SELECT 
  
 EUCLIDEAN_DISTANCE 
 ( 
 [ 
 1.0 
 , 
  
 2.0 
 ] 
 , 
  
 [ 
 3.0 
 , 
  
 4.0 
 ] 
 ); 
 

  SELECT 
  
 EUCLIDEAN_DISTANCE 
 ( 
 [ 
 2.0 
 , 
  
 1.0 
 ] 
 , 
  
 [ 
 4.0 
 , 
  
 3.0 
 ] 
 ); 
 

   
 /*----------* 
 | results  | 
 +----------+ 
 | 2.828    | 
 *----------*/ 
 

Both vectors must have the same dimensions. If not, an error is produced. In the following example, the first vector has two dimensions and the second vector has three:

  -- ERROR 
 SELECT 
  
 EUCLIDEAN_DISTANCE 
 ( 
 [ 
 9.0 
 , 
  
 7.0 
 ] 
 , 
  
 [ 
 8.0 
 , 
  
 4.0 
 , 
  
 5.0 
 ] 
 ) 
  
 AS 
  
 results 
 ; 
 

FLOOR

  FLOOR 
 ( 
 X 
 ) 
 

Description

Returns the largest integral value that isn't greater than X.

Return Data Type

GREATEST

  GREATEST 
 ( 
 X1 
 ,..., 
 XN 
 ) 
 

Description

Returns the greatest value among X1,...,XN . If any argument is NULL , returns NULL . Otherwise, in the case of floating-point arguments, if any argument is NaN , returns NaN . In all other cases, returns the value among X1,...,XN that has the greatest value according to the ordering used by the ORDER BY clause. The arguments X1, ..., XN must be coercible to a common supertype, and the supertype must support ordering.

Return Data Types

Data type of the input values.

IEEE_DIVIDE

  IEEE_DIVIDE 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Divides X by Y; this function never fails. Returns FLOAT64 unless both X and Y are FLOAT32 , in which case it returns FLOAT32 . Unlike the division operator (/), this function doesn't generate errors for division by zero or overflow.

IS_INF

  IS_INF 
 ( 
 X 
 ) 
 

Description

Returns TRUE if the value is positive or negative infinity.

Returns FALSE for NUMERIC inputs since NUMERIC can't be INF .

IS_NAN

  IS_NAN 
 ( 
 X 
 ) 
 

Description

Returns TRUE if the value is a NaN value.

Returns FALSE for NUMERIC inputs since NUMERIC can't be NaN .

LEAST

  LEAST 
 ( 
 X1 
 ,..., 
 XN 
 ) 
 

Description

Returns the least value among X1,...,XN . If any argument is NULL , returns NULL . Otherwise, in the case of floating-point arguments, if any argument is NaN , returns NaN . In all other cases, returns the value among X1,...,XN that has the least value according to the ordering used by the ORDER BY clause. The arguments X1, ..., XN must be coercible to a common supertype, and the supertype must support ordering.

Return Data Types

Data type of the input values.

LN

  LN 
 ( 
 X 
 ) 
 

Description

Computes the natural logarithm of X. Generates an error if X is less than or equal to zero.

Return Data Type

LOG

  LOG 
 ( 
 X 
  
 [ 
 , 
  
 Y 
 ] 
 ) 
 

Description

If only X is present, LOG is a synonym of LN . If Y is also present, LOG computes the logarithm of X to base Y.

Return Data Type

LOG10

  LOG10 
 ( 
 X 
 ) 
 

Description

Similar to LOG , but computes logarithm to base 10.

Return Data Type

MOD

  MOD 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Modulo function: returns the remainder of the division of X by Y. Returned value has the same sign as X. An error is generated if Y is 0.

Return Data Type

The return data type is determined by the argument types with the following table.

POW

  POW 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Returns the value of X raised to the power of Y. If the result underflows and isn't representable, then the function returns a value of zero.

Return Data Type

The return data type is determined by the argument types with the following table.

POWER

  POWER 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Synonym of POW(X, Y) .

ROUND

  ROUND 
 ( 
 X 
  
 [ 
 , 
  
 N 
 ] 
 ) 
 

Description

If only X is present, rounds X to the nearest integer. If N is present, rounds X to N decimal places after the decimal point. If N is negative, rounds off digits to the left of the decimal point. Rounds halfway cases away from zero. Generates an error if overflow occurs.

Return Data Type

SAFE_ADD

  SAFE_ADD 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Equivalent to the addition operator ( + ), but returns NULL if overflow occurs.

Return Data Type

SAFE_DIVIDE

  SAFE_DIVIDE 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Equivalent to the division operator ( X / Y ), but returns NULL if an error occurs, such as a division by zero error.

Return Data Type

SAFE_MULTIPLY

  SAFE_MULTIPLY 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Equivalent to the multiplication operator ( * ), but returns NULL if overflow occurs.

Return Data Type

SAFE_NEGATE

  SAFE_NEGATE 
 ( 
 X 
 ) 
 

Description

Equivalent to the unary minus operator ( - ), but returns NULL if overflow occurs.

Return Data Type

SAFE_SUBTRACT

  SAFE_SUBTRACT 
 ( 
 X 
 , 
  
 Y 
 ) 
 

Description

Returns the result of Y subtracted from X. Equivalent to the subtraction operator ( - ), but returns NULL if overflow occurs.

Return Data Type

SIGN

  SIGN 
 ( 
 X 
 ) 
 

Description

Returns -1 , 0 , or +1 for negative, zero and positive arguments respectively. For floating point arguments, this function doesn't distinguish between positive and negative zero.

Return Data Type

SIN

  SIN 
 ( 
 X 
 ) 
 

Description

Computes the sine of X where X is specified in radians. Never fails.

SINH

  SINH 
 ( 
 X 
 ) 
 

Description

Computes the hyperbolic sine of X where X is specified in radians. Generates an error if overflow occurs.

If X is NUMERIC then, the output is FLOAT64 .

SQRT

  SQRT 
 ( 
 X 
 ) 
 

Description

Computes the square root of X. Generates an error if X is less than 0.

Return Data Type

TAN

  TAN 
 ( 
 X 
 ) 
 

Description

Computes the tangent of X where X is specified in radians. Generates an error if overflow occurs.

TANH

  TANH 
 ( 
 X 
 ) 
 

Description

Computes the hyperbolic tangent of X where X is specified in radians. Doesn't fail.

If X is NUMERIC then, the output is FLOAT64 .

TRUNC

  TRUNC 
 ( 
 X 
  
 [ 
 , 
  
 N 
 ] 
 ) 
 

Description

If only X is present, TRUNC rounds X to the nearest integer whose absolute value isn't greater than the absolute value of X. If N is also present, TRUNC behaves like ROUND(X, N) , but always rounds towards zero and never overflows.

Return Data Type