@gravity-ui/querieskit 1.0.1

package/src/components/MonacoEditor/monaco-yql-languages/clickhouse/clickhouse.ts

@@ -0,0 +1,217 @@
+import {type languages} from '../fillers/monaco-editor-core';
+import {
+    constants,
+    dataTypeFamiliesCaseInsensitive,
+    dataTypeFamiliesCaseSensitive,
+    functionsCaseInsensitive,
+    functionsCaseSensitive,
+    keywords,
+    tableEngines,
+    tableFunctions,
+} from './clickhouse.keywords';
+
+export const conf: languages.LanguageConfiguration = {
+    comments: {
+        lineComment: '--',
+        blockComment: ['```', '```'],
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+        {open: '"', close: '"'},
+        {open: "'", close: "'"},
+        {open: '`', close: '`'},
+    ],
+    surroundingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+        {open: '"', close: '"'},
+        {open: "'", close: "'"},
+        {open: '`', close: '`'},
+    ],
+};
+
+const keywordsCaseInsensitive = getCaseInsensitiveRegExp(keywords);
+const typeKeywordsCaseInsensitive = getCaseInsensitiveRegExp(
+    oneWordPatterns(dataTypeFamiliesCaseInsensitive),
+);
+const builtinFunctionsCaseInsensitive = getCaseInsensitiveRegExp(functionsCaseInsensitive);
+
+export const language: languages.IMonarchLanguage & Record<string, unknown> = {
+    defaultToken: 'text',
+
+    brackets: [
+        {open: '[', close: ']', token: 'delimiter.square'},
+        {open: '(', close: ')', token: 'delimiter.parenthesis'},
+        {open: '{', close: '}', token: 'delimiter.curly'},
+    ],
+
+    keywords,
+
+    keywordsDouble: [
+        `${caseInsensitiveRegExp('GROUP')}\\W+${caseInsensitiveRegExp('BY')}`,
+        `${caseInsensitiveRegExp('ON')}\\W+${caseInsensitiveRegExp('CLUSTER')}`,
+        `${caseInsensitiveRegExp('ORDER')}\\W+${caseInsensitiveRegExp('BY')}`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W*,\\W*\\d+`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+\\W+${caseInsensitiveRegExp('BY')}\\W+`,
+        `${caseInsensitiveRegExp('LIMIT')}\\W+\\d+`,
+        `${caseInsensitiveRegExp('RENAME')}\\W+${caseInsensitiveRegExp('TABLE')}`,
+        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp(
+            'NOT',
+        )}\\W+${caseInsensitiveRegExp('EXISTS')}`,
+        `${caseInsensitiveRegExp('IF')}\\W+${caseInsensitiveRegExp('EXISTS')}`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+Vertical`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONCompact`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSONEachRow`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TSKV`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNames`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedWithNamesAndTypes`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparatedRaw`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+BlockTabSeparated`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+CSVWithNames`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+CSV`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+JSON`,
+        `${caseInsensitiveRegExp('FORMAT')}\\W+TabSeparated`,
+    ].join('|'),
+
+    typeKeywords: dataTypeFamiliesCaseSensitive,
+    typeKeywordsDouble: getCaseInsensitiveRegExp(
+        manyWordsPatterns(dataTypeFamiliesCaseInsensitive),
+    ),
+    constants,
+
+    builtinFunctions: functionsCaseSensitive,
+
+    tableFunctions,
+    tableEngines,
+
+    operators: [
+        '+',
+        '-',
+        '/',
+        '//',
+        '%',
+        '<@>',
+        '@>',
+        '<@',
+        '&',
+        '^',
+        '~',
+        '<',
+        '>',
+        '<=',
+        '=>',
+        '==',
+        '!=',
+        '<>',
+        '=',
+    ],
+
+    symbols: /[=><!~?:&|+\-*/^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+    variables: /[\w]+(?:\[[\w\]]+|=-]>[\w]+)?/,
+
+    tokenizer: {
+        root: [
+            {include: '@whitespace'},
+            {include: '@comments'},
+            {include: '@numbers'},
+            {include: '@strings'},
+            [/[$@:](@variables)/, 'variable'],
+            [/\{(@variables)\}/, 'variable'],
+            [/[?;,.]/, 'delimiter'],
+            [/[{}()[\]]/, '@brackets'],
+            [/(\w+\.)*`\/\/(.*?)`/g, {token: 'path'}],
+            [/@keywordsDouble/, 'keyword'],
+            [/@typeKeywordsDouble/, 'keyword.type'],
+            [
+                /[a-zA-Z_$][\w$]*/,
+                {
+                    cases: {
+                        [keywordsCaseInsensitive]: {token: 'keyword'},
+                        '@constants': {token: 'constant'},
+                        '@builtinFunctions': {token: 'constant.other.color'},
+                        [builtinFunctionsCaseInsensitive]: {token: 'constant.other.color'},
+                        '@tableFunctions': {token: 'constant.other.color'},
+                        '@tableEngines': {token: 'constant.other.color'},
+                        '@typeKeywords': {token: 'keyword.type'},
+                        [typeKeywordsCaseInsensitive]: {token: 'keyword.type'},
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+            [
+                /@symbols/,
+                {
+                    cases: {
+                        '@operators': 'operator.sql',
+                        '@default': '',
+                    },
+                },
+            ],
+        ],
+        whitespace: [[/\s+/, 'white']],
+        comments: [
+            [/--+.*/, 'comment'],
+            [/\/\*/, {token: 'comment.quote', next: '@cppComment'}],
+        ],
+        comment: [
+            [/[^`]+/, 'comment'],
+            [/./, 'comment'],
+        ],
+        cppComment: [
+            [/[^*/]+/, 'comment'],
+            [/./, 'comment'],
+        ],
+        numbers: [[/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/, 'number']],
+        strings: [
+            [/'/, {token: 'string', next: '@stringSingle'}],
+            [/"/, {token: 'string.tablepath', next: '@stringDouble'}],
+        ],
+        stringSingle: [
+            [/[^\\']/, 'string'],
+            [/@escapes/, 'string.escape'],
+            [/\\./, 'string.escape.invalid'],
+            [/'/, {token: 'string', next: '@pop'}],
+        ],
+        stringDouble: [
+            [/[^\\"]/, 'string.tablepath'],
+            [/@escapes/, 'string.tablepath'],
+            [/\\./, 'string.tablepath'],
+            [/"/, {token: 'string.tablepath', next: '@pop'}],
+        ],
+    },
+};
+
+function caseInsensitiveRegExp(pattern: string) {
+    return pattern
+        .split('')
+        .map((char) => {
+            if (/[a-zA-Z]/.test(char)) {
+                return `[${char.toLowerCase()}${char.toUpperCase()}]`;
+            }
+            return char;
+        })
+        .join('');
+}
+
+function getCaseInsensitiveRegExp(patterns: string[]) {
+    return `(${patterns
+        .map((pattern) => caseInsensitiveRegExp(pattern).replace(/\s+/g, '\\s'))
+        .join('|')})`;
+}
+
+function oneWordPatterns(patterns: string[]) {
+    return patterns.filter((pattern) => /^\S*$/.test(pattern));
+}
+
+function manyWordsPatterns(patterns: string[]) {
+    return patterns.filter((pattern) => /\s/.test(pattern)).sort((a, b) => b.localeCompare(a));
+}

package/src/components/MonacoEditor/monaco-yql-languages/constants.ts

@@ -0,0 +1,6 @@
+export enum MonacoLanguage {
+    YQL = 'yql',
+    YTQL = 'yql_ansi',
+    CHYT = 'clickhouse',
+    SPYT = 's-expression',
+}

package/src/components/MonacoEditor/monaco-yql-languages/fillers/monaco-editor-core.ts

@@ -0,0 +1,3 @@
+// @ts-ignore monaco-editor ships its own types but the default resolution
+// doesn't pick them up for this deep import path in this project setup.
+export * from 'monaco-editor/editor/editor.api';

package/src/components/MonacoEditor/monaco-yql-languages/index.ts

@@ -0,0 +1 @@
+export {MonacoLanguage} from './constants';

package/src/components/MonacoEditor/monaco-yql-languages/monaco.contribution.ts

@@ -0,0 +1,5 @@
+import './clickhouse/clickhouse.contribution';
+import './yql/yql.contribution';
+import './yql_ansi/yql_ansi.contribution';
+import './s-expressions/s-expressions.contribution';
+import './themes/themes.contribution';

package/src/components/MonacoEditor/monaco-yql-languages/s-expressions/s-expressions.contribution.ts

@@ -0,0 +1,14 @@
+import {registerLanguage} from '../_.contribution';
+import {MonacoLanguage} from '../constants';
+
+registerLanguage({
+    id: MonacoLanguage.SPYT,
+    extensions: [],
+    loader: async () => {
+        const lang = await import('./s-expressions');
+        return {
+            conf: lang.conf,
+            language: lang.language,
+        };
+    },
+});

package/src/components/MonacoEditor/monaco-yql-languages/s-expressions/s-expressions.keywords.ts

@@ -0,0 +1,97 @@
+export const keywords = [
+    'ALL',
+    'AND',
+    'AS',
+    'ASC',
+    'BETWEEN',
+    'BY',
+    'CASE',
+    'CAST',
+    'CREATE',
+    'CROSS',
+    'DELETE',
+    'DESC',
+    'DISTINCT',
+    'DROP',
+    'ELSE',
+    'END',
+    'EXCEPT',
+    'EXISTS',
+    'FALSE',
+    'FROM',
+    'FULL',
+    'GROUP',
+    'HAVING',
+    'IF',
+    'IN',
+    'INNER',
+    'INSERT',
+    'INTERSECT',
+    'INTO',
+    'IS',
+    'JOIN',
+    'LEFT',
+    'LIKE',
+    'LIMIT',
+    'NOT',
+    'NULL',
+    'OFFSET',
+    'ON',
+    'OR',
+    'ORDER',
+    'OUTER',
+    'RIGHT',
+    'SELECT',
+    'SET',
+    'TABLE',
+    'THEN',
+    'TRUE',
+    'UNION',
+    'UPDATE',
+    'USING',
+    'VALUES',
+    'WHEN',
+    'WHERE',
+    'WITH',
+];
+
+export const operators = ['MOD', 'INCLUDE', 'EXCLUDE', 'ILIKE', 'RLIKE', 'PIVOT', 'UNPIVOT'];
+
+export const builtinFunctions = [
+    'AVG',
+    'COUNT',
+    'MAX',
+    'MIN',
+    'SUM',
+    'ABS',
+    'COALESCE',
+    'CONCAT',
+    'LENGTH',
+    'LOWER',
+    'UPPER',
+    'SUBSTRING',
+    'TRIM',
+    'CAST',
+    'IFNULL',
+    'NVL',
+];
+
+export const typeKeywords = [
+    'BOOLEAN',
+    'TINYINT',
+    'SMALLINT',
+    'INT',
+    'INTEGER',
+    'BIGINT',
+    'FLOAT',
+    'DOUBLE',
+    'DATE',
+    'TIMESTAMP',
+    'STRING',
+    'BINARY',
+    'ARRAY',
+    'MAP',
+    'STRUCT',
+];
+
+export const scopeKeywords = ['CASE', 'END', 'WHEN', 'THEN', 'ELSE'];

package/src/components/MonacoEditor/monaco-yql-languages/s-expressions/s-expressions.ts

@@ -0,0 +1,170 @@
+import {type languages} from '../fillers/monaco-editor-core';
+import {
+    builtinFunctions,
+    keywords,
+    operators,
+    scopeKeywords,
+    typeKeywords,
+} from './s-expressions.keywords';
+
+export const LANGUAGE_ID = 's-expression';
+
+const TokenClassConsts = {
+    BINARY: 'binary',
+    BINARY_ESCAPE: 'binary.escape',
+    COMMENT: 'comment',
+    COMMENT_QUOTE: 'comment.quote',
+    DELIMITER: 'delimiter',
+    IDENTIFIER: 'identifier',
+    KEYWORD: 'keyword',
+    KEYWORD_SCOPE: 'keyword.scope',
+    NUMBER: 'number',
+    NUMBER_FLOAT: 'number.float',
+    NUMBER_HEX: 'number.hex',
+    OPERATOR_KEYWORD: 'operator.keyword',
+    OPERATOR_SYMBOL: 'operator.symbol',
+    PREDEFINED: 'predefined',
+    STRING: 'string',
+    STRING_ESCAPE: 'string.escape',
+    TYPE: 'type',
+    VARIABLE: 'variable',
+    WHITE: 'white',
+};
+
+export const conf: languages.LanguageConfiguration = {
+    comments: {
+        lineComment: '#',
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+        {open: '"', close: '"'},
+        {open: "'", close: "'"},
+        {open: '`', close: '`'},
+    ],
+    surroundingPairs: [
+        {open: '{', close: '}'},
+        {open: '[', close: ']'},
+        {open: '(', close: ')'},
+        {open: '"', close: '"'},
+        {open: "'", close: "'"},
+        {open: '`', close: '`'},
+    ],
+};
+
+export const language: languages.IMonarchLanguage & Record<string, unknown> = {
+    defaultToken: 'text',
+    ignoreCase: true,
+    tokenPostfix: '.yql',
+
+    brackets: [
+        {open: '[', close: ']', token: 'delimiter.square'},
+        {open: '(', close: ')', token: 'delimiter.parenthesis'},
+        {open: '{', close: '}', token: 'delimiter.curly'},
+    ],
+
+    builtinFunctions,
+    builtinVariables: [],
+    keywords,
+    typeKeywords,
+    scopeKeywords,
+    operators,
+    pseudoColumns: [],
+
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+
+    tokenizer: {
+        root: [
+            {include: '@comments'},
+            {include: '@whitespace'},
+            {include: '@pseudoColumns'},
+            {include: '@numbers'},
+            {include: '@binaries'},
+            {include: '@strings'},
+            {include: '@scopes'},
+            {include: '@complexDataTypes'},
+            [/[;,.]/, TokenClassConsts.DELIMITER],
+            [/[(){}[\]]/, '@brackets'],
+            [/yt\.`(\/\/.*?)`/g, {token: 'path'}],
+            [
+                /[\w@#$]+/,
+                {
+                    cases: {
+                        '@scopeKeywords': TokenClassConsts.KEYWORD_SCOPE,
+                        '@operators': TokenClassConsts.OPERATOR_KEYWORD,
+                        '@typeKeywords': TokenClassConsts.TYPE,
+                        '@builtinVariables': TokenClassConsts.VARIABLE,
+                        '@builtinFunctions': TokenClassConsts.PREDEFINED,
+                        '@keywords': TokenClassConsts.KEYWORD,
+                        '@default': TokenClassConsts.IDENTIFIER,
+                    },
+                },
+            ],
+            [/[<>=!%&+\-*/|~^]/, TokenClassConsts.OPERATOR_SYMBOL],
+        ],
+        whitespace: [[/[\s\t\r\n]+/, TokenClassConsts.WHITE]],
+        comments: [
+            [/--+.*/, TokenClassConsts.COMMENT],
+            [/\/\*/, {token: TokenClassConsts.COMMENT_QUOTE, next: '@comment'}],
+        ],
+        comment: [
+            [/[^*/]+/, TokenClassConsts.COMMENT],
+            [/\*\//, {token: TokenClassConsts.COMMENT_QUOTE, next: '@pop'}],
+            [/./, TokenClassConsts.COMMENT],
+        ],
+        pseudoColumns: [
+            [
+                /[$][A-Za-z_][\w@#$]*/,
+                {
+                    cases: {
+                        '@pseudoColumns': TokenClassConsts.PREDEFINED,
+                        '@default': TokenClassConsts.IDENTIFIER,
+                    },
+                },
+            ],
+        ],
+        numbers: [
+            [/0[xX][0-9a-fA-F]*/, TokenClassConsts.NUMBER_HEX],
+            [/[$][+-]*\d*(\.\d*)?/, TokenClassConsts.NUMBER],
+            [/((\d+(\.\d*)?)|(\.\d+))([eE][-+]?\d+)?/, TokenClassConsts.NUMBER_FLOAT],
+        ],
+        binaries: [
+            [/X'/i, {token: TokenClassConsts.BINARY, next: '@binarySingle'}],
+            [/X"/i, {token: TokenClassConsts.BINARY, next: '@binaryDouble'}],
+        ],
+        binarySingle: [
+            [/\d+/, TokenClassConsts.BINARY_ESCAPE],
+            [/''/, TokenClassConsts.BINARY],
+            [/'/, {token: TokenClassConsts.BINARY, next: '@pop'}],
+        ],
+        binaryDouble: [
+            [/\d+/, TokenClassConsts.BINARY_ESCAPE],
+            [/""/, TokenClassConsts.BINARY],
+            [/"/, {token: TokenClassConsts.BINARY, next: '@pop'}],
+        ],
+        strings: [
+            [/'/, {token: TokenClassConsts.STRING, next: '@stringSingle'}],
+            [/R'/i, {token: TokenClassConsts.STRING, next: '@stringSingle'}],
+            [/"/, {token: TokenClassConsts.STRING, next: '@stringDouble'}],
+            [/R"/i, {token: TokenClassConsts.STRING, next: '@stringDouble'}],
+        ],
+        stringSingle: [
+            [/[^']+/, TokenClassConsts.STRING_ESCAPE],
+            [/''/, TokenClassConsts.STRING],
+            [/'/, {token: TokenClassConsts.STRING, next: '@pop'}],
+        ],
+        stringDouble: [
+            [/[^"]+/, TokenClassConsts.STRING_ESCAPE],
+            [/""/, TokenClassConsts.STRING],
+            [/"/, {token: TokenClassConsts.STRING, next: '@pop'}],
+        ],
+        scopes: [],
+        complexDataTypes: [],
+    },
+};

package/src/components/MonacoEditor/monaco-yql-languages/themes/themes.contribution.ts

@@ -0,0 +1,35 @@
+import * as monaco from '../fillers/monaco-editor-core';
+
+monaco.editor.defineTheme('vs', {
+    base: 'vs',
+    inherit: true,
+    rules: [
+        {token: 'string.tablepath', foreground: '338186'},
+        {token: 'constant.yql', foreground: '608b4e'},
+        {token: 'keyword.type', foreground: '4d932d'},
+        {token: 'string.sql', foreground: 'a31515'},
+        {token: 'support.function', foreground: '7a3e9d'},
+        {token: 'constant.other.color', foreground: '7a3e9d'},
+        {token: 'comment', foreground: '969896'},
+    ],
+    colors: {
+        'editor.lineHighlightBackground': '#EFEFEF',
+    },
+});
+
+monaco.editor.defineTheme('vs-dark', {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+        {token: 'string.tablepath', foreground: '338186'},
+        {token: 'constant.yql', foreground: '608b4e'},
+        {token: 'storage.type', foreground: '6A8759'},
+        {token: 'string.sql', foreground: 'ce9178'},
+        {token: 'support.function', foreground: '9e7bb0'},
+        {token: 'constant.other.color', foreground: '9e7bb0'},
+        {token: 'comment', foreground: '969896'},
+    ],
+    colors: {
+        'editor.lineHighlightBackground': '#282A2E',
+    },
+});

package/src/components/MonacoEditor/monaco-yql-languages/yql/yql.contribution.ts

@@ -0,0 +1,14 @@
+import {registerLanguage} from '../_.contribution';
+import {MonacoLanguage} from '../constants';
+
+registerLanguage({
+    id: MonacoLanguage.YQL,
+    extensions: [],
+    loader: async () => {
+        const lang = await import('./yql');
+        return {
+            conf: lang.conf,
+            language: lang.language,
+        };
+    },
+});

package/src/components/MonacoEditor/monaco-yql-languages/yql/yql.keywords.ts

@@ -0,0 +1,13 @@
+export const keywords =
+    'intersect|except|$row|$rows|action|all|and|any|as|asc|assume|begin|bernoulli|between|by|case|columns|commit|compact|create|cross|cube|declare|define|delete|desc|dict|discard|distinct|do|drop|else|empty_action|end|erase|evaluate|exclusion|exists|export|flatten|for|from|full|group|grouping|having|if|ignore|ilike|import|in|inner|insert|into|is|join|left|like|limit|list|match|not|null|nulls|offset|on|only|optional|or|order|over|partition|pragma|presort|process|reduce|regexp|repeatable|replace|respect|result|return|right|rlike|rollup|sample|schema|select|semi|set|sets|stream|subquery|table|tablesample|then|truncate|union|update|upsert|use|using|values|view|when|where|window|with|without|xor'.split(
+        '|',
+    );
+export const typeKeywords =
+    'bool|date|datetime|decimal|double|float|int16|int32|int64|int8|interval|json|string|timestamp|tzdate|tzdatetime|tztimestamp|uint16|uint32|uint64|uint8|utf8|uuid|yson'.split(
+        '|',
+    );
+
+export const builtinFunctions =
+    'abs|aggregate_by|aggregate_list|aggregate_list_distinct|agg_list|agg_list_distinct|as_table|avg|avg_if|adaptivedistancehistogram|adaptivewardhistogram|adaptiveweighthistogram|addmember|addtimezone|aggregateflatten|aggregatetransforminput|aggregatetransformoutput|aggregationfactory|asatom|asdict|asdictstrict|asenum|aslist|asliststrict|asset|assetstrict|asstruct|astagged|astuple|asvariant|atomcode|bitcast|bit_and|bit_or|bit_xor|bool_and|bool_or|bool_xor|bottom|bottom_by|blockwardhistogram|blockweighthistogram|cast|coalesce|concat|concat_strict|correlation|count|count_if|covariance|covariance_population|covariance_sample|callableargument|callableargumenttype|callableresulttype|callabletype|callabletypecomponents|callabletypehandle|choosemembers|combinemembers|countdistinctestimate|currentauthenticateduser|currentoperationid|currentoperationsharedid|currenttzdate|currenttzdatetime|currenttztimestamp|currentutcdate|currentutcdatetime|currentutctimestamp|dense_rank|datatype|datatypecomponents|datatypehandle|dictaggregate|dictcontains|dictcreate|dicthasitems|dictitems|dictkeytype|dictkeys|dictlength|dictlookup|dictpayloadtype|dictpayloads|dicttype|dicttypecomponents|dicttypehandle|each|each_strict|emptydicttype|emptydicttypehandle|emptylisttype|emptylisttypehandle|endswith|ensure|ensureconvertibleto|ensuretype|enum|evaluateatom|evaluatecode|evaluateexpr|evaluatetype|expandstruct|filter|filter_strict|find|first_value|folder|filecontent|filepath|flattenmembers|forceremovemember|forceremovemembers|forcerenamemembers|forcespreadmembers|formatcode|formattype|frombytes|funccode|greatest|grouping|gathermembers|generictype|histogram|hll|hyperloglog|if|if_strict|instanceof|json_exists|json_query|json_value|jointablerow|just|lag|last_value|lead|least|len|length|like|likely|like_strict|lambdaargumentscount|lambdacode|linearhistogram|listaggregate|listall|listany|listavg|listcode|listcollect|listconcat|listcreate|listdistinct|listenumerate|listextend|listextendstrict|listextract|listfilter|listflatmap|listflatten|listfromrange|listhas|listhasitems|listhead|listindexof|listitemtype|listlast|listlength|listmap|listmax|listmin|listnotnull|listreplicate|listreverse|listskip|listskipwhile|listskipwhileinclusive|listsort|listsortasc|listsortdesc|listsum|listtake|listtakewhile|listtakewhileinclusive|listtype|listtypehandle|listunionall|listuniq|listzip|listzipall|loghistogram|logarithmichistogram|max|max_by|max_of|median|min|min_by|min_of|mode|multi_aggregate_by|nanvl|nvl|nothing|nulltype|nulltypehandle|optionalitemtype|optionaltype|optionaltypehandle|percentile|parsefile|parsetype|parsetypehandle|pickle|quotecode|range|range_strict|rank|regexp|regexp_strict|rfind|row_number|random|randomnumber|randomuuid|removemember|removemembers|removetimezone|renamemembers|replacemember|reprcode|resourcetype|resourcetypehandle|resourcetypetag|some|stddev|stddev_population|stddev_sample|substring|sum|sum_if|sessionstart|sessionwindow|setcreate|setdifference|setincludes|setintersection|setisdisjoint|setsymmetricdifference|setunion|spreadmembers|stablepickle|startswith|staticmap|streamitemtype|streamtype|streamtypehandle|structmembertype|structmembers|structtypecomponents|structtypehandle|subqueryextend|subqueryextendfor|subquerymerge|subquerymergefor|subqueryunionall|subqueryunionallfor|subqueryunionmerge|subqueryunionmergefor|top|topfreq|top_by|tablename|tablepath|tablerecordindex|tablerow|taggedtype|taggedtypecomponents|taggedtypehandle|tobytes|todict|tomultidict|toset|tosorteddict|tosortedmultidict|trymember|tupleelementtype|tupletype|tupletypecomponents|tupletypehandle|typehandle|typekind|typeof|udaf|unittype|unpickle|untag|unwrap|variance|variance_population|variance_sample|variant|varianttype|varianttypehandle|variantunderlyingtype|voidtype|voidtypehandle|way|worldcode'.split(
+        '|',
+    );