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

LIKE 表达式如果 字符串 匹配提供的 模式，则返回 true。（正如预期的那样，NOT LIKE 表达式如果 LIKE 返回 true，则返回 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 个带括号的子表达式匹配的源子字符串，并且可以包含 \&，表示应插入与整个模式匹配的子字符串。如果您需要在替换文本中添加一个字面反斜杠，请编写 \\。 通常情况下，从字符串的开头开始在 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)

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

函数 regexp_substr 返回与 POSIX 正则表达式模式匹配的子字符串，如果未匹配，则返回 NULL。其语法为 regexp_substr(string, pattern [, start [, N [, flags [, subexpr ]]]]). 通常情况下，从字符串的开头开始在 string 中搜索 pattern，但如果提供了 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}