List operators - 3 - 3.12

Data360 Analyze Server Help

Product type
Software
Portfolio
Verify
Product family
Data360
Product
Data360 Analyze
Version
3.12
Language
English
Product name
Data360 Analyze
Title
Data360 Analyze Server Help
Copyright
2023
First publish date
2016
CAUTION:
This topic relates to Data360 Analyze Script which is the language that is used in some superseded nodes. If you are looking for help configuring the Python-based nodes, please see Python scripting.

append

Returns a list with the specified values appended onto the end of list.

Used in the following format, where list must be of type list, and there are no restrictions for value or value*:

append(list, value, [value*])

list.append(value, [value*])

The return value type is a list.

Examples

append(list(1, 2, 3), 4) # value: {1,2,3,4} list(1, 2, 3).append(4) # value: {1,2,3,4}

append(list(1, 2, 3), 4, 5) # value: {1,2,3,4,5} list(1, 2, 3).append(4, 5) # value: {1,2,3,4,5}

append(list(1, 2, 3), null, 5) # value: {1,2,3,null,5} list(1, 2, 3).append(null, 5) # value: {1,2,3,null,5}

append(list(1, 2, 3), list(4, 5)) # value: {1,2,3,{4,5}} list(1, 2, 3).append(list(4,5)) # value: {1,2,3,{4.5}}

apply

Evaluates the operator with the specified parameters. Evaluates to null if the operator parameter is null. If the parameter list is null, uses an empty parameter list.

Used in the following format, where &operator must be an operator with a prepended & and parameter-list must be a list:

apply(&operator, parameter-list)

The return value type varies.

Examples

apply(&+, list(1, 2, 3, 4)) # value: 10

apply(&date, list()) # value: current date

filter

Constructs a list containing only those elements of the source list for which the predicate operator evaluates to true. The predicate operator must take a single parameter. The predicate operator is called on each element in the source list, and the value must be boolean (or null). If true, the element is included in the result list. If the predicate operator does not evaluate to true for any of the elements in the source list, the result is an empty list.

Used in the following format, where predicate-operator must be an operator, and & must be prepended to the operator and source-list must be a list:

filter(predicate-operator,source-list)

The return value type is a list.

Examples

filter(&isNotNull, list(null, 1, null, 2, 3, null, 4)) # value: { 1 2 3 4 }

find

Searches the list or dict linearly starting at offset for the value value and returns the value's index in the array if found, -1 otherwise. If offset is not specified, the search starts at the beginning of the array.

Used in the following format, where array must be a list or dict, value is what is searched for and offset must be an integer identifying the starting offset (only valid for lists):

find(array, value, [offset])

The return value type is an integer.

Examples

find(list(1, 2, 3, 4, 5), 2) # value: 1 list(1, 2, 3, 4, 5).find(2) # value: 1

find(list(1, 2, 3, 4, 5), 6) # value: -1 list(1, 2, 3, 4, 5).find(6) # value: -1

find(list(1, 2, 1, 2, 1), 2, 2) # value: 3 list(1, 2, 1, 2, 1).find(2, 2) # value: 3

flatten

Returns a list containing the concatenation of each of the entries from each of the input lists. Does not recursively flatten nested lists.

Used in the following format, where list1, list2 and listX must be lists:

flatten(list 1, {list l2}+)

The return value type is a list.

Examples

flatten(list(1,2), list(3, 4)) # value: {1,2,3,4}

flatten(list(1,2), list(3, 4), list(5, 6)) # value: {1,2,3,4,5,6}

getItem

Retrieves the list element at the specified index (zero-indexed). Errors if the index is out of range. Evaluates to null if either parameter is null.

Used in the following format, where list must be a list and index must be an integer or long integer:

getItem(list, index)

list.getItem(index)

The return value type varies.

Examples

getItem(list(1, "a", time(9, 30, 0)) 1) # value: "a" list(1, "a", time(9, 30, 0)).getItem(1) # value: "a"

getItem(list(list(), list(1, "a", 75.0)) 0) # value: {} list(list(), list(1, "a", 75.0)).getItem(0) # value: {}

len

Evaluates to the length of the given list. Each element of the list always contributes 1 to the length count. This means that if the list contains sub-elements that themselves are lists, the len operator is not executed recursively. Evaluates to null if the parameter is null.

Used in the following format, where list must be a list:

len(list)

list.len()

The return value type is an integer.

Examples

len(list(1,"a",time(9,30,0))) # value: 3 list(1,"a",time(9,30,0)).len() # value: 3

len(list()) # value: 0 list().len() # value: 0

len(list(list(), list(1,"a","75.0"))) # value: 2 list(list(), list(1,"a","75.0"))).len() # value: 2

#Null elements also contribute 1 to the length count. len(list(null, list(1, 2), 2) # value 3 list(null, list(1, 2), 2).len() # Value 3

list

Creates a list. The elements of the list may be any type.

Used in the following format, where expr may be any expression:

list({expr}*)

{expr}*.list()

The return value type is a list.

Examples

list(1, "a", time(9,30,0)) # value: { 1 "a" 9:30:00 } (1, "a", time(9,30,0)).list() # value: { 1 "a" 9:30:00 }

list() # value: {}

list(list(), list(1,"a",75.0)) # value: ( {} { 1 "a" 75.0 } } (list(), list(1,"a",75.0)).list() # value: ( {} { 1 "a" 75.0 } }

map

Constructs a list containing the results of applying the operator to the elements of the source lists. All source lists must have the same length; the result list will have this length as well. The operator must be preceded by an "&" and take n parameters, where n is the number of source lists passed. The operator is called on each elements in the source lists, and the results are assembled into a list of the same length as the source lists.

Used in the following format, where operator must be an operator or function, preceded by the "&" symbol, to show we don't want to evaluate the function, but rather pass it as an actual function name and source-lists must all be lists of the same length:

map(operator, {source-list}+)

operator.map({source-list}+)

The return value type is a list.

Examples

map(&isNull, list(null, 1, null, 2, 3)) # value: { t f t f f } map(&toUpper, list("a", "b" , "c")) # value: { A B C } map(&+, list(100, 200), list(10, 20), list(1, 2)) # value: { 111 222 }

reduce

Evaluates to the result of chain-calling the operator on each element in the source list. The operator must take two parameters. The operator is called on the first two elements in the list, then on that result and the third element, then on that result and the fourth element, and so on. The final value is the result. If an initial value is provided, it is considered to precede all elements in the list. If only a single element is provided (1-length list and no initializer or 0-length list and initializer) then that element is the result value. Evaluates to null if the operator or source list is null. Null is a valid value for the initializer.

Used in the following format, where &operator must be an operator with a prepended &, source-list must be a list and initializer may be any expression:

reduce(&operator, source-list, [initializer])

The return value type varies.

Examples

reduce(&+, list(10,27,5.7) ) # value: 42.7

reduce(&+, list(10,27,5.7),11 ) # value: 53.7

setItem

Returns a copy of list, with the value at index index set to value.

Used in the following format, where list must be a list, index must be an integer which is the position at which the value is modified and value is what it is set to:

setItem(list, index, value)

list.setItem(index, value)

The return value type is an integer.

Examples

setItem(list(1, 2, 3, 4), 2, 5) # value: (1,2,5,4) list(1, 2, 3, 4).setItem(2, 5) # value: (1,2,5,4)

slice

Returns the slice of length length of the list list starting at offset. If length is omitted or negative, the rest of the list starting at offset is returned.

Used in the following format, where list must be a list, offset must be an integer identifying the starting offset and length must be an integer identifying the size of the slice to return; default to remainder of list:

slice(list, offset, [length])

list.slice(offset, [length])

The return value type is a list.

Examples

slice(list(1, 2, 3, 4, 5), 2, 2) # value: (3,4) list(1, 2, 3, 4, 5).slice(2, 2) # value: (3,4)

slice(list(1, 2, 3, 4, 5), 2) # value: (3,4,5) list(1, 2, 3, 4, 5).slice(2) # value: (3,4,5)

slice(list(1, 2, 3, 4, 5), 2, -1) # value: (3,4,5) list(1, 2, 3, 4, 5).slice(2, -1) # value: (3,4,5)

splice

Remove the slice of length length of the list list starting at offset. If length is omitted or negative, the rest of the list starting at offset is removed. Optionally, a replacement list can be inserted in the place of the removed slice.

Used in the following format, where list must be a list, offset must be an integer identifying the starting offset, length must be an integer identifying the size of the slice to return; default to remainder of list, and replacement is a string that is inserted in place of the removed slice (does not need to be the same length as the removed slice):

splice(list, offset, [length], [replacement])

list.splice(offset, [length], [replacement])

The return value type is a list.

Examples

splice(list(1, 2, 3, 4, 5), 2) # value: {1,2} list(1, 2, 3, 4, 5).splice(2) # value: {1,2}

splice(list(1, 2, 3, 4, 5), 2, -1) # value: {1,2} list(1, 2, 3, 4, 5).splice(2, -1) # value: {1,2}

splice(list(1, 2, 3, 4, 5), 2, 2, list(6, 7)) # value: {1,2,6,7,5} list(1, 2, 3, 4, 5).splice(2, 2, list(6, 7)) # value: {1,2,6,7,5}

splice(list(1, 2, 3, 4, 5), 2, 0, list(6, 7)) # value: {1,2,6,7,3,4,5} list(1, 2, 3, 4, 5).splice(2, 0, list(6, 7)) # value: {1,2,6,7,3,4,5}