spark-sql-language-server 0.0.1-beta.0

package/out-tsc/assets/built-in-functions.js

@@ -0,0 +1,3996 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuiltInFunctions = void 0;
+const vscode_languageserver_types_1 = require("vscode-languageserver-types");
+const generateDescription = (v) => {
+    return [`#### ${v.name}`, `${v.funcDesc}`, `#### Examples`, '```sql', `${v.examples?.trim()}`, '```'].join('\n');
+};
+exports.BuiltInFunctions = [
+    {
+        name: 'any(expr)',
+        funcDesc: 'Returns true if at least one value of `expr` is true.',
+        examples: '> SELECT any(col) FROM VALUES (true), (false), (false) AS tab(col);\n true\n> SELECT any(col) FROM VALUES (NULL), (true), (false) AS tab(col);\n true\n> SELECT any(col) FROM VALUES (false), (false), (NULL) AS tab(col);\n false\n',
+        expr: 'any()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'any_value(expr[, isIgnoreNull])',
+        funcDesc: 'Returns some value of `expr` for a group of rows. If `isIgnoreNull` is true, returns only non-null values.',
+        examples: '> SELECT any_value(col) FROM VALUES (10), (5), (20) AS tab(col);\n 10\n> SELECT any_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);\n NULL\n> SELECT any_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);\n 5\n',
+        expr: 'any_value()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'approx_count_distinct(expr[, relativeSD])',
+        funcDesc: 'Returns the estimated cardinality by HyperLogLog++. `relativeSD` defines the maximum relative standard deviation allowed.',
+        examples: '> SELECT approx_count_distinct(col1) FROM VALUES (1), (1), (2), (2), (3) tab(col1);\n 3\n',
+        expr: 'approx_count_distinct()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'approx_percentile(col, percentage [, accuracy])',
+        funcDesc: 'Returns the approximate `percentile` of the numeric or ansi interval column `col` which is the smallest value in the ordered `col` values (sorted from least to greatest) such that no more than `percentage` of `col` values is less than the value or equal to that value. The value of percentage must be between 0.0 and 1.0. The `accuracy` parameter (default: 10000) is a positive numeric literal which controls approximation accuracy at the cost of memory. Higher value of `accuracy` yields better accuracy, `1.0/accuracy` is the relative error of the approximation. When `percentage` is an array, each value of the percentage array must be between 0.0 and 1.0. In this case, returns the approximate percentile array of column `col` at the given percentage array.',
+        examples: "> SELECT approx_percentile(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);\n [1,1,0]\n> SELECT approx_percentile(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);\n 7\n> SELECT approx_percentile(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-1\n> SELECT approx_percentile(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);\n [0 00:00:01.000000000,0 00:00:02.000000000]\n",
+        expr: 'approx_percentile()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_agg(expr)',
+        funcDesc: 'Collects and returns a list of non-unique elements.',
+        examples: '> SELECT array_agg(col) FROM VALUES (1), (2), (1) AS tab(col);\n [1,2,1]\n',
+        expr: 'array_agg()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'avg(expr)',
+        funcDesc: 'Returns the mean calculated from values of a group.',
+        examples: '> SELECT avg(col) FROM VALUES (1), (2), (3) AS tab(col);\n 2.0\n> SELECT avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);\n 1.5\n',
+        expr: 'avg()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_and(expr)',
+        funcDesc: 'Returns the bitwise AND of all non-null input values, or null if none.',
+        examples: '> SELECT bit_and(col) FROM VALUES (3), (5) AS tab(col);\n 1\n',
+        expr: 'bit_and()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_or(expr)',
+        funcDesc: 'Returns the bitwise OR of all non-null input values, or null if none.',
+        examples: '> SELECT bit_or(col) FROM VALUES (3), (5) AS tab(col);\n 7\n',
+        expr: 'bit_or()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_xor(expr)',
+        funcDesc: 'Returns the bitwise XOR of all non-null input values, or null if none.',
+        examples: '> SELECT bit_xor(col) FROM VALUES (3), (5) AS tab(col);\n 6\n',
+        expr: 'bit_xor()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bool_and(expr)',
+        funcDesc: 'Returns true if all values of `expr` are true.',
+        examples: '> SELECT bool_and(col) FROM VALUES (true), (true), (true) AS tab(col);\n true\n> SELECT bool_and(col) FROM VALUES (NULL), (true), (true) AS tab(col);\n true\n> SELECT bool_and(col) FROM VALUES (true), (false), (true) AS tab(col);\n false\n',
+        expr: 'bool_and()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bool_or(expr)',
+        funcDesc: 'Returns true if at least one value of `expr` is true.',
+        examples: '> SELECT bool_or(col) FROM VALUES (true), (false), (false) AS tab(col);\n true\n> SELECT bool_or(col) FROM VALUES (NULL), (true), (false) AS tab(col);\n true\n> SELECT bool_or(col) FROM VALUES (false), (false), (NULL) AS tab(col);\n false\n',
+        expr: 'bool_or()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'collect_list(expr)',
+        funcDesc: 'Collects and returns a list of non-unique elements.',
+        examples: '> SELECT collect_list(col) FROM VALUES (1), (2), (1) AS tab(col);\n [1,2,1]\n',
+        expr: 'collect_list()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'collect_set(expr)',
+        funcDesc: 'Collects and returns a set of unique elements.',
+        examples: '> SELECT collect_set(col) FROM VALUES (1), (2), (1) AS tab(col);\n [1,2]\n',
+        expr: 'collect_set()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'corr(expr1, expr2)',
+        funcDesc: 'Returns Pearson coefficient of correlation between a set of number pairs.',
+        examples: '> SELECT corr(c1, c2) FROM VALUES (3, 2), (3, 3), (6, 4) as tab(c1, c2);\n 0.8660254037844387\n',
+        expr: 'corr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'count(*)',
+        funcDesc: 'Returns the total number of retrieved rows, including rows containing null.',
+        examples: '> SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 4\n> SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 3\n> SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);\n 2\n',
+        expr: 'count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'count(expr[, expr...])',
+        funcDesc: 'Returns the number of rows for which the supplied expression(s) are all non-null.',
+        examples: '> SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 4\n> SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 3\n> SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);\n 2\n',
+        expr: 'count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'count(DISTINCT expr[, expr...])',
+        funcDesc: 'Returns the number of rows for which the supplied expression(s) are unique and non-null.',
+        examples: '> SELECT count(*) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 4\n> SELECT count(col) FROM VALUES (NULL), (5), (5), (20) AS tab(col);\n 3\n> SELECT count(DISTINCT col) FROM VALUES (NULL), (5), (5), (10) AS tab(col);\n 2\n',
+        expr: 'count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'count_if(expr)',
+        funcDesc: 'Returns the number of `TRUE` values for the expression.',
+        examples: '> SELECT count_if(col % 2 = 0) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);\n 2\n> SELECT count_if(col IS NULL) FROM VALUES (NULL), (0), (1), (2), (3) AS tab(col);\n 1\n',
+        expr: 'count_if()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'count_min_sketch(col, eps, confidence, seed)',
+        funcDesc: 'Returns a count-min sketch of a column with the given esp, confidence and seed. The result is an array of bytes, which can be deserialized to a `CountMinSketch` before usage. Count-min sketch is a probabilistic data structure used for cardinality estimation using sub-linear space.',
+        examples: '> SELECT hex(count_min_sketch(col, 0.5d, 0.5d, 1)) FROM VALUES (1), (2), (1) AS tab(col);\n 0000000100000000000000030000000100000004000000005D8D6AB90000000000000000000000000000000200000000000000010000000000000000\n',
+        expr: 'count_min_sketch()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'covar_pop(expr1, expr2)',
+        funcDesc: 'Returns the population covariance of a set of number pairs.',
+        examples: '> SELECT covar_pop(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);\n 0.6666666666666666\n',
+        expr: 'covar_pop()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'covar_samp(expr1, expr2)',
+        funcDesc: 'Returns the sample covariance of a set of number pairs.',
+        examples: '> SELECT covar_samp(c1, c2) FROM VALUES (1,1), (2,2), (3,3) AS tab(c1, c2);\n 1.0\n',
+        expr: 'covar_samp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'every(expr)',
+        funcDesc: 'Returns true if all values of `expr` are true.',
+        examples: '> SELECT every(col) FROM VALUES (true), (true), (true) AS tab(col);\n true\n> SELECT every(col) FROM VALUES (NULL), (true), (true) AS tab(col);\n true\n> SELECT every(col) FROM VALUES (true), (false), (true) AS tab(col);\n false\n',
+        expr: 'every()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'first(expr[, isIgnoreNull])',
+        funcDesc: 'Returns the first value of `expr` for a group of rows. If `isIgnoreNull` is true, returns only non-null values.',
+        examples: '> SELECT first(col) FROM VALUES (10), (5), (20) AS tab(col);\n 10\n> SELECT first(col) FROM VALUES (NULL), (5), (20) AS tab(col);\n NULL\n> SELECT first(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);\n 5\n',
+        expr: 'first()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'first_value(expr[, isIgnoreNull])',
+        funcDesc: 'Returns the first value of `expr` for a group of rows. If `isIgnoreNull` is true, returns only non-null values.',
+        examples: '> SELECT first_value(col) FROM VALUES (10), (5), (20) AS tab(col);\n 10\n> SELECT first_value(col) FROM VALUES (NULL), (5), (20) AS tab(col);\n NULL\n> SELECT first_value(col, true) FROM VALUES (NULL), (5), (20) AS tab(col);\n 5\n',
+        expr: 'first_value()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'grouping(col)',
+        funcDesc: 'indicates whether a specified column in a GROUP BY is aggregated or not, returns 1 for aggregated or 0 for not aggregated in the result set.",',
+        examples: "> SELECT name, grouping(name), sum(age) FROM VALUES (2, 'Alice'), (5, 'Bob') people(age, name) GROUP BY cube(name);\n  Alice 0   2\n  Bob   0   5\n  NULL  1   7\n",
+        expr: 'grouping()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'grouping_id([col1[, col2 ..]])',
+        funcDesc: 'returns the level of grouping, equals to `(grouping(c1) << (n-1)) + (grouping(c2) << (n-2)) + ... + grouping(cn)`',
+        examples: "> SELECT name, grouping_id(), sum(age), avg(height) FROM VALUES (2, 'Alice', 165), (5, 'Bob', 180) people(age, name, height) GROUP BY cube(name, height);\n  Alice 0   2   165.0\n  Alice 1   2   165.0\n  NULL  3   7   172.5\n  Bob   0   5   180.0\n  Bob   1   5   180.0\n  NULL  2   2   165.0\n  NULL  2   5   180.0\n",
+        expr: 'grouping_id()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'histogram_numeric(expr, nb)',
+        funcDesc: "Computes a histogram on numeric 'expr' using nb bins. The return value is an array of (x,y) pairs representing the centers of the histogram's bins. As the value of 'nb' is increased, the histogram approximation gets finer-grained, but may yield artifacts around outliers. In practice, 20-40 histogram bins appear to work well, with more bins being required for skewed or smaller datasets. Note that this function creates a histogram with non-uniform bin widths. It offers no guarantees in terms of the mean-squared-error of the histogram, but in practice is comparable to the histograms produced by the R/S-Plus statistical computing packages. Note: the output type of the 'x' field in the return value is propagated from the input value consumed in the aggregate function.",
+        examples: '> SELECT histogram_numeric(col, 5) FROM VALUES (0), (1), (2), (10) AS tab(col);\n [{"x":0,"y":1.0},{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":10,"y":1.0}]\n',
+        expr: 'histogram_numeric()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'kurtosis(expr)',
+        funcDesc: 'Returns the kurtosis value calculated from values of a group.',
+        examples: '> SELECT kurtosis(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);\n -0.7014368047529627\n> SELECT kurtosis(col) FROM VALUES (1), (10), (100), (10), (1) as tab(col);\n 0.19432323191699075\n',
+        expr: 'kurtosis()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'last(expr[, isIgnoreNull])',
+        funcDesc: 'Returns the last value of `expr` for a group of rows. If `isIgnoreNull` is true, returns only non-null values',
+        examples: '> SELECT last(col) FROM VALUES (10), (5), (20) AS tab(col);\n 20\n> SELECT last(col) FROM VALUES (10), (5), (NULL) AS tab(col);\n NULL\n> SELECT last(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);\n 5\n',
+        expr: 'last()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'last_value(expr[, isIgnoreNull])',
+        funcDesc: 'Returns the last value of `expr` for a group of rows. If `isIgnoreNull` is true, returns only non-null values',
+        examples: '> SELECT last_value(col) FROM VALUES (10), (5), (20) AS tab(col);\n 20\n> SELECT last_value(col) FROM VALUES (10), (5), (NULL) AS tab(col);\n NULL\n> SELECT last_value(col, true) FROM VALUES (10), (5), (NULL) AS tab(col);\n 5\n',
+        expr: 'last_value()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'max(expr)',
+        funcDesc: 'Returns the maximum value of `expr`.',
+        examples: '> SELECT max(col) FROM VALUES (10), (50), (20) AS tab(col);\n 50\n',
+        expr: 'max()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'max_by(x, y)',
+        funcDesc: 'Returns the value of `x` associated with the maximum value of `y`.',
+        examples: "> SELECT max_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);\n b\n",
+        expr: 'max_by()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'mean(expr)',
+        funcDesc: 'Returns the mean calculated from values of a group.',
+        examples: '> SELECT mean(col) FROM VALUES (1), (2), (3) AS tab(col);\n 2.0\n> SELECT mean(col) FROM VALUES (1), (2), (NULL) AS tab(col);\n 1.5\n',
+        expr: 'mean()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'median(col)',
+        funcDesc: 'Returns the median of numeric or ANSI interval column `col`.',
+        examples: "> SELECT median(col) FROM VALUES (0), (10) AS tab(col);\n 5.0\n> SELECT median(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-5\n",
+        expr: 'median()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'min(expr)',
+        funcDesc: 'Returns the minimum value of `expr`.',
+        examples: '> SELECT min(col) FROM VALUES (10), (-1), (20) AS tab(col);\n -1\n',
+        expr: 'min()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'min_by(x, y)',
+        funcDesc: 'Returns the value of `x` associated with the minimum value of `y`.',
+        examples: "> SELECT min_by(x, y) FROM VALUES (('a', 10)), (('b', 50)), (('c', 20)) AS tab(x, y);\n a\n",
+        expr: 'min_by()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'mode(col)',
+        funcDesc: 'Returns the most frequent value for the values within `col`. NULL values are ignored. If all the values are NULL, or there are 0 rows, returns NULL.',
+        examples: "> SELECT mode(col) FROM VALUES (0), (10), (10) AS tab(col);\n 10\n> SELECT mode(col) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-10\n> SELECT mode(col) FROM VALUES (0), (10), (10), (null), (null), (null) AS tab(col);\n 10\n",
+        expr: 'mode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'percentile(col, percentage [, frequency])',
+        funcDesc: 'Returns the exact percentile value of numeric or ANSI interval column `col` at the given percentage. The value of percentage must be between 0.0 and 1.0. The value of frequency should be positive integral',
+        examples: "> SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);\n 3.0\n> SELECT percentile(col, array(0.25, 0.75)) FROM VALUES (0), (10) AS tab(col);\n [2.5,7.5]\n> SELECT percentile(col, 0.5) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-5\n> SELECT percentile(col, array(0.2, 0.5)) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '10' SECOND) AS tab(col);\n [0 00:00:02.000000000,0 00:00:05.000000000]\n",
+        expr: 'percentile()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'percentile(col, array(percentage1 [, percentage2]...) [, frequency])',
+        funcDesc: 'Returns the exact percentile value array of numeric column `col` at the given percentage(s). Each value of the percentage array must be between 0.0 and 1.0. The value of frequency should be positive integral',
+        examples: "> SELECT percentile(col, 0.3) FROM VALUES (0), (10) AS tab(col);\n 3.0\n> SELECT percentile(col, array(0.25, 0.75)) FROM VALUES (0), (10) AS tab(col);\n [2.5,7.5]\n> SELECT percentile(col, 0.5) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-5\n> SELECT percentile(col, array(0.2, 0.5)) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '10' SECOND) AS tab(col);\n [0 00:00:02.000000000,0 00:00:05.000000000]\n",
+        expr: 'percentile()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'percentile_approx(col, percentage [, accuracy])',
+        funcDesc: 'Returns the approximate `percentile` of the numeric or ansi interval column `col` which is the smallest value in the ordered `col` values (sorted from least to greatest) such that no more than `percentage` of `col` values is less than the value or equal to that value. The value of percentage must be between 0.0 and 1.0. The `accuracy` parameter (default: 10000) is a positive numeric literal which controls approximation accuracy at the cost of memory. Higher value of `accuracy` yields better accuracy, `1.0/accuracy` is the relative error of the approximation. When `percentage` is an array, each value of the percentage array must be between 0.0 and 1.0. In this case, returns the approximate percentile array of column `col` at the given percentage array.',
+        examples: "> SELECT percentile_approx(col, array(0.5, 0.4, 0.1), 100) FROM VALUES (0), (1), (2), (10) AS tab(col);\n [1,1,0]\n> SELECT percentile_approx(col, 0.5, 100) FROM VALUES (0), (6), (7), (9), (10) AS tab(col);\n 7\n> SELECT percentile_approx(col, 0.5, 100) FROM VALUES (INTERVAL '0' MONTH), (INTERVAL '1' MONTH), (INTERVAL '2' MONTH), (INTERVAL '10' MONTH) AS tab(col);\n 0-1\n> SELECT percentile_approx(col, array(0.5, 0.7), 100) FROM VALUES (INTERVAL '0' SECOND), (INTERVAL '1' SECOND), (INTERVAL '2' SECOND), (INTERVAL '10' SECOND) AS tab(col);\n [0 00:00:01.000000000,0 00:00:02.000000000]\n",
+        expr: 'percentile_approx()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_avgx(y, x)',
+        funcDesc: 'Returns the average of the independent variable for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 2.75\n> SELECT regr_avgx(y, x) FROM VALUES (1, null) AS tab(y, x);\n NULL\n> SELECT regr_avgx(y, x) FROM VALUES (null, 1) AS tab(y, x);\n NULL\n> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 3.0\n> SELECT regr_avgx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 3.0\n',
+        expr: 'regr_avgx()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_avgy(y, x)',
+        funcDesc: 'Returns the average of the dependent variable for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 1.75\n> SELECT regr_avgy(y, x) FROM VALUES (1, null) AS tab(y, x);\n NULL\n> SELECT regr_avgy(y, x) FROM VALUES (null, 1) AS tab(y, x);\n NULL\n> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 1.6666666666666667\n> SELECT regr_avgy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 1.5\n',
+        expr: 'regr_avgy()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_count(y, x)',
+        funcDesc: 'Returns the number of non-null number pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 4\n> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 3\n> SELECT regr_count(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 2\n',
+        expr: 'regr_count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_intercept(y, x)',
+        funcDesc: 'Returns the intercept of the univariate linear regression line for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_intercept(y, x) FROM VALUES (1,1), (2,2), (3,3) AS tab(y, x);\n 0.0\n> SELECT regr_intercept(y, x) FROM VALUES (1, null) AS tab(y, x);\n NULL\n> SELECT regr_intercept(y, x) FROM VALUES (null, 1) AS tab(y, x);\n NULL\n',
+        expr: 'regr_intercept()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_r2(y, x)',
+        funcDesc: 'Returns the coefficient of determination for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 0.2727272727272727\n> SELECT regr_r2(y, x) FROM VALUES (1, null) AS tab(y, x);\n NULL\n> SELECT regr_r2(y, x) FROM VALUES (null, 1) AS tab(y, x);\n NULL\n> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 0.7500000000000001\n> SELECT regr_r2(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 1.0\n',
+        expr: 'regr_r2()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_slope(y, x)',
+        funcDesc: 'Returns the slope of the linear regression line for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_slope(y, x) FROM VALUES (1,1), (2,2), (3,3) AS tab(y, x);\n 1.0\n> SELECT regr_slope(y, x) FROM VALUES (1, null) AS tab(y, x);\n NULL\n> SELECT regr_slope(y, x) FROM VALUES (null, 1) AS tab(y, x);\n NULL\n',
+        expr: 'regr_slope()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_sxx(y, x)',
+        funcDesc: 'Returns REGR_COUNT(y, x) * VAR_POP(x) for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 2.75\n> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 2.0\n> SELECT regr_sxx(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 2.0\n',
+        expr: 'regr_sxx()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_sxy(y, x)',
+        funcDesc: 'Returns REGR_COUNT(y, x) * COVAR_POP(y, x) for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 0.75\n> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 1.0\n> SELECT regr_sxy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 1.0\n',
+        expr: 'regr_sxy()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regr_syy(y, x)',
+        funcDesc: 'Returns REGR_COUNT(y, x) * VAR_POP(y) for non-null pairs in a group, where `y` is the dependent variable and `x` is the independent variable.',
+        examples: '> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, 2), (2, 3), (2, 4) AS tab(y, x);\n 0.75\n> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (2, 3), (2, 4) AS tab(y, x);\n 0.6666666666666666\n> SELECT regr_syy(y, x) FROM VALUES (1, 2), (2, null), (null, 3), (2, 4) AS tab(y, x);\n 0.5\n',
+        expr: 'regr_syy()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'skewness(expr)',
+        funcDesc: 'Returns the skewness value calculated from values of a group.',
+        examples: '> SELECT skewness(col) FROM VALUES (-10), (-20), (100), (1000) AS tab(col);\n 1.1135657469022011\n> SELECT skewness(col) FROM VALUES (-1000), (-100), (10), (20) AS tab(col);\n -1.1135657469022011\n',
+        expr: 'skewness()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'some(expr)',
+        funcDesc: 'Returns true if at least one value of `expr` is true.',
+        examples: '> SELECT some(col) FROM VALUES (true), (false), (false) AS tab(col);\n true\n> SELECT some(col) FROM VALUES (NULL), (true), (false) AS tab(col);\n true\n> SELECT some(col) FROM VALUES (false), (false), (NULL) AS tab(col);\n false\n',
+        expr: 'some()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'std(expr)',
+        funcDesc: 'Returns the sample standard deviation calculated from values of a group.',
+        examples: '> SELECT std(col) FROM VALUES (1), (2), (3) AS tab(col);\n 1.0\n',
+        expr: 'std()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'stddev(expr)',
+        funcDesc: 'Returns the sample standard deviation calculated from values of a group.',
+        examples: '> SELECT stddev(col) FROM VALUES (1), (2), (3) AS tab(col);\n 1.0\n',
+        expr: 'stddev()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'stddev_pop(expr)',
+        funcDesc: 'Returns the population standard deviation calculated from values of a group.',
+        examples: '> SELECT stddev_pop(col) FROM VALUES (1), (2), (3) AS tab(col);\n 0.816496580927726\n',
+        expr: 'stddev_pop()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'stddev_samp(expr)',
+        funcDesc: 'Returns the sample standard deviation calculated from values of a group.',
+        examples: '> SELECT stddev_samp(col) FROM VALUES (1), (2), (3) AS tab(col);\n 1.0\n',
+        expr: 'stddev_samp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sum(expr)',
+        funcDesc: 'Returns the sum calculated from values of a group.',
+        examples: '> SELECT sum(col) FROM VALUES (5), (10), (15) AS tab(col);\n 30\n> SELECT sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);\n 25\n> SELECT sum(col) FROM VALUES (NULL), (NULL) AS tab(col);\n NULL\n',
+        expr: 'sum()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_avg(expr)',
+        funcDesc: 'Returns the mean calculated from values of a group and the result is null on overflow.',
+        examples: "> SELECT try_avg(col) FROM VALUES (1), (2), (3) AS tab(col);\n 2.0\n> SELECT try_avg(col) FROM VALUES (1), (2), (NULL) AS tab(col);\n 1.5\n> SELECT try_avg(col) FROM VALUES (interval '2147483647 months'), (interval '1 months') AS tab(col);\n NULL\n",
+        expr: 'try_avg()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_sum(expr)',
+        funcDesc: 'Returns the sum calculated from values of a group and the result is null on overflow.',
+        examples: '> SELECT try_sum(col) FROM VALUES (5), (10), (15) AS tab(col);\n 30\n> SELECT try_sum(col) FROM VALUES (NULL), (10), (15) AS tab(col);\n 25\n> SELECT try_sum(col) FROM VALUES (NULL), (NULL) AS tab(col);\n NULL\n> SELECT try_sum(col) FROM VALUES (9223372036854775807L), (1L) AS tab(col);\n NULL\n',
+        expr: 'try_sum()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'var_pop(expr)',
+        funcDesc: 'Returns the population variance calculated from values of a group.',
+        examples: '> SELECT var_pop(col) FROM VALUES (1), (2), (3) AS tab(col);\n 0.6666666666666666\n',
+        expr: 'var_pop()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'var_samp(expr)',
+        funcDesc: 'Returns the sample variance calculated from values of a group.',
+        examples: '> SELECT var_samp(col) FROM VALUES (1), (2), (3) AS tab(col);\n 1.0\n',
+        expr: 'var_samp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'variance(expr)',
+        funcDesc: 'Returns the sample variance calculated from values of a group.',
+        examples: '> SELECT variance(col) FROM VALUES (1), (2), (3) AS tab(col);\n 1.0\n',
+        expr: 'variance()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cume_dist()',
+        funcDesc: 'Computes the position of a value relative to all values in the partition.',
+        examples: "> SELECT a, b, cume_dist() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   0.6666666666666666\n A1 1   0.6666666666666666\n A1 2   1.0\n A2 3   1.0\n",
+        expr: 'cume_dist()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'dense_rank()',
+        funcDesc: 'Computes 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.',
+        examples: "> SELECT a, b, dense_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   1\n A1 2   2\n A2 3   1\n",
+        expr: 'dense_rank()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'lag(input[, offset[, default]])',
+        funcDesc: 'Returns the value of `input` at the `offset`th row before the current row in the window. The default value of `offset` is 1 and the default value of `default` is null. If the value of `input` at the `offset`th row is null, null is returned. If there is no such offset row (e.g., when the offset is 1, the first row of the window does not have any previous row), `default` is returned.',
+        examples: "> SELECT a, b, lag(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   NULL\n A1 1   1\n A1 2   1\n A2 3   NULL\n",
+        expr: 'lag()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'lead(input[, offset[, default]])',
+        funcDesc: 'Returns the value of `input` at the `offset`th row after the current row in the window. The default value of `offset` is 1 and the default value of `default` is null. If the value of `input` at the `offset`th row is null, null is returned. If there is no such an offset row (e.g., when the offset is 1, the last row of the window does not have any subsequent row), `default` is returned.',
+        examples: "> SELECT a, b, lead(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   2\n A1 2   NULL\n A2 3   NULL\n",
+        expr: 'lead()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'nth_value(input[, offset])',
+        funcDesc: 'Returns the value of `input` at the row that is the `offset`th row from beginning of the window frame. Offset starts at 1. If ignoreNulls=true, we will skip nulls when finding the `offset`th row. Otherwise, every row counts for the `offset`. If there is no such an `offset`th row (e.g., when the offset is 10, size of the window frame is less than 10), null is returned.',
+        examples: "> SELECT a, b, nth_value(b, 2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   1\n A1 2   1\n A2 3   NULL\n",
+        expr: 'nth_value()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ntile(n)',
+        funcDesc: 'Divides the rows for each window partition into `n` buckets ranging from 1 to at most `n`.',
+        examples: "> SELECT a, b, ntile(2) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   1\n A1 2   2\n A2 3   1\n",
+        expr: 'ntile()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'percent_rank()',
+        funcDesc: 'Computes the percentage ranking of a value in a group of values.',
+        examples: "> SELECT a, b, percent_rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   0.0\n A1 1   0.0\n A1 2   1.0\n A2 3   0.0\n",
+        expr: 'percent_rank()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rank()',
+        funcDesc: 'Computes 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.',
+        examples: "> SELECT a, b, rank(b) OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   1\n A1 2   3\n A2 3   1\n",
+        expr: 'rank()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'row_number()',
+        funcDesc: 'Assigns a unique, sequential number to each row, starting with one, according to the ordering of rows within the window partition.',
+        examples: "> SELECT a, b, row_number() OVER (PARTITION BY a ORDER BY b) FROM VALUES ('A1', 2), ('A1', 1), ('A2', 3), ('A1', 1) tab(a, b);\n A1 1   1\n A1 1   2\n A1 2   3\n A2 3   1\n",
+        expr: 'row_number()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array(expr, ...)',
+        funcDesc: 'Returns an array with the given elements.',
+        examples: '> SELECT array(1, 2, 3);\n [1,2,3]\n',
+        expr: 'array()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_append(array, element)',
+        funcDesc: 'Add the element at the end of the array passed as first argument. Type of element should be similar to type of the elements of the array. Null element is also appended into the array. But if the array passed, is NULL output is NULL',
+        examples: '> SELECT array_append(array(\'b\', \'d\', \'c\', \'a\'), \'d\');\n ["b","d","c","a","d"]\n> SELECT array_append(array(1, 2, 3, null), null);\n [1,2,3,null,null]\n> SELECT array_append(CAST(null as Array<Int>), 2);\n NULL\n',
+        expr: 'array_append()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_compact(array)',
+        funcDesc: 'Removes null values from the array.',
+        examples: '> SELECT array_compact(array(1, 2, 3, null));\n [1,2,3]\n> SELECT array_compact(array("a", "b", "c"));\n ["a","b","c"]\n',
+        expr: 'array_compact()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_contains(array, value)',
+        funcDesc: 'Returns true if the array contains the value.',
+        examples: '> SELECT array_contains(array(1, 2, 3), 2);\n true\n',
+        expr: 'array_contains()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_distinct(array)',
+        funcDesc: 'Removes duplicate values from the array.',
+        examples: '> SELECT array_distinct(array(1, 2, 3, null, 3));\n [1,2,3,null]\n',
+        expr: 'array_distinct()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_except(array1, array2)',
+        funcDesc: 'Returns an array of the elements in array1 but not in array2, without duplicates.',
+        examples: '> SELECT array_except(array(1, 2, 3), array(1, 3, 5));\n [2]\n',
+        expr: 'array_except()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_insert(x, pos, val)',
+        funcDesc: "Places val into index pos of array x. Array indices start at 1, or start from the end if index is negative. Index above array size appends the array, or prepends the array if index is negative, with 'null' elements.",
+        examples: '> SELECT array_insert(array(1, 2, 3, 4), 5, 5);\n [1,2,3,4,5]\n> SELECT array_insert(array(5, 3, 2, 1), -3, 4);\n [5,4,3,2,1]\n',
+        expr: 'array_insert()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_intersect(array1, array2)',
+        funcDesc: 'Returns an array of the elements in the intersection of array1 and array2, without duplicates.',
+        examples: '> SELECT array_intersect(array(1, 2, 3), array(1, 3, 5));\n [1,3]\n',
+        expr: 'array_intersect()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_join(array, delimiter[, nullReplacement])',
+        funcDesc: 'Concatenates the elements of the given array using the delimiter and an optional string to replace nulls. If no value is set for nullReplacement, any null value is filtered.',
+        examples: "> SELECT array_join(array('hello', 'world'), ' ');\n hello world\n> SELECT array_join(array('hello', null ,'world'), ' ');\n hello world\n> SELECT array_join(array('hello', null ,'world'), ' ', ',');\n hello , world\n",
+        expr: 'array_join()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_max(array)',
+        funcDesc: 'Returns the maximum value in the array. NaN is greater than any non-NaN elements for double/float type. NULL elements are skipped.',
+        examples: '> SELECT array_max(array(1, 20, null, 3));\n 20\n',
+        expr: 'array_max()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_min(array)',
+        funcDesc: 'Returns the minimum value in the array. NaN is greater than any non-NaN elements for double/float type. NULL elements are skipped.',
+        examples: '> SELECT array_min(array(1, 20, null, 3));\n 1\n',
+        expr: 'array_min()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_position(array, element)',
+        funcDesc: 'Returns the (1-based) index of the first element of the array as long.',
+        examples: '> SELECT array_position(array(3, 2, 1), 1);\n 3\n',
+        expr: 'array_position()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_remove(array, element)',
+        funcDesc: 'Remove all elements that equal to element from array.',
+        examples: '> SELECT array_remove(array(1, 2, 3, null, 3), 3);\n [1,2,null]\n',
+        expr: 'array_remove()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_repeat(element, count)',
+        funcDesc: 'Returns the array containing element count times.',
+        examples: '> SELECT array_repeat(\'123\', 2);\n ["123","123"]\n',
+        expr: 'array_repeat()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'array_union(array1, array2)',
+        funcDesc: 'Returns an array of the elements in the union of array1 and array2, without duplicates.',
+        examples: '> SELECT array_union(array(1, 2, 3), array(1, 3, 5));\n [1,2,3,5]\n',
+        expr: 'array_union()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'arrays_overlap(a1, a2)',
+        funcDesc: 'Returns true if a1 contains at least a non-null element present also in a2. If the arrays have no common element and they are both non-empty and either of them contains a null element null is returned, false otherwise.',
+        examples: '> SELECT arrays_overlap(array(1, 2, 3), array(3, 4, 5));\n true\n',
+        expr: 'arrays_overlap()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'arrays_zip(a1, a2, ...)',
+        funcDesc: 'Returns a merged array of structs in which the N-th struct contains all N-th values of input arrays.',
+        examples: '> SELECT arrays_zip(array(1, 2, 3), array(2, 3, 4));\n [{"0":1,"1":2},{"0":2,"1":3},{"0":3,"1":4}]\n> SELECT arrays_zip(array(1, 2), array(2, 3), array(3, 4));\n [{"0":1,"1":2,"2":3},{"0":2,"1":3,"2":4}]\n',
+        expr: 'arrays_zip()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'flatten(arrayOfArrays)',
+        funcDesc: 'Transforms an array of arrays into a single array.',
+        examples: '> SELECT flatten(array(array(1, 2), array(3, 4)));\n [1,2,3,4]\n',
+        expr: 'flatten()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'get(array, index)',
+        funcDesc: 'Returns element of array at given (0-based) index. If the index points outside of the array boundaries, then this function returns NULL.',
+        examples: '> SELECT get(array(1, 2, 3), 0);\n 1\n> SELECT get(array(1, 2, 3), 3);\n NULL\n> SELECT get(array(1, 2, 3), -1);\n NULL\n',
+        expr: 'get()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sequence(start, stop, step)',
+        funcDesc: "Generates an array of elements from start to stop (inclusive), incrementing by step. The type of the returned elements is the same as the type of argument expressions. Supported types are: byte, short, integer, long, date, timestamp. The start and stop expressions must resolve to the same type. If start and stop expressions resolve to the 'date' or 'timestamp' type then the step expression must resolve to the 'interval' or 'year-month interval' or 'day-time interval' type, otherwise to the same type as the start and stop expressions.",
+        examples: "> SELECT sequence(1, 5);\n [1,2,3,4,5]\n> SELECT sequence(5, 1);\n [5,4,3,2,1]\n> SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval 1 month);\n [2018-01-01,2018-02-01,2018-03-01]\n> SELECT sequence(to_date('2018-01-01'), to_date('2018-03-01'), interval '0-1' year to month);\n [2018-01-01,2018-02-01,2018-03-01]\n",
+        expr: 'sequence()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'shuffle(array)',
+        funcDesc: 'Returns a random permutation of the given array.',
+        examples: '> SELECT shuffle(array(1, 20, 3, 5));\n [3,1,5,20]\n> SELECT shuffle(array(1, 20, null, 3));\n [20,null,3,1]\n',
+        expr: 'shuffle()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'slice(x, start, length)',
+        funcDesc: 'Subsets array x starting from index start (array indices start at 1, or starting from the end if start is negative) with the specified length.',
+        examples: '> SELECT slice(array(1, 2, 3, 4), 2, 2);\n [2,3]\n> SELECT slice(array(1, 2, 3, 4), -2, 2);\n [3,4]\n',
+        expr: 'slice()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sort_array(array[, ascendingOrder])',
+        funcDesc: 'Sorts the input array in ascending or descending order according to the natural ordering of the array elements. NaN is greater than any non-NaN elements for double/float type. Null elements will be placed at the beginning of the returned array in ascending order or at the end of the returned array in descending order.',
+        examples: '> SELECT sort_array(array(\'b\', \'d\', null, \'c\', \'a\'), true);\n [null,"a","b","c","d"]\n',
+        expr: 'sort_array()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'element_at(array, index)',
+        funcDesc: 'Returns element of array at given (1-based) index. If Index is 0, Spark will throw an error. If index < 0, accesses elements from the last to the first. The function returns NULL if the index exceeds the length of the array and `spark.sql.ansi.enabled` is set to false. If `spark.sql.ansi.enabled` is set to true, it throws ArrayIndexOutOfBoundsException for invalid indices.',
+        examples: "> SELECT element_at(array(1, 2, 3), 2);\n 2\n> SELECT element_at(map(1, 'a', 2, 'b'), 2);\n b\n",
+        expr: 'element_at()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'element_at(map, key)',
+        funcDesc: 'Returns value for given key. The function returns NULL if the key is not contained in the map.',
+        examples: "> SELECT element_at(array(1, 2, 3), 2);\n 2\n> SELECT element_at(map(1, 'a', 2, 'b'), 2);\n b\n",
+        expr: 'element_at()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map(key0, value0, key1, value1, ...)',
+        funcDesc: 'Creates a map with the given key/value pairs.',
+        examples: '> SELECT map(1.0, \'2\', 3.0, \'4\');\n {1.0:"2",3.0:"4"}\n',
+        expr: 'map()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_concat(map, ...)',
+        funcDesc: 'Returns the union of all the given maps',
+        examples: '> SELECT map_concat(map(1, \'a\', 2, \'b\'), map(3, \'c\'));\n {1:"a",2:"b",3:"c"}\n',
+        expr: 'map_concat()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_contains_key(map, key)',
+        funcDesc: 'Returns true if the map contains the key.',
+        examples: "> SELECT map_contains_key(map(1, 'a', 2, 'b'), 1);\n true\n> SELECT map_contains_key(map(1, 'a', 2, 'b'), 3);\n false\n",
+        expr: 'map_contains_key()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_entries(map)',
+        funcDesc: 'Returns an unordered array of all entries in the given map.',
+        examples: '> SELECT map_entries(map(1, \'a\', 2, \'b\'));\n [{"key":1,"value":"a"},{"key":2,"value":"b"}]\n',
+        expr: 'map_entries()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_from_arrays(keys, values)',
+        funcDesc: 'Creates a map with a pair of the given key/value arrays. All elements in keys should not be null',
+        examples: '> SELECT map_from_arrays(array(1.0, 3.0), array(\'2\', \'4\'));\n {1.0:"2",3.0:"4"}\n',
+        expr: 'map_from_arrays()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_from_entries(arrayOfEntries)',
+        funcDesc: 'Returns a map created from the given array of entries.',
+        examples: '> SELECT map_from_entries(array(struct(1, \'a\'), struct(2, \'b\')));\n {1:"a",2:"b"}\n',
+        expr: 'map_from_entries()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_keys(map)',
+        funcDesc: 'Returns an unordered array containing the keys of the map.',
+        examples: "> SELECT map_keys(map(1, 'a', 2, 'b'));\n [1,2]\n",
+        expr: 'map_keys()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'map_values(map)',
+        funcDesc: 'Returns an unordered array containing the values of the map.',
+        examples: '> SELECT map_values(map(1, \'a\', 2, \'b\'));\n ["a","b"]\n',
+        expr: 'map_values()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'str_to_map(text[, pairDelim[, keyValueDelim]])',
+        funcDesc: "Creates a map after splitting the text into key/value pairs using delimiters. Default delimiters are ',' for `pairDelim` and ':' for `keyValueDelim`. Both `pairDelim` and `keyValueDelim` are treated as regular expressions.",
+        examples: '> SELECT str_to_map(\'a:1,b:2,c:3\', \',\', \':\');\n {"a":"1","b":"2","c":"3"}\n> SELECT str_to_map(\'a\');\n {"a":null}\n',
+        expr: 'str_to_map()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_element_at(array, index)',
+        funcDesc: 'Returns element of array at given (1-based) index. If Index is 0, Spark will throw an error. If index < 0, accesses elements from the last to the first. The function always returns NULL if the index exceeds the length of the array.',
+        examples: "> SELECT try_element_at(array(1, 2, 3), 2);\n 2\n> SELECT try_element_at(map(1, 'a', 2, 'b'), 2);\n b\n",
+        expr: 'try_element_at()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_element_at(map, key)',
+        funcDesc: 'Returns value for given key. The function always returns NULL if the key is not contained in the map.',
+        examples: "> SELECT try_element_at(array(1, 2, 3), 2);\n 2\n> SELECT try_element_at(map(1, 'a', 2, 'b'), 2);\n b\n",
+        expr: 'try_element_at()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'add_months(start_date, num_months)',
+        funcDesc: 'Returns the date that is `num_months` after `start_date`.',
+        examples: "> SELECT add_months('2016-08-31', 1);\n 2016-09-30\n",
+        expr: 'add_months()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'convert_timezone([sourceTz, ]targetTz, sourceTs)',
+        funcDesc: 'Converts the timestamp without time zone `sourceTs` from the `sourceTz` time zone to `targetTz`.',
+        examples: "> SELECT convert_timezone('Europe/Brussels', 'America/Los_Angeles', timestamp_ntz'2021-12-06 00:00:00');\n 2021-12-05 15:00:00\n> SELECT convert_timezone('Europe/Brussels', timestamp_ntz'2021-12-05 15:00:00');\n 2021-12-06 00:00:00\n",
+        expr: 'convert_timezone()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'curdate()',
+        funcDesc: 'Returns the current date at the start of query evaluation. All calls of curdate within the same query return the same value.',
+        examples: '> SELECT curdate();\n 2022-09-06\n',
+        expr: 'curdate()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_date()',
+        funcDesc: 'Returns the current date at the start of query evaluation. All calls of current_date within the same query return the same value.',
+        examples: '> SELECT current_date();\n 2020-04-25\n> SELECT current_date;\n 2020-04-25\n',
+        expr: 'current_date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_date',
+        funcDesc: 'Returns the current date at the start of query evaluation.',
+        examples: '> SELECT current_date();\n 2020-04-25\n> SELECT current_date;\n 2020-04-25\n',
+        expr: 'current_date',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_timestamp()',
+        funcDesc: 'Returns the current timestamp at the start of query evaluation. All calls of current_timestamp within the same query return the same value.',
+        examples: '> SELECT current_timestamp();\n 2020-04-25 15:49:11.914\n> SELECT current_timestamp;\n 2020-04-25 15:49:11.914\n',
+        expr: 'current_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_timestamp',
+        funcDesc: 'Returns the current timestamp at the start of query evaluation.',
+        examples: '> SELECT current_timestamp();\n 2020-04-25 15:49:11.914\n> SELECT current_timestamp;\n 2020-04-25 15:49:11.914\n',
+        expr: 'current_timestamp',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_timezone()',
+        funcDesc: 'Returns the current session local timezone.',
+        examples: '> SELECT current_timezone();\n Asia/Shanghai\n',
+        expr: 'current_timezone()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_add(start_date, num_days)',
+        funcDesc: 'Returns the date that is `num_days` after `start_date`.',
+        examples: "> SELECT date_add('2016-07-30', 1);\n 2016-07-31\n",
+        expr: 'date_add()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_diff(endDate, startDate)',
+        funcDesc: 'Returns the number of days from `startDate` to `endDate`.',
+        examples: "> SELECT date_diff('2009-07-31', '2009-07-30');\n 1\n\n> SELECT date_diff('2009-07-30', '2009-07-31');\n -1\n",
+        expr: 'date_diff()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_format(timestamp, fmt)',
+        funcDesc: 'Converts `timestamp` to a value of string in the format specified by the date format `fmt`.',
+        examples: "> SELECT date_format('2016-04-08', 'y');\n 2016\n",
+        expr: 'date_format()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_from_unix_date(days)',
+        funcDesc: 'Create date from the number of days since 1970-01-01.',
+        examples: '> SELECT date_from_unix_date(1);\n 1970-01-02\n',
+        expr: 'date_from_unix_date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_part(field, source)',
+        funcDesc: 'Extracts a part of the date/timestamp or interval source.',
+        examples: "> SELECT date_part('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');\n 2019\n> SELECT date_part('week', timestamp'2019-08-12 01:00:00.123456');\n 33\n> SELECT date_part('doy', DATE'2019-08-12');\n 224\n> SELECT date_part('SECONDS', timestamp'2019-10-01 00:00:01.000001');\n 1.000001\n> SELECT date_part('days', interval 5 days 3 hours 7 minutes);\n 5\n> SELECT date_part('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);\n 30.001001\n> SELECT date_part('MONTH', INTERVAL '2021-11' YEAR TO MONTH);\n 11\n> SELECT date_part('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);\n 55\n",
+        expr: 'date_part()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_sub(start_date, num_days)',
+        funcDesc: 'Returns the date that is `num_days` before `start_date`.',
+        examples: "> SELECT date_sub('2016-07-30', 1);\n 2016-07-29\n",
+        expr: 'date_sub()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date_trunc(fmt, ts)',
+        funcDesc: 'Returns timestamp `ts` truncated to the unit specified by the format model `fmt`.',
+        examples: "> SELECT date_trunc('YEAR', '2015-03-05T09:32:05.359');\n 2015-01-01 00:00:00\n> SELECT date_trunc('MM', '2015-03-05T09:32:05.359');\n 2015-03-01 00:00:00\n> SELECT date_trunc('DD', '2015-03-05T09:32:05.359');\n 2015-03-05 00:00:00\n> SELECT date_trunc('HOUR', '2015-03-05T09:32:05.359');\n 2015-03-05 09:00:00\n> SELECT date_trunc('MILLISECOND', '2015-03-05T09:32:05.123456');\n 2015-03-05 09:32:05.123\n",
+        expr: 'date_trunc()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'dateadd(start_date, num_days)',
+        funcDesc: 'Returns the date that is `num_days` after `start_date`.',
+        examples: "> SELECT dateadd('2016-07-30', 1);\n 2016-07-31\n",
+        expr: 'dateadd()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'datediff(endDate, startDate)',
+        funcDesc: 'Returns the number of days from `startDate` to `endDate`.',
+        examples: "> SELECT datediff('2009-07-31', '2009-07-30');\n 1\n\n> SELECT datediff('2009-07-30', '2009-07-31');\n -1\n",
+        expr: 'datediff()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'datepart(field, source)',
+        funcDesc: 'Extracts a part of the date/timestamp or interval source.',
+        examples: "> SELECT datepart('YEAR', TIMESTAMP '2019-08-12 01:00:00.123456');\n 2019\n> SELECT datepart('week', timestamp'2019-08-12 01:00:00.123456');\n 33\n> SELECT datepart('doy', DATE'2019-08-12');\n 224\n> SELECT datepart('SECONDS', timestamp'2019-10-01 00:00:01.000001');\n 1.000001\n> SELECT datepart('days', interval 5 days 3 hours 7 minutes);\n 5\n> SELECT datepart('seconds', interval 5 hours 30 seconds 1 milliseconds 1 microseconds);\n 30.001001\n> SELECT datepart('MONTH', INTERVAL '2021-11' YEAR TO MONTH);\n 11\n> SELECT datepart('MINUTE', INTERVAL '123 23:55:59.002001' DAY TO SECOND);\n 55\n",
+        expr: 'datepart()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'day(date)',
+        funcDesc: 'Returns the day of month of the date/timestamp.',
+        examples: "> SELECT day('2009-07-30');\n 30\n",
+        expr: 'day()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'dayofmonth(date)',
+        funcDesc: 'Returns the day of month of the date/timestamp.',
+        examples: "> SELECT dayofmonth('2009-07-30');\n 30\n",
+        expr: 'dayofmonth()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'dayofweek(date)',
+        funcDesc: 'Returns the day of the week for date/timestamp (1 = Sunday, 2 = Monday, ..., 7 = Saturday).',
+        examples: "> SELECT dayofweek('2009-07-30');\n 5\n",
+        expr: 'dayofweek()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'dayofyear(date)',
+        funcDesc: 'Returns the day of year of the date/timestamp.',
+        examples: "> SELECT dayofyear('2016-04-09');\n 100\n",
+        expr: 'dayofyear()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'extract(field FROM source)',
+        funcDesc: 'Extracts a part of the date/timestamp or interval source.',
+        examples: "> SELECT extract(YEAR FROM TIMESTAMP '2019-08-12 01:00:00.123456');\n 2019\n> SELECT extract(week FROM timestamp'2019-08-12 01:00:00.123456');\n 33\n> SELECT extract(doy FROM DATE'2019-08-12');\n 224\n> SELECT extract(SECONDS FROM timestamp'2019-10-01 00:00:01.000001');\n 1.000001\n> SELECT extract(days FROM interval 5 days 3 hours 7 minutes);\n 5\n> SELECT extract(seconds FROM interval 5 hours 30 seconds 1 milliseconds 1 microseconds);\n 30.001001\n> SELECT extract(MONTH FROM INTERVAL '2021-11' YEAR TO MONTH);\n 11\n> SELECT extract(MINUTE FROM INTERVAL '123 23:55:59.002001' DAY TO SECOND);\n 55\n",
+        expr: 'extract()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'from_unixtime(unix_time[, fmt])',
+        funcDesc: 'Returns `unix_time` in the specified `fmt`.',
+        examples: "> SELECT from_unixtime(0, 'yyyy-MM-dd HH:mm:ss');\n 1969-12-31 16:00:00\n\n> SELECT from_unixtime(0);\n 1969-12-31 16:00:00\n",
+        expr: 'from_unixtime()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'from_utc_timestamp(timestamp, timezone)',
+        funcDesc: "Given a timestamp like '2017-07-14 02:40:00.0', interprets it as a time in UTC, and renders that time as a timestamp in the given time zone. For example, 'GMT+1' would yield '2017-07-14 03:40:00.0'.",
+        examples: "> SELECT from_utc_timestamp('2016-08-31', 'Asia/Seoul');\n 2016-08-31 09:00:00\n",
+        expr: 'from_utc_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'hour(timestamp)',
+        funcDesc: 'Returns the hour component of the string/timestamp.',
+        examples: "> SELECT hour('2009-07-30 12:58:59');\n 12\n",
+        expr: 'hour()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'last_day(date)',
+        funcDesc: 'Returns the last day of the month which the date belongs to.',
+        examples: "> SELECT last_day('2009-01-12');\n 2009-01-31\n",
+        expr: 'last_day()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'localtimestamp()',
+        funcDesc: 'Returns the current timestamp without time zone at the start of query evaluation. All calls of localtimestamp within the same query return the same value.',
+        examples: '> SELECT localtimestamp();\n 2020-04-25 15:49:11.914\n> SELECT localtimestamp;\n 2020-04-25 15:49:11.914\n',
+        expr: 'localtimestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'localtimestamp',
+        funcDesc: 'Returns the current local date-time at the session time zone at the start of query evaluation.',
+        examples: '> SELECT localtimestamp();\n 2020-04-25 15:49:11.914\n> SELECT localtimestamp;\n 2020-04-25 15:49:11.914\n',
+        expr: 'localtimestamp',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_date(year, month, day)',
+        funcDesc: 'Create date from year, month and day fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead.',
+        examples: '> SELECT make_date(2013, 7, 15);\n 2013-07-15\n> SELECT make_date(2019, 7, NULL);\n NULL\n',
+        expr: 'make_date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_dt_interval([days[, hours[, mins[, secs]]]])',
+        funcDesc: 'Make DayTimeIntervalType duration from days, hours, mins and secs.',
+        examples: '> SELECT make_dt_interval(1, 12, 30, 01.001001);\n 1 12:30:01.001001000\n> SELECT make_dt_interval(2);\n 2 00:00:00.000000000\n> SELECT make_dt_interval(100, null, 3);\n NULL\n',
+        expr: 'make_dt_interval()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_interval([years[, months[, weeks[, days[, hours[, mins[, secs]]]]]]])',
+        funcDesc: 'Make interval from years, months, weeks, days, hours, mins and secs.',
+        examples: '> SELECT make_interval(100, 11, 1, 1, 12, 30, 01.001001);\n 100 years 11 months 8 days 12 hours 30 minutes 1.001001 seconds\n> SELECT make_interval(100, null, 3);\n NULL\n> SELECT make_interval(0, 1, 0, 1, 0, 0, 100.000001);\n 1 months 1 days 1 minutes 40.000001 seconds\n',
+        expr: 'make_interval()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_timestamp(year, month, day, hour, min, sec[, timezone])',
+        funcDesc: 'Create timestamp from year, month, day, hour, min, sec and timezone fields. The result data type is consistent with the value of configuration `spark.sql.timestampType`. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead.',
+        examples: "> SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887);\n 2014-12-28 06:30:45.887\n> SELECT make_timestamp(2014, 12, 28, 6, 30, 45.887, 'CET');\n 2014-12-27 21:30:45.887\n> SELECT make_timestamp(2019, 6, 30, 23, 59, 60);\n 2019-07-01 00:00:00\n> SELECT make_timestamp(2019, 6, 30, 23, 59, 1);\n 2019-06-30 23:59:01\n> SELECT make_timestamp(null, 7, 22, 15, 30, 0);\n NULL\n",
+        expr: 'make_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_timestamp_ltz(year, month, day, hour, min, sec[, timezone])',
+        funcDesc: 'Create the current timestamp with local time zone from year, month, day, hour, min, sec and timezone fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead.',
+        examples: "> SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887);\n 2014-12-28 06:30:45.887\n> SELECT make_timestamp_ltz(2014, 12, 28, 6, 30, 45.887, 'CET');\n 2014-12-27 21:30:45.887\n> SELECT make_timestamp_ltz(2019, 6, 30, 23, 59, 60);\n 2019-07-01 00:00:00\n> SELECT make_timestamp_ltz(null, 7, 22, 15, 30, 0);\n NULL\n",
+        expr: 'make_timestamp_ltz()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_timestamp_ntz(year, month, day, hour, min, sec)',
+        funcDesc: 'Create local date-time from year, month, day, hour, min, sec fields. If the configuration `spark.sql.ansi.enabled` is false, the function returns NULL on invalid inputs. Otherwise, it will throw an error instead.',
+        examples: '> SELECT make_timestamp_ntz(2014, 12, 28, 6, 30, 45.887);\n 2014-12-28 06:30:45.887\n> SELECT make_timestamp_ntz(2019, 6, 30, 23, 59, 60);\n 2019-07-01 00:00:00\n> SELECT make_timestamp_ntz(null, 7, 22, 15, 30, 0);\n NULL\n',
+        expr: 'make_timestamp_ntz()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'make_ym_interval([years[, months]])',
+        funcDesc: 'Make year-month interval from years, months.',
+        examples: '> SELECT make_ym_interval(1, 2);\n 1-2\n> SELECT make_ym_interval(1, 0);\n 1-0\n> SELECT make_ym_interval(-1, 1);\n -0-11\n> SELECT make_ym_interval(2);\n 2-0\n',
+        expr: 'make_ym_interval()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'minute(timestamp)',
+        funcDesc: 'Returns the minute component of the string/timestamp.',
+        examples: "> SELECT minute('2009-07-30 12:58:59');\n 58\n",
+        expr: 'minute()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'month(date)',
+        funcDesc: 'Returns the month component of the date/timestamp.',
+        examples: "> SELECT month('2016-07-30');\n 7\n",
+        expr: 'month()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'months_between(timestamp1, timestamp2[, roundOff])',
+        funcDesc: 'If `timestamp1` is later than `timestamp2`, then the result is positive. If `timestamp1` and `timestamp2` are on the same day of month, or both are the last day of month, time of day will be ignored. Otherwise, the difference is calculated based on 31 days per month, and rounded to 8 digits unless roundOff=false.',
+        examples: "> SELECT months_between('1997-02-28 10:30:00', '1996-10-30');\n 3.94959677\n> SELECT months_between('1997-02-28 10:30:00', '1996-10-30', false);\n 3.9495967741935485\n",
+        expr: 'months_between()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'next_day(start_date, day_of_week)',
+        funcDesc: 'Returns the first date which is later than `start_date` and named as indicated. The function returns NULL if at least one of the input parameters is NULL. When both of the input parameters are not NULL and day_of_week is an invalid input, the function throws IllegalArgumentException if `spark.sql.ansi.enabled` is set to true, otherwise NULL.',
+        examples: "> SELECT next_day('2015-01-14', 'TU');\n 2015-01-20\n",
+        expr: 'next_day()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'now()',
+        funcDesc: 'Returns the current timestamp at the start of query evaluation.',
+        examples: '> SELECT now();\n 2020-04-25 15:49:11.914\n',
+        expr: 'now()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'quarter(date)',
+        funcDesc: 'Returns the quarter of the year for date, in the range 1 to 4.',
+        examples: "> SELECT quarter('2016-08-31');\n 3\n",
+        expr: 'quarter()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'second(timestamp)',
+        funcDesc: 'Returns the second component of the string/timestamp.',
+        examples: "> SELECT second('2009-07-30 12:58:59');\n 59\n",
+        expr: 'second()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'session_window(time_column, gap_duration)',
+        funcDesc: "Generates session window given a timestamp specifying column and gap duration. See 'Types of time windows' in Structured Streaming guide doc for detailed explanation and examples.",
+        examples: "> SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, session_window(b, '5 minutes') ORDER BY a, start;\n  A1    2021-01-01 00:00:00 2021-01-01 00:09:30 2\n  A1    2021-01-01 00:10:00 2021-01-01 00:15:00 1\n  A2    2021-01-01 00:01:00 2021-01-01 00:06:00 1\n> SELECT a, session_window.start, session_window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:10:00'), ('A2', '2021-01-01 00:01:00'), ('A2', '2021-01-01 00:04:30') AS tab(a, b) GROUP by a, session_window(b, CASE WHEN a = 'A1' THEN '5 minutes' WHEN a = 'A2' THEN '1 minute' ELSE '10 minutes' END) ORDER BY a, start;\n  A1    2021-01-01 00:00:00 2021-01-01 00:09:30 2\n  A1    2021-01-01 00:10:00 2021-01-01 00:15:00 1\n  A2    2021-01-01 00:01:00 2021-01-01 00:02:00 1\n  A2    2021-01-01 00:04:30 2021-01-01 00:05:30 1\n",
+        expr: 'session_window()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'timestamp_micros(microseconds)',
+        funcDesc: 'Creates timestamp from the number of microseconds since UTC epoch.',
+        examples: '> SELECT timestamp_micros(1230219000123123);\n 2008-12-25 07:30:00.123123\n',
+        expr: 'timestamp_micros()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'timestamp_millis(milliseconds)',
+        funcDesc: 'Creates timestamp from the number of milliseconds since UTC epoch.',
+        examples: '> SELECT timestamp_millis(1230219000123);\n 2008-12-25 07:30:00.123\n',
+        expr: 'timestamp_millis()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'timestamp_seconds(seconds)',
+        funcDesc: 'Creates timestamp from the number of seconds (can be fractional) since UTC epoch.',
+        examples: '> SELECT timestamp_seconds(1230219000);\n 2008-12-25 07:30:00\n> SELECT timestamp_seconds(1230219000.123);\n 2008-12-25 07:30:00.123\n',
+        expr: 'timestamp_seconds()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_date(date_str[, fmt])',
+        funcDesc: 'Parses the `date_str` expression with the `fmt` expression to a date. Returns null with invalid input. By default, it follows casting rules to a date if the `fmt` is omitted.',
+        examples: "> SELECT to_date('2009-07-30 04:17:52');\n 2009-07-30\n> SELECT to_date('2016-12-31', 'yyyy-MM-dd');\n 2016-12-31\n",
+        expr: 'to_date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_timestamp(timestamp_str[, fmt])',
+        funcDesc: 'Parses the `timestamp_str` expression with the `fmt` expression to a timestamp. Returns null with invalid input. By default, it follows casting rules to a timestamp if the `fmt` is omitted. The result data type is consistent with the value of configuration `spark.sql.timestampType`.',
+        examples: "> SELECT to_timestamp('2016-12-31 00:12:00');\n 2016-12-31 00:12:00\n> SELECT to_timestamp('2016-12-31', 'yyyy-MM-dd');\n 2016-12-31 00:00:00\n",
+        expr: 'to_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_timestamp_ltz(timestamp_str[, fmt])',
+        funcDesc: 'Parses the `timestamp_str` expression with the `fmt` expression to a timestamp with local time zone. Returns null with invalid input. By default, it follows casting rules to a timestamp if the `fmt` is omitted.',
+        examples: "> SELECT to_timestamp_ltz('2016-12-31 00:12:00');\n 2016-12-31 00:12:00\n> SELECT to_timestamp_ltz('2016-12-31', 'yyyy-MM-dd');\n 2016-12-31 00:00:00\n",
+        expr: 'to_timestamp_ltz()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_timestamp_ntz(timestamp_str[, fmt])',
+        funcDesc: 'Parses the `timestamp_str` expression with the `fmt` expression to a timestamp without time zone. Returns null with invalid input. By default, it follows casting rules to a timestamp if the `fmt` is omitted.',
+        examples: "> SELECT to_timestamp_ntz('2016-12-31 00:12:00');\n 2016-12-31 00:12:00\n> SELECT to_timestamp_ntz('2016-12-31', 'yyyy-MM-dd');\n 2016-12-31 00:00:00\n",
+        expr: 'to_timestamp_ntz()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_unix_timestamp(timeExp[, fmt])',
+        funcDesc: 'Returns the UNIX timestamp of the given time.',
+        examples: "> SELECT to_unix_timestamp('2016-04-08', 'yyyy-MM-dd');\n 1460098800\n",
+        expr: 'to_unix_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_utc_timestamp(timestamp, timezone)',
+        funcDesc: "Given a timestamp like '2017-07-14 02:40:00.0', interprets it as a time in the given time zone, and renders that time as a timestamp in UTC. For example, 'GMT+1' would yield '2017-07-14 01:40:00.0'.",
+        examples: "> SELECT to_utc_timestamp('2016-08-31', 'Asia/Seoul');\n 2016-08-30 15:00:00\n",
+        expr: 'to_utc_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trunc(date, fmt)',
+        funcDesc: 'Returns `date` with the time portion of the day truncated to the unit specified by the format model `fmt`.',
+        examples: "> SELECT trunc('2019-08-04', 'week');\n 2019-07-29\n> SELECT trunc('2019-08-04', 'quarter');\n 2019-07-01\n> SELECT trunc('2009-02-12', 'MM');\n 2009-02-01\n> SELECT trunc('2015-10-27', 'YEAR');\n 2015-01-01\n",
+        expr: 'trunc()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_to_timestamp(timestamp_str[, fmt])',
+        funcDesc: 'Parses the `timestamp_str` expression with the `fmt` expression to a timestamp. The function always returns null on an invalid input with/without ANSI SQL mode enabled. By default, it follows casting rules to a timestamp if the `fmt` is omitted. The result data type is consistent with the value of configuration `spark.sql.timestampType`.',
+        examples: "> SELECT try_to_timestamp('2016-12-31 00:12:00');\n 2016-12-31 00:12:00\n> SELECT try_to_timestamp('2016-12-31', 'yyyy-MM-dd');\n 2016-12-31 00:00:00\n> SELECT try_to_timestamp('foo', 'yyyy-MM-dd');\n NULL\n",
+        expr: 'try_to_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unix_date(date)',
+        funcDesc: 'Returns the number of days since 1970-01-01.',
+        examples: '> SELECT unix_date(DATE("1970-01-02"));\n 1\n',
+        expr: 'unix_date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unix_micros(timestamp)',
+        funcDesc: 'Returns the number of microseconds since 1970-01-01 00:00:00 UTC.',
+        examples: "> SELECT unix_micros(TIMESTAMP('1970-01-01 00:00:01Z'));\n 1000000\n",
+        expr: 'unix_micros()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unix_millis(timestamp)',
+        funcDesc: 'Returns the number of milliseconds since 1970-01-01 00:00:00 UTC. Truncates higher levels of precision.',
+        examples: "> SELECT unix_millis(TIMESTAMP('1970-01-01 00:00:01Z'));\n 1000\n",
+        expr: 'unix_millis()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unix_seconds(timestamp)',
+        funcDesc: 'Returns the number of seconds since 1970-01-01 00:00:00 UTC. Truncates higher levels of precision.',
+        examples: "> SELECT unix_seconds(TIMESTAMP('1970-01-01 00:00:01Z'));\n 1\n",
+        expr: 'unix_seconds()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unix_timestamp([timeExp[, fmt]])',
+        funcDesc: 'Returns the UNIX timestamp of current or specified time.',
+        examples: "> SELECT unix_timestamp();\n 1476884637\n> SELECT unix_timestamp('2016-04-08', 'yyyy-MM-dd');\n 1460041200\n",
+        expr: 'unix_timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'weekday(date)',
+        funcDesc: 'Returns the day of the week for date/timestamp (0 = Monday, 1 = Tuesday, ..., 6 = Sunday).',
+        examples: "> SELECT weekday('2009-07-30');\n 3\n",
+        expr: 'weekday()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'weekofyear(date)',
+        funcDesc: 'Returns the week of the year of the given date. A week is considered to start on a Monday and week 1 is the first week with >3 days.',
+        examples: "> SELECT weekofyear('2008-02-20');\n 8\n",
+        expr: 'weekofyear()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'window(time_column, window_duration[, slide_duration[, start_time]])',
+        funcDesc: "Bucketize rows into one or more time windows given a timestamp specifying column. Window starts are inclusive but the window ends are exclusive, e.g. 12:05 will be in the window [12:05,12:10) but not in [12:00,12:05). Windows can support microsecond precision. Windows in the order of months are not supported. See 'Window Operations on Event Time' in Structured Streaming guide doc for detailed explanation and examples.",
+        examples: "> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, start;\n  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2\n  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 1\n  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 1\n> SELECT a, window.start, window.end, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '10 minutes', '5 minutes') ORDER BY a, start;\n  A1    2020-12-31 23:55:00 2021-01-01 00:05:00 2\n  A1    2021-01-01 00:00:00 2021-01-01 00:10:00 3\n  A1    2021-01-01 00:05:00 2021-01-01 00:15:00 1\n  A2    2020-12-31 23:55:00 2021-01-01 00:05:00 1\n  A2    2021-01-01 00:00:00 2021-01-01 00:10:00 1\n",
+        expr: 'window()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'window_time(window_column)',
+        funcDesc: "Extract the time value from time/session window column which can be used for event time value of window. The extracted time is (window.end - 1) which reflects the fact that the the aggregating windows have exclusive upper bound - [start, end) See 'Window Operations on Event Time' in Structured Streaming guide doc for detailed explanation and examples.",
+        examples: "> SELECT a, window.start as start, window.end as end, window_time(window), cnt FROM (SELECT a, window, count(*) as cnt FROM VALUES ('A1', '2021-01-01 00:00:00'), ('A1', '2021-01-01 00:04:30'), ('A1', '2021-01-01 00:06:00'), ('A2', '2021-01-01 00:01:00') AS tab(a, b) GROUP by a, window(b, '5 minutes') ORDER BY a, window.start);\n  A1    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  2\n  A1    2021-01-01 00:05:00 2021-01-01 00:10:00 2021-01-01 00:09:59.999999  1\n  A2    2021-01-01 00:00:00 2021-01-01 00:05:00 2021-01-01 00:04:59.999999  1\n",
+        expr: 'window_time()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'year(date)',
+        funcDesc: 'Returns the year component of the date/timestamp.',
+        examples: "> SELECT year('2016-07-30');\n 2016\n",
+        expr: 'year()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'from_json(jsonStr, schema[, options])',
+        funcDesc: 'Returns a struct value with the given `jsonStr` and `schema`.',
+        examples: '> SELECT from_json(\'{"a":1, "b":0.8}\', \'a INT, b DOUBLE\');\n {"a":1,"b":0.8}\n> SELECT from_json(\'{"time":"26/08/2015"}\', \'time Timestamp\', map(\'timestampFormat\', \'dd/MM/yyyy\'));\n {"time":2015-08-26 00:00:00}\n> SELECT from_json(\'{"teacher": "Alice", "student": [{"name": "Bob", "rank": 1}, {"name": "Charlie", "rank": 2}]}\', \'STRUCT<teacher: STRING, student: ARRAY<STRUCT<name: STRING, rank: INT>>>\');\n {"teacher":"Alice","student":[{"name":"Bob","rank":1},{"name":"Charlie","rank":2}]}\n',
+        expr: 'from_json()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'get_json_object(json_txt, path)',
+        funcDesc: 'Extracts a json object from `path`.',
+        examples: '> SELECT get_json_object(\'{"a":"b"}\', \'$.a\');\n b\n',
+        expr: 'get_json_object()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'json_array_length(jsonArray)',
+        funcDesc: 'Returns the number of elements in the outermost JSON array.',
+        examples: "> SELECT json_array_length('[1,2,3,4]');\n  4\n> SELECT json_array_length('[1,2,3,{\"f1\":1,\"f2\":[5,6]},4]');\n  5\n> SELECT json_array_length('[1,2');\n  NULL\n",
+        expr: 'json_array_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'json_object_keys(json_object)',
+        funcDesc: 'Returns all the keys of the outermost JSON object as an array.',
+        examples: '> SELECT json_object_keys(\'{}\');\n  []\n> SELECT json_object_keys(\'{"key": "value"}\');\n  ["key"]\n> SELECT json_object_keys(\'{"f1":"abc","f2":{"f3":"a", "f4":"b"}}\');\n  ["f1","f2"]\n',
+        expr: 'json_object_keys()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'json_tuple(jsonStr, p1, p2, ..., pn)',
+        funcDesc: 'Returns a tuple like the function get_json_object, but it takes multiple names. All the input parameters and output column types are string.',
+        examples: "> SELECT json_tuple('{\"a\":1, \"b\":2}', 'a', 'b');\n 1  2\n",
+        expr: 'json_tuple()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'schema_of_json(json[, options])',
+        funcDesc: 'Returns schema in the DDL format of JSON string.',
+        examples: "> SELECT schema_of_json('[{\"col\":0}]');\n ARRAY<STRUCT<col: BIGINT>>\n> SELECT schema_of_json('[{\"col\":01}]', map('allowNumericLeadingZeros', 'true'));\n ARRAY<STRUCT<col: BIGINT>>\n",
+        expr: 'schema_of_json()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_json(expr[, options])',
+        funcDesc: 'Returns a JSON string with a given struct value',
+        examples: "> SELECT to_json(named_struct('a', 1, 'b', 2));\n {\"a\":1,\"b\":2}\n> SELECT to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));\n {\"time\":\"26/08/2015\"}\n> SELECT to_json(array(named_struct('a', 1, 'b', 2)));\n [{\"a\":1,\"b\":2}]\n> SELECT to_json(map('a', named_struct('b', 1)));\n {\"a\":{\"b\":1}}\n> SELECT to_json(map(named_struct('a', 1),named_struct('b', 2)));\n {\"[1]\":{\"b\":2}}\n> SELECT to_json(map('a', 1));\n {\"a\":1}\n> SELECT to_json(array((map('a', 1))));\n [{\"a\":1}]\n",
+        expr: 'to_json()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 % expr2',
+        funcDesc: 'Returns the remainder after `expr1`/`expr2`.',
+        examples: '> SELECT 2 % 1.8;\n 0.2\n> SELECT 2 % 0;\n Error: DIVIDE_BY_ZERO\n',
+        expr: 'expr1 % expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 * expr2',
+        funcDesc: 'Returns `expr1`*`expr2`.',
+        examples: '> SELECT 2 * 3;\n 6\n',
+        expr: 'expr1 * expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 + expr2',
+        funcDesc: 'Returns `expr1`+`expr2`.',
+        examples: '> SELECT 1 + 2;\n 3\n',
+        expr: 'expr1 + expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 - expr2',
+        funcDesc: 'Returns `expr1`-`expr2`.',
+        examples: '> SELECT 2 - 1;\n 1\n',
+        expr: 'expr1 - expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 / expr2',
+        funcDesc: 'Returns `expr1`/`expr2`. It always performs floating point division.',
+        examples: '> SELECT 3 / 2;\n 1.5\n> SELECT 2L / 2L;\n 1.0\n',
+        expr: 'expr1 / expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'abs(expr)',
+        funcDesc: 'Returns the absolute value of the numeric or interval value.',
+        examples: "> SELECT abs(-1);\n 1\n> SELECT abs(INTERVAL -'1-1' YEAR TO MONTH);\n 1-1\n",
+        expr: 'abs()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'acos(expr)',
+        funcDesc: 'Returns the inverse cosine (a.k.a. arc cosine) of `expr`, as if computed by `java.lang.Math.acos`.',
+        examples: '> SELECT acos(1);\n 0.0\n> SELECT acos(2);\n NaN\n',
+        expr: 'acos()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'acosh(expr)',
+        funcDesc: 'Returns inverse hyperbolic cosine of `expr`.',
+        examples: '> SELECT acosh(1);\n 0.0\n> SELECT acosh(0);\n NaN\n',
+        expr: 'acosh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'asin(expr)',
+        funcDesc: 'Returns the inverse sine (a.k.a. arc sine) the arc sin of `expr`, as if computed by `java.lang.Math.asin`.',
+        examples: '> SELECT asin(0);\n 0.0\n> SELECT asin(2);\n NaN\n',
+        expr: 'asin()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'asinh(expr)',
+        funcDesc: 'Returns inverse hyperbolic sine of `expr`.',
+        examples: '> SELECT asinh(0);\n 0.0\n',
+        expr: 'asinh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'atan(expr)',
+        funcDesc: 'Returns the inverse tangent (a.k.a. arc tangent) of `expr`, as if computed by `java.lang.Math.atan`',
+        examples: '> SELECT atan(0);\n 0.0\n',
+        expr: 'atan()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'atan2(exprY, exprX)',
+        funcDesc: 'Returns the angle in radians between the positive x-axis of a plane and the point given by the coordinates (`exprX`, `exprY`), as if computed by `java.lang.Math.atan2`.',
+        examples: '> SELECT atan2(0, 0);\n 0.0\n',
+        expr: 'atan2()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'atanh(expr)',
+        funcDesc: 'Returns inverse hyperbolic tangent of `expr`.',
+        examples: '> SELECT atanh(0);\n 0.0\n> SELECT atanh(2);\n NaN\n',
+        expr: 'atanh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bin(expr)',
+        funcDesc: 'Returns the string representation of the long value `expr` represented in binary.',
+        examples: '> SELECT bin(13);\n 1101\n> SELECT bin(-13);\n 1111111111111111111111111111111111111111111111111111111111110011\n> SELECT bin(13.3);\n 1101\n',
+        expr: 'bin()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bround(expr, d)',
+        funcDesc: 'Returns `expr` rounded to `d` decimal places using HALF_EVEN rounding mode.',
+        examples: '> SELECT bround(2.5, 0);\n 2\n> SELECT bround(25, -1);\n 20\n',
+        expr: 'bround()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cbrt(expr)',
+        funcDesc: 'Returns the cube root of `expr`.',
+        examples: '> SELECT cbrt(27.0);\n 3.0\n',
+        expr: 'cbrt()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ceil(expr[, scale])',
+        funcDesc: 'Returns the smallest number after rounding up that is not smaller than `expr`. An optional `scale` parameter can be specified to control the rounding behavior.',
+        examples: '> SELECT ceil(-0.1);\n 0\n> SELECT ceil(5);\n 5\n> SELECT ceil(3.1411, 3);\n 3.142\n> SELECT ceil(3.1411, -3);\n 1000\n',
+        expr: 'ceil()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ceiling(expr[, scale])',
+        funcDesc: 'Returns the smallest number after rounding up that is not smaller than `expr`. An optional `scale` parameter can be specified to control the rounding behavior.',
+        examples: '> SELECT ceiling(-0.1);\n 0\n> SELECT ceiling(5);\n 5\n> SELECT ceiling(3.1411, 3);\n 3.142\n> SELECT ceiling(3.1411, -3);\n 1000\n',
+        expr: 'ceiling()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'conv(num, from_base, to_base)',
+        funcDesc: 'Convert `num` from `from_base` to `to_base`.',
+        examples: "> SELECT conv('100', 2, 10);\n 4\n> SELECT conv(-10, 16, -10);\n -16\n",
+        expr: 'conv()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cos(expr)',
+        funcDesc: 'Returns the cosine of `expr`, as if computed by `java.lang.Math.cos`.',
+        examples: '> SELECT cos(0);\n 1.0\n',
+        expr: 'cos()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cosh(expr)',
+        funcDesc: 'Returns the hyperbolic cosine of `expr`, as if computed by `java.lang.Math.cosh`.',
+        examples: '> SELECT cosh(0);\n 1.0\n',
+        expr: 'cosh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cot(expr)',
+        funcDesc: 'Returns the cotangent of `expr`, as if computed by `1/java.lang.Math.tan`.',
+        examples: '> SELECT cot(1);\n 0.6420926159343306\n',
+        expr: 'cot()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'csc(expr)',
+        funcDesc: 'Returns the cosecant of `expr`, as if computed by `1/java.lang.Math.sin`.',
+        examples: '> SELECT csc(1);\n 1.1883951057781212\n',
+        expr: 'csc()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'degrees(expr)',
+        funcDesc: 'Converts radians to degrees.',
+        examples: '> SELECT degrees(3.141592653589793);\n 180.0\n',
+        expr: 'degrees()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 div expr2',
+        funcDesc: 'Divide `expr1` by `expr2`. It returns NULL if an operand is NULL or `expr2` is 0. The result is casted to long.',
+        examples: "> SELECT 3 div 2;\n 1\n> SELECT INTERVAL '1-1' YEAR TO MONTH div INTERVAL '-1' MONTH;\n -13\n",
+        expr: 'expr1 div expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'e()',
+        funcDesc: "Returns Euler's number, e.",
+        examples: '> SELECT e();\n 2.718281828459045\n',
+        expr: 'e()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'exp(expr)',
+        funcDesc: 'Returns e to the power of `expr`.',
+        examples: '> SELECT exp(0);\n 1.0\n',
+        expr: 'exp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expm1(expr) - Returns exp(`expr`)',
+        funcDesc: '1.',
+        examples: '> SELECT expm1(0);\n 0.0\n',
+        expr: 'expm1()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'factorial(expr)',
+        funcDesc: 'Returns the factorial of `expr`. `expr` is [0..20]. Otherwise, null.',
+        examples: '> SELECT factorial(5);\n 120\n',
+        expr: 'factorial()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'floor(expr[, scale])',
+        funcDesc: 'Returns the largest number after rounding down that is not greater than `expr`. An optional `scale` parameter can be specified to control the rounding behavior.',
+        examples: '> SELECT floor(-0.1);\n -1\n> SELECT floor(5);\n 5\n> SELECT floor(3.1411, 3);\n 3.141\n> SELECT floor(3.1411, -3);\n 0\n',
+        expr: 'floor()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'greatest(expr, ...)',
+        funcDesc: 'Returns the greatest value of all parameters, skipping null values.',
+        examples: '> SELECT greatest(10, 9, 2, 4, 3);\n 10\n',
+        expr: 'greatest()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'hex(expr)',
+        funcDesc: 'Converts `expr` to hexadecimal.',
+        examples: "> SELECT hex(17);\n 11\n> SELECT hex('Spark SQL');\n 537061726B2053514C\n",
+        expr: 'hex()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'hypot(expr1, expr2)',
+        funcDesc: 'Returns sqrt(`expr1`**2 + `expr2`**2).',
+        examples: '> SELECT hypot(3, 4);\n 5.0\n',
+        expr: 'hypot()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'least(expr, ...)',
+        funcDesc: 'Returns the least value of all parameters, skipping null values.',
+        examples: '> SELECT least(10, 9, 2, 4, 3);\n 2\n',
+        expr: 'least()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ln(expr)',
+        funcDesc: 'Returns the natural logarithm (base e) of `expr`.',
+        examples: '> SELECT ln(1);\n 0.0\n',
+        expr: 'ln()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'log(base, expr)',
+        funcDesc: 'Returns the logarithm of `expr` with `base`.',
+        examples: '> SELECT log(10, 100);\n 2.0\n',
+        expr: 'log()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'log10(expr)',
+        funcDesc: 'Returns the logarithm of `expr` with base 10.',
+        examples: '> SELECT log10(10);\n 1.0\n',
+        expr: 'log10()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'log1p(expr)',
+        funcDesc: 'Returns log(1 + `expr`).',
+        examples: '> SELECT log1p(0);\n 0.0\n',
+        expr: 'log1p()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'log2(expr)',
+        funcDesc: 'Returns the logarithm of `expr` with base 2.',
+        examples: '> SELECT log2(2);\n 1.0\n',
+        expr: 'log2()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 mod expr2',
+        funcDesc: 'Returns the remainder after `expr1`/`expr2`.',
+        examples: '> SELECT 2 % 1.8;\n 0.2\n> SELECT MOD(2, 1.8);\n 0.2\n',
+        expr: 'expr1 mod expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'negative(expr)',
+        funcDesc: 'Returns the negated value of `expr`.',
+        examples: '> SELECT negative(1);\n -1\n',
+        expr: 'negative()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'pi()',
+        funcDesc: 'Returns pi.',
+        examples: '> SELECT pi();\n 3.141592653589793\n',
+        expr: 'pi()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'pmod(expr1, expr2)',
+        funcDesc: 'Returns the positive value of `expr1` mod `expr2`.',
+        examples: '> SELECT pmod(10, 3);\n 1\n> SELECT pmod(-10, 3);\n 2\n',
+        expr: 'pmod()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'positive(expr)',
+        funcDesc: 'Returns the value of `expr`.',
+        examples: '> SELECT positive(1);\n 1\n',
+        expr: 'positive()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'pow(expr1, expr2)',
+        funcDesc: 'Raises `expr1` to the power of `expr2`.',
+        examples: '> SELECT pow(2, 3);\n 8.0\n',
+        expr: 'pow()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'power(expr1, expr2)',
+        funcDesc: 'Raises `expr1` to the power of `expr2`.',
+        examples: '> SELECT power(2, 3);\n 8.0\n',
+        expr: 'power()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'radians(expr)',
+        funcDesc: 'Converts degrees to radians.',
+        examples: '> SELECT radians(180);\n 3.141592653589793\n',
+        expr: 'radians()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rand([seed])',
+        funcDesc: 'Returns a random value with independent and identically distributed (i.i.d.) uniformly distributed values in [0, 1).',
+        examples: '> SELECT rand();\n 0.9629742951434543\n> SELECT rand(0);\n 0.7604953758285915\n> SELECT rand(null);\n 0.7604953758285915\n',
+        expr: 'rand()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'randn([seed])',
+        funcDesc: 'Returns a random value with independent and identically distributed (i.i.d.) values drawn from the standard normal distribution.',
+        examples: '> SELECT randn();\n -0.3254147983080288\n> SELECT randn(0);\n 1.6034991609278433\n> SELECT randn(null);\n 1.6034991609278433\n',
+        expr: 'randn()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'random([seed])',
+        funcDesc: 'Returns a random value with independent and identically distributed (i.i.d.) uniformly distributed values in [0, 1).',
+        examples: '> SELECT random();\n 0.9629742951434543\n> SELECT random(0);\n 0.7604953758285915\n> SELECT random(null);\n 0.7604953758285915\n',
+        expr: 'random()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rint(expr)',
+        funcDesc: 'Returns the double value that is closest in value to the argument and is equal to a mathematical integer.',
+        examples: '> SELECT rint(12.3456);\n 12.0\n',
+        expr: 'rint()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'round(expr, d)',
+        funcDesc: 'Returns `expr` rounded to `d` decimal places using HALF_UP rounding mode.',
+        examples: '> SELECT round(2.5, 0);\n 3\n',
+        expr: 'round()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sec(expr)',
+        funcDesc: 'Returns the secant of `expr`, as if computed by `1/java.lang.Math.cos`.',
+        examples: '> SELECT sec(0);\n 1.0\n',
+        expr: 'sec()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'shiftleft(base, expr)',
+        funcDesc: 'Bitwise left shift.',
+        examples: '> SELECT shiftleft(2, 1);\n 4\n',
+        expr: 'shiftleft()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sign(expr)',
+        funcDesc: 'Returns -1.0, 0.0 or 1.0 as `expr` is negative, 0 or positive.',
+        examples: "> SELECT sign(40);\n 1.0\n> SELECT sign(INTERVAL -'100' YEAR);\n -1.0\n",
+        expr: 'sign()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'signum(expr)',
+        funcDesc: 'Returns -1.0, 0.0 or 1.0 as `expr` is negative, 0 or positive.',
+        examples: "> SELECT signum(40);\n 1.0\n> SELECT signum(INTERVAL -'100' YEAR);\n -1.0\n",
+        expr: 'signum()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sin(expr)',
+        funcDesc: 'Returns the sine of `expr`, as if computed by `java.lang.Math.sin`.',
+        examples: '> SELECT sin(0);\n 0.0\n',
+        expr: 'sin()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sinh(expr)',
+        funcDesc: 'Returns hyperbolic sine of `expr`, as if computed by `java.lang.Math.sinh`.',
+        examples: '> SELECT sinh(0);\n 0.0\n',
+        expr: 'sinh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sqrt(expr)',
+        funcDesc: 'Returns the square root of `expr`.',
+        examples: '> SELECT sqrt(4);\n 2.0\n',
+        expr: 'sqrt()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'tan(expr)',
+        funcDesc: 'Returns the tangent of `expr`, as if computed by `java.lang.Math.tan`.',
+        examples: '> SELECT tan(0);\n 0.0\n',
+        expr: 'tan()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'tanh(expr)',
+        funcDesc: 'Returns the hyperbolic tangent of `expr`, as if computed by `java.lang.Math.tanh`.',
+        examples: '> SELECT tanh(0);\n 0.0\n',
+        expr: 'tanh()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_add(expr1, expr2)',
+        funcDesc: 'Returns the sum of `expr1`and `expr2` and the result is null on overflow. The acceptable input types are the same with the `+` operator.',
+        examples: "> SELECT try_add(1, 2);\n 3\n> SELECT try_add(2147483647, 1);\n NULL\n> SELECT try_add(date'2021-01-01', 1);\n 2021-01-02\n> SELECT try_add(date'2021-01-01', interval 1 year);\n 2022-01-01\n> SELECT try_add(timestamp'2021-01-01 00:00:00', interval 1 day);\n 2021-01-02 00:00:00\n> SELECT try_add(interval 1 year, interval 2 year);\n 3-0\n",
+        expr: 'try_add()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_divide(dividend, divisor)',
+        funcDesc: 'Returns `dividend`/`divisor`. It always performs floating point division. Its result is always null if `expr2` is 0. `dividend` must be a numeric or an interval. `divisor` must be a numeric.',
+        examples: '> SELECT try_divide(3, 2);\n 1.5\n> SELECT try_divide(2L, 2L);\n 1.0\n> SELECT try_divide(1, 0);\n NULL\n> SELECT try_divide(interval 2 month, 2);\n 0-1\n> SELECT try_divide(interval 2 month, 0);\n NULL\n',
+        expr: 'try_divide()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_multiply(expr1, expr2)',
+        funcDesc: 'Returns `expr1`*`expr2` and the result is null on overflow. The acceptable input types are the same with the `*` operator.',
+        examples: '> SELECT try_multiply(2, 3);\n 6\n> SELECT try_multiply(-2147483648, 10);\n NULL\n> SELECT try_multiply(interval 2 year, 3);\n 6-0\n',
+        expr: 'try_multiply()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_subtract(expr1, expr2)',
+        funcDesc: 'Returns `expr1`-`expr2` and the result is null on overflow. The acceptable input types are the same with the `-` operator.',
+        examples: "> SELECT try_subtract(2, 1);\n 1\n> SELECT try_subtract(-2147483648, 1);\n NULL\n> SELECT try_subtract(date'2021-01-02', 1);\n 2021-01-01\n> SELECT try_subtract(date'2021-01-01', interval 1 year);\n 2020-01-01\n> SELECT try_subtract(timestamp'2021-01-02 00:00:00', interval 1 day);\n 2021-01-01 00:00:00\n> SELECT try_subtract(interval 2 year, interval 1 year);\n 1-0\n",
+        expr: 'try_subtract()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unhex(expr)',
+        funcDesc: 'Converts hexadecimal `expr` to binary.',
+        examples: "> SELECT decode(unhex('537061726B2053514C'), 'UTF-8');\n Spark SQL\n",
+        expr: 'unhex()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'width_bucket(value, min_value, max_value, num_bucket)',
+        funcDesc: 'Returns the bucket number to which `value` would be assigned in an equiwidth histogram with `num_bucket` buckets, in the range `min_value` to `max_value`."',
+        examples: "> SELECT width_bucket(5.3, 0.2, 10.6, 5);\n 3\n> SELECT width_bucket(-2.1, 1.3, 3.4, 3);\n 0\n> SELECT width_bucket(8.1, 0.0, 5.7, 4);\n 5\n> SELECT width_bucket(-0.9, 5.2, 0.5, 2);\n 3\n> SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);\n 1\n> SELECT width_bucket(INTERVAL '1' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);\n 2\n> SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);\n 1\n> SELECT width_bucket(INTERVAL '1' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);\n 2\n",
+        expr: 'width_bucket()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ascii(str)',
+        funcDesc: 'Returns the numeric value of the first character of `str`.',
+        examples: "> SELECT ascii('222');\n 50\n> SELECT ascii(2);\n 50\n",
+        expr: 'ascii()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'base64(bin)',
+        funcDesc: 'Converts the argument from a binary `bin` to a base 64 string.',
+        examples: "> SELECT base64('Spark SQL');\n U3BhcmsgU1FM\n> SELECT base64(x'537061726b2053514c');\n U3BhcmsgU1FM\n",
+        expr: 'base64()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_length(expr)',
+        funcDesc: 'Returns the bit length of string data or number of bits of binary data.',
+        examples: "> SELECT bit_length('Spark SQL');\n 72\n> SELECT bit_length(x'537061726b2053514c');\n 72\n",
+        expr: 'bit_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'btrim(str)',
+        funcDesc: 'Removes the leading and trailing space characters from `str`.',
+        examples: "> SELECT btrim('    SparkSQL   ');\n SparkSQL\n> SELECT btrim(encode('    SparkSQL   ', 'utf-8'));\n SparkSQL\n> SELECT btrim('SSparkSQLS', 'SL');\n parkSQ\n> SELECT btrim(encode('SSparkSQLS', 'utf-8'), encode('SL', 'utf-8'));\n parkSQ\n",
+        expr: 'btrim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'btrim(str, trimStr)',
+        funcDesc: 'Remove the leading and trailing `trimStr` characters from `str`.',
+        examples: "> SELECT btrim('SSparkSQLS', 'SL');\n parkSQ\n> SELECT btrim(encode('SSparkSQLS', 'utf-8'), encode('SL', 'utf-8'));\n parkSQ\n",
+        expr: 'btrim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'char(expr)',
+        funcDesc: 'Returns the ASCII character having the binary equivalent to `expr`. If n is larger than 256 the result is equivalent to chr(n % 256)',
+        examples: '> SELECT char(65);\n A\n',
+        expr: 'char()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'char_length(expr)',
+        funcDesc: 'Returns the character length of string data or number of bytes of binary data. The length of string data includes the trailing spaces. The length of binary data includes binary zeros.',
+        examples: "> SELECT char_length('Spark SQL ');\n 10\n> SELECT char_length(x'537061726b2053514c');\n 9\n> SELECT CHAR_LENGTH('Spark SQL ');\n 10\n> SELECT CHARACTER_LENGTH('Spark SQL ');\n 10\n",
+        expr: 'char_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'character_length(expr)',
+        funcDesc: 'Returns the character length of string data or number of bytes of binary data. The length of string data includes the trailing spaces. The length of binary data includes binary zeros.',
+        examples: "> SELECT character_length('Spark SQL ');\n 10\n> SELECT character_length(x'537061726b2053514c');\n 9\n> SELECT CHAR_LENGTH('Spark SQL ');\n 10\n> SELECT CHARACTER_LENGTH('Spark SQL ');\n 10\n",
+        expr: 'character_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'chr(expr)',
+        funcDesc: 'Returns the ASCII character having the binary equivalent to `expr`. If n is larger than 256 the result is equivalent to chr(n % 256)',
+        examples: '> SELECT chr(65);\n A\n',
+        expr: 'chr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'concat_ws(sep[, str | array(str)]+)',
+        funcDesc: 'Returns the concatenation of the strings separated by `sep`.',
+        examples: "> SELECT concat_ws(' ', 'Spark', 'SQL');\n  Spark SQL\n> SELECT concat_ws('s');\n",
+        expr: 'concat_ws()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'contains(left, right)',
+        funcDesc: 'Returns a boolean. The value is True if right is found inside left. Returns NULL if either input expression is NULL. Otherwise, returns False. Both left or right must be of STRING or BINARY type.',
+        examples: "> SELECT contains('Spark SQL', 'Spark');\n true\n> SELECT contains('Spark SQL', 'SPARK');\n false\n> SELECT contains('Spark SQL', null);\n NULL\n> SELECT contains(x'537061726b2053514c', x'537061726b');\n true\n",
+        expr: 'contains()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'decode(bin, charset)',
+        funcDesc: 'Decodes the first argument using the second argument character set.',
+        examples: "> SELECT decode(encode('abc', 'utf-8'), 'utf-8');\n abc\n> SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');\n San Francisco\n> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');\n Non domestic\n> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');\n NULL\n> SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks');\n SQL\n",
+        expr: 'decode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'decode(expr, search, result [, search, result ] ... [, default])',
+        funcDesc: 'Compares expr to each search value in order. If expr is equal to a search value, decode returns the corresponding result. If no match is found, then it returns default. If default is omitted, it returns null.',
+        examples: "> SELECT decode(encode('abc', 'utf-8'), 'utf-8');\n abc\n> SELECT decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');\n San Francisco\n> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');\n Non domestic\n> SELECT decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');\n NULL\n> SELECT decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks');\n SQL\n",
+        expr: 'decode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'elt(n, input1, input2, ...)',
+        funcDesc: 'Returns the `n`-th input, e.g., returns `input2` when `n` is 2. The function returns NULL if the index exceeds the length of the array and `spark.sql.ansi.enabled` is set to false. If `spark.sql.ansi.enabled` is set to true, it throws ArrayIndexOutOfBoundsException for invalid indices.',
+        examples: "> SELECT elt(1, 'scala', 'java');\n scala\n> SELECT elt(2, 'a', 1);\n 1\n",
+        expr: 'elt()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'encode(str, charset)',
+        funcDesc: 'Encodes the first argument using the second argument character set.',
+        examples: "> SELECT encode('abc', 'utf-8');\n abc\n",
+        expr: 'encode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'endswith(left, right)',
+        funcDesc: 'Returns a boolean. The value is True if left ends with right. Returns NULL if either input expression is NULL. Otherwise, returns False. Both left or right must be of STRING or BINARY type.',
+        examples: "> SELECT endswith('Spark SQL', 'SQL');\n true\n> SELECT endswith('Spark SQL', 'Spark');\n false\n> SELECT endswith('Spark SQL', null);\n NULL\n> SELECT endswith(x'537061726b2053514c', x'537061726b');\n false\n> SELECT endswith(x'537061726b2053514c', x'53514c');\n true\n",
+        expr: 'endswith()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'find_in_set(str, str_array)',
+        funcDesc: 'Returns the index (1-based) of the given string (`str`) in the comma-delimited list (`str_array`). Returns 0, if the string was not found or if the given string (`str`) contains a comma.',
+        examples: "> SELECT find_in_set('ab','abc,b,ab,c,def');\n 3\n",
+        expr: 'find_in_set()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'format_number(expr1, expr2)',
+        funcDesc: "Formats the number `expr1` like '#,###,###.##', rounded to `expr2` decimal places. If `expr2` is 0, the result has no decimal point or fractional part. `expr2` also accept a user specified format. This is supposed to function like MySQL's FORMAT.",
+        examples: "> SELECT format_number(12332.123456, 4);\n 12,332.1235\n> SELECT format_number(12332.123456, '##################.###');\n 12332.123\n",
+        expr: 'format_number()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'format_string(strfmt, obj, ...)',
+        funcDesc: 'Returns a formatted string from printf-style format strings.',
+        examples: '> SELECT format_string("Hello World %d %s", 100, "days");\n Hello World 100 days\n',
+        expr: 'format_string()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'initcap(str)',
+        funcDesc: 'Returns `str` with the first letter of each word in uppercase. All other letters are in lowercase. Words are delimited by white space.',
+        examples: "> SELECT initcap('sPark sql');\n Spark Sql\n",
+        expr: 'initcap()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'instr(str, substr)',
+        funcDesc: 'Returns the (1-based) index of the first occurrence of `substr` in `str`.',
+        examples: "> SELECT instr('SparkSQL', 'SQL');\n 6\n",
+        expr: 'instr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'lcase(str)',
+        funcDesc: 'Returns `str` with all characters changed to lowercase.',
+        examples: "> SELECT lcase('SparkSql');\n sparksql\n",
+        expr: 'lcase()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'left(str, len)',
+        funcDesc: 'Returns the leftmost `len`(`len` can be string type) characters from the string `str`,if `len` is less or equal than 0 the result is an empty string.',
+        examples: "> SELECT left('Spark SQL', 3);\n Spa\n> SELECT left(encode('Spark SQL', 'utf-8'), 3);\n Spa\n",
+        expr: 'left()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'len(expr)',
+        funcDesc: 'Returns the character length of string data or number of bytes of binary data. The length of string data includes the trailing spaces. The length of binary data includes binary zeros.',
+        examples: "> SELECT len('Spark SQL ');\n 10\n> SELECT len(x'537061726b2053514c');\n 9\n> SELECT CHAR_LENGTH('Spark SQL ');\n 10\n> SELECT CHARACTER_LENGTH('Spark SQL ');\n 10\n",
+        expr: 'len()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'length(expr)',
+        funcDesc: 'Returns the character length of string data or number of bytes of binary data. The length of string data includes the trailing spaces. The length of binary data includes binary zeros.',
+        examples: "> SELECT length('Spark SQL ');\n 10\n> SELECT length(x'537061726b2053514c');\n 9\n> SELECT CHAR_LENGTH('Spark SQL ');\n 10\n> SELECT CHARACTER_LENGTH('Spark SQL ');\n 10\n",
+        expr: 'length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'levenshtein(str1, str2)',
+        funcDesc: 'Returns the Levenshtein distance between the two given strings.',
+        examples: "> SELECT levenshtein('kitten', 'sitting');\n 3\n",
+        expr: 'levenshtein()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'locate(substr, str[, pos])',
+        funcDesc: 'Returns the position of the first occurrence of `substr` in `str` after position `pos`. The given `pos` and return value are 1-based.',
+        examples: "> SELECT locate('bar', 'foobarbar');\n 4\n> SELECT locate('bar', 'foobarbar', 5);\n 7\n> SELECT POSITION('bar' IN 'foobarbar');\n 4\n",
+        expr: 'locate()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'lower(str)',
+        funcDesc: 'Returns `str` with all characters changed to lowercase.',
+        examples: "> SELECT lower('SparkSql');\n sparksql\n",
+        expr: 'lower()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'lpad(str, len[, pad])',
+        funcDesc: 'Returns `str`, left-padded with `pad` to a length of `len`. If `str` is longer than `len`, the return value is shortened to `len` characters or bytes. If `pad` is not specified, `str` will be padded to the left with space characters if it is a character string, and with zeros if it is a byte sequence.',
+        examples: "> SELECT lpad('hi', 5, '??');\n ???hi\n> SELECT lpad('hi', 1, '??');\n h\n> SELECT lpad('hi', 5);\n    hi\n> SELECT hex(lpad(unhex('aabb'), 5));\n 000000AABB\n> SELECT hex(lpad(unhex('aabb'), 5, unhex('1122')));\n 112211AABB\n",
+        expr: 'lpad()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ltrim(str)',
+        funcDesc: 'Removes the leading space characters from `str`.',
+        examples: "> SELECT ltrim('    SparkSQL   ');\n SparkSQL\n",
+        expr: 'ltrim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'mask(input[, upperChar, lowerChar, digitChar, otherChar])',
+        funcDesc: "masks the given string value. The function replaces characters with 'X' or 'x', and numbers with 'n'. This can be useful for creating copies of tables with sensitive information removed.",
+        examples: "> SELECT mask('abcd-EFGH-8765-4321');\n  xxxx-XXXX-nnnn-nnnn\n> SELECT mask('abcd-EFGH-8765-4321', 'Q');\n  xxxx-QQQQ-nnnn-nnnn\n> SELECT mask('AbCD123-@$#', 'Q', 'q');\n  QqQQnnn-@$#\n> SELECT mask('AbCD123-@$#');\n  XxXXnnn-@$#\n> SELECT mask('AbCD123-@$#', 'Q');\n  QxQQnnn-@$#\n> SELECT mask('AbCD123-@$#', 'Q', 'q');\n  QqQQnnn-@$#\n> SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');\n  QqQQddd-@$#\n> SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');\n  QqQQdddoooo\n> SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');\n  AqCDdddoooo\n> SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');\n  AbCDdddoooo\n> SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');\n  AbCD123oooo\n> SELECT mask(NULL, NULL, NULL, NULL, 'o');\n  NULL\n> SELECT mask(NULL);\n  NULL\n> SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);\n  AbCD123-@$#\n",
+        expr: 'mask()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'octet_length(expr)',
+        funcDesc: 'Returns the byte length of string data or number of bytes of binary data.',
+        examples: "> SELECT octet_length('Spark SQL');\n 9\n> SELECT octet_length(x'537061726b2053514c');\n 9\n",
+        expr: 'octet_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'overlay(input, replace, pos[, len])',
+        funcDesc: 'Replace `input` with `replace` that starts at `pos` and is of length `len`.',
+        examples: "> SELECT overlay('Spark SQL' PLACING '_' FROM 6);\n Spark_SQL\n> SELECT overlay('Spark SQL' PLACING 'CORE' FROM 7);\n Spark CORE\n> SELECT overlay('Spark SQL' PLACING 'ANSI ' FROM 7 FOR 0);\n Spark ANSI SQL\n> SELECT overlay('Spark SQL' PLACING 'tructured' FROM 2 FOR 4);\n Structured SQL\n> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('_', 'utf-8') FROM 6);\n Spark_SQL\n> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('CORE', 'utf-8') FROM 7);\n Spark CORE\n> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('ANSI ', 'utf-8') FROM 7 FOR 0);\n Spark ANSI SQL\n> SELECT overlay(encode('Spark SQL', 'utf-8') PLACING encode('tructured', 'utf-8') FROM 2 FOR 4);\n Structured SQL\n",
+        expr: 'overlay()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'position(substr, str[, pos])',
+        funcDesc: 'Returns the position of the first occurrence of `substr` in `str` after position `pos`. The given `pos` and return value are 1-based.',
+        examples: "> SELECT position('bar', 'foobarbar');\n 4\n> SELECT position('bar', 'foobarbar', 5);\n 7\n> SELECT POSITION('bar' IN 'foobarbar');\n 4\n",
+        expr: 'position()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'printf(strfmt, obj, ...)',
+        funcDesc: 'Returns a formatted string from printf-style format strings.',
+        examples: '> SELECT printf("Hello World %d %s", 100, "days");\n Hello World 100 days\n',
+        expr: 'printf()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_count(str, regexp)',
+        funcDesc: 'Returns a count of the number of times that the regular expression pattern `regexp` is matched in the string `str`.',
+        examples: "> SELECT regexp_count('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');\n 2\n> SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');\n 8\n",
+        expr: 'regexp_count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_extract(str, regexp[, idx])',
+        funcDesc: 'Extract the first string in the `str` that match the `regexp` expression and corresponding to the regex group index.',
+        examples: "> SELECT regexp_extract('100-200', '(\\\\d+)-(\\\\d+)', 1);\n 100\n",
+        expr: 'regexp_extract()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_extract_all(str, regexp[, idx])',
+        funcDesc: 'Extract all strings in the `str` that match the `regexp` expression and corresponding to the regex group index.',
+        examples: '> SELECT regexp_extract_all(\'100-200, 300-400\', \'(\\\\d+)-(\\\\d+)\', 1);\n ["100","300"]\n',
+        expr: 'regexp_extract_all()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_instr(str, regexp)',
+        funcDesc: 'Searches a string for a regular expression and returns an integer that indicates the beginning position of the matched substring. Positions are 1-based, not 0-based. If no match is found, returns 0.',
+        examples: "> SELECT regexp_instr('user@spark.apache.org', '@[^.]*');\n 5\n",
+        expr: 'regexp_instr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_replace(str, regexp, rep[, position])',
+        funcDesc: 'Replaces all substrings of `str` that match `regexp` with `rep`.',
+        examples: "> SELECT regexp_replace('100-200', '(\\\\d+)', 'num');\n num-num\n",
+        expr: 'regexp_replace()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_substr(str, regexp)',
+        funcDesc: 'Returns the substring that matches the regular expression `regexp` within the string `str`. If the regular expression is not found, the result is null.',
+        examples: "> SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Ste(v|ph)en');\n Steven\n> SELECT regexp_substr('Steven Jones and Stephen Smith are the best players', 'Jeck');\n NULL\n",
+        expr: 'regexp_substr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'repeat(str, n)',
+        funcDesc: 'Returns the string which repeats the given string value n times.',
+        examples: "> SELECT repeat('123', 2);\n 123123\n",
+        expr: 'repeat()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'replace(str, search[, replace])',
+        funcDesc: 'Replaces all occurrences of `search` with `replace`.',
+        examples: "> SELECT replace('ABCabc', 'abc', 'DEF');\n ABCDEF\n",
+        expr: 'replace()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'right(str, len)',
+        funcDesc: 'Returns the rightmost `len`(`len` can be string type) characters from the string `str`,if `len` is less or equal than 0 the result is an empty string.',
+        examples: "> SELECT right('Spark SQL', 3);\n SQL\n",
+        expr: 'right()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rpad(str, len[, pad])',
+        funcDesc: 'Returns `str`, right-padded with `pad` to a length of `len`. If `str` is longer than `len`, the return value is shortened to `len` characters. If `pad` is not specified, `str` will be padded to the right with space characters if it is a character string, and with zeros if it is a binary string.',
+        examples: "> SELECT rpad('hi', 5, '??');\n hi???\n> SELECT rpad('hi', 1, '??');\n h\n> SELECT rpad('hi', 5);\n hi\n> SELECT hex(rpad(unhex('aabb'), 5));\n AABB000000\n> SELECT hex(rpad(unhex('aabb'), 5, unhex('1122')));\n AABB112211\n",
+        expr: 'rpad()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rtrim(str)',
+        funcDesc: 'Removes the trailing space characters from `str`.',
+        examples: "> SELECT rtrim('    SparkSQL   ');\n SparkSQL\n",
+        expr: 'rtrim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'sentences(str[, lang, country])',
+        funcDesc: 'Splits `str` into an array of array of words.',
+        examples: '> SELECT sentences(\'Hi there! Good morning.\');\n [["Hi","there"],["Good","morning"]]\n',
+        expr: 'sentences()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'soundex(str)',
+        funcDesc: 'Returns Soundex code of the string.',
+        examples: "> SELECT soundex('Miller');\n M460\n",
+        expr: 'soundex()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'space(n)',
+        funcDesc: 'Returns a string consisting of `n` spaces.',
+        examples: "> SELECT concat(space(2), '1');\n   1\n",
+        expr: 'space()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'split(str, regex, limit)',
+        funcDesc: 'Splits `str` around occurrences that match `regex` and returns an array with a length of at most `limit`',
+        examples: '> SELECT split(\'oneAtwoBthreeC\', \'[ABC]\');\n ["one","two","three",""]\n> SELECT split(\'oneAtwoBthreeC\', \'[ABC]\', -1);\n ["one","two","three",""]\n> SELECT split(\'oneAtwoBthreeC\', \'[ABC]\', 2);\n ["one","twoBthreeC"]\n',
+        expr: 'split()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'split_part(str, delimiter, partNum)',
+        funcDesc: 'Splits `str` by delimiter and return requested part of the split (1-based). If any input is null, returns null. if `partNum` is out of range of split parts, returns empty string. If `partNum` is 0, throws an error. If `partNum` is negative, the parts are counted backward from the end of the string. If the `delimiter` is an empty string, the `str` is not split.',
+        examples: "> SELECT split_part('11.12.13', '.', 3);\n 13\n",
+        expr: 'split_part()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'startswith(left, right)',
+        funcDesc: 'Returns a boolean. The value is True if left starts with right. Returns NULL if either input expression is NULL. Otherwise, returns False. Both left or right must be of STRING or BINARY type.',
+        examples: "> SELECT startswith('Spark SQL', 'Spark');\n true\n> SELECT startswith('Spark SQL', 'SQL');\n false\n> SELECT startswith('Spark SQL', null);\n NULL\n> SELECT startswith(x'537061726b2053514c', x'537061726b');\n true\n> SELECT startswith(x'537061726b2053514c', x'53514c');\n false\n",
+        expr: 'startswith()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'substr(str, pos[, len])',
+        funcDesc: 'Returns the substring of `str` that starts at `pos` and is of length `len`, or the slice of byte array that starts at `pos` and is of length `len`.',
+        examples: "> SELECT substr('Spark SQL', 5);\n k SQL\n> SELECT substr('Spark SQL', -3);\n SQL\n> SELECT substr('Spark SQL', 5, 1);\n k\n> SELECT substr('Spark SQL' FROM 5);\n k SQL\n> SELECT substr('Spark SQL' FROM -3);\n SQL\n> SELECT substr('Spark SQL' FROM 5 FOR 1);\n k\n> SELECT substr(encode('Spark SQL', 'utf-8'), 5);\n k SQL\n",
+        expr: 'substr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'substr(str FROM pos[ FOR len]])',
+        funcDesc: 'Returns the substring of `str` that starts at `pos` and is of length `len`, or the slice of byte array that starts at `pos` and is of length `len`.',
+        examples: "> SELECT substr('Spark SQL', 5);\n k SQL\n> SELECT substr('Spark SQL', -3);\n SQL\n> SELECT substr('Spark SQL', 5, 1);\n k\n> SELECT substr('Spark SQL' FROM 5);\n k SQL\n> SELECT substr('Spark SQL' FROM -3);\n SQL\n> SELECT substr('Spark SQL' FROM 5 FOR 1);\n k\n> SELECT substr(encode('Spark SQL', 'utf-8'), 5);\n k SQL\n",
+        expr: 'substr()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'substring(str, pos[, len])',
+        funcDesc: 'Returns the substring of `str` that starts at `pos` and is of length `len`, or the slice of byte array that starts at `pos` and is of length `len`.',
+        examples: "> SELECT substring('Spark SQL', 5);\n k SQL\n> SELECT substring('Spark SQL', -3);\n SQL\n> SELECT substring('Spark SQL', 5, 1);\n k\n> SELECT substring('Spark SQL' FROM 5);\n k SQL\n> SELECT substring('Spark SQL' FROM -3);\n SQL\n> SELECT substring('Spark SQL' FROM 5 FOR 1);\n k\n> SELECT substring(encode('Spark SQL', 'utf-8'), 5);\n k SQL\n",
+        expr: 'substring()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'substring(str FROM pos[ FOR len]])',
+        funcDesc: 'Returns the substring of `str` that starts at `pos` and is of length `len`, or the slice of byte array that starts at `pos` and is of length `len`.',
+        examples: "> SELECT substring('Spark SQL', 5);\n k SQL\n> SELECT substring('Spark SQL', -3);\n SQL\n> SELECT substring('Spark SQL', 5, 1);\n k\n> SELECT substring('Spark SQL' FROM 5);\n k SQL\n> SELECT substring('Spark SQL' FROM -3);\n SQL\n> SELECT substring('Spark SQL' FROM 5 FOR 1);\n k\n> SELECT substring(encode('Spark SQL', 'utf-8'), 5);\n k SQL\n",
+        expr: 'substring()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'substring_index(str, delim, count)',
+        funcDesc: 'Returns the substring from `str` before `count` occurrences of the delimiter `delim`. If `count` is positive, everything to the left of the final delimiter (counting from the left) is returned. If `count` is negative, everything to the right of the final delimiter (counting from the right) is returned. The function substring_index performs a case-sensitive match when searching for `delim`.',
+        examples: "> SELECT substring_index('www.apache.org', '.', 2);\n www.apache\n",
+        expr: 'substring_index()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_binary(str[, fmt])',
+        funcDesc: 'Converts the input `str` to a binary value based on the supplied `fmt`. `fmt` can be a case-insensitive string literal of "hex", "utf-8", "utf8", or "base64". By default, the binary format for conversion is "hex" if `fmt` is omitted. The function returns NULL if at least one of the input parameters is NULL.',
+        examples: "> SELECT to_binary('abc', 'utf-8');\n abc\n",
+        expr: 'to_binary()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_char(numberExpr, formatExpr)',
+        funcDesc: "Convert `numberExpr` to a string based on the `formatExpr`. Throws an exception if the conversion fails. The format can consist of the following characters, case insensitive: '0' or '9': Specifies an expected digit between 0 and 9. A sequence of 0 or 9 in the format string matches a sequence of digits in the input value, generating a result string of the same length as the corresponding sequence in the format string. The result string is left-padded with zeros if the 0/9 sequence comprises more digits than the matching part of the decimal value, starts with 0, and is before the decimal point. Otherwise, it is padded with spaces. '.' or 'D': Specifies the position of the decimal point (optional, only allowed once). ',' or 'G': Specifies the position of the grouping (thousands) separator (,). There must be a 0 or 9 to the left and right of each grouping separator. '\n′\n:Specifiesthelocationofthe\n′\n:\n𝑆\n𝑝\n𝑒\n𝑐\n𝑖\n𝑓\n𝑖\n𝑒\n𝑠\n𝑡\nℎ\n𝑒\n𝑙\n𝑜\n𝑐\n𝑎\n𝑡\n𝑖\n𝑜\n𝑛\n𝑜\n𝑓\n𝑡\nℎ\n𝑒\n currency sign. This character may only be specified once. 'S' or 'MI': Specifies the position of a '-' or '+' sign (optional, only allowed once at the beginning or end of the format string). Note that 'S' prints '+' for positive values but 'MI' prints a space. 'PR': Only allowed at the end of the format string; specifies that the result string will be wrapped by angle brackets if the input value is negative. ('<1>').",
+        examples: "> SELECT to_char(454, '999');\n 454\n> SELECT to_char(454.00, '000D00');\n 454.00\n> SELECT to_char(12454, '99G999');\n 12,454\n> SELECT to_char(78.12, '$99.99');\n $78.12\n> SELECT to_char(-12454.8, '99G999D9S');\n 12,454.8-\n",
+        expr: 'to_char()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_number(expr, fmt)',
+        funcDesc: "Convert string 'expr' to a number based on the string format 'fmt'. Throws an exception if the conversion fails. The format can consist of the following characters, case insensitive: '0' or '9': Specifies an expected digit between 0 and 9. A sequence of 0 or 9 in the format string matches a sequence of digits in the input string. If the 0/9 sequence starts with 0 and is before the decimal point, it can only match a digit sequence of the same size. Otherwise, if the sequence starts with 9 or is after the decimal point, it can match a digit sequence that has the same or smaller size. '.' or 'D': Specifies the position of the decimal point (optional, only allowed once). ',' or 'G': Specifies the position of the grouping (thousands) separator (,). There must be a 0 or 9 to the left and right of each grouping separator. 'expr' must match the grouping separator relevant for the size of the number. '\n′\n:Specifiesthelocationofthe\n′\n:\n𝑆\n𝑝\n𝑒\n𝑐\n𝑖\n𝑓\n𝑖\n𝑒\n𝑠\n𝑡\nℎ\n𝑒\n𝑙\n𝑜\n𝑐\n𝑎\n𝑡\n𝑖\n𝑜\n𝑛\n𝑜\n𝑓\n𝑡\nℎ\n𝑒\n currency sign. This character may only be specified once. 'S' or 'MI': Specifies the position of a '-' or '+' sign (optional, only allowed once at the beginning or end of the format string). Note that 'S' allows '-' but 'MI' does not. 'PR': Only allowed at the end of the format string; specifies that 'expr' indicates a negative number with wrapping angled brackets. ('<1>').",
+        examples: "> SELECT to_number('454', '999');\n 454\n> SELECT to_number('454.00', '000.00');\n 454.00\n> SELECT to_number('12,454', '99,999');\n 12454\n> SELECT to_number('$78.12', '$99.99');\n 78.12\n> SELECT to_number('12,454.8-', '99,999.9S');\n -12454.8\n",
+        expr: 'to_number()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'translate(input, from, to)',
+        funcDesc: 'Translates the `input` string by replacing the characters present in the `from` string with the corresponding characters in the `to` string.',
+        examples: "> SELECT translate('AaBbCc', 'abc', '123');\n A1B2C3\n",
+        expr: 'translate()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(str)',
+        funcDesc: 'Removes the leading and trailing space characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(BOTH FROM str)',
+        funcDesc: 'Removes the leading and trailing space characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(LEADING FROM str)',
+        funcDesc: 'Removes the leading space characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(TRAILING FROM str)',
+        funcDesc: 'Removes the trailing space characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(trimStr FROM str)',
+        funcDesc: 'Remove the leading and trailing `trimStr` characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(BOTH trimStr FROM str)',
+        funcDesc: 'Remove the leading and trailing `trimStr` characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(LEADING trimStr FROM str)',
+        funcDesc: 'Remove the leading `trimStr` characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'trim(TRAILING trimStr FROM str)',
+        funcDesc: 'Remove the trailing `trimStr` characters from `str`.',
+        examples: "> SELECT trim('    SparkSQL   ');\n SparkSQL\n> SELECT trim(BOTH FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(LEADING FROM '    SparkSQL   ');\n SparkSQL\n> SELECT trim(TRAILING FROM '    SparkSQL   ');\n     SparkSQL\n> SELECT trim('SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(BOTH 'SL' FROM 'SSparkSQLS');\n parkSQ\n> SELECT trim(LEADING 'SL' FROM 'SSparkSQLS');\n parkSQLS\n> SELECT trim(TRAILING 'SL' FROM 'SSparkSQLS');\n SSparkSQ\n",
+        expr: 'trim()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_to_binary(str[, fmt])',
+        funcDesc: 'This is a special version of `to_binary` that performs the same operation, but returns a NULL value instead of raising an error if the conversion cannot be performed.',
+        examples: "> SELECT try_to_binary('abc', 'utf-8');\n abc\n> select try_to_binary('a!', 'base64');\n NULL\n> select try_to_binary('abc', 'invalidFormat');\n NULL\n",
+        expr: 'try_to_binary()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'try_to_number(expr, fmt)',
+        funcDesc: "Convert string 'expr' to a number based on the string format `fmt`. Returns NULL if the string 'expr' does not match the expected format. The format follows the same semantics as the to_number function.",
+        examples: "> SELECT try_to_number('454', '999');\n 454\n> SELECT try_to_number('454.00', '000.00');\n 454.00\n> SELECT try_to_number('12,454', '99,999');\n 12454\n> SELECT try_to_number('$78.12', '$99.99');\n 78.12\n> SELECT try_to_number('12,454.8-', '99,999.9S');\n -12454.8\n",
+        expr: 'try_to_number()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ucase(str)',
+        funcDesc: 'Returns `str` with all characters changed to uppercase.',
+        examples: "> SELECT ucase('SparkSql');\n SPARKSQL\n",
+        expr: 'ucase()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'unbase64(str)',
+        funcDesc: 'Converts the argument from a base 64 string `str` to a binary.',
+        examples: "> SELECT unbase64('U3BhcmsgU1FM');\n Spark SQL\n",
+        expr: 'unbase64()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'upper(str)',
+        funcDesc: 'Returns `str` with all characters changed to uppercase.',
+        examples: "> SELECT upper('SparkSql');\n SPARKSQL\n",
+        expr: 'upper()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'coalesce(expr1, expr2, ...)',
+        funcDesc: 'Returns the first non-null argument if exists. Otherwise, null.',
+        examples: '> SELECT coalesce(NULL, 1, NULL);\n 1\n',
+        expr: 'coalesce()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'if(expr1, expr2, expr3)',
+        funcDesc: 'If `expr1` evaluates to true, then returns `expr2`; otherwise returns `expr3`.',
+        examples: "> SELECT if(1 < 2, 'a', 'b');\n a\n",
+        expr: 'if()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'ifnull(expr1, expr2)',
+        funcDesc: 'Returns `expr2` if `expr1` is null, or `expr1` otherwise.',
+        examples: '> SELECT ifnull(NULL, array(\'2\'));\n ["2"]\n',
+        expr: 'ifnull()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'nanvl(expr1, expr2)',
+        funcDesc: "Returns `expr1` if it's not NaN, or `expr2` otherwise.",
+        examples: "> SELECT nanvl(cast('NaN' as double), 123);\n 123.0\n",
+        expr: 'nanvl()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'nullif(expr1, expr2)',
+        funcDesc: 'Returns null if `expr1` equals to `expr2`, or `expr1` otherwise.',
+        examples: '> SELECT nullif(2, 2);\n NULL\n',
+        expr: 'nullif()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'nvl(expr1, expr2)',
+        funcDesc: 'Returns `expr2` if `expr1` is null, or `expr1` otherwise.',
+        examples: '> SELECT nvl(NULL, array(\'2\'));\n ["2"]\n',
+        expr: 'nvl()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'nvl2(expr1, expr2, expr3)',
+        funcDesc: 'Returns `expr2` if `expr1` is not null, or `expr3` otherwise.',
+        examples: '> SELECT nvl2(NULL, 2, 1);\n 1\n',
+        expr: 'nvl2()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]* [ELSE expr5] END',
+        funcDesc: 'When `expr1` = true, returns `expr2`; else when `expr3` = true, returns `expr4`; else returns `expr5`.',
+        examples: '> SELECT CASE WHEN 1 > 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;\n 1.0\n> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 > 0 THEN 2.0 ELSE 1.2 END;\n 2.0\n> SELECT CASE WHEN 1 < 0 THEN 1 WHEN 2 < 0 THEN 2.0 END;\n NULL',
+        expr: 'CASE WHEN expr1 THEN expr2 [WHEN expr3 THEN expr4]* [ELSE expr5] END',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 & expr2',
+        funcDesc: 'Returns the result of bitwise AND of `expr1` and `expr2`.',
+        examples: '> SELECT 3 & 5;\n 1\n',
+        expr: 'expr1 & expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 ^ expr2',
+        funcDesc: 'Returns the result of bitwise exclusive OR of `expr1` and `expr2`.',
+        examples: '> SELECT 3 ^ 5;\n 6\n',
+        expr: 'expr1 ^ expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_count(expr)',
+        funcDesc: 'Returns the number of bits that are set in the argument expr as an unsigned 64-bit integer, or NULL if the argument is NULL.',
+        examples: '> SELECT bit_count(0);\n 0\n',
+        expr: 'bit_count()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bit_get(expr, pos)',
+        funcDesc: 'Returns the value of the bit (0 or 1) at the specified position. The positions are numbered from right to left, starting at zero. The position argument cannot be negative.',
+        examples: '> SELECT bit_get(11, 0);\n 1\n> SELECT bit_get(11, 2);\n 0\n',
+        expr: 'bit_get()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'getbit(expr, pos)',
+        funcDesc: 'Returns the value of the bit (0 or 1) at the specified position. The positions are numbered from right to left, starting at zero. The position argument cannot be negative.',
+        examples: '> SELECT getbit(11, 0);\n 1\n> SELECT getbit(11, 2);\n 0\n',
+        expr: 'getbit()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'shiftright(base, expr)',
+        funcDesc: 'Bitwise (signed) right shift.',
+        examples: '> SELECT shiftright(4, 1);\n 2\n',
+        expr: 'shiftright()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'shiftrightunsigned(base, expr)',
+        funcDesc: 'Bitwise unsigned right shift.',
+        examples: '> SELECT shiftrightunsigned(4, 1);\n 2\n',
+        expr: 'shiftrightunsigned()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 | expr2',
+        funcDesc: 'Returns the result of bitwise OR of `expr1` and `expr2`.',
+        examples: '> SELECT 3 | 5;\n 7\n',
+        expr: 'expr1 | expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: '~ expr',
+        funcDesc: 'Returns the result of bitwise NOT of `expr`.',
+        examples: '> SELECT ~ 0;\n -1\n',
+        expr: '~ expr',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'bigint(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `bigint`.',
+        examples: "> SELECT bigint(current_timestamp);\n 1616168320\n> SELECT bigint('5');\n 5\n",
+        expr: 'bigint()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'binary(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `binary`.',
+        examples: "> SELECT binary('Spark SQL');\n [53 70 61 72 6B 20 53 51 4C]\n> SELECT binary(1984);\n [00 00 07 C0]\n",
+        expr: 'binary()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'boolean(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `boolean`.',
+        examples: '> SELECT boolean(1);\n true\n> SELECT boolean(0);\n false\n> SELECT boolean(2);\n true\n',
+        expr: 'boolean()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'cast(expr AS type)',
+        funcDesc: 'Casts the value `expr` to the target data type `type`.',
+        examples: "> SELECT cast('10' as int);\n 10\n",
+        expr: 'cast()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'date(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `date`.',
+        examples: "> SELECT date_add('2016-07-30', 1);\n 2016-07-31\n",
+        expr: 'date()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'decimal(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `decimal`.',
+        examples: "> SELECT decimal('5.2');\n 5\n",
+        expr: 'decimal()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'double(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `double`.',
+        examples: "> SELECT double('5.2');\n 5.2",
+        expr: 'double()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'float(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `float`.',
+        examples: "> SELECT float('5.2');\n 5.2\n",
+        expr: 'float()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'int(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `int`.',
+        examples: "> SELECT int(-5.6);\n 5\n> SELECT int('5');\n 5\n",
+        expr: 'int()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'smallint(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `smallint`.',
+        examples: "> SELECT smallint(-5.6);\n 5\n> SELECT smallint('5');\n 5\n",
+        expr: 'smallint()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'string(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `string`.',
+        examples: '> SELECT string(5);\n 5\n> SELECT string(current_date);\n 2021-04-01\n',
+        expr: 'string()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'timestamp(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `timestamp`.',
+        examples: '> SELECT timestamp_micros(1230219000123123);\n 2008-12-25 07:30:00.123123\n',
+        expr: 'timestamp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'tinyint(expr)',
+        funcDesc: 'Casts the value `expr` to the target data type `tinyint`.',
+        examples: "> SELECT tinyint('12');\n 12\n> SELECT tinyint(5.4);\n 5\n",
+        expr: 'tinyint()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: '! expr',
+        funcDesc: 'Logical not.',
+        examples: '> SELECT ! true;\n false\n> SELECT ! false;\n true\n> SELECT ! NULL;\n NULL\n',
+        expr: '! expr',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 < expr2',
+        funcDesc: 'Returns true if `expr1` is less than `expr2`.',
+        examples: "> SELECT 1 < 2;\n true\n> SELECT 1.1 < '1';\n false\n> SELECT to_date('2009-07-30 04:17:52') < to_date('2009-07-30 04:17:52');\n false\n SELECT to_date('2009-07-30 04:17:52') < to_date('2009-08-01 04:17:52');\n true\n> SELECT 1 < NULL;\n NULL\n",
+        expr: 'expr1 < expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 <= expr2',
+        funcDesc: 'Returns true if `expr1` is less than or equal to `expr2`.',
+        examples: "> SELECT 2 <= 2;\n true\n> SELECT 1.0 <= '1';\n true\n> SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-07-30 04:17:52');\n true\n> SELECT to_date('2009-07-30 04:17:52') <= to_date('2009-08-01 04:17:52');\n true\n> SELECT 1 <= NULL;\n NULL\n",
+        expr: 'expr1 <= expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 <=> expr2',
+        funcDesc: 'Returns same result as the EQUAL(=) operator for non-null operands, but returns true if both are null, false if one of the them is null.',
+        examples: "> SELECT 2 <=> 2;\n true\n> SELECT 1 <=> '1';\n true\n> SELECT true <=> NULL;\n false\n> SELECT NULL <=> NULL;\n true\n",
+        expr: 'expr1 <=> expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 = expr2',
+        funcDesc: 'Returns true if `expr1` equals `expr2`, or false otherwise.',
+        examples: "> SELECT 2 = 2;\n true\n> SELECT 1 = '1';\n true\n> SELECT true = NULL;\n NULL\n> SELECT NULL = NULL;\n NULL\n",
+        expr: 'expr1 = expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 == expr2',
+        funcDesc: 'Returns true if `expr1` equals `expr2`, or false otherwise.',
+        examples: "> SELECT 2 == 2;\n true\n> SELECT 1 == '1';\n true\n> SELECT true == NULL;\n NULL\n> SELECT NULL == NULL;\n NULL\n",
+        expr: 'expr1 == expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 > expr2',
+        funcDesc: 'Returns true if `expr1` is greater than `expr2`.',
+        examples: "> SELECT 2 > 1;\n true\n> SELECT 2 > 1.1;\n true\n> SELECT to_date('2009-07-30 04:17:52') > to_date('2009-07-30 04:17:52');\n false\n> SELECT to_date('2009-07-30 04:17:52') > to_date('2009-08-01 04:17:52');\n false\n> SELECT 1 > NULL;\n NULL\n",
+        expr: 'expr1 > expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 >= expr2',
+        funcDesc: 'Returns true if `expr1` is greater than or equal to `expr2`.',
+        examples: "> SELECT 2 >= 1;\n true\n> SELECT 2.0 >= '2.1';\n false\n> SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-07-30 04:17:52');\n true\n> SELECT to_date('2009-07-30 04:17:52') >= to_date('2009-08-01 04:17:52');\n false\n> SELECT 1 >= NULL;\n NULL\n",
+        expr: 'expr1 >= expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 and expr2',
+        funcDesc: 'Logical AND.',
+        examples: '> SELECT true and true;\n true\n> SELECT true and false;\n false\n> SELECT true and NULL;\n NULL\n> SELECT false and NULL;\n false\n',
+        expr: 'expr1 and expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'str ilike pattern[ ESCAPE escape]',
+        funcDesc: 'Returns true if str matches `pattern` with `escape` case-insensitively, null if any arguments are null, false otherwise.',
+        examples: "> SELECT ilike('Spark', '_Park');\n true\n> SET spark.sql.parser.escapedStringLiterals=true;\n spark.sql.parser.escapedStringLiterals  true\n> SELECT '%SystemDrive%\\Users\\John' ilike '\\%SystemDrive\\%\\\\users%';\n true\n> SET spark.sql.parser.escapedStringLiterals=false;\n spark.sql.parser.escapedStringLiterals  false\n> SELECT '%SystemDrive%\\\\USERS\\\\John' ilike '\\%SystemDrive\\%\\\\\\\\Users%';\n true\n> SELECT '%SystemDrive%/Users/John' ilike '/%SYSTEMDrive/%//Users%' ESCAPE '/';\n true\n",
+        expr: 'str ilike pattern[ ESCAPE escape]',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 in(expr2, expr3, ...)',
+        funcDesc: 'Returns true if `expr` equals to any valN.',
+        examples: "> SELECT 1 in(1, 2, 3);\n true\n> SELECT 1 in(2, 3, 4);\n false\n> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 1), named_struct('a', 1, 'b', 3));\n false\n> SELECT named_struct('a', 1, 'b', 2) in(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 3));\n true\n",
+        expr: 'expr1 in()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'isnan(expr)',
+        funcDesc: 'Returns true if `expr` is NaN, or false otherwise.',
+        examples: "> SELECT isnan(cast('NaN' as double));\n true\n",
+        expr: 'isnan()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'isnotnull(expr)',
+        funcDesc: 'Returns true if `expr` is not null, or false otherwise.',
+        examples: '> SELECT isnotnull(1);\n true\n',
+        expr: 'isnotnull()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'isnull(expr)',
+        funcDesc: 'Returns true if `expr` is null, or false otherwise.',
+        examples: '> SELECT isnull(1);\n false\n',
+        expr: 'isnull()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'str like pattern[ ESCAPE escape]',
+        funcDesc: 'Returns true if str matches `pattern` with `escape`, null if any arguments are null, false otherwise.',
+        examples: "> SELECT like('Spark', '_park');\n true\n> SET spark.sql.parser.escapedStringLiterals=true;\n spark.sql.parser.escapedStringLiterals  true\n> SELECT '%SystemDrive%\\Users\\John' like '\\%SystemDrive\\%\\\\Users%';\n true\n> SET spark.sql.parser.escapedStringLiterals=false;\n spark.sql.parser.escapedStringLiterals  false\n> SELECT '%SystemDrive%\\\\Users\\\\John' like '\\%SystemDrive\\%\\\\\\\\Users%';\n true\n> SELECT '%SystemDrive%/Users/John' like '/%SystemDrive/%//Users%' ESCAPE '/';\n true\n",
+        expr: 'str like pattern[ ESCAPE escape]',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'not expr',
+        funcDesc: 'Logical not.',
+        examples: '> SELECT not true;\n false\n> SELECT not false;\n true\n> SELECT not NULL;\n NULL\n',
+        expr: 'not expr',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'expr1 or expr2',
+        funcDesc: 'Logical OR.',
+        examples: '> SELECT true or false;\n true\n> SELECT false or false;\n false\n> SELECT true or NULL;\n true\n> SELECT false or NULL;\n NULL\n',
+        expr: 'expr1 or expr2',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp(str, regexp)',
+        funcDesc: 'Returns true if `str` matches `regexp`, or false otherwise.',
+        examples: "> SET spark.sql.parser.escapedStringLiterals=true;\nspark.sql.parser.escapedStringLiterals  true\n> SELECT regexp('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');\ntrue\n> SET spark.sql.parser.escapedStringLiterals=false;\nspark.sql.parser.escapedStringLiterals  false\n> SELECT regexp('%SystemDrive%\\\\Users\\\\John', '%SystemDrive%\\\\\\\\Users.*');\ntrue\n",
+        expr: 'regexp()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'regexp_like(str, regexp)',
+        funcDesc: 'Returns true if `str` matches `regexp`, or false otherwise.',
+        examples: "> SET spark.sql.parser.escapedStringLiterals=true;\nspark.sql.parser.escapedStringLiterals  true\n> SELECT regexp_like('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');\ntrue\n> SET spark.sql.parser.escapedStringLiterals=false;\nspark.sql.parser.escapedStringLiterals  false\n> SELECT regexp_like('%SystemDrive%\\\\Users\\\\John', '%SystemDrive%\\\\\\\\Users.*');\ntrue\n",
+        expr: 'regexp_like()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'rlike(str, regexp)',
+        funcDesc: 'Returns true if `str` matches `regexp`, or false otherwise.',
+        examples: "> SET spark.sql.parser.escapedStringLiterals=true;\nspark.sql.parser.escapedStringLiterals  true\n> SELECT rlike('%SystemDrive%\\Users\\John', '%SystemDrive%\\\\Users.*');\ntrue\n> SET spark.sql.parser.escapedStringLiterals=false;\nspark.sql.parser.escapedStringLiterals  false\n> SELECT rlike('%SystemDrive%\\\\Users\\\\John', '%SystemDrive%\\\\\\\\Users.*');\ntrue\n",
+        expr: 'rlike()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'from_csv(csvStr, schema[, options])',
+        funcDesc: 'Returns a struct value with the given `csvStr` and `schema`.',
+        examples: "> SELECT from_csv('1, 0.8', 'a INT, b DOUBLE');\n {\"a\":1,\"b\":0.8}\n> SELECT from_csv('26/08/2015', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));\n {\"time\":2015-08-26 00:00:00}\n",
+        expr: 'from_csv()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'schema_of_csv(csv[, options])',
+        funcDesc: 'Returns schema in the DDL format of CSV string.',
+        examples: "> SELECT schema_of_csv('1,abc');\n STRUCT<_c0: INT, _c1: STRING>\n",
+        expr: 'schema_of_csv()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'to_csv(expr[, options])',
+        funcDesc: 'Returns a CSV string with a given struct value',
+        examples: "> SELECT to_csv(named_struct('a', 1, 'b', 2));\n 1,2\n> SELECT to_csv(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));\n 26/08/2015\n",
+        expr: 'to_csv()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'aes_decrypt(expr, key[, mode[, padding]])',
+        funcDesc: "Returns a decrypted value of `expr` using AES in `mode` with `padding`. Key lengths of 16, 24 and 32 bits are supported. Supported combinations of (`mode`, `padding`) are ('ECB', 'PKCS') and ('GCM', 'NONE'). The default mode is GCM.",
+        examples: "> SELECT aes_decrypt(unhex('83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94'), '0000111122223333');\n Spark\n> SELECT aes_decrypt(unhex('6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210'), '0000111122223333', 'GCM');\n Spark SQL\n> SELECT aes_decrypt(unbase64('3lmwu+Mw0H3fi5NDvcu9lg=='), '1234567890abcdef', 'ECB', 'PKCS');\n Spark SQL\n",
+        expr: 'aes_decrypt()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'aes_encrypt(expr, key[, mode[, padding]])',
+        funcDesc: "Returns an encrypted value of `expr` using AES in given `mode` with the specified `padding`. Key lengths of 16, 24 and 32 bits are supported. Supported combinations of (`mode`, `padding`) are ('ECB', 'PKCS') and ('GCM', 'NONE'). The default mode is GCM.",
+        examples: "> SELECT hex(aes_encrypt('Spark', '0000111122223333'));\n 83F16B2AA704794132802D248E6BFD4E380078182D1544813898AC97E709B28A94\n> SELECT hex(aes_encrypt('Spark SQL', '0000111122223333', 'GCM'));\n 6E7CA17BBB468D3084B5744BCA729FB7B2B7BCB8E4472847D02670489D95FA97DBBA7D3210\n> SELECT base64(aes_encrypt('Spark SQL', '1234567890abcdef', 'ECB', 'PKCS'));\n 3lmwu+Mw0H3fi5NDvcu9lg==\n",
+        expr: 'aes_encrypt()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'assert_true(expr)',
+        funcDesc: 'Throws an exception if `expr` is not true.',
+        examples: '> SELECT assert_true(0 < 1);\n NULL\n',
+        expr: 'assert_true()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_catalog()',
+        funcDesc: 'Returns the current catalog.',
+        examples: '> SELECT current_catalog();\n spark_catalog\n',
+        expr: 'current_catalog()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_database()',
+        funcDesc: 'Returns the current database.',
+        examples: '> SELECT current_database();\n default\n',
+        expr: 'current_database()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_schema()',
+        funcDesc: 'Returns the current database.',
+        examples: '> SELECT current_schema();\n default\n',
+        expr: 'current_schema()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'current_user()',
+        funcDesc: 'user name of current execution context.',
+        examples: '> SELECT current_user();\n mockingjay\n',
+        expr: 'current_user()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'equal_null(expr1, expr2)',
+        funcDesc: 'Returns same result as the EQUAL(=) operator for non-null operands, but returns true if both are null, false if one of the them is null.',
+        examples: "> SELECT equal_null(3, 3);\n true\n> SELECT equal_null(1, '11');\n false\n> SELECT equal_null(true, NULL);\n false\n> SELECT equal_null(NULL, 'abc');\n false\n> SELECT equal_null(NULL, NULL);\n true\n",
+        expr: 'equal_null()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'input_file_block_length()',
+        funcDesc: 'Returns the length of the block being read, or -1 if not available.',
+        examples: '> SELECT input_file_block_length();\n -1\n',
+        expr: 'input_file_block_length()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'input_file_block_start()',
+        funcDesc: 'Returns the start offset of the block being read, or -1 if not available.',
+        examples: '> SELECT input_file_block_start();\n -1\n',
+        expr: 'input_file_block_start()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'input_file_name()',
+        funcDesc: 'Returns the name of the file being read, or empty string if not available.',
+        examples: '> SELECT input_file_name();\n',
+        expr: 'input_file_name()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'java_method(class, method[, arg1[, arg2 ..]])',
+        funcDesc: 'Calls a method with reflection.',
+        examples: "> SELECT java_method('java.util.UUID', 'randomUUID');\n c33fb387-8500-4bfa-81d2-6e0e3e930df2\n> SELECT java_method('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');\n a5cf6c42-0c85-418f-af6c-3e4e5b1328f2\n",
+        expr: 'java_method()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'monotonically_increasing_id()',
+        funcDesc: 'Returns monotonically increasing 64-bit integers. The generated ID is guaranteed to be monotonically increasing and unique, but not consecutive. The current implementation puts the partition ID in the upper 31 bits, and the lower 33 bits represent the record number within each partition. The assumption is that the data frame has less than 1 billion partitions, and each partition has less than 8 billion records. The function is non-deterministic because its result depends on partition IDs.',
+        examples: '> SELECT monotonically_increasing_id();\n 0\n',
+        expr: 'monotonically_increasing_id()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'reflect(class, method[, arg1[, arg2 ..]])',
+        funcDesc: 'Calls a method with reflection.',
+        examples: "> SELECT reflect('java.util.UUID', 'randomUUID');\n c33fb387-8500-4bfa-81d2-6e0e3e930df2\n> SELECT reflect('java.util.UUID', 'fromString', 'a5cf6c42-0c85-418f-af6c-3e4e5b1328f2');\n a5cf6c42-0c85-418f-af6c-3e4e5b1328f2\n",
+        expr: 'reflect()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'spark_partition_id()',
+        funcDesc: 'Returns the current partition id.',
+        examples: '> SELECT spark_partition_id();\n 0\n',
+        expr: 'spark_partition_id()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'typeof(expr)',
+        funcDesc: 'Return DDL-formatted type string for the data type of the input.',
+        examples: '> SELECT typeof(1);\n int\n> SELECT typeof(array(1));\n array<int>\n',
+        expr: 'typeof()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'user()',
+        funcDesc: 'user name of current execution context.',
+        examples: '> SELECT user();\n mockingjay\n',
+        expr: 'user()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'uuid()',
+        funcDesc: 'Returns an universally unique identifier (UUID) string. The value is returned as a canonical UUID 36-character string.',
+        examples: '> SELECT uuid();\n 46707d92-02f4-4817-8116-a4c3b23e6266\n',
+        expr: 'uuid()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'version()',
+        funcDesc: 'Returns the Spark version. The string contains 2 fields, the first being a release version and the second being a git revision.',
+        examples: '> SELECT version();\n 3.1.0 a6d6ea3efedbad14d99c24143834cd4e2e52fb40\n',
+        expr: 'version()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'explode(expr)',
+        funcDesc: 'Separates the elements of array `expr` into multiple rows, or the elements of map `expr` into multiple rows and columns. Unless specified otherwise, uses the default column name `col` for elements of the array or `key` and `value` for the elements of the map.',
+        examples: '> SELECT explode(array(10, 20));\n 10\n 20\n',
+        expr: 'explode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'explode_outer(expr)',
+        funcDesc: 'Separates the elements of array `expr` into multiple rows, or the elements of map `expr` into multiple rows and columns. Unless specified otherwise, uses the default column name `col` for elements of the array or `key` and `value` for the elements of the map.',
+        examples: '> SELECT explode_outer(array(10, 20));\n 10\n 20\n',
+        expr: 'explode_outer()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'inline(expr)',
+        funcDesc: 'Explodes an array of structs into a table. Uses column names col1, col2, etc. by default unless specified otherwise.',
+        examples: "> SELECT inline(array(struct(1, 'a'), struct(2, 'b')));\n 1  a\n 2  b\n",
+        expr: 'inline()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'inline_outer(expr)',
+        funcDesc: 'Explodes an array of structs into a table. Uses column names col1, col2, etc. by default unless specified otherwise.',
+        examples: "> SELECT inline_outer(array(struct(1, 'a'), struct(2, 'b')));\n 1  a\n 2  b\n",
+        expr: 'inline_outer()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'posexplode(expr)',
+        funcDesc: 'Separates the elements of array `expr` into multiple rows with positions, or the elements of map `expr` into multiple rows and columns with positions. Unless specified otherwise, uses the column name `pos` for position, `col` for elements of the array or `key` and `value` for elements of the map.',
+        examples: '> SELECT posexplode(array(10,20));\n 0  10\n 1  20\n',
+        expr: 'posexplode()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'posexplode_outer(expr)',
+        funcDesc: 'Separates the elements of array `expr` into multiple rows with positions, or the elements of map `expr` into multiple rows and columns with positions. Unless specified otherwise, uses the column name `pos` for position, `col` for elements of the array or `key` and `value` for elements of the map.',
+        examples: '> SELECT posexplode_outer(array(10,20));\n 0  10\n 1  20\n',
+        expr: 'posexplode_outer()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    },
+    {
+        name: 'stack(n, expr1, ..., exprk)',
+        funcDesc: 'Separates `expr1`, ..., `exprk` into `n` rows. Uses column names col0, col1, etc. by default unless specified otherwise.',
+        examples: '> SELECT stack(2, 1, 2, 3);\n 1  2\n 3  NULL\n',
+        expr: 'stack()',
+        description: {
+            kind: vscode_languageserver_types_1.MarkupKind.Markdown,
+            value: ''
+        }
+    }
+].map(func => ({
+    ...func,
+    description: {
+        kind: func.description.kind,
+        value: generateDescription(func)
+    }
+}));
+//# sourceMappingURL=built-in-functions.js.map