Show TOC

Generic FunctionsLocate this document in the navigation structure

Use

The expression editor contains a list with built-in functions for transforming data. The list is now enhanced with a set of generic functions such as sort, filter, and so on. With anyType support, it is possible to create such generic functions whose input parameters and/or return types are xsd:anyType. This means that you can provide every custom or base type as an actual parameter to the function. If you provide a concrete type as a parameter, the function returns the same concrete type as a result.

The following table lists the built-in generic functions, their description, signature, and an example of each generic function. The asterisk (*) indicates that there are zero or more occurrences of the marked element:

Generic Function

Description

Signature

Example

Sort

Sorts a list which is provided as one of the input parameters of the function. The list is sorted by the string representation of the input parameter serving as a sort criterion. The sort direction can be either ascending or descending and is set as a Boolean value. The result is a sorted list.

Note that if the criterion is an attribute, you must prefix it with an at sign (@).

sort( list as xsd:anyType*, sortBy as xsd:string, descending as xsd:boolean ) as xsd:anyType*

The sort function sorts a list of task attributes contained in a data object DataObject . The sort criterion is the type of actual owner. The sort direction is descending, which means that the Boolean value is true .

                           sort( DataObject/TaskAttributes, "actualOwner/type", true )

The sort function sorts a list with addresses contained in data object DataObject . The sort criterion is the country zipcode, which is an attribute and is prefixed with an at (@) sign.

                           DataObject
  Address
    city
    country
      @zipcode
      #text()
                           sort( DataObject/Address, "country/@zipcode", true )

Filter

Filters a list which is provided as one of the input parameters of the function. The list is filtered by the string representation of the input parameter serving as a filter criterion. Note that the filter criterion cannot be a list.

The result is a filtered list.

In case you want to use a parameter whose type has a qualified namespace, you need to specify the namesapce together with the parameter in the expression editor.

Note that if the criterion is an attribute, you must prefix it with an at sign (@).

filter( list as xsd:anyType*, criteria as xsd:string ) as xsd:anyType*

The filter function filters a list of principals contained as potential owners in a data object DataObject . To evaluate the filter criterion, the built-in function concat is invoked, which returns a result as xs:string. This example shows the possibility the filter criterion to have a dynamic value.

                           filter( 
DataObject/PotentialOwners/principal,
concat(
"principalId=",DataObject/ExcludedOwners/principal/principalId )
 )

The parameter e1 that you want to use as a filter criterion has a type with a qualified namespace "http://www.example.org/NewXMLSchema" . You specify the namespace of the parameter when using the filter function as follows:

                           filter( arg1,"http://www.example.org/NewXMLSchema:e1=1")

Get

Gets the n-th element from a list, starting the count from 0. The input parameters of the function are a list and an index. The result is a single element.

get( list as xsd:anyType*, index as xsd:long ) as xsd:anyType ( single )

The get function gets the third principal from a list of excluded owners, contained in a data object DataObject .

                           get( DataObject/ExcludedOwners/principal, 3 )

Count

Counts the number of elements in the input parameter. The result is a number.

count( arg as xsd:anyType* ) as xsd:long

The count function counts the principals contained as potential owners in a data object DataObject .

                           count( DataObject/PotentialOwners/principal )

Insert-Before

Inserts a list in another list in a defined position, starting the count from 0.

insert-before( target as xsd:anyType*, position as xsd:long, inserts as xsd:anyType* ) as xsd:anyType*

The insert-before function inserts the principals from the excluded owners list in the list of potential owners starting from position 2. Both lists are contained in a data object DataObject .

                           insert-before( DataObject/PotentialOwners/principal,
2,
DataObject/ExcludedOwners/principal )

IF

Can be used for both lists and single values. Function evaluates a Boolean condition provided as an input parameter. Based on the result, either the first or the second value, provided also as input parameters is taken.

IF( test as xsd:boolean, thenValue as xsd:anyType*, elseValue as xsd:anyType* ) as xsd:anyType*

Deprecated. This function is deprecated and you can use the conditional if statement instead: if (<ExpressionOne>) then <ExpressionTwo> else <ExpressionThree> .

Following is an example of IF function that evaluates the result of the condition as false and takes the value of the description, contained in a data object DataObject .

                           IF( 
min( 3,5 )>10,
DataObject/subject,
DataObject/description )

IsSet

Returns true as a result if the list that is provided as an input parameter, is not null.

isSet( list as xsd:anyType*) as xsd:boolean

The isSet function evaluates the list of potential owners in a data object DataObject and returns true if the list is initialized. If the list is null, the function returns false as a result.

                           isSet( DataObject/PotentialOwners/principal )

Nilled

Returns true as a result only if the input parameter is initialized and annotated as xsi:nil

nilled( arg xsd:anyType) as xsd:boolean

The nilled function checks whether the element A in a data object DataObject is initialized and annotated as xsi:nil and returns true if it is. Otherwise the nilled function returns false .

                           <DataObject>

                           <A xsi:nil="true"/>

                           </DataObject>
                        
                           nilled( DataObject/A)-> true

load-xml

This function converts a valid XML string into SDO of type xsd:anyType. A runtime exception is thrown if xml passed is not well formed.

Load-xml(xml string as xsd:string) as xsd:anyType

Say PurchaseOrder is DataObject defined as part of Process which can hold XML string like given below:

                           ns1:PurchaseOrder xmlns:ns1="http://demo.sap.com
xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
<orderID>505</orderID>
<OrderItems>
<productID.505</productID>
<quantity>0</quantity>
</Orderitems>
</ns1:PurchaseOrder>

load-xml(PurchaseOrder) returns a SDO of type xsd:anyType.