string LIKE pattern [ESCAPE escape-character]
string NOT LIKE pattern [ESCAPE escape-character]

如果该string匹配了提供的pattern，那么LIKE表达式返回真（和预期的一样，如果LIKE返回真，那么NOT LIKE表达式返回假， 反之亦然。一个等效的表达式是NOT (string LIKE pattern)）。

如果pattern不包含百分号或者下划线，那么该模式只代表它本身的串；这时候LIKE的行为就象等号操作符。在pattern里的下划线 （_）代表（匹配）任何单个字符； 而一个百分号（%）匹配任何零或更多个字符的序列。

一些例子：

'abc' LIKE 'abc'    true
'abc' LIKE 'a%'     true
'abc' LIKE '_b_'    true
'abc' LIKE 'c'      false

LIKE模式匹配总是覆盖整个串。因此，要匹配在串内任何位置的序列，该模式必须以百分号开头和结尾。

要匹配文本的下划线或者百分号，而不是匹配其它字符， 在pattern里相应的字符必须 前导逃逸字符。缺省的逃逸字符是反斜线，但是你可以用ESCAPE子句指定一个不同的逃逸字符。 要匹配逃逸字符本身，写两个逃逸字符。

请注意反斜线在串文本里已经有特殊含义了，所以如果你写一个 包含反斜线的模式常量，那你就要在 SQL 语句里写两个反斜线。 因此，写一个匹配单个反斜线的模式实际上要在语句里写四个反斜线。 你可以通过用 ESCAPE 选择一个不同的逃逸字符 来避免这样；这样反斜线就不再是 LIKE 的特殊字符了。 但仍然是字符文本分析器的特殊字符，所以你还是需要两个反斜线。) 我们也可以通过写ESCAPE ''的方式不选择逃逸字符，这样可以有效地禁用逃逸机制，但是没有办法关闭下划线和百分号在模式中的特殊含义。

根据SQL标准，省略ESCAPE意味着没有转义字符(而不是默认为反斜杠)，并且不允许使用零长度的ESCAPE值。 因此，PostgreSQL在这方面的行为有点不标准。

关键字ILIKE可以用于替换LIKE， 它令该匹配根据活动区域成为大小写无关。这个不属于SQL标准而是一个PostgreSQL扩展。

操作符~~等效于LIKE， 而~~*对应ILIKE。 还有 !~~和!~~*操作符分别代表NOT LIKE和NOT ILIKE。 所有这些操作符都是PostgreSQL特有的。 你可能会在EXPLAIN输出和类似的地方看到这些操作符名称，因为解析器实际上将LIKE等翻译成这些运算符。

短语LIKE，ILIKE，NOT LIKE，和 NOT ILIKE 在PostgreSQL语法中通常被视为操作符； 例如，它们可以用于expression operator的任何（subquery）构造，尽管这里不能包含ESCAPE子句。 在某些晦涩难懂的情况下，可能需要用底层操作符名称替代。

另请参阅以^@开头的运算符和相应的starts_with()函数， 在需要简单匹配字符串开头的情况下非常有用。

string SIMILAR TO pattern [ESCAPE escape-character]
string NOT SIMILAR TO pattern [ESCAPE escape-character]

SIMILAR TO操作符根据自己的模式是否匹配给定串而返回真或者假。 它和LIKE非常类似，只不过它使用 SQL 标准定义的正则表达式理解模式。 SQL 正则表达式是在LIKE标记和普通的(POSIX)正则表达式标记的奇怪的杂交。

类似LIKE，SIMILAR TO操作符只有在它的模式匹配整个串的时候才能成功；这一点和普通的 正则表达式的行为不同，在普通的正则表达式里，模式匹配串的任意部分。 和LIKE类似的地方还有，SIMILAR TO使用_和%作为分别代表任意单个字符和任意串的通配符（这些可以比得上 POSIX 正则表达式里的.和.*）。

除了这些从LIKE借用的功能之外，SIMILAR TO支持下面这些从 POSIX 正则表达式借用的 模式匹配元字符：

注意点号（.）不是SIMILAR TO的一个元字符。

与LIKE一样，反斜杠将禁用这些元字符的特殊含义。 可以用 ESCAPE 来指定不同的转义字符，或者可以通过写 ESCAPE '' 来禁用转义功能。

根据SQL标准，省略ESCAPE意味着没有转义字符(而不是默认为反斜杠)，并且不允许使用零长度的ESCAPE值。 因此，PostgreSQL在这方面的行为有点不标准。

另一个非标准扩展是，在转义字符后面跟着一个字母或数字提供了对为POSIX正则表达式定义的转义序列的访问；参见下面的 表 9.20，表 9.21，和 表 9.22 。

一些例子：

'abc' SIMILAR TO 'abc'          true
'abc' SIMILAR TO 'a'            false
'abc' SIMILAR TO '%(b|d)%'      true
'abc' SIMILAR TO '(b|c)%'       false
'-abc-' SIMILAR TO '%\mabc\M%'  true
'xabcy' SIMILAR TO '%\mabc\M%'  false

带有三个参数的substring函数可以提取匹配SQL正则表达式模式的子字符串。 该函数可以按照标准SQL99语法编写。

substring(string similar pattern escape escape-character)

或使用现在废除的 SQL:1999 语法:

substring(string from pattern for escape-character)

或作为一个普通的三参数函数:

substring(string, pattern, escape-character)

与SIMILAR TO一样，指定的模式必须与整个数据字符串匹配，否则函数失败并返回空值。 为了表示匹配的数据子字符串的模式中，模式中应该包含两个转义字符的出现，并在后面加上一个双引号(")。 匹配成功后，将返回与这些分隔符之间的模式部分匹配的文本。

转义-双引号分隔符实际上是 将子字符串的模式分成三个独立的 正则表达式；例如，竖条(|) 三节中的任何一节只影响到该节。 此外，第一节和第三种正则表达式的定义是为了匹配最小的 尽可能多的文字，而不是最大的文字，当有歧义的时候，就不应该是最大的文字。关于有多少数据字符串符合哪种模式。 (在POSIX术语中，第一和第三种正则表达式被强行规定为非贪婪)。

作为对SQL标准的扩展，PostgreSQL只允许有一个转义双引号分隔符，在这种情况下，第三个正则表达式被视为空；或者没有分隔符，在这种情况下，第一个和第三个正则表达式被视为空。

一些例子，使用#"定界返回串：

substring('foobar' similar '%#"o_b#"%' escape '#')   oob
substring('foobar' similar '#"o_b#"%' escape '#')    NULL

表 9.16列出了所有可用于 POSIX 正则表达式模式匹配的操作符。

POSIX正则表达式提供了比LIKE和SIMILAR TO操作符更强大的含义。许多 Unix 工具，例如egrep、sed或awk使用一种与我们这里描述的类似的模式匹配语言。

正则表达式是一个字符序列，它是定义一个串集合 （一个正则集）的缩写。 如果一个串是正则表达式描述的正则集中的一员时， 我们就说这个串匹配该正则表达式。 和LIKE一样，模式字符准确地匹配串字符， 除非在正则表达式语言里有特殊字符 — 不过正则表达式用的 特殊字符和LIKE用的不同。 和LIKE模式不一样的是，正则表达式允许匹配串里的任何位置，除非该正则表达式显式地挂接在串的开头或者结尾。

一些例子：

'abcd' ~ 'bc'     true
'abcd' ~ 'a.c'    true — dot matches any character
'abcd' ~ 'a.*d'   true — * repeats the preceding pattern item
'abcd' ~ '(b|x)'  true — | means OR, parentheses group
'abcd' ~ '^a'     true — ^ anchors to start of string
'abcd' ~ '^(b|c)' false — would match except for anchoring

POSIX模式语言的详细描述见下文。

带两个参数的substring函数，即substring(string from pattern)，提供了抽取一个匹配 POSIX 正则表达式模式的子串的方法。 如果没有匹配它返回空值，否则就是匹配模式的文本中的第一部分。 但是如果该模式包含任何圆括号，那么将返回匹配第一对子表达式（对应第一个左圆括号的） 的文本。 如果你想在表达式里使用圆括号而又不想导致这个例外，那么你可以在整个表达式外边放上一对圆括号。 如果你需要在想抽取的子表达式前有圆括号，参阅后文描述的非捕获性圆括号。

一些例子：

substring('foobar' from 'o.b')     oob
substring('foobar' from 'o(.)b')   o

regexp_count函数计算 POSIX 正则表达式模式与字符串匹配的次数。 它的语法为 regexp_count(string, pattern [, start [, flags ]])。 pattern在string中进行搜索， 通常从字符串的开头开始，但如果提供了start参数，则从该字符索引开始。 flags参数是一个可选的文本字符串，包含零个或多个单字母标志，改变函数的行为。 例如，在flags中包含i指定不区分大小写匹配。 支持的标志在表 9.24中描述。

一些示例:

regexp_count('ABCABCAXYaxy', 'A.')          3
regexp_count('ABCABCAXYaxy', 'A.', 1, 'i')  4

regexp_instr函数返回字符串中第N个匹配项的起始或结束位置，如果没有这样的匹配项则返回零。 它的语法为regexp_instr(string, pattern [, start [, N [, endoption [, flags [, subexpr ]]]]]). 在string中搜索pattern，通常从字符串的开头开始，但如果提供了start参数，则从该字符索引开始。 如果指定了N，则定位模式的第N个匹配项，否则定位第一个匹配项。 如果省略了endoption参数或将其指定为0，则函数返回匹配项的第一个字符的位置。否则，endoption 必须为1，函数返回匹配项后面字符的位置。 flags参数是一个可选的文本字符串，包含零个或多个单字母标志，可以改变函数的行为。支持的标志在表 9.24中描述。 对于包含括号子表达式的模式，subexpr是一个整数，表示感兴趣的子表达式：结果标识与该子表达式匹配的子字符串的位置。 子表达式按其前导括号的顺序编号。 当省略或将subexpr指定为零时，结果标识整个匹配的位置，而不考虑括号子表达式。

一些示例:

regexp_instr('number of your street, town zip, FR', '[^,]+', 1, 2)
                                   23
regexp_instr('ABCDEFGHI', '(c..)(...)', 1, 1, 0, 'i', 2)
                                   6

regexp_like函数检查字符串中是否存在 POSIX 正则表达式模式的匹配， 返回布尔值 true 或 false。它的语法为 regexp_like(string, pattern [, flags ])。 flags参数是一个可选的文本字符串，包含零个或多个单字母标志， 可以改变函数的行为。支持的标志在表 9.24中描述。 如果没有指定标志，此函数的结果与~操作符相同。 如果只指定了i标志，则结果与~*操作符相同。

一些示例:

regexp_like('Hello World', 'world')       false
regexp_like('Hello World', 'world', 'i')  true

regexp_match函数返回一个文本数组，其中包含与POSIX正则表达式模式对字符串的第一个匹配的子字符串。它的语法为 regexp_match(string, pattern [, flags ])。 如果没有匹配，结果为NULL。 如果找到匹配，并且pattern不包含括号子表达式，则结果是包含与整个模式匹配的子字符串的单元素文本数组。 如果找到匹配，并且pattern包含括号子表达式，则结果是一个文本数组，其中n的元素是匹配 pattern的第n个括号子表达式的子字符串（不包括“非捕获”括号；详情见下文）。 flags参数是一个可选的文本字符串，其中包含零个或多个单个字母标志，用于更改函数的行为。支持的标志在表 9.24中描述。

一些示例:

SELECT regexp_match('foobarbequebaz', 'bar.*que');
 regexp_match
--------------
 {barbeque}
(1 row)

SELECT regexp_match('foobarbequebaz', '(bar)(beque)');
 regexp_match
--------------
 {bar,beque}
(1 row)

SELECT (regexp_match('foobarbequebaz', 'bar.*que'))[1];
 regexp_match
--------------
 barbeque
(1 row)

regexp_matches函数返回一个文本数组的集合，其中包含与POSIX正则表达式模式匹配的子字符串。 它具有与regexp_match相同的语法。 如果没有匹配，则此函数不返回任何行；如果有匹配且未给出g标志，则返回一行； 如果有N个匹配且给出g标志，则返回N行。 每个返回的行都是一个文本数组，其中包含整个匹配的子字符串或与pattern的括号子表达式匹配的子字符串， 就像regexp_match中描述的那样。 regexp_matches接受在表 9.24中显示的所有标志， 还接受g标志，该标志命令它返回所有匹配项，而不仅仅是第一个匹配项。

一些例子：

SELECT regexp_matches('foo', 'not there');
 regexp_matches
----------------
(0 rows)

SELECT regexp_matches('foobarbequebazilbarfbonk', '(b[^b]+)(b[^b]+)', 'g');
 regexp_matches
----------------
 {bar,beque}
 {bazil,barf}
(2 rows)

SELECT col1, (SELECT regexp_matches(col2, '(bar)(beque)')) FROM tab;

regexp_replace函数提供了对匹配POSIX正则表达式模式的子字符串进行替换的功能。 它的语法为 regexp_replace(source, pattern, replacement [, start [, N ]] [, flags ]). (注意，除非指定了start，否则无法指定N， 但flags可以在任何情况下给出。) 如果pattern没有匹配到source字符串， 则返回未更改的source字符串。如果有匹配，则返回带有 replacement字符串替换匹配子字符串的source字符串。 replacement字符串可以包含\n， 其中n为1至9，表示应插入与模式的第n个括号子表达式匹配的源子字符串， 也可以包含\&表示应插入与整个模式匹配的子字符串。 如果需要在替换文本中放置一个字面上的反斜杠，则写\\。 在string中搜索pattern， 通常从字符串的开头开始，但如果提供了start参数，则从该字符索引开始。 默认情况下，只替换模式的第一个匹配项。 如果指定了N且大于零，则替换模式的第N个匹配项。 如果给出了g标志，或者指定了N且为零，则在或之后的所有匹配项 位置都将被替换。 （当指定了N时，g标志将被忽略。） flags参数是一个可选的文本字符串，包含零个或多个单字母标志，用于更改函数的行为。 支持的标志（尽管不包括g）在表 9.24中描述。

一些示例:

regexp_replace('foobarbaz', 'b..', 'X')
                                   fooXbaz
regexp_replace('foobarbaz', 'b..', 'X', 'g')
                                   fooXX
regexp_replace('foobarbaz', 'b(..)', 'X\1Y', 'g')
                                   fooXarYXazY
regexp_replace('A PostgreSQL function', 'a|e|i|o|u', 'X', 1, 0, 'i')
                                   X PXstgrXSQL fXnctXXn
regexp_replace('A PostgreSQL function', 'a|e|i|o|u', 'X', 1, 3, 'i')
                                   A PostgrXSQL function

regexp_split_to_table把一个 POSIX 正则表达式模式当作一个定界符来分离一个串。它的语法形式是regexp_split_to_table(string, pattern [, flags ])。如果没有与pattern的匹配，该函数返回string。如果有至少有一个匹配，对每一个匹配它都返回从上一个匹配的末尾（或者串的开头）到这次匹配开头之间的文本。当没有更多匹配时，它返回从上一次匹配的末尾到串末尾之间的文本。flags参数是一个可选的文本串，它包含零个或更多单字母标志，这些标识可以改变该函数的行为。regexp_split_to_table能支持的标志在表 9.24中描述。

regexp_split_to_array函数的行为和regexp_split_to_table相同，不过regexp_split_to_array会把它的结果以一个text数组的形式返回。它的语法是regexp_split_to_array(string, pattern [, flags ])。这些参数和regexp_split_to_table的相同。

一些示例:

SELECT foo FROM regexp_split_to_table('the quick brown fox jumps over the lazy dog', '\s+') AS foo;
  foo
-------
 the
 quick
 brown
 fox
 jumps
 over
 the
 lazy
 dog
(9 rows)

SELECT regexp_split_to_array('the quick brown fox jumps over the lazy dog', '\s+');
              regexp_split_to_array
-----------------------------------------------
 {the,quick,brown,fox,jumps,over,the,lazy,dog}
(1 row)

SELECT foo FROM regexp_split_to_table('the quick brown fox', '\s*') AS foo;
 foo
-----
 t
 h
 e
 q
 u
 i
 c
 k
 b
 r
 o
 w
 n
 f
 o
 x
(16 rows)

正如最后一个示例所示，regexp分割函数会忽略出现在字符串开头或结尾 或紧跟在前一个匹配项之后的零长度匹配。这与其他regexp函数实现的 严格的regexp匹配定义相矛盾，但在实践中通常是最方便的行为。 其他软件系统如Perl使用类似的定义。

regexp_substr函数返回与POSIX正则表达式模式匹配的子字符串， 如果没有匹配，则返回NULL。它的语法为 regexp_substr(string, pattern [, start [, N [, flags [, subexpr ]]]]）。 pattern在string中进行搜索， 通常从字符串的开头开始，但如果提供了start参数，则从该字符索引开始。 如果指定了N，则返回模式的第N次匹配， 否则返回第一次匹配。参数flags是一个可选文本字符串， 包含零个或多个单字母标志，可以改变函数的行为。支持的标志在表 9.24中描述。 对于包含括号子表达式的模式，subexpr是一个整数， 表示感兴趣的子表达式：结果是与该子表达式匹配的子字符串。 子表达式按其前导括号的顺序编号。 当省略或为零时，subexpr的结果是整个匹配，而不考虑括号子表达式。

一些示例:

regexp_substr('number of your street, town zip, FR', '[^,]+', 1, 2)
                                    城镇 邮编
regexp_substr('ABCDEFGHI', '(c..)(...)', 1, 1, 'i', 2)
                                   FGH

SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
结果：123
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
结果：1

SELECT regexp_match('abc01234xyz', '(.*)(\d+)(.*)');
Result: {abc0123,4,xyz}

SELECT regexp_match('abc01234xyz', '(.*?)(\d+)(.*)');
Result: {abc,0,""}

SELECT regexp_match('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}');
Result: {abc,01234,xyz}