字符串函数和操作符
更新时间：2026-06-25
字符串函数和操作符
格式检查及操作函数
本节描述了用于检查和操作字符串值的函数和操作符。在这个环境中的串包括所有类型character、character varying和text的值。除非另外说明，所有下面列出的函数都可以处理这些类型，不过要小心的是，在使用character类型的时候，它有自动填充空白的潜在影响。有些函数还可以处理位串类型。
SQL定义了一些字符串函数，它们使用关键字，而不是逗号来分隔参数。详情请见 SQL字符串函数和操作符，PalopgSQL也提供了这些函数使用正常函数调用语法的版本（见 其他字符串函数）。
注意
- 字符串串接操作符（
||）接受非字符串输入，只要至少一个输入是一种字符串类型，如SQL字符串函数和操作符所示。对于其他情况，可以为text插入一个显式强制转换。
||
语法
string || string, string || non-string/non-string || string
返回类型 : text
描述
字符串拼接或字符串与非字符串拼接
示例
SQL
1 palopgsql=# select 'Palopg' || 'SQL';
2 ?column?
3 -----------
4 PalopgSQL
5 (1 row)
6
7 palopgsql=# select 'Value: ' || 42;
8 ?column?
9 -----------
10 Value: 42
11 (1 row)
12 ```
13
14
15##### `bit_length()`
16
17## 语法
18
19bit_length(*`string`*)
20
21返回类型
22: int
23
24## 描述
25
26串中的位数
27
28## 示例
29
30注意中文长度
31
32 ``` sql
33 palopgsql=# select bit_length('jose');
34 bit_length
35 ------------
36 32
37 (1 row)
38 palopgsql=# select bit_length('Palo');
39 bit_length
40 ------------
41 48
42 (1 row)
43 ```
44
45##### `char_length()/character_length()`
46
47## 语法
48
49`char_length(string)`/`character_length(string)`
50
51返回类型
52: int
53
54## 描述
55
56字符长度
57
58## 示例
59
60注意中文长度
61
62 ``` sql
63 palopgsql=# select char_length('jose');
64 char_length
65 -------------
66 4
67 (1 row)
68
69 palopgsql=# select char_length('Palo');
70 char_length
71 -------------
72 2
73 (1 row)
74 ```
75
76
77
78##### `lower()`
79
80## 语法
81
82`lower(string)`
83
84返回类型
85: text
86
87## 描述
88
89将字符串转换为小写形式
90
91## 示例
92
93``` sql
94 palopgsql=# select lower('TOM');
95 lower
96 -------
97 tom
98 (1 row)
99 ```
100
101
102##### `octet_length()`
103
104## 语法
105
106`octet_length(string)`
107
108返回类型
109: int
110
111## 描述
112
113串中的字节数
114
115## 示例
116
117注意中文长度
118
119 ``` sql
120 palopgsql=# select octet_length('jose');
121 octet_length
122 --------------
123 4
124 (1 row)
125
126 palopgsql=# select octet_length('Palo');
127 octet_length
128 --------------
129 6
130 (1 row)
131 ```
132
133##### overlay
134
135## 语法
136
137`overlay(string placing string from int [for int])`
138
139返回类型
140: text
141
142## 描述
143
144替换子串, 第一个参数为被替换的对象字符串；第二个参数为使用替换的子字符串；第三个参数为被替换字符串中的起始替换位置；第四个参数为被替换掉的子串长度，如未指定则长度与参数2子字符串一致。
145
146## 示例
147
148``` sql
149 palopgsql=# select overlay('Txxxxas' placing 'hom' from 2 for 4);
150 overlay
151 ---------
152 Thomas
153 (1 row)
154
155 palopgsql=# select overlay('Txxxxas' placing 'hom' from 2 );
156 overlay
157 ---------
158 Thomxas
159 (1 row)
160 ```
161
162
163##### `position()`
164
165## 语法
166
167`position(substring in string)`
168
169返回类型
170: int
171
172## 描述
173
174定位指定子串的起始位置
175
176## 示例
177
178``` sql
179 palopgsql=# select position('om' in 'Thomas');
180 position
181 ----------
182 3
183 (1 row)
184 ```
185
186
187##### `substring()`
188
189## 语法
190
191``` sql
192 substring(string [from int] [for int])
193 substring(string from pattern)
194 substring(string from pattern for escap)
195 ```
196
197返回类型
198: text
199
200## 描述
201
202提取子串，第一种语法为指定起始位置及长度截取； 第二种语法为使用POSIX正则表达式匹配截取 ； 第三种语法为使用SQL正则表达式截取匹配子串
203
204## 示例
205
206``` sql
207 palopgsql=# select substring('Thomas' from 2 for 3);
208 substring
209 -----------
210 hom
211 (1 row)
212
213 palopgsql=# select substring('Thomas' from '...$');
214 substring
215 -----------
216 mas
217 (1 row)
218
219 palopgsql=# select substring('Thomas' from '%#"o_a#"_' for '#');
220 substring
221 -----------
222 oma
223 (1 row)
224 ```
225
226
227##### `trim()`
228
229## 语法
230
231`trim([leading | trailing | both] [*`characters`*] from string)`, `trim([leading \| trailing \| both] [from] *`string`* [, *`characters`*])`
232
233返回类型
234: text
235
236## 描述
237
238从*string的开头、结尾或者两端（both是默认值）移除只包含characters*（默认是一个空格）中字符的最长字符串; 第二种语法为非标准用法
239
240## 示例
241
242``` sql
243 palopgsql=# select trim(both 'xyz' from 'yxTomxx');
244 btrim
245 -------
246 Tom
247 (1 row)
248
249 palopgsql=# select trim(both from 'xTomxx', 'x');
250 btrim
251 -------
252 Tom
253 (1 row)
254 ```
255
256
257##### `upper()`
258
259## 语法
260
261upper(*`string`*)
262
263返回类型
264: text
265
266## 描述
267
268将字符串转换成大写形式
269
270## 示例
271
272``` sql
273 palopgsql=# select upper('tom');
274 upper
275 -------
276 TOM
277 (1 row)
278 ```
279
280
281
282
283#### 其他字符串函数
284
285还有额外的串操作函数可以用，它们在下面其他字符串函数中列出。它们有些在内部用于实现SQL字符串函数和操作符列出的SQL标准字符串函数。
286
287##### `ascii()`
288
289## 语法
290
291ascii(*`string`*)
292
293返回类型
294: int
295
296## 描述
297
298参数第一个字符的ASCII代码。对于UTF8返回该字符的Unicode代码点。对于其他多字节编码，该参数必须是一个ASCII字符。
299
300## 示例
301
302``` sql
303 palopgsql=# select ascii('x');
304 ascii
305 -------
306 120
307 (1 row)
308 ```
309
310
311##### `btrim()`
312
313## 语法
314
315`btrim(*`string`* text [, *`characters`* text])`
316
317返回类型
318: text
319
320## 描述
321
322从 *`string`* 的开头或结尾删除最长的只包含 *`characters`*（默认是一个空格）的串
323
324## 示例
325
326``` sql
327 palopgsql=# select btrim('xyxtrimyyx', 'xyz');
328 btrim
329 -------
330 trim
331 (1 row)
332 ```
333
334##### `chr()`
335
336## 语法
337
338`chr(int)`
339
340返回类型
341: text
342
343## 描述
344
345给定代码的字符。对于UTF8该参数被视作一个Unicode代码点。对于其他多字节编码该参数必须指定一个ASCII字符。NULL (0) 字符不被允许，因为文本数据类型不能存储这种字节。
346
347## 示例
348
349``` sql
350 palopgsql=# select chr(65);
351 chr
352 -----
353 A
354 (1 row)
355 ```
356
357
358##### `concat()`
359
360## 语法
361
362`concat(*`str`* "any" [, *`str`* "any" [, ...] ])`
363
364返回类型
365: text
366
367## 描述
368
369串接所有参数的文本表示。NULL 参数被忽略。
370
371## 示例
372
373``` sql
374 palopgsql=# select concat('abcde', 2, NULL, 22);
375 concat
376 ----------
377 abcde222
378 (1 row)
379 ```
380
381
382
383##### `concat_ws()`
384
385## 语法
386
387`concat_ws(*`sep`* text, *`str`* "any" [, *`str`* "any" [, ...] ])`
388
389返回类型
390: text
391
392## 描述
393
394将除了第一个参数外的其他参数用分隔符串接在一起。第一个参数被用作分隔符字符串。NULL 参数被忽略。
395
396## 示例
397
398``` sql
399 palopgsql=# select concat_ws(',', 'abcde', 2, NULL, 22);
400 concat_ws
401 ------------
402 abcde,2,22
403 (1 row)
404 ```
405
406
407##### `convert()`
408
409## 语法
410
411convert(*`string`* bytea, *`src_encoding`* name,*`dest_encoding`* name)
412
413返回类型
414: bytea
415
416## 描述
417
418将字符串转换为 *`dest_encoding`* 。原始编码由 *`src_encoding`* 指定。*`string`* 在这个编码中必须可用。转换可以使用CREATE CONVERSION定义。也有一些预定义的转换。
419
420## 示例
421
422``` sql
423 palopgsql=# select convert('text_in_utf8', 'UTF8', 'LATIN1');
424 convert
425 ----------------------------
426 \x746578745f696e5f75746638
427 (1 row)
428 ```
429
430
431##### `convert_from()`
432
433## 语法
434
435convert_from(*`string`* bytea, *`src_encoding`* name)
436
437返回类型
438: text
439
440## 描述
441
442将字符串转换为数据库编码。原始编码由 *`src_encoding`*指定。*`string`* 在这个编码中必须可用。
443
444## 示例
445
446``` sql
447 palopgsql=# select convert_from('text_in_utf8', 'UTF8');
448 convert_from
449 --------------
450 text_in_utf8
451 (1 row)
452 ```
453
454
455##### convert_to
456
457## 语法
458
459convert_to(*`string`* text, *`dest_encoding`* name)
460
461返回类型
462: bytea
463
464## 描述
465
466将字符串转换为 *`dest_encoding`* 。
467
468## 示例
469
470``` sql
471 palopgsql=# select convert_to('some text', 'UTF8');
472 convert_to
473 ----------------------
474 \x736f6d652074657874
475 (1 row)
476 ```
477
478
479##### `decode()`
480
481## 语法
482
483decode(*`string`* text, *`format`* text)
484
485返回类型
486: bytea
487
488## 描述
489
490从 *`string`* 中的文本表达解码二进制数据。 *`format`* 的选项和 *`encode`* 中的一样。
491
492## 示例
493
494``` sql
495 palopgsql=# select decode('MTIzAAE=', 'base64');
496 decode
497 --------------
498 \x3132330001
499 (1 row)
500 ```
501
502
503##### `encode()`
504
505## 语法
506
507encode(*`data`* bytea, *`format`* text)
508
509返回类型
510: text
511
512## 描述
513
514将二进制数据编码成一个文本表达。支持的格式有：base64、hex、escape。escape将零字节和高位组字节转换为八进制序列（`\nnn` ）和双写的反斜线。
515
516## 示例
517
518``` sql
519 palopgsql=# select encode('123\000\001', 'base64');
520 encode
521 ----------
522 MTIzAAE=
523 (1 row)
524 ```
525
526
527##### `format()`
528
529## 语法
530
531`format(formatstr text [, formatarg "any" [, ...] ])`
532
533返回类型
534: text
535
536## 描述
537
538根据一个格式字符串格式化参数。该函数和C函数sprintf相似。
539
540 *`formatstr`*是一个格式字符串，它指定了结果应该如何被格式化。格式字符串中的文本被直接复制到结果中，除了使用*格式说明符*的地方。格式说明符在字符串中扮演着占位符的角色，它定义后续的函数参数如何被格式化及插入到结果中。每一个 *`formatarg`* 参数会被根据其数据类型的常规输出规则转换为文本，并接着根据格式说明符被格式化和插入到结果字符串中。
541
542 格式说明符由一个`%`字符开始并且有这样的形式
543
544 ``` c
545 %[position][flags][width]type
546 ```
547 其中的各组件域是：
548
549
550 `position`（可选）
551 : 一个形式为`n`$的字符串，其中 *`n`* 是要打印的参数的索引。索引 1 表示 *`formatstr`* 之后的第一个参数。如果 *`position`* 被忽略，默认会使用序列中的下一个参数。
552
553 `flags`（可选）
554 : 控制格式说明符的输出如何被格式化的附加选项。当前唯一支持的标志是一个负号（`-`），它将导致格式说明符的输出会被左对齐（left-justified）。除非 *`width`* 域也被指定，否者这个域不会产生任何效果。
555
556 `width`（可选）
557 : 指定用于显示格式说明符输出的*最小*字符数。输出将被在左部或右部（取决于`-`标志）用空格填充以保证充满该宽度。太小的宽度设置不会导致输出被截断，但是会被简单地忽略。宽度可以使用下列形式之一指定：一个正整数；一个星号（`*`）表示使用下一个函数参数作为宽度；或者一个形式为`*n`$的字符串表示使用第 *`n`* 个函数参数作为宽度。
558
559 如果宽度来自于一个函数参数，则参数在被格式说明符的值使用之前就被消耗掉了。如果宽度参数是负值，结果会在长度为`abs`(*`width`*)的域中被左对齐（如果`-`标志被指定）。
560
561 `type`（必需）
562 : 格式转换的类型，用于产生格式说明符的输出。支持下面的类型：
563
564 `s`
565 : 将参数值格式化为一个简单字符串。一个控制被视为一个空字符串。
566
567 `I`
568 : 将参数值视作 SQL标识符，并在必要时用双写引号包围它。如果参数为空，将会是一个错误（等效于`quote_ident`）。
569
570 `L`
571 : 将参数值引用为 SQL 文字。一个空值将被显示为不带引号的字符串`NULL`（等效于`quote_nullable`）。
572
573
574
575 除了以上所述的格式说明符之外，要输出一个文字形式的`%`字符，可以使用特殊序列`%%`。
576
577
578## 示例
579
580``` sql
581 palopgsql=# select format('Hello %s, %1$s', 'World');
582 format
583 --------------------
584 Hello World, World
585 (1 row)
586
587 palopgsql=# SELECT format('Hello %s', 'World');
588 format
589 -------------
590 Hello World
591 (1 row)
592
593 palopgsql=# SELECT format('Testing %s, %s, %s, %%', 'one', 'two', 'three');
594 format
595 ----------------------------
596 Testing one, two, three, %
597 (1 row)
598
599 palopgsql=# SELECT format('INSERT INTO %I VALUES(%L)', 'Foo bar', E'O\'Reilly');
600 format
601 -------------------------------------------
602 INSERT INTO "Foo bar" VALUES('O''Reilly')
603 (1 row)
604
605 palopgsql=# SELECT format('INSERT INTO %I VALUES(%L)', 'locations', 'C:\Program Files');
606 format
607 ----------------------------------------------------
608 INSERT INTO locations VALUES(E'C:\\Program Files')
609 (1 row)
610
611 -- 使用 *`width`* 域和`-`标志的例子：
612 palopgsql=# SELECT format('|%10s|', 'foo');
613 format
614 --------------
615 | foo|
616 (1 row)
617
618 palopgsql=# SELECT format('|%-10s|', 'foo');
619 format
620 --------------
621 |foo |
622 (1 row)
623
624 palopgsql=# SELECT format('|%*s|', 10, 'foo');
625 format
626 --------------
627 | foo|
628 (1 row)
629
630 palopgsql=# SELECT format('|%*s|', -10, 'foo');
631 format
632 --------------
633 |foo |
634 (1 row)
635
636 palopgsql=# SELECT format('|%-*s|', 10, 'foo');
637 format
638 --------------
639 |foo |
640 (1 row)
641
642 palopgsql=# SELECT format('|%-*s|', -10, 'foo');
643 format
644 --------------
645 |foo |
646 (1 row)
647
648 -- 使用position域的例子：
649 palopgsql=# SELECT format('Testing %3$s, %2$s, %1$s', 'one', 'two', 'three');
650 format
651 -------------------------
652 Testing three, two, one
653 (1 row)
654
655 palopgsql=# SELECT format('|%*2$s|', 'foo', 10, 'bar');
656 format
657 --------------
658 | bar|
659 (1 row)
660
661 palopgsql=# SELECT format('|%1$*2$s|', 'foo', 10, 'bar');
662 format
663 --------------
664 | foo|
665 (1 row)
666
667 -- format函数不要求所有函数参数都被用在格式字符串中。
668 palopgsql=# SELECT format('Testing %3$s, %2$s, %s', 'one', 'two', 'three');
669 format
670 ---------------------------
671 Testing three, two, three
672 (1 row)
673 ```
674
675
676
677##### `initcap()`
678
679## 语法
680
681initcap(*`string`*)
682
683返回类型
684: text
685
686## 描述
687
688将每一个词的第一个字母转换为大写形式并把剩下的字母转换为小写形式。词是由非字母数字字符分隔的字母数字字符的序列。
689
690## 示例
691
692``` sql
693 palopgsql=# select initcap('hi THOMAS');
694 initcap
695 -----------
696 Hi Thomas
697 (1 row)
698 ```
699
700##### `left()`
701
702## 语法
703
704left(*`str`* text, *`n`* int)
705
706返回类型
707: text
708
709## 描述
710
711返回字符串中的前 *`n`* 个字符。当 *`n`* 为负时，将返回除了最后| *`n`* |个字符之外的所有字符。
712
713## 示例
714
715``` sql
716 palopgsql=# select left('abcde', 2);
717 left
718 ------
719 ab
720 (1 row)
721 ```
722
723
724##### `length()`
725
726## 语法
727
728length(*`string`*);length(*`string`* bytea, *`encoding`* name )
729
730返回类型
731: int
732
733## 描述
734
735*`string`* 中的字符数; 参数为2个时，返回*`string`* 在给定*编码*中的字符数，*`string`* 必须在这个编码中有效。
736
737## 示例
738
739``` sql
740 palopgsql=# select length('jose');
741 length
742 --------
743 4
744 (1 row)
745
746 palopgsql=# select length('Palo');
747 length
748 --------
749 2
750 (1 row)
751
752 palopgsql=# select length('jose', 'UTF8');
753 length
754 --------
755 4
756 (1 row)
757
758 palopgsql=# select length('Palo', 'UTF8');
759 length
760 --------
761 2
762 (1 row)
763 ```
764
765
766##### `lpad()`
767
768## 语法
769
770lpad(*`string`* text, *`length`* int [, *`fil`8l text])
771
772返回类型
773: text
774
775## 描述
776
777将 *`string`* 通过前置字符 *`fill`*（默认是一个空格）填充到长度 *`length`* 。如果 *`string`* 已经长于 *`length`* ，则它被（从右边）截断。
778
779## 示例
780
781``` sql
782 palopgsql=# select lpad('hi', 5, 'xy');
783 lpad
784 -------
785 xyxhi
786 (1 row)
787 ```
788
789
790##### `ltrim()`
791
792## 语法
793
794ltrim( *`string`* text [, *`characters`* text])
795
796返回类型
797: text
798
799## 描述
800
801从 *`string`* 的开头删除最长的只包含 *`characters`*（默认是一个空格）的串
802
803## 示例
804
805``` sql
806 palopgsql=# select ltrim('zzzytest', 'xyz');
807 ltrim
808 -------
809 test
810 (1 row)
811 ```
812
813
814##### `md5()`
815
816## 语法
817
818md5(*`string`*)
819
820返回类型
821: text
822
823## 描述
824
825计算 *`string`* 的 MD5 哈希，返回十六进制的结果
826
827## 示例
828
829``` sql
830 palopgsql=# select md5('abc');
831 md5
832 ----------------------------------
833 900150983cd24fb0d6963f7d28e17f72
834 (1 row)
835 ```
836
837##### `parse_ident()`
838
839## 语法
840
841parse_ident(*`qualified_identifier`* text [,*`strictmode`* boolean DEFAULT true ] )
842
843返回类型
844: text[]
845
846## 描述
847
848把 *`qualified_identifier`* 分成一个标识符数组，移除单个标识符上的任何引号。默认情况下，最后一个标识符后面的多余字符会被当做错误。但是如果第二个参数为false，那么这一类多余的字符会被忽略（这种行为对于解析函数之类的对象名称有用）。注意这个函数不会截断超长标识符。如果想要进行截断，可以把结果转换成name[]。
849
850## 示例
851
852``` sql
853 palopgsql=# select parse_ident('"SomeSchema".someTable');
854 parse_ident
855 ------------------------
856 {SomeSchema,sometable}
857 (1 row)
858 ```
859
860
861##### `pg_client_encoding()`
862
863## 语法
864
865pg_client_encoding()
866
867返回类型
868: `name`
869
870## 描述
871
872当前的客户端编码名字
873
874## 示例
875
876``` sql
877 palopgsql=# select pg_client_encoding();
878 pg_client_encoding
879 --------------------
880 UTF8
881 (1 row)
882 ```
883
884
885##### `quote_ident()`
886
887## 语法
888
889quote_ident( *`string`* text)
890
891返回类型
892: `text`
893
894## 描述
895
896将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个标识符。只有需要时才会加上引号（即，如果字符串包含非标识符字符或可能是大小写折叠的）。嵌入的引号会被正确地双写。
897
898## 示例
899
900``` sql
901 palopgsql=# select quote_ident('Foo bar');
902 quote_ident
903 -------------
904 "Foo bar"
905 (1 row)
906 ```
907
908
909
910##### `quote_literal()`
911
912## 语法
913
914quote_literal(*`string`* text), quote_literal(*`value`* anyelement)
915
916返回类型
917: `text`
918
919## 描述
920
921将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个字符串文字。嵌入的引号会被正确地双写。注意quote_literal对空输入返回空；如果参数可能为空，quote_nullable通常更合适。当参数为其他类型时，强迫给定值为文本并且接着将它用引号包围作为一个文本。嵌入的单引号和反斜线被正确的双写。
922
923## 示例
924
925``` sql
926 palopgsql=# select quote_literal(E'O\'Reilly');
927 quote_literal
928 ---------------
929 'O''Reilly'
930 (1 row)
931
932 palopgsql=# select quote_literal(42.5);
933 quote_literal
934 ---------------
935 '42.5'
936 (1 row)
937 ```
938
939
940##### `quote_nullable()`
941
942## 语法
943
944quote_nullable(*`string`* text), quote_nullable(*`value`* anyelement)
945
946返回类型
947: `text`
948
949## 描述
950
951将给定字符串返回成合适的引用形式，使它可以在一个SQL语句字符串中被用作一个字符串文字；或者，如果参数为空，返回NULL。嵌入的引号会被正确地双写; 参数类型为其他数据类型时，强迫给定值为文本并且接着将它用引号包围作为一个文本；或者，如果参数为空，返回NULL。嵌入的单引号和反斜线被正确的双写。
952
953## 示例
954
955``` sql
956 palopgsql=# select quote_nullable(NULL);
957 quote_nullable
958 ----------------
959 NULL
960 (1 row)
961
962 palopgsql=# select quote_nullable(42.5);
963 quote_nullable
964 ----------------
965 '42.5'
966 (1 row)
967 ```
968
969
970##### `regexp_match()`
971
972## 语法
973
974regexp_match(*`string`* text, *`pattern`* text [,*`flags`* text])
975
976返回类型
977: `text[]`
978
979## 描述
980
981返回一个POSIX正则表达式与 *`string`* 的第一个匹配得到的子串。
982
983## 示例
984
985``` sql
986 palopgsql=# select regexp_match('foobarbequebaz', '(bar)(beque)');
987 regexp_match
988 --------------
989 {bar,beque}
990 (1 row)
991 ```
992
993
994##### `regexp_matches()`
995
996## 语法
997
998regexp_matches(*`string`* text, *`pattern`* text [,*`flags`* text])
999
1000返回类型
1001: `setof text[]`
1002
1003## 描述
1004
1005返回一个POSIX正则表达式与*`string`*匹配得到的子串。
1006
1007## 示例
1008
1009``` sql
1010 palopgsql=# select regexp_matches('foobarbequebaz', 'ba.', 'g');
1011 regexp_matches
1012 ----------------
1013 {bar}
1014 {baz}
1015 (2 rows)
1016 ```
1017
1018##### `regexp_replace()`
1019
1020## 语法
1021
1022regexp_replace(*`string`* text, *`pattern`* text [,*`flags`* text])
1023
1024返回类型
1025: `text`
1026
1027## 描述
1028
1029替换匹配一个POSIX正则表达式的子串。
1030
1031## 示例
1032
1033``` sql
1034 palopgsql=# select regexp_replace('Thomas', '.[mN]a.', 'M');
1035 regexp_replace
1036 ----------------
1037 ThM
1038 (1 row)
1039 ```
1040
1041##### `regexp_split_to_array()`
1042
1043## 语法
1044
1045regexp_split_to_array(*`string`* text, *`pattern`* text [,*`flags`* text])
1046
1047返回类型
1048: `text[]`
1049
1050## 描述
1051
1052使用一个POSIX正则表达式作为分隔符划分 *`string`* 。
1053
1054## 示例
1055
1056``` sql
1057 palopgsql=# select regexp_split_to_array('hello world', '\s+');
1058 regexp_split_to_array
1059 -----------------------
1060 {hello,world}
1061 (1 row)
1062 ```
1063
1064
1065
1066##### `regexp_split_to_table()`
1067
1068## 语法
1069
1070regexp_split_to_table(*`string`* text, *`pattern`* text [,*`flags`* text])
1071
1072返回类型
1073: `setof text `
1074
1075## 描述
1076
1077使用一个POSIX正则表达式作为分隔符划分 *`string`*。
1078
1079## 示例
1080
1081``` sql
1082 palopgsql=# select regexp_split_to_table('hello world', '\s+');
1083 regexp_split_to_table
1084 -----------------------
1085 hello
1086 world
1087 (2 rows)
1088 ```
1089
1090
1091##### `repeat()`
1092
1093## 语法
1094
1095repeat(*`string`* text, *`number`* int)
1096
1097返回类型
1098: `text`
1099
1100## 描述
1101
1102重复 *`string`* 指定的 *`number`* 次
1103
1104## 示例
1105
1106``` sql
1107 palopgsql=# select repeat('palopg', 4);
1108 repeat
1109 --------------------------
1110 palopgpalopgpalopgpalopg
1111 (1 row)
1112 ```
1113
1114
1115##### `replace()`
1116
1117## 语法
1118
1119replace(*`string`* text, *`from`* text, *`to`* text)
1120
1121返回类型
1122: `text`
1123
1124## 描述
1125
1126将 *`string`* 中出现的所有子串 *`from`* 替换为子串 *`to`*
1127
1128## 示例
1129
1130``` sql
1131 palopgsql=# select replace('abcdefabcdefdc', 'cd', 'XX');
1132 replace
1133 ----------------
1134 abXXefabXXefdc
1135 (1 row)
1136 ```
1137
1138##### `reverse()`
1139
1140## 语法
1141
1142reverse(*`str`*)
1143
1144返回类型
1145: `text`
1146
1147## 描述
1148
1149返回反转的字符串。
1150
1151## 示例
1152
1153``` sql
1154 palopgsql=# select reverse('abcde');
1155 reverse
1156 ---------
1157 edcba
1158 (1 row)
1159 ```
1160
1161##### `right()`
1162
1163## 语法
1164
1165right(*`str`* text, *`n`* int)
1166
1167返回类型
1168: `text`
1169
1170## 描述
1171
1172返回字符串中的最后 *`n`* 个字符。如果 *`n`* 为负，返回除最前面的|*`n`*|个字符外的所有字符。
1173
1174## 示例
1175
1176``` sql
1177 palopgsql=# select right('abcde', 2);
1178 right
1179 -------
1180 de
1181 (1 row)
1182 ```
1183
1184
1185##### `rpad()`
1186
1187## 语法
1188
1189rpad(*`string`* text, *`length`* int [, *`fill`* text])
1190
1191返回类型
1192: `text`
1193
1194## 描述
1195
1196将 *`string`* 通过增加字符 *`fill`*（默认为一个空格）填充到长度 *`length`*。如果 *`string`* 已经长于 *`length`* 则它会被截断。
1197
1198## 示例
1199
1200``` sql
1201 palopgsql=# select rpad('hi', 5, 'xy');
1202 rpad
1203 -------
1204 hixyx
1205 (1 row)
1206 ```
1207
1208
1209##### `rtrim()`
1210
1211## 语法
1212
1213`rtrim(string text [, characters text])`
1214
1215返回类型
1216: `text`
1217
1218## 描述
1219
1220从string的结尾删除最长的只包含characters（默认是一个空格）的串
1221
1222## 示例
1223
1224``` sql
1225 palopgsql=# select rtrim('testxxzx', 'xyz');
1226 rtrim
1227 -------
1228 test
1229 (1 row)
1230 ```
1231
1232
1233##### `split_part()`
1234
1235## 语法
1236
1237split_part(*`string`* text, *`delimiter`* text,*`field`* int)
1238
1239返回类型
1240: text
1241
1242## 描述
1243
1244按 *`delimiter`* 划分 *`string`* 并返回给定域（从1开始计算）
1245
1246## 示例
1247
1248``` sql
1249 palopgsql=# select split_part('abc~@~def~@~ghi', '~@~', 2);
1250 split_part
1251 ------------
1252 def
1253 (1 row)
1254 ```
1255
1256
1257
1258#### `strpos()`
1259
1260## 语法
1261
1262strpos(*`string`*, *`substring`*)
1263
1264返回类型
1265: int
1266
1267## 描述
1268
1269指定子串的位置（和position(*`substring`* in *`string`*)相同，但是注意相反的参数顺序）
1270
1271## 示例
1272
1273``` sql
1274 palopgsql=# select strpos('high', 'ig');
1275 strpos
1276 --------
1277 2
1278 (1 row)
1279 ```
1280
1281
1282
1283##### `substr()`
1284
1285## 语法
1286
1287`substr(string, from [, count])`
1288
1289返回类型
1290: text
1291
1292## 描述
1293
1294提取子串（与substring (*`string`* from *`from`* for *`count`*)相同）
1295
1296## 示例
1297
1298``` sql
1299 palopgsql=# select substr('alphabet', 3, 2);
1300 substr
1301 --------
1302 ph
1303 (1 row)
1304 ```
1305
1306
1307
1308##### `starts_with()`
1309
1310## 语法
1311
1312starts_with(*`string`*, *`prefix`*)
1313
1314返回类型
1315: bool
1316
1317## 描述
1318
1319如果 *`string`* 以 *`prefix`* 开始则返回真。
1320
1321## 示例
1322
1323``` sql
1324 palopgsql=# select starts_with('alphabet', 'alph');
1325 starts_with
1326 -------------
1327 t
1328 (1 row)
1329 ```
1330
1331
1332##### `to_ascii()`
1333
1334## 语法
1335
1336to_ascii(*`string`* text [, *`encoding`* text])
1337
1338返回类型
1339: text
1340
1341## 描述
1342
1343将 *`string`* 从另一个编码转换到ASCII（只支持从LATIN1、LATIN2、LATIN9和WIN1250编码的转换）
1344
1345## 示例
1346
1347``` sql
1348 palopgsql=# select to_ascii('Karel','latin1');
1349 to_ascii
1350 ----------
1351 Karel
1352 (1 row)
1353 ```
1354
1355
1356##### `to_hex()`
1357
1358## 语法
1359
1360to_hex(*`number`* int or bigint)
1361
1362返回类型
1363: `text`
1364
1365## 描述
1366
1367将 *`number`* 转换到它等效的十六进制表示
1368
1369## 示例
1370
1371``` sql
1372 palopgsql=# select to_hex(2147483647);
1373 to_hex
1374 ----------
1375 7fffffff
1376 (1 row)
1377 ```
1378
1379
1380
1381##### translate()
1382
1383## 语法
1384
1385translate(*`string`* text, *`from`* text, *`to`* text)
1386
1387返回类型
1388: text
1389
1390## 描述
1391
1392*`string`* 中任何匹配 *`from`* 集合中一个字符的字符会被替换成 *`to`* 集合中的相应字符。如果 *`from`* 比 *`to`* 长，*`from`* 中的额外字符会被删除。
1393
1394## 示例
1395
1396``` sql
1397 palopgsql=# select translate('12345', '143', 'ax');
1398 translate
1399 -----------
1400 a2x5
1401 (1 row)
1402
1403 palopgsql=# select translate('12345', '14', 'axt');
1404 translate
1405 -----------
1406 a23x5
1407 (1 row)
1408 ```
1409
1410
1411### 模式匹配
1412
1413
1414PalopgSQL提供了三种独立的实现模式匹配的方法：SQL `LIKE`操作符、更近一些的`SIMILAR TO`操作符（SQL:1999 里添加进来的）和POSIX-风格的正则表达式。
1415
1416
1417除了这些基本的“串匹配模式”操作符外，还有一些函数可用于提取或替换匹配子串并在匹配位置分离一个串。
1418
1419
1420**注意**
1421
1422* 如果模式匹配的要求超出了这些，请考虑用 Perl 或 Tcl 写一个用户定义的函数。
1423
1424* 虽然大部分的正则表达式搜索都能被很快地执行，但是正则表达式仍可能被人为地弄成需要任意长的时间和任意量的内存进行处理。要当心从不怀好意的来源接受正则表达式搜索模式。如果必须这样做，建议加上语句超时限制。
1425
1426* 使用`SIMILAR TO`模式的搜索具有同样的安全性危险， 因为`SIMILAR TO`提供了很多和 POSIX-风格正则表达式相同的能力。
1427
1428* `LIKE`搜索比其他两种选项简单得多，因此在使用不怀好意的模式来源时要更安全些。
1429
1430
1431#### `LIKE/NOT LIKE`
1432
1433
1434## 语法
1435
1436``` sql
1437 string LIKE pattern [ESCAPE escape-character]
1438 string NOT LIKE pattern [ESCAPE escape-character]
1439 ```
1440
1441## 描述
1442
1443如果该*`string`*匹配了提供的*`pattern`*，那么`LIKE`表达式返回真（和预期的一样，如果`LIKE`返回真，那么`NOT LIKE`表达式返回假， 反之亦然。一个等效的表达式是`NOT (string` LIKE *`pattern`*)）。
1444
1445 如果*`pattern`*不包含百分号或者下划线，那么该模式只代表它本身的串；这时候`LIKE`的行为就象等号操作符。在*`pattern`*里的下划线（`_`）代表（匹配）任何单个字符； 而一个百分号（`%`）匹配任何零或更多个字符的序列。
1446
1447## 示例
1448
1449``` sql
1450 palopgsql=# select 'abc' LIKE 'abc';
1451 ?column?
1452 ----------
1453 t
1454 (1 row)
1455
1456 palopgsql=# select 'abc' LIKE 'a%' ;
1457 ?column?
1458 ----------
1459 t
1460 (1 row)
1461
1462 palopgsql=# select 'abc' LIKE '_b_' ;
1463 ?column?
1464 ----------
1465 t
1466 (1 row)
1467
1468 palopgsql=# select 'abc' LIKE 'c';
1469 ?column?
1470 ----------
1471 f
1472 (1 row)
1473 ```
1474
1475`LIKE`模式匹配总是覆盖整个串。因此，要匹配在串内任何位置的序列，该模式必须以百分号开头和结尾。
1476
1477要匹配文本的下划线或者百分号，而不是匹配其它字符， 在*`pattern`*里相应的字符必须前导转义字符。缺省的转义字符是反斜线，但是你可以用`ESCAPE`子句指定一个不同的转义字符。要匹配转义字符本身，写两个转义字符。
1478
1479
1480**注意**
1481
1482* 如果关掉了GUC配置参赛standard_conforming_strings，在文串常量中写的任何反斜线都需要被双写。
1483
1484* 反斜线在串文本里已经有特殊含义了，所以如果写一个 包含反斜线的模式常量，那你就要在 SQL 语句里写两个反斜线。
1485 因此，写一个匹配单个反斜线的模式实际上要在语句里写四个反斜线。 (可以通过用 ESCAPE选择一个不同的转义字符来避免这样；这样反斜线就不再是 LIKE 的特殊字符了。但仍然是字符文本分析器的特殊字符，所以还是需要两个反斜线。)
1486
1487 也可以通过写`ESCAPE ''`的方式不选择转义字符，这样可以有效地禁用转义机制，但是没有办法关闭下划线和百分号在模式中的特殊含义。
1488
1489* 关键字`ILIKE`可以用于替换`LIKE`，它令该匹配根据活动区域成为大小写无关。这个不属于SQL标准而是一个PalopgSQL扩展。
1490
1491* 操作符`~~`等效于`LIKE`， 而`~~*`对应`ILIKE`。 还有 `!~~`和`!~~*`操作符分别代表`NOT LIKE`和`NOT ILIKE`。所有这些操作符都是PalopgSQL特有的。
1492
1493* 在仅需要从字符串的开始部分搜索的情况，还有前缀操作符`^@`和相应的`starts_with`函数可以使用。
1494
1495
1496#### `SIMILAR TO`正则表达式
1497
1498## 语法
1499
1500``` sql
1501 string SIMILAR TO pattern [ESCAPE escape-character]
1502 string NOT SIMILAR TO pattern [ESCAPE escape-character]
1503 ```
1504
1505## 描述
1506
1507`SIMILAR TO`操作符根据自己的模式是否匹配给定串而返回真或者假。 它和`LIKE`非常类似，只不过它使用 SQL标准定义的正则表达式理解模式。 SQL正则表达式是在`LIKE`标记和普通的正则表达式标记的奇怪的杂交。
1508
1509 类似`LIKE`，`SIMILAR TO`操作符只有在它的模式匹配整个串的时候才能成功；这一点和普通的正则表达式的行为不同，在普通的正则表达式里，模式匹配串的任意部分。
1510
1511 和`LIKE`类似的地方还有，`SIMILAR TO`使用`_`和`%`作为分别代表任意单个字符和任意串的通配符（这些可以比得上 POSIX正则表达式里的`.`和`.*`）。
1512
1513 除了这些从`LIKE`借用的功能之外，`SIMILAR TO`支持下面这些从 POSIX 正则表达式借用的 模式匹配元字符：
1514
1515
1516 - `|`表示选择（两个候选之一）。
1517
1518 - `*`表示重复前面的项零次或更多次。
1519
1520 - `+`表示重复前面的项一次或更多次。
1521
1522 - `?`表示重复前面的项零次或一次。
1523
1524 - `{`*`m`*`}`表示重复前面的项刚好*`m`*次。
1525
1526 - `{`*`m`*`,}`表示重复前面的项*`m`*次或更多次。
1527
1528 - `{`*`m`*`,`*`n`*`}`表示重复前面的项至少*`m`*次并且不超过*`n`*次。
1529
1530 - 可以使用圆括号`()`把多个项组合成一个逻辑项。
1531
1532 - 一个方括号表达式`[...]`声明一个字符类，就像 POSIX 正则表达式一样。
1533
1534
1535 注意点号（`.`）不是`SIMILAR TO`的一个元字符。
1536
1537 和`LIKE`一样，反斜线禁用所有这些元字符的特殊含义；当然我们也可以用`ESCAPE`指定一个不同的转义字符。
1538
1539## 示例
1540
1541``` sql
1542 palopgsql=# select 'abc' SIMILAR TO 'abc';
1543 ?column?
1544 ----------
1545 t
1546 (1 row)
1547
1548 palopgsql=# select 'abc' SIMILAR TO 'a' ;
1549 ?column?
1550 ----------
1551 f
1552 (1 row)
1553
1554 palopgsql=# select 'abc' SIMILAR TO '%(b|d)%';
1555 ?column?
1556 ----------
1557 t
1558 (1 row)
1559
1560 palopgsql=# select 'abc' SIMILAR TO '(b|c)%';
1561 ?column?
1562 ----------
1563 f
1564 (1 row)
1565 ```
1566
1567
1568#### POSIX正则表达式
1569
1570POSIX正则表达式提供了比`LIKE`和`SIMILAR TO`操作符更强大的含义。许多 Unix工具，例如`egrep`、`sed`或`awk`使用一种与我们这里描述的类似的模式匹配语言。
1571
1572正则表达式是一个字符序列，它是定义一个串集合 （一个*正则集*）的缩写。 如果一个串是正则表达式描述的正则集中的一员时，我们就说这个串匹配该正则表达式。 和`LIKE`一样，模式字符准确地匹配串字符，除非在正则表达式语言里有特殊字符 — 不过正则表达式用的 特殊字符和`LIKE`用的不同。和`LIKE`模式不一样的是，正则表达式允许匹配串里的任何位置，除非该正则表达式显式地挂接在串的开头或者结尾。
1573
1574以下是所有可用于POSIX 正则表达式模式匹配的操作符和函数的说明。
1575
1576
1577##### `~`
1578
1579## 描述
1580
1581匹配正则表达式，大小写敏感
1582
1583## 示例
1584
1585``` sql
1586 palopgsql=# select 'thomas' ~ '.*thomas.*';
1587 ?column?
1588 ----------
1589 t
1590 (1 row)
1591 palopgsql=# select 'abc' ~ 'abc';
1592 ?column?
1593 ----------
1594 t
1595 (1 row)
1596
1597 palopgsql=# select 'abc' ~ '^a' ;
1598 ?column?
1599 ----------
1600 t
1601 (1 row)
1602
1603 palopgsql=# select 'abc' ~ '(b|d)';
1604 ?column?
1605 ----------
1606 t
1607 (1 row)
1608
1609 palopgsql=# select 'abc' ~ '^(b|c)';
1610 ?column?
1611 ----------
1612 f
1613 (1 row)
1614 ```
1615
1616
1617##### `~*`
1618
1619## 描述
1620
1621匹配正则表达式，大小写不敏感
1622
1623## 示例
1624
1625``` sql
1626 palopgsql=# select 'thomas' ~* '.*Thomas.*';
1627 ?column?
1628 ----------
1629 t
1630 (1 row)
1631 ```
1632
1633##### `!~`
1634
1635## 描述
1636
1637不匹配正则表达式，大小写敏感
1638
1639## 示例
1640
1641``` sql
1642 palopgsql=# select 'thomas' !~ '.*Thomas.*';
1643 ?column?
1644 ----------
1645 t
1646 (1 row)
1647 ```
1648
1649
1650##### `!~*`
1651
1652## 描述
1653
1654不匹配正则表达式，大小写不敏感
1655
1656## 示例
1657
1658``` sql
1659 palopgsql=# select 'thomas' !~* '.*vadim.*';
1660 ?column?
1661 ----------
1662 t
1663 (1 row)
1664 ```
1665
1666
1667##### `substring()`
1668
1669## 语法
1670
1671`substring(string` from *`pattern`* `[ for escape-character])`
1672
1673## 描述
1674
1675抽取匹配POSIX 正则表达式模式的子串. 如果没有匹配它返回空值，否则就是文本中匹配模式的那部分。但是如果该模式包含任何圆括号，那么将返回匹配第一对子表达式（对应第一个左圆括号的`）`的文本。如果你想在表达式里使用圆括号而又不想导致这个例外，那么你可以在整个表达式外边放上一对圆括号。如果你需要在想抽取的子表达式前有圆括号，参阅后文描述的非捕获性圆括号。
1676
1677 带三个参数的`substring`，增加了指定转义字符的功能。和`SIMILAR TO`一样，声明的模式必须匹配整个数据串，否则函数失败并返回空值。为了标识在成功的时候应该返回的模式部分，模式必须包含转义字符的两次出现，并且后面要跟上双引号（`"`）。匹配这两个标记之间的模式的文本将被返回。
1678
1679## 示例
1680
1681``` sql
1682 palopgsql=# select substring('foobar' from 'o.b');
1683 substring
1684 -----------
1685 oob
1686 (1 row)
1687
1688 palopgsql=# select substring('foobar' from 'o(.)b');
1689 substring
1690 -----------
1691 o
1692 (1 row)
1693 ```
1694
1695 一些使用`#"`定界返回串的示例如下：
1696
1697 ``` sql
1698 palopgsql=# select substring('foobar' from '%#"o_b#"%' for '#') ;
1699 substring
1700 -----------
1701 oob
1702 (1 row)
1703
1704 palopgsql=# select substring('foobar' from '#"o_b#"%' for '#') ;
1705 substring
1706 -----------
1707
1708 (1 row)
1709 ```
1710
1711##### `regexp_replace()`
1712
1713## 语法
1714
1715`regexp_replace`(*`source`*, *`pattern`*, *`replacement`*\[, *`flags`* \])
1716
1717## 描述
1718
1719`regexp_replace`函数提供了将匹配 POSIX 正则表达式模式的子串替换为新文本的功能。 如果没有匹配*`pattern`*，那么返回不加修改的*`source`*串。如果有匹配，则返回的*`source`*串里面的匹配子串将被*`replacement`*串替换掉。*`replacement`*串可以包含`\`*`n`*，其中`\`*`n`*是 1 到 9， 表明源串里匹配模式里第*`n`*个圆括号子表达式的子串应该被插入，并且它可以包含`\&`表示应该插入匹配整个模式的子串。如果你需要放一个文字形式的反斜线在替换文本里，那么写`\\`。*`flags`*参数是一个可选的文本串，它包含另个或更多单字母标志，这些标志可以改变函数的行为。标志`i`指定大小写无关的匹配，而标志`g`指定替换每一个匹配的子串而不仅仅是第一个。支持的标志（但不是`g`）在下表“ARE 嵌入选项字母“中描述。
1720
1721## 示例
1722
1723``` sql
1724 palopgsql=# select regexp_replace('foobarbaz', 'b..', 'X');
1725 regexp_replace
1726 ----------------
1727 fooXbaz
1728 (1 row)
1729
1730 palopgsql=# select regexp_replace('foobarbaz', 'b..', 'X', 'g');
1731 regexp_replace
1732 ----------------
1733 fooXX
1734 (1 row)
1735
1736 palopgsql=# select regexp_replace('foobarbaz', 'b(..)', 'X\1Y', 'g');
1737 regexp_replace
1738 ----------------
1739 fooXarYXazY
1740 (1 row)
1741 ```
1742
1743##### `regexp_match()`
1744
1745## 语法
1746
1747`regexp_match`(*`string`*,*`pattern`* \[, *`flags`*\])
1748
1749## 描述
1750
1751返回一个文本数组，它包含一个POSIX正则表达式模式与一个字符串第一个匹配所得到的子串。如果没有匹配，则结果为`NULL`。如果找到一个匹配并且*`pattern`*不包含带括号的子表达式，那么结果是一个单一元素的文本数组，其中包含匹配整个模式的子串。如果找到一个匹配并且*`pattern`*含有带括号的子表达式，那么结果是一个文本数组，其中第*`n`*个元素是与*`pattern`*的第*`n`*个圆括号子表达式匹配的子串（“非捕获”圆括号不计入在内，详见下文）。*`flags`*参数是一个可选的文本字符串，它包含零个或者更多个可以改变该函数行为的单字母标志。支持的标志在下表“ARE 嵌入选项字母“中描述。
1752
1753## 示例
1754
1755``` sql
1756 palopgsql=# SELECT regexp_match('foobarbequebaz', 'bar.*que');
1757 regexp_match
1758 --------------
1759 {barbeque}
1760 (1 row)
1761
1762 palopgsql=# SELECT regexp_match('foobarbequebaz', '(bar)(beque)');
1763 regexp_match
1764 --------------
1765 {bar,beque}
1766 (1 row)
1767 ```
1768
1769 在通常情况下，只是想要的大整个匹配的子串或者`NULL`（没有匹配），可以写成这样
1770
1771 ``` sql
1772 palopgsql=# SELECT (regexp_match('foobarbequebaz', 'bar.*que'))[1];
1773 regexp_match
1774 --------------
1775 barbeque
1776 (1 row)
1777 ```
1778
1779##### `regexp_matches()`
1780
1781## 语法
1782
1783`regexp_matches`(*`string`*,*`pattern`* \[, *`flags`*\])
1784
1785## 描述
1786
1787`regexp_matches`函数返回一个文本数组的集合，其中包含着一个POSIX正则表达式模式与一个字符串匹配得到的子串。如果没有匹配，这个函数不会返回行。如果有一个匹配并且给定了`g`标志，则返回一行。如果有*`N`*个匹配并且给定了`g`标志，则返回*`N`*行。每一个返回的行都是一个文本数组，其中含有整个匹配的子串或者匹配*`pattern`*的圆括号子表达式的子串，这和上面对`regexp_match`的介绍一样。`regexp_matches`接受"表 ARE 嵌入选项字母"中展示的所有标志，外加令它返回所有匹配而不仅仅是第一个匹配的`g`标志。
1788
1789## 示例
1790
1791``` sql
1792 palopgsql=# SELECT regexp_matches('foo', 'not there');
1793 regexp_matches
1794 ----------------
1795 (0 rows)
1796
1797 palopgsql=# SELECT regexp_matches('foobarbequebazilbarfbonk', '(b[^b]+)(b[^b]+)', 'g');
1798 regexp_matches
1799 ----------------
1800 {bar,beque}
1801 {bazil,barf}
1802 (2 rows)
1803 ```
1804
1805
1806注意
1807: 在大部分情况下，`regexp_matches()`应该与`g`标志一起使用，因为如果只是想要第一个匹配，使用`regexp_match()`会更加简单高效。
1808
1809##### `regexp_split_to_table()`
1810
1811## 语法
1812
1813`regexp_split_to_table`(*`string`*,*`pattern`* \[, *`flags`*\])
1814
1815## 描述
1816
1817`regexp_split_to_table`把一个 POSIX正则表达式模式当作一个定界符来分离一个串。如果没有与*`pattern`*的匹配，该函数返回*`string`*。如果有至少有一个匹配，对每一个匹配它都返回从上一个匹配的末尾（或者串的开头）到这次匹配开头之间的文本。当没有更多匹配时，它返回从上一次匹配的末尾到串末尾之间的文本。*`flags`*参数是一个可选的文本串，它包含零个或更多单字母标志，这些标识可以改变该函数的行为。`regexp_split_to_table`能支持的标志在"表 ARE 嵌入选项字母"中描述。
1818
1819## 示例
1820
1821``` sql
1822 palopgsql=# SELECT foo FROM regexp_split_to_table('the quick brown fox jumps over the lazy dog', '\s+') AS foo;
1823 foo
1824 -------
1825 the
1826 quick
1827 brown
1828 fox
1829 jumps
1830 over
1831 the
1832 lazy
1833 dog
1834 (9 rows)
1835 palopgsql=# SELECT foo FROM regexp_split_to_table('the quick brown fox', '\s*') AS foo;
1836 foo
1837 -----
1838 t
1839 h
1840 e
1841 q
1842 u
1843 i
1844 c
1845 k
1846 b
1847 r
1848 o
1849 w
1850 n
1851 f
1852 o
1853 x
1854 (16 rows)
1855 ```
1856
1857##### `regexp_split_to_array()`
1858
1859## 语法
1860
1861`regexp_split_to_array`(*`string`*,*`pattern`* \[, *`flags`*\])
1862
1863## 描述
1864
1865`regexp_split_to_array`函数的行为和`regexp_split_to_table`相同，不过`regexp_split_to_array`会把它的结果以一个`text`数组的形式返回。
1866
1867
1868## 示例
1869
1870``` sql
1871 palopgsql=# SELECT regexp_split_to_array('the quick brown fox jumps over the lazy dog', '\s+');
1872 regexp_split_to_array
1873 -----------------------------------------------
1874 {the,quick,brown,fox,jumps,over,the,lazy,dog}
1875 (1 row)
1876 ```
1877
1878正如上一个例子所示，正则表达式分离函数会忽略零长度的匹配，这种匹配发生在串的开头或结尾或者正好发生在前一个匹配之后。这和正则表达式匹配的严格定义是相悖的，后者由`regexp_match`和`regexp_matches`实现，但是通常前者是实际中最常用的行为。其他软件系统如Perl也使用相似的定义。
1879
1880#### 正则表达式细节
1881
1882PalopgSQL正则表达式与PostgreSQL的正则表达式一样, 是使用 Henry Spencer写的一个包来实现的。以下正则表达式的大部分描述都是从
1883Henry Spencer手册页中拷贝过来的。
1884
1885正则表达式（RE），在POSIX 1003.2 中定义， 它有两种形式：*扩展*的RE或者是ERE（大概地说就是那些在`egrep`里的），*基本*的RE或者是BRE（大概地说就是那些在`ed`里的）。PostgreSQL支持两种形式，并且还实现了一些POSIX标准中没有但是在类似Perl 或者 Tcl 这样的语言中得到广泛应用的一些扩展。使用了那些非POSIX扩展的RE叫*高级*RE， 或者本文档里说的ARE。ARE几乎完全是 ERE 的超集，但是 BRE 有几个符号上的不兼容（以及更多的限制）。我们首先描述 ARE 和 ERE 形式，描述那些只适用于 ARE 的特性，然后描述 BRE 的区别是什么。
1886
1887
1888
1889##### 正则表达式元语法
1890
1891PalopgSQL数据库默认总是推测一个正则表达式遵循 ARE规则。但可以通过为 RE 模式预置一个*embedded option*来选择限制更多的 ERE 或BRE规则，如正则表达式元语法中所述。
1892
1893* 一个正则表达式被定义为一个或更多*分支*，它们之间被`|`分隔。只要能匹配其中一个分支的东西都能匹配正则表达式。
1894
1895* 一个分支是一个或多个*量化原子*或者*约束*连接而成。一个原子匹配第一个，然后后面的原子匹配第二个， 以此类推；一个空分支匹配空串。
1896
1897* 一个量化原子是一个*原子*， 后面可能跟着一个*量词*。没有量词的时候，它匹配一个原子，有量词的时候，它可以匹配若干个原子。一个*原子*可以是在下文显示的任何可能。
1898
1899以下是:
1900
1901`(`*`re`*`)`
1902: （其中*`re`*是任何正则表达式） 匹配一个对*`re`*的匹配，匹配将为可能的报告被记下
1903
1904`(?:`*`re`*`)`
1905: 同上，但是匹配不会为了报告而被记下 （一个“非捕获”圆括号集） （只对 ARE）
1906
1907`.`
1908: 匹配任意单个字符
1909
1910`[`*`chars`*`]`
1911: 一个*方括号表达式*， 匹配*`chars`*中的任意一个
1912
1913`\`*`k`*
1914: （其中*`k`*是一个非字母数字字符） 匹配一个被当作普通字符看待的特定字符， 例如，`\\`匹配一个反斜线字符
1915
1916`\`*`c`*
1917: 其中*`c`*是一个字母数字 （可能跟着其它字符），它是一个*转义*，（仅对 ARE； 在 ERE 和 BRE 中，它匹配*`c`*）
1918
1919`{`
1920: 如果后面跟着一个字符，而不是数字， 那么就匹配左花括弧`{`；如果跟着一个数字， 那么它是*`range`*的开始（见下文）
1921
1922*`x`*
1923: 其中*`x`*是一个没有其它意义的单个字符，则匹配该字符。
1924
1925
1926RE 不能以反斜线（`\`）结尾。
1927
1928
1929**注意**
1930
1931* 如果关掉了GUC配置参数standard_conforming_strings，任何写在文字串常量中的反斜线都需要被双写。
1932
1933##### 正则表达式量词
1934
1935正则表达式量词及其匹配含义见下表
1936
1937**表 正则表达式量词**
1938
1939
1940| 量词 | 匹配 |
1941| -------------------- | ---------------------------------------------- |
1942| `*` | 一个由原子的 0 次或更多次匹配组成的序列 |
1943| `+` | 一个由原子的 1 次或更多次匹配组成的序列 |
1944| `?` | 一个由原子的 0 次或 1 次匹配组成的序列 |
1945| `{`*`m`*`}` | 一个由原子的正好*`m`*次匹配组成的序列 |
1946| `{`*`m`*`,}` | 一个由原子的*`m`*次或更多次匹配组成的序列 |
1947| `{`*`m`*`,`*`n`*`}` | 一个由原子的从*`m`*次到*`n`*次（包括）匹配组成的序列；*`m`*不能超过*`n`* |
1948| `*?` | `*`的非贪婪版本 |
1949| `+?` | `+`的非贪婪版本 |
1950| `??` | `?`的非贪婪版本 |
1951| `{`*`m`*`}?` | `{`*`m`*`}`的非贪婪版本 |
1952| `{`*`m`*`,}?` | `{`*`m`*`,}`的非贪婪版本 |
1953| `{`*`m`*`,`*`n`*`}?` | `{`*`m`*`,`*`n`*`}`的非贪婪版本 |
1954
1955
1956
1957
1958
1959使用`{`*`...`*`}`的形式被称作*范围*。 一个范围内的数字*`m`*和*`n`*都是无符号十进制整数， 允许的数值从 0 到 255（包含）。
1960
1961*非贪婪*的量词（只在 ARE 中可用）匹配对应的正常（*贪婪*）模式，区别是它寻找最少的匹配，而不是最多的匹配。详见"正则表达式匹配规则"。
1962
1963
1964**注意**
1965
1966* 一个量词不能紧跟在另外一个量词后面，例如`**`是非法的。量词不能作为表达式或者子表达式的开头，也不能跟在`^`或者`|`后面。
1967
1968##### 正则表达式约束
1969
1970一个*约束*匹配一个空串，但只是在满足特定条件下才匹配。
1971
1972约束可以在能够使用原子的地方使用，只是它不能跟着量词。简单的约束在下表里显示：
1973
1974**表 正则表达式约束**
1975
1976
1977| 约束 | 描述 |
1978| --------------- | ------------------------------------------------------------ |
1979| `^` | 串开头的匹配 |
1980| `$` | 串末尾的匹配 |
1981| `(?=`*`re`*`)` | 在匹配*`re`*的子串开始的任何点的* positive lookahead*匹配（只对 ARE） |
1982| `(?!`*`re`*`)` | 在匹配*`re`*的子串开始的任何点的* negative lookahead*匹配（只对 ARE） |
1983| `(?<=`*`re`*`)` | 只要有一个点上有一个子串匹配*`re`*端， *positive lookbehind* 就在这个点上匹配（只对 ARE） |
1984| `(?<!`*`re`*`)` | 只要有一个点上没有子串匹配*`re`*端， *negative lookbehind* 就在这个点上匹配（只对 ARE） |
1985
1986lookahead 和 lookbehind 约束不能包含*后引用*，并且其中的所有圆括号都被认为是非捕获的。
1987
1988##### 方括号表达式
1989
1990
1991
1992
1993*方括号表达式*是一个包围在`[]`中的字符列表。它通常匹配列表中的任意单个字符。
1994
1995* 如果列表以`^`开头，它匹配任意单个*不*在该列表参与部分中的字符。如果该列表中两个字符用`-`隔开，那它就是那两个字符（包括在内）之间的所有字符范围的缩写，例如，在ASCII中`[0-9]`匹配任何十进制数字。两个范围共享一个端点是非法的，例如，`a-c-e`。范围与字符集关系密切，可移植的程序应该避免依靠它们。
1996
1997* 想在列表中包含文本`]`，可以让它做列表的首字符（如果使用了`^`，需要放在其后）。
1998
1999* 想在列表中包含文本`-`，可以让它做列表的首字符或者尾字符，或者一个范围的第二个端点。
2000
2001* 想在列表中把文本`-`当做范围的起点， 把它用`[.`和`.]`包围起来，这样它就成为一个排序元素。
2002
2003除了这些字符本身、一些用`[`的组合（见下段）以及转义（只在 ARE中有效）以外，所有其它特殊字符 在方括号表达式里都失去它们的特殊含义。特别是，在 ERE 和 BRE规则下`\`不是特殊的， 但在 ARE 里，它是特殊的（引入一个转义）。
2004
2005在一个方括号表达式里，一个排序元素（一个字符、一个被当做一个单一字符排序的多字符序列或者一个表示上面两种情况的排序序列名称）包含在`[.`和`.]`里面的时候表示该排序元素的字符序列。该序列被当做该方括号列表的一个单一元素。这允许一个包含多字符排序元素的方括号表达式去匹配多于一个字符，例如，如果排序序列包含一个`ch`排序元素，那么 RE `[[.ch.]]*c`匹配`chchcc`的头五个字符。
2006
2007
2008**注意**
2009
2010* 当前不支持多字符排序元素。这些信息描述了将来可能有的行为。
2011
2012
2013在方括号表达式里，包围在`[=`和`=]`里的排序元素是一个*等价类*，代表等效于那一个的所有排序元素的字符序列，包括它本身（如果没有其它等效排序元素，那么就好象封装定界符是`[.`和`.]`）。例如，如果`o`和`^`是一个等价类的成员，那么`[[=o=]]`、`[[=^=]]`和`[o^]`都是同义的。一个等价类不能是一个范围的端点。
2014
2015在方括号表达式里，在`[:`和`:]`里面封装的字符类的名字代表属于该类的所有字符的列表。 标准的字符类名字是：`alnum`、`alpha`、`blank`、 `cntrl`、`digit`、 `graph`、`lower`、 `print`、`punct`、`space`、`upper`、 `xdigit`。它们代表在ctype中定义的字符类。
2016
2017一个区域可以会提供其他的类。字符类不能用做一个范围的端点。
2018
2019方括号表达式里有两个特例：方括号表达式`[[:<:]]`和`[[:>:]]`是约束，分别匹配一个单词开头和结束的空串。单词定义为一个单词字符序列，前面和后面都没有其它单词字符。单词字符是一个`alnum`字符（和ctype中定义的一样）或者一个下划线。
2020
2021
2022
2023
2024##### 正则表达式转义
2025
2026
2027
2028
2029*转义*是以`\`开头，后面跟着一个字母数字字符得特殊序列。 转义有好几种变体：字符项、类缩写、约束转义以及后引用。在 ARE 里，如果一个`\`后面跟着一个字母数字，但是并未组成一个合法的转义， 那么它是非法的。在 ERE中没有转义：在方括号表达式之外，一个后面跟着字母数字字符的`\`只是表示该字符是一个普通的字符，而且在一个方括号表达式里，`\`是一个普通的字符（后者实际上在ERE 和 ARE 不兼容）。
2030
2031*字符项转义*用于便于我们在 RE中声明那些不可打印的或其他习惯的字符。如下表"表 正则表达式字符项转义"中内容。
2032
2033*类缩写转义*用来提供一些常用的字符类缩写。如下表 "表 正则表达式类缩写转义"中内容。
2034
2035*约束转义*是一个约束，如果满足特定的条件，它匹配该空串。如下表 "表 正则表达式约束转义"中内容。
2036
2037*后引用*（`\`*`n`*）匹配数字`\`*`n`*指定的被前面的圆括号子表达式匹配的同一个串，如下表 "表 正则表达式后引用"中内容。例如，`([bc])\1`匹配`bb`或者`cc`， 但是不匹配`bc`或者`cb`。RE 中子表达式必须完全在后引用前面。子表达式以它们的先导圆括号的顺序编号。非捕获圆括号并不定义子表达式。
2038
2039
2040**表 正则表达式字符项转义**
2041
2042
2043| 转义 | 描述 |
2044| ---------------- | --------------------------------------------------------------- |
2045| `\a` | 警告（响铃）字符，和 C 中一样 |
2046| `\b` | 退格，和 C 中一样 |
2047| `\B` | 反斜线（`\`）的同义词，用来减少双写反斜线 |
2048| `\c`*`X`* | （其中*`X`*是任意字符）低序5位和*`X`*相同的字符，它的其他位都是零 |
2049| `\e` | 排序序列名为`ESC`的字符，如果无法做到该字符为八进制值 `033` |
2050| `\f` | 换页，和 C 中一样 |
2051| `\n` | 新行，和 C 中一样 |
2052| `\r` | 回车，和 C 中一样 |
2053| `\t` | 水平制表符，和 C 中一样 |
2054| `\u`*`wxyz`* | （其中*`wxyz`*正好是四个十六进制位）十六进制值为`0x`*`wxyz`*的字符 |
2055| `\U`*`stuvwxyz`* | （其中*`stuvwxyz`*正好是八个十六进制位）十六进制值为`0x`*`stuvwxyz`*的字符 |
2056| `\v` | 垂直制表符，和 C 中一样 |
2057| `\x`*`hhh`* | （其中*`hhh`*是十六进制位的任意序列）十六进制值为`0x`*`hhh`*的字符（一个单一字符，不管用了多少个十六进制位） |
2058| `\0` | 值为`0`（空字节）的字符 |
2059| `\`*`xy`* | （其中*`xy`*正好是两个八进制位，并且不是一个*后引用*）八进制值为`0`*`xy`*的字符 |
2060| `\`*`xyz`* | （其中*`xyz`*正好是三个八进制位，并且不是一个*后引用*）八进制值为`0`*`xyz`*的字符 |
2061
2062
2063
2064
2065
2066十六进制位是`0`-`9`、`a`-`f`和`A`-`F`。八进制位是`0`-`7`。
2067
2068指定 ASCII 范围（0-127）之外的值的数字字符项转义的含义取决于数据库编码。 当编码是 UTF-8 时，转义值等价于 Unicode代码点，例如 `\u1234`表示字符`U+1234`。对于其他多字节编码，字符项转义通常只是指定该字符的字节值的串接。如果该转义值不对应数据库编码中的任何合法字符，将不会发生错误，但是它不会匹配任何数据。
2069
2070字符项转义总是被当作普通字符。例如，`\135`是 ASCII 中的`]`， 但`\135`并不终止一个方括号表达式。
2071
2072
2073**表 正则表达式类缩写转义**
2074
2075
2076| 转义 | 描述 |
2077| ---- | ---------------------------- |
2078| `\d` | `[[:digit:]]` |
2079| `\s` | `[[:space:]]` |
2080| `\w` | `[[:alnum:]_]`（注意下划线是被包括的） |
2081| `\D` | `[^[:digit:]]` |
2082| `\S` | `[^[:space:]]` |
2083| `\W` | `[^[:alnum:]_]` （注意下划线是被包括的） |
2084
2085
2086
2087
2088
2089在方括号表达式里，`\d`、`\s`和`\w`会失去它们的外层方括号，而`\D`、`\S`和`\W`是非法的（也就是说，例如`[a-c\d]`等效于`[a-c[:digit:]]`。同样`[a-c\D]`等效于`[a-c^[:digit:]]`的，也是非法的）。
2090
2091
2092**表 正则表达式约束转义**
2093
2094
2095| 转义 | 描述 |
2096| ---- | ------------------------------------ |
2097| `\A` | 只在串开头匹配（与`^`不同） |
2098| `\m` | 只在一个词的开头匹配 |
2099| `\M` | 只在一个词的末尾匹配 |
2100| `\y` | 只在一个词的开头或末尾匹配 |
2101| `\Y` | 只在一个词的不是开头或末尾的点上匹配 |
2102| `\Z` | 只在串的末尾匹配（与`$`不同） |
2103
2104
2105
2106
2107
2108一个词被定义成在上面`[[:<:]]`和`[[:>:]]`中的声明。在方括号表达式里，约束转义是非法的。
2109
2110
2111**表 正则表达式后引用**
2112
2113
2114| 转义 | 描述 |
2115| ---------- | ----------------------------------------------- |
2116| `\`*`m`* | （其中*`m`*是一个非零位）一个到第*`m`*个子表达式的后引用 |
2117| `\`*`mnn`* | （其中*`m`*是一个非零位， 并且*`nn`*是一些更多的位， 并且十六进制值 *`mnn`* 不超过目前能看到的封闭捕获圆括号的数目） 一个到第*`mnn`*个子表达式的后引用 |
2118
2119
2120
2121
2122
2123
2124**注意**
2125
2126* 在八进制字符项转义和后引用之间有一个历史继承的歧义存在，这个歧义是通过下面的启发式规则解决的，像上面描述地那样。前导零总是表示这是一个八进制转义。而单个非零数字，如果没有跟着任何其它位，那么总是被认为后引用。 一个多位的非零开头的序列也被认为是后引用，只要它出现在合适的子表达式后面（也就是说，在后引用的合法范围中的数），否则就被认为是一个八进制。
2127
2128
2129
2130
2131
2132
2133
2134##### 正则表达式元语法
2135
2136
2137
2138
2139除了上面描述的主要语法之外，还有几种特殊形式和杂项语法。
2140
2141如果一个 RE 以`***:`开头，那么剩下的 RE 都被当作ARE（这在PalopgSQL中通常是无效的，因为 RE被假定为 ARE，但是如果 ERE 或 BRE模式通过*`flags`*参数被指定为一个正则表达式函数时，它确实能产生效果）。如果一个RE 以`***=`开头， 那么剩下的 RE 被当作一个文本串，所有的字符都被认为是一个普通字符。
2142
2143一个 ARE 可以以*嵌入选项*开头：一个序列`(?`*`xyz`*`)`（这里的*`xyz`*是一个或多个字母字符）声明影响剩余 RE的选项。 这些选项覆盖任何前面判断的选项 —特别地，它们可以覆盖一个正则表达式操作符隐含的大小写敏感的行为，或者覆盖*`flags`*参数中的正则表达式函数。可用的选项字母在下表"表 ARE 嵌入选项字母"中显示。注意这些同样的选项字母也被用在正则表达式函数的*`flags`*参数中。
2144
2145
2146**表 ARE 嵌入选项字母**
2147
2148
2149| 选项 | 描述 |
2150| --- | ------------------------------------------------ |
2151| `b` | RE的剩余部分是一个BRE |
2152| `c` | 大小写敏感的匹配（覆盖操作符类型） |
2153| `e` | RE的剩余部分是一个ERE |
2154| `i` | 大小写不敏感的匹配（覆盖操作符类型） |
2155| `m` | `n`的历史原因的同义词 |
2156| `n` | 新行敏感的匹配 |
2157| `p` | 部分新行敏感的匹配） |
2158| `q` | RE的剩余部分是一个文字（“quoted”）串，全部是普通字符 |
2159| `s` | 非新行敏感的匹配（默认） |
2160| `t` | 紧语法（默认，见下文） |
2161| `w` | 逆部分新行敏感（“怪异”）的匹配 |
2162| `x` | 扩展语法（见下文） |
2163
2164
2165
2166
2167
2168嵌入选项在`)`终止序列时发生作用。它们只在 ARE 的开始处起作用 （在任何可能存在的`***:`控制器后面）。
2169
2170除了通常的（*紧*）RE 语法（这种情况下所有字符都有效）， 还有一种*扩展*语法，可以通过声明嵌入的`x`选项获得。在扩展语法里，RE中的空白字符被忽略，就像那些在`#`和其后的新行（或 RE 的末尾）之间的字符一样。这样就允许我们给一个复杂的 RE分段和注释。不过这个基本规则有三种例外：
2171
2172
2173 - 空白字符或前置了`\`的`#`将被保留
2174
2175 - 方括号表达式里的空白或者`#`将被保留
2176
2177 - 在多字符符号里面不能出现空白和注释，例如`(?:`
2178
2179
2180为了这个目的，空白是空格、制表符、新行和任何属于*`空白`*字符类的字符。
2181
2182最后，在 ARE 里，方括号表达式外面，序列`(?#`*`ttt`*`)`（其中*`ttt`*是任意不包含一个`)`)的文本）是一个注释，它被完全忽略。同样，这样的东西是不允许出现在多字符符号的字符中间的，例如`(?:`。这种注释更像是一种历史产物而不是一种有用的设施，并且它们的使用已经被废弃；请使用扩展语法来替代。
2183
2184如果声明了一个初始的`***=`控制器，那么所有这些元语法扩展*都不能*使用，因为这样表示把用户输入当作一个文字串而不是RE 对待。
2185
2186
2187
2188
2189
2190
2191##### 正则表达式匹配规则
2192
2193
2194
2195
2196在 RE 可以在给定串中匹配多于一个子串的情况下， RE 匹配串中最靠前的那个子串。如果 RE 可以匹配在那个位置开始的多个子串，要么是取最长的子串，要么是最短的，具体哪种， 取决于 RE是*贪婪*的还是*非贪婪*的。
2197
2198一个 RE 是否贪婪取决于下面规则：
2199
2200
2201 - 大多数原子以及所有约束，都没有贪婪属性（因为它们毕竟无法匹配个数变化的文本）。
2202
2203 - 在一个 RE 周围加上圆括号并不会改变其贪婪性。
2204
2205 - 带一个固定重复次数量词 （`{`*`m`*`}`或者`{`*`m`*`}?`） 的量化原子和原子自身具有同样的贪婪性（可能是没有）。
2206
2207 - 一个带其他普通的量词（包括`{`*`m`*`,`*`n`*`}`中*`m`*等于*`n`*的情况）的量化原子是贪婪的（首选最长匹配）。
2208
2209 - 一个带非贪婪量词（包括`{`*`m`*`,`*`n`*`}?`中*`m`*等于 *`n`*的情况）的量化原子是非贪婪的（首选最短匹配）。
2210
2211 - 一个分支 — 也就是说，一个没有顶级`|`操作符的 RE — 和它里面的第一个有贪婪属性的量化原子有着同样的贪婪性。
2212
2213 - 一个由`|`操作符连接起来的两个或者更多分支组成的 RE 总是贪婪的。
2214
2215
2216上面的规则所描述的贪婪属性不仅仅适用于独立的量化原子， 而且也适用于包含量化原子的分支和整个 RE。这里的意思是， 匹配是按照分支或者整个 RE*作为一个整体*匹配最长或者最短的可能子串。
2217
2218一旦整个匹配的长度确定，那么匹配任意特定子表达式的部分就基于该子表达式的贪婪属性进行判断，在RE 里面靠前的子表达式的优先级高于靠后的子表达式。
2219
2220一个相应的例子：
2221
2222``` sql
2223palopgsql=# SELECT SUBSTRING('XY1234Z', 'Y*([0-9]{1,3})');
2224 substring
2225-----------
2226 123
2227(1 row)
2228
2229palopgsql=# SELECT SUBSTRING('XY1234Z', 'Y*?([0-9]{1,3})');
2230 substring
2231-----------
2232 1
2233(1 row)在第一个例子里，RE 作为整体是贪婪的，因为Y*是贪婪的。它可以匹配从Y开始的东西，并且它匹配从这个位置开始的最长的串，也就是，Y123。输出是这里的圆括号包围的部分，或者说是123。在第二个例子里， RE 总体上是一个非贪婪的RE，因为Y*?是非贪婪的。它可以匹配从Y开始的最短的子串，也就是说Y1。子表达式[0-9]{1,3}是贪婪的，但是它不能修改总体匹配长度的决定；因此它被迫只匹配1。
简而言之，如果一个 RE 同时包含贪婪和非贪婪的子表达式，那么总的匹配长度要么是尽可能长，要么是尽可能短，这取决于给整个 RE赋予的属性。给子表达式赋予的属性只影响在这个匹配里，各个子表达式之间相互允许“吃掉”的多少。
量词{1,1}和{1,1}?可以分别用于在一个子表达式 或者整个 RE 上强制贪婪或者非贪婪。当需要整个 RE 具有不同于从其元素中推导出的贪婪属性时，这很有用。例如，假设我们尝试将一个包含一些数字的 字符串分隔成数字以及在它们之前和之后的部分，我们可能会尝试这样做：
SQL
1palopgsql=# SELECT regexp_matches('abc01234xyz', '(.*)(\d+)(.*)');
2 regexp_matches
3-----------------
4 {abc0123,4,xyz}
5(1 row)这不会有用：第一个.*是贪婪的，因此它会“吃掉”尽可能多的字符而留下\d+去匹配在最后一个可能位置上的最 后一个数字。我们可能会通过让它变成非贪婪来修复：
SQL
1palopgsql=# SELECT regexp_matches('abc01234xyz', '(.*?)(\d+)(.*)');
2 regexp_matches
3----------------
4 {abc,0,""}
5(1 row)这也不会有用：因为现在 RE 作为整体来说是非贪婪的，因此它会尽快结束 全部的匹配。我们可以通过强制 RE 整体是贪婪的来得到我们想要的：
SQL
1palopgsql=# SELECT regexp_matches('abc01234xyz', '(?:(.*?)(\d+)(.*)){1,1}');
2 regexp_matches
3-----------------
4 {abc,01234,xyz}
5(1 row)独立于 RE 的组件的贪婪性之外控制 RE 的整体贪婪性为处理变长模式提供了 很大的灵活性。
在决定更长或者更短的匹配时，匹配长度是以字符衡量的，而不是排序元素。一个空串会被认为比什么都不匹配长。例如：bb*匹配abbbc的中间三个字符；(week|wee)(night|knights)匹配weeknights的所有十个字符；而(.*).*匹配 abc的时候，圆括号包围的子表达式匹配所有三个字符；当(a*)*被拿来匹配bc时，整个 RE 和圆括号子表达式都匹配一个空串。
如果声明了大小写无关的匹配，那么效果就好像所有大小写区别在字母表中消失了。如果在多个情况中一个字母以一个普通字符的形式出现在方括号表达式外面，那么它实际上被转换成一个包含大小写的方括号表达式，也就是说，x 变成 [xX]。 如果它出现在一个方括号表达式里面，那么它的所有大小写的同族都被加入方括号表达式中，也就是说，x变成[xX]。当它出现在一个方括号表达式内时，它的所有大小写副本都被加入到方括号表达式中，例如，[x]会变成[xX]，而[^x]会变成[^xX]。
如果指定了新行敏感的匹配，.和使用^的方括号表达式 将永远不会匹配新行字符（这样，匹配就绝对不会跨越新行，除非 RE显式地安排了这样的情况）并且^和$除了分别匹配串开头和结尾之外，还将分别匹配新行后面和前面的空串。但是ARE 转义\A和\Z仍然只匹配串的开头和结尾。
如果指定了部分新行敏感的匹配，那么它影响.和方括号表达式， 这个时候和新行敏感的匹配一样，但是不影响^和$。
如果指定了逆新行敏感匹配，那么它影响^和$，其作用和在新行敏感的匹配里一样，但是不影响.和方括号表达式。这个并不是很有用，只是为了满足对称性而提供的。
限制和兼容性说明
在PalopgSQL正则表达式实现里，对 RE 的长度没有特别的限制。但是，那些希望高移植性的程序应该避免使用长度超过 256 字节的 RE，因为 POSIX 兼容的实现可以拒绝接受这样的 RE。
ARE 实际上和 POSIX ERE 不兼容的唯一的特性是在方括号表达式里\并不失去它特殊的含义。所有其它 ARE 特性都使用在 POSIX ERE 里面是非法或者是未定义、未声明效果的语法；指示器的***就是在 POSIX 的 BRE 和 ERE 之外的语法。
许多 ARE 扩展都是从 Perl 那里借来的（但是有些被做了修改来清理它们），以及一些 Perl里没有出现的扩展。要注意的不兼容性包括\b、\B、对结尾的新行缺乏特别的处理、对那些被新行敏感匹配的东西附加的补齐方括号表达式、在lookahead/lookbehind 约束里对圆括号和后引用的限制以及最长/最短 匹配（而不是第一匹配）的语义。
基本正则表达式
BRE 在几个方面和 ERE 不太一样。在 BRE中，|、+和?都是普通字符并且没有与它们功能等价的东西。范围的定界符是\{和\}，因为 {和}本身是普通字符。嵌套的子表达式的圆括号是\(和\)，因为(和)自身是普通字符。除非在 RE开头或者是圆括号子表达式开头，^都是一个普通字符。 除非在 RE结尾或者是圆括号子表达式的结尾，$是一个普通字符。如果*出现在 RE开头或者是圆括号封装的子表达式开头（前面可能有^），那么它是个普通字符。最后，可以用单数字的后引用，\<和\>分别是[[:<:]]和[[:>:]]的同义词；在BRE 中没有其它可用的转义。
数据类型转换函数
PalopgSQL转换函数提供一套强大的工具用于把各种数据类型（日期/时间、整数、浮点、数字） 转换成格式化的字符串以及反过来从格式化的字符串转换成指定的数据类型。这些函数都遵循公共的调用规范：第一个参数是待格式化的值，而第二个是一个定义输出或输入格式的模板。
转换函数
注意
to_timestamp和to_date存在的目的是为了处理无法用简单造型转换的输入格式。对于大部分标准的日期/时间格式，简单地把源字符串造型成所需的数据类型是可以的，并且简单很多。类似地，对于标准的数字表示形式，to_number也是没有必要的。- 在一个
to_char输出模板串中，一些特定的模式可以被识别并且被替换成基于给定值的被恰当地格式化的数据。任何不属于模板模式的文本都简单地照字面拷贝。同样，在一个输入模板串里（对其他函数），模板模式标识由输入数据串提供的值。如果在模板字符串中有不是模板模式的字符，输入数据字符串中的对应字符会被简单地跳过（不管它们是否等于模板字符串字符）。
还有一个单一参数的to_timestamp函数，请见"日期/时间函数"
to_char()
语法
to_char(timestamp, text), to_char(interval, text), to_char(int, text), to_char(double precision, text), to_char(numeric, text)
返回类型 : text
描述
把时间戳转成字符串; 把间隔转成字符串; 把实数或双精度转成字符串; 把数字转成字符串
示例
SQL
1 palopgsql=# select to_char(current_timestamp, 'HH12:MI:SS');
2 to_char
3 ----------
4 03:40:21
5 (1 row)
6
7 palopgsql=# select to_char(interval '15h 2m 12s', 'HH24:MI:SS');
8 to_char
9 ----------
10 15:02:12
11 (1 row)
12
13 palopgsql=# select to_char(125, '999');
14 to_char
15 ---------
16 125
17 (1 row)
18
19 palopgsql=# select to_char(125.8::real, '999D9');
20 to_char
21 ---------
22 125.8
23 (1 row)
24
25 palopgsql=# select to_char(-125.8, '999D99S');
26 to_char
27 ---------
28 125.80-
29 (1 row)
30
31 palopgsql=# select to_char(current_timestamp, 'Day, DD HH12:MI:SS');
32 to_char
33 -------------------------
34 Monday , 28 03:56:00
35 (1 row)
36
37 palopgsql=# select to_char(current_timestamp, 'FMDay, FMDD HH12:MI:SS');
38 to_char
39 ----------------------
40 Monday, 28 03:56:00
41 (1 row)
42
43 palopgsql=# select to_char(-0.1, '99.99');
44 to_char
45 ---------
46 -.10
47 (1 row)
48
49 palopgsql=# select to_char(-0.1, 'FM9.99');
50 to_char
51 ---------
52 -.1
53 (1 row)
54
55 palopgsql=# select to_char(-0.1, 'FM90.99');
56 to_char
57 ---------
58 -0.1
59 (1 row)
60
61 palopgsql=# select to_char(0.1, '0.9');
62 to_char
63 ---------
64 0.1
65 (1 row)
66
67 palopgsql=# select to_char(12, '9990999.9');
68 to_char
69 ------------
70 0012.0
71 (1 row)
72
73 palopgsql=# select to_char(12, 'FM9990999.9');
74 to_char
75 ---------
76 0012.
77 (1 row)
78
79 palopgsql=# select to_char(485, '999');
80 to_char
81 ---------
82 485
83 (1 row)
84
85 palopgsql=# select to_char(-485, '999');
86 to_char
87 ---------
88 -485
89 (1 row)
90
91 palopgsql=# select to_char(485, '9 9 9');
92 to_char
93 ---------
94 4 8 5
95 (1 row)
96
97 palopgsql=# select to_char(1485, '9,999');
98 to_char
99 ---------
100 1,485
101 (1 row)
102
103 palopgsql=# select to_char(1485, '9G999');
104 to_char
105 ---------
106 1,485
107 (1 row)
108
109 palopgsql=# select to_char(148.5, '999.999');
110 to_char
111 ----------
112 148.500
113 (1 row)
114
115 palopgsql=# select to_char(148.5, 'FM999.999');
116 to_char
117 ---------
118 148.5
119 (1 row)
120
121 palopgsql=# select to_char(148.5, 'FM999.990');
122 to_char
123 ---------
124 148.500
125 (1 row)
126
127 palopgsql=# select to_char(148.5, '999D999');
128 to_char
129 ----------
130 148.500
131 (1 row)
132
133 palopgsql=# select to_char(3148.5, '9G999D999');
134 to_char
135 ------------
136 3,148.500
137 (1 row)
138
139 palopgsql=# select to_char(-485, '999S');
140 to_char
141 ---------
142 485-
143 (1 row)
144
145 palopgsql=# select to_char(-485, '999MI');
146 to_char
147 ---------
148 485-
149 (1 row)
150
151 palopgsql=# select to_char(485, '999MI');
152 to_char
153 ---------
154 485
155 (1 row)
156
157 palopgsql=# select to_char(485, 'FM999MI');
158 to_char
159 ---------
160 485
161 (1 row)
162
163 palopgsql=# select to_char(485, 'PL999');
164 to_char
165 ---------
166 + 485
167 (1 row)
168
169 palopgsql=# select to_char(485, 'SG999');
170 to_char
171 ---------
172 +485
173 (1 row)
174
175 palopgsql=# select to_char(-485, 'SG999');
176 to_char
177 ---------
178 -485
179 (1 row)
180
181 palopgsql=# select to_char(-485, '9SG99');
182 to_char
183 ---------
184 4-85
185 (1 row)
186
187 palopgsql=# select to_char(-485, '999PR');
188 to_char
189 ---------
190 <485>
191 (1 row)
192
193 palopgsql=# select to_char(485, 'L999');
194 to_char
195 ---------
196 485
197 (1 row)
198
199 palopgsql=# select to_char(485, 'RN');
200 to_char
201 -----------------
202 CDLXXXV
203 (1 row)
204
205 palopgsql=# select to_char(485, 'FMRN');
206 to_char
207 ---------
208 CDLXXXV
209 (1 row)
210
211 palopgsql=# select to_char(5.2, 'FMRN');
212 to_char
213 ---------
214 V
215 (1 row)
216
217 palopgsql=# select to_char(482, '999th');
218 to_char
219 ---------
220 482nd
221 (1 row)
222
223 palopgsql=# select to_char(485, '"Good number:"999');
224 to_char
225 ------------------
226 Good number: 485
227 (1 row)
228
229 palopgsql=# select to_char(485.8, '"Pre:"999" Post:" .999');
230 to_char
231 ---------------------
232 Pre: 485 Post: .800
233 (1 row)
234
235 palopgsql=# select to_char(12, '99V999');
236 to_char
237 ---------
238 12000
239 (1 row)
240
241 palopgsql=# select to_char(12.4, '99V999');
242 to_char
243 ---------
244 12400
245 (1 row)
246
247 palopgsql=# select to_char(12.45, '99V9');
248 to_char
249 ---------
250 125
251 (1 row)
252
253 palopgsql=# select to_char(0.0004859, '9.99EEEE');
254 to_char
255 -----------
256 4.86e-04
257 (1 row)
258 ```
259
260
261##### `to_date()`
262
263## 语法
264
265`to_date(text, text)`
266
267返回类型
268: date
269
270## 描述
271
272把字符串转成日期
273
274## 示例
275
276``` sql
277 palopgsql=# select to_date('05 Dec 2000', 'DD Mon YYYY');
278 to_date
279 ------------
280 2000-12-05
281 (1 row)
282 ```
283
284
285
286##### `to_number()`
287
288## 语法
289
290`to_number(text, text)`
291
292返回类型
293: numeric
294
295## 描述
296
297把字符串转成数字
298
299## 示例
300
301``` sql
302 palopgsql=# select to_number('12,454.8-', '99G999D9S');
303 to_number
304 -----------
305 -12454.8
306 (1 row)
307 ```
308
309
310
311##### `to_timestamp()`
312
313## 语法
314
315`to_timestamp(text, text)`
316
317返回类型
318: timestamp with time zone
319
320## 描述
321
322把字符串转成时间戳
323
324## 示例
325
326``` sql
327 palopgsql=# select to_timestamp('05 Dec 2000', 'DD Mon YYYY') ;
328 to_timestamp
329 ------------------------
330 2000-12-05 00:00:00+00
331 (1 row)
332 ```
333
334
335
336#### 用于日期/时间格式化的模板模式
337
338下文展示了可以用于格式化日期和时间值的模版。
339
340HH模式
341: 一天中的小时 （01-12）
342
343HH12模式
344: 一天中的小时 （01-12）
345
346HH24模式
347: 一天中的小时 （00-23）
348
349MI模式
350: 分钟 （00-59）minute (00-59)
351
352SS模式
353: 秒（00-59）
354
355MS模式
356: 毫秒（000-999）
357
358US模式
359: 微秒（000000-999999）
360
361SSSS模式
362: 午夜后的秒（0-86399）
363
364AM, am, PM or pm模式
365: 正午指示器（不带句号）
366
367A.M., a.m., P.M. or p.m.模式
368: 正午指示器（带句号）
369
370Y,YYY模式
371: 带逗号的年（4 位或者更多位）
372
373YYYY模式
374: 年（4 位或者更多位）
375
376YYY模式
377: 年的后三位
378
379YY模式
380: 年的后两位
381
382Y模式
383: 年的最后一位
384
385IYYY模式
386: ISO 8601 周编号方式的年（4 位或更多位）
387
388IYY模式
389: ISO 8601 周编号方式的年的最后 3 位
390
391IY模式
392: ISO 8601 周编号方式的年的最后 2 位
393
394I模式
395: ISO 8601 周编号方式的年的最后一位
396
397BC, bc, AD或者ad模式
398: 纪元指示器（不带句号）
399
400B.C., b.c., A.D.或者a.d.模式
401: 纪元指示器（带句号）
402
403MONTH模式
404: 全大写形式的月名（空格补齐到 9 字符）
405
406Month模式
407: 全首字母大写形式的月名（空格补齐到 9 字符）
408
409month模式
410: 全小写形式的月名（空格补齐到 9 字符）
411
412MON模式
413: 简写的大写形式的月名（英文 3 字符，本地化长度可变）
414
415Mon模式
416: 简写的首字母大写形式的月名（英文 3 字符，本地化长度可变）
417
418mon模式
419: 简写的小写形式的月名（英文 3 字符，本地化长度可变）
420
421MM模式
422: 月编号（01-12）
423
424DAY模式
425: 全大写形式的日名（空格补齐到 9 字符）
426
427Day模式
428: 全首字母大写形式的日名（空格补齐到 9 字符）
429
430day模式
431
432: 全小写形式的日名（空格补齐到 9 字符）
433
434DY模式
435: 简写的大写形式的日名（英语 3 字符，本地化长度可变）
436
437Dy模式
438: 简写的首字母大写形式的日名（英语 3 字符，本地化长度可变）
439
440dy模式
441: 简写的小写形式的日名（英语 3 字符，本地化长度可变）
442
443DDD模式
444: 一年中的日（001-366）
445
446IDDD模式
447: ISO 8601 周编号方式的年中的日（001-371，年的第 1 日时第一个 ISO 周的周一）
448
449DD模式
450: 月中的日（01-31）
451
452D模式
453: 周中的日，周日（1）到周六（7）
454
455ID模式
456: 周中的 ISO 8601 日，周一（1）到周日（7）
457
458W模式
459: 月中的周（1-5）（第一周从该月的第一天开始）
460
461WW模式
462: 年中的周数（1-53）（第一周从该年的第一天开始）
463
464IW模式
465: ISO 8601 周编号方式的年中的周数（01 - 53；新的一年的第一个周四在第一周）
466
467CC模式
468: 世纪（2 位数）（21 世纪开始于 2001-01-01）
469
470J模式
471: 儒略日（从午夜 UTC 的公元前 4714 年 11 月 24 日开始的整数日数）
472
473Q模式
474: 季度（to_date和to_timestamp会忽略）
475
476RM模式
477: 大写形式的罗马计数法的月（I-XII；I 是 一月）
478
479rm模式
480: 小写形式的罗马计数法的月（i-xii；i 是 一月）
481
482TZ模式
483: 大写形式的时区缩写（仅在to_char中支持）
484
485tz模式
486: 小写形式的时区缩写（仅在to_char中支持）
487
488TZH模式
489: 时区的小时
490
491TZM模式
492: 时区的分钟
493
494OF模式
495: 从UTC开始的时区偏移（仅在to_char中支持）
496
497#### 用于日期/时间格式化的模板模式修饰语
498
499修饰语可以被应用于模板模式来修改它们的行为。例如，`FMMonth`就是带着`FM`修饰语的`Month`模式。下文展示了可用于日期/时间格式化的修饰语模式。
500
501
502
503FM prefix
504: 填充模式（抑制前导零和填充的空格），示例：`FMMonth`
505
506
507TH suffix
508: 大写形式的序数后缀 ，示例：`DDTH`, e.g., `12TH`
509
510
511th suffix
512: 小写形式的序数后缀 ，示例：`DDth`, e.g., `12th`
513
514
515FX prefix
516: 固定的格式化全局选项（见使用须知），示例： `FX Month DD Day`
517
518
519TM prefix
520: 翻译模式（基于lc_time打印本地化的日和月名），示例： `TMMonth`
521
522
523SP suffix
524: 拼写模式（未实现），示例： `DDSP`
525
526
527
528#### 日期/时间格式化的使用须知
529
530
531 - `FM`抑制前导的零或尾随的空白，否则会把它们增加到输入从而把一个模式的输出变成固定宽度。在PalopgSQL中，`FM`只修改下一个声明，而在Oracle 中，`FM`影响所有随后的声明，并且重复的`FM`修饰语将触发填充模式开和关。
532
533 - `TM`不包括结尾空白。`to_timestamp`和`to_date`会忽略`TM`修饰语。
534
535 - 如果没有使用`FX`选项，`to_timestamp`和`to_date`会跳过输入字符串中的多个空白。例如，`to_timestamp('2000 JUN', 'YYYY MON')`是正确的，但`to_timestamp('2000 JUN', 'FXYYYY MON')`会返回一个错误，因为`to_timestamp`只期望一个空白。`FX`必须被指定为模板中的第一个项。
536
537 - 在`to_char`模板里可以有普通文本，并且它们会被照字面输出。你可以把一个子串放到双引号里强迫它被解释成一个文本，即使它里面包含模板模式也如此。例如，在 `'"Hello Year "YYYY'`中，`YYYY`将被年份数据代替，但是`Year`中单独的`Y`不会。在`to_date`、`to_number`以及`to_timestamp`中，文本和双引号字符串会导致跳过该字符串中所包含的字符数量，例如`"XX"`会跳过两个输入字符（不管它们是不是`XX`）。
538
539 - 如果想在输出里有双引号，那么你必须在它们前面放反斜线，例如 `'\"YYYY Month\"'`。不然，在双引号字符串外面的反斜线就不是特殊的。在双引号字符串内，反斜线会导致下一个字符被取其字面形式，不管它是什么字符（但是这没有特殊效果，除非下一个字符是一个双引号或者另一个反斜线）。
540
541 - 在`to_timestamp`和`to_date`中，如果年份格式声明少于四位（如`YYY`）并且提供的年份少于四位，年份将被调整为最接近于
542 2020 年，例如`95`会变成 1995。
543
544 - 在`to_timestamp`和`to_date`中，在处理超过4位数的年份时，`YYYY`转换具有限制。你必须在`YYYY`后面使用一些非数字字符或者模板，否则年份总是被解释为 4 位数字。例如（对于 20000 年）：`to_date('200001131','YYYYMMDD')`将会被解释成一个 4 位数字的年份，而不是在年份后使用一个非数字分隔符，像`to_date('20000-1131', 'YYYY-MMDD')`或`to_date('20000Nov31', 'YYYYMonDD')`。
545
546 - 在`to_timestamp`和`to_date`中，`CC`（世纪）字段会被接受，但是如果有`YYY`、`YYYY`或者`Y,YYY`字段则会忽略它。如果`CC`与`YY`或`Y`一起使用，则结果被计算为指定世纪中的那一年。如果指定了世纪但是没有指定年，则会假定为该世纪的第一年。
547
548 - 在`to_timestamp`和`to_date`中，工作日名称或编号（`DAY`、`D`以及相关的字段类型）会被接受，但会为了计算结果的目的而忽略。季度（`Q`）字段也是一样。
549
550 - 在`to_timestamp`和`to_date`中，一个 ISO 8601 周编号的日期（与一个格里高利日期相区别）可以用两种方法之一被指定为`to_timestamp`和`to_date`：
551
552
553 - 年、周编号和工作日：例如`to_date('2006-42-4', 'IYYY-IW-ID')`返回日期`2006-10-19`。如果你忽略工作日，它被假定为 1（周一）。
554
555 - 年和一年中的日：例如`to_date('2006-291', 'IYYY-IDDD')`也返回`2006-10-19`。
556
557
558 尝试使用一个混合了 ISO 8601 周编号和格里高利日期的域来输入一个日期是无意义的，并且将导致一个错误。在一个 ISO周编号的年的环境下，一个“月”或“月中的日”的概念没有意义。在一个格里高利年的环境下，ISO周没有意义。用户应当避免混合格里高利和 ISO 日期声明。
559
560
561 - 虽然`to_date`将会拒绝混合使用格里高利和 ISO 周编号日期的域， `to_char`却不会，因为`YYYY-MM-DD
562 (IYYY-IDDD)` 这种输出格式也会有用。但是避免写类似`IYYY-MM-DD`的东西，那会得到在起始年附近令人惊讶的结果。
563
564 - 在`to_timestamp`中，毫秒（`MS`）和微秒（`US`）域都被用作小数点后的秒位。例如`to_timestamp('12.3', 'SS.MS')`不是 3 毫秒, 而是 300，因为该转换把它看做 12 + 0.3秒。这意味着对于格式`SS.MS`而言，输入值`12.3`、`12.30`和`12.300`指定了相同数目的毫秒。要得到三毫秒，你必须使用 `12.003`，转换会把它看做 12 + 0.003 = 12.003 秒。
565
566 下面是一个更复杂的示例:`to_timestamp('15:12:02.020.001230', 'HH24:MI:SS.MS.US')`是 15 小时、12 分钟和 2 秒 + 20 毫秒 + 1230微秒 = 2.021230秒。
567
568 - `to_char(..., 'ID')`的一周中日的编号匹配`extract(isodow from ...)`函数，但是`to_char(..., 'D')`不匹配`extract(dow from ...)`的日编号。
569
570 - `to_char(interval)`格式化`HH`和`HH12`为显示在一个 12 小时的时钟上，即零小时和 36 小时输出为`12`，而`HH24`会输出完整的小时值，对于间隔它可以超过 23.
571
572
573
574#### 用于数字格式化的模板模式
575
576下文展示了可以用于格式化数字值的模版模式。
577
578`9`
579: 数位（如果无意义可以被删除）
580
581 `0`
582: 数位（即便没有意义也不会被删除）
583
584 `.` (period)
585: 小数点
586
587 `,` (comma)
588: 分组（千）分隔符
589
590 `PR`
591: 尖括号内的负值
592
593 `S`
594: 带符号的数字（使用区域）
595
596 `L`
597: 货币符号（使用区域）
598
599 `D`
600: 小数点（使用区域）
601
602 `G`
603: 分组分隔符（使用区域）
604
605 `MI`
606: 在指定位置的负号（如果数字 \< 0）
607
608 `PL`
609: 在指定位置的正号（如果数字 \> 0）
610
611 `SG`
612: 在指定位置的正/负号
613
614 `RN`
615: 罗马数字（输入在 1 和 3999 之间）
616
617 `TH` or `th`
618: 序数后缀
619
620
621 `V`
622: 移动指定位数（参阅注解）
623
624 `EEEE`
625: 科学记数的指数
626
627数字格式化的用法须知：
628
629
630 - `0`指定一个总是被打印的数位，即便它包含前导/拖尾的零。`9`也指定一个数位，但是如果它是前导零则会被空格替换，而如果是拖尾零并且指定了填充模式则它会被删除（对于`to_number()`来说，这两种模式字符等效）。
631
632 - 模式字符`S`、`L`、`D`以及`G`表示当前locale定义的负号、货币符号、小数点以及数字分隔符字符。不管locale是什么，模式字符句号和逗号就表示小数点和数字分隔符。
633
634 - 对于`to_char()`的模式中的一个负号，如果没有明确的规定，将为该负号保留一列，并且它将被锚接到（出现在左边）那个数字。如果`S`正好出现在某个`9`的左边，它也将被锚接到那个数字。
635
636 - 使用`SG`、`PL`或`MI`格式化的符号并不挂在数字上面； 例如，`to_char(-12, 'MI9999')`生成`'- 12'`，而`to_char(-12, 'S9999')`生成`' -12'`。（Oracle 里的实现不允许在`9`前面使用`MI`，而是要求`9`在`MI`前面。）
637
638 - `TH`不会转换小于零的数值，也不会转换小数。
639
640 - `PL`、`SG`和`TH`是PalopgSQL扩展。
641
642 - 在`to_number`中，如果没有使用`L`或`TH`之类的非数据模板模式，相应数量的输入字符会被跳过，不管它们是否匹配模板模式，除非它们是数据字符（也就是数位、负号、小数点或者逗号）。例如，`TH`会跳过两个非数据字符。
643
644 - 带有`to_char`的`V`会把输入值乘上`10^n`，其中*`n`*是跟在`V`后面的位数。带有`to_number`的`V`以类似的方式做除法。`to_char`和`to_number`不支持使用结合小数点的`V`（例如，不允许`99.9V99`）。
645
646 - `EEEE`（科学记数法）不能和任何其他格式化模式或修饰语（数字和小数点模式除外）组合在一起使用，并且必须位于格式化字符串的最后（例如`9.99EEEE`是一个合法的模式）。
647
648#### 用于数字格式化的模板模式修饰语
649
650某些修饰语可以被应用到任何模板来改变其行为。例如，`FM99.99`是带有`FM`修饰语的`99.99`模式。下文中展示了用于数字格式化模式修饰语。
651
652
653`FM prefix`
654: 填充模式（抑制拖尾零和填充的空白），示例：FM99.99
655
656
657`TH suffix`
658: 大写序数后缀 ，示例：999TH
659
660
661`th suffix`
662: 小写序数后缀 ，示例：999th评价此篇文章