webMethods Regular Expressions

A regular expression is a text string that describes some set of strings. Regular
expressions are a pattern-matching technique supported in a variety of tools and
software but are most commonly known from UNIX tools such as grep, sed, vi and
emacs. Using regular expressions (regex for short) you can determine if a string
matches a specific pattern.
web Methods Integration Server provides regex support. The syntax and usage is
described in the web Methods Developer User's Guide (Appendix D in version 4.6,
Appendix B in 6.0).
This web Methods E-zine article addresses using regex patterns in:
The label property of a child step within a BRANCH
Web Methods Query Language (WQL) statements
Built-in String Services
Regex in Labels
Using regular expressions can greatly simplify your BRANCH constructs. The regular
expression in a label must be surrounded with slashes. As an example, consider the
common task of needing to determine if a pipeline variable contains at least one
non-space character. Without using regex the FLOW steps to accomplish this might
look like this:

Using a regular
expression can greatly
simplify the steps
needed. The following
FLOW steps
accomplish this easily:
The following table
provides a few regular
expressions samples
for common tasks.

regex and WQL

WQL is the webMethods precursor to XQL. Both languages are supported by the
query service (pub.xml:queryXMLNode in v6.0, pub.web:queryDocument in v4.6 and
earlier). WQL supports using regex to specify a pattern-matching string to select
members of an element array.
This facility is described in the Working with XML Documents document shipped
with v6.0 and in the Developer User's Guide with v4.6 and earlier. From an example
described in the webMethods documentation, the following query:
doc.bitterrootboards['*Pro Series*'].text
returns every bitterrootboards element that contains the string "Pro Series"
anywhere within it. WQL coupled with regex provides significant power and
flexibility in processing XML.

regex and Built-In String Services

There are two built-in services that support regex:
pub.string: lookup Table
pub.string: replace
The pub.string: lookup Table service can use a regular expression to perform a
lookup on the table. It returns the first value in the table whose key matches the
specified regex pattern.

The pub.string: replace service supports using a regular expression as the search
string. For example post to strip leading zeroes from a number. The screen shot
below is the results tab after running pub.string: replace.

In this example, "+0000" in the in String is replaced by "+" as shown by the

variable named value. The search string can be described as "look at the beginning
of the string for a + followed by one or more zeroes." The search string uses these
regex features:

The ^ specifies that the pattern must be at the start of the in String.
The + character has a special meaning in regex. For this pattern we want to use the
+ character literally. The escapes the + telling the regex engine to use + as a literal
rather than a regex operator.
The 0 is used literally. The second + character is a regex operator indicating that
the preceding element (in this case the character 0) can occur 1 or more times.
We can add some flexibility to Eric's regex example to support a optional leading +
or - and keep it in the resulting value. The screen shot below again shows the
results tab after running pub.string: replace with the indicated parameters. Note the
differences in the search String parameter in this example as compared to the first
example.

The search string in this second example can be described as "look at the beginning
of the string for an optional + or - followed by one or more zeroes." This search
string uses these regex features:
The ^ specifies that the pattern must be at the start of the in String.
The parentheses indicate a subexpression that can be used as a substitution
variable in the replacement string. In this case, any leading + or - will be placed
where $1 appears, so the resulting value will have the same leading sign as the
input string. If there is no leading sign, then the resulting value will not have a
leading sign.
The brackets indicate a character set. The set here is the + and the - characters.
The \ escapes the + (since it is a regex operator character and we want to use it
literally).
The? Is a regex operator which indicates that the preceding item can occur zero or
one times. The preceding item in this case is a character set, so the pattern will
match only if one of the characters from the set appears in in String.
The 0 is used literally. The second + is a regex operator indicating that the
preceding element (in this case the character 0) can occur 1 or more times.
As you can see, just a few characters in a regular expression can do quite a bit of
work. Any regular expression can be used to search for and replace substrings.
The best way to learn to use regular expressions is to play around with them. Run
pub.string: replace directly in Developer to learn the basics and expand your regex
abilities.

Example:
You can use regular expressions as the labels on your branch step even when
evaluate labels is false. A simple example is checking the http status values from a
RESTful call:

Branch header->status
/^2[0-9][0-9] $/ (OK)
/^4[0-9][0-9] $/ (Non retry enabled error)
/^5[0-9][0-9] $/ (Retry enabled error)

Much easier than trying to list all combinations.

Here I am trying to Bran on a http status string which can in the range i) 200 - 299
ii) 400 - 499 and 500 - 599
Conclusion
Regular expressions are a powerful way to easily process strings and control process
flow. While they can't do everything (e.g. using regex to try to trim whitespace from
all elements in an XML string would be ill-advised) they can make many tasks a
breeze.