teradataml 20.0.0.8__py3-none-any.whl

teradataml/data/jsons/sqle/17.10/Unpack.json

@@ -0,0 +1,188 @@
+{
+  "json_schema_major_version": "1",
+  "json_schema_minor_version": "1",
+  "json_content_version": "1",
+  "function_name": "Unpack",
+  "function_version": "1.0",
+  "function_alias_name": "Unpack",
+  "function_type": "fastpath",
+  "function_category" : "Data Cleaning",
+  "function_r_name": "aa.unpack",
+  "short_description": "Utility for unpacking data that has been put into a single column.",
+  "long_description": "Takes a single column with packed data and transforms it into a table with multiple columns, as specified by the user's parameters.",
+  "input_tables": [
+    {
+      "requiredInputKind": [
+        "PartitionByAny"
+      ],
+      "isOrdered": false,
+      "partitionByOne": false,
+      "name": "input",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "The table containing the input attributes.",
+      "description": "The table containing the input attributes.",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data",
+      "useInR": true,
+      "rOrderNum": 1
+    }
+  ],
+  "argument_clauses": [
+    {
+      "targetTable": [
+        "input"
+      ],
+      "checkDuplicate": true,
+      "allowedTypes": [],
+      "allowedTypeGroups": [
+        "STRING"
+      ],
+      "requiredLength": 1,
+      "matchLengthOfArgument": "",
+      "allowPadding": false,
+      "name": "TargetColumn",
+      "alternateNames": ["InputColumn"],
+      "isRequired": true,
+      "rDescription": " Specifies the name of the input column that contains the packed data.",
+      "description": " Specifies the name of the input column that contains the packed data.",
+      "datatype": "COLUMNS",
+      "allowsLists": false,
+      "rName": "input.column",
+      "useInR": true,
+      "rOrderNum": 2
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": true,
+      "matchLengthOfArgument": "",
+      "allowPadding": false,
+      "name": "OutputColumns",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "Specifies the names to give to the output columns, in the order in which the corresponding virtual columns appear in input_column.If you specify fewer output column names than there are virtual input columns, the function ignores the extra virtual input columns. That is, if the packed data contains x+y virtual columns and the OutputColumns argument specifies x output column names, the function assigns the names to the first x virtual columns and ignores the remaining y virtual columns. ",
+      "description": "Specifies the names to give to the output columns, in the order in which the corresponding virtual columns appear in input_column.If you specify fewer output column names than there are virtual input columns, the function ignores the extra virtual input columns. That is, if the packed data contains x+y virtual columns and the OutputColumns argument specifies x output column names, the function assigns the names to the first x virtual columns and ignores the remaining y virtual columns.",
+      "datatype": "STRING",
+      "allowsLists": true,
+      "rName": "output.columns",
+      "useInR": true,
+      "rOrderNum": 3
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": false,
+      "matchLengthOfArgument": "OutputColumns",
+      "allowPadding": false,
+      "name": "OutputDataTypes",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "Specifies the datatypes of the unpacked output columns.Supported output.datatypes are VARCHAR, INTEGER, DOUBLE PRECISION, TIME, DATE, and TIMESTAMP.If output.datatypes specifies only one value and output.columns specifies multiple columns, then the specified value applies to every output_column. If output.datatypes specifies multiple values, then it must specify a value for each output_column. The nth datatype corresponds to the nth output_column.The function can output only 16 VARCHAR columns.",
+      "description": "Specifies the datatypes of the unpacked output columns.Supported OutputDataTypes are VARCHAR, INTEGER, DOUBLE PRECISION, TIME, DATE, and TIMESTAMP.If OutputDataTypes specifies only one value and OutputColumns specifies multiple columns, then the specified value applies to every output_column. If OutputDataTypes specifies multiple values, then it must specify a value for each output_column. The nth datatype corresponds to the nth output_column.The function can output only 16 VARCHAR columns.",
+      "datatype": "STRING",
+      "allowsLists": true,
+      "rName": "output.datatypes",
+      "useInR": true,
+      "rOrderNum": 4
+    },
+    {
+      "permittedValues": [],
+      "defaultValue": ",",
+      "isOutputColumn": false,
+      "name": "Delimiter",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": " Specifies the delimiter (a string) that separates the virtual columns in the packed data.The default delimiter is comma (,). If the virtual columns are separated by a delimiter, then specify the delimiter with this argument; otherwise, specify the column.length argument. Do not specify both this argument and the column.length argument.",
+      "description": "Specifies the delimiter (a string) that separates the virtual columns in the packed data.The default delimiter is comma (,). If the virtual columns are separated by a delimiter, then specify the delimiter with this argument; otherwise, specify the ColumnLength argument. Do not specify both this argument and the ColumnLength argument.",
+      "datatype": "STRING",
+      "allowsLists": false,
+      "rName": "delimiter",
+      "useInR": true,
+      "rOrderNum": 5
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": false,
+      "matchLengthOfArgument": "OutputColumns",
+      "allowPadding": false,
+      "name": "ColumnLength",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Specifies the lengths of the virtual columns; therefore, to use this argument, you must know the length of each virtual column. If column.length specifies only one value and output.columns specifies multiple columns, then the specified value applies to every output_column. If column.length specifies multiple values, then it must specify a value for each output_column. The nth datatype corresponds to the nth output_column. However, the last column_name can be an asterisk (*), which represents a single virtual column that contains the remaining data. For example, if the first three virtual columns have the lengths 2, 1, and 3, and all remaining data belongs to the fourth virtual column, you can specify column.length ('2', '1', '3', *). If you specify this argument, you must omit the delimiter argument.",
+      "description": "Specifies the lengths of the virtual columns; therefore, to use this argument, you must know the length of each virtual column. If ColumnLength specifies only one value and OutputColumns specifies multiple columns, then the specified value applies to every output_column. If ColumnLength specifies multiple values, then it must specify a value for each output_column. The nth datatype corresponds to the nth output_column. However, the last column_name can be an asterisk (*), which represents a single virtual column that contains the remaining data. For example, if the first three virtual columns have the lengths 2, 1, and 3, and all remaining data belongs to the fourth virtual column, you can specify ColumnLength ('2', '1', '3', *). If you specify this argument, you must omit the Delimiter argument.",
+      "datatype": "STRING",
+      "allowsLists": true,
+      "rName": "column.length",
+      "useInR": true,
+      "rOrderNum": 6
+    },
+    {
+      "permittedValues": [],
+      "defaultValue": "(.*)",
+      "isOutputColumn": false,
+      "name": "Regex",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Specifies a regular expression that describes a row of packed data, enabling the function to find the data values. A row of packed data contains one data value for each virtual column, but the row might also contain other information (such as the virtual column name). In the regular_expression, each data value is enclosed in parentheses. For example, suppose that the packed data has two virtual columns, age and sex, and that one row of packed data is: age:34,sex:male The regular_expression that describes the row is '.*:(.*)'. The '.*:' matches the virtual column names, age and sex, and the '(.*)' matches the values, 34 and male. The default regular_expression is '(.*)' which matches the whole string (between delimiters, if any). When applied to the preceding sample row, the default regular_expression causes the function to return 'age:34' and 'sex:male' as data values. To represent multiple data groups in regular_expression, use multiple pairs of parentheses. By default, the last data group in regular_expression represents the data value (other data groups are assumed to be virtual column names or unwanted data). If a different data group represents the data value, specify its group number with the regex.set argument.",
+      "description": "Specifies a regular expression that describes a row of packed data, enabling the function to find the data values. A row of packed data contains one data value for each virtual column, but the row might also contain other information (such as the virtual column name). In the regular_expression, each data value is enclosed in parentheses. For example, suppose that the packed data has two virtual columns, age and sex, and that one row of packed data is: age:34,sex:male The regular_expression that describes the row is '.*:(.*)'. The '.*:' matches the virtual column names, age and sex, and the '(.*)' matches the values, 34 and male. The default regular_expression is '(.*)' which matches the whole string (between delimiters, if any). When applied to the preceding sample row, the default regular_expression causes the function to return 'age:34' and 'sex:male' as data values. To represent multiple data groups in regular_expression, use multiple pairs of parentheses. Bydefault, the last data group in regular_expression represents the data value (other data groups are assumed to be virtual column names or unwanted data). If a different data group represents the data value, specify its group number with the RegexSet argument.",
+      "datatype": "STRING",
+      "allowsLists": false,
+      "rName": "regex",
+      "useInR": true,
+      "rOrderNum": 7
+    },
+    {
+      "defaultValue": 1,
+      "lowerBound": 0,
+      "upperBound": 30,
+      "lowerBoundType": "INCLUSIVE",
+      "upperBoundType": "INCLUSIVE",
+      "allowNaN": false,
+      "name": "RegexSet",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Specifies the ordinal number of the data group in regular_expression that represents the data value in a virtual column. By default, the last data group in regular_expression represents the data value. For example, suppose that regular_expression is: '([a-zA-Z]*):(.*)' If group_number is '1', then '([a-zA-Z]*)' represents the data value. If group_number is '2', then '(.*)' represents the data value.",
+      "description": "Specifies the ordinal number of the data group in regular_expression that represents the data value in a virtual column. By default, the last data group in regular_expression represents the data value. For example, suppose that regular_expression is: '([a-zA-Z]*):(.*)' If group_number is '1', then '([a-zA-Z]*)' represents the data value. If group_number is '2', then '(.*)' represents the data value.",
+      "datatype": "INTEGER",
+      "allowsLists": false,
+      "rName": "regex.set",
+      "useInR": true,
+      "rOrderNum": 8
+    },
+    {
+      "defaultValue": false,
+      "name": "IgnoreInvalid",
+      "alternateNames": ["Exception"],
+      "isRequired": false,
+      "rDescription": "Specifies whether the function ignores rows that contain invalid data; that is, continues without outputting them. The default value is 'false', which causes the function to fail if it encounters a row with invalid data.",
+      "description": "Specifies whether the function ignores rows that contain invalid data; that is, continues without outputting them. The default value is 'false', which causes the function to fail if it encounters a row with invalid data.",
+      "datatype": "BOOLEAN",
+      "allowsLists": false,
+      "rName": "exception",
+      "useInR": true,
+      "rOrderNum": 9
+    },
+    {
+      "targetTable": [
+        "input"
+      ],
+      "checkDuplicate": true,
+      "allowedTypes": [],
+      "allowedTypeGroups": [
+        "ALL"
+      ],
+      "matchLengthOfArgument": "",
+      "allowPadding": false,
+      "name": "Accumulate",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Specifies the input table columns to copy to the output table. By default, the function copies no input table columns to the output table.",
+      "description": "Specifies the input table columns to copy to the output table. By default, the function copies no input table columns to the output table.",
+      "datatype": "COLUMNS",
+      "allowsLists": true,
+      "rName": "accumulate",
+      "useInR": true,
+      "rOrderNum": 10
+    }
+  ]
+}

teradataml/data/jsons/sqle/17.10/nPath.json

@@ -0,0 +1,269 @@
+{
+  "json_schema_major_version": "1",
+  "json_schema_minor_version": "2",
+  "json_content_version": "1",
+  "function_name": "nPath",
+  "function_version": "1.1",
+  "function_type": "fastpath",
+  "function_category": "Path and Pattern Analysis",
+  "function_alias_name": "nPath",
+  "function_r_name": "aa.npath",
+  "short_description": "The nPath function matches specified patterns in a sequence of rows from one or more input tables and extracts information from the matched rows.",
+  "long_description": "The nPath function matches specified patterns in a sequence of rows from one or more input tables and extracts information from the matched rows.",
+  "input_tables": [
+    {
+      "requiredInputKind": [
+        "PartitionByKey"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input1",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "Input table",
+      "description": "Input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data1",
+      "useInR": true,
+      "rOrderNum": 1
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input2",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data2",
+      "useInR": true,
+      "rOrderNum": 7
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input3",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data3",
+      "useInR": true,
+      "rOrderNum": 8
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input4",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data4",
+      "useInR": true,
+      "rOrderNum": 9
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input5",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data5",
+      "useInR": true,
+      "rOrderNum": 10
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input6",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data6",
+      "useInR": true,
+      "rOrderNum": 11
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input7",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data7",
+      "useInR": true,
+      "rOrderNum": 12
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input8",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data8",
+      "useInR": true,
+      "rOrderNum": 13
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input9",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data9",
+      "useInR": true,
+      "rOrderNum": 14
+    },
+    {
+      "requiredInputKind": [
+        "PartitionByKey",
+        "Dimension"
+      ],
+      "isOrdered": true,
+      "partitionByOne": false,
+      "name": "input10",
+      "alternateNames": [],
+      "isRequired": false,
+      "rDescription": "Additional optional input table",
+      "description": "Additional optional input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data10",
+      "useInR": true,
+      "rOrderNum": 15
+    }
+  ],
+  "argument_clauses": [
+    {
+      "permittedValues": [
+        "OVERLAPPING",
+        "NONOVERLAPPING"
+       ],
+      "isOutputColumn": false,
+      "name": "Mode",
+      "alternateNames": [],
+      "rDescription": "Specifies the pattern-matching mode: \n OVERLAPPING: The function finds every occurrence of the pattern in the partition, regardless of  whether it is part of a previously found match. Therefore, one row can match multiple symbols in a  given matched pattern. \n NONOVERLAPPING: The function begins the next pattern search at the row that follows the last  pattern match. This is the default behavior of many commonly used pattern matching utilities, including the UNIX grep utility.",
+      "description": "Specifies the pattern-matching mode: \n OVERLAPPING: The function finds every occurrence of the pattern in the partition, regardless of  whether it is part of a previously found match. Therefore, one row can match multiple symbols in a  given matched pattern. \n NONOVERLAPPING: The function begins the next pattern search at the row that follows the last  pattern match. This is the default behavior of many commonly used pattern matching utilities, including the UNIX grep utility.",
+      "datatype": "STRING",
+      "allowsLists": false,
+      "isRequired": true,
+      "rName": "mode",
+      "useInR": true,
+      "rOrderNum": 2
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": false,
+      "name": "Pattern",
+      "alternateNames": [],
+      "rDescription": "Specifies the pattern for which the function searches. You compose pattern with the symbols that you define in the symbols argument, operators, and parentheses. Table describes the simplest patterns, which you can combine to form more complex patterns. When patterns have multiple operators, the function applies them in order of precedence, and applies operators of equal precedence from left to right. Table also shows operator precedence. To force the function to evaluate a subpattern first, enclose it in parentheses. To specify that a subpattern must appear a specific number of times, use the 'Range-Matching Feature'.\n For pattern matching details, refer to 'Pattern Matching'.",
+      "description": "Specifies the pattern for which the function searches. You compose pattern with the symbols that you define in the Symbols argument, operators, and parentheses. Table describes the simplest patterns, which you can combine to form more complex patterns. When patterns have multiple operators, the function applies them in order of precedence, and applies operators of equal precedence from left to right. Table also shows operator precedence. To force the function to evaluate a subpattern first, enclose it in parentheses. To specify that a subpattern must appear a specific number of times, use the 'Range-Matching Feature' \n For pattern matching details, refer to 'Pattern Matching'.",
+      "datatype": "STRING",
+      "allowsLists": false,
+      "isRequired": true,
+      "rName": "pattern",
+      "useInR": true,
+      "rOrderNum": 3
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": false,
+      "name": "Symbols",
+      "alternateNames": [],
+      "rDescription": "Defines the symbols that appear in the values of the pattern and result arguments. The col_expr is an expression whose value is a column name, symbol is any valid identifier, and  symbol_predicate is a SQL predicate (often a column name).\n For example, the Symbols argument for analyzing website visits might look like this: \nsymbols \n(\n pagetype = 'homepage' AS H, \npagetype <> 'homepage' AND  pagetype <> 'checkout' AS PP,\n pagetype = 'checkout' AS CO \n)\n The symbol is case-insensitive; however, a symbol of one or two uppercase letters is easy to identify in patterns. \nIf col_expr represents a column that appears in multiple input tables, then you must qualify the ambiguous column name with its table name. For example: \n Symbols \n ( \n weblog.pagetype = 'homepage' AS H, \n weblog.pagetype = 'thankyou' AS T, \n ads.adname = 'xmaspromo' AS X, \n ads.adname = 'realtorpromo' AS R \n) \nFor more information about symbols that appear in the Pattern argument value, refer to 'symbols'. For more information about symbols that appear in the Result argument value, refer to 'result: Applying Aggregate Functions'.",
+      "description": "Defines the symbols that appear in the values of the Pattern and Result arguments. The col_expr is an expression whose value is a column name, symbol is any valid identifier, and  symbol_predicate is a SQL predicate (often a column name).\n For example, the Symbols argument for analyzing website visits might look like this: \n Symbols \n (\n pagetype = 'homepage' AS H, \n pagetype <> 'homepage' AND  pagetype <> 'checkout' AS PP, \n pagetype = 'checkout' AS CO \n)\n The symbol is case-insensitive; however, a symbol of one or two uppercase letters is easy to identify in patterns. If col_expr represents a column that appears in multiple input tables, then you must qualify the ambiguous column name with its table name. For example: Symbols ( weblog.pagetype = 'homepage' AS H, weblog.pagetype = 'thankyou' AS T, ads.adname = 'xmaspromo' AS X, ads.adname = 'realtorpromo' AS R ) For more information about symbols that appear in the Pattern argument value, refer to 'Symbols'. For more information about symbols that appear in the Result argument value, refer to 'Result: Applying Aggregate Functions'.",
+      "datatype": "STRING",
+      "isRequired": true,
+      "allowsLists": true,
+      "rName": "symbols",
+      "useInR": true,
+      "rOrderNum": 4
+    },
+    {
+      "permittedValues": [],
+      "isOutputColumn": false,
+	   "name": "Filter",
+	   "alternateNames": [],
+	   "isRequired": false,
+	   "rDescription": "Specifies filters to impose on the matched rows. The function combines the filter expressions using the AND operator. \nThe filter_expression syntax is: \nsymbol_expression  comparison_operator symbol_expression \nThe two symbol expressions must be type-compatible. The symbol_expression syntax is: \n{ FIRST | LAST }(column_with_expression OF [ANY](symbol[,...])) \nThe column_with_expression cannot contain the operator AND or OR, and all its columns must come from the same input. If the function has multiple inputs, then column_with_expression and symbol must come from the same input. \nThe comparison_operator is either <, >, <=, >=, =, or <>.",
+      "description": "Specifies filters to impose on the matched rows. The function combines the filter expressions using the AND operator. \nThe filter_expression syntax is: \nsymbol_expression  comparison_operator symbol_expression \nThe two symbol expressions must be type-compatible. The symbol_expression syntax is: \n{ FIRST | LAST }(column_with_expression OF [ANY](symbol[,...])) \nThe column_with_expression cannot contain the operator AND or OR, and all its columns must come from the same input. If the function has multiple inputs, then column_with_expression and symbol must come from the same input. \nThe comparison_operator is either <, >, <=, >=, =, or <>. \nThis argument can improve or degrade nPath performance, depending on several factors. For details, refer to 'Filters'",
+      "datatype": "STRING",
+      "allowsLists": true,
+      "rName": "filter",
+      "useInR": true,
+      "rOrderNum": 6
+    },
+    {
+	   "permittedValues": [],
+      "isOutputColumn": true,
+      "name": "Result",
+      "alternateNames": [],
+      "rDescription": "Defines the output columns. The col_expr is an expression whose value is a column name; it specifies the values to retrieve from the matched rows. The function applies aggregate_function  to these values. For details, see 'result: Applying Aggregate Functions'. \nThe function evaluates this argument once for every matched pattern in the partition (that is, it outputs one row for each pattern match).",
+      "description": "Defines the output columns. The col_expr is an expression whose value is a column name; it specifies the values to retrieve from the matched rows. The function applies aggregate_function  to these values. For details, see 'Result: Applying Aggregate Functions'. \nThe function evaluates this argument once for every matched pattern in the partition (that is, it outputs one row for each pattern match).",
+      "datatype": "STRING",
+      "isRequired": true,
+      "allowsLists": true,
+      "rName": "result",
+      "useInR": true,
+      "rOrderNum": 5
+    }
+  ]
+}

teradataml/data/jsons/sqle/17.20/Antiselect.json

@@ -0,0 +1,56 @@
+{
+  "json_schema_major_version": "1",
+  "json_schema_minor_version": "1",
+  "json_content_version": "1",
+  "function_name": "Antiselect",
+  "function_version": "1.0",
+  "function_alias_name": "Antiselect",
+  "function_type": "fastpath",
+  "function_category": "Feature Engineering Transform",
+  "function_r_name": "aa.antiselect",
+  "short_description": "Outputs columns except for excluded ones.",
+  "long_description": "Outputs columns from input table or inputselect query and removes columns in exclude list.",
+  "input_tables": [
+    {
+      "requiredInputKind": [
+        "PartitionByAny"
+      ],
+      "isOrdered": false,
+      "partitionByOne": false,
+      "name": "input",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "Input table",
+      "description": "Input table",
+      "datatype": "TABLE_ALIAS",
+      "allowsLists": false,
+      "rName": "data",
+      "useInR": true,
+      "rOrderNum": 1
+    }
+  ],
+  "argument_clauses": [
+    {
+      "targetTable": [
+        "input"
+      ],
+      "checkDuplicate": false,
+      "allowedTypes": [],
+      "allowedTypeGroups": [
+        "ALL"
+      ],
+      "matchLengthOfArgument": "",
+      "allowPadding": false,
+      "name": "Exclude",
+      "alternateNames": [],
+      "isRequired": true,
+      "rDescription": "Specifies the names of the columns not to return.",
+      "description": "Specifies the names of the columns not to return.",
+      "datatype": "COLUMNS",
+      "allowsLists": true,
+      "rName": "exclude",
+      "useInR": true,
+      "rOrderNum": 2
+    }
+  ]
+}