Describes the Pattern Matching in Mule DataWeave.

1. Mule Concepts
DataWeave VII

2. • Pattern matching executes on the first pattern that
matches the specified expression.
• DataWeave supports four different types of patterns:
– Literal
– type/traits
– Regex
– Expression
• Each pattern type can be either named or
unnamed.
DataWeave – Body - Pattern matching

3. • The example below is a model for how matching
works :
---
value match {
(<name>:)?<pattern> -> <when matched>,
(<name>:)?<pattern> -> <when matched>,
default -> <when none of them matched>
}
---
DataWeave – Body - Pattern matching

4. • Literal Pattern :
– Matches when the evaluated value equals a simple literal value.
– Example :
– In this example, the first field simply matches the value in
'payload.string' and returns a boolean, the second field performs the
same match, but returns an object that contains both a boolean and a
reference to the validated value.
DataWeave – Body - Pattern matching
Transform Input Output
%dw 1.0
%output application/json
---
a: payload.string match {
"Emiliano" -> true,
"Mariano" -> false
},
b: payload.string match {
str: "Emiliano" -> { "matches": true, value: str },
str: "Mariano" -> { "matches": false, value: str }
}
{ "string": "Emiliano" }
{
"a": true,
"b": {
"matches": true,
"value": "Emiliano"
}
}

5. • Expression Pattern :
– Matches when running a certain expression over the evaluated value
returns true.
– Example :
– In this example, the first field matches the value of 'payload.string' against two
alternatives and conditionally appends a different string to it; the second field
evaluates if the value in 'payload.number' is larger or smaller than 3 and
returns "lower" or "higher" accordingly.
DataWeave – Body - Pattern matching
Transform Input Output
%dw 1.0
%output application/json
---
{
a: payload.string match {
str when str == "Mariano" -> str ++ " de Achaval",
str when str == "Emiliano" -> str ++ " Lesende" },
b: payload.number match {
n when n < 3 -> "lower",
n when n > 3 -> "higher" }}
{
"string":
"Emiliano",
"number": 3.14
}
{
"a": "Emiliano
Lesende",
"b": "higher"
}

6. • Match Type :
– Matches when the evaluated value is of the specified type.
– Example :
DataWeave – Body - Pattern matching
Transform Input Output
%dw 1.0
%output application/json
---
{
a: payload.a match {
:object -> "OBJECT",
:string -> "STRING",
:number -> "NUMBER",
:boolean -> "BOOLEAN",
:array -> "ARRAY",
:null -> "NULL"
},
b: payload.b match {
y is :object -> { type: "OBJECT", y: y },
y is :string -> { type: "STRING", y: y },
y is :number -> { type: "NUMBER", y: y },
y is :boolean -> { type: "BOOLEAN", y: y },
y is :array -> { type: "ARRAY", y: y },
y is :null -> { type: "NULL", y: y }
}}
{
"a": "Emiliano",
"b": 3.14
}
{
"a": "STRING",
"b": {
"type": "NUMBER",
"y": 3.14
}
}

7. • Match Type :
– In this example, the first field evaluates the type of 'payload.a' and returns a
different string with the type name depending on what type it matches with
(this could be easier done through the Type Of operator), the second field
returns an object with the same type name as a string and a reference to the
evaluated value.
DataWeave – Body - Pattern matching

8. • Match Regex :
– Matches when the evaluated value fits a given regular expression.
– Example :
DataWeave – Body - Pattern matching
Transform Input Output
%dw 1.0
%output application/json
---
{
a: payload.phones map ($ match {
/+(d+)s((d+))s(d+-d+)/ -> { country: $[0], area:
$[1], number: $[2] },
/((d+))s(d+-d+)/ -> { area: $[1], number: $[2] }
}),
b: payload.phones map ($ match {
phone: /+(d+)s((d+))s(d+-d+)/ -> { country:
phone[0], area: phone[1], number: phone[2] },
phone: /((d+))s(d+-d+)/ -> { area: phone[1],
number: phone[2] }
})
}
{
"phones": [
"+1 (415) 229-
2009",
"(647) 456-
7008"
]
}
{
"a": [
{
"country": "+1 (415) 229-
2009","area": "1","number":
"415"
},{
"area": "647",
"number": "456-7008"
} ],
"b": [
{"country": "+1 (415) 229-
2009",
"area": "1",
"number": "415"},
{"area": "647",
"number": "456-7008" }]}

9. • Match Regex :
– In this example, the payload includes two elements in an array, and in both
cases the Map operatorto cycle through the array. It then evaluates each
element agains a regular expression and outputs a different object depending
on what kind of match is found.
DataWeave – Body - Pattern matching