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 模式匹配支持非确定性排序规则（请参阅 第 23.2.2.4 节），例如不区分大小写的排序规则或忽略标点符号的排序规则。因此，使用不区分大小写的排序规则，可以实现

'AbC' LIKE 'abc' COLLATE case_insensitive    true
'AbC' LIKE 'a%' COLLATE case_insensitive     true

对于忽略某些字符或总体上认为不同长度的字符串相等的排序规则，语义可能会变得稍微复杂一些。请考虑以下示例

'.foo.' LIKE 'foo' COLLATE ign_punct    true
'.foo.' LIKE 'f_o' COLLATE ign_punct    true
'.foo.' LIKE '_oo' COLLATE ign_punct    false

匹配工作方式是将模式划分为通配符序列和非通配符字符串（通配符是 _ 和 %）。例如，模式 f_o 被划分为 f, _, o，模式 _oo 被划分为 _, oo。当输入字符串可以这样划分，使得通配符分别匹配一个字符或任意数量的字符，并且非通配符部分在适用的排序规则下相等时，输入字符串就匹配该模式。所以例如，'.foo.' LIKE 'f_o' COLLATE ign_punct 为 true，因为 .foo. 可以划分为 .f, o, o.，然后 '.f' = 'f' COLLATE ign_punct，'o' 匹配 _ 通配符，并且 'o.' = 'o' COLLATE ign_punct。但是 '.foo.' LIKE '_oo' COLLATE ign_punct 为 false，因为 .foo. 不能以第一字符是任何字符且字符串的其余部分与 oo 相等的方式进行划分。（请注意，单字符通配符始终匹配正好一个字符，与排序规则无关。所以在这个例子中，_ 会匹配 .，但字符串的其余部分将与模式的其余部分不匹配。）

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 操作符返回 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 ]])。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 ]]]]]).pattern 在 string 中搜索，通常从字符串开头开始，但如果提供了 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(string=>'ABCDEFGHI', pattern=>'(c..)(...)', start=>1, "N"=>1, endoption=>0, flags=>'i', subexpr=>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 个元素是与模式的第 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 行。返回的每一行都是一个文本数组，包含与整个匹配模式或模式的括号子表达式匹配的子字符串，就像上面为 regexp_match 所描述的那样。regexp_matches 接受 表 9.24 中显示的所有标志，再加上 g 标志，该标志命令它返回所有匹配项，而不仅仅是第一个。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(string, pattern, replacement [, flags ]) 或 regexp_replace(string, pattern, replacement, start [, N [, flags ]]). 如果模式 pattern 没有匹配，则源字符串 string 将原样返回。如果存在匹配，则返回 string，并将 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(string=>'A PostgreSQL function', pattern=>'a|e|i|o|u', replacement=>'X', start=>1, "N"=>3, flags=>'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)
                                    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}