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模式匹配支持非确定性排序规则（见第 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为真，因为可以将.foo.划分为.f, o, o.，然后'.f' = 'f' COLLATE ign_punct，'o'匹配_通配符，'o.' = 'o' COLLATE ign_punct。但是'.foo.' LIKE '_oo' COLLATE ign_punct为假，因为.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操作符根据其模式是否匹配给定字符串而返回真或假。 它与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 — 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 正则表达式模式的子串的方法。如果没有匹配它返回空值，否则就是匹配模式的文本中的第一部分。但是如果该模式包含任何圆括号，那么将返回匹配第一对子表达式（对应第一个左圆括号的）的文本。如果你想在表达式里使用圆括号而又不想导致这个例外，那么你可以在整个表达式外边放上一对圆括号。如果你需要在想抽取的子表达式前有圆括号，参阅后文描述的非捕获性圆括号。

一些例子：

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函数返回字符串中第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(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的元素是匹配 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(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})');
结果：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}