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

如果字符串与提供的模式匹配，则 LIKE 表达式返回 true。（正如预期的那样，如果 LIKE 返回 true，则 NOT LIKE 表达式返回 false，反之亦然。等效表达式是 NOT (字符串 LIKE 模式)。）

如果模式不包含百分号或下划线，则该模式仅表示字符串本身；在这种情况下，LIKE 的作用类似于等于操作符。 模式中的下划线 (_) 代表（匹配）任何单个字符；百分号 (%) 匹配零个或多个字符的任何序列。

一些例子

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

LIKE 模式匹配始终覆盖整个字符串。因此，如果希望匹配字符串中任何位置的序列，则模式必须以百分号开头和结尾。

要匹配文字下划线或百分号而不匹配其他字符，则必须在模式中的相应字符前面加上转义字符。默认的转义字符是反斜杠，但可以使用 ESCAPE 子句选择不同的转义字符。要匹配转义字符本身，请写入两个转义字符。

也可以通过写入 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 语法中被视为操作符；例如，它们可以在 表达式 操作符 ANY (子查询) 构造中使用，尽管不能在那里包含 ESCAPE 子句。在某些晦涩的情况下，可能需要使用底层操作符名称。

另请参阅以开头操作符 ^@ 和相应的 starts_with() 函数，它们在只需要匹配字符串开头的情况下很有用。

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

SIMILAR TO 操作符返回 true 或 false，具体取决于其模式是否与给定的字符串匹配。它类似于 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 一样，指定的模式必须匹配整个数据字符串，否则函数会失败并返回 null。要指示模式中匹配的数据子字符串所关注的部分，该模式应包含两个转义字符后跟双引号 (")。当匹配成功时，将返回匹配这些分隔符之间模式部分的文本。

转义双引号分隔符实际上将 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 — 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 正则表达式模式匹配的子字符串的提取。如果没有匹配项，则返回 null，否则返回与模式匹配的文本的第一部分。但是，如果模式包含任何括号，则返回与第一个带括号的子表达式（左括号最先出现的那个）匹配的文本部分。如果您想在表达式中使用括号而不触发此异常，则可以将括号放在整个表达式周围。如果您需要在要提取的子表达式之前的模式中使用括号，请参阅下面描述的非捕获括号。

一些例子

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

regexp_count 函数计算 POSIX 正则表达式模式与字符串匹配的位置数。它的语法为 regexp_count(string, pattern [, start [, flags ]])。在 string 中搜索 pattern，通常从字符串的开头开始，但如果提供了 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 参数或指定为零，则函数返回匹配的第一个字符的位置。否则，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 字符串替换。replacement 字符串可以包含 \n，其中 n 是 1 到 9，表示应该插入与模式的第 n 个带括号的子表达式匹配的源子字符串，并且可以包含 \& 表示应该插入与整个模式匹配的子字符串。如果需要在替换文本中放入字面反斜杠，请写 \\。pattern 在 string 中搜索，通常从字符串的开头开始，但如果提供了 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)

正如最后一个示例所示，regexp split 函数会忽略出现在字符串开头或结尾或紧接在前一个匹配项之后的零长度匹配项。这与由其他 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)
                                    town zip
regexp_substr('ABCDEFGHI', '(c..)(...)', 1, 1, 'i', 2)
                                   FGH

SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
Result: 123
SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
Result: 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}