{
    "functions": [
        {
            "name": "POWER",
            "description": "Function: `POWER`\n\nType: Arithmetic Function\n\nUsage: `POWER(numeric1, numeric2)`\n\nDescription:  NUMERIC1.power(NUMERIC2)\n\n"
        },
        {
            "name": "ABS",
            "description": "Function: `ABS`\n\nType: Arithmetic Function\n\nUsage: `ABS(numeric)`\n\nDescription:  Returns the absolute value of numeric.\n\n"
        },
        {
            "name": "SQRT",
            "description": "Function: `SQRT`\n\nType: Arithmetic Function\n\nUsage: `SQRT(numeric)`\n\nDescription:  Returns the square root of NUMERIC.\n\n"
        },
        {
            "name": "LN",
            "description": "Function: `LN`\n\nType: Arithmetic Function\n\nUsage: `LN(numeric)`\n\nDescription:  Returns the natural logarithm (base e) of NUMERIC.\n\n"
        },
        {
            "name": "LOG10",
            "description": "Function: `LOG10`\n\nType: Arithmetic Function\n\nUsage: `LOG10(numeric)`\n\nDescription:  Returns the base 10 logarithm of numeric.\n\n"
        },
        {
            "name": "LOG2",
            "description": "Function: `LOG2`\n\nType: Arithmetic Function\n\nUsage: `LOG2(numeric)`\n\nDescription:  Returns the base 2 logarithm of numeric.\n\n"
        },
        {
            "name": "LOG",
            "description": "Function: `LOG`\n\nType: Arithmetic Function\n\nUsage: `LOG(numeric2)` | `LOG(numeric1, numeric2)`\n\nDescription:  When called with one argument, returns the natural logarithm of numeric2\\. When called with two arguments, this function returns the logarithm of numeric2 to the base numeric1\\. Currently, numeric2 must be greater than 0 and numeric1 must be greater than 1.\n\n"
        },
        {
            "name": "EXP",
            "description": "Function: `EXP`\n\nType: Arithmetic Function\n\nUsage: `EXP(numeric)`\n\nDescription:  Returns e raised to the power of numeric.\n\n"
        },
        {
            "name": "CEIL",
            "description": "Function: `CEIL`\n\nType: Arithmetic Function\n\nUsage: `CEIL(numeric)`\n\nDescription:  Rounds numeric up, and returns the smallest number that is greater than or equal to numeric.\n\n"
        },
        {
            "name": "CEILING",
            "description": "Function: `CEILING`\n\nType: Arithmetic Function\n\nUsage: `CEILING(numeric)`\n\nDescription:  Rounds numeric up, and returns the smallest number that is greater than or equal to numeric.\n\n"
        },
        {
            "name": "FLOOR",
            "description": "Function: `FLOOR`\n\nType: Arithmetic Function\n\nUsage: `FLOOR(numeric)`\n\nDescription:  Rounds numeric down, and returns the largest number that is less than or equal to numeric.\n\n"
        },
        {
            "name": "SIN",
            "description": "Function: `SIN`\n\nType: Arithmetic Function\n\nUsage: `SIN(numeric)`\n\nDescription:  Returns the sine of numeric.\n\n"
        },
        {
            "name": "SINH",
            "description": "Function: `SINH`\n\nType: Arithmetic Function\n\nUsage: `SINH(numeric)`\n\nDescription:  Returns the hyperbolic sine of numeric. The return type is DOUBLE.\n\n"
        },
        {
            "name": "COS",
            "description": "Function: `COS`\n\nType: Arithmetic Function\n\nUsage: `COS(numeric)`\n\nDescription:  Returns the cosine of numeric.\n\n"
        },
        {
            "name": "TAN",
            "description": "Function: `TAN`\n\nType: Arithmetic Function\n\nUsage: `TAN(numeric)`\n\nDescription:  Returns the tangent of numeric.\n\n"
        },
        {
            "name": "TANH",
            "description": "Function: `TANH`\n\nType: Arithmetic Function\n\nUsage: `TANH(numeric)`\n\nDescription:  Returns the hyperbolic tangent of numeric. The return type is DOUBLE.\n\n"
        },
        {
            "name": "COT",
            "description": "Function: `COT`\n\nType: Arithmetic Function\n\nUsage: `COT(numeric)`\n\nDescription:  Returns the cotangent of a numeric.\n\n"
        },
        {
            "name": "ASIN",
            "description": "Function: `ASIN`\n\nType: Arithmetic Function\n\nUsage: `ASIN(numeric)`\n\nDescription:  Returns the arc sine of numeric.\n\n"
        },
        {
            "name": "ACOS",
            "description": "Function: `ACOS`\n\nType: Arithmetic Function\n\nUsage: `ACOS(numeric)`\n\nDescription:  Returns the arc cosine of numeric.\n\n"
        },
        {
            "name": "ATAN",
            "description": "Function: `ATAN`\n\nType: Arithmetic Function\n\nUsage: `ATAN(numeric)`\n\nDescription:  Returns the arc tangent of numeric.\n\n"
        },
        {
            "name": "ATAN2",
            "description": "Function: `ATAN2`\n\nType: Arithmetic Function\n\nUsage: `ATAN2(numeric1, numeric2)`\n\nDescription:  Returns the arc tangent of a coordinate (NUMERIC1, NUMERIC2).\n\n"
        },
        {
            "name": "COSH",
            "description": "Function: `COSH`\n\nType: Arithmetic Function\n\nUsage: `COSH(numeric)`\n\nDescription:  Returns the hyperbolic cosine of NUMERIC. Return value type is DOUBLE.\n\n"
        },
        {
            "name": "DEGREES",
            "description": "Function: `DEGREES`\n\nType: Arithmetic Function\n\nUsage: `DEGREES(numeric)`\n\nDescription:  Returns the degree representation of a radian NUMERIC.\n\n"
        },
        {
            "name": "RADIANS",
            "description": "Function: `RADIANS`\n\nType: Arithmetic Function\n\nUsage: `RADIANS(numeric)`\n\nDescription:  Returns the radian representation of a degree NUMERIC.\n\n"
        },
        {
            "name": "SIGN",
            "description": "Function: `SIGN`\n\nType: Arithmetic Function\n\nUsage: `SIGN(numeric)`\n\nDescription:  Returns the signum of NUMERIC.\n\n"
        },
        {
            "name": "ROUND",
            "description": "Function: `ROUND`\n\nType: Arithmetic Function\n\nUsage: `ROUND(NUMERIC, INT)`\n\nDescription:  Returns a number rounded to INT decimal places for NUMERIC.\n\n"
        },
        {
            "name": "PI",
            "description": "Function: `PI`\n\nType: Arithmetic Function\n\nUsage: `PI()`\n\nDescription:  Returns a value that is closer than any other values to pi.\n\n"
        },
        {
            "name": "E",
            "description": "Function: `E`\n\nType: Arithmetic Function\n\nUsage: `E()`\n\nDescription:  Returns a value that is closer than any other values to e.\n\n"
        },
        {
            "name": "RAND",
            "description": "Function: `RAND`\n\nType: Arithmetic Function\n\nUsage: `RAND()`\n\nDescription:  Returns a pseudorandom double value in the range \\[0.0, 1.0)\n\n"
        },
        {
            "name": "RAND",
            "description": "Function: `RAND`\n\nType: Arithmetic Function\n\nUsage: `RAND(INT)`\n\nDescription:  Returns a pseudorandom double value in the range \\[0.0, 1.0) with an initial seed integer. Two RAND functions will return identical sequences of numbers if they have the same initial seed.\n\n"
        },
        {
            "name": "RAND_INTEGER",
            "description": "Function: `RAND_INTEGER`\n\nType: Arithmetic Function\n\nUsage: `RAND_INTEGER(INT)`\n\nDescription:  Returns a pseudorandom integer value in the range \\[0, INT)\n\n"
        },
        {
            "name": "RAND_INTEGER",
            "description": "Function: `RAND_INTEGER`\n\nType: Arithmetic Function\n\nUsage: `RAND_INTEGER(INT1, INT2)`\n\nDescription:  Returns a pseudorandom integer value in the range \\[0, INT2) with an initial seed INT1\\. Two RAND\\_INTGER functions will return idential sequences of numbers if they have the same initial seed and bound.\n\n"
        },
        {
            "name": "UUID",
            "description": "Function: `UUID`\n\nType: Arithmetic Function\n\nUsage: `UUID()`\n\nDescription:  Returns an UUID (Universally Unique Identifier) string (e.g., “3d3c68f7-f608-473f-b60c-b0c44ad4cc4e”) according to RFC 4122 type 4 (pseudo randomly generated) UUID. The UUID is generated using a cryptographically strong pseudo random number generator.\n\n"
        },
        {
            "name": "BIN",
            "description": "Function: `BIN`\n\nType: Arithmetic Function\n\nUsage: `BIN(INT)`\n\nDescription:  Returns a string representation of INTEGER in binary format. Returns NULL if INTEGER is NULL. E.g., 4.bin() returns “100” and 12.bin() returns “1100”.\n\n"
        },
        {
            "name": "HEX",
            "description": "Function: `HEX`\n\nType: Arithmetic Function\n\nUsage: `HEX(numeric)` | `HEX(string)`\n\nDescription:  Returns a string representation of an integer NUMERIC value or a STRING in hex format. Returns NULL if the argument is NULL. E.g. a numeric 20 leads to “14”, a numeric 100 leads to “64”, a string “hello,world” leads to “68656C6C6F2C776F726C64”.\n\n"
        },
        {
            "name": "TRUNCATE",
            "description": "Function: `TRUNCATE`\n\nType: Arithmetic Function\n\nUsage: `TRUNCATE(numeric1, integer2)`\n\nDescription:  Returns a numeric of truncated to integer2 decimal places. Returns NULL if numeric1 or integer2 is NULL. If integer2 is 0, the result has no decimal point or fractional part. integer2 can be negative to cause integer2 digits left of the decimal point of the value to become zero. This function can also pass in only one numeric1 parameter and not set integer2 to use. If integer2 is not set, the function truncates as if integer2 were 0\\. E.g. 42.324.truncate(2) to 42.32\\. and 42.324.truncate() to 42.0.\n\n"
        },
        {
            "name": "CHAR_LENGTH",
            "description": "Function: `CHAR_LENGTH`\n\nType: String Function\n\nUsage: `CHAR_LENGTH(string)`\n\nDescription:  Returns the number of characters in STRING.\n\n"
        },
        {
            "name": "CHARACTER_LENGTH",
            "description": "Function: `CHARACTER_LENGTH`\n\nType: String Function\n\nUsage: `CHARACTER_LENGTH(string)`\n\nDescription:  Returns the number of characters in STRING.\n\n"
        },
        {
            "name": "UPPER",
            "description": "Function: `UPPER`\n\nType: String Function\n\nUsage: `UPPER(string)`\n\nDescription:  Returns STRING in uppercase.\n\n"
        },
        {
            "name": "LOWER",
            "description": "Function: `LOWER`\n\nType: String Function\n\nUsage: `LOWER(string)`\n\nDescription:  Returns string in lowercase.\n\n"
        },
        {
            "name": "POSITION",
            "description": "Function: `POSITION`\n\nType: String Function\n\nUsage: `POSITION(string1 IN string2)`\n\nDescription:  Returns the position (start from 1) of the first occurrence of STRING1 in STRING2; returns 0 if STRING1 cannot be found in STRING2.\n\n"
        },
        {
            "name": "TRIM",
            "description": "Function: `TRIM`\n\nType: String Function\n\nUsage: `TRIM([ BOTH | LEADING | TRAILING ] string1 FROM string2)`\n\nDescription:  Returns a string that removes leading and/or trailing characters STRING2 from STRING1\\. By default, whitespaces at both sides are removed.\n\n"
        },
        {
            "name": "LTRIM",
            "description": "Function: `LTRIM`\n\nType: String Function\n\nUsage: `LTRIM(string)`\n\nDescription:  Returns a string that removes the left whitespaces from STRING. E.g., ’ This is a test String.’.ltrim() returns “This is a test String.”.\n\n"
        },
        {
            "name": "RTRIM",
            "description": "Function: `RTRIM`\n\nType: String Function\n\nUsage: `RTRIM(string)`\n\nDescription:  Returns a string that removes the right whitespaces from STRING. E.g., ‘This is a test String. ‘.rtrim() returns “This is a test String.”.\n\n"
        },
        {
            "name": "REPEAT",
            "description": "Function: `REPEAT`\n\nType: String Function\n\nUsage: `REPEAT(string, int)`\n\nDescription:  Returns a string that repeats the base string integer times. E.g., REPEAT(‘This is a test String.’, 2) returns “This is a test String.This is a test String.”.\n\n"
        },
        {
            "name": "REGEXP_REPLACE",
            "description": "Function: `REGEXP_REPLACE`\n\nType: String Function\n\nUsage: `REGEXP_REPLACE(string1, string2, string3)`\n\nDescription:  Returns a string from STRING1 with all the substrings that match a regular expression STRING2 consecutively being replaced with STRING3\\. E.g., ‘foobar’.regexpReplace(‘oo|ar’, ‘’) returns “fb”.\n\n"
        },
        {
            "name": "OVERLAY",
            "description": "Function: `OVERLAY`\n\nType: String Function\n\nUsage: `OVERLAY(string1 PLACING string2 FROM integer1 [ FOR integer2 ])`\n\nDescription:  Returns a string that replaces INT2 (STRING2’s length by default) characters of STRING1 with STRING2 from position INT1\\. E.g., ‘xxxxxtest’.overlay(‘xxxx’, 6) returns “xxxxxxxxx”; ‘xxxxxtest’.overlay(‘xxxx’, 6, 2) returns “xxxxxxxxxst”.\n\n"
        },
        {
            "name": "SUBSTRING",
            "description": "Function: `SUBSTRING`\n\nType: String Function\n\nUsage: `SUBSTRING(string FROM integer1 [ FOR integer2 ])`\n\nDescription:  Returns a substring of STRING starting from position INT1 with length INT2 (to the end by default).\n\n"
        },
        {
            "name": "REPLACE",
            "description": "Function: `REPLACE`\n\nType: String Function\n\nUsage: `REPLACE(string1, string2, string3)`\n\nDescription:  Returns a new string which replaces all the occurrences of STRING2 with STRING3 (non-overlapping) from STRING1\\. E.g., ‘hello world’.replace(‘world’, ‘flink’) returns ‘hello flink’; ‘ababab’.replace(‘abab’, ‘z’) returns ‘zab’.\n\n"
        },
        {
            "name": "REGEXP_EXTRACT",
            "description": "Function: `REGEXP_EXTRACT`\n\nType: String Function\n\nUsage: `REGEXP_EXTRACT(string1, string2[, integer])`\n\nDescription: Returns a string from string1 which extracted with a specified regular expression string2 and a regex match group index integer.\n\nThe regex match group index starts from 1 and 0 means matching the whole regex. In addition, the regex match group index should not exceed the number of the defined groups.\n\nE.g. REGEXP\\_EXTRACT(‘foothebar’, ‘foo(.\\*?)(bar)’, 2)\" returns “bar”.\n\n"
        },
        {
            "name": "INITCAP",
            "description": "Function: `INITCAP`\n\nType: String Function\n\nUsage: `INITCAP(string)`\n\nDescription:  Returns a new form of STRING with the first character of each word converted to uppercase and the rest characters to lowercase. Here a word means a sequences of alphanumeric characters.\n\n"
        },
        {
            "name": "CONCAT",
            "description": "Function: `CONCAT`\n\nType: String Function\n\nUsage: `CONCAT(string1, string2,…)`\n\nDescription:  Returns a string that concatenates string1, string2, …. Returns NULL if any argument is NULL. E.g., CONCAT(‘AA’, ‘BB’, ‘CC’) returns “AABBCC”.\n\n"
        },
        {
            "name": "CONCAT_WS",
            "description": "Function: `CONCAT_WS`\n\nType: String Function\n\nUsage: `CONCAT_WS(string1, string2, string3,…)`\n\nDescription:  Returns a string that concatenates STRING2, STRING3, … with a separator STRING1\\. The separator is added between the strings to be concatenated. Returns NULL If STRING1 is NULL. Compared with concat(), concat\\_ws() automatically skips NULL arguments. E.g., concat\\_ws(’\\~’, ‘AA’, Null(STRING), ‘BB’, ‘’, ‘CC’) returns “AA\\~BB\\~\\~CC”.\n\n"
        },
        {
            "name": "LPAD",
            "description": "Function: `LPAD`\n\nType: String Function\n\nUsage: `LPAD(string1, integer, string2)`\n\nDescription:  Returns a new string from string1 left-padded with string2 to a length of integer characters. If the length of string1 is shorter than integer, returns string1 shortened to integer characters. E.g., LPAD(‘hi’, 4, ‘??’) returns “??hi”; LPAD(‘hi’, 1, ‘??’) returns “h”.\n\n"
        },
        {
            "name": "RPAD",
            "description": "Function: `RPAD`\n\nType: String Function\n\nUsage: `RPAD(string1, integer, string2)`\n\nDescription:  Returns a new string from string1 right-padded with string2 to a length of integer characters. If the length of string1 is shorter than integer, returns string1 shortened to integer characters. E.g., RPAD(‘hi’, 4, ‘??’) returns “hi??”, RPAD(‘hi’, 1, ‘??’) returns “h”.\n\n"
        },
        {
            "name": "FROM_BASE64",
            "description": "Function: `FROM_BASE64`\n\nType: String Function\n\nUsage: `FROM_BASE64(string)`\n\nDescription:  Returns the base64-decoded result from string; returns NULL if string is NULL. E.g., FROM\\_BASE64(‘aGVsbG8gd29ybGQ=’) returns “hello world”.\n\n"
        },
        {
            "name": "TO_BASE64",
            "description": "Function: `TO_BASE64`\n\nType: String Function\n\nUsage: `TO_BASE64(string)`\n\nDescription:  Returns the base64-encoded result from string; returns NULL if string is NULL. E.g., TO\\_BASE64(‘hello world’) returns “aGVsbG8gd29ybGQ=”.\n\n"
        },
        {
            "name": "ASCII",
            "description": "Function: `ASCII`\n\nType: String Function\n\nUsage: `ASCII(string)`\n\nDescription:  Returns the numeric value of the first character of string. Returns NULL if string is NULL. E.g., ascii(‘abc’) returns 97, and ascii(CAST(NULL AS VARCHAR)) returns NULL.\n\n"
        },
        {
            "name": "CHR",
            "description": "Function: `CHR`\n\nType: String Function\n\nUsage: `CHR(integer)`\n\nDescription:  Returns the ASCII character having the binary equivalent to integer. If integer is larger than 255, we will get the modulus of integer divided by 255 first, and returns CHR of the modulus. Returns NULL if integer is NULL. E.g., chr(97) returns a, chr(353) returns a, and ascii(CAST(NULL AS VARCHAR)) returns NULL.\n\n"
        },
        {
            "name": "DECODE",
            "description": "Function: `DECODE`\n\nType: String Function\n\nUsage: `DECODE(binary, string)`\n\nDescription:  Decodes the first argument into a String using the provided character set (one of ‘US-ASCII’, ‘ISO-8859-1’, ‘UTF-8’, ‘UTF-16BE’, ‘UTF-16LE’, ‘UTF-16’). If either argument is null, the result will also be null.\n\n"
        },
        {
            "name": "ENCODE",
            "description": "Function: `ENCODE`\n\nType: String Function\n\nUsage: `ENCODE(string1, string2)`\n\nDescription:  Encodes the string1 into a BINARY using the provided string2 character set (one of ‘US-ASCII’, ‘ISO-8859-1’, ‘UTF-8’, ‘UTF-16BE’, ‘UTF-16LE’, ‘UTF-16’). If either argument is null, the result will also be null.\n\n"
        },
        {
            "name": "INSTR",
            "description": "Function: `INSTR`\n\nType: String Function\n\nUsage: `INSTR(string1, string2)`\n\nDescription:  Returns the position of the first occurrence of string2 in string1\\. Returns NULL if any of arguments is NULL.\n\n"
        },
        {
            "name": "LEFT",
            "description": "Function: `LEFT`\n\nType: String Function\n\nUsage: `LEFT(string, integer)`\n\nDescription:  Returns the leftmost integer characters from the string. Returns EMPTY String if integer is negative. Returns NULL if any argument is NULL.\n\n"
        },
        {
            "name": "RIGHT",
            "description": "Function: `RIGHT`\n\nType: String Function\n\nUsage: `RIGHT(string, integer)`\n\nDescription:  Returns the rightmost integer characters from the string. Returns EMPTY String if integer is negative. Returns NULL if any argument is NULL.\n\n"
        },
        {
            "name": "LOCATE",
            "description": "Function: `LOCATE`\n\nType: String Function\n\nUsage: `LOCATE(string1, string2[, integer])`\n\nDescription:  Returns the position of the first occurrence of string1 in string2 after position integer. Returns 0 if not found. Returns NULL if any of arguments is NULL.\n\n"
        },
        {
            "name": "PARSE_URL",
            "description": "Function: `PARSE_URL`\n\nType: String Function\n\nUsage: `PARSE_URL(string1, string2[, string3])`\n\nDescription: Returns the specified part from the URL. Valid values for string2 include ‘HOST’, ‘PATH’, ‘QUERY’, ‘REF’, ‘PROTOCOL’, ‘AUTHORITY’, ‘FILE’, and ‘USERINFO’. Returns NULL if any of arguments is NULL.\n\nE.g., parse\\_url(‘[http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1'](http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1%27), ‘HOST’), returns ‘facebook.com’.\n\nAlso a value of a particular key in QUERY can be extracted by providing the key as the third argument string3.\n\nE.g., parse\\_url(‘[http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1'](http://facebook.com/path1/p.php?k1=v1&k2=v2#Ref1%27), ‘QUERY’, ‘k1’) returns ‘v1’.\n\n"
        },
        {
            "name": "REGEXP",
            "description": "Function: `REGEXP`\n\nType: String Function\n\nUsage: `REGEXP(string1, string2)`\n\nDescription:  Returns TRUE if any (possibly empty) substring of string1 matches the Java regular expression string2, otherwise FALSE. Returns NULL if any of arguments is NULL.\n\n"
        },
        {
            "name": "REVERSE",
            "description": "Function: `REVERSE`\n\nType: String Function\n\nUsage: `REVERSE(string)`\n\nDescription:  Returns the reversed string. Returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SPLIT_INDEX",
            "description": "Function: `SPLIT_INDEX`\n\nType: String Function\n\nUsage: `SPLIT_INDEX(string1, string2, integer1)`\n\nDescription:  Splits string1 by the delimiter string2, returns the integerth (zero-based) string of the split strings. Returns NULL if integer is negative. Returns NULL if any of arguments is NULL.\n\n"
        },
        {
            "name": "STR_TO_MAP",
            "description": "Function: `STR_TO_MAP`\n\nType: String Function\n\nUsage: `STR_TO_MAP(string1[, string2, string3])`\n\nDescription:  Returns a map after splitting the string1 into key/value pairs using delimiters. string2 is the pair delimiter, default is ‘,’. And string3 is the key-value delimiter, default is ‘=’. Both pair delimiter and key-value delimiter are treated as regular expressions. So special characters (e.g. `<([{\\^-=$!|]})?*+.>`) need to be properly escaped before using as a delimiter literally.\n\n"
        },
        {
            "name": "SUBSTR",
            "description": "Function: `SUBSTR`\n\nType: String Function\n\nUsage: `SUBSTR(string, integer1[, integer2])`\n\nDescription:  Returns a substring of string starting from position integer1 with length integer2 (to the end by default).\n\n"
        },
        {
            "name": "NOW",
            "description": "Function: `NOW`\n\nType: Temporal Function\n\nUsage: `NOW()`\n\nDescription:  Returns the current SQL timestamp in the local time zone, this is a synonym of CURRENT\\_TIMESTAMP.\n\n"
        },
        {
            "name": "CURRENT_ROW_TIMESTAMP",
            "description": "Function: `CURRENT_ROW_TIMESTAMP`\n\nType: Temporal Function\n\nUsage: `CURRENT_ROW_TIMESTAMP()`\n\nDescription:  Returns the current SQL timestamp in the local time zone, the return type is TIMESTAMP\\_LTZ(3). It is evaluated for each record no matter in batch or streaming mode.\n\n"
        },
        {
            "name": "EXTRACT",
            "description": "Function: `EXTRACT`\n\nType: Temporal Function\n\nUsage: `EXTRACT(timeinteravlunit FROM temporal)`\n\nDescription:  Returns a long value extracted from the timeintervalunit part of temporal. E.g., EXTRACT(DAY FROM DATE ‘2006-06-05’) returns 5.\n\n"
        },
        {
            "name": "YEAR",
            "description": "Function: `YEAR`\n\nType: Temporal Function\n\nUsage: `YEAR(date)`\n\nDescription:  Returns the year from SQL date. Equivalent to EXTRACT(YEAR FROM date). E.g., YEAR(DATE ‘1994-09-27’) returns 1994.\n\n"
        },
        {
            "name": "QUARTER",
            "description": "Function: `QUARTER`\n\nType: Temporal Function\n\nUsage: `QUARTER(date)`\n\nDescription:  Returns the quarter of a year (an integer between 1 and 4) from SQL date. Equivalent to EXTRACT(QUARTER FROM date). E.g., QUARTER(DATE ‘1994-09-27’) returns 3.\n\n"
        },
        {
            "name": "MONTH",
            "description": "Function: `MONTH`\n\nType: Temporal Function\n\nUsage: `MONTH(date)`\n\nDescription:  Returns the month of a year (an integer between 1 and 12) from SQL date. Equivalent to EXTRACT(MONTH FROM date). E.g., MONTH(DATE ‘1994-09-27’) returns 9.\n\n"
        },
        {
            "name": "WEEK",
            "description": "Function: `WEEK`\n\nType: Temporal Function\n\nUsage: `WEEK(date)`\n\nDescription:  Returns the week of a year (an integer between 1 and 53) from SQL date. Equivalent to EXTRACT(WEEK FROM date). E.g., WEEK(DATE ‘1994-09-27’) returns 39.\n\n"
        },
        {
            "name": "DAYOFYEAR",
            "description": "Function: `DAYOFYEAR`\n\nType: Temporal Function\n\nUsage: `DAYOFYEAR(date)`\n\nDescription:  Returns the day of a year (an integer between 1 and 366) from SQL date. Equivalent to EXTRACT(DOY FROM date). E.g., DAYOFYEAR(DATE ‘1994-09-27’) returns 270.\n\n"
        },
        {
            "name": "DAYOFMONTH",
            "description": "Function: `DAYOFMONTH`\n\nType: Temporal Function\n\nUsage: `DAYOFMONTH(date)`\n\nDescription:  Returns the day of a month (an integer between 1 and 31) from SQL date. Equivalent to EXTRACT(DAY FROM date). E.g., DAYOFMONTH(DATE ‘1994-09-27’) returns 27.\n\n"
        },
        {
            "name": "DAYOFWEEK",
            "description": "Function: `DAYOFWEEK`\n\nType: Temporal Function\n\nUsage: `DAYOFWEEK(date)`\n\nDescription:  Returns the day of a week (an integer between 1 and 7) from SQL date. Equivalent to EXTRACT(DOW FROM date). E.g., DAYOFWEEK(DATE ‘1994-09-27’) returns 3.\n\n"
        },
        {
            "name": "HOUR",
            "description": "Function: `HOUR`\n\nType: Temporal Function\n\nUsage: `HOUR(timestamp)`\n\nDescription:  Returns the hour of a day (an integer between 0 and 23) from SQL timestamp timestamp. Equivalent to EXTRACT(HOUR FROM timestamp). E.g., MINUTE(TIMESTAMP ‘1994-09-27 13:14:15’) returns 14.\n\n"
        },
        {
            "name": "MINUTE",
            "description": "Function: `MINUTE`\n\nType: Temporal Function\n\nUsage: `MINUTE(timestamp)`\n\nDescription:  Returns the minute of an hour (an integer between 0 and 59) from SQL timestamp timestamp. Equivalent to EXTRACT(MINUTE FROM timestamp). E.g., MINUTE(TIMESTAMP ‘1994-09-27 13:14:15’) returns 14.\n\n"
        },
        {
            "name": "SECOND",
            "description": "Function: `SECOND`\n\nType: Temporal Function\n\nUsage: `SECOND(timestamp)`\n\nDescription:  Returns the second of a minute (an integer between 0 and 59) from SQL timestamp. Equivalent to EXTRACT(SECOND FROM timestamp). E.g., SECOND(TIMESTAMP ‘1994-09-27 13:14:15’) returns 15.\n\n"
        },
        {
            "name": "FLOOR",
            "description": "Function: `FLOOR`\n\nType: Temporal Function\n\nUsage: `FLOOR(timepoint TO timeintervalunit)`\n\nDescription:  Returns a value that rounds timepoint down to the time unit timeintervalunit. E.g., FLOOR(TIME ‘12:44:31’ TO MINUTE) returns 12:44:00.\n\n"
        },
        {
            "name": "CEIL",
            "description": "Function: `CEIL`\n\nType: Temporal Function\n\nUsage: `CEIL(timepoint TO timeintervaluntit)`\n\nDescription:  Returns a value that rounds timepoint up to the time unit timeintervalunit. E.g., CEIL(TIME ‘12:44:31’ TO MINUTE) returns 12:45:00.\n\n"
        },
        {
            "name": "DATE_FORMAT",
            "description": "Function: `DATE_FORMAT`\n\nType: Temporal Function\n\nUsage: `DATE_FORMAT(timestamp, string)`\n\nDescription:  Converts timestamp to a string in the format specified by the date format string. The format string is compatible with Java’s DateTimeFormatter.\n\n"
        },
        {
            "name": "DATE_FORMAT",
            "description": "Function: `DATE_FORMAT`\n\nType: Temporal Function\n\nUsage: `DATE_FORMAT(string, string)`\n\nDescription:  Re-format a timestamp string to another string, using a custom format. The format string is compatible with Java’s SimpleDateFormat.\n\n"
        },
        {
            "name": "TIMESTAMPADD",
            "description": "Function: `TIMESTAMPADD`\n\nType: Temporal Function\n\nUsage: `TIMESTAMPADD(timeintervalunit, interval, timepoint)`\n\nDescription: \n\n"
        },
        {
            "name": "TIMESTAMPDIFF",
            "description": "Function: `TIMESTAMPDIFF`\n\nType: Temporal Function\n\nUsage: `TIMESTAMPDIFF(timepointunit, timepoint1, timepoint2)`\n\nDescription:  Returns the (signed) number of timepointunit between timepoint1 and timepoint2\\. The unit for the interval is given by the first argument, which should be one of the following values: SECOND, MINUTE, HOUR, DAY, MONTH, or YEAR.\n\n"
        },
        {
            "name": "CONVERT_TZ",
            "description": "Function: `CONVERT_TZ`\n\nType: Temporal Function\n\nUsage: `CONVERT_TZ(string1, string2, string3)`\n\nDescription:  Converts a datetime string1 (with default ISO timestamp format ‘yyyy-MM-dd HH:mm:ss’) from time zone string2 to time zone string3\\. The format of time zone should be either an abbreviation such as “PST”, a full name such as “America/Los\\_Angeles”, or a custom ID such as “GMT-08:00”. E.g., CONVERT\\_TZ(‘1970-01-01 00:00:00’, ‘UTC’, ‘America/Los\\_Angeles’) returns ‘1969-12-31 16:00:00’.\n\n"
        },
        {
            "name": "FROM_UNIXTIME",
            "description": "Function: `FROM_UNIXTIME`\n\nType: Temporal Function\n\nUsage: `FROM_UNIXTIME(numeric[, string])`\n\nDescription:  Returns a representation of the numeric argument as a value in string format (default is ‘yyyy-MM-dd HH:mm:ss’). numeric is an internal timestamp value representing seconds since ‘1970-01-01 00:00:00’ UTC, such as produced by the UNIX\\_TIMESTAMP() function. The return value is expressed in the session time zone (specified in TableConfig). E.g., FROM\\_UNIXTIME(44) returns ‘1970-01-01 00:00:44’ if in UTC time zone, but returns ‘1970-01-01 09:00:44’ if in ‘Asia/Tokyo’ time zone.\n\n"
        },
        {
            "name": "UNIX_TIMESTAMP",
            "description": "Function: `UNIX_TIMESTAMP`\n\nType: Temporal Function\n\nUsage: `UNIX_TIMESTAMP()`\n\nDescription:  Gets current Unix timestamp in seconds. This function is not deterministic which means the value would be recalculated for each record.\n\n"
        },
        {
            "name": "UNIX_TIMESTAMP",
            "description": "Function: `UNIX_TIMESTAMP`\n\nType: Temporal Function\n\nUsage: `UNIX_TIMESTAMP(string1[, string2])`\n\nDescription: Converts a date time string string1 with format string2 (by default: yyyy-MM-dd HH:mm:ss if not specified) to Unix timestamp (in seconds), using the specified timezone in table config.\n\nIf a time zone is specified in the date time string and parsed by UTC+X format such as “yyyy-MM-dd HH:mm:ss.SSS X”, this function will use the specified timezone in the date time string instead of the timezone in table config. If the date time string can not be parsed, the default value Long.MIN\\_VALUE(-9223372036854775808) will be returned.\n\n```sql\nFlink SQL> SET 'table.local-time-zone' = 'Europe/Berlin';\n\n-- Returns 25201\nFlink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001', 'yyyy-MM-dd HH:mm:ss.SSS');\n-- Returns 1\nFlink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001 +0800', 'yyyy-MM-dd HH:mm:ss.SSS X');\n-- Returns 25201\nFlink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001 +0800', 'yyyy-MM-dd HH:mm:ss.SSS');\n-- Returns -9223372036854775808\nFlink SQL> SELECT UNIX_TIMESTAMP('1970-01-01 08:00:01.001', 'yyyy-MM-dd HH:mm:ss.SSS X');\n\n```\n\n"
        },
        {
            "name": "TO_DATE",
            "description": "Function: `TO_DATE`\n\nType: Temporal Function\n\nUsage: `TO_DATE(string1[, string2])`\n\nDescription:  Converts a date string string1 with format string2 (by default ‘yyyy-MM-dd’) to a date.\n\n"
        },
        {
            "name": "TO_TIMESTAMP_LTZ",
            "description": "Function: `TO_TIMESTAMP_LTZ`\n\nType: Temporal Function\n\nUsage: `TO_TIMESTAMP_LTZ(numeric, precision)`\n\nDescription:  Converts a epoch seconds or epoch milliseconds to a TIMESTAMP\\_LTZ, the valid precision is 0 or 3, the 0 represents TO\\_TIMESTAMP\\_LTZ(epochSeconds, 0), the 3 represents TO\\_TIMESTAMP\\_LTZ(epochMilliseconds, 3).\n\n"
        },
        {
            "name": "TO_TIMESTAMP",
            "description": "Function: `TO_TIMESTAMP`\n\nType: Temporal Function\n\nUsage: `TO_TIMESTAMP(string1[, string2])`\n\nDescription:  Converts date time string string1 with format string2 (by default: ‘yyyy-MM-dd HH:mm:ss’) to a timestamp, without time zone.\n\n"
        },
        {
            "name": "CURRENT_WATERMARK",
            "description": "Function: `CURRENT_WATERMARK`\n\nType: Temporal Function\n\nUsage: `CURRENT_WATERMARK(rowtime)`\n\nDescription: Returns the current watermark for the given rowtime attribute, or `NULL` if no common watermark of all upstream operations is available at the current operation in the pipeline. The return type of the function is inferred to match that of the provided rowtime attribute, but with an adjusted precision of 3\\. For example, if the rowtime attribute is `TIMESTAMP_LTZ(9)`, the function will return `TIMESTAMP_LTZ(3)`.\n\nNote that this function can return `NULL`, and you may have to consider this case. For example, if you want to filter out late data you can use:\n\n```sql\nWHERE\n  CURRENT_WATERMARK(ts) IS NULL\n  OR ts > CURRENT_WATERMARK(ts)\n\n```\n\n"
        },
        {
            "name": "NULLIF",
            "description": "Function: `NULLIF`\n\nType: Conditional Function\n\nUsage: `NULLIF(value1, value2)`\n\nDescription:  Returns NULL if value1 is equal to value2; returns value1 otherwise. E.g., NULLIF(5, 5) returns NULL; NULLIF(5, 0) returns 5.\n\n"
        },
        {
            "name": "COALESCE",
            "description": "Function: `COALESCE`\n\nType: Conditional Function\n\nUsage: `COALESCE(value1 [, value2]*)`\n\nDescription: Returns the first argument that is not NULL.\n\nIf all arguments are NULL, it returns NULL as well. The return type is the least restrictive, common type of all of its arguments. The return type is nullable if all arguments are nullable as well.\n\n```sql\n-- Returns 'default'\nCOALESCE(NULL, 'default')\n\n-- Returns the first non-null value among f0 and f1,\n-- or 'default' if f0 and f1 are both NULL\nCOALESCE(f0, f1, 'default')\n\n```\n\n"
        },
        {
            "name": "IF",
            "description": "Function: `IF`\n\nType: Conditional Function\n\nUsage: `IF(condition, true_value, false_value)`\n\nDescription:  Returns the true\\_value if condition is met, otherwise false\\_value. E.g., IF(5 > 3, 5, 3) returns 5.\n\n"
        },
        {
            "name": "IFNULL",
            "description": "Function: `IFNULL`\n\nType: Conditional Function\n\nUsage: `IFNULL(input, null_replacement)`\n\nDescription: Returns null\\_replacement if input is NULL; otherwise input is returned.\n\nCompared to COALESCE or CASE WHEN, this function returns a data type that is very specific in terms of nullability. The returned type is the common type of both arguments but only nullable if the null\\_replacement is nullable.\n\nThe function allows to pass nullable columns into a function or table that is declared with a NOT NULL constraint.\n\nE.g., IFNULL(nullable\\_column, 5) returns never NULL.\n\n"
        },
        {
            "name": "IS_ALPHA",
            "description": "Function: `IS_ALPHA`\n\nType: Conditional Function\n\nUsage: `IS_ALPHA(string)`\n\nDescription:  Returns true if all characters in string are letter, otherwise false.\n\n"
        },
        {
            "name": "IS_DECIMAL",
            "description": "Function: `IS_DECIMAL`\n\nType: Conditional Function\n\nUsage: `IS_DECIMAL(string)`\n\nDescription:  Returns true if string can be parsed to a valid numeric, otherwise false.\n\n"
        },
        {
            "name": "IS_DIGIT",
            "description": "Function: `IS_DIGIT`\n\nType: Conditional Function\n\nUsage: `IS_DIGIT(string)`\n\nDescription:  Returns true if all characters in string are digit, otherwise false.\n\n"
        },
        {
            "name": "GREATEST",
            "description": "Function: `GREATEST`\n\nType: Conditional Function\n\nUsage: `GREATEST(value1[, value2]*)`\n\nDescription:  Returns the greatest value of the list of arguments. Returns NULL if any argument is NULL.\n\n"
        },
        {
            "name": "LEAST",
            "description": "Function: `LEAST`\n\nType: Conditional Function\n\nUsage: `LEAST(value1[, value2]*)`\n\nDescription:  Returns the least value of the list of arguments. Returns NULL if any argument is NULL.\n\n"
        },
        {
            "name": "CAST",
            "description": "Function: `CAST`\n\nType: Type Conversion Function\n\nUsage: `CAST(value AS type)`\n\nDescription:  Returns a new value being cast to type type. A CAST error throws an exception and fails the job. When performing a cast operation that may fail, like STRING to INT, one should rather use TRY\\_CAST, in order to handle errors. If “table.exec.legacy-cast-behaviour” is enabled, CAST behaves like TRY\\_CAST. E.g., CAST(‘42’ AS INT) returns 42; CAST(NULL AS STRING) returns NULL of type STRING; CAST(’non-number’ AS INT) throws an exception and fails the job.\n\n"
        },
        {
            "name": "TRY_CAST",
            "description": "Function: `TRY_CAST`\n\nType: Type Conversion Function\n\nUsage: `TRY_CAST(value AS type)`\n\nDescription:  Like CAST, but in case of error, returns NULL rather than failing the job. E.g., TRY\\_CAST(‘42’ AS INT) returns 42; TRY\\_CAST(NULL AS STRING) returns NULL of type STRING; TRY\\_CAST(’non-number’ AS INT) returns NULL of type INT; COALESCE(TRY\\_CAST(’non-number’ AS INT), 0) returns 0 of type INT.\n\n"
        },
        {
            "name": "TYPEOF",
            "description": "Function: `TYPEOF`\n\nType: Type Conversion Function\n\nUsage: `TYPEOF(input)` | `TYPEOF(input, force_serializable)`\n\nDescription:  Returns the string representation of the input expression’s data type. By default, the returned string is a summary string that might omit certain details for readability. If force\\_serializable is set to TRUE, the string represents a full data type that could be persisted in a catalog. Note that especially anonymous, inline data types have no serializable string representation. In this case, NULL is returned.\n\n"
        },
        {
            "name": "CARDINALITY",
            "description": "Function: `CARDINALITY`\n\nType: Collection Function\n\nUsage: `CARDINALITY(array)`\n\nDescription:  Returns the number of elements in array.\n\n"
        },
        {
            "name": "CARDINALITY",
            "description": "Function: `CARDINALITY`\n\nType: Collection Function\n\nUsage: `CARDINALITY(map)`\n\nDescription:  Returns the number of entries in map.\n\n"
        },
        {
            "name": "ELEMENT",
            "description": "Function: `ELEMENT`\n\nType: Collection Function\n\nUsage: `ELEMENT(array)`\n\nDescription:  Returns the sole element of array (whose cardinality should be one); returns NULL if array is empty. Throws an exception if array has more than one element.\n\n"
        },
        {
            "name": "ARRAY_APPEND",
            "description": "Function: `ARRAY_APPEND`\n\nType: Collection Function\n\nUsage: `ARRAY_APPEND(array, element)`\n\nDescription:  Appends an element to the end of the array and returns the result. If the array itself is null, the function will return null. If an element to add is null, the null element will be added to the end of the array.\n\n"
        },
        {
            "name": "ARRAY_CONTAINS",
            "description": "Function: `ARRAY_CONTAINS`\n\nType: Collection Function\n\nUsage: `ARRAY_CONTAINS(haystack, needle)`\n\nDescription:  Returns whether the given element exists in an array. Checking for null elements in the array is supported. If the array itself is null, the function will return null. The given element is cast implicitly to the array’s element type if necessary.\n\n"
        },
        {
            "name": "ARRAY_DISTINCT",
            "description": "Function: `ARRAY_DISTINCT`\n\nType: Collection Function\n\nUsage: `ARRAY_DISTINCT(haystack)`\n\nDescription:  Returns an array with unique elements. If the array itself is null, the function will return null. Keeps ordering of elements.\n\n"
        },
        {
            "name": "ARRAY_POSITION",
            "description": "Function: `ARRAY_POSITION`\n\nType: Collection Function\n\nUsage: `ARRAY_POSITION(haystack, needle)`\n\nDescription:  Returns the position of the first occurrence of element in the given array as int. Returns 0 if the given value could not be found in the array. Returns null if either of the arguments are null. And this is not zero based, but 1-based index. The first element in the array has index 1.\n\n"
        },
        {
            "name": "ARRAY_PREPEND",
            "description": "Function: `ARRAY_PREPEND`\n\nType: Collection Function\n\nUsage: `ARRAY_PREPEND(array, element)`\n\nDescription:  Appends an element to the beginning of the array and returns the result. If the array itself is null, the function will return null. If an element to add is null, the null element will be added to the beginning of the array.\n\n"
        },
        {
            "name": "ARRAY_REMOVE",
            "description": "Function: `ARRAY_REMOVE`\n\nType: Collection Function\n\nUsage: `ARRAY_REMOVE(haystack, needle)`\n\nDescription:  Removes all elements that equal to element from array. If the array itself is null, the function will return null. Keeps ordering of elements.\n\n"
        },
        {
            "name": "ARRAY_REVERSE",
            "description": "Function: `ARRAY_REVERSE`\n\nType: Collection Function\n\nUsage: `ARRAY_REVERSE(haystack)`\n\nDescription:  Returns an array in reverse order. If the array itself is null, the function will return null.\n\n"
        },
        {
            "name": "ARRAY_SLICE",
            "description": "Function: `ARRAY_SLICE`\n\nType: Collection Function\n\nUsage: `ARRAY_SLICE(array, start_offset[, end_offset])`\n\nDescription:  Returns a subarray of the input array between ‘start\\_offset’ and ’end\\_offset’ inclusive. The offsets are 1-based however 0 is also treated as the beginning of the array. Positive values are counted from the beginning of the array while negative from the end. If ’end\\_offset’ is omitted then this offset is treated as the length of the array. If ‘start\\_offset’ is after ’end\\_offset’ or both are out of array bounds an empty array will be returned. Returns null if any input is null.\n\n"
        },
        {
            "name": "ARRAY_SORT",
            "description": "Function: `ARRAY_SORT`\n\nType: Collection Function\n\nUsage: `ARRAY_SORT(array[, ascending_order[, null_first]])`\n\nDescription:  Returns the array in sorted order.The function sorts an array, defaulting to ascending order with NULLs at the start when only the array is input. Specifying ascending\\_order as true orders the array in ascending with NULLs first, and setting it to false orders it in descending with NULLs last. Independently, null\\_first as true moves NULLs to the beginning, and as false to the end, irrespective of the sorting order. The function returns null if any input is null.\n\n"
        },
        {
            "name": "ARRAY_UNION",
            "description": "Function: `ARRAY_UNION`\n\nType: Collection Function\n\nUsage: `ARRAY_UNION(array1, array2)`\n\nDescription:  Returns an array of the elements in the union of array1 and array2, without duplicates. If any of the array is null, the function will return null.\n\n"
        },
        {
            "name": "ARRAY_CONCAT",
            "description": "Function: `ARRAY_CONCAT`\n\nType: Collection Function\n\nUsage: `ARRAY_CONCAT(array1, …)`\n\nDescription:  Returns an array that is the result of concatenating at least one array. This array contains all the elements in the first array, followed by all the elements in the second array, and so forth, up to the Nth array. If any input array is NULL, the function returns NULL.\n\n"
        },
        {
            "name": "ARRAY_EXCEPT",
            "description": "Function: `ARRAY_EXCEPT`\n\nType: Collection Function\n\nUsage: `ARRAY_EXCEPT(array1, array2)`\n\nDescription:  Returns an ARRAY that contains the elements from array1 that are not in array2, without duplicates. If no elements remain after excluding the elements in array2 from array1, the function returns an empty ARRAY. If one or both arguments are NULL, the function returns NULL. The order of the elements from array1 is kept.\n\n"
        },
        {
            "name": "ARRAY_INTERSECT",
            "description": "Function: `ARRAY_INTERSECT`\n\nType: Collection Function\n\nUsage: `ARRAY_INTERSECT(array1, array2)`\n\nDescription:  Returns an ARRAY that contains the elements from array1 that are also in array2, without duplicates. If no elements that are both in array1 and array2, the function returns an empty ARRAY. If any of the array is null, the function will return null. The order of the elements from array1 is kept.\n\n"
        },
        {
            "name": "ARRAY_MAX",
            "description": "Function: `ARRAY_MAX`\n\nType: Collection Function\n\nUsage: `ARRAY_MAX(array)`\n\nDescription:  Returns the maximum value from the array, if array itself is null, the function returns null.\n\n"
        },
        {
            "name": "ARRAY_JOIN",
            "description": "Function: `ARRAY_JOIN`\n\nType: Collection Function\n\nUsage: `ARRAY_JOIN(array, delimiter[, nullReplacement])`\n\nDescription:  Returns a string that represents the concatenation of the elements in the given array and the elements’ data type in the given array is string. The delimiter is a string that separates each pair of consecutive elements of the array. The optional nullReplacement is a string that replaces null elements in the array. If nullReplacement is not specified, null elements in the array will be omitted from the resulting string. Returns null if input array or delimiter or nullReplacement are null.\n\n"
        },
        {
            "name": "ARRAY_MIN",
            "description": "Function: `ARRAY_MIN`\n\nType: Collection Function\n\nUsage: `ARRAY_MIN(array)`\n\nDescription:  Returns the minimum value from the array, if array itself is null, the function returns null.\n\n"
        },
        {
            "name": "MAP_KEYS",
            "description": "Function: `MAP_KEYS`\n\nType: Collection Function\n\nUsage: `MAP_KEYS(map)`\n\nDescription:  Returns the keys of the map as array. No order guaranteed.\n\n"
        },
        {
            "name": "MAP_UNION",
            "description": "Function: `MAP_UNION`\n\nType: Collection Function\n\nUsage: `MAP_UNION(map1, …)`\n\nDescription:  Returns a map created by merging at least one map. These maps should have a common map type. If there are overlapping keys, the value from ‘map2’ will overwrite the value from ‘map1’, the value from ‘map3’ will overwrite the value from ‘map2’, the value from ‘mapn’ will overwrite the value from ‘map(n-1)’. If any of maps is null, return null.\n\n"
        },
        {
            "name": "MAP_VALUES",
            "description": "Function: `MAP_VALUES`\n\nType: Collection Function\n\nUsage: `MAP_VALUES(map)`\n\nDescription:  Returns the values of the map as array. No order guaranteed.\n\n"
        },
        {
            "name": "MAP_ENTRIES",
            "description": "Function: `MAP_ENTRIES`\n\nType: Collection Function\n\nUsage: `MAP_ENTRIES(map)`\n\nDescription:  Returns an array of all entries in the given map. No order guaranteed.\n\n"
        },
        {
            "name": "MAP_FROM_ARRAYS",
            "description": "Function: `MAP_FROM_ARRAYS`\n\nType: Collection Function\n\nUsage: `MAP_FROM_ARRAYS(array_of_keys, array_of_values)`\n\nDescription:  Returns a map created from an arrays of keys and values. Note that the lengths of two arrays should be the same.\n\n"
        },
        {
            "name": "SPLIT",
            "description": "Function: `SPLIT`\n\nType: Collection Function\n\nUsage: `SPLIT(string, delimiter)`\n\nDescription:  Returns an array of substrings by splitting the input string based on the given delimiter. If the delimiter is not found in the string, the original string is returned as the only element in the array. If the delimiter is empty, every character in the string is split. If the string or delimiter is null, a null value is returned. If the delimiter is found at the beginning or end of the string, or there are contiguous delimiters, then an empty string is added to the array.\n\n"
        },
        {
            "name": "JSON_EXISTS",
            "description": "Function: `JSON_EXISTS`\n\nType: JSON Function\n\nUsage: `JSON_EXISTS(jsonValue, path [ { TRUE | FALSE | UNKNOWN | ERROR } ON ERROR ])`\n\nDescription: Determines whether a JSON string satisfies a given path search criterion.\n\nIf the error behavior is omitted, `FALSE ON ERROR` is assumed as the default.\n\n```sql\n-- TRUE\nSELECT JSON_EXISTS('{\"a\": true}', '$.a');\n-- FALSE\nSELECT JSON_EXISTS('{\"a\": true}', '$.b');\n-- TRUE\nSELECT JSON_EXISTS('{\"a\": [{ \"b\": 1 }]}',\n  '$.a[0].b');\n\n-- TRUE\nSELECT JSON_EXISTS('{\"a\": true}',\n  'strict $.b' TRUE ON ERROR);\n-- FALSE\nSELECT JSON_EXISTS('{\"a\": true}',\n  'strict $.b' FALSE ON ERROR);\n\n```\n\n"
        },
        {
            "name": "JSON_STRING",
            "description": "Function: `JSON_STRING`\n\nType: JSON Function\n\nUsage: `JSON_STRING(value)`\n\nDescription: Serializes a value into JSON.\n\nThis function returns a JSON string containing the serialized value. If the value is `NULL`, the function returns `NULL`.\n\n```sql\n-- NULL\nJSON_STRING(CAST(NULL AS INT))\n\n-- '1'\nJSON_STRING(1)\n-- 'true'\nJSON_STRING(TRUE)\n-- '\"Hello, World!\"'\nJSON_STRING('Hello, World!')\n-- '[1,2]'\nJSON_STRING(ARRAY[1, 2])\n\n```\n\n"
        },
        {
            "name": "JSON_VALUE",
            "description": "Function: `JSON_VALUE`\n\nType: JSON Function\n\nUsage: `JSON_VALUE(jsonValue, path [RETURNING ] [ { NULL | ERROR | DEFAULT } ON EMPTY ] [ { NULL | ERROR | DEFAULT } ON ERROR ])`\n\nDescription: Extracts a scalar from a JSON string.\n\nThis method searches a JSON string for a given path expression and returns the value if the value at that path is scalar. Non-scalar values cannot be returned. By default, the value is returned as `STRING`. Using `dataType` a different type can be chosen, with the following types being supported:\n\n* `VARCHAR` / `STRING`\n* `BOOLEAN`\n* `INTEGER`\n* `DOUBLE`\n\nFor empty path expressions or errors a behavior can be defined to either return `null`, raise an error or return a defined default value instead. When omitted, the default is`NULL ON EMPTY` or `NULL ON ERROR`, respectively. The default value may be a literal or an expression. If the default value itself raises an error, it falls through to the error behavior for `ON EMPTY`, and raises an error for `ON ERROR`.\n\nFor path contains special characters such as spaces, you can use `['property']` or `[\"property\"]`to select the specified property in a parent object. Be sure to put single or double quotes around the property name. When using JSON\\_VALUE in SQL, the path is a character parameter which is already single quoted, so you have to escape the single quotes around property name, such as `JSON_VALUE('{\"a b\": \"true\"}', '$.[''a b'']')`.\n\n```sql\n-- \"true\"\nJSON_VALUE('{\"a\": true}', '$.a')\n\n-- TRUE\nJSON_VALUE('{\"a\": true}', '$.a' RETURNING BOOLEAN)\n\n-- \"false\"\nJSON_VALUE('{\"a\": true}', 'lax $.b'\n    DEFAULT FALSE ON EMPTY)\n\n-- \"false\"\nJSON_VALUE('{\"a\": true}', 'strict $.b'\n    DEFAULT FALSE ON ERROR)\n\n-- 0.998D\nJSON_VALUE('{\"a.b\": [0.998,0.996]}','$.[\"a.b\"][0]' \n    RETURNING DOUBLE)\n\n-- \"right\"\nJSON_VALUE('{\"contains blank\": \"right\"}', 'strict $.[''contains blank'']' NULL ON EMPTY DEFAULT 'wrong' ON ERROR)\n\n```\n\n"
        },
        {
            "name": "JSON_QUERY",
            "description": "Function: `JSON_QUERY`\n\nType: JSON Function\n\nUsage: `JSON_QUERY(jsonValue, path [RETURNING ] [ { WITHOUT | WITH CONDITIONAL | WITH UNCONDITIONAL } [ ARRAY ] WRAPPER ] [ { NULL | EMPTY ARRAY | EMPTY OBJECT | ERROR } ON EMPTY ] [ { NULL | EMPTY ARRAY | EMPTY OBJECT | ERROR } ON ERROR ])`\n\nDescription: Extracts JSON values from a JSON string.\n\nThe result is returned as a `STRING` or `ARRAY<STRING>`. This can be controlled with the `RETURNING` clause.\n\nThe `wrappingBehavior` determines whether the extracted value should be wrapped into an array, and whether to do so unconditionally or only if the value itself isn’t an array already.\n\n`onEmpty` and `onError` determine the behavior in case the path expression is empty, or in case an error was raised, respectively. By default, in both cases `null` is returned. Other choices are to use an empty array, an empty object, or to raise an error.\n\n```sql\n-- '{ \"b\": 1 }'\nJSON_QUERY('{ \"a\": { \"b\": 1 } }', '$.a')\n-- '[1, 2]'\nJSON_QUERY('[1, 2]', '$')\n-- NULL\nJSON_QUERY(CAST(NULL AS STRING), '$')\n-- '[\"c1\",\"c2\"]'\nJSON_QUERY('{\"a\":[{\"c\":\"c1\"},{\"c\":\"c2\"}]}',\n    'lax $.a[*].c')\n-- ['c1','c2']\nJSON_QUERY('{\"a\":[{\"c\":\"c1\"},{\"c\":\"c2\"}]}', 'lax $.a[*].c' RETURNING ARRAY<STRING>)\n\n-- Wrap result into an array\n-- '[{}]'\nJSON_QUERY('{}', '$' WITH CONDITIONAL ARRAY WRAPPER)\n-- '[1, 2]'\nJSON_QUERY('[1, 2]', '$' WITH CONDITIONAL ARRAY WRAPPER)\n-- '[[1, 2]]'\nJSON_QUERY('[1, 2]', '$' WITH UNCONDITIONAL ARRAY WRAPPER)\n\n-- Scalars must be wrapped to be returned\n-- NULL\nJSON_QUERY(1, '$')\n-- '[1]'\nJSON_QUERY(1, '$' WITH CONDITIONAL ARRAY WRAPPER)\n\n-- Behavior if path expression is empty / there is an error\n-- '{}'\nJSON_QUERY('{}', 'lax $.invalid' EMPTY OBJECT ON EMPTY)\n-- '[]'\nJSON_QUERY('{}', 'strict $.invalid' EMPTY ARRAY ON ERROR)\n\n```\n\n"
        },
        {
            "name": "JSON_OBJECT",
            "description": "Function: `JSON_OBJECT`\n\nType: JSON Function\n\nUsage: `JSON_OBJECT([[KEY] key VALUE value]* [ { NULL | ABSENT } ON NULL ])`\n\nDescription: Builds a JSON object string from a list of key-value pairs.\n\nNote that keys must be non-`NULL` string literals, while values may be arbitrary expressions.\n\nThis function returns a JSON string. The `ON NULL` behavior defines how to treat `NULL`values. If omitted, `NULL ON NULL` is assumed by default.\n\nValues which are created from another JSON construction function call (`JSON_OBJECT`,`JSON_ARRAY`) are inserted directly rather than as a string. This allows building nested JSON structures.\n\n```sql\n-- '{}'\nJSON_OBJECT()\n\n-- '{\"K1\":\"V1\",\"K2\":\"V2\"}'\nJSON_OBJECT('K1' VALUE 'V1', 'K2' VALUE 'V2')\n\n-- Expressions as values\nJSON_OBJECT('orderNo' VALUE orders.orderId)\n\n-- ON NULL\nJSON_OBJECT(KEY 'K1' VALUE CAST(NULL AS STRING) NULL ON NULL)   -- '{\"K1\":null}'\nJSON_OBJECT(KEY 'K1' VALUE CAST(NULL AS STRING) ABSENT ON NULL) -- '{}'\n\n-- '{\"K1\":{\"K2\":\"V\"}}'\nJSON_OBJECT(\n  KEY 'K1'\n  VALUE JSON_OBJECT(\n    KEY 'K2'\n    VALUE 'V'\n  )\n)\n\n```\n\n"
        },
        {
            "name": "JSON_ARRAY",
            "description": "Function: `JSON_ARRAY`\n\nType: JSON Function\n\nUsage: `JSON_ARRAY([value]* [ { NULL | ABSENT } ON NULL ])`\n\nDescription: Builds a JSON array string from a list of values.\n\nThis function returns a JSON string. The values can be arbitrary expressions. The `ON NULL`behavior defines how to treat `NULL` values. If omitted, `ABSENT ON NULL` is assumed by default.\n\nElements which are created from another JSON construction function call (`JSON_OBJECT`,`JSON_ARRAY`) are inserted directly rather than as a string. This allows building nested JSON structures.\n\n```sql\n-- '[]'\nJSON_ARRAY()\n-- '[1,\"2\"]'\nJSON_ARRAY(1, '2')\n\n-- Expressions as values\nJSON_ARRAY(orders.orderId)\n\n-- ON NULL\nJSON_ARRAY(CAST(NULL AS STRING) NULL ON NULL) -- '[null]'\nJSON_ARRAY(CAST(NULL AS STRING) ABSENT ON NULL) -- '[]'\n\n-- '[[1]]'\nJSON_ARRAY(JSON_ARRAY(1))\n\n```\n\n"
        },
        {
            "name": "GROUP_ID",
            "description": "Function: `GROUP_ID`\n\nType: Grouping Function\n\nUsage: `GROUP_ID()`\n\nDescription:  Returns an integer that uniquely identifies the combination of grouping keys.\n\n"
        },
        {
            "name": "GROUPING",
            "description": "Function: `GROUPING`\n\nType: Grouping Function\n\nUsage: `GROUPING(expression1 [, expression2]* )`\n\nDescription:  Returns a bit vector of the given grouping expressions.\n\n"
        },
        {
            "name": "GROUPING_ID",
            "description": "Function: `GROUPING_ID`\n\nType: Grouping Function\n\nUsage: `GROUPING_ID(expression1 [, expression2]* )`\n\nDescription:  Returns a bit vector of the given grouping expressions.\n\n"
        },
        {
            "name": "MD5",
            "description": "Function: `MD5`\n\nType: Hash Function\n\nUsage: `MD5(string)`\n\nDescription:  Returns the MD5 hash of string as a string of 32 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA1",
            "description": "Function: `SHA1`\n\nType: Hash Function\n\nUsage: `SHA1(string)`\n\nDescription:  Returns the SHA-1 hash of string as a string of 40 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA224",
            "description": "Function: `SHA224`\n\nType: Hash Function\n\nUsage: `SHA224(string)`\n\nDescription:  Returns the SHA-224 hash of string as a string of 56 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA256",
            "description": "Function: `SHA256`\n\nType: Hash Function\n\nUsage: `SHA256(string)`\n\nDescription:  Returns the SHA-256 hash of string as a string of 64 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA384",
            "description": "Function: `SHA384`\n\nType: Hash Function\n\nUsage: `SHA384(string)`\n\nDescription:  Returns the SHA-384 hash of string as a string of 96 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA512",
            "description": "Function: `SHA512`\n\nType: Hash Function\n\nUsage: `SHA512(string)`\n\nDescription:  Returns the SHA-512 hash of string as a string of 128 hexadecimal digits; returns NULL if string is NULL.\n\n"
        },
        {
            "name": "SHA2",
            "description": "Function: `SHA2`\n\nType: Hash Function\n\nUsage: `SHA2(string, hashLength)`\n\nDescription:  Returns the hash using the SHA-2 family of hash functions (SHA-224, SHA-256, SHA-384, or SHA-512). The first argument string is the string to be hashed and the second argument hashLength is the bit length of the result (224, 256, 384, or 512). Returns NULL if string or hashLength is NULL.\n\n"
        },
        {
            "name": "COUNT",
            "description": "Function: `COUNT`\n\nType: Aggregate Function\n\nUsage: `COUNT([ ALL ] expression | DISTINCT expression1 [, expression2]*)`\n\nDescription:  By default or with ALL, returns the number of input rows for which expression is not NULL. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "COUNT",
            "description": "Function: `COUNT`\n\nType: Aggregate Function\n\nUsage: `COUNT(*)`\n\nDescription:  Returns the number of input rows.\n\n"
        },
        {
            "name": "COUNT",
            "description": "Function: `COUNT`\n\nType: Aggregate Function\n\nUsage: `COUNT(1)`\n\nDescription:  Returns the number of input rows.\n\n"
        },
        {
            "name": "AVG",
            "description": "Function: `AVG`\n\nType: Aggregate Function\n\nUsage: `AVG([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the average (arithmetic mean) of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "SUM",
            "description": "Function: `SUM`\n\nType: Aggregate Function\n\nUsage: `SUM([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the sum of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "MAX",
            "description": "Function: `MAX`\n\nType: Aggregate Function\n\nUsage: `MAX([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the maximum value of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "MIN",
            "description": "Function: `MIN`\n\nType: Aggregate Function\n\nUsage: `MIN([ ALL | DISTINCT ] expression )`\n\nDescription:  By default or with keyword ALL, returns the minimum value of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "STDDEV_POP",
            "description": "Function: `STDDEV_POP`\n\nType: Aggregate Function\n\nUsage: `STDDEV_POP([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the population standard deviation of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "STDDEV_SAMP",
            "description": "Function: `STDDEV_SAMP`\n\nType: Aggregate Function\n\nUsage: `STDDEV_SAMP([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the sample standard deviation of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "VAR_POP",
            "description": "Function: `VAR_POP`\n\nType: Aggregate Function\n\nUsage: `VAR_POP([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the population variance (square of the population standard deviation) of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "VAR_SAMP",
            "description": "Function: `VAR_SAMP`\n\nType: Aggregate Function\n\nUsage: `VAR_SAMP([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns the sample variance (square of the sample standard deviation) of expression across all input rows. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "COLLECT",
            "description": "Function: `COLLECT`\n\nType: Aggregate Function\n\nUsage: `COLLECT([ ALL | DISTINCT ] expression)`\n\nDescription:  By default or with keyword ALL, returns a multiset of expression across all input rows. NULL values will be ignored. Use DISTINCT for one unique instance of each value.\n\n"
        },
        {
            "name": "VARIANCE",
            "description": "Function: `VARIANCE`\n\nType: Aggregate Function\n\nUsage: `VARIANCE([ ALL | DISTINCT ] expression)`\n\nDescription:  Synonyms for VAR\\_SAMP().\n\n"
        },
        {
            "name": "RANK",
            "description": "Function: `RANK`\n\nType: Aggregate Function\n\nUsage: `RANK()`\n\nDescription:  Returns the rank of a value in a group of values. The result is one plus the number of rows preceding or equal to the current row in the ordering of the partition. The values will produce gaps in the sequence.\n\n"
        },
        {
            "name": "DENSE_RANK",
            "description": "Function: `DENSE_RANK`\n\nType: Aggregate Function\n\nUsage: `DENSE_RANK()`\n\nDescription:  Returns the rank of a value in a group of values. The result is one plus the previously assigned rank value. Unlike the function rank, dense\\_rank will not produce gaps in the ranking sequence.\n\n"
        },
        {
            "name": "ROW_NUMBER",
            "description": "Function: `ROW_NUMBER`\n\nType: Aggregate Function\n\nUsage: `ROW_NUMBER()`\n\nDescription:  Assigns a unique, sequential number to each row, starting with one, according to the ordering of rows within the window partition. ROW\\_NUMBER and RANK are similar. ROW\\_NUMBER numbers all rows sequentially (for example 1, 2, 3, 4, 5). RANK provides the same numeric value for ties (for example 1, 2, 2, 4, 5).\n\n"
        },
        {
            "name": "LEAD",
            "description": "Function: `LEAD`\n\nType: Aggregate Function\n\nUsage: `LEAD(expression [, offset] [, default])`\n\nDescription:  Returns the value of expression at the offsetth row after the current row in the window. The default value of offset is 1 and the default value of default is NULL.\n\n"
        },
        {
            "name": "LAG",
            "description": "Function: `LAG`\n\nType: Aggregate Function\n\nUsage: `LAG(expression [, offset] [, default])`\n\nDescription:  Returns the value of expression at the offsetth row before the current row in the window. The default value of offset is 1 and the default value of default is NULL.\n\n"
        },
        {
            "name": "FIRST_VALUE",
            "description": "Function: `FIRST_VALUE`\n\nType: Aggregate Function\n\nUsage: `FIRST_VALUE(expression)`\n\nDescription:  Returns the first value in an ordered set of values.\n\n"
        },
        {
            "name": "LAST_VALUE",
            "description": "Function: `LAST_VALUE`\n\nType: Aggregate Function\n\nUsage: `LAST_VALUE(expression)`\n\nDescription:  Returns the last value in an ordered set of values.\n\n"
        },
        {
            "name": "LISTAGG",
            "description": "Function: `LISTAGG`\n\nType: Aggregate Function\n\nUsage: `LISTAGG(expression [, separator])`\n\nDescription:  Concatenates the values of string expressions and places separator values between them. The separator is not added at the end of string. The default value of separator is ‘,’.\n\n"
        },
        {
            "name": "CUME_DIST",
            "description": "Function: `CUME_DIST`\n\nType: Aggregate Function\n\nUsage: `CUME_DIST()`\n\nDescription:  Return the cumulative distribution of a value in a group of values. The result is the number of rows preceding or equal to the current row in the ordering of the partition divided by the number of rows in the window partition.\n\n"
        },
        {
            "name": "PERCENT_RANK",
            "description": "Function: `PERCENT_RANK`\n\nType: Aggregate Function\n\nUsage: `PERCENT_RANK()`\n\nDescription:  Return the percentage ranking of a value in a group of values. The result is the rank value minus one, divided by the number of rows in the parition minus one. If the partition only contains one row, the function will return 0.\n\n"
        },
        {
            "name": "NTILE",
            "description": "Function: `NTILE`\n\nType: Aggregate Function\n\nUsage: `NTILE(n)`\n\nDescription:  Divides the rows for each window partition into `n` buckets ranging from 1 to at most `n`. If the number of rows in the window partition doesn’t divide evenly into the number of buckets, then the remainder values are distributed one per bucket, starting with the first bucket. For example, with 6 rows and 4 buckets, the bucket values would be as follows: 1 1 2 2 3 4\n\n"
        },
        {
            "name": "ARRAY_AGG",
            "description": "Function: `ARRAY_AGG`\n\nType: Aggregate Function\n\nUsage: `ARRAY_AGG([ ALL | DISTINCT ] expression [ RESPECT NULLS | IGNORE NULLS ])`\n\nDescription:  By default or with keyword `ALL` and, return an array that concatenates the input rows and returns `NULL` if there are no input rows. Use `DISTINCT` for one unique instance of each value. By default `NULL` values are respected, use `IGNORE NULLS` to skip `NULL` values. The `ORDER BY` clause is currently not supported.\n\n"
        },
        {
            "name": "JSON_OBJECTAGG",
            "description": "Function: `JSON_OBJECTAGG`\n\nType: Aggregate Function\n\nUsage: `JSON_OBJECTAGG([KEY] key VALUE value [ { NULL | ABSENT } ON NULL ])`\n\nDescription: Builds a JSON object string by aggregating key-value expressions into a single JSON object.\n\nThe key expression must return a non-nullable character string. Value expressions can be arbitrary, including other JSON functions. If a value is `NULL`, the `ON NULL` behavior defines what to do. If omitted, `NULL ON NULL` is assumed by default.\n\nNote that keys must be unique. If a key occurs multiple times, an error will be thrown.\n\nThis function is currently not supported in `OVER` windows.\n\n```sql\n-- '{\"Apple\":2,\"Banana\":17,\"Orange\":0}'\nSELECT\n  JSON_OBJECTAGG(KEY product VALUE cnt)\nFROM orders\n\n```\n\n"
        },
        {
            "name": "JSON_ARRAYAGG",
            "description": "Function: `JSON_ARRAYAGG`\n\nType: Aggregate Function\n\nUsage: `JSON_ARRAYAGG(items [ { NULL | ABSENT } ON NULL ])`\n\nDescription: Builds a JSON object string by aggregating items into an array.\n\nItem expressions can be arbitrary, including other JSON functions. If a value is `NULL`, the`ON NULL` behavior defines what to do. If omitted, `ABSENT ON NULL` is assumed by default.\n\nThis function is currently not supported in `OVER` windows, unbounded session windows, or hop windows.\n\n```sql\n-- '[\"Apple\",\"Banana\",\"Orange\"]'\nSELECT\n  JSON_ARRAYAGG(product)\nFROM orders\n\n```\n\n"
        }
    ],
    "tables": []
}