Built-In Functions
FEEL includes a library of built-in functions that you can use to define expressions.
Oracle Integration supports the following types of built-in functions in decisions. Additionally, to assist with expression creation, a list of built-in functions is presented as suggestions when you click an empty expression field.
String Functions
| Name(parameters) | Parameter Domain | Description | Example | 
|---|---|---|---|
| 
                                  string(from)  | 
                              
                                  non-null  | 
                              
                                  Convert from to a string.  | 
                              
                                  string(1.1) = "1.1" string(null) = null  | 
                           
| 
                                  substring(string, start, length)  | 
                              
                                  string, number1  | 
                              
                                  Return length (or all) characters in string, starting at start position. The first position is 1, last position is -1.  | 
                              
                                 
  | 
                           
| 
                                  string length(string)  | 
                              
                                  string  | 
                              
                                  Return length of string.  | 
                              
                                  string length("red") = 3  | 
                           
| 
                                  upper case(string)  | 
                              
                                  string  | 
                              
                                  Return uppercased string.  | 
                              
                                  upper case("aBc4") = "ABC4"  | 
                           
| 
                                  lower case(string)  | 
                              
                                  string  | 
                              
                                  Return lowercased string.  | 
                              
                                  lower case("aBc4") = "abc4"  | 
                           
| 
                                  substring before (string, match)  | 
                              
                                  string, string  | 
                              
                                  Return substring of string before the match in string.  | 
                              
                                 
  | 
                           
| 
                                  substring after (string, match)  | 
                              
                                  string, string  | 
                              
                                  Return substring of string after the match in string.  | 
                              
                                 
  | 
                           
| 
                                  replace(input, pattern, replacement, flags?)  | 
                              
                                  string2  | 
                              
                                  Regular expression pattern matching and replacement.  | 
                              
                                  replace("abcd", "(ab)|(a)", "[1=$1][2=$2]") = "[1=ab] [2=]cd"  | 
                           
| 
                                  contains(string, match)  | 
                              
                                  string  | 
                              
                                  Does the string contain the match?  | 
                              
                                  contains("redwood", "de") = false  | 
                           
| 
                                  starts with(string, match)  | 
                              
                                  string  | 
                              
                                  Does the string start with the match?  | 
                              
                                  starts with("redwood", "re") = true  | 
                           
| 
                                  ends with(string, match)  | 
                              
                                  string  | 
                              
                                  Does the string end with the match?  | 
                              
                                  ends with("redwood", "d") = true  | 
                           
| 
                                  matches(input, pattern, flags?)  | 
                              
                                  string2  | 
                              
                                  Does the input match the regexp pattern?  | 
                              
                                  matches("redwood", "^re*w") = true  | 
                           
List Functions
| Name(parameters) | Parameter Domain | Description | Example | 
|---|---|---|---|
| 
                                  list contains(list, element)  | 
                              
                                  list, any element of the semantic domain including null  | 
                              
                                  Does the list contain the element?  | 
                              
                                  list contains([1,2,3], 2) = true  | 
                           
| 
                                  count(list)  | 
                              
                                  list  | 
                              
                                  Return size of list.  | 
                              
                                  count([1,2,3]) = 3  | 
                           
| 
                                  minimum(list)  | 
                              
                                  (list of) comparable items  | 
                              
                                  Return minimum item.  | 
                              
                                  minimum([1,2,3]) = 1  | 
                           
| 
                                  maximum(list)  | 
                              
                                  (list of) comparable items  | 
                              
                                  Return maximum item.  | 
                              
                                  maximum([1,2,3]) = 3  | 
                           
| 
                                  sublist(list, start position, length?)  | 
                              
                                  list, number1, number2  | 
                              
                                  Return list of length (or all) elements of list, starting with list[start position]. The first position is 1, last position is -1.  | 
                              
                                  sublist([1,2,3], 1, 2) = [2]  | 
                           
| 
                                  append(list, item…)  | 
                              
                                  list, any element including null  | 
                              
                                  Return new list with items appended.  | 
                              
                                  append([1], 2, 3) = [1,2,3]  | 
                           
| 
                                  concatenate(list…)  | 
                              
                                  list  | 
                              
                                  Return new list that is a concatenation of the arguments.  | 
                              
                                  concatenate([1,2],[3]) = [1,2,3] concatenate(1,2,3) = [1,2,3] concatenate([1,2],3) = [1,2,3]  | 
                           
| 
                                  insert before(list, position, newItem)  | 
                              
                                  list, number1, any element including null  | 
                              
                                  Return new list with newItem inserted at position.  | 
                              
                                  insert before([1,3],1,2) = [1,2,3]  | 
                           
| 
                                  remove(list, position)  | 
                              
                                  list, number1  | 
                              
                                  The list with item at position removed.  | 
                              
                                  remove([1,2,3], 2) = [1,3]  | 
                           
| 
                                  reverse(list)  | 
                              
                                  list  | 
                              
                                  Reverse the list.  | 
                              
                                  reverse([1,2,3]) = [3,2,1]  | 
                           
| 
                                  index of(list, match)  | 
                              
                                  list, any element including null  | 
                              
                                  Return ascending list of list positions containing match.  | 
                              
                                  index of([1,2,3,2],2) = [2,4]  | 
                           
| 
                                  union(list…)  | 
                              
                                  list  | 
                              
                                  Concatenate with duplicate removal.  | 
                              
                                  union([1,2],[2,3]) = [1,2,3]  | 
                           
| 
                                  distinct values(list)  | 
                              
                                  list  | 
                              
                                  Duplicate removal.  | 
                              
                                  distinct values([1,2,3,2,1]) = [1,2,3]  | 
                           
| 
                                  flatten(list)  | 
                              
                                  list  | 
                              
                                  Flatten nested lists.  | 
                              
                                  flatten([[1,2],[[3]], 4]) = [1,2,3,4]  | 
                           
| 
                                  sum(list)  | 
                              
                                  (list of) numbers  | 
                              
                                  Return sum of numbers.  | 
                              
                                  sum([1,2,3]) = 6  | 
                           
| 
                                  mean(list)  | 
                              
                                  (list of) numbers  | 
                              
                                  Return arithmetic mean (average) of numbers.  | 
                              
                                  mean([1,2,3]) = 2  | 
                           
Numeric Functions
| Name(parameters) | Parameter Domain | Description | Example | 
|---|---|---|---|
| 
                                  number(from, grouping separator, decimal separator)  | 
                              
                                  number, separator, decimal notation  | 
                              
                                  Convert from to a number.  | 
                              
                                  number("1 000,0", " ", ",") = number("1,000.0", ",", ".")  | 
                           
| 
                                  decimal(n, scale)  | 
                              
                                  number, number1  | 
                              
                                  Return n with given scale.  | 
                              
                                 
  | 
                           
| 
                                  floor(n)  | 
                              
                                  number  | 
                              
                                  Return greatest integer <= n.  | 
                              
                                 
  | 
                           
| 
                                  ceiling(n)  | 
                              
                                  number  | 
                              
                                  Return smallest integer >= n.  | 
                              
                                 
  | 
                           
Boolean Functions
| Name(parameters) | Parameter Domain | Description | Example | 
|---|---|---|---|
| 
                                  not(negand)  | 
                              
                                  boolean  | 
                              
                                  Logical negation.  | 
                              
                                 
  | 
                           
Conversion Functions
| Name(parameters) | Parameter Domain | Description | Example | 
|---|---|---|---|
| 
                                  date(from)  | 
                              
                                  date string  | 
                              
                                  Convert from to a date.  | 
                              
                                  date("2012-12-25") - date("2012-12-24") = duration("P1D")  | 
                           
| 
                                  date(from)  | 
                              
                                  date and time  | 
                              
                                  Convert from to a date (set time components to null).  | 
                              
                                  date( date and time("2012-12-25T11:00:00Z")) = date("2012-12-25")  | 
                           
| 
                                  date and time(from)  | 
                              
                                  date time string  | 
                              
                                  Convert from to a date and time.  | 
                              
                                  date and time("2012-12-24T23:59:00") + duration("PT1M") = date and time("2012-12-25T00:00:00")  | 
                           
| 
                                  time(from)  | 
                              
                                  time string  | 
                              
                                  Convert from to time.  | 
                              
                                  time("23:59:00") + duration("PT2M") = time("00:01:00")  | 
                           
| 
                                  time(from)  | 
                              
                                  time, date and time  | 
                              
                                  Convert from to time (ignoring date components).  | 
                              
                                  time( date and time("2012-12-25T11:00:00Z")) = time("11:00:00")  | 
                           
| 
                                  duration(from)  | 
                              
                                  duration string  | 
                              
                                  Convert from to a date and time or years and months duration.  | 
                              
                                 
  | 
                           
| 
                                  years and months duration(from, to)  | 
                              
                                  both are date and time  | 
                              
                                  Return years and months duration between from and to.  | 
                              
                                  years and months duration( date("2011-12-22"), date("2013-08-24") ) = duration("P1Y8M")  |