---
title: Alphabetical SQL Functions List
slug: lv7gAwyqE9Zf5j-imoMfR
description: Browse the alphabetical list of SQL functions in Ocient, providing diverse data manipulation and analysis capabilities.
docTags: 
createdAt: Fri Jan 05 2024 19:53:42 GMT+0000 (Coordinated Universal Time)
updatedAt: Tue Apr 07 2026 21:40:05 GMT+0000 (Coordinated Universal Time)
---

| **Function Name**                                                                                                     | **Category Name**                              | **Function Description**                                                                                                                                                                                                                                                             |
| --------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| [ABS](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the absolute value of a specified floating-point number.                                                                                                                                                                                                                     |
| [ABS](<./Matrix Functions and Operators.md>)                                                                          | Matrix Functions                               | Returns the magnitude of one-dimensional matrix or vector.                                                                                                                                                                                                                           |
| [ACOS](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the inverse cosine of a specified floating-point number.                                                                                                                                                                                                                     |
| [ACOSH](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns the hyperbolic arc-cosine of a specified floating-point number.                                                                                                                                                                                                              |
| [ACCURACY\_SCORE](<./Aggregate Functions.md>)                                                                         | Aggregate Functions                            | Returns the fraction of predictions that match the actual class labels.                                                                                                                                                                                                              |
| [ADD\_MONTHS](<./Date and Time Functions.md>)                                                                         | Date and Time Functions                        | Adds the specified number of months to the date.                                                                                                                                                                                                                                     |
| [ANY\_VALUE](<./Aggregate Functions.md>)                                                                              | Aggregate Functions                            | Returns an arbitrary, non-NULL value from the input column.                                                                                                                                                                                                                          |
| [APPROX\_COUNT\_DISTINCT](<./Aggregate Functions.md>)                                                                 | Aggregate Functions                            | Approximate distinct count by using hyper-log-log (95% confidence interval that the value is within 4.5%).                                                                                                                                                                           |
| [APPROX\_SUM](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Allows the aggregation engine to use a faster, non-deterministic ordering to summate floating-point columns.                                                                                                                                                                         |
| [ARRAY\[\]](<./Array Functions and Operators.md>)                                                                     | Array Functions                                | PostgreSQL®-compliant constructor. The type of the array is deduced from the elements.                                                                                                                                                                                               |
| [ARRAY\_AGG](<./Aggregate Functions.md>)                                                                              | Aggregate Functions                            | Returns an array containing every row from the expression.                                                                                                                                                                                                                           |
| [ARRAY\_APPEND](<./Array Functions and Operators.md>)                                                                 | Array Functions                                | Add value to the back of an array.                                                                                                                                                                                                                                                   |
| [ARRAY\_ARGMAX](<./Array Functions and Operators.md>)                                                                 | Array Functions                                | Returns the corresponding argmax of the array as a BIGINT index.                                                                                                                                                                                                                     |
| [ARRAY\_ARGMIN](<./Array Functions and Operators.md>)                                                                 | Array Functions                                | Returns the corresponding argmin of the array as a BIGINT index.                                                                                                                                                                                                                     |
| [ARRAY\_CAT](<./Array Functions and Operators.md>)                                                                    | Array Functions                                | Concatenate 2 arrays into a new one.                                                                                                                                                                                                                                                 |
| [ARRAY\_CAT\_DISTINCT](<./Array Functions and Operators.md>)                                                          | Array Functions                                | Concatenates two or more arrays in the order of the input arguments.                                                                                                                                                                                                                 |
| [ARRAY\_CAP](<././Load Data/Transform Data in Data Pipelines.md>)                                                     | Special Data Pipeline Transformation Functions | Restrict the length of an array to a maximum number of elements.                                                                                                                                                                                                                     |
| [ARRAY\_COMPACT](<././Load Data/Transform Data in Data Pipelines.md>)                                                 | Special Data Pipeline Transformation Functions | Removes NULL values from the array.                                                                                                                                                                                                                                                  |
| [ARRAY\_CONCAT\_AGG](<./Aggregate Functions.md>)                                                                      | Aggregate Functions                            | Returns an array that concatenates arrays across rows.                                                                                                                                                                                                                               |
| [ARRAY\_CONTAINS](<././Load Data/Transform Data in Data Pipelines.md>)                                                | Special Data Pipeline Transformation Functions | Returns `true` if the array contains the specified value.                                                                                                                                                                                                                            |
| [ARRAY\_DISTINCT](<./Array Functions and Operators.md>)                                                               | Array Functions                                | Removes duplicates from an array while preserving the first occurrence order.                                                                                                                                                                                                        |
| [ARRAY\_LENGTH](<./Array Functions and Operators.md>)                                                                 | Array Functions                                | Return the number of elements of a given array.                                                                                                                                                                                                                                      |
| [ARRAY\_MAX](<./Array Functions and Operators.md>)                                                                    | Array Functions                                | Returns the corresponding maximum of the array.                                                                                                                                                                                                                                      |
| [ARRAY\_MIN](<./Array Functions and Operators.md>)                                                                    | Array Functions                                | Returns the corresponding minimum of the array.                                                                                                                                                                                                                                      |
| [ARRAY\_POSITION](<./Array Functions and Operators.md>)                                                               | Array Functions                                | Returns the position of the first matching scalar in the array.                                                                                                                                                                                                                      |
| [ARRAY\_POSITIONS](<./Array Functions and Operators.md>)                                                              | Array Functions                                | Returns all elements stored in the right array and returns their respective positions in the left array.                                                                                                                                                                             |
| [ARRAY\_PREPEND](<./Array Functions and Operators.md>)                                                                | Array Functions                                | Add value to the front of an array.                                                                                                                                                                                                                                                  |
| [ARRAY\_REMOVE](<./Array Functions and Operators.md>)                                                                 | Array Functions                                | Remove value from the array.                                                                                                                                                                                                                                                         |
| [ARRAY\_REPLACE](<./Array Functions and Operators.md>)                                                                | Array Functions                                | Replace value by another in an array.                                                                                                                                                                                                                                                |
| [ARRAY\_SORT](<././Load Data/Transform Data in Data Pipelines.md>)                                                    | Special Data Pipeline Transformation Functions | Sort and return the input array based on the natural ordering of its elements or the specified Lambda function.                                                                                                                                                                      |
| [ARRAY\_SUM](<./Array Functions and Operators.md>)                                                                    | Array Functions                                | Returns the sum of the array. The array must be one-dimensional and contain numeric values. NULL values do not contribute to the sum.                                                                                                                                                |
| [ARRAY\_TO\_STRING](<./Array Functions and Operators.md>)                                                             | Array Functions                                | Converts array to a list of elements separated by 'delimiter'.                                                                                                                                                                                                                       |
| [ASCII](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Returns the ASCII code value of the leftmost character of the character value.                                                                                                                                                                                                       |
| [ASIN](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the inverse sine of a specified floating-point number.                                                                                                                                                                                                                       |
| [ASINH](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns the hyperbolic arc-sine of a specified floating-point number.                                                                                                                                                                                                                |
| [ATAN](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the inverse tangent of a specified floating-point number.                                                                                                                                                                                                                    |
| [ATAN2](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns the inverse tangent of two numeric, floating-point values.                                                                                                                                                                                                                   |
| [ATANH](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns the hyperbolic arc-tangent of a specified floating-point number.                                                                                                                                                                                                             |
| [AVG](<./Aggregate Functions.md>)                                                                                     | Aggregate Functions                            | Average, or arithmetic mean, over the set.                                                                                                                                                                                                                                           |
| [BICDF](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | The cumulative distribution function of the standard bivariate normal distribution.                                                                                                                                                                                                  |
| [BIGINT](<./Scalar Data Conversion Functions.md>)                                                                     | Scalar Data Conversion Functions               | Casts the argument to a value of type `bigint`.                                                                                                                                                                                                                                      |
| [BINARY](<./Scalar Data Conversion Functions.md>)                                                                     | Scalar Data Conversion Functions               | Parses a hexadecimal string (such as 0x54ab) to create a binary value. Letters can be of either case.                                                                                                                                                                                |
| [BIPDF](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | The probability density function of the standard bivariate normal distribution.                                                                                                                                                                                                      |
| [BIT\_LENGTH](<./Character and Binary Functions.md>)                                                                  | Character and Binary Functions                 | Returns the length of the character value in bits.                                                                                                                                                                                                                                   |
| [BITAND](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | Alias for the BITFUNC syntax `BITFUNC('AND', x, y)`.                                                                                                                                                                                                                                 |
| [BITFUNC](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Performs a variety of bit operations. Can be any of these string literals: `'AND'`, `'OR'`, or `'XOR'`.                                                                                                                                                                              |
| [BITNOT](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | Returns the bitwise negation of integral\_x.                                                                                                                                                                                                                                         |
| [BITOR](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Alias for the BITFUNC syntax BITFUNC('OR', x, y).                                                                                                                                                                                                                                    |
| [BITXOR](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | Alias for the BITFUNC syntax BITFUNC('XOR', x, y).                                                                                                                                                                                                                                   |
| [BOOLAND](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Alias for the BOOLFUNC syntax BOOLFUNC('AND', x, y).                                                                                                                                                                                                                                 |
| [BOOLEAN](<./Scalar Data Conversion Functions.md>)                                                                    | Scalar Data Conversion Functions               | Parses a string to create a Boolean value. The string must contain either true or false. It is case-insensitive.                                                                                                                                                                     |
| [BOOLFUNC](<./Math Functions and Operators.md>)                                                                       | Math Functions                                 | Performs a Boolean logical evaluation on arguments x and y. Can be any of these string literals: `'AND'`, `'OR'`, or `'XOR'`.                                                                                                                                                        |
| [BOOLNOT](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Returns the logical negation of the BOOLFUNC function.                                                                                                                                                                                                                               |
| [BOOLOR](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | Alias for the BOOLFUNC syntax BOOLFUNC('OR', x, y).                                                                                                                                                                                                                                  |
| [BOOLXOR](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Alias for the BOOLFUNC syntax BOOLFUNC('XOR', x, y).                                                                                                                                                                                                                                 |
| [BTRIM](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Alias for TRIM.                                                                                                                                                                                                                                                                      |
| [BYTE](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Casts the argument to a value of type byte.                                                                                                                                                                                                                                          |
| [CANCEL](<./Data Definition Language _DDL_ Statement Reference/Query Management.md>)                                  | Query Management                               | Cancels a running query based on its specific query identifier.                                                                                                                                                                                                                      |
| [CASE](<./Other Functions and Expressions.md>) <br />                                                                 | Conditional Functions                          | CASE operates similarly to conditional scripting in other programming languages, allowing it to function like an if / then / else statement or as a switch statement.                                                                                                                |
| [CASE WHEN](<././Load Data/Transform Data in Data Pipelines.md>)<br /><br />                                          | Special Data Pipeline Transformation Functions | Returns the `result` value based on whether an expression is `true`.                                                                                                                                                                                                                 |
| [CAST\_TO\_ARRAY](<./Array Functions and Operators.md>)                                                               | Array Functions                                | Casts the elements of the array to another type.                                                                                                                                                                                                                                     |
| [CAST\_TO\_TUPLE](<./Tuple Functions and Operators.md>)                                                               | Tuple Functions                                | Converts a tuple into another tuple of a different type.                                                                                                                                                                                                                             |
| [CBRT](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the cube root of the numeric value x.                                                                                                                                                                                                                                        |
| [CDF](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | The cumulative distribution function of the standard normal distribution. Returns the probability that a random sample is less than or equal to the specified value.                                                                                                                 |
| [CEIL](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the nearest integer greater than or equal to x.                                                                                                                                                                                                                              |
| [CEILING](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Alias for CEIL.                                                                                                                                                                                                                                                                      |
| [CENTURY](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Returns the number of centuries.                                                                                                                                                                                                                                                     |
| [CHAR](<./Array Functions and Operators.md>)                                                                          | Array Functions                                | Converts array to its string representation.                                                                                                                                                                                                                                         |
| [CHAR](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Creates a string version of the numeric value.                                                                                                                                                                                                                                       |
| [CHAR](<./Tuple Functions and Operators.md>)                                                                          | Tuple Functions                                | Converts a tuple to its string representation.                                                                                                                                                                                                                                       |
| [CHAR\_LENGTH](<./Character and Binary Functions.md>)                                                                 | Character and Binary Functions                 | Alias for LENGTH.                                                                                                                                                                                                                                                                    |
| [CHARACTER\_LENGTH](<./Character and Binary Functions.md>)                                                            | Character and Binary Functions                 | Alias for LENGTH.                                                                                                                                                                                                                                                                    |
| [CHR](<./Character and Binary Functions.md>)                                                                          | Character and Binary Functions                 | Converts an integer value to a string.                                                                                                                                                                                                                                               |
| [COALESCE](<./Other Functions and Expressions.md>)                                                                    | Conditional Functions                          | Evaluates to the first argument that is not NULL, or NULL if all arguments are NULL.                                                                                                                                                                                                 |
| [COEFFICIENT\_OF\_DETERMINATION](<./Aggregate Functions.md>)                                                          | Aggregate Functions                            | Computes the coefficient of determination (R²) between actual and predicted values.                                                                                                                                                                                                  |
| [COMMIT](<./Other Functions and Expressions.md>)                                                                      | System Functions                               | Returns the most recent commit hash of the database to which the client is currently connected.                                                                                                                                                                                      |
| [CONCAT](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | Concatenates two values, which must both be either binary, hash, or string data types. This function is equivalent to the \|\| operator.                                                                                                                                             |
| [CONFUSION\_MATRIX](<./Aggregate Functions.md>)                                                                       | Aggregate Functions                            | Returns a structured representation of the counts for every combination of actual and predicted class labels relative to a specified positive class.                                                                                                                                 |
| [CONVERT\_LOCAL\_TIMESTAMP\_TO\_UTC](<./Time Zone Functions.md>)                                                      | Time Zone Functions                            | The function converts a timestamp in a specified local time zone to the UTC time zone.                                                                                                                                                                                               |
| [CONVERT\_UTC\_TIMESTAMP\_TO\_LOCAL](<./Time Zone Functions.md>)                                                      | Time Zone Functions                            | The function converts a timestamp from the UTC time zone to a specified local time zone.                                                                                                                                                                                             |
| [CORR](<./Aggregate Functions.md>)                                                                                    | Aggregate Functions                            | Alias for CORRELATION.                                                                                                                                                                                                                                                               |
| [CORRELATION](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Sample correlation.                                                                                                                                                                                                                                                                  |
| [CORRELATIONP](<./Aggregate Functions.md>)                                                                            | Aggregate Functions                            | Population correlation.                                                                                                                                                                                                                                                              |
| [COS](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the cosine of x.                                                                                                                                                                                                                                                             |
| [COSH](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the hyperbolic cosine of x.                                                                                                                                                                                                                                                  |
| [COT](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the cotangent of x.                                                                                                                                                                                                                                                          |
| [COUNT](<./Aggregate Functions.md>)                                                                                   | Aggregate Functions                            | Number of rows in the set.                                                                                                                                                                                                                                                           |
| [COVAR\_POP](<./Aggregate Functions.md>)                                                                              | Aggregate Functions                            | Alias for COVARIANCEP.                                                                                                                                                                                                                                                               |
| [COVAR\_SAMP](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Alias for COVARIANCE.                                                                                                                                                                                                                                                                |
| [COVARIANCE](<./Aggregate Functions.md>)                                                                              | Aggregate Functions                            | Sample covariance.                                                                                                                                                                                                                                                                   |
| [COVARIANCEP](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Population covariance.                                                                                                                                                                                                                                                               |
| [CROSS\_ENTROPY\_LOSS](<./Array Functions and Operators.md>)                                                          | Array Functions                                | Returns the cross entropy loss of two arrays.                                                                                                                                                                                                                                        |
| [CROSS\_ENTROPY\_LOSS](<./Matrix Functions and Operators.md>)                                                         | Matrix Functions                               | Returns the cross entropy loss of two one-dimensional matrices or vectors.                                                                                                                                                                                                           |
| [CUME\_DIST](<./Window Aggregate Functions.md>)                                                                       | Window Aggregate Functions                     | Returns a number 0 \< n 1 and can be used to calculate the percentage of values less than or equal to the current value in the group.                                                                                                                                                |
| [CURDATE](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Alias for CURRENT\_DATE.                                                                                                                                                                                                                                                             |
| [CURRENT\_DATABASE](<./Other Functions and Expressions.md>)                                                           | System Functions                               | Alias for DATABASE.                                                                                                                                                                                                                                                                  |
| [CURRENT\_DATE](<./Date and Time Functions.md>)                                                                       | Date and Time Functions                        | Returns the current date in the format YYYY-MM-DD.                                                                                                                                                                                                                                   |
| [CURRENT\_GROUPS](<./Other Functions and Expressions.md>)                                                             | System Functions                               | Returns the fully-qualified names of groups in the database.                                                                                                                                                                                                                         |
| [CURRENT\_NODE](<./Other Functions and Expressions.md>)                                                               | System Functions                               | Returns the name of the SQL Node where the current query executes. The name of the node corresponds to the name column in the `sys.nodes` system catalog table.                                                                                                                      |
| [CURRENT\_NODE\_ID](<./Other Functions and Expressions.md>)                                                           | System Functions                               | Returns the identifier of the SQL Node where the current query executes.                                                                                                                                                                                                             |
| [CURRENT\_SCHEMA](<./Other Functions and Expressions.md>)                                                             | System Functions                               | Returns the name of the current schema.                                                                                                                                                                                                                                              |
| [CURRENT\_SESSION\_ID](<./Other Functions and Expressions.md>)                                                        | System Functions                               | Returns the Universally Unique IDentifier (UUID) of the current session.                                                                                                                                                                                                             |
| [CURRENT\_SYSTEM](<./Other Functions and Expressions.md>)                                                             | System Functions                               | Returns the name of the system.                                                                                                                                                                                                                                                      |
| [CURRENT\_TIME](<./Date and Time Functions.md>)                                                                       | Date and Time Functions                        | Returns the current time as a TIME value (e.g., `hh:mm:ss.mm`).                                                                                                                                                                                                                      |
| [CURRENT\_TIMESTAMP](<./Date and Time Functions.md>)                                                                  | Date and Time Functions                        | Returns the current date and time as a TIMESTAMP value (e.g., YYYY-MM-DD hh🇲🇲ss.mmm).                                                                                                                                                                                              |
| [CURRENT\_USER](<./Other Functions and Expressions.md>)                                                               | System Functions                               | Returns the user for the current connection.                                                                                                                                                                                                                                         |
| [DATABASE](<./Other Functions and Expressions.md>)                                                                    | System Functions                               | Returns the name of the database to which the client is currently connected.                                                                                                                                                                                                         |
| [DATE](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Parses a string in the form 'YYYY-MM-DD' to create a date. Extra characters are ignored.                                                                                                                                                                                             |
| [DATE\_PART](<./Date and Time Functions.md>)                                                                          | Date and Time Functions                        | Alias for EXTRACT.                                                                                                                                                                                                                                                                   |
| [DATE\_TRUNC](<./Date and Time Functions.md>)                                                                         | Date and Time Functions                        | Returns the date or timestamp entered, truncated to the specified precision.                                                                                                                                                                                                         |
| [DATEADD](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Adds a specified number value (as a signed integer) to a specified date part of an input date value, and then returns that modified value.                                                                                                                                           |
| [DATEDIFF](<./Date and Time Functions.md>)                                                                            | Date and Time Functions                        | This function returns an INT representing the difference between two date or time values in a specified date or time unit.                                                                                                                                                           |
| [DAY](<./Date and Time Functions.md>)                                                                                 | Date and Time Functions                        | Alias for DAY\_OF\_MONTH.                                                                                                                                                                                                                                                            |
| [DAY\_OF\_MONTH](<./Date and Time Functions.md>)                                                                      | Date and Time Functions                        | Extracts the day-of-month portion of a timestamp or date as an integer.                                                                                                                                                                                                              |
| [DAY\_OF\_WEEK](<./Date and Time Functions.md>)                                                                       | Date and Time Functions                        | Returns an integer, in the range of 1 to 7, that represents the day of the week.                                                                                                                                                                                                     |
| [DAY\_OF\_YEAR](<./Date and Time Functions.md>)                                                                       | Date and Time Functions                        | Returns an integer in the range 1 to 366 that represents the day of the year.                                                                                                                                                                                                        |
| [DAYS](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type days to be used in date calculations.                                                                                                                                                                                        |
| [DECADE](<./Date and Time Functions.md>)                                                                              | Date and Time Functions                        | The decade is the year divided by 10.                                                                                                                                                                                                                                                |
| [DECIMAL](<./Scalar Data Conversion Functions.md>)                                                                    | Scalar Data Conversion Functions               | Casts the argument to a value of type decimal.                                                                                                                                                                                                                                       |
| [DEGREES](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Returns the corresponding angle in degrees for x in radians.                                                                                                                                                                                                                         |
| [DELTA](<./Window Aggregate Functions.md>)                                                                            | Window Aggregate Functions                     | Computes the finite difference between successive values of expression under the specified ordering. This is a backwards difference, which means that, at degree one, the value for a given row is the difference between the value of expression for that row and the previous row. |
| [DENSE\_RANK](<./Window Aggregate Functions.md>)                                                                      | Window Aggregate Functions                     | Assigns a number to each row in the result set with equal values having the same number. There will be no gaps between ranks.                                                                                                                                                        |
| [DERIVATIVE](<./Window Aggregate Functions.md>)                                                                       | Window Aggregate Functions                     | Computes the difference quotient between successive values of expression with respect to expression2.                                                                                                                                                                                |
| [DET](<./Matrix Functions and Operators.md>)                                                                          | Matrix Functions                               | Returns the determinant of the matrix as a double.                                                                                                                                                                                                                                   |
| [DIV](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the result of x divided by y. If y is zero, returns NULL.                                                                                                                                                                                                                    |
| [DOT](<./Matrix Functions and Operators.md>)                                                                          | Matrix Functions                               | Returns dot product of two one-dimensional matrices/vectors.                                                                                                                                                                                                                         |
| [DOUBLE](<./Scalar Data Conversion Functions.md>)                                                                     | Scalar Data Conversion Functions               | Casts the argument to a value of type double.                                                                                                                                                                                                                                        |
| [DOW](<./Date and Time Functions.md>)                                                                                 | Date and Time Functions                        | Alias for DAY\_OF\_WEEK.                                                                                                                                                                                                                                                             |
| [DOY](<./Date and Time Functions.md>)                                                                                 | Date and Time Functions                        | Alias for DAY\_OF\_YEAR.                                                                                                                                                                                                                                                             |
| [EIGEN](<./Matrix Functions and Operators.md>)                                                                        | Matrix Functions                               | Returns eigenvalues and eigenvalues of a square matrix as a vector of pairs.                                                                                                                                                                                                         |
| [ELEMENT\_AT](<././Load Data/Transform Data in Data Pipelines.md>)                                                    | Special Data Pipeline Transformation Functions | Returns the element value of the array or tuple at the specified index.                                                                                                                                                                                                              |
| [ENDSWITH](<./Character and Binary Functions.md>)                                                                     | Character and Binary Functions                 | Returns true if x ends with y and false otherwise.                                                                                                                                                                                                                                   |
| [EOMONTH](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Returns the last day of the timestamp or date.                                                                                                                                                                                                                                       |
| [EPOCH](<./Date and Time Functions.md>)                                                                               | Date and Time Functions                        | The number of seconds after 1970-01-01 00:00:00 UTC.                                                                                                                                                                                                                                 |
| [ERF](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | The error function is used for measurements that follow a normal distribution.                                                                                                                                                                                                       |
| [ERFC](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | The complement of the error function. ERFC(x) = 1 - ERF(x).                                                                                                                                                                                                                          |
| [EXP](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the exponential of x (e raised to the power of x).                                                                                                                                                                                                                           |
| [EXPLODE\_OUTER](<././Load Data/Transform Data in Data Pipelines/Special Data Pipeline Transformation Functions.md>)  | Special Data Pipeline Transformation Functions | Expands a one-dimensional or multidimensional array into its elements with one element per row of output from the system.                                                                                                                                                            |
| [EXTRACT](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Extract a component from a timestamp or date.                                                                                                                                                                                                                                        |
| [F1\_SCORE](<./Aggregate Functions.md>)                                                                               | Aggregate Functions                            | Returns the harmonic mean of precision and recall for a specified positive class.                                                                                                                                                                                                    |
| [FILTER](<././Load Data/Transform Data in Data Pipelines/Special Data Pipeline Transformation Functions.md>)          | Special Data Pipeline Transformation Functions | Filters elements in an array based on the logic in a lambda expression.                                                                                                                                                                                                              |
| [FIRST\_VALUE](<./Window Aggregate Functions.md>)                                                                     | Window Aggregate Functions                     | Returns the first value in the ordered result set.                                                                                                                                                                                                                                   |
| [FLATTEN](<././Load Data/Transform Data in Data Pipelines.md>)                                                        | Special Data Pipeline Transformation Functions | Transforms an `N`-dimensional array into an `N-1`-dimensional array.                                                                                                                                                                                                                 |
| [FLOAT](<./Scalar Data Conversion Functions.md>)                                                                      | Scalar Data Conversion Functions               | Casts the argument to a value of type float.                                                                                                                                                                                                                                         |
| [FLOOR](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns the nearest integer less than or equal to x.                                                                                                                                                                                                                                 |
| [FROBENIUS](<./Matrix Functions and Operators.md>)                                                                    | Matrix Functions and Operators                 | Returns the Frobenius norm of a matrix.                                                                                                                                                                                                                                              |
| [GAMMA](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | [Gamma function.](https://en.wikipedia.org/wiki/Gamma_function)                                                                                                                                                                                                                      |
| [GREATEST](<./Other Functions and Expressions.md>)                                                                    | Conditional Functions                          | Returns the largest non-NULL value of all the arguments, or NULL if all the arguments are NULL.                                                                                                                                                                                      |
| [HASH](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Creates a fixed length binary value, with length `<length>`, from a string, i.e. `0x1234abcd`. Zero extended if the string does not have enough bytes, truncated if it has too many.                                                                                                 |
| [HEXBINX](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Returns the x-coordinate of the center of the nearest hexagonal bin to the point (x, y).                                                                                                                                                                                             |
| [HEXBINY](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Returns the y-coordinate of the center of the nearest hexagonal bin to the point (x, y).                                                                                                                                                                                             |
| [HINGE\_LOSS](<./Array Functions and Operators.md>)                                                                   | Array Functions                                | Returns the hinge loss of two arrays.                                                                                                                                                                                                                                                |
| [HINGE\_LOSS](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns the hinge loss of two one-dimensional matrices or vectors.                                                                                                                                                                                                                   |
| [HLL\_SKETCH\_CREATE](<./HyperLogLog Functions.md>)                                                                   | HyperLogLog Functions                          | Creates an HLL sketch from the data on a specified aggregated column. Returns a HASH((2^log2k) + 8) data representation of the sketch that you can store in a separate column.                                                                                                       |
| [HLL\_SKETCH\_GET\_ESTIMATE](<./HyperLogLog Functions.md>)                                                            | HyperLogLog Functions                          | The scalar function converts a sketch into a distinct count estimate of a sketch value. Returns the distinct count estimate as a BIGINT.                                                                                                                                             |
| [HLL\_SKETCH\_GET\_ESTIMATE\_BOUND](<./HyperLogLog Functions.md>)                                                     | HyperLogLog Functions                          | Takes a HLL\_SKETCH column or an integral log2k literal value and returns the resulting bounding 95-percent confidence interval error proportion as a DOUBLE.                                                                                                                        |
| [HLL\_SKETCH\_TO\_STRING](<./HyperLogLog Functions.md>)                                                               | HyperLogLog Functions                          | The HLL\_SKETCH\_TO\_STRING scalar function takes a HLL\_SKETCH column or value and returns a string summary of the sketch.                                                                                                                                                          |
| [HLL\_SKETCH\_UNION (aggregate function)](<./HyperLogLog Functions.md>)                                               | HyperLogLog Functions                          | Merges multiple sketches in a single column into a unified sketch. All sketches must have the same precision. This function is an aggregate function and operates on a column.                                                                                                       |
| [HLL\_SKETCH\_UNION (scalar function)](<./HyperLogLog Functions.md>)                                                  | HyperLogLog Functions                          | Merges two sketches into a new combined sketch. This function is a scalar function and operates row-wise. The scalar function merges two sketch columns with heterogeneous precisions into a sketch with the lower of the two precisions.                                            |
| [HOUR](<./Date and Time Functions.md>)                                                                                | Date and Time Functions                        | Extracts the hour portion of a timestamp as an integer.                                                                                                                                                                                                                              |
| [HOURS](<./Scalar Data Conversion Functions.md>)                                                                      | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type hours.                                                                                                                                                                                                                       |
| [IDENTITY\_MATRIX](<./Matrix Functions and Operators.md>)                                                             | Matrix Functions                               | Returns an identity matrix of the specified dimension.                                                                                                                                                                                                                               |
| [IERF](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | The inverse of the ERF error function.                                                                                                                                                                                                                                               |
| [IERFC](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | The inverse of the complement of the error function.                                                                                                                                                                                                                                 |
| [IF](<././Load Data/Transform Data in Data Pipelines.md>)                                                             | Special Data Pipeline Transformation Functions | Returns `T` if the expression `X` evaluates to `true`, or the function returns `F` if `X` evaluates to `false`.                                                                                                                                                                      |
| [IF\_NULL](<./Other Functions and Expressions.md>)                                                                    | Conditional Functions                          | Alias for COALESCE.                                                                                                                                                                                                                                                                  |
| [INITCAP](<./Character and Binary Functions.md>)                                                                      | Character and Binary Functions                 | For each word in the provided string, capitalize the first character if it is alphabetic.                                                                                                                                                                                            |
| [INSTR](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Returns the index position of the first occurrence where the character value char\_substring appears in the character value char by ignoring case.                                                                                                                                   |
| [INTEGER](<./Scalar Data Conversion Functions.md>)                                                                    | Scalar Data Conversion Functions               | Casts the argument to a value of type integer.                                                                                                                                                                                                                                       |
| [INVERSE](<./Matrix Functions and Operators.md>)                                                                      | Matrix Functions                               | Returns inverse of a square, invertible matrix.                                                                                                                                                                                                                                      |
| [IP](<./Network Type Functions.md>)                                                                                   | Network Type Functions                         | Casts an IP data type from an IPV4 data type expression.                                                                                                                                                                                                                             |
| [IPV4](<./Network Type Functions.md>)                                                                                 | Network Type Functions                         | Casts an IPV4 address from an IPV6 address.                                                                                                                                                                                                                                          |
| [ISDATE](<./Date and Time Functions.md>)                                                                              | Date and Time Functions                        | Returns TRUE if the input argument can be successfully cast to a date.                                                                                                                                                                                                               |
| [IS\_IPV4](<./Network Type Functions.md>)                                                                             | Network Type Functions                         | Tests whether the database can convert the `IP` value to the `IPV4` data type.                                                                                                                                                                                                       |
| [ISODOW](<./Date and Time Functions.md>)                                                                              | Date and Time Functions                        | Extracts the day of the week based on ISO 8601, which ranges from Monday (1) to Sunday (7).                                                                                                                                                                                          |
| [JSON\_EXTRACT\_PATH\_TEXT](<./Character and Binary Functions.md>)                                                    | Character and Binary Functions                 | Returns the value for the key-value pair referenced by a series of path elements in a JSON string.                                                                                                                                                                                   |
| [KILL](<./Data Definition Language _DDL_ Statement Reference/Query Management.md>)                                    | Query Management                               | Cancels a running query based on its specific query identifier.                                                                                                                                                                                                                      |
| [KURTOSIS](<./Aggregate Functions.md>)                                                                                | Aggregate Functions                            | The sample over the set.                                                                                                                                                                                                                                                             |
| [KURTOSISP](<./Aggregate Functions.md>)                                                                               | Aggregate Functions                            | The population over the set.                                                                                                                                                                                                                                                         |
| [LAG](<./Window Aggregate Functions.md>)                                                                              | Window Aggregate Functions                     | Returns the row, which is the specified number backward from the current row. Default is 1 if offset is omitted.                                                                                                                                                                     |
| [LAG\_VECTORS](<./Machine Learning Model Functions/Data Preparation.md>)                                              | Data Preparation                               | Groups lagged columns generated by the `MULTI_LAGS` or `MULTI_LAGS_ZEROFILL` functions into vector columns.                                                                                                                                                                          |
| [LAGS](<./Machine Learning Model Functions/Data Preparation.md>)                                                      | Data Preparation                               | Generates a series of lagged columns for a single variable in one statement.                                                                                                                                                                                                         |
| [LAGS\_ZEROFILL](<./Machine Learning Model Functions/Data Preparation.md>)                                            | Data Preparation                               | Generates lagged columns for a single variable and replaces NULL values with `0`.                                                                                                                                                                                                    |
| [LAST\_VALUE](<./Window Aggregate Functions.md>)                                                                      | Window Aggregate Functions                     | Returns the last value in the ordered result set.                                                                                                                                                                                                                                    |
| [LCASE](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Alias for LOWER.                                                                                                                                                                                                                                                                     |
| [LEAD](<./Window Aggregate Functions.md>)                                                                             | Window Aggregate Functions                     | Returns the row, which is the specified number forward from the current row. Default is 1 if offset is omitted.                                                                                                                                                                      |
| [LEAKYRELU](<./Math Functions and Operators.md>)                                                                      | Math Functions                                 | Returns the leaky rectified linear unit function of x.                                                                                                                                                                                                                               |
| [LEAST](<./Other Functions and Expressions.md>)                                                                       | Conditional Functions                          | Returns the smallest non-NULL value of all arguments, or NULL if all arguments are NULL.                                                                                                                                                                                             |
| [LEFT](<./Character and Binary Functions.md>)                                                                         | Character and Binary Functions                 | Return the number of characters in the string equal to the value integer. If the integer is negative, the function returns all but the last integer characters.                                                                                                                      |
| [LEFT\_SHIFT](<./Math Functions and Operators.md>)                                                                    | Math Functions                                 | Returns x shifted to the left by y bits.                                                                                                                                                                                                                                             |
| [LENGTH](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | For character data types, this value is in terms of characters. For binary data types, this value is in terms of bytes.                                                                                                                                                              |
| [LN](<./Math Functions and Operators.md>)                                                                             | Math Functions                                 | Returns the natural logarithm of x.                                                                                                                                                                                                                                                  |
| [LOCATE](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | Alias for POSITION. Returns the index position of the first occurrence of the character value substring in the character value string.                                                                                                                                               |
| [LOG](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the base 10 logarithm of x. The optional base argument specifies the numeral system to use. If unspecified, the function defaults to base 10.                                                                                                                                |
| [LOG\_GAMMA](<./Math Functions and Operators.md>)                                                                     | Math Functions                                 | The natural logarithm of the absolute value of the gamma function.                                                                                                                                                                                                                   |
| [LOG\_LOSS](<./Array Functions and Operators.md>)                                                                     | Array Functions                                | Returns the log loss of two arrays.                                                                                                                                                                                                                                                  |
| [LOG\_LOSS](<./Matrix Functions and Operators.md>)                                                                    | Matrix Functions                               | Returns the log loss of two one-dimensional matrices or vectors.                                                                                                                                                                                                                     |
| [LOG2](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the base 2 logarithm of x.                                                                                                                                                                                                                                                   |
| [LOGITS\_LOSS](<./Array Functions and Operators.md>)                                                                  | Array Functions                                | Returns the logits loss of two arrays.                                                                                                                                                                                                                                               |
| [LOGITS\_LOSS](<./Matrix Functions and Operators.md>)                                                                 | Matrix Functions                               | Returns the logits loss of two one-dimensional matrices or vectors.                                                                                                                                                                                                                  |
| [LOOKUP](<././Load Data/Load Data from External Sources in Data Pipelines.md>)                                        | Special Data Pipeline Transformation Functions | Look up and load data in an external data source.                                                                                                                                                                                                                                    |
| [LOWER](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Alias for LCASE. Convert string to lowercase.                                                                                                                                                                                                                                        |
| [LPAD](<./Character and Binary Functions.md>)                                                                         | Character and Binary Functions                 | Pad the input text to the specified length with the pad string on the left side.                                                                                                                                                                                                     |
| [LTRIM](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Removes leading blanks from the string value string.                                                                                                                                                                                                                                 |
| [LUPQ\_DECOMP](<./Matrix Functions and Operators.md>)                                                                 | Matrix Functions                               | Returns LUPQ decomposition of a square matrix A as a tuple of 4 matrices where PAQ = LU.                                                                                                                                                                                             |
| [MAP\_KEYS](<././Load Data/Transform Data in Data Pipelines.md>)                                                      | Special Data Pipeline Transformation Functions | Returns the keys in the specified JSON string.                                                                                                                                                                                                                                       |
| [MAP\_VALUES](<././Load Data/Transform Data in Data Pipelines.md>)                                                    | Special Data Pipeline Transformation Functions | Returns the values in the specified JSON string.                                                                                                                                                                                                                                     |
| [MATRIX\_DIM](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns the dimensions of the specified matrix as a tuple of (row, col) integers.                                                                                                                                                                                                    |
| [MAKE\_MATRIX\_IXJ](<./Matrix Functions and Operators.md>)                                                            | Matrix Functions                               | Creates an `ixj` matrix with elements `e_00`, `…`, `e_ij`.                                                                                                                                                                                                                           |
| [MAKEDATETIME](<./Date and Time Functions.md>)                                                                        | Date and Time Functions                        | Returns a timestamp consisting of the specified date and time.                                                                                                                                                                                                                       |
| [MATRIX\_FROM\_TEXT](<./Matrix Functions and Operators.md>)                                                           | Matrix Functions                               | Creates a matrix from the specified string.                                                                                                                                                                                                                                          |
| [MATRIX\_TRACE](<./Matrix Functions and Operators.md>)                                                                | Matrix Functions                               | Returns trace of a square matrix as a double.                                                                                                                                                                                                                                        |
| [MAX](<./Aggregate Functions.md>)                                                                                     | Aggregate Functions                            | Maximum value in the specified column.                                                                                                                                                                                                                                               |
| [MD5](<./Character and Binary Functions.md>)                                                                          | Character and Binary Functions                 | Returns the hexadecimal string (all lowercase) representing the md5 hash of char.                                                                                                                                                                                                    |
| [MEAN\_ABSOLUTE\_ERROR](<./Aggregate Functions.md>)                                                                   | Aggregate Functions                            | Returns the mean absolute error (MAE) between actual and predicted values.                                                                                                                                                                                                           |
| [MEAN\_ABSOLUTE\_PERCENTAGE\_ERROR](<./Aggregate Functions.md>)                                                       | Aggregate Functions                            | Returns the mean absolute percentage error (MAPE) between actual and predicted values.                                                                                                                                                                                               |
| [METADATA](<././Load Data/Load Metadata and File-Based Partitioned Data in Data Pipelines.md>)                        | Special Data Pipeline Transformation Functions | Extracts the metadata value for the specified key from available metadata for the pipeline.                                                                                                                                                                                          |
| [MICROSECONDS](<./Scalar Data Conversion Functions.md>)                                                               | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type microseconds.                                                                                                                                                                                                                |
| [MID](<./Character and Binary Functions.md>)                                                                          | Character and Binary Functions                 | Alias for SUBSTRING.                                                                                                                                                                                                                                                                 |
| [MILLISECOND](<./Date and Time Functions.md>)                                                                         | Date and Time Functions                        | Extracts the millisecond portion of a timestamp as an integer.                                                                                                                                                                                                                       |
| [MILLISECONDS](<./Scalar Data Conversion Functions.md>)                                                               | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type milliseconds.                                                                                                                                                                                                                |
| [MIN](<./Aggregate Functions.md>)                                                                                     | Aggregate Functions                            | Minimum value in the specified column.                                                                                                                                                                                                                                               |
| [MINUTE](<./Date and Time Functions.md>)                                                                              | Date and Time Functions                        | Extracts the minute portion of a timestamp or date as an integer.                                                                                                                                                                                                                    |
| [MINUTES](<./Scalar Data Conversion Functions.md>)                                                                    | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type minutes.                                                                                                                                                                                                                     |
| [MOD](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the remainder from x divided by y.                                                                                                                                                                                                                                           |
| [MONTH](<./Date and Time Functions.md>)                                                                               | Date and Time Functions                        | Extracts the month portion of a timestamp or date as an integer.                                                                                                                                                                                                                     |
| [MONTH\_NAME](<./Date and Time Functions.md>)                                                                         | Date and Time Functions                        | Returns the calendar name in English of the month for the specified date.                                                                                                                                                                                                            |
| [MONTHS](<./Scalar Data Conversion Functions.md>) <br />                                                              | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type months to be used in date calculations.                                                                                                                                                                                      |
| [MONTHS\_BETWEEN](<./Date and Time Functions.md>)                                                                     | Date and Time Functions                        | Returns the difference between the two dates or timestamps in months as a DOUBLE.                                                                                                                                                                                                    |
| [MSECS](<./Date and Time Functions.md>)                                                                               | Date and Time Functions                        | The seconds field, including fractional parts. The function multiplies the seconds part of the value by 1,000.                                                                                                                                                                       |
| [MULTI\_LAGS](<./Machine Learning Model Functions/Data Preparation.md>)                                               | Data Preparation                               | Generates lagged columns for multiple variables at once.                                                                                                                                                                                                                             |
| [MULTI\_LAGS\_ZEROFILL](<./Machine Learning Model Functions/Data Preparation.md>)                                     | Data Preparation                               | Generates lagged columns for multiple variables and replaces NULL values with `0`.                                                                                                                                                                                                   |
| [MURMUR3](<./Other Functions and Expressions.md>)                                                                     | Conditional Functions                          | [Returns a 32-bit MurmurHash3 hash of the input value as an INTEGER data type.](https://github.com/aappleby/smhasher/blob/master/README.md)                                                                                                                                          |
| [NANOS\_TO\_TIMESTAMP](<./Date and Time Functions.md>)                                                                | Date and Time Functions                        | Convert a number of nanoseconds into a timestamp equivalent to the duration after the epoch time.                                                                                                                                                                                    |
| [NANOSECONDS](<./Scalar Data Conversion Functions.md>)                                                                | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type nanoseconds.                                                                                                                                                                                                                 |
| [NEXT\_DAY](<./Date and Time Functions.md>)                                                                           | Date and Time Functions                        | Returns the closest date after a specified date that lies on a specific day of the week.                                                                                                                                                                                             |
| [NOW](<./Date and Time Functions.md>)                                                                                 | Date and Time Functions                        | Alias for CURRENT\_TIMESTAMP.                                                                                                                                                                                                                                                        |
| [NTH\_VALUE](<./Window Aggregate Functions.md>)                                                                       | Window Aggregate Functions                     | Returns the nth value in the ordered result set.                                                                                                                                                                                                                                     |
| [NULL\_IF](<./Other Functions and Expressions.md>)                                                                    | Conditional Functions                          | Returns the NULL value if two arguments are equal; otherwise, returns the first argument.                                                                                                                                                                                            |
| [NULL\_MATRIX](<./Matrix Functions and Operators.md>)                                                                 | Matrix Functions                               | Returns a null matrix of the given (row, col) dimensions.                                                                                                                                                                                                                            |
| [OCTET\_LENGTH](<./Character and Binary Functions.md>)                                                                | Character and Binary Functions                 | Returns the length in bytes of a character or binary value.                                                                                                                                                                                                                          |
| [PARSE\_DELIMITED\_ARRAY](<././Load Data/Transform Data in Data Pipelines.md>)                                        | Special Data Pipeline Transformation Functions | Converts a string of text data representing an array into a `CHAR[]`.                                                                                                                                                                                                                |
| [PERCENT\_RANK](<./Window Aggregate Functions.md>)                                                                    | Window Aggregate Functions                     | The value returned is 0 \< n ≤ 1 and can be used to calculate the percentage of values less than the current group, excluding the highest value.                                                                                                                                     |
| [PERCENTILE](<./Window Aggregate Functions.md>)                                                                       | Window Aggregate Functions                     | Returns the value that corresponds to the specified percentile (0 ≤ n ≤ 1) within the group.                                                                                                                                                                                         |
| [PI](<./Math Functions and Operators.md>)                                                                             | Math Functions                                 | Returns the constant value of π.                                                                                                                                                                                                                                                     |
| [PMOD](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the smallest non-negative equivalence class of x % y.                                                                                                                                                                                                                        |
| [POSITION](<./Character and Binary Functions.md>)                                                                     | Character and Binary Functions                 | Alias for LOCATE.                                                                                                                                                                                                                                                                    |
| [POWER](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns x raised to the power of y.                                                                                                                                                                                                                                                  |
| [PRECISION\_SCORE](<./Aggregate Functions.md>)                                                                        | Aggregate Functions                            | Returns the precision score for a specified positive class.                                                                                                                                                                                                                          |
| [PROBIT](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | The inverse of the cumulative distribution function.                                                                                                                                                                                                                                 |
| [PRODUCT](<./Aggregate Functions.md>)                                                                                 | Aggregate Functions                            | Product over the set.                                                                                                                                                                                                                                                                |
| [QR\_DECOMP](<./Matrix Functions and Operators.md>)                                                                   | Matrix Functions                               | Returns QR decomposition of a matrix as a tuple of 2 matrices.                                                                                                                                                                                                                       |
| [QUARTER](<./Date and Time Functions.md>)                                                                             | Date and Time Functions                        | Returns an integer between 1 and 4 that represents the quarter of the year in which the specified date falls.                                                                                                                                                                        |
| [RADIANS](<./Math Functions and Operators.md>)                                                                        | Math Functions                                 | Returns the corresponding angle in radians for x in degrees.                                                                                                                                                                                                                         |
| [RAND](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Takes no argument and returns a random DOUBLE value in the range \[0, 1).                                                                                                                                                                                                            |
| [RAND\_UUID](<./Other Functions and Expressions.md>) <br />                                                           | Other Functions and Expressions                | Generates a random UUID value (version 4)                                                                                                                                                                                                                                            |
| [RANK](<./Window Aggregate Functions.md>)                                                                             | Window Aggregate Functions                     | Assigns a number to each row in the result set with equal values having the same number. There can be gaps between ranks.                                                                                                                                                            |
| [RATIO\_TO\_REPORT](<./Window Aggregate Functions.md>)                                                                | Window Aggregate Functions                     | Computes the ratio of a value to the sum of the set of values.                                                                                                                                                                                                                       |
| [RECALL\_SCORE](<./Aggregate Functions.md>)                                                                           | Aggregate Functions                            | Returns the recall score for a specified positive class.                                                                                                                                                                                                                             |
| [ROC\_AUC\_SCORE](<./Aggregate Functions.md>)                                                                         | Aggregate Functions                            | Returns the area under the receiver operating characteristic (ROC) curve (AUC).                                                                                                                                                                                                      |
| [RECORD\_UUID](<././LAT Reference/LAT Data Transformation with JMESPath/LAT Transformation Functions.md>) <br />      | Other Transformation Functions                 | Returns string that represents a unique identifier for the record in a specified pipeline for a specified file\_group or topic.                                                                                                                                                      |
| [REDUCE](<././Load Data/Transform Data in Data Pipelines.md>)                                                         | Special Data Pipeline Transformation Functions | Applies a merge function to a starting value and all elements in the array, and then reduces the array to a single value. Optionally, specify a finish function for the returned single value.                                                                                       |
| [REGEXP\_COUNT](<./Character and Binary Functions.md>)                                                                | Character and Binary Functions                 | Searches a string for all occurrences of a regular expression pattern.                                                                                                                                                                                                               |
| [REGEXP\_INSTR](<./Character and Binary Functions.md>)                                                                | Character and Binary Functions                 | Searches a string using a regular expression pattern and returns an integer representing the start position or end position of the substring that matches.                                                                                                                           |
| [REGEXP\_REPLACE](<./Character and Binary Functions.md>)                                                              | Character and Binary Functions                 | Searches a string for all occurrences of a regular expression pattern.                                                                                                                                                                                                               |
| [REGEXP\_SUBSTR](<./Character and Binary Functions.md>)                                                               | Character and Binary Functions                 | Returns one substring from a string that matches a specified regular expression pattern.                                                                                                                                                                                             |
| [RELU](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the rectified linear unit function of x.                                                                                                                                                                                                                                     |
| [REPEAT](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | Repeats the character value char a number of times equal to num.                                                                                                                                                                                                                     |
| [REPLACE](<./Character and Binary Functions.md>) <br /><br />                                                         | Character and Binary Functions                 | Replaces all occurrences of `substr_to_remove` in the character value string with `substr_to_replace`.                                                                                                                                                                               |
| [REVERSE](<./Character and Binary Functions.md>)                                                                      | Character and Binary Functions                 | Reverse the input string.                                                                                                                                                                                                                                                            |
| [RIGHT](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Return the number of trailing characters in the string equal to the value integer.                                                                                                                                                                                                   |
| [RIGHT\_SHIFT](<./Math Functions and Operators.md>)                                                                   | Math Functions                                 | Returns x shifted to the right by y bits.                                                                                                                                                                                                                                            |
| [ROUND](<./Date and Time Functions.md>)                                                                               | Date and Time Functions                        | Returns the specified date or timestamp, rounded to the specified precision.                                                                                                                                                                                                         |
| [ROUND](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns x rounded to the nearest integer.                                                                                                                                                                                                                                            |
| [ROW\_NUMBER](<./Window Aggregate Functions.md>)                                                                      | Window Aggregate Functions                     | Assigns a unique number to each row in the result set.                                                                                                                                                                                                                               |
| [RPAD](<./Character and Binary Functions.md>)                                                                         | Character and Binary Functions                 | Pad the input text to the specified length with the pad string on the right side.                                                                                                                                                                                                    |
| [RSUBSTRING](<./Character and Binary Functions.md>)                                                                   | Character and Binary Functions                 | Returns the substring from the right side of a string, based on a specified length.                                                                                                                                                                                                  |
| [RTRIM](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Removes leading blanks from the string value string.                                                                                                                                                                                                                                 |
| [SECOND](<./Date and Time Functions.md>)                                                                              | Date and Time Functions                        | Extracts the seconds portion of a timestamp as an integer.                                                                                                                                                                                                                           |
| [SECONDS](<./Scalar Data Conversion Functions.md>)                                                                    | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type seconds.                                                                                                                                                                                                                     |
| [SHA1](<./Character and Binary Functions.md>)                                                                         | Character and Binary Functions                 | Uses the [SHA-1](https://en.wikipedia.org/wiki/SHA-1#:~\:text=In%20cryptography%2C%20SHA%2D1%20\(,rendered%20as%2040%20hexadecimal%20digits.) cryptographic hash function to convert a string into a 40-character string representing the hexadecimal value of a 160-bit checksum.   |
| [SHOW](<./Other Functions and Expressions.md>)                                                                        | System Functions                               | The SHOW function enables you to explore the database and its metadata for user-defined items.                                                                                                                                                                                       |
| [SIGN](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the positive (+1), zero (0), or negative (-1) sign of x.                                                                                                                                                                                                                     |
| [SIN](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the sine of x.                                                                                                                                                                                                                                                               |
| [SINH](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the hyperbolic sine of x.                                                                                                                                                                                                                                                    |
| [SKEW](<./Aggregate Functions.md>)                                                                                    | Aggregate Functions                            | The sample over the set.                                                                                                                                                                                                                                                             |
| [SKEWP](<./Aggregate Functions.md>)                                                                                   | Aggregate Functions                            | Computes the population skewness over the set of values.                                                                                                                                                                                                                             |
| [SMALLINT](<./Scalar Data Conversion Functions.md>)                                                                   | Scalar Data Conversion Functions               | Casts the argument to a value of type `smallint`.                                                                                                                                                                                                                                    |
| [SOFTMAX](<./Array Functions and Operators.md>)                                                                       | Array Functions                                | Returns the softmax of the array.                                                                                                                                                                                                                                                    |
| [SOFTMAX](<./Matrix Functions and Operators.md>)                                                                      | Matrix Functions                               | Returns the softmax of a one-dimensional matrix or vector.                                                                                                                                                                                                                           |
| [SPACE](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Returns a string of repeated spaces equal to the number value, repeat.                                                                                                                                                                                                               |
| [SPLIT\_PART](<./Character and Binary Functions.md>)                                                                  | Character and Binary Functions                 | Split the value string based on the delimiter value. The function returns a substring from the split operation based on the index value (starting from 1).                                                                                                                           |
| [SPLIT\_TO\_ARRAY](<./Character and Binary Functions.md>)                                                             | Character and Binary Functions                 | Splits a string into an array of substrings.                                                                                                                                                                                                                                         |
| [SQRT](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the square root of x.                                                                                                                                                                                                                                                        |
| [SQUARE](<./Math Functions and Operators.md>)                                                                         | Math Functions                                 | Returns the square of x.                                                                                                                                                                                                                                                             |
| [ST\_ADDPOINT](<./Geospatial Functions/Linestring Functions.md>)                                                      | Geospatial Linestring Function                 | Adds a POINT to the given LINESTRING at the specified 0-indexed location.                                                                                                                                                                                                            |
| [ST\_ANGLE](<./Geospatial Functions/Spatial Measurement.md>)                                                          | Geospatial Spatial Measurement                 | Calculates the angle between two lines.                                                                                                                                                                                                                                              |
| [ST\_AREA](<./Geospatial Functions/Spatial Measurement.md>)                                                           | Geospatial Spatial Measurement                 | Returns the area of the specified geospatial object in the specified unit of measurement.                                                                                                                                                                                            |
| [ST\_ASBINARY](<./Geospatial Functions/Conversion Functions.md>)                                                      | Geospatial Conversion Functions                | Returns the well-known binary (WKB) representation of the specified geography. Alias of ST\_ASWKB.                                                                                                                                                                                   |
| [ST\_ASEWKT](<./Geospatial Functions/Conversion Functions.md>)                                                        | Geospatial Conversion Functions                | Returns a string that represents geographic coordinates of a specified POINT in the specified format.                                                                                                                                                                                |
| [ST\_ASGEOJSON](<./Geospatial Functions/Conversion Functions.md>)                                                     | Geospatial Conversion Functions                | Alias of ST\_ASBINARY.                                                                                                                                                                                                                                                               |
| [ST\_ASLATLONTEXT](<./Geospatial Functions/Conversion Functions.md>)                                                  | Geospatial Conversion Functions                | [Returns the GeoJSON representation of the specified geography using the IETF standards.](https://datatracker.ietf.org/doc/html/rfc7946)                                                                                                                                             |
| [ST\_ASTEXT](<./Geospatial Functions/Conversion Functions.md>)                                                        | Geospatial Conversion Functions                | Alias of ST\_ASTEXT.                                                                                                                                                                                                                                                                 |
| [ST\_ASWKB](<./Geospatial Functions/Conversion Functions.md>)                                                         | Geospatial Conversion Functions                | Alias of ST\_ASTEXT.                                                                                                                                                                                                                                                                 |
| [ST\_ASWKT](<./Geospatial Functions/Conversion Functions.md>)                                                         | Geospatial Conversion Functions                | Alias of ST\_ASWKT and ST\_EWKT. Returns the WKT representation of the specified geography.                                                                                                                                                                                          |
| [ST\_AZIMUTH](<./Geospatial Functions/Spatial Measurement.md>)                                                        | Geospatial Spatial Measurement                 | Returns the azimuth of the line from `point1` to `point2` in radians.                                                                                                                                                                                                                |
| [ST\_BOUNDINGDIAGONAL](<./Geospatial Functions/Spatial Operators.md>)                                                 | Geospatial Spatial Operators                   | Returns the diagonal LINESTRING from the minimum point to the maximum point of the bounding box that ST\_ENVELOPE returns.                                                                                                                                                           |
| [ST\_BUFFER](<./Geospatial Functions/Spatial Operators.md>)                                                           | Geospatial Spatial Operators                   | Returns a geography that contains all points where the distance from the geography is less than or equal to the specified distance.                                                                                                                                                  |
| [ST\_CENTROID](<./Geospatial Functions/Point Constructors.md>)                                                        | Geospatial Point Constructors                  | The geographic center of mass is calculated by taking the average of all points on a three-dimensional sphere, projecting the resultant point onto the sphere, and converting it back to latitude and longitude coordinates.                                                         |
| [ST\_CLOSESTPOINT](<./Geospatial Functions/Spatial Operators.md>)                                                     | Geospatial Spatial Operators                   | Returns the two-dimensional POINT of one specified geospatial object that is closest to a second specified geospatial object.                                                                                                                                                        |
| [ST\_CLUSTERDBSCAN](<./Geospatial Functions/Spatial Relationships.md>)                                                | Geospatial Spatial Relationships               | [Returns the cluster number for each input geography, based on a two-dimensional implementation of the density-based spatial clustering of applications with noise (DBSCAN) algorithm.](https://en.wikipedia.org/wiki/DBSCAN)                                                        |
| [ST\_CONTAINS](<./Geospatial Functions/Spatial Relationships.md>)                                                     | Geospatial Spatial Relationships               | Returns TRUE if the first geographic argument, geo1, contains the second geographic argument, geo2.                                                                                                                                                                                  |
| [ST\_CONTAINSPROPERLY](<./Geospatial Functions/Spatial Relationships.md>)                                             | Geospatial Spatial Relationships               | Returns true if geo2 lies entirely in the interior of geo1, and does not intersect or touch the boundary or exterior points.                                                                                                                                                         |
| [ST\_CONVEXHULL](<./Geospatial Functions/Spatial Operators.md>)                                                       | Geospatial Spatial Operators                   | The convex hull is the smallest convex geometry that encloses the input geometry.                                                                                                                                                                                                    |
| [ST\_COORDDIM](<./Geospatial Functions/Attribute Functions.md>)                                                       | Geospatial Attribute Functions                 | Alias for ST\_NDIMS or ST\_NDIMENSION. Returns an INTEGER of the coordinate dimension of the specified geography.                                                                                                                                                                    |
| [ST\_COVEREDBY](<./Geospatial Functions/Spatial Relationships.md>)                                                    | Geospatial Spatial Relationships               | Returns TRUE if no POINT in geo1 is outside of geo2.                                                                                                                                                                                                                                 |
| [ST\_COVERS](<./Geospatial Functions/Spatial Relationships.md>)                                                       | Geospatial Spatial Relationships               | Returns TRUE if no POINT in geo2 is outside of geo1.                                                                                                                                                                                                                                 |
| [ST\_CROSSES](<./Geospatial Functions/Spatial Relationships.md>)                                                      | Geospatial Spatial Relationships               | Returns TRUE if two geospatial objects meet these criteria: The intersection of the geospatial interiors is not empty. The intersection is not equal to geo1 or geo2. Neither geospatial object is a single POINT.                                                                   |
| [ST\_DIFFERENCEARRAY](<./Geospatial Functions/Spatial Operators.md>)                                                  | Geospatial Spatial Operators                   | Returns an array containing any geospatial objects that are present in the first specified geospatial argument that are not found in the second geospatial argument.                                                                                                                 |
| [ST\_DIMENSION](<./Geospatial Functions/Attribute Functions.md>)                                                      | Geospatial Attribute Functions                 | Returns an INTEGER that represents the dimension of the specified geography.                                                                                                                                                                                                         |
| [ST\_DISJOINT](<./Geospatial Functions/Spatial Relationships.md>)                                                     | Geospatial Spatial Relationships               | Returns true if the specified geographies have no intersection, including boundaries. Both geographic arguments can be different types.                                                                                                                                              |
| [ST\_DISTANCE](<./Geospatial Functions/Spatial Measurement.md>) <br />                                                | Geospatial Spatial Measurement                 | Returns the minimum distance between the specified arguments.                                                                                                                                                                                                                        |
| [ST\_DISTANCE](<./Geospatial Functions/Spatiotemporal Measurement.md>)                                                | Geospatial Spatiotemporal Measurement          | Returns the two-dimensional interpolated minimum simultaneous distance between two LINESTRING-TIMESTAMP array pairs in the specified unit of measurement.                                                                                                                            |
| [ST\_DISTANCESPHERE](<./Geospatial Functions/Spatial Measurement.md>)                                                 | Geospatial Spatial Measurement                 | Returns the minimum distance between the specified arguments using a spherical computation.                                                                                                                                                                                          |
| [ST\_DISTANCESPHEROID](<./Geospatial Functions/Spatial Measurement.md>)                                               | Geospatial Spatial Measurement                 | Returns the minimum distance between the specified arguments using a spheroid computation.                                                                                                                                                                                           |
| [ST\_DWITHIN](<./Geospatial Functions/Spatial Relationships.md>)                                                      | Geospatial Spatial Relationships               | Returns TRUE if the geographies are within a specified distance in meters.                                                                                                                                                                                                           |
| [ST\_ENDPOINT](<./Geospatial Functions/Linestring Functions.md>)                                                      | Geospatial Linestring Function                 | Returns the endpoint of a specified LINESTRING. The returned value is a POINT.                                                                                                                                                                                                       |
| [ST\_ENVELOPE](<./Geospatial Functions/Spatial Operators.md>)                                                         | Geospatial Spatial Operators                   | Returns a POLYGON that represents the minimum bounding box for the specified geography.                                                                                                                                                                                              |
| [ST\_EQUALS](<./Geospatial Functions/Spatial Relationships.md>)                                                       | Geospatial Spatial Relationships               | Returns TRUE if both geographies are spatially equal.                                                                                                                                                                                                                                |
| [ST\_EUCLIDEANDISTANCE3D](<./Geospatial Functions/Spatial Measurement.md>)                                            | Geospatial Spatial Measurement                 | Returns the minimum distance between two geospatial points with altitude values.                                                                                                                                                                                                     |
| [ST\_EXPAND](<./Geospatial Functions/Spatial Operators.md>)                                                           | Geospatial Spatial Operators                   | Returns the bounding box of a specified geospatial value, which is expanded by a specified length.                                                                                                                                                                                   |
| [ST\_EXTERIORRING](<./Geospatial Functions/Spatial Operators.md>)                                                     | Geospatial Spatial Operators                   | Returns a LINESTRING that represents the exterior ring of a provided POLYGON value.                                                                                                                                                                                                  |
| [ST\_FLIPCOORDINATES](<./Geospatial Functions/Spatial Operators.md>)                                                  | Geospatial Spatial Operators                   | Returns a new geographic object with the X and Y coordinates switched using the specified argument.                                                                                                                                                                                  |
| [ST\_FORCE2D](<./Geospatial Functions/Spatial Operators.md>)                                                          | Geospatial Spatial Operators                   | Convert a geographic object into a two-dimensional geography.                                                                                                                                                                                                                        |
| [ST\_FORCECCW](<./Geospatial Functions/Polygon Constructors.md>)                                                      | Geospatial Polygon Constructors                | Creates a standardized polygon from an existing one. Ocient® defines standardized as the exterior being counterclockwise (CCW) and all holes being clockwise (CW) oriented.                                                                                                          |
| [ST\_GEOGPOINT](<./Geospatial Functions/Point Constructors.md>)                                                       | Geospatial Point Constructors                  | Creates and returns a POLYGON geography with a single point, defined by the longitude and latitude specified for the function.                                                                                                                                                       |
| [ST\_GEOHASH](<./Geospatial Functions/Conversion Functions.md>)                                                       | Geospatial Conversion Functions                | Returns a string that represents the geohash of the input POINT.                                                                                                                                                                                                                     |
| [ST\_GEOMETRYTYPE](<./Geospatial Functions/Attribute Functions.md>)                                                   | Geospatial Attribute Functions                 | Returns a string representing the geometry type of the input value.                                                                                                                                                                                                                  |
| [ST\_HAUSDORFFDISTANCE](<./Geospatial Functions/Spatial Measurement.md>)                                              | Geospatial Spatial Measurement                 | Returns the Hausdorff distance between two geographies in a specified measurement.                                                                                                                                                                                                   |
| [ST\_INTERIORRINGN](<./Geospatial Functions/Spatial Operators.md>)                                                    | Geospatial Spatial Operators                   | Returns a LINESTRING representing the interior ring of the specified POLYGON, which is specified by its index. (1-indexed)                                                                                                                                                           |
| [ST\_INTERSECTALL](<./Geospatial Functions/Spatial Operators.md>)                                                     | Geospatial Spatial Operators                   | Returns the intersection of all geographies in the specified array. All geographies in the array must be the same type.                                                                                                                                                              |
| [ST\_INTERSECTION](<./Geospatial Functions/Spatiotemporal Operators.md>)                                              | Geospatial Spatiotemporal Operators            | Returns a tuple that represents the intersection of a spatiotemporal LINESTRING with a static geography.                                                                                                                                                                             |
| [ST\_INTERSECTIONARRAY](<./Geospatial Functions/Spatial Operators.md>)                                                | Geospatial Spatial Operators                   | Returns a geography that represents the point-set intersection of two geographies.                                                                                                                                                                                                   |
| [ST\_INTERSECTS](<./Geospatial Functions/Spatial Relationships.md>)                                                   | Geospatial Spatial Relationships               | Returns TRUE if the specified geographies have an intersection, including boundaries.                                                                                                                                                                                                |
| [ST\_ISCCW](<./Geospatial Functions/Spatial Relationships.md>)                                                        | Geospatial Spatial Relationships               | Alias for ST\_ISPOLYGONCCW.                                                                                                                                                                                                                                                          |
| [ST\_ISCLOSED](<./Geospatial Functions/Spatial Relationships.md>)                                                     | Geospatial Spatial Relationships               | Returns TRUE if an input POLYGON has an exterior that is counter-clockwise.                                                                                                                                                                                                          |
| [ST\_ISEMPTY](<./Geospatial Functions/Attribute Functions.md>)                                                        | Geospatial Attribute Functions                 | Returns TRUE if the specified geography value is empty, such as 'POLYGON EMPTY'.                                                                                                                                                                                                     |
| [ST\_ISPOLYGONCCW](<./Geospatial Functions/Spatial Relationships.md>)                                                 | Geospatial Spatial Relationships               | Returns TRUE if an input LINESTRING has starting and ending points that are equal.                                                                                                                                                                                                   |
| [ST\_ISPOLYGONCW](<./Geospatial Functions/Spatial Relationships.md>)                                                  | Geospatial Spatial Relationships               | Returns TRUE if an input POLYGON has an exterior that is clockwise.                                                                                                                                                                                                                  |
| [ST\_ISRING](<./Geospatial Functions/Spatial Relationships.md>)                                                       | Geospatial Spatial Relationships               | Returns TRUE if the specified LINESTRING is closed and does not intersect itself.                                                                                                                                                                                                    |
| [ST\_ISSIMPLE](<./Geospatial Functions/Spatial Relationships.md>)                                                     | Geospatial Spatial Relationships               | For LINESTRING values, this function returns FALSE if any line segments intersect anywhere besides the endpoints. For POLYGON values, the function returns FALSE if either the exterior ring or any interior hole is not simple.                                                     |
| [ST\_ISVALID](<./Geospatial Functions/Spatial Relationships.md>)                                                      | Geospatial Spatial Relationships               | [Returns TRUE if the specified geospatial value is a well-formed and valid geography according to the OGC standards.](https://www.ogc.org/standard/sfa/)                                                                                                                             |
| [ST\_LENGTH](<./Geospatial Functions/Spatial Measurement.md>)                                                         | Geospatial Spatial Measurement                 | Returns the length of the specified line in the specified measurement unit.                                                                                                                                                                                                          |
| [ST\_LENGTH2D](<./Geospatial Functions/Spatial Measurement.md>)                                                       | Geospatial Spatial Measurement                 | Alias for ST\_LENGTH.                                                                                                                                                                                                                                                                |
| [ST\_LINEFROMEWKT](<./Geospatial Functions/Linestring Constructors.md>)                                               | Geospatial Linestring Constructor              | Creates a LINESTRING from the specified CHAR.                                                                                                                                                                                                                                        |
| [ST\_LINEFROMGEOJSON](<./Geospatial Functions/Linestring Constructors.md>)                                            | Geospatial Linestring Constructor              | Creates a LINESTRING represented by the specified GeoJSON.                                                                                                                                                                                                                           |
| [ST\_LINEFROMTEXT](<./Geospatial Functions/Linestring Constructors.md>)                                               | Geospatial Linestring Constructor              | Creates a LINESTRING from a specified CHAR. The CHAR must be a LINESTRING value in WKT format.                                                                                                                                                                                       |
| [ST\_LINEFROMWKB](<./Geospatial Functions/Linestring Constructors.md>)                                                | Geospatial Linestring Constructor              | Creates a LINESTRING from the specified BINARY. The BINARY value must be a LINESTRING in WKB format.                                                                                                                                                                                 |
| [ST\_LINEGETALLTIMESATPOINT](<./Geospatial Functions/Spatiotemporal Operators.md>)                                    | Geospatial Spatiotemporal Operators            | Returns a timestamp array of all times when the specified LINESTRING value intersects the specified POINT value.                                                                                                                                                                     |
| [ST\_LINEGETPOINTATTIME](<./Geospatial Functions/Spatiotemporal Operators.md>)                                        | Geospatial Spatiotemporal Operators            | Returns a POINT within the bounds of the specified LINESTRING that corresponds to the interpolated point at the specified TIMESTAMP value.                                                                                                                                           |
| [ST\_LINEGETTIMEATPOINT](<./Geospatial Functions/Spatiotemporal Operators.md>)                                        | Geospatial Spatiotemporal Operators            | Returns the interpolated time of the specified POINT on the specified LINESTRING that is paired with a TIMESTAMP ARRAY.                                                                                                                                                              |
| [ST\_LINEINTERPOLATEPOINT](<./Geospatial Functions/Linestring Functions.md>)                                          | Geospatial Linestring Function                 | Returns a POINT along a LINESTRING based on a specified fraction of its total length.                                                                                                                                                                                                |
| [ST\_LINELOCATEPOINT](<./Geospatial Functions/Linestring Functions.md>)                                               | Geospatial Linestring Function                 | Similar to ST\_LINEINTERPOLATEPOINT, this function computes a fraction based on where a specified POINT is located along the length of a specified LINESTRING.                                                                                                                       |
| [ST\_LINESTRING](<./Geospatial Functions/Linestring Constructors.md>)                                                 | Geospatial Linestring Constructor              | Creates a LINESTRING based on the specified inputs.                                                                                                                                                                                                                                  |
| [ST\_LINESUBSTRING](<./Geospatial Functions/Linestring Functions.md>)                                                 | Geospatial Linestring Function                 | Returns a LINESTRING that is a substring of a specified line that starts and ends at the specified fractions of its total length.                                                                                                                                                    |
| [ST\_LONGESTLINE](<./Geospatial Functions/Spatial Operators.md>)                                                      | Geospatial Spatial Operators                   | Returns the longest LINESTRING between two given geospatial arguments.                                                                                                                                                                                                               |
| [ST\_LONGESTLINE](<./Geospatial Functions/Spatiotemporal Operators.md>)                                               | Geospatial Spatiotemporal Operators            | With the specified two LINESTRING-TIMESTAMP ARRAY pairs, this function returns a two-point LINESTRING that represents the maximum distance between points at a concurrent time.                                                                                                      |
| [ST\_MAKEENVELOPE](<./Geospatial Functions/Spatial Operators.md>)                                                     | Geospatial Spatial Operators                   | Returns a POLYGON with vertices that represent the minimum bounding box for the specified coordinates.                                                                                                                                                                               |
| [ST\_MAKELINE](<./Geospatial Functions/Linestring Constructors.md>)                                                   | Geospatial Linestring Constructor              | Alias for ST\_LINESTRING.                                                                                                                                                                                                                                                            |
| [ST\_MAKEPOINT](<./Geospatial Functions/Point Constructors.md>)                                                       | Geospatial Point Constructors                  | Alias for ST\_POINT.                                                                                                                                                                                                                                                                 |
| [ST\_MAKEPOLYGON](<./Geospatial Functions/Polygon Constructors.md>)                                                   | Geospatial Polygon Constructors                | Alias for ST\_POLYGON.                                                                                                                                                                                                                                                               |
| [ST\_MAXDISTANCE](<./Geospatial Functions/Spatial Measurement.md>)                                                    | Geospatial Spatial Measurement                 | Returns maximum distance between the specified arguments.                                                                                                                                                                                                                            |
| [ST\_MAXDISTANCE](<./Geospatial Functions/Spatiotemporal Measurement.md>)                                             | Geospatial Spatiotemporal Measurement          | Returns the two-dimensional interpolated maximum cotemporal distance between two LINESTRING-TIMESTAMP array pairs in the specified unit of measurement.                                                                                                                              |
| [ST\_MEMSIZE](<./Geospatial Functions/Attribute Functions.md>)                                                        | Geospatial Attribute Functions                 | Returns an INTEGER representing the number of bytes in memory required to store the specified geography.                                                                                                                                                                             |
| [ST\_MINIMUMBOUNDINGCIRCLE](<./Geospatial Functions/Spatial Operators.md>)                                            | Geospatial Spatial Operators                   | Returns the smallest circle POLYGON that contains the specified geographic object.                                                                                                                                                                                                   |
| [ST\_MULTIDIFFERENCEARRAY](<./Geospatial Functions/Spatial Operators.md>)                                             | Geospatial Spatial Operators                   | Returns an array of geographies that represents the parts of the union of the geographies in the first array that do not intersect with the union of geographies in the second array.                                                                                                |
| [ST\_MINIMUMDISTANCETOSURFACE](<./Geospatial Functions/Spatial Measurement.md>)                                       | Geospatial Spatial Measurement                 | Calculates the shortest distance between any point along a Euclidean line segment in three-dimensional space and the surface of the Earth.                                                                                                                                           |
| [ST\_MULTIINTERSECTIONARRAY](<./Geospatial Functions/Spatial Operators.md>)                                           | Geospatial Spatial Operators                   | When you specify two arrays of geospatial objects, this function returns an array of any intersections.                                                                                                                                                                              |
| [ST\_MULTISYMDIFFERENCEARRAY](<./Geospatial Functions/Spatial Operators.md>)                                          | Geospatial Spatial Operators                   | When you specify two arrays of geospatial objects, this function returns an array of any geospatial values that do not intersect.                                                                                                                                                    |
| [ST\_MULTIUNIONARRAY](<./Geospatial Functions/Spatial Operators.md>)                                                  | Geospatial Spatial Operators                   | When you specify two arrays of geospatial objects, this function returns one array that represents a union of all geographies in both arrays.                                                                                                                                        |
| [ST\_NDIMENSION](<./Geospatial Functions/Attribute Functions.md>)                                                     | Geospatial Attribute Functions                 | Alias for ST\_COORDDIM.                                                                                                                                                                                                                                                              |
| [ST\_NDIMS](<./Geospatial Functions/Attribute Functions.md>)                                                          | Geospatial Attribute Functions                 | Alias for ST\_COORDDIM.                                                                                                                                                                                                                                                              |
| [ST\_NPOINTS](<./Geospatial Functions/Attribute Functions.md>)                                                        | Geospatial Attribute Functions                 | Returns an INTEGER representing the number of POINT values in a specified geography.                                                                                                                                                                                                 |
| [ST\_NRINGS](<./Geospatial Functions/Spatial Operators.md>)                                                           | Geospatial Spatial Operators                   | Returns the number of rings of the specified POLYGON, including both interior and exterior rings.                                                                                                                                                                                    |
| [ST\_NUMINTERIORRING](<./Geospatial Functions/Spatial Operators.md>)                                                  | Geospatial Spatial Operators                   | Returns the number of interior rings of the specified POLYGON.                                                                                                                                                                                                                       |
| [ST\_NUMINTERIORRINGS](<./Geospatial Functions/Spatial Operators.md>)                                                 | Geospatial Spatial Operators                   | Returns the number of interior rings of the specified POLYGON.                                                                                                                                                                                                                       |
| [ST\_NUMPOINTS](<./Geospatial Functions/Attribute Functions.md>)                                                      | Geospatial Attribute Functions                 | Returns an INTEGER representing the number of POINT values in a specified geography.                                                                                                                                                                                                 |
| [ST\_OVERLAPS](<./Geospatial Functions/Spatial Relationships.md>)                                                     | Geospatial Spatial Relationships               | Returns TRUE if both geographic arguments are of the same dimension and they intersect each other, but neither contains the other.                                                                                                                                                   |
| [ST\_PERIMETER](<./Geospatial Functions/Spatial Measurement.md>)                                                      | Geospatial Spatial Measurement                 | Returns the length of the exterior (outer ring) of the POLYGON in the specified unit of measurement.                                                                                                                                                                                 |
| [ST\_PERIMETER2D](<./Geospatial Functions/Spatial Measurement.md>)                                                    | Geospatial Spatial Measurement                 | Alias for ST\_PERIMETER.                                                                                                                                                                                                                                                             |
| [ST\_POINT](<./Geospatial Functions/Point Constructors.md>)                                                           | Geospatial Point Constructors                  | Creates a POINT from the specified input arguments.                                                                                                                                                                                                                                  |
| [ST\_POINTFROMEWKT](<./Geospatial Functions/Point Constructors.md>)                                                   | Geospatial Point Constructors                  | Alias for ST\_POINT. Creates a POINT using an EWKT-formatted CHAR as an input argument.                                                                                                                                                                                              |
| [ST\_POINTFROMGEOHASH](<./Geospatial Functions/Point Constructors.md>)                                                | Geospatial Point Constructors                  | Creates a POINT represented by the specified geohash.                                                                                                                                                                                                                                |
| [ST\_POINTFROMGEOJSON](<./Geospatial Functions/Point Constructors.md>)                                                | Geospatial Point Constructors                  | Creates a POINT represented by the specified GeoJSON value as an input argument.                                                                                                                                                                                                     |
| [ST\_POINTFROMTEXT](<./Geospatial Functions/Point Constructors.md>)                                                   | Geospatial Point Constructors                  | Alias for ST\_POINT(char).                                                                                                                                                                                                                                                           |
| [ST\_POINTFROMWKB](<./Geospatial Functions/Point Constructors.md>)                                                    | Geospatial Point Constructors                  | Alias for ST\_POINT(binary).                                                                                                                                                                                                                                                         |
| [ST\_POINTINSIDECIRCLE](<./Geospatial Functions/Spatial Relationships.md>)                                            | Geospatial Spatial Relationships               | Returns TRUE if the geographic object is inside a circle that is centered at the specified point coordinates and with the specified radius.                                                                                                                                          |
| [ST\_POINTN](<./Geospatial Functions/Linestring Functions.md>)                                                        | Geospatial Linestring Function                 | Returns the POINT value at a specified index of the given LINESTRING.                                                                                                                                                                                                                |
| [ST\_POINTONSURFACE](<./Geospatial Functions/Spatial Operators.md>)                                                   | Geospatial Spatial Operators                   | Returns a POINT guaranteed to intersect the specified geospatial object.                                                                                                                                                                                                             |
| [ST\_POLYGON](<./Geospatial Functions/Polygon Constructors.md>)                                                       | Geospatial Polygon Constructors                | Creates a POLYGON.                                                                                                                                                                                                                                                                   |
| [ST\_POLYGONFROMEWKT](<./Geospatial Functions/Polygon Constructors.md>)                                               | Geospatial Polygon Constructors                | Creates a POLYGON using an EWKT-formatted CHAR as an input argument. Alias for the ST\_POLYGON constructor.                                                                                                                                                                          |
| [ST\_POLYGONFROMGEOJSON](<./Geospatial Functions/Polygon Constructors.md>)                                            | Geospatial Polygon Constructors                | Creates a POLYGON from the specified POINT, POINT array, LINESTRING, or POLYGON geography.                                                                                                                                                                                           |
| [ST\_POLYGONFROMTEXT](<./Geospatial Functions/Polygon Constructors.md>)                                               | Geospatial Polygon Constructors                | Alias for ST\_POLYGON(char).                                                                                                                                                                                                                                                         |
| [ST\_POLYGONFROMWKB](<./Geospatial Functions/Polygon Constructors.md>)                                                | Geospatial Polygon Constructors                | Alias for ST\_POLYGON(binary).                                                                                                                                                                                                                                                       |
| [ST\_PROJECT](<./Geospatial Functions/Spatial Operators.md>)                                                          | Geospatial Spatial Operators                   | Returns a POINT by projecting a distance and an azimuth value from the specified starting POINT value.                                                                                                                                                                               |
| [ST\_REDUCEPRECISION](<./Geospatial Functions/Spatial Operators.md>)                                                  | Geospatial Spatial Operators                   | Returns a new geospatial object with all POINT values rounded to the specified decimal precision.                                                                                                                                                                                    |
| [ST\_RELATE](<./Geospatial Functions/Spatial Relationships.md>)                                                       | Geospatial Spatial Relationships               | Returns the [DE-9IM](https://postgis.net/workshops/postgis-intro/de9im.html) intersection string that represents the nature of the intersection with the specified geographies.                                                                                                      |
| [ST\_REMOVEPOINT](<./Geospatial Functions/Linestring Functions.md>)                                                   | Geospatial Linestring Functions                | Removes a POINT value at a specified index from the specified line.                                                                                                                                                                                                                  |
| [ST\_REMOVEREPEATEDPOINTS](<./Geospatial Functions/Spatial Operators.md>)                                             | Geospatial Spatial Operators                   | Returns a new geospatial object with no repeated POINT values.                                                                                                                                                                                                                       |
| [ST\_REVERSE](<./Geospatial Functions/Spatial Operators.md>)                                                          | Geospatial Spatial Operators                   | Returns a new geospatial object with the vertexes reversed.                                                                                                                                                                                                                          |
| [ST\_SEGMENTIZE](<./Geospatial Functions/Spatial Operators.md>)                                                       | Geospatial Spatial Operators                   | Returns a geospatial object that the function modifies to have no segment longer than the specified max\_segment\_length in meters.                                                                                                                                                  |
| [ST\_SETPOINT](<./Geospatial Functions/Linestring Functions.md>)                                                      | Geospatial Linestring Functions                | Replaces a POINT value in a given LINESTRING at a specified index. The function returns the altered LINESTRING with the replaced point.                                                                                                                                              |
| [ST\_SHORTESTLINE](<./Geospatial Functions/Spatial Operators.md>)                                                     | Geospatial Spatial Operators                   | Returns the shortest LINESTRING between two specified geospatial arguments.                                                                                                                                                                                                          |
| [ST\_SHORTESTLINE](<./Geospatial Functions/Spatiotemporal Operators.md>)                                              | Geospatial Spatiotemporal Operators            | When you specify two LINESTRING-TIMESTAMP ARRAY pairs, this function returns a LINESTRING with two points that represents the minimum distance between points at a concurrent time.                                                                                                  |
| [ST\_SIMPLIFY](<./Geospatial Functions/Spatial Operators.md>)                                                         | Geospatial Spatial Operators                   | Returns a simplified version of the specified geography, which is either a POINT or LINESTRING.                                                                                                                                                                                      |
| [ST\_SIMPLIFYARRAY](<./Geospatial Functions/Spatial Operators.md>)                                                    | Geospatial Spatial Operators                   | Returns a POLYGON array that represents a simplified version of the specified geography, which is either a POINT, LINESTRING, or POLYGON.                                                                                                                                            |
| [ST\_SNAPTOGRID](<./Geospatial Functions/Spatial Operators.md>)                                                       | Geospatial Spatial Operators                   | Returns a new geography value with all POINT values rounded to the specified precisions.                                                                                                                                                                                             |
| [ST\_SRID](<./Geospatial Functions/Attribute Functions.md>)                                                           | Geospatial Attribute Functions                 | Returns the EPSG code of the spatial reference identifier (SRID) of the input geography.                                                                                                                                                                                             |
| [ST\_STARTPOINT](<./Geospatial Functions/Linestring Functions.md>) <br />                                             | Geospatial Linestring Functions                | Returns the starting POINT value of the line.                                                                                                                                                                                                                                        |
| [ST\_SYMDIFFERENCEARRAY](<./Geospatial Functions/Spatial Operators.md>)                                               | Geospatial Spatial Operators                   | Returns a geographic array that contains the parts that are not common between two geographic objects, geo1 and geo2.                                                                                                                                                                |
| [ST\_TOTALSECONDSININTERSECTION](<./Geospatial Functions/Spatiotemporal Measurement.md>)                              | Geospatial Spatiotemporal Measurement          | Returns the total number of seconds spent in the intersection result calculated by the spatiotemporal version of ST\_INTERSECTION.                                                                                                                                                   |
| [ST\_TOUCHES](<./Geospatial Functions/Spatial Relationships.md>)                                                      | Geospatial Spatial Relationships               | Returns TRUE if the only POINT values in common between the two geographic arguments lie in the union of their boundaries.                                                                                                                                                           |
| [ST\_UNIONARRAY](<./Geospatial Functions/Spatial Operators.md>)                                                       | Geospatial Spatial Operators                   | Performs a union of the input geography values to produce a geographic array.                                                                                                                                                                                                        |
| [ST\_WHOLEEARTH](<./Geospatial Functions/Polygon Constructors.md>)                                                    | Geospatial Polygon Constructors                | Returns the database internal representation of the whole earth polygon.                                                                                                                                                                                                             |
| [ST\_WITHIN](<./Geospatial Functions/Spatial Relationships.md>)                                                       | Geospatial Spatial Relationships               | Alias for ST\_CONTAINS.                                                                                                                                                                                                                                                              |
| [ST\_X](<./Geospatial Functions/Attribute Functions.md>)                                                              | Geospatial Attribute Functions                 | Returns the x value of the specified POINT.                                                                                                                                                                                                                                          |
| [ST\_XMAX](<./Geospatial Functions/Attribute Functions.md>)                                                           | Geospatial Attribute Functions                 | Returns the maximum x value of the specified geography.                                                                                                                                                                                                                              |
| [ST\_XMIN](<./Geospatial Functions/Attribute Functions.md>)                                                           | Geospatial Attribute Functions                 | Returns the minimum x value of the specified geography.                                                                                                                                                                                                                              |
| [ST\_Y](<./Geospatial Functions/Attribute Functions.md>)                                                              | Geospatial Attribute Functions                 | Returns the y value of the specified POINT.                                                                                                                                                                                                                                          |
| [ST\_YMAX](<./Geospatial Functions/Attribute Functions.md>)                                                           | Geospatial Attribute Functions                 | Returns the maximum y value of specified geography.                                                                                                                                                                                                                                  |
| [ST\_YMIN](<./Geospatial Functions/Attribute Functions.md>)                                                           | Geospatial Attribute Functions                 | Returns the minimum y value of specified geography.                                                                                                                                                                                                                                  |
| [STARTSWITH](<./Character and Binary Functions.md>)                                                                   | Character and Binary Functions                 | Returns true if string starts with substring and false otherwise.                                                                                                                                                                                                                    |
| [STDEV](<./Aggregate Functions.md>)                                                                                   | Aggregate Functions                            | Sample standard deviation.                                                                                                                                                                                                                                                           |
| [STDDEV](<./Aggregate Functions.md>)                                                                                  | Aggregate Functions                            | Alias for STDEV.                                                                                                                                                                                                                                                                     |
| [STDDEV\_POP](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Alias for STDEVP.                                                                                                                                                                                                                                                                    |
| [STDDEV\_SAMP](<./Aggregate Functions.md>)                                                                            | Aggregate Functions                            | Alias for STDEV.                                                                                                                                                                                                                                                                     |
| [STDEVP](<./Aggregate Functions.md>)                                                                                  | Aggregate Functions                            | Population standard deviation.                                                                                                                                                                                                                                                       |
| [STRING\_AGG](<./Aggregate Functions.md>)                                                                             | Aggregate Functions                            | Returns a string concatenated from every row from the expression. The delimiter argument is optional.                                                                                                                                                                                |
| [STRING\_TO\_ARRAY](<./Array Functions and Operators.md>)                                                             | Array Functions                                | Converts the string representation of an array (e.g., `'int[1,2,NULL]'`) into an array.                                                                                                                                                                                              |
| [STRING\_TO\_TUPLE](<./Tuple Functions and Operators.md>)                                                             | Tuple Functions                                | Converts the string representation of a tuple (e.g `'tuple<<INT,BIGINT,CHAR>>(1,2,NULL)'`) into a tuple.                                                                                                                                                                             |
| [STRPOS](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | Equivalent to using LOCATE as `LOCATE(substring, string)`. Note the reversed argument order.                                                                                                                                                                                         |
| [SUBSTR](<./Character and Binary Functions.md>)                                                                       | Character and Binary Functions                 | Alias for SUBSTRING.                                                                                                                                                                                                                                                                 |
| [SUBSTRING](<./Character and Binary Functions.md>)                                                                    | Character and Binary Functions                 | Returns the substring of a character or binary value.                                                                                                                                                                                                                                |
| [SUBNET](<./Network Type Functions.md>)                                                                               | Network Type Functions                         | Computes the prefix from an `IP` or `IPV4` value and the size of the prefix.                                                                                                                                                                                                         |
| [SUM](<./Aggregate Functions.md>)                                                                                     | Aggregate Functions                            | Sum over the set.                                                                                                                                                                                                                                                                    |
| [SVD\_DECOMP](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns SVD decomposition of a matrix as a tuple of 3 matrices.                                                                                                                                                                                                                      |
| [TAN](<./Math Functions and Operators.md>)                                                                            | Math Functions                                 | Returns the tangent of x.                                                                                                                                                                                                                                                            |
| [TANH](<./Math Functions and Operators.md>)                                                                           | Math Functions                                 | Returns the hyperbolic tangent of x.                                                                                                                                                                                                                                                 |
| [TIME](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Parses the string to create a time value. The string must be in the form `'HH:MM[.SSSSSSSSS]'`.                                                                                                                                                                                      |
| [TIMESTAMP](<./Scalar Data Conversion Functions.md>)                                                                  | Scalar Data Conversion Functions               | Parses a string and makes a timestamp value. The string must be in the format `'YYYY-MM-DD[ HH:MM][.SSSSSSSSS]'`.                                                                                                                                                                    |
| [TIMESTAMP\_TO\_NANOS](<./Date and Time Functions.md>)                                                                | Date and Time Functions                        | Convert timestamp into nanoseconds after epoch as BIGINT.                                                                                                                                                                                                                            |
| [TO\_ARRAY\_LENGTH](<././Load Data/Transform Data in Data Pipelines.md>)                                              | Special Data Pipeline Transformation Functions | Create the specified number of copies of any JSON object in an array.                                                                                                                                                                                                                |
| [TO\_BASE](<./Math Functions and Operators.md>)                                                                       | Math Functions                                 | Converts an integer value to its string representation in a specified base (radix).                                                                                                                                                                                                  |
| [TO\_CHAR](<./Character and Binary Functions.md>)                                                                     | Character and Binary Functions                 | Converts a numeric, date, or timestamp value into a CHAR date type.                                                                                                                                                                                                                  |
| [TO\_DATE](<./Formatting Functions.md>)                                                                               | Formatting Functions                           | Converts a character value with the specified format to a DATE type.                                                                                                                                                                                                                 |
| [TO\_NUMBER](<./Formatting Functions.md>)                                                                             | Formatting Functions                           | Converts a character value with the specified format to a DECIMAL type.                                                                                                                                                                                                              |
| [TO\_TIMESTAMP](<./Formatting Functions.md>)                                                                          | Formatting Functions                           | Converts a character value with the specified format to a TIMESTAMP type.                                                                                                                                                                                                            |
| [TRANSFORM](<././Load Data/Transform Data in Data Pipelines.md>)                                                      | Special Data Pipeline Transformation Functions | Transforms an array based on the logic in a lambda expression.                                                                                                                                                                                                                       |
| [TRANSLATE](<./Character and Binary Functions.md>)                                                                    | Character and Binary Functions                 | Replaces specified characters in a provided string with a separate set of characters.                                                                                                                                                                                                |
| [TRANSPOSE](<./Matrix Functions and Operators.md>)                                                                    | Matrix Functions                               | Returns transpose of the matrix.                                                                                                                                                                                                                                                     |
| [TRIM](<./Character and Binary Functions.md>)                                                                         | Character and Binary Functions                 | Alias for BTRIM. Trim leading and trailing blanks from the string.                                                                                                                                                                                                                   |
| [TRUNC](<./Math Functions and Operators.md>)                                                                          | Math Functions                                 | Returns x truncated to y decimal places.                                                                                                                                                                                                                                             |
| [TRUNCATE](<./Math Functions and Operators.md>)                                                                       | Math Functions                                 | Alias for TRUNC.                                                                                                                                                                                                                                                                     |
| [TUPLE()](<./Tuple Functions and Operators.md>)                                                                       | Tuple Functions                                | Construct a tuple with the specified elements. Types of the tuple are inferred from the inner elements.                                                                                                                                                                              |
| [TUPLE\<\<>>](<./Tuple Functions and Operators.md>)                                                                   | Tuple Functions                                | Construct a tuple with the specified elements. NULL is also supported as an element.                                                                                                                                                                                                 |
| [TYPE\[\]](<./Array Functions and Operators.md>)                                                                      | Array Functions                                | Construct an array of SQL type TYPE giving the elements.                                                                                                                                                                                                                             |
| [UCASE](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Alias for UPPER.                                                                                                                                                                                                                                                                     |
| [UNNEST](<./Array Functions and Operators.md>)                                                                        | Array Functions                                | Expand each element in an input array out to an individual row.                                                                                                                                                                                                                      |
| [UPPER](<./Character and Binary Functions.md>)                                                                        | Character and Binary Functions                 | Convert string to upper case.                                                                                                                                                                                                                                                        |
| [USECS](<./Date and Time Functions.md>)                                                                               | Date and Time Functions                        | The seconds part of a time value, including fractional parts, returned as an integer. The function multiplies the seconds part of the value by 1,000,000.                                                                                                                            |
| [UUID](<./Scalar Data Conversion Functions.md>)                                                                       | Scalar Data Conversion Functions               | Parses the string and makes a Universally Unique IDentifier (UUID) value. The string must be a valid UUID.                                                                                                                                                                           |
| [UUID\_GENERATE](<./Other Functions and Expressions.md>)                                                              | Other Functions and Expressions                | Generates a random UUID value (version 4).                                                                                                                                                                                                                                           |
| [VAR\_POP](<./Aggregate Functions.md>)                                                                                | Aggregate Functions                            | Alias for VARIANCEP.                                                                                                                                                                                                                                                                 |
| [VAR\_SAMP](<./Aggregate Functions.md>)                                                                               | Aggregate Functions                            | Alias for VARIANCE.                                                                                                                                                                                                                                                                  |
| [VARIANCE](<./Aggregate Functions.md>)                                                                                | Aggregate Functions                            | Sample variance.                                                                                                                                                                                                                                                                     |
| [VARIANCEP](<./Aggregate Functions.md>)                                                                               | Aggregate Functions                            | Population variance.                                                                                                                                                                                                                                                                 |
| [VECTOR\_ARGMAX](<./Matrix Functions and Operators.md>)                                                               | Matrix Functions                               | Returns the argmax of a one-dimensional matrix or vector.                                                                                                                                                                                                                            |
| [VECTOR\_ARGMIN](<./Matrix Functions and Operators.md>)                                                               | Matrix Functions                               | Returns the argmin of a one-dimensional matrix or vector.                                                                                                                                                                                                                            |
| [VECTOR\_MAX](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns the maximum of elements in a one-dimensional matrix/vector.                                                                                                                                                                                                                  |
| [VECTOR\_MIN](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns the minimum of elements in a one-dimensional matrix/vector.                                                                                                                                                                                                                  |
| [VECTOR\_SUM](<./Matrix Functions and Operators.md>)                                                                  | Matrix Functions                               | Returns the sum of elements in a one-dimensional matrix/vector.                                                                                                                                                                                                                      |
| [VERSION](<./Other Functions and Expressions.md>)                                                                     | System Functions                               | Returns the version of the database to which the client is currently connected.                                                                                                                                                                                                      |
| [WEEK](<./Date and Time Functions.md>)                                                                                | Date and Time Functions                        | Returns the ISO-8601 week number, as an integer, of the specified timestamp or date value.                                                                                                                                                                                           |
| [WEEKS](<./Scalar Data Conversion Functions.md>)                                                                      | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type weeks to be used in date calculations.                                                                                                                                                                                       |
| [WIDTH\_BUCKET](<././Load Data/Transform Data in Data Pipelines.md>)                                                  | Special Data Pipeline Transformation Functions | Creates `N` equal-width buckets in the range `[min,max)` as a histogram.                                                                                                                                                                                                             |
| [YEAR](<./Date and Time Functions.md>)                                                                                | Date and Time Functions                        | Extracts the year portion of a timestamp or date as an integer.                                                                                                                                                                                                                      |
| [YEARS](<./Scalar Data Conversion Functions.md>)                                                                      | Scalar Data Conversion Functions               | Converts an integral value to an interval value of type years.                                                                                                                                                                                                                       |
| [ZERO\_MATRIX](<./Matrix Functions and Operators.md>)                                                                 | Matrix Functions                               | Returns a zero matrix of the specified (row, col) dimensions.                                                                                                                                                                                                                        |
| [ZIP\_WITH](<././Load Data/Transform Data in Data Pipelines.md>)                                                      | Special Data Pipeline Transformation Functions | Merges two or more input arrays, element-wise, into a single array using the trailing combining function.                                                                                                                                                                            |
| [ZN](<./Other Functions and Expressions.md>)                                                                          | Conditional Functions                          | If x is NULL, returns 0. Otherwise, returns x.                                                                                                                                                                                                                                       |
| [ZSCORE](<./Window Aggregate Functions.md>)                                                                           | Window Aggregate Functions                     | Zscore of the sample based on the `stddev()` function.                                                                                                                                                                                                                               |
| [ZSCOREP](<./Window Aggregate Functions.md>)                                                                          | Window Aggregate Functions                     | Zscore of the sample based on the `stddevp()` function.                                                                                                                                                                                                                              |

