A predicate specifies a condition that SQL evaluates as true,
    false, or unknown. Predicates are also called conditional
    expressions. You can specify several different types of
    predicates with different conditional operators. The different
    types of predicates are:

    o  Basic

    o  BETWEEN

    o  Complex

    o  CONTAINING

    o  EXISTS

    o  IN

    o  IS NULL

    o  LIKE

    o  MATCHING

    o  Quantified

    o  SINGLE

    o  STARTING WITH

    o  UNIQUE

    When you compare character value expressions, if automatic
    translation has not been enabled, character sets of those value
    expressions must be identical.

    Some predicates have a specific behavior when used with the DEC
    Multinational Character Set (MCS).

    The following list describes multinational character set behavior
    that applies to predicates:

    o  The character ñ is always treated as different from the
       character n, in keeping with the practices of the Spanish
       language. In a similar manner, the character ç is treated the
       same as the character c, in keeping with the practices of the
       French language.

    o  The character ü is treated the same as the character u for
       many languages, but is sorted between the characters x and z
       (with the ys) for Danish, Norwegian, and Finnish languages.

    The following diagram shows the syntax for predicates:

  predicate =

  -+-+--------+-+-> basic-predicate ----------------+-+-->
   | +-> NOT -+ +-> between-predicate --------------+ |
   |            +-> containing-predicate -----------+ |
   |            +-> exists-predicate ---------------+ |
   |            +-> in-predicate -------------------+ |
   |            +-> is-null-predicate --------------+ |
   |            +-> like-predicate -----------------+ |
   |            +-> matching-predicate -------------+ |
   |            +-> quantified-predicate -----------+ |
   |            +-> single-predicate ---------------+ |
   |            +-> unique-predicate ---------------+ |
   |            +-> starting-with-predicate --------+ |
   |            +-> (predicate) --------------------+ |
   +-----------------+- AND <--+----------------------+
                     +-- OR <--+

                                   NOTE

       Except for the IS NULL, EXISTS, and SINGLE operators, if
       either operand in a predicate is null, the value of the
       predicate is unknown.

       You cannot use a value of the LIST OF BYTE VARYING data
       type for either operand in a comparison predicate. For more
       information, see the LIST_OF_BYTE_VARYING HELP topic.

       When you use the DEC_MCS or ASCII character set, SQL
       compares character string literals according to the ASCII
       collating sequence. Therefore, it considers lowercase
       letters to have a greater value than uppercase letters,
       and considers the letters near the beginning of the alphabet
       to have a lesser value than those near the end.

       'a' > 'A'
       'a' > 'Z'
       'a' < 'z'
       'A' < 'z'
       'A' < 'Z'