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

如果 string 匹配提供的 pattern，则 LIKE 表达式返回 true。（正如预期的那样，如果 LIKE 返回 true，则 NOT LIKE 表达式返回 false，反之亦然。等效表达式为 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 等转换为这些运算符。

短语 LIKE、ILIKE、NOT LIKE 和 NOT ILIKE 通常在 PostgreSQL 语法中被视为运算符；例如，它们可用于 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 一样，指定模式必须与整个数据字符串匹配，否则函数将失败并返回 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 必须为一，并且该函数返回匹配项后一个字符的位置。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'th 元素是与 pattern 的 n'th 带括号的子表达式匹配的子字符串（不计入 “非捕获” 括号；有关详细信息，请参见下文）。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;

The regexp_replace function provides substitution of new text for substrings that match POSIX regular expression patterns. It has the syntax regexp_replace(source, pattern, replacement [, start [, N ]] [, flags ]). (Notice that N cannot be specified unless start is, but flags can be given in any case.) The source string is returned unchanged if there is no match to the pattern. If there is a match, the source string is returned with the replacement string substituted for the matching substring. The replacement string can contain \n, where n is 1 through 9, to indicate that the source substring matching the n'th parenthesized subexpression of the pattern should be inserted, and it can contain \& to indicate that the substring matching the entire pattern should be inserted. Write \\ if you need to put a literal backslash in the replacement text. pattern is searched for in string, normally from the beginning of the string, but if the start parameter is provided then beginning from that character index. By default, only the first match of the pattern is replaced. If N is specified and is greater than zero, then the N'th match of the pattern is replaced. If the g flag is given, or if N is specified and is zero, then all matches at or after the start position are replaced. (The g flag is ignored when N is specified.) The flags parameter is an optional text string containing zero or more single-letter flags that change the function's behavior. Supported flags (though not g) are described in Table 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 ]]]]). 通常从字符串开头在 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}