Conditional expressions

An example that uses calendar dates best illustrates this concept. When verifying dates, you want to verify the length of numbers. One example is as follows:

^ [{}LEN=4] | - | ^ [{}LEN=2] | - | ^ [{}LEN=2]
; format for ccyy-mm-dd

This pattern matches on 2009-07-08 but not on 07-08-09.

The pattern operands in the preceding example have the following meaning:

When character literals are in an equality test, the standard abbreviation is tested if one is available. If this fails, the original input is tested. The following examples show pattern operands when you have ROAD RD T in your classifications:

T [ {} = "RD" ]

T [ {} = "ROAD" ]

T [ {} =A= "RD"]

T [ {} =T= "ROAD"]

T [ {} <= "RD" ]

Sometimes you need to test a value placed in a dictionary field from an earlier process or from a pattern-action set that was previously executed. This can be accomplished by specifying the field name enclosed in braces.

For example, you have two streets named EAST WEST HIGHWAY. In postal codes 20100 - 20300, the name of the street is EAST WEST, and in postal codes 80000 - 90000, WEST is the name of the street and EAST is the direction. If the postal code field is populated by an earlier process and named {ZipCode}, you can use the following pattern-action sets:

^ | D = "E" | D = "W" | T = "HWY" | [ {ZipCode} >= 20100 & {ZipCode} <= 20300 ]
COPY [1] {HouseNumber}   ; move house number to {HouseNumber} field
COPY [2] temp   ; concat EAST WEST and move
CONCAT [3] temp   ;   to street name field
COPY temp {StreetName}
COPY_A [4] {StreetSuffixType}   ; move HWY to street type field

^ | D  = "E" | D = "W" | T = "HWY" | [ {ZipCode} >= 80000 & {ZipCode} <= 90000 ]
COPY [1] {HouseNumber}   ; move house number to {HouseNumber} field
COPY_A [2] {StreetPrefixDirectional}   ; move EAST to direction
COPY [3] {StreetName}   ; move WEST to street name
COPY_A [4] {StreetSuffixType}   ; move HWY to street type field

In this pattern, the operand [{ZipCode} >= 20100 & {ZipCode} <= 20300] states:

The logical operator & is used to connect two conditional expressions. The condition is placed in a separate operand. It can also be placed in the operand for HWY; for example:

^ | D = "E" | D = "W" | T = "HWY"  [ {ZipCode} >= 80000 & {ZipCode} <= 90000 ]

These two forms are identical in function. However, the first form is easier to read because the conditions are placed in separate pattern operands.

When conditions only reference dictionary field contents (and not any pattern operand), as in the preceding example with {ZipCode}, the condition must follow all pattern operands. The following example is not valid since the second operand does not reference an input field and a third operand (T) follows the condition:

^ | [{ZipCode} = 80000] | T

The correct form is:

^ | T | [{ZipCode} = 80000]

If you use in a condition a dictionary field name that is not defined in the dictionary definition file, any test on its value always returns FALSE. If you are testing for NULL contents, the test returns TRUE; for example:

{ZZ} = ""

This facility allows use of the same general Pattern-Action files on projects which dispense with certain fields (as opposed to ending the program with an invalid field error).

Numeric constants are referenced to by coding a number. Negative numbers and decimal points are not permitted in numeric constants. The following pattern operand matches on a number equal to 10000:

^ [{} = 10000]

The following example matches to the text MAIN:

? [ {} = "MAIN" ]

If an unknown operand (?) is specified, multiple words are concatenated to a single word. To match to CHERRY HILL, use the following pattern:

? [ {} = "CHERRYHILL" ]

A NULL or empty value is indicated by two consecutive quote marks.

[ user_variable = ""]

You can use any of the relational operators for character strings. The following example matches on all strings starting with MA or greater, including MA, MAIN, NAN, PAT, but not ADAMS, M, or LZ:

? [ {} > "MA" ]

The equality (=) is tested on the abbreviation for the operand first if one exists, and then on the full operand. The other relational operators test on the full operand and not the abbreviation.

You can define variables to which you assign specific values by using the actions. You can test variables for specific values within conditions. Variables must be named according to the following conventions:

• The first character must be alphabetic.
• The name cannot exceed 32 characters.

After the first alphabetic character, you can use any combination of alphanumeric characters or the underline (_).

For example, if you set the variable postcode to the postal code, you can test to see if the post code is 12345 as follows:

[postcode = 12345]

This type of condition can be a separate pattern operand or combined with a standard class. For example, the following two patterns produce identical results:

^ | [postcode = 12345]
^ [postcode = 12345]

If a user variable is set to a numeric value, its type is numeric. If it is set to a literal value, its type is character.

If a condition only references variables or dictionary fields, and not current input operands, the condition must follow all operands. The following example is not valid since the second operand does not reference an input field and a third operand follows:

^ | [postcode = 12345] | T

You must replace it with:

^ | T | [postcode = 12345]

A special LEN function is available. You can use the expression in one of the following three ways:

If you want to search for a nine-digit postal code of 12345-6789, check for a five-digit number followed by a hyphen and a four-digit number, for example:

^ [ {} LEN = 5] | - | ^ [{} LEN = 4]

If the numerics do not match the length, the pattern does not match.

Similarly to test the length of a variable, the following pattern matches if the variable contains five characters:

? [ temp LEN = 5]

Finally, to test the length of a dictionary field, use the field name within braces:

[ {StreetName} LEN = 20 ]

Any trailing blanks are ignored in the calculation of the length. Leading blanks are counted. For example, if a user variable or a dictionary field is set to " XY" (two leading spaces), the length of either is 4.

In some cases, you must test for special formats. You can use the PICT (picture) function. For example, Canadian postal codes have the form character-number-character (space) number-character-number; for example, K1A 3H4. You can use the PICT function to represent these sequences:

@ [{} PICT = "cnc"] | @ [{} PICT = "ncn"]

The @ (at sign) matches to a complex type (mixed numeric and alphabetic characters).

Some British postal codes use the form character-character-number (space) number-character-character; for example, AB3 5NW.

< [{} PICT = "ccn"] | > [{} PICT = "ncc"]

The PICT clause works for dictionary field values:

[ {ZipCode} PICT = "ccn" ]

The PICT operand works for user variables:

[ temp PICT = "ncncn" ]

Only the equality (=) and inequality (!=) operators can be used with PICT comparisons.

These portions are called substrings. The following forms are valid:

The (beg:end) specifies the beginning and ending character to extract. The first character in the string is 1, the last character is –1, and so on.

For example, German style addresses have the street type appended to the end of the street name. Thus, HESSESTRASSE means HESSE STREET. The substring form can be used to test for these suffixes. Consider an input address of HESSESTRASSE 15. The following pattern matches to all words ending in STRASSE that are followed by a numeric:

+ [{} (-7:-1) = "STRASSE"]  | ^

Similarly, variables and fields can be tested:

[temp(2:4) = "BCD"]
[{StreetName}(1:4) = "FORT"]

? [{} (1:12) = "MARTINLUTHERKING"]