Добавил:
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз: Предмет: Файл:
Скачиваний:
32
Добавлен:
16.04.2013
Размер:
4.96 Mб
Скачать

 

 

 

Constructing Regular Expressions

 

 

 

 

Table 12–2 (Cont.)

Metacharacters Supported in Regular Expressions

 

 

 

 

 

Metacharacter

 

 

 

Syntax

Operator Name

Description

 

 

 

 

$

End of Line Anchor

Match the preceding expression only when it

 

 

 

occurs at the end of a line.

 

[:class:]

POSIX Character

Match any character belonging to the specified

 

 

Class

character class. Can be used inside any list

 

 

 

expression.

 

[.element.]

POSIX Collating

Specifies a collating sequence to use in the

 

 

Sequence

regular expression. The element you use must

 

 

 

be a defined collating sequence, in the current

 

 

 

locale.

 

[=character=]

POSIX Character

Match characters having the same base

 

 

Equivalence Class

character as the character you specify.

 

 

 

 

Constructing Regular Expressions

This section discusses construction of regular expressions.

Basic String Matching with Regular Expressions

The simplest match that you can perform with regular expressions is the basic string match. For this type of match, the regular expression is a string of literals with no metacharacters. For example, to find the sequence 'abc', you specify the regular expression:

abc

Regular Expression Operations on Subexpressions

As mentioned earlier, regular expressions are constructed using metacharacters and literals. Metacharacters that operate on a single literal, such as '+' and '?' can also operate on a sequence of literals or on a whole expression. To do so, you use the grouping operator to enclose the sequence or subexpression. See "Subexpression" on page 12-10 for more information on grouping.

Regular Expression Operator and Metacharacter Usage

This section gives usage examples for each supported metacharacter or regular expression operator.

Using Regular Expressions With Oracle Database 12-5

Constructing Regular Expressions

Match Any Character—Dot

The dot operator '.' matches any single character in the current character set. For example, to find the sequence—'a', followed by any character, followed by 'c'—use the expression:

a.c

This expression matches all of the following sequences:

abc adc a1c a&c

The expression does not match:

abb

One or More—Plus

The one or more operator '+' matches one or more occurrences of the preceding expression. For example, to find one or more occurrences of the character 'a', you use the regular expression:

a+

This expression matches all of the following:

a aa aaa

The expression does not match:

bbb

Zero or One—Question Mark Operator

The question mark matches zero or one—and only one—occurrence of the preceding character or subexpression. You can think of this operator as specifying an expression that is optional in the source text.

For example, to find—'a', optionally followed by 'b', then followed by 'c'—you use the following regular expression:

12-6 Oracle Database Application Developer's Guide - Fundamentals

Constructing Regular Expressions

ab?c

This expression matches:

abc ac

The expression does not match:

adc abbc

Zero or More—Star

The zero or more operator '*', matches zero or more occurrences of the preceding character or subexpression. For example, to find—'a', followed by zero or more occurrences of 'b', then followed by 'c'—use the regular expression:

ab*c

This expression matches all of the following sequences:

ac abc abbc abbbbc

The expression does not match:

adc

Interval—Exact Count

The exact-count interval operator is specified with a single digit enclosed in braces. You use this operator to search for an exact number of occurrences of the preceding character or subexpression.

For example, to find where 'a' occurs exactly 5 times, you specify the regular expression:

a{5}

This expression matches:

aaaaa

Using Regular Expressions With Oracle Database 12-7

Constructing Regular Expressions

The expression does not match:

aaaa

Interval—At Least Count

You use the at-least-count interval operator to search for a specified number of occurrences, or more, of the preceding character or subexpression. For example, to find where 'a' occurs at least 3 times, you use the regular expression:

a{3,}

This expression matches all of the following:

aaa aaaaa

The expression does not match:

aa

Interval—Between Count

You use the between-count interval operator to search for a number of occurrences within a specified range. For example, to find where 'a' occurs at least 3 times and no more than 5 times, you use the following regular expression:

a{3,5}

This expression matches all of the following sequences:

aaa aaaa aaaaa

The expression does not match:

aa

Matching Character List

You use the matching character list to search for an occurrence of any character in a list. For example, to find either 'a', 'b', or 'c' use the following regular expression:

[abc]

12-8 Oracle Database Application Developer's Guide - Fundamentals

Constructing Regular Expressions

This expression matches the first character in each of the following strings:

at bet cot

The expression does not match:

def

The following regular expression operators are allowed within the character list, any other metacharacters included in a character list lose their special meaning (are treated as literals):

Range operator '-'

POSIX character class [: :]

POSIX collating sequence [. .]

POSIX character equivalence class [= =]

Non-Matching Character List

Use the non-matching character list to specify characters that you do not want to match. Characters that are not in the non-matching character list are returned as a match. For example, to exclude the characters 'a', 'b', and 'c' from your search results, use the following regular expression:

[^abc]

This expression matches characters 'd' and 'g' in the following strings:

abcdef ghi

The expression does not match:

abc

As with the matching character list, the following regular expression operators are allowed within the non-matching character list (any other metacharacters included in a character list are ignored):

Range operator '-'

POSIX character class [: :]

POSIX collating sequence [. .]

Using Regular Expressions With Oracle Database 12-9

Constructing Regular Expressions

POSIX character equivalence class [= =]

For example, the following regular expression excludes any character between 'a' and 'i' from the search result:

[^a-i]

This expression matches the characters 'j' and 'l' in the following strings:

hijk lmn

The expression does not match the characters:

abcdefghi

Or

Use the Or operator '|' to specify an alternate expression. For example to match 'a' or 'b', use the following regular expression:

a|b

Subexpression

You can use the subexpression operator to group characters that you want to find as a string or to create a complex expression. For example, to find the optional string 'abc', followed by 'def', use the following regular expression:

(abc)?def

This expression matches strings 'abcdef' and 'def' in the following strings:

abcdefghi defghi

The expression does not match the string:

ghi

Backreference

The backreference lets you search for a repeated expression. You specify a backreference with '\n', where n is an integer from 1 to 9 indicating the nth preceding subexpression in your regular expression.

12-10 Oracle Database Application Developer's Guide - Fundamentals

Constructing Regular Expressions

For example, to find a repeated occurrence of either string 'abc' or 'def', use the following regular expression:

(abc|def)\1

This expression matches the following strings:

abcabc defdef

The expression does not match the following strings:

abcdef abc

The backreference counts subexpressions from left to right starting with the opening parenthesis of each preceding subexpression.

The backreference lets you search for a repeated string without knowing the actual string ahead of time. For example, the regular expression:

^(.*)\1$

matches a line consisting of two adjacent appearances of the same string.

Escape Character

Use the escape character '\' to search for a character that is normally treated as a metacharacter. For example to search for the '+' character, use the following regular expression:

\+

This expression matches the plus character '+' in the following string:

abc+def

The expression does not match any characters in the string:

abcdef

Beginning of Line Anchor

Use the beginning of line anchor ^ to search for an expression that occurs only at the beginning of a line. For example, to find an occurrence of the string def at the beginning of a line, use the expression:

Using Regular Expressions With Oracle Database 12-11

Constructing Regular Expressions

^def

This expression matches def in the string:

defghi

The expression does not match def in the following string:

abcdef

End of Line Anchor

The end of line anchor metacharacter '$' lets you search for an expression that occurs only at the end of a line. For example, to find an occurrence of def that occurs at the end of a line, use the following expression:

def$

This expression matches def in the string:

abcdef

The expression does not match def in the following string:

defghi

POSIX Character Class

The POSIX character class operator lets you search for an expression within a character list that is a member of a specific POSIX Character Class. You can use this operator to search for characters with specific formatting such as uppercase characters, or you can search for special characters such as digits or punctuation characters. The full set of POSIX character classes is supported.

To use this operator, specify the expression using the syntax [:class:] where class is the name of the POSIX character class to search for. For example, to search for one or more consecutive uppercase characters, use the following regular expression:

[[:upper:]]+

This expression matches 'DEF' in the string:

abcDEFghi

The expression does not return a match for the following string:

12-12 Oracle Database Application Developer's Guide - Fundamentals

Constructing Regular Expressions

abcdefghi

Note that the character class must occur within a character list, so the character class is always nested within the brackets for the character list in the regular expression.

See Also: Mastering Regular Expressions published by O'Reilly & Associates, Inc. for more information on POSIX character classes

POSIX Collating Sequence

The POSIX collating sequence element operator [. .] lets you use a collating sequence in your regular expression. The element you specify must be a defined collating sequence in the current locale.

This operator lets you use a multicharacter collating sequence in your regular expression where only one character would otherwise be allowed. For example, you can use this operator to ensure that the collating sequence 'ch', when defined in a locale such as Spanish, is treated as one character in operations that depend on the ordering of characters.

To use the collating sequence operator, specify [.element.] where element is the collating sequence you want to find. You can use any collating sequence that is defined in the current locale including single-character elements as well as multicharacter elements.

For example, to find the collating sequence 'ch', use the following regular expression:

[[.ch.]]

This expression matches the sequence 'ch' in the following string:

chabc

The expression does not match the following string:

cdefg

You can use the collating sequence operator in any regular expression where collation is needed. For example, to specify the range from 'a' to 'ch', you can use the following expression:

[a-[.ch.]]

Using Regular Expressions With Oracle Database 12-13

Constructing Regular Expressions

POSIX Character Equivalence Class

Use the POSIX character equivalence class operator to search for characters in the current locale that are equivalent. For example, to find the Spanish character 'ñ' as well as 'n'.

To use this operator, specify [=character=], to find all characters that are members of the same character equivalence class as the specified character.

For example, the following regular expression could be used to search for characters equivalent to 'n' in a Spanish locale:

[[=n=]]

This expression matches both 'N' and 'ñ' in the following string:

El Niño

Note:

The character equivalence class must occur within a character list, so the character equivalence class is always nested within the brackets for the character list in the regular expression.

Usage of character equivalents depends on how canonical rules are defined for your database locale. See the Oracle Database Globalization Support Guide for more information on linguistic sorting and string searching.

12-14 Oracle Database Application Developer's Guide - Fundamentals

Тут вы можете оставить комментарий к выбранному абзацу или сообщить об ошибке.

Оставленные комментарии видны всем.

Соседние файлы в папке Oracle 10g