Collection/Search

◷ Reading Time: 17 minutes

Sequence Search

These pipes are applicable to a sequence of elements. Some of these pipes require a local name and predicate.

The local name is a name that will be used to reference an element in the sequence. A predicate is an Expression based on your parameters and the defined local name.

Let’s consider the following business objects:

Name	Age	Sex
Arash	38	Male
Parsa	6	Male
Pooya	3	Male
Shah	3	Female

These business objects are the basis of the examples provided here. Please note in the example expressions, people is the parameter name that references these business objects.

all

Determines whether all of the elements of a sequence satisfy a condition.

 |all (localName, predicate)

localName: Required
predicate: Required
return: Boolean

Example:

Sample:  people  |all (x, x.Sex == 'Female')

Result: false

any

Determines whether all of the elements of a sequence satisfy a condition.

 |any (localName, predicate)

localName: Optional
predicate: Optional (must follow localName)
return: Boolean

Example: Has any element with Female sex?

Sample: people |any (x, x.Sex == 'Female') 
Result: true

Example: Has any element at all?

Sample: people |any ()  
Result: true

contains

Determines whether a sequence contains a specified element. It checks for collection, sequence, enum flag and string.

 |contains (value)

value: Required
return: Boolean

Example:

Sample: people
        |select (x, x.Name)
        |contains ('arash')
Result: true

Example: String check

Sample: 'test 123'
        |contains ('123')
Result: true

toIndex

Creates a lookup index based on a key. Use [ and ] to access the data using a key. When the key is not found in the index, return null.

 |toIndex (localName, predicate)

localName: Required
predicate: This is used to create a key for the index. The key can be a single property or composite by using { and }.

Example:
b:= [{'Name':'a', 'Age': 23},{'Name':'b', 'Age': 33},{'Name':'c', 'Age': 43}]
b|toIndex(x,x.Name)

Result:
[
     {
         "Key" : "a",
         "Value" : {
             "Name" : "a",
             "Age" : 23
         }
     },
     {
         "Key" : "b",
         "Value" : {
             "Name" : "b",
             "Age" : 33
         }
     },
     {
         "Key" : "c",
         "Value" : {
             "Name" : "c",
             "Age" : 43
         }
     }
 ]

indexOf

Return index value based on a key. When the key is not found in the index, return (-1).

 |indexOf (localName, predicate)

localName: Required
predicate: This is used to create a key for the index. The key can be a single property or composite by using { and }.

Example:
b:= [{'Name':'a', 'Age': 23},{'Name':'b', 'Age': 33},{'Name':'c', 'Age': 43}]

b|indexOf(x, x.Name=='c')

Result:
2

forIndex

forIndex function allows you to access every node in your dataset by the index of the element.

 |forIndex (localName, predicate)

localName: Required
predicate: Required

Example:
Data:= [{'Name': "Karl", 'Height': "150"},{'Name': "James", 'Height': "125"}]

B:=Data|forIndex(x,Data[0].Height=165)

Result:
[
    {
        "Name" : "Karl",
        "Height" : 165
    },
    {
        "Name" : "James",
        "Height" : "125"
    }
]

groupBy

Groups the elements of a sequence based on a key.

 |group (localName, predicate)

localName: Required
predicate: Required (key builder for groups) or list of properties of an element
return: Sequence of IGrouping elements

Example 1: Group people by gender (single property)

Sample: people |groupBy (x, x.Sex)
Result: Sequence of groups based on people gender (Sex property)

Example 2: Group people by gender and Age (by key function)

Sample: people |groupBy (x, key(x.Sex, x.Age))
Result: Sequence of groups based on people gender and age (Sex and Age property)

Example 3: Group people by gender and Age (by the list of properties)

Sample: people |groupBy (x, x.Sex, x.Age)
Result: Sequence of groups based on people gender and age (Sex and Age property)

groupIndexBy

Groups the elements of a sequence based on a key and then create an index based on the grouping key.

 |groupIndexBy (localName, predicate)

 Example:
b:= [{'Name':'a', 'Age': 23},{'Name':'b', 'Age': 33},{'Name':'c', 'Age': 43}]
b|groupIndexBy(x,x.Name)

Result:
[
     {
         "Key" : "a",
         "Value" : [
             {
                 "Name" : "a",
                 "Age" : 23
             }
         ]
     },
     {
         "Key" : "b",
         "Value" : [
             {
                 "Name" : "b",
                 "Age" : 33
             }
         ]
     },
     {
         "Key" : "c",
         "Value" : [
             {
                 "Name" : "c",
                 "Age" : 43
             }
         ]
     }
 ]

select

Projects each element of a sequence into a new form.

 |select (localName, predicate)

localName: Required
predicate: Required
return: Sequence of the projections

Example:

Sample: people|select (x, x.Name)

Result: a list of strings containing all the names ('Name' property of business objects)

Name
Arash
Parsa
Pooya
Shah

Also: you can use property selectors on the list

Sample: people.Name

Result: a list of strings containing all the names ('Name' property of business objects)

Name
Arash
Parsa
Pooya
Shah

selectMany

Projects each element of a sequence to a list and flattens the resulting sequences into one sequence.

 |selectMany (localName, sequence)

localName: Required
sequence: Required
return: a flattened sequence of the projections

Example:

Sample: people |selectMany (x, x.Emails)
Result: a list of strings containing all emails of all people

apply

Executes a set of expressions on all elements of a sequence.

 |apply (localName, predicates)

localName: mandatory
predicates: comma-separated list of expressions based on localName

Example:

Sample: people |apply (x, x.Email=null, x.Age=0)
Result: on the list of people it sets Email to null and sets Age to 0.

forEach

Allows you to access every node in your dataset.

 |forEach (localName, predicates)

localName: mandatory
predicates: mandatory

Example:

Example:
Data:= [{'Name': "Karl", 'Height': "150"},{'Name': "James", 'Height': "125"}, {'Name': "Jean", 'Height': "141"}]

A:=Data|forEach(x,x.Height=x.Height|asInt()+10)

Result:

[
   { "Name" : "Karl",
       "Height" : 160 },
   {   "Name" : "James",
       "Height" : 135 },
   {    "Name" : "Jean",
       "Height" : 151 }
]

firstOrDefault

Returns the first item in the sequence or a null value. When a predicate is defined, the first item that matches will be returned.

 |firstOrDefault (localName, predicates)

localName: Optional
predicate: Optional
return: an element from sequence or null.

Sample: people |firstOrDefault (x, x.Age lt 3)
Result: The first person has the Age less than 3

first

Check firstOrDefault

lastOrDefault

Returns the last item in the sequence or a null value. When a predicate is defined, the last item that matches will be returned.

 |lastOrDefault (localName, predicate)

localName: Optional
predicate: Optional
return: an element from sequence or null.

Sample: people |lastOrDefault (x, x.Age gt 3)
Result: The last person has the Age greater than 3

distinct

Finds distinct elements from a list

 |distinct ()

return: an element from sequence or null.

Example:

Student = ["Sarah","Alex","Emma","Emma","Sarah"]

Student|distinct()

Result: [
     "Sarah",
     "Alex",
     "Emma"
 ]

last

Check lastOrDefault

where

Filters sequence based on a condition.

 |where (localName, predicate)

localName: Required
predicate: Required
return: Sequence that matches the predicate

Example:

Sample: people |where (x, x.Age == 3)
Result: A sequence of business objects that has all the people with the Age of 3

Name	Age	Sex
Pooya	3	Male
Shah	3	Female

Also: you can use list filtering using an indexer (element access operator)

Sample: people[Age==3] 
Result: A sequence of business objects that has all the people with the Age of 3

Name	Age	Sex
Pooya	3	Male
Shah	3	Female

take

Returns the first n elements of a sequence.

 |take (count)

count: Required (Length of the elements to be returned)
return: Sequence

Example:

Sample: people |take (2)
Result: A list that contains the first two elements of the business objects list.

Name	Age	Sex
Arash	38	Male
Parsa	6	Male

item

The indexer filter, a parameter named item is always registered.

Example:

Sample: [1,2,4,5,3] [item<3]
Result:[1,2]

Example:

Sample: people[item.Age>3 and item.name!= 'Arash']
Result:

Name	Age	Sex
Parsa	6	Male

skip

Bypasses a specified number of elements in a sequence and then returns the remaining ones.

 |skip (count)

count: Required
return: Sequence

Example:

Sample: people |skip (2)
Result: Sequence containing 2 elements that is excluding the first two elements of the original list

Name	Age	Sex
Pooya	3	Male
Shah	3	Female

union

Produces the set union of two sequences.

 |union (second)

second: Mandatory (address of the second set)
return: Sequence (collection)

Example: Let’s consider the following two sets

a = [ 1, 2, 3, 4, 5, 9, 12 ]
b = [ 3, 5, 7, 8, 9 ]

Sample: a |union (b)
Result: [ 1, 2, 3, 4, 5, 7, 8, 9, 12 ]

intersect

Produces the set intersection of two sequences by using the default equality comparer to compare values.

 |intersect (second)

second: Mandatory (address of the second set)
return: Sequence (collection)

Example: Let’s consider the following two sets

a = [ 1, 2, 3, 4, 5, 9, 12 ]
b = [ 3, 5, 7, 8, 9 ]

Sample: a |intersect (b)
Result: [ 3, 5, 9 ]

except

Produces the set difference of two sequences.

 |except (second)

second: Mandatory (address of the second set)
return: Sequence (collection)

Example: 

a = [ 1, 2, 3, 4, 5, 9, 12 ]
b = [ 3, 5, 7, 8, 9 ]

a|except (b) 

Result: [ 1, 2, 4, 12 ]

toList

Returns a sequence of characters as a list from a given string.

value |toList ()

value (String): Value to be converted into a list (Mandatory)

Example: 'hello'|toList () 
Result: ["h", "e", "l", "l", "o"]

filter

Check where

exists

Checks whether a given list is empty and returns a boolean value.

list |exists ()

list: List to be checked whether it is contains any values (Mandatory)

Example: []|exists()
Result: False

Example: [1,2,3]|exists()
Result: True