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 中的一个下划线 （_） 代表 （匹配） 任何单个字符； 一个百分号 （%） 匹配零个或更多字符的任何序列。

Some examples:

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

LIKE 模式匹配支持非确定性排序规则 （参见 Section 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 正则表达式借用的模式匹配元字符：

Notice that the period (.) is not a metacharacter for SIMILAR TO.

与 LIKE 一样， 反斜杠会关闭这些元字符中任何一个的特殊含义。 可以用 ESCAPE 指定一个不同的转义字符， 或者可以通过写 ESCAPE '' 来禁用转义能力。

按照 SQL 标准， 省略 ESCAPE 意味着没有转义字符 （而不是默认为反斜杠）， 并且不允许零长度的 ESCAPE 值。 因此 PostgreSQL 在这方面的行为略微偏离标准。

另一个非标准的扩展是： 在转义字符后面跟一个字母或数字， 可以访问为 POSIX 正则表达式定义的转义序列； 参见下文的 Table 9.20、 Table 9.21 和 Table 9.22。

Some examples:

'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

Table 9.16 列出了使用 POSIX 正则表达式进行模式匹配的可用操作符。

POSIX 正则表达式提供了比 LIKE 和 SIMILAR TO 操作符更强大的模式匹配手段。 许多 Unix 工具， 例如 egrep、 sed 或 awk， 都使用一种与此处描述的相似的模式匹配语言。

正则表达式是一个字符序列， 它是一组字符串 （一个 正则集） 的缩写式定义。 如果一个字符串是该正则表达式所描述的正则集的成员， 就称它匹配该正则表达式。 与 LIKE 一样， 模式字符精确地匹配字符串字符， 除非它们是正则表达式语言中的特殊字符 — 但正则表达式使用的特殊字符与 LIKE 的不同。 与 LIKE 模式不同， 正则表达式允许匹配字符串内的任何位置， 除非该正则表达式被显式地锚定在字符串的开头或结尾。

Some examples:

'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 正则表达式模式的子串的提取。 如果没有匹配， 它返回空； 否则返回与该模式相匹配的第一部分文本。 但如果模式中包含任何圆括号， 那么返回的是与第一个带圆括号的子表达式 （即左圆括号在最前的那个） 相匹配的那部分文本。 如果你想在表达式中使用圆括号而又不触发这个例外， 可以把整个表达式都放进圆括号里。 如果你需要在模式中、 在想提取的子表达式之前使用圆括号， 请参见下文描述的非捕获圆括号。

Some examples:

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 表示不区分大小写的匹配。 受支持的标志在 Table 9.24 中描述。

Some examples:

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 参数是一个可选的文本字符串， 包含零个或多个改变该函数行为的单字母标志。 受支持的标志在 Table 9.24 中描述。 对于一个包含带圆括号的子表达式的模式， subexpr 是一个整数， 指示哪个子表达式令人感兴趣： 结果标识与那个子表达式相匹配的子串的位置。 子表达式按照它们的前导圆括号的顺序编号。 当省略了 subexpr 或它为零时， 结果标识整个匹配的位置， 而不管带圆括号的子表达式。

Some examples:

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 正则表达式模式的匹配是否出现在一个字符串中， 返回布尔值真或假。 它的语法是 regexp_like(string, pattern [, flags ])。 flags 参数是一个可选的文本字符串， 包含零个或多个改变该函数行为的单字母标志。 受支持的标志在 Table 9.24 中描述。 如果没有指定任何标志， 这个函数的结果与 ~ 操作符相同。 如果只指定了 i 标志， 则结果与 ~* 操作符相同。

Some examples:

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 参数是一个可选的文本字符串， 包含零个或多个改变该函数行为的单字母标志。 受支持的标志在 Table 9.24 中描述。

Some examples:

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 接受 Table 9.24 中展示的所有标志， 外加 g 标志， 它命令该函数返回所有匹配， 而非只是第一个。

Some examples:

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 个带圆括号的子表达式相匹配的源子串； 它还可以包含 \&， 表示应当插入与整个模式相匹配的子串。 如果你需要在替换文本中放入一个字面上的反斜杠， 写 \\。 在 string 中搜索 pattern， 通常从字符串的开头开始， 但如果提供了 start 参数， 则从那个字符索引开始。 默认情况下， 只替换模式的第一次匹配。 如果指定了 N 并且它大于零， 则替换该模式的第 N 次匹配。 如果给出了 g 标志， 或者指定了 N 并且它为零， 则替换 start 位置上及之后的所有匹配。 （当指定了 N 时， g 标志会被忽略。） flags 参数是一个可选的文本字符串， 包含零个或多个改变该函数行为的单字母标志。 受支持的标志 （但不含 g） 在 Table 9.24 中描述。

Some examples:

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 支持 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 的相同。

Some examples:

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 参数是一个可选的文本字符串， 包含零个或多个改变该函数行为的单字母标志。 受支持的标志在 Table 9.24 中描述。 对于一个包含带圆括号的子表达式的模式， subexpr 是一个整数， 指示哪个子表达式令人感兴趣： 结果是与那个子表达式相匹配的子串。 子表达式按照它们的前导圆括号的顺序编号。 当省略了 subexpr 或它为零时， 结果是整个匹配， 而不管带圆括号的子表达式。

Some examples:

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}