|
|
@@ -0,0 +1,566 @@
|
|
|
+// Licensed to Cloudera, Inc. under one
|
|
|
+// or more contributor license agreements. See the NOTICE file
|
|
|
+// distributed with this work for additional information
|
|
|
+// regarding copyright ownership. Cloudera, Inc. licenses this file
|
|
|
+// to you under the Apache License, Version 2.0 (the
|
|
|
+// "License"); you may not use this file except in compliance
|
|
|
+// with the License. You may obtain a copy of the License at
|
|
|
+//
|
|
|
+// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
+//
|
|
|
+// Unless required by applicable law or agreed to in writing, software
|
|
|
+// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
+// See the License for the specific language governing permissions and
|
|
|
+// limitations under the License.
|
|
|
+
|
|
|
+import { UdfCategory, UdfCategoryFunctions } from 'sql/reference/types';
|
|
|
+import I18n from 'utils/i18n';
|
|
|
+
|
|
|
+const EVAL_FUNCTIONS: UdfCategoryFunctions = {
|
|
|
+ avg: {
|
|
|
+ name: 'avg',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'AVG(%VAR%)',
|
|
|
+ draggable: 'AVG()'
|
|
|
+ },
|
|
|
+ concat: {
|
|
|
+ name: 'concat',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'CONCAT(%VAR1%, %VAR2%)',
|
|
|
+ draggable: 'CONCAT()'
|
|
|
+ },
|
|
|
+ count: {
|
|
|
+ name: 'count',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'COUNT(%VAR%)',
|
|
|
+ draggable: 'COUNT()'
|
|
|
+ },
|
|
|
+ count_start: {
|
|
|
+ name: 'count_start',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'COUNT_START(%VAR%)',
|
|
|
+ draggable: 'COUNT_START()'
|
|
|
+ },
|
|
|
+ is_empty: {
|
|
|
+ name: 'is_empty',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'IsEmpty(%VAR%)',
|
|
|
+ draggable: 'IsEmpty()'
|
|
|
+ },
|
|
|
+ diff: {
|
|
|
+ name: 'diff',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'DIFF(%VAR1%, %VAR2%)',
|
|
|
+ draggable: 'DIFF()'
|
|
|
+ },
|
|
|
+ max: {
|
|
|
+ name: 'max',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'MAX(%VAR%)',
|
|
|
+ draggable: 'MAX()'
|
|
|
+ },
|
|
|
+ min: {
|
|
|
+ name: 'min',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'MIN(%VAR%)',
|
|
|
+ draggable: 'MIN()'
|
|
|
+ },
|
|
|
+ size: {
|
|
|
+ name: 'size',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SIZE(%VAR%)',
|
|
|
+ draggable: 'SIZE()'
|
|
|
+ },
|
|
|
+ sum: {
|
|
|
+ name: 'sum',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SUM(%VAR%)',
|
|
|
+ draggable: 'SUM()'
|
|
|
+ },
|
|
|
+ tokenize: {
|
|
|
+ name: 'tokenize',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TOKENIZE(%VAR%, %DELIM%)',
|
|
|
+ draggable: 'TOKENIZE()'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const RELATIONAL_OPERATORS: UdfCategoryFunctions = {
|
|
|
+ cogroup: {
|
|
|
+ name: 'cogroup',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'COGROUP %VAR% BY %VAR%',
|
|
|
+ draggable: 'COGROUP %VAR% BY %VAR%'
|
|
|
+ },
|
|
|
+ cross: {
|
|
|
+ name: 'cross',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'CROSS %VAR1%, %VAR2%;',
|
|
|
+ draggable: 'CROSS %VAR1%, %VAR2%;'
|
|
|
+ },
|
|
|
+ distinct: {
|
|
|
+ name: 'distinct',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'DISTINCT %VAR%;',
|
|
|
+ draggable: 'DISTINCT %VAR%;'
|
|
|
+ },
|
|
|
+ filter: {
|
|
|
+ name: 'filter',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'FILTER %VAR% BY %COND%',
|
|
|
+ draggable: 'FILTER %VAR% BY %COND%'
|
|
|
+ },
|
|
|
+ flatten: {
|
|
|
+ name: 'flatten',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'FLATTEN(%VAR%)',
|
|
|
+ draggable: 'FLATTEN()'
|
|
|
+ },
|
|
|
+ foreach_generate: {
|
|
|
+ name: 'foreach_generate',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'FOREACH %DATA% GENERATE %NEW_DATA%;',
|
|
|
+ draggable: 'FOREACH %DATA% GENERATE %NEW_DATA%;'
|
|
|
+ },
|
|
|
+ foreach: {
|
|
|
+ name: 'foreach',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'FOREACH %DATA% {%NESTED_BLOCK%};',
|
|
|
+ draggable: 'FOREACH %DATA% {%NESTED_BLOCK%};'
|
|
|
+ },
|
|
|
+ group_by: {
|
|
|
+ name: 'group_by',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'GROUP %VAR% BY %VAR%',
|
|
|
+ draggable: 'GROUP %VAR% BY %VAR%'
|
|
|
+ },
|
|
|
+ group_all: {
|
|
|
+ name: 'group_all',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'GROUP %VAR% ALL',
|
|
|
+ draggable: 'GROUP %VAR% ALL'
|
|
|
+ },
|
|
|
+ join: {
|
|
|
+ name: 'join',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'JOIN %VAR% BY ',
|
|
|
+ draggable: 'JOIN %VAR% BY '
|
|
|
+ },
|
|
|
+ limit: {
|
|
|
+ name: 'limit',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'LIMIT %VAR% %N%',
|
|
|
+ draggable: 'LIMIT %VAR% %N%'
|
|
|
+ },
|
|
|
+ order: {
|
|
|
+ name: 'order',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ORDER %VAR% BY %FIELD%',
|
|
|
+ draggable: 'ORDER %VAR% BY %FIELD%'
|
|
|
+ },
|
|
|
+ sample: {
|
|
|
+ name: 'sample',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SAMPLE %VAR% %SIZE%',
|
|
|
+ draggable: 'SAMPLE %VAR% %SIZE%'
|
|
|
+ },
|
|
|
+ split: {
|
|
|
+ name: 'split',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SPLIT %VAR1% INTO %VAR2% IF %EXPRESSIONS%',
|
|
|
+ draggable: 'SPLIT %VAR1% INTO %VAR2% IF %EXPRESSIONS%'
|
|
|
+ },
|
|
|
+ union: {
|
|
|
+ name: 'union',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'UNION %VAR1%, %VAR2%',
|
|
|
+ draggable: 'UNION %VAR1%, %VAR2%'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const INPUT_OUTPUT: UdfCategoryFunctions = {
|
|
|
+ load: {
|
|
|
+ name: 'load',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "LOAD '%FILE%';",
|
|
|
+ draggable: "LOAD '%FILE%';"
|
|
|
+ },
|
|
|
+ dump: {
|
|
|
+ name: 'dump',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'DUMP %VAR%;',
|
|
|
+ draggable: 'DUMP %VAR%;'
|
|
|
+ },
|
|
|
+ store: {
|
|
|
+ name: 'store',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'STORE %VAR% INTO %PATH%;',
|
|
|
+ draggable: 'STORE %VAR% INTO %PATH%;'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const DEBUG: UdfCategoryFunctions = {
|
|
|
+ explain: {
|
|
|
+ name: 'explain',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'EXPLAIN %VAR%;',
|
|
|
+ draggable: 'EXPLAIN %VAR%;'
|
|
|
+ },
|
|
|
+ illustrate: {
|
|
|
+ name: 'illustrate',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ILLUSTRATE %VAR%;',
|
|
|
+ draggable: 'ILLUSTRATE %VAR%;'
|
|
|
+ },
|
|
|
+ describe: {
|
|
|
+ name: 'describe',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'DESCRIBE %VAR%;',
|
|
|
+ draggable: 'DESCRIBE %VAR%;'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const HCATALOG: UdfCategoryFunctions = {
|
|
|
+ LOAD: {
|
|
|
+ name: 'LOAD',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "LOAD '%TABLE%' USING org.apache.hcatalog.pig.HCatLoader();",
|
|
|
+ draggable: "LOAD '%TABLE%' USING org.apache.hcatalog.pig.HCatLoader();"
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const MATH_FUNCTIONS: UdfCategoryFunctions = {
|
|
|
+ abs: {
|
|
|
+ name: 'abs',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ABS(%VAR%)',
|
|
|
+ draggable: 'ABS()'
|
|
|
+ },
|
|
|
+ acos: {
|
|
|
+ name: 'acos',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ACOS(%VAR%)',
|
|
|
+ draggable: 'ACOS()'
|
|
|
+ },
|
|
|
+ asin: {
|
|
|
+ name: 'asin',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ASIN(%VAR%)',
|
|
|
+ draggable: 'ASIN()'
|
|
|
+ },
|
|
|
+ atan: {
|
|
|
+ name: 'atan',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ATAN(%VAR%)',
|
|
|
+ draggable: 'ATAN()'
|
|
|
+ },
|
|
|
+ cbrt: {
|
|
|
+ name: 'cbrt',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'CBRT(%VAR%)',
|
|
|
+ draggable: 'CBRT()'
|
|
|
+ },
|
|
|
+ ceil: {
|
|
|
+ name: 'ceil',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'CEIL(%VAR%)',
|
|
|
+ draggable: 'CEIL()'
|
|
|
+ },
|
|
|
+ cos: {
|
|
|
+ name: 'cos',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'COS(%VAR%)',
|
|
|
+ draggable: 'COS()'
|
|
|
+ },
|
|
|
+ cosh: {
|
|
|
+ name: 'cosh',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'COSH(%VAR%)',
|
|
|
+ draggable: 'COSH()'
|
|
|
+ },
|
|
|
+ exp: {
|
|
|
+ name: 'exp',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'EXP(%VAR%)',
|
|
|
+ draggable: 'EXP()'
|
|
|
+ },
|
|
|
+ floor: {
|
|
|
+ name: 'floor',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'FLOOR(%VAR%)',
|
|
|
+ draggable: 'FLOOR()'
|
|
|
+ },
|
|
|
+ log: {
|
|
|
+ name: 'log',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'LOG(%VAR%)',
|
|
|
+ draggable: 'LOG()'
|
|
|
+ },
|
|
|
+ log10: {
|
|
|
+ name: 'log10',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'LOG10(%VAR%)',
|
|
|
+ draggable: 'LOG10()'
|
|
|
+ },
|
|
|
+ random: {
|
|
|
+ name: 'random',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'RANDOM(%VAR%)',
|
|
|
+ draggable: 'RANDOM()'
|
|
|
+ },
|
|
|
+ round: {
|
|
|
+ name: 'round',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'ROUND(%VAR%)',
|
|
|
+ draggable: 'ROUND()'
|
|
|
+ },
|
|
|
+ sin: {
|
|
|
+ name: 'sin',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SIN(%VAR%)',
|
|
|
+ draggable: 'SIN()'
|
|
|
+ },
|
|
|
+ sinh: {
|
|
|
+ name: 'sinh',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SINH(%VAR%)',
|
|
|
+ draggable: 'SINH()'
|
|
|
+ },
|
|
|
+ sqrt: {
|
|
|
+ name: 'sqrt',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SQRT(%VAR%)',
|
|
|
+ draggable: 'SQRT()'
|
|
|
+ },
|
|
|
+ tan: {
|
|
|
+ name: 'tan',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TAN(%VAR%)',
|
|
|
+ draggable: 'TAN()'
|
|
|
+ },
|
|
|
+ tanh: {
|
|
|
+ name: 'tanh',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TANH(%VAR%)',
|
|
|
+ draggable: 'TANH()'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const TUPLE_BAG_MAP: UdfCategoryFunctions = {
|
|
|
+ totuple: {
|
|
|
+ name: 'totuple',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TOTUPLE(%VAR%)',
|
|
|
+ draggable: 'TOTUPLE()'
|
|
|
+ },
|
|
|
+ tobag: {
|
|
|
+ name: 'tobag',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TOBAG(%VAR%)',
|
|
|
+ draggable: 'TOBAG()'
|
|
|
+ },
|
|
|
+ tomap: {
|
|
|
+ name: 'tomap',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TOMAP(%KEY%, %VALUE%)',
|
|
|
+ draggable: 'TOMAP()'
|
|
|
+ },
|
|
|
+ top: {
|
|
|
+ name: 'top',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TOP(%topN%, %COLUMN%, %RELATION%)',
|
|
|
+ draggable: 'TOP()'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const STRING_FUNCTIONS: UdfCategoryFunctions = {
|
|
|
+ indexof: {
|
|
|
+ name: 'indexof',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "INDEXOF(%STRING%, '%CHARACTER%', %STARTINDEX%)",
|
|
|
+ draggable: 'INDEXOF()'
|
|
|
+ },
|
|
|
+ last_index_of: {
|
|
|
+ name: 'last_index_of',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "LAST_INDEX_OF(%STRING%, '%CHARACTER%', %STARTINDEX%)",
|
|
|
+ draggable: 'LAST_INDEX_OF()'
|
|
|
+ },
|
|
|
+ lower: {
|
|
|
+ name: 'lower',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'LOWER(%STRING%)',
|
|
|
+ draggable: 'LOWER()'
|
|
|
+ },
|
|
|
+ regex_extract: {
|
|
|
+ name: 'regex_extract',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'REGEX_EXTRACT(%STRING%, %REGEX%, %INDEX%)',
|
|
|
+ draggable: 'REGEX_EXTRACT()'
|
|
|
+ },
|
|
|
+ regex_extract_all: {
|
|
|
+ name: 'regex_extract_all',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'REGEX_EXTRACT_ALL(%STRING%, %REGEX%)',
|
|
|
+ draggable: 'REGEX_EXTRACT_ALL()'
|
|
|
+ },
|
|
|
+ replace: {
|
|
|
+ name: 'replace',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "REPLACE(%STRING%, '%oldChar%', '%newChar%')",
|
|
|
+ draggable: 'REPLACE()'
|
|
|
+ },
|
|
|
+ strsplit: {
|
|
|
+ name: 'strsplit',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'STRSPLIT(%STRING%, %REGEX%, %LIMIT%)',
|
|
|
+ draggable: 'STRSPLIT()'
|
|
|
+ },
|
|
|
+ substring: {
|
|
|
+ name: 'substring',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'SUBSTRING(%STRING%, %STARTINDEX%, %STOPINDEX%)',
|
|
|
+ draggable: 'SUBSTRING()'
|
|
|
+ },
|
|
|
+ trim: {
|
|
|
+ name: 'trim',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'TRIM(%STRING%)',
|
|
|
+ draggable: 'TRIM()'
|
|
|
+ },
|
|
|
+ ucfirst: {
|
|
|
+ name: 'ucfirst',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'UCFIRST(%STRING%)',
|
|
|
+ draggable: 'UCFIRST()'
|
|
|
+ },
|
|
|
+ upper: {
|
|
|
+ name: 'upper',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: 'UPPER(%STRING%)',
|
|
|
+ draggable: 'UPPER()'
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const MACROS: UdfCategoryFunctions = {
|
|
|
+ import: {
|
|
|
+ name: 'import',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "IMPORT '%PATH_TO_MACRO%';",
|
|
|
+ draggable: "IMPORT '%PATH_TO_MACRO%';"
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const HBASE: UdfCategoryFunctions = {
|
|
|
+ load: {
|
|
|
+ name: 'load',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature:
|
|
|
+ "LOAD 'hbase://%TABLE%' USING org.apache.pig.backend.hadoop.hbase.HBaseStorage('%columnList%')",
|
|
|
+ draggable:
|
|
|
+ "LOAD 'hbase://%TABLE%' USING org.apache.pig.backend.hadoop.hbase.HBaseStorage('%columnList%')"
|
|
|
+ },
|
|
|
+ store: {
|
|
|
+ name: 'store',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature:
|
|
|
+ "STORE %VAR% INTO 'hbase://%TABLE%' USING org.apache.pig.backend.hadoop.hbase.HBaseStorage('%columnList%')",
|
|
|
+ draggable:
|
|
|
+ "STORE %VAR% INTO 'hbase://%TABLE%' USING org.apache.pig.backend.hadoop.hbase.HBaseStorage('%columnList%')"
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+const PYTHON_UDF: UdfCategoryFunctions = {
|
|
|
+ register: {
|
|
|
+ name: 'register',
|
|
|
+ returnTypes: ['T'],
|
|
|
+ arguments: [[{ type: 'T', multiple: true }]],
|
|
|
+ signature: "REGISTER 'python_udf.py' USING jython AS myfuncs;",
|
|
|
+ draggable: "REGISTER 'python_udf.py' USING jython AS myfuncs;"
|
|
|
+ }
|
|
|
+};
|
|
|
+
|
|
|
+export const UDF_CATEGORIES: UdfCategory[] = [
|
|
|
+ { name: I18n('Eval'), functions: EVAL_FUNCTIONS },
|
|
|
+ { name: I18n('Relational Operators'), functions: RELATIONAL_OPERATORS },
|
|
|
+ { name: I18n('Input and Output'), functions: INPUT_OUTPUT },
|
|
|
+ { name: I18n('Debug'), functions: DEBUG },
|
|
|
+ { name: I18n('HCatalog'), functions: HCATALOG },
|
|
|
+ { name: I18n('Math'), functions: MATH_FUNCTIONS },
|
|
|
+ { name: I18n('Tuple, Bag and Map'), functions: TUPLE_BAG_MAP },
|
|
|
+ { name: I18n('String'), functions: STRING_FUNCTIONS },
|
|
|
+ { name: I18n('Macros'), functions: MACROS },
|
|
|
+ { name: I18n('HBase'), functions: HBASE },
|
|
|
+ { name: I18n('Python UDF'), functions: PYTHON_UDF }
|
|
|
+];
|