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}