oracle like

http://www.adp-gmbh.ch/ora/sql/like.html

http://www.techonthenet.com/sql/like.php

http://www-eleves-isia.cma.fr/documentation/OracleDoc/LIKE-OPERATOR.html

LIKE-OPERATOR

    LIKE OPERATOR

    The LIKE operator is used in character string comparisons with
    pattern matching.  The syntax for a condition using the LIKE
    operator is shown in this diagram:

SYNTAX:

char1 [NOT] LIKE char2 [ESCAPE 'c']

where:

char1
    is a value to be compared with a pattern.  This value can have
    datatype CHAR or VARCHAR2.

NOT
    logically inverts the result of the condition, returning FALSE if
    the condition evaluates to TRUE and TRUE if it evaluates to FALSE.

char2
    is the pattern to which char1 is compared.  The pattern is a value
    of datatype CHAR or VARCHAR2 and can contain the special pattern
    matching characters % and _.

ESCAPE
    identifies a single character as the escape character.  The escape
    character can be used to cause Oracle to interpret % or _ literally,
    rather than as a special character, in the pattern.
    If you wish to search for strings containing an escape character, you
    must specify this character twice.  For example, if the escape
    character is '/', to search for the string 'client/server', you must
    specify, 'client//server'.

    While the equal (=) operator exactly matches one character value to
    another, the LIKE operator matches a portion of one character value
    to another by searching the first value for the pattern specified by
    the second.

    With the LIKE operator, you can compare a value to a pattern rather
    than to a constant.  The pattern can only appear after the LIKE
    keyword.  For example, you can issue the following query to find the
    salaries of all employees with names beginning with 'SM':

    SELECT sal
        FROM emp
        WHERE ename LIKE 'SM%'

    The following query finds the salaries of all employees with the
    name 'SM%', since the query uses the equality operator instead of
    the LIKE operator:

    SELECT sal
        FROM emp
        WHERE ename = 'SM%'

    The following query finds the salaries of all employees with the
    name 'SM%'.  Oracle interprets 'SM%' as a text literal, rather than
    as a pattern, because it precedes the LIKE operator:

    SELECT sal
        FROM emp
        WHERE 'SM%' LIKE ename

    Patterns often use special characters that Oracle matches with
    different characters in the value:

    * An underscore (_) in the pattern matches exactly one character (as
      opposed to one byte in a multi-byte character set) in the value.
    * A percent sign (%) in the pattern can match zero or more
      characters (as opposed to bytes in a multi-byte character set) in
      the value.  Note that the pattern '%' cannot match a null.

    Case is significant in all conditions comparing character
    expressions including the LIKE and equality (=) operators.  You can
    use the UPPER() function to perform a case insensitive match, as in
    this condition:

    UPPER(ename) LIKE 'SM%'

    When LIKE is used to search an indexed column for a pattern, the
    performance benefit associated with the index is lost if the first
    character in the pattern is % or _.  If the leading character in the
    pattern is not % or _, there is some performance benefit to the
    index because Oracle can restrict the comparison to rows known to
    begin with the specified first character.

EXAMPLE I:
    This condition is true for all ENAME values beginning with MA:

    ename LIKE 'MA%'

    All of these ENAME values make the condition TRUE:

    MARTIN, MA, MARK, MARY

    Since case is significant, ENAME values beginning with Ma, ma, and
    mA make the condition FALSE.

EXAMPLE II:
    Consider this condition:

    ename LIKE 'SMITH_'

    This condition is true for these ENAME values:

    SMITHE, SMITHY, SMITHS

    This condition is false for 'SMITH', since the special character _
    must match exactly one character of the ENAME value.

THE ESCAPE OPTION:
    You can include the actual characters % or _ in the pattern by using
    the ESCAPE option.  The ESCAPE option identifies the escape
    character.  If the escape character appears in the pattern before
    the character % or _, Oracle interprets this character literally in
    the pattern, rather than as a special pattern matching character.

EXAMPLE III:
    To search for any employees with the character string 'A_B' in their
    name:

    SELECT ename
        FROM emp
        WHERE ename LIKE '%A\_B%' ESCAPE '\'

    The ESCAPE option identifies the backslash (\) as the escape
    character.  In the pattern, the escape character precedes the
    underscore (_).  This causes Oracle to interpret the underscore
    literally, rather than as a special pattern matching character.