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 子句选择其他转义字符。要匹配转义字符本身，请写两个转义字符。

也可以通过写 ESCAPE '' 来选择不使用转义字符。这会禁用转义机制，从而无法关闭模式中下划线和百分号的特殊含义。

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

可以用关键字 ILIKE 代替 LIKE，使匹配根据当前区域设置忽略大小写。这不属于 SQL 标准，而是 PostgreSQL 的扩展。

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

在 PostgreSQL 语法中，LIKE、ILIKE、NOT LIKE 和 NOT ILIKE 通常被当作操作符；例如，它们可以用于 expression operator ANY (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 正则表达式模式的子字符串。该函数可以按照标准 SQL 语法书写：

substring(string similar pattern escape escape-character)

也可以使用现已过时的 SQL:1999 语法：

substring(string from pattern for escape-character)

或写成普通的三参数函数：

substring(string, pattern, escape-character)

与 SIMILAR TO 一样，指定的模式必须匹配整个数据字符串，否则函数失败并返回空值。为了指明要提取的子字符串所对应的模式部分，模式中应包含两个分隔符，每个分隔符都由转义字符后跟双引号（"）组成。匹配成功时，返回与这两个分隔符之间的模式部分匹配的文本。

转义双引号分隔符实际上会把 substring 的模式分成三个彼此独立的正则表达式；例如，在这三个部分中的任何一个部分里，竖线（|）都只影响该部分。此外，在数据字符串与各模式的匹配边界存在歧义时，第一和第三个正则表达式被定义为匹配尽可能少的文本，而不是尽可能多的文本。（按 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 — 点号匹配任意单个字符
'abcd' ~ 'a.*d'   true — * 重复前一个模式项
'abcd' ~ '(b|x)'  true — | 表示 OR，圆括号用于分组
'abcd' ~ '^a'     true — ^ 锚定到字符串开头
'abcd' ~ '^(b|c)' false — 如果没有这个锚定本来会匹配

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 函数返回 POSIX 正则表达式模式在字符串中第 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 函数返回一个 text 数组，包含字符串首次匹配 POSIX 正则表达式模式时匹配的子字符串。它的语法为 regexp_match(string, pattern [, flags ])。如果没有匹配，结果为 NULL。如果找到匹配，并且 pattern 不包含圆括号子表达式，则结果是包含与整个模式匹配的子字符串的单元素 text 数组。如果找到匹配，并且 pattern 包含圆括号子表达式，则结果是一个 text 数组，其中第 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 函数返回一个 text 数组的集合，其中包含与 POSIX 正则表达式模式匹配的子字符串。它具有与 regexp_match 相同的语法。如果没有匹配，则此函数不返回任何行；如果有匹配且未给出 g 标志，则返回一行；如果有 N 个匹配且给出 g 标志，则返回 N 行。每个返回的行都是一个 text 数组，其中包含整个匹配的子字符串或与 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。如果有匹配，则返回将匹配的子字符串替换为 replacement 后的 source。replacement 字符串可以包含\n，其中 n 为 1 至 9，表示插入与模式中第 n 个圆括号子表达式匹配的源子字符串；也可以包含\&，表示插入与整个模式匹配的子字符串。要在替换文本中放入字面的反斜线，应写成\\。在 string 中搜索 pattern 时，通常从字符串开头开始；如果提供了 start 参数，则从该字符索引开始。默认只替换模式的第一个匹配项。如果指定了 N 且其值大于零，则替换模式的第 N 个匹配项。如果给出 g 标志，或指定了 N 且其值为零，则替换 start 位置及其后的所有匹配项。（指定 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)

正如最后一个示例所示，正则表达式分割函数会忽略出现在字符串开头或结尾或紧跟在前一个匹配项之后的零长度匹配。这与其他正则表达式函数实现的严格的正则表达式匹配定义相矛盾，但在实践中通常是最方便的行为。其他软件系统如 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)
                                    town zip
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+)(.*)');
结果：{abc0123,4,xyz}

SELECT regexp_match('abc01234xyz', '(.*?)(\d+)(.*)');
结果：{abc,0,""}

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