华为云用户手册

示例 示例1：创建各种组合类型的二级分区表 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 CREATE TABLE list_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES ( '201902' ) ( SUBPARTITION p_201901_a VALUES ( '1' ), SUBPARTITION p_201901_b VALUES ( '2' ) ), PARTITION p_201902 VALUES ( '201903' ) ( SUBPARTITION p_201902_a VALUES ( '1' ), SUBPARTITION p_201902_b VALUES ( '2' ) ) ); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201902', '2', '1', 1); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); insert into list_list values('201903', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); select * from list_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (6 rows) drop table list_list; CREATE TABLE list_hash ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY LIST (month_code) SUBPARTITION BY HASH (dept_code) ( PARTITION p_201901 VALUES ( '201902' ) ( SUBPARTITION p_201901_a, SUBPARTITION p_201901_b ), PARTITION p_201902 VALUES ( '201903' ) ( SUBPARTITION p_201902_a, SUBPARTITION p_201902_b ) ); insert into list_hash values('201902', '1', '1', 1); insert into list_hash values('201902', '2', '1', 1); insert into list_hash values('201902', '3', '1', 1); insert into list_hash values('201903', '4', '1', 1); insert into list_hash values('201903', '5', '1', 1); insert into list_hash values('201903', '6', '1', 1); select * from list_hash; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 4 | 1 | 1 201903 | 5 | 1 | 1 201903 | 6 | 1 | 1 201902 | 2 | 1 | 1 201902 | 3 | 1 | 1 201902 | 1 | 1 | 1 (6 rows) drop table list_hash; CREATE TABLE list_range ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY LIST (month_code) SUBPARTITION BY RANGE (dept_code) ( PARTITION p_201901 VALUES ( '201902' ) ( SUBPARTITION p_201901_a values less than ('4'), SUBPARTITION p_201901_b values less than ('6') ), PARTITION p_201902 VALUES ( '201903' ) ( SUBPARTITION p_201902_a values less than ('3'), SUBPARTITION p_201902_b values less than ('6') ) ); insert into list_range values('201902', '1', '1', 1); insert into list_range values('201902', '2', '1', 1); insert into list_range values('201902', '3', '1', 1); insert into list_range values('201903', '4', '1', 1); insert into list_range values('201903', '5', '1', 1); insert into list_range values('201903', '6', '1', 1); ERROR: inserted partition key does not map to any table partition select * from list_range; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 4 | 1 | 1 201903 | 5 | 1 | 1 201902 | 1 | 1 | 1 201902 | 2 | 1 | 1 201902 | 3 | 1 | 1 (5 rows) drop table list_range; CREATE TABLE range_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY RANGE (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES LESS THAN( '201903' ) ( SUBPARTITION p_201901_a values ('1'), SUBPARTITION p_201901_b values ('2') ), PARTITION p_201902 VALUES LESS THAN( '201904' ) ( SUBPARTITION p_201902_a values ('1'), SUBPARTITION p_201902_b values ('2') ) ); insert into range_list values('201902', '1', '1', 1); insert into range_list values('201902', '2', '1', 1); insert into range_list values('201902', '1', '1', 1); insert into range_list values('201903', '2', '1', 1); insert into range_list values('201903', '1', '1', 1); insert into range_list values('201903', '2', '1', 1); select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 (6 rows) drop table range_list; CREATE TABLE range_hash ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY RANGE (month_code) SUBPARTITION BY HASH (dept_code) ( PARTITION p_201901 VALUES LESS THAN( '201903' ) ( SUBPARTITION p_201901_a, SUBPARTITION p_201901_b ), PARTITION p_201902 VALUES LESS THAN( '201904' ) ( SUBPARTITION p_201902_a, SUBPARTITION p_201902_b ) ); insert into range_hash values('201902', '1', '1', 1); insert into range_hash values('201902', '2', '1', 1); insert into range_hash values('201902', '1', '1', 1); insert into range_hash values('201903', '2', '1', 1); insert into range_hash values('201903', '1', '1', 1); insert into range_hash values('201903', '2', '1', 1); select * from range_hash; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 (6 rows) drop table range_hash; CREATE TABLE range_range ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY RANGE (month_code) SUBPARTITION BY RANGE (dept_code) ( PARTITION p_201901 VALUES LESS THAN( '201903' ) ( SUBPARTITION p_201901_a VALUES LESS THAN( '2' ), SUBPARTITION p_201901_b VALUES LESS THAN( '3' ) ), PARTITION p_201902 VALUES LESS THAN( '201904' ) ( SUBPARTITION p_201902_a VALUES LESS THAN( '2' ), SUBPARTITION p_201902_b VALUES LESS THAN( '3' ) ) ); insert into range_range values('201902', '1', '1', 1); insert into range_range values('201902', '2', '1', 1); insert into range_range values('201902', '1', '1', 1); insert into range_range values('201903', '2', '1', 1); insert into range_range values('201903', '1', '1', 1); insert into range_range values('201903', '2', '1', 1); select * from range_range; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 2 | 1 | 1 201903 | 1 | 1 | 1 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 (6 rows) drop table range_range; CREATE TABLE hash_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY hash (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 ( SUBPARTITION p_201901_a VALUES ( '1' ), SUBPARTITION p_201901_b VALUES ( '2' ) ), PARTITION p_201902 ( SUBPARTITION p_201902_a VALUES ( '1' ), SUBPARTITION p_201902_b VALUES ( '2' ) ) ); insert into hash_list values('201901', '1', '1', 1); insert into hash_list values('201901', '2', '1', 1); insert into hash_list values('201901', '1', '1', 1); insert into hash_list values('201903', '2', '1', 1); insert into hash_list values('201903', '1', '1', 1); insert into hash_list values('201903', '2', '1', 1); select * from hash_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 201901 | 2 | 1 | 1 201901 | 1 | 1 | 1 201901 | 1 | 1 | 1 (6 rows) drop table hash_list; CREATE TABLE hash_hash ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY hash (month_code) SUBPARTITION BY hash (dept_code) ( PARTITION p_201901 ( SUBPARTITION p_201901_a, SUBPARTITION p_201901_b ), PARTITION p_201902 ( SUBPARTITION p_201902_a, SUBPARTITION p_201902_b ) ); insert into hash_hash values('201901', '1', '1', 1); insert into hash_hash values('201901', '2', '1', 1); insert into hash_hash values('201901', '1', '1', 1); insert into hash_hash values('201903', '2', '1', 1); insert into hash_hash values('201903', '1', '1', 1); insert into hash_hash values('201903', '2', '1', 1); select * from hash_hash; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 201901 | 2 | 1 | 1 201901 | 1 | 1 | 1 201901 | 1 | 1 | 1 (6 rows) drop table hash_hash; CREATE TABLE hash_range ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY hash (month_code) SUBPARTITION BY range (dept_code) ( PARTITION p_201901 ( SUBPARTITION p_201901_a VALUES LESS THAN ( '2' ), SUBPARTITION p_201901_b VALUES LESS THAN ( '3' ) ), PARTITION p_201902 ( SUBPARTITION p_201902_a VALUES LESS THAN ( '2' ), SUBPARTITION p_201902_b VALUES LESS THAN ( '3' ) ) ); insert into hash_range values('201901', '1', '1', 1); insert into hash_range values('201901', '2', '1', 1); insert into hash_range values('201901', '1', '1', 1); insert into hash_range values('201903', '2', '1', 1); insert into hash_range values('201903', '1', '1', 1); insert into hash_range values('201903', '2', '1', 1); select * from hash_range; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 1 | 1 | 1 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201901 | 1 | 1 | 1 201901 | 1 | 1 | 1 201901 | 2 | 1 | 1 (6 rows) 示例2：对二级分区表进行DML指定分区操作 CREATE TABLE range_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY RANGE (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES LESS THAN( '201903' ) ( SUBPARTITION p_201901_a values ('1'), SUBPARTITION p_201901_b values ('2') ), PARTITION p_201902 VALUES LESS THAN( '201910' ) ( SUBPARTITION p_201902_a values ('1'), SUBPARTITION p_201902_b values ('2') ) ); --指定一级分区插入数据 insert into range_list partition (p_201901) values('201902', '1', '1', 1); --实际分区和指定分区不一致，报错 insert into range_list partition (p_201902) values('201902', '1', '1', 1); ERROR: inserted partition key does not map to the table partition DETAIL: N/A. --指定二级分区插入数据 insert into range_list subpartition (p_201901_a) values('201902', '1', '1', 1); --实际分区和指定分区不一致，报错 insert into range_list subpartition (p_201901_b) values('201902', '1', '1', 1); ERROR: inserted subpartition key does not map to the table subpartition DETAIL: N/A. insert into range_list partition for ('201902') values('201902', '1', '1', 1); insert into range_list subpartition for ('201902','1') values('201902', '1', '1', 1); --指定分区查询数据 select * from range_list partition (p_201901); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) select * from range_list subpartition (p_201901_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) select * from range_list partition for ('201902'); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) select * from range_list subpartition for ('201902','1'); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) --指定分区更新数据 update range_list partition (p_201901) set user_no = '2'; select * from range_list; select *from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 2 | 1 201902 | 1 | 2 | 1 201902 | 1 | 2 | 1 201902 | 1 | 2 | 1 (4 rows) update range_list subpartition (p_201901_a) set user_no = '3'; select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 3 | 1 201902 | 1 | 3 | 1 201902 | 1 | 3 | 1 201902 | 1 | 3 | 1 (4 rows) update range_list partition for ('201902') set user_no = '4'; select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 (4 rows) update range_list subpartition for ('201902','2') set user_no = '5'; openGauss=# select *from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 201902 | 1 | 4 | 1 (4 rows) select * from range_list; --指定分区删除数据 delete from range_list partition (p_201901); DELETE 4 delete from range_list partition for ('201903'); DELETE 0 delete from range_list subpartition (p_201901_a); DELETE 0 delete from range_list subpartition for ('201903','2'); DELETE 0 --指定分区insert数据 insert into range_list partition (p_201901) values('201902', '1', '1', 1) ON DUPLICATE KEY UPDATE sales_amt = 5; insert into range_list subpartition (p_201901_a) values('201902', '1', '1', 1) ON DUPLICATE KEY UPDATE sales_amt = 10; insert into range_list partition for ('201902') values('201902', '1', '1', 1) ON DUPLICATE KEY UPDATE sales_amt = 30; insert into range_list subpartition for ('201902','1') values('201902', '1', '1', 1) ON DUPLICATE KEY UPDATE sales_amt = 40; select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) --指定分区merge into数据 CREATE TABLE newrange_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY RANGE (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES LESS THAN( '201903' ) ( SUBPARTITION p_201901_a values ('1'), SUBPARTITION p_201901_b values ('2') ), PARTITION p_201902 VALUES LESS THAN( '201910' ) ( SUBPARTITION p_201902_a values ('1'), SUBPARTITION p_201902_b values ('2') ) ); insert into newrange_list values('201902', '1', '1', 1); insert into newrange_list values('201903', '1', '1', 2); MERGE INTO range_list partition (p_201901) p USING newrange_list partition (p_201901) np ON p.month_code= np.month_code WHEN MATCHED THEN UPDATE SET dept_code = np.dept_code, user_no = np.user_no, sales_amt = np.sales_amt WHEN NOT MATCHED THEN INSERT VALUES (np.month_code, np.dept_code, np.user_no, np.sales_amt); select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) MERGE INTO range_list partition for ('201901') p USING newrange_list partition for ('201901') np ON p.month_code= np.month_code WHEN MATCHED THEN UPDATE SET dept_code = np.dept_code, user_no = np.user_no, sales_amt = np.sales_amt WHEN NOT MATCHED THEN INSERT VALUES (np.month_code, np.dept_code, np.user_no, np.sales_amt); select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) MERGE INTO range_list subpartition (p_201901_a) p USING newrange_list subpartition (p_201901_a) np ON p.month_code= np.month_code WHEN MATCHED THEN UPDATE SET dept_code = np.dept_code, user_no = np.user_no, sales_amt = np.sales_amt WHEN NOT MATCHED THEN INSERT VALUES (np.month_code, np.dept_code, np.user_no, np.sales_amt); select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) MERGE INTO range_list subpartition for ('201901', '1') p USING newrange_list subpartition for ('201901', '1') np ON p.month_code= np.month_code WHEN MATCHED THEN UPDATE SET dept_code = np.dept_code, user_no = np.user_no, sales_amt = np.sales_amt WHEN NOT MATCHED THEN INSERT VALUES (np.month_code, np.dept_code, np.user_no, np.sales_amt); select * from range_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (4 rows) 示例3对二级分区表进行truncate操作 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 CREATE TABLE list_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES ( '201902' ) ( SUBPARTITION p_201901_a VALUES ( '1' ), SUBPARTITION p_201901_b VALUES ( default ) ), PARTITION p_201902 VALUES ( '201903' ) ( SUBPARTITION p_201902_a VALUES ( '1' ), SUBPARTITION p_201902_b VALUES ( '2' ) ) ); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201902', '2', '1', 1); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); insert into list_list values('201903', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); select * from list_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (6 rows) select * from list_list partition (p_201901); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (3 rows) alter table list_list truncate partition p_201901; select * from list_list partition (p_201901); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list partition (p_201902); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 (3 rows) alter table list_list truncate partition p_201902; select * from list_list partition (p_201902); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) insert into list_list values('201902', '1', '1', 1); insert into list_list values('201902', '2', '1', 1); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); insert into list_list values('201903', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); select * from list_list subpartition (p_201901_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (2 rows) alter table list_list truncate subpartition p_201901_a; select * from list_list subpartition (p_201901_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list subpartition (p_201901_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 (1 row) alter table list_list truncate subpartition p_201901_b; select * from list_list subpartition (p_201901_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list subpartition (p_201902_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 1 | 1 | 1 (1 row) alter table list_list truncate subpartition p_201902_a; select * from list_list subpartition (p_201902_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list subpartition (p_201902_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 (2 rows) alter table list_list truncate subpartition p_201902_b; select * from list_list subpartition (p_201902_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) drop table list_list; 示例4：对二级分区表进行split操作 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 CREATE TABLE list_list ( month_code VARCHAR2 ( 30 ) NOT NULL , dept_code VARCHAR2 ( 30 ) NOT NULL , user_no VARCHAR2 ( 30 ) NOT NULL , sales_amt int ) PARTITION BY LIST (month_code) SUBPARTITION BY LIST (dept_code) ( PARTITION p_201901 VALUES ( '201902' ) ( SUBPARTITION p_201901_a VALUES ( '1' ), SUBPARTITION p_201901_b VALUES ( default ) ), PARTITION p_201902 VALUES ( '201903' ) ( SUBPARTITION p_201902_a VALUES ( '1' ), SUBPARTITION p_201902_b VALUES ( default ) ) ); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201902', '2', '1', 1); insert into list_list values('201902', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); insert into list_list values('201903', '1', '1', 1); insert into list_list values('201903', '2', '1', 1); select * from list_list; month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 201903 | 1 | 1 | 1 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (6 rows) select * from list_list subpartition (p_201901_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (2 rows) select * from list_list subpartition (p_201901_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 (1 row) alter table list_list split subpartition p_201901_b values (2) into ( subpartition p_201901_b, subpartition p_201901_c ); select * from list_list subpartition (p_201901_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (2 rows) select * from list_list subpartition (p_201901_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 (1 row) select * from list_list subpartition (p_201901_c); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list partition (p_201901); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201902 | 2 | 1 | 1 201902 | 1 | 1 | 1 201902 | 1 | 1 | 1 (3 rows) select * from list_list subpartition (p_201902_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 1 | 1 | 1 (1 row) select * from list_list subpartition (p_201902_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 (2 rows) alter table list_list split subpartition p_201902_b values (3) into ( subpartition p_201902_b, subpartition p_201902_c ); select * from list_list subpartition (p_201902_a); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 1 | 1 | 1 (1 row) select * from list_list subpartition (p_201902_b); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- (0 rows) select * from list_list subpartition (p_201902_c); month_code | dept_code | user_no | sales_amt ------------+-----------+---------+----------- 201903 | 2 | 1 | 1 201903 | 2 | 1 | 1 (2 rows) drop table list_list;

语法格式 CREATE TABLE [ IF NOT EXISTS ] subpartition_table_name ( { column_name data_type [ COLLATE collation ] [ column_constraint [ ... ] ] | table_constraint | LIKE source_table [ like_option [...] ] }[, ... ] ) [ WITH ( {storage_parameter = value} [, ... ] ) ] [ COMPRESS | NOCOMPRESS ] [ TABLESPACE tablespace_name ] PARTITION BY {RANGE | LIST | HASH} (partition_key) SUBPARTITION BY {RANGE | LIST | HASH} (subpartition_key) ( PARTITION partition_name1 [ VALUES LESS THAN (val1) | VALUES (val1[, …]) ] [ TABLESPACE tablespace ] [( { SUBPARTITION subpartition_name1 [ VALUES LESS THAN (val1_1) | VALUES (val1_1[, …])] [ TABLESPACE tablespace ] } [, ...] )][, ...] )[ { ENABLE | DISABLE } ROW MOVEMENT ]; 列约束column_constraint： [ CONSTRAINT constraint_name ] { NOT NULL | NULL | CHECK ( expression ) | DEFAULT default_e xpr | GENERATED ALWAYS AS ( generation_expr ) STORED | UNIQUE index_parameters | PRIMARY KEY index_parameters | REFERENCES reftable [ ( refcolumn ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE | INITIALLY DEFERRED | INITIALLY IMMEDIATE ] 表约束table_constraint： [ CONSTRAINT constraint_name ] { CHECK ( expression ) | UNIQUE ( column_name [, ... ] ) index_parameters | PRIMARY KEY ( column_name [, ... ] ) index_parameters | FOREIGN KEY ( column_name [, ... ] ) REFERENCES reftable [ ( refcolumn [, ... ] ) ] [ MATCH FULL | MATCH PARTIAL | MATCH SIMPLE ] [ ON DELETE action ] [ ON UPDATE action ] } [ DEFERRABLE | NOT DEFERRABLE | INITIALLY DEFERRED | INITIALLY IMMEDIATE ] like选项like_option： { INCLUDING | EXCLUDING } { DEFAULTS | GENERATED | CONSTRAINTS | INDEXES | STORAGE | COMMENTS | RELOPTIONS| ALL } 索引存储参数index_parameters： [ WITH ( {storage_parameter = value} [, ... ] ) ] [ USING INDEX TABLESPACE tablespace_name ]

参数说明 IF NOT EXISTS 如果已经存在相同名称的表，不会抛出一个错误，而会发出一个通知，告知表关系已存在。 subpartition_table_name 二级分区表的名称。 取值范围：字符串，要符合标识符的命名规范。 column_name 新表中要创建的字段名。 取值范围：字符串，要符合标识符的命名规范。 data_type 字段的数据类型。 COLLATE collation COLLATE子句指定列的排序规则（该列必须是可排列的数据类型）。如果没有指定，则使用默认的排序规则。排序规则可以使用“select * from pg_collation;”命令从pg_collation系统表中查询，默认的排序规则为查询结果中以default开始的行。 CONSTRAINT constraint_name 列约束或表约束的名称。可选的约束子句用于声明约束，新行或者更新的行必须满足这些约束才能成功插入或更新。 定义约束有两种方法： 列约束：作为一个列定义的一部分，仅影响该列。 表约束：不和某个列绑在一起，可以作用于多个列。 LIKE source_table [ like_option ... ] 二级分区表暂不支持该功能。 WITH ( storage_parameter [= value] [, ... ] ) 这个子句为表或索引指定一个可选的存储参数。参数的详细描述如下所示： FILLFACTOR 一个表的填充因子（fillfactor）是一个介于10和100之间的百分数。100（完全填充）是默认值。如果指定了较小的填充因子，INSERT操作仅按照填充因子指定的百分率填充表页。每个页上的剩余空间将用于在该页上更新行，这就使得UPDATE有机会在同一页上放置同一条记录的新版本，这比把新版本放置在其他页上更有效。对于一个从不更新的表将填充因子设为100是最佳选择，但是对于频繁更新的表，选择较小的填充因子则更加合适。该参数对于列存表没有意义。 取值范围：10~100 ORIENTATION 决定了表的数据的存储方式。 取值范围： COLUMN：表的数据将以列式存储。 ROW（缺省值）：表的数据将以行式存储。 orientation不支持修改。 STORAGE_TYPE 指定存储引擎类型，该参数设置成功后就不再支持修改。 取值范围： USTORE，表示表支持Inplace-Update存储引擎。特别需要注意，使用USTORE表，必须要开启track_counts和track_activities参数，否则会引起空间膨胀。 ASTORE，表示表支持Append-Only存储引擎。 默认值： 不指定表时，默认是Append-Only存储。 COMPRESSION 列存表的有效值为LOW/MIDDLE/HIGH/YES/NO，压缩级别依次升高，默认值为LOW。 行存表不支持压缩。 MAX_BATCHROW 指定了在数据加载过程中一个存储单元可以容纳记录的最大数目。该参数只对列存表有效。 取值范围：10000~60000，默认60000。 PARTIAL_CLUSTER_ROWS 指定了在数据加载过程中进行将局部聚簇存储的记录数目。该参数只对列存表有效。 取值范围：大于等于MAX_BATCHROW，建议取值为MAX_BATCHROW的整数倍数。 DELTAROW_THRESHOLD 预留参数。该参数只对列存表有效。 取值范围：0～9999 segment 使用段页式的方式存储。本参数仅支持行存表。不支持列存表、临时表、unlog表。不支持ustore存储引擎。 取值范围：on/off 默认值：off COMPRESS / NOCOMPRESS 创建一个新表时，需要在创建表语句中指定关键字COMPRESS，这样，当对该表进行批量插入时就会触发压缩特性。该特性会在页范围内扫描所有元组数据，生成字典、压缩元组数据并进行存储。指定关键字NOCOMPRESS则不对表进行压缩。行存表不支持压缩。 缺省值为NOCOMPRESS，即不对元组数据进行压缩。 TABLESPACE tablespace_name 指定新表将要在tablespace_name表空间内创建。如果没有声明，将使用默认表空间。 PARTITION BY {RANGE | LIST | HASH} (partition_key) 对于partition_key，分区策略的分区键仅支持1列。 分区键支持的数据类型和一级分区表约束保持一致。 SUBPARTITION BY {RANGE | LIST | HASH} (subpartition_key) 对于subpartition_key，分区策略的分区键仅支持1列。 分区键支持的数据类型和一级分区表约束保持一致。 { ENABLE | DISABLE } ROW MOVEMENT 行迁移开关。 如果进行UPDATE操作时，更新了元组在分区键上的值，造成了该元组所在分区发生变化，就会根据该开关给出报错信息，或者进行元组在分区间的转移。 取值范围： ENABLE（缺省值）：行迁移开关打开。 DISABLE：行迁移开关关闭。 在打开行迁移开关情况下，并发update、delete操作可能会报错，原因如下： 目前GaussDB astore引擎下，update和delete操作对于旧数据都是标记为已删除。在打开行迁移开关情况下，如果更新分区键时，导致了跨分区更新，目前GaussDB astore引擎下，会把旧分区中旧数据标记为已删除，在新分区中新增加一条数据，无法通过旧数据找到新数据。 在以下三个并发场景下，update和update并发，delete和delete并发，update和delete并发，如果并发操作同一行数据时，数据跨分区和非跨分区结果有不同的行为。 对于数据非跨分区结果，第一个操作执行完后，第二个操作不会报错。 如果第一个操作是update，第二个操作能成功找到最新的数据，之后对新数据操作。 如果第一个操作是delete，第二个操作看到当前数据已经被删除而且找不到最新数据，就终止操作。 对于数据跨分区结果，第一个操作执行完后，第二个操作会报错。 如果第一个操作是update，由于新数据在新分区中，第二个操作不能成功找到最新的数据，就无法操作，之后会报错。 如果第一个操作是delete，第二个操作看到当前数据已经被删除而且找不到最新数据，但无法判断删除旧数据的操作是update还是delete。如果是update，报错处理。如果是delete，终止操作。为了保持数据的正确性，只能报错处理。 如果是update和update并发，update和delete并发场景，需要串行执行才能解决问题，如果是delete和delete并发，关闭行迁移开关可以解决问题。 NOT NULL 字段值不允许为NULL。ENABLE用于语法兼容，可省略。 NULL 字段值允许NULL ，这是缺省。 这个子句只是为和非标准SQL数据库兼容。不建议使用。 CHECK (condition) [ NO INHERIT ] CHECK约束声明一个布尔表达式，每次要插入的新行或者要更新的行的新值必须使表达式结果为真或未知才能成功，否则会抛出一个异常并且不会修改数据库。 声明为字段约束的检查约束应该只引用该字段的数值，而在表约束里出现的表达式可以引用多个字段。 用NO INHERIT标记的约束将不会传递到子表中去。 ENABLE用于语法兼容，可省略。 DEFAULT default_expr DEFAULT子句给字段指定缺省值。该数值可以是任何不含变量的表达式(不允许使用子查询和对本表中的其他字段的交叉引用)。缺省表达式的数据类型必须和字段类型匹配。 缺省表达式将被用于任何未声明该字段数值的插入操作。如果没有指定缺省值则缺省值为NULL 。 GENERATED ALWAYS AS ( generation_expr ) STORED 该子句将字段创建为生成列，生成列的值在写入（插入或更新）数据时由generation_expr计算得到，STORED表示像普通列一样存储生成列的值。 生成表达式不能以任何方式引用当前行以外的其他数据。生成表达式不能引用其他生成列，不能引用系统列。生成表达式不能返回结果集，不能使用子查询，不能使用聚集函数，不能使用窗口函数。生成表达式调用的函数只能是不可变（IMMUTABLE）函数。 不能为生成列指定默认值。 生成列不能作为分区键的一部分。 生成列不能和ON UPDATE约束字句的CASCADE,SET NULL,SET DEFAULT动作同时指定。生成列不能和ON DELETE约束字句的SET NULL,SET DEFAULT动作同时指定。 修改和删除生成列的方法和普通列相同。删除生成列依赖的普通列，生成列被自动删除。不能改变生成列所依赖的列的类型。 生成列不能被直接写入。在INSERT或UPDATE命令中, 不能为生成列指定值, 但是可以指定关键字DEFAULT。 生成列的权限控制和普通列一样。 列存表、内存表MOT不支持生成列。外表中仅postgres_fdw支持生成列。 UNIQUE index_parameters UNIQUE ( column_name [, ... ] ) index_parameters UNIQUE约束表示表里的一个字段或多个字段的组合必须在全表范围内唯一。 对于唯一约束，NULL被认为是互不相等的。 PRIMARY KEY index_parameters PRIMARY KEY ( column_name [, ... ] ) index_parameters 主键约束声明表中的一个或者多个字段只能包含唯一的非NULL值。 一个表只能声明一个主键。 DEFERRABLE | NOT DEFERRABLE 这两个关键字设置该约束是否可推迟。一个不可推迟的约束将在每条命令之后马上检查。可推迟约束可以推迟到事务结尾使用SET CONSTRAINTS命令检查。缺省是NOT DEFERRABLE。目前，UNIQUE约束、主键约束、外键约束可以接受这个子句。所有其他约束类型都是不可推迟的。 INITIALLY IMMEDIATE | INITIALLY DEFERRED 如果约束是可推迟的，则这个子句声明检查约束的缺省时间。 如果约束是INITIALLY IMMEDIATE（缺省），则在每条语句执行之后就立即检查它； 如果约束是INITIALLY DEFERRED ，则只有在事务结尾才检查它。 约束检查的时间可以用SET CONSTRAINTS命令修改。 USING INDEX TABLESPACE tablespace_name 为UNIQUE或PRIMARY KEY约束相关的索引声明一个表空间。如果没有提供这个子句，这个索引将在default_tablespace中创建，如果default_tablespace为空，将使用数据库的缺省表空间。

功能描述 创建二级分区表。分区表是把逻辑上的一张表根据某种方案分成几张物理块进行存储，这张逻辑上的表称之为分区表，物理块称之为分区。分区表是一张逻辑表，不存储数据，数据实际是存储在分区上的。对于二级分区表，顶层节点表和一级分区都是逻辑表，不存储数据，只有二级分区（叶子节点）存储数据。 二级分区表的分区方案是由两个一级分区的分区方案组合而来的，一级分区的分区方案详见章节CREATE TABLE PARTITION。 常见的二级分区表组合方案有Range-Range分区、Range-List分区、Range-Hash分区、List-Range分区、List-List分区、List-Hash分区、Hash-Range分区、Hash-List分区、Hash-Hash分区等。目前二级分区仅支持行存表。

注意事项 二级分区表有两个分区键，每个分区键只能支持1列，两个分区键不能是同一列。 唯一约束和主键约束的约束键包含所有分区键将为约束创建LOCAL索引，否则创建GLOBAL索引。如果指定创建local唯一索引，必须包含所有分区键。 创建二级分区表时，如果在其一级分区下不显示指定二级分区，会自动创建一个同范围的二级分区。 二级分区表的二级分区（叶子节点）个数不能超过1048575个，一级分区无限制，但一级分区下面至少有一个二级分区。 二级分区表的总分区数（包括一级分区和二级分区）最大值为1048575个，一般情况下业务不可能创建这么多分区，这样会导致内存不足。应参照参数local_syscache_threshold的值合理创建分区，二级分区表使用内存大致为（总分区数 * 3 / 1024）MB。理论上分区占用内存不允许大于local_syscache_threshold的值，同时还需要预留部分空间以供其他功能使用。 二级分区表只支持行存，不支持列存，hashbucket。 不支持cluster。 指定分区查询时，如select * from tablename partition/subpartition (partitionname)，关键字partition和subpartition注意不要写错。如果写错，查询不会报错，这时查询会变为对表起别名进行查询。 不支持密态数据库、账本数据库和行级访问控制。 对于二级分区表PARTITION FOR (values)语法，values只能是常量。 对于二级分区表PARTITION/SUBPARTITION FOR (values)语法，values在需要数据类型转换时，建议使用强制类型转换，以防隐式类型转换结果与预期不符。 指定分区语句目前不能走全局索引扫描。

更新表中数据 修改已经存储在数据库中数据的行为叫做更新。用户可以更新单独一行、所有行或者指定的部分行。还可以独立更新每个字段，而其他字段则不受影响。 使用UPDATE命令更新现有行，需要提供以下三种信息： 表的名称和要更新的字段名 字段的新值 要更新哪些行 SQL通常不会为数据行提供唯一标识，因此无法直接声明需要更新哪一行。但是可以通过声明一个被更新的行必须满足的条件。只有在表里存在主键的时候，才可以通过主键指定一个独立的行。 建立表和插入数据的步骤请参考创建表和向表中插入数据。 需要将表customer_t1中c_customer_sk为9527的地域重新定义为9876： 1 openGauss=# UPDATE customer_t1 SET c_customer_sk = 9876 WHERE c_customer_sk = 9527; 这里的表名称也可以使用模式名修饰，否则会从默认的模式路径找到这个表。SET后面紧跟字段和新的字段值。新的字段值不仅可以是常量，也可以是变量表达式。 比如，把所有c_customer_sk的值增加100： 1 openGauss=# UPDATE customer_t1 SET c_customer_sk = c_customer_sk + 100; 在这里省略了WHERE子句，表示表中的所有行都要被更新。如果出现了WHERE子句，那么只有匹配其条件的行才会被更新。 在SET子句中的等号是一个赋值，而在WHERE子句中的等号是比较。WHERE条件不一定是相等测试，许多其他的操作符也可以使用。 用户可以在一个UPDATE命令中更新更多的字段，方法是在SET子句中列出更多赋值，比如： 1 openGauss=# UPDATE customer_t1 SET c_customer_id = 'Admin', c_first_name = 'Local' WHERE c_customer_sk = 4421; 批量更新或删除数据后，会在数据文件中产生大量的删除标记，查询过程中标记删除的数据也是需要扫描的。故多次批量更新/删除后，标记删除的数据量过大会严重影响查询的性能。建议在批量更新/删除业务会反复执行的场景下，定期执行VACUUM FULL以保持查询性能。 父主题： 创建和管理表

分词器测试 函数ts_debug允许简单测试文本搜索分词器。 1 2 3 4 5 6 7 8 ts_debug([ config regconfig, ] document text, OUT alias text, OUT description text, OUT token text, OUT dictionaries regdictionary[], OUT dictionary regdictionary, OUT lexemes text[]) returns setof record ts_debug显示document的每个token信息，token是由解析器生成，由指定的词典进行处理。如果忽略对应参数，则使用config指定的分词器或者default_text_search_config指定的分词器。 ts_debug为文本解析器标识的每个token返回一行记录。记录中的列分别是： alias：text类型，token的别名。 description：text类型，token的描述。 token：text类型，token的文本内容。 dictionaries：regdictionary数组类型，是分词器为token选定的词典。 dictionary：regdictionary类型，用来识别token的词典。如果为空，则不做识别。 lexemes：text数组类型，词典识别token时生成的词素。如果为空，则不生成词素。空数组（{}）意味着token将被识别成停用词。 一个简单的例子： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 openGauss=# SELECT * FROM ts_debug('english','a fat cat sat on a mat - it ate a fat rats'); alias | description | token | dictionaries | dictionary | lexemes -----------+-----------------+-------+----------------+--------------+--------- asciiword | Word, all ASCII | a | {english_stem} | english_stem | {} blank | Space symbols | | {} | | asciiword | Word, all ASCII | fat | {english_stem} | english_stem | {fat} blank | Space symbols | | {} | | asciiword | Word, all ASCII | cat | {english_stem} | english_stem | {cat} blank | Space symbols | | {} | | asciiword | Word, all ASCII | sat | {english_stem} | english_stem | {sat} blank | Space symbols | | {} | | asciiword | Word, all ASCII | on | {english_stem} | english_stem | {} blank | Space symbols | | {} | | asciiword | Word, all ASCII | a | {english_stem} | english_stem | {} blank | Space symbols | | {} | | asciiword | Word, all ASCII | mat | {english_stem} | english_stem | {mat} blank | Space symbols | | {} | | blank | Space symbols | - | {} | | asciiword | Word, all ASCII | it | {english_stem} | english_stem | {} blank | Space symbols | | {} | | asciiword | Word, all ASCII | ate | {english_stem} | english_stem | {ate} blank | Space symbols | | {} | | asciiword | Word, all ASCII | a | {english_stem} | english_stem | {} blank | Space symbols | | {} | | asciiword | Word, all ASCII | fat | {english_stem} | english_stem | {fat} blank | Space symbols | | {} | | asciiword | Word, all ASCII | rats | {english_stem} | english_stem | {rat} (24 rows) 父主题： 测试和调试文本搜索

模式匹配操作符 数据库提供了三种独立的实现模式匹配的方法：SQL LIKE操作符、SIMILAR TO操作符和POSIX-风格的正则表达式。除了这些基本的操作符外，还有一些函数可用于提取或替换匹配子串并在匹配位置分离一个串。 LIKE 描述：判断字符串是否能匹配上LIKE后的模式字符串。如果字符串与提供的模式匹配，则LIKE表达式返回为真（NOT LIKE表达式返回假），否则返回为假（NOT LIKE表达式返回真）。 匹配规则： 此操作符只有在它的模式匹配整个串的时候才能成功。如果要匹配在串内任何位置的序列，该模式必须以百分号开头和结尾。 下划线 （_）代表（匹配）任何单个字符； 百分号（%）代表任意串的通配符。 要匹配文本里的下划线或者百分号，在提供的模式里相应字符必须前导逃逸字符。逃逸字符的作用是禁用元字符的特殊含义，缺省的逃逸字符是反斜线，也可以用ESCAPE子句指定一个不同的逃逸字符。 要匹配逃逸字符本身，写两个逃逸字符。例如要写一个包含反斜线的模式常量，那你就要在SQL语句里写两个反斜线。 参数standard_conforming_strings设置为off时，在文串常量中写的任何反斜线都需要被双写。因此，写一个匹配单个反斜线的模式实际上要在语句里写四个反斜线（你可以通过用ESCAPE选择一个不同的逃逸字符来避免这种情况，这样反斜线就不再是LIKE的特殊字符了。但仍然是字符文本分析器的特殊字符，所以你还是需要两个反斜线）。 在兼容MYSQL数据模式时，您也可以通过写ESCAPE ''的方式不选择逃逸字符，这样可以有效地禁用逃逸机制，但是没有办法关闭下划线和百分号在模式中的特殊含义。 关键字ILIKE可以用于替换LIKE，区别是LIKE大小写敏感，ILIKE大小写不敏感。 操作符~~等效于LIKE，操作符~~*等效于ILIKE。 示例： 1 2 3 4 5 openGauss=# SELECT 'abc' LIKE 'abc' AS RESULT; result ----------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' LIKE 'a%' AS RESULT; result ----------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' LIKE '_b_' AS RESULT; result ----------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' LIKE 'c' AS RESULT; result ----------- f (1 row) SIMILAR TO 描述：SIMILAR TO操作符根据自己的模式是否匹配给定串而返回真或者假。他和LIKE非常类似，只不过他使用SQL标准定义的正则表达式理解模式。 匹配规则： 和LIKE一样，此操作符只有在它的模式匹配整个串的时候才能成功。如果要匹配在串内任何位置的序列，该模式必须以百分号开头和结尾。 下划线 （_）代表（匹配）任何单个字符； 百分号（%）代表任意串的通配符。 SIMILAR TO也支持下面这些从POSIX正则表达式借用的模式匹配元字符。 元字符 含义 | 表示选择（两个候选之一） * 表示重复前面的项零次或更多次 + 表示重复前面的项一次或更多次 ? 表示重复前面的项零次或一次 {m} 表示重复前面的项刚好m次 {m,} 表示重复前面的项m次或更多次 {m,n} 表示重复前面的项至少m次并且不超过n次 () 把多个项组合成一个逻辑项 [...] 声明一个字符类，就像POSIX正则表达式一样 前导逃逸字符可以禁止所有这些元字符的特殊含义。逃逸字符的使用规则和LIKE一样。 正则表达式函数： 支持使用函数substring(string from pa...截取匹配SQL正则表达式的子字符串。 示例： 1 2 3 4 5 openGauss=# SELECT 'abc' SIMILAR TO 'abc' AS RESULT; result ----------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' SIMILAR TO 'a' AS RESULT; result ----------- f (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' SIMILAR TO '%(b|d)%' AS RESULT; result ----------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' SIMILAR TO '(b|c)%' AS RESULT; result ----------- f (1 row) POSIX正则表达式 描述：正则表达式是一个字符序列，它是定义一个串集合（一个正则集）的缩写。 如果一个串是正则表达式描述的正则集中的一员时， 我们就说这个串匹配该正则表达式。 POSIX正则表达式提供了比LIKE和SIMILAR TO操作符更强大的含义。表1列出了所有可用于POSIX正则表达式模式匹配的操作符。 表1 正则表达式匹配操作符 操作符 描述 例子 ~ 匹配正则表达式，大小写敏感 'thomas' ~ '.*thomas.*' ~* 匹配正则表达式，大小写不敏感 'thomas' ~* '.*Thomas.*' !~ 不匹配正则表达式，大小写敏感 'thomas' !~ '.*Thomas.*' !~* 不匹配正则表达式，大小写不敏感 'thomas' !~* '.*vadim.*' 匹配规则： 与LIKE不同，正则表达式允许匹配串里的任何位置，除非该正则表达式显式地挂接在串的开头或者结尾。 除了上文提到的元字符外， POSIX正则表达式还支持下列模式匹配元字符。 元字符 含义 ^ 表示串开头的匹配 $ 表示串末尾的匹配 . 匹配任意单个字符 正则表达式函数： POSIX正则表达式支持下面函数。 substring(string from pa...函数提供了抽取一个匹配POSIX正则表达式模式的子串的方法。 •regexp_count(string tex...函数提供了获取匹配POSIX正则表达式模式的子串数量的功能。 •regexp_instr(string tex...函数提供了获取匹配POSIX正则表达式模式子串位置的功能。 •regexp_substr(string te...函数提供了抽取一个匹配POSIX正则表达式模式的子串的方法。 regexp_replace(string, p...函数提供了将匹配POSIX正则表达式模式的子串替换为新文本的功能。 regexp_matches(string te...函数返回一个文本数组，该数组由匹配一个POSIX正则表达式模式得到的所有被捕获子串构成。 regexp_split_to_table(st...函数把一个POSIX正则表达式模式当作一个定界符来分离一个串。 regexp_split_to_array(st...和regexp_split_to_table类似，是一个正则表达式分离函数，不过它的结果以一个text数组的形式返回。 正则表达式分离函数会忽略零长度的匹配，这种匹配发生在串的开头或结尾或者正好发生在前一个匹配之后。这和正则表达式匹配的严格定义是相悖的，后者由regexp_matches实现，但是通常前者是实际中最常用的行为。 示例： 1 2 3 4 5 openGauss=# SELECT 'abc' ~ 'Abc' AS RESULT; result -------- f (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' ~* 'Abc' AS RESULT; result -------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' !~ 'Abc' AS RESULT; result -------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc'!~* 'Abc' AS RESULT; result -------- f (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' ~ '^a' AS RESULT; result -------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' ~ '(b|d)'AS RESULT; result -------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'abc' ~ '^(b|c)'AS RESULT; result -------- f (1 row) 虽然大部分的正则表达式搜索都能很快地执行，但是正则表达式仍可能被人为地弄成需要任意长的时间和任意量的内存进行处理。不建议从非安全模式来源接受正则表达式搜索模式，如果必须这样做，建议加上语句超时限制。使用SIMILAR TO模式的搜索具有同样的安全性危险， 因为SIMILAR TO提供了很多和POSIX-风格正则表达式相同的能力。LIKE搜索比其他两种选项简单得多，因此在接受非安全模式来源搜索时要更安全些。 父主题： 函数和操作符

PATTERN 很多\d命令都可以用一个PATTERN参数来指定要被显示的对象名称。在最简单的情况下，PATTERN正好就是该对象的准确名称。在PATTERN中的字符通常会被变成小写形式（就像在SQL名称中那样），例如\dt FOO将会显示名为foo的表。就像在SQL名称中那样，把PATTERN放在双引号中可以阻止它被转换成小写形式。如果需要在一个PATTERN中包括一个真正的双引号字符，则需要把它写成两个相邻的双引号，这同样是符合SQL引用标识符的规则。例如，\dt "FOO""BAR"将显示名为FOO"BAR（不是foo"bar）的表。和普通的SQL名称规则不同，不能只在PATTERN的一部分周围放上双引号，例如\dt FOO"FOO"BAR将会显示名为fooFOObar的表。 不使用PATTERN参数时，\d命令会显示当前schema搜索路径中可见的全部对象——这等价于用*作为PATTERN。所谓对象可见是指可以直接用名称引用该对象，而不需要用schema来进行限定。要查看数据库中所有的对象而不管它们的可见性，可以把*.*用作PATTERN。 如果放在一个PATTERN中，*将匹配任意字符序列（包括空序列），而?会匹配任意的单个字符（这种记号方法就像 Unix shell 的文件名PATTERN一样）。例如，\dt int*会显示名称以int开始的表。但是如果被放在双引号内，*和?就会失去这些特殊含义而变成普通的字符。 包含一个点号（.）的PATTERN被解释为一个schema名称模式后面跟上一个对象名称模式。例如，\dt foo*.*bar*会显示名称以foo开始的schema中所有名称包括bar的表。如果没有出现点号，那么模式将只匹配当前schema搜索路径中可见的对象。同样，双引号内的点号会失去其特殊含义并且变成普通的字符。 高级用户可以使用字符类等正则表达式记法，如[0-9]可以匹配任意数字。所有的正则表达式特殊字符都按照POSIX正则表达式所说的工作。以下字符除外： .会按照上面所说的作为一种分隔符。 *会被翻译成正则表达式记号.*。 ?会被翻译成.。 $则按字面意思匹配。 根据需要，可以通过书写?、(R+|)、(R|)和R?来分别模拟PATTERN字符.、R*和R?。$不需要作为一个正则表达式字符，因为PATTERN必须匹配整个名称，而不是像正则表达式的常规用法那样解释（换句话说，$会被自动地追加到PATTERN上）。如果不希望该PATTERN的匹配位置被固定，可以在开头或者结尾写上*。注意在双引号内，所有的正则表达式特殊字符会失去其特殊含义并且按照其字面意思进行匹配。另外，在操作符名称PATTERN中（即\do的PATTERN参数），正则表达式特殊字符也按照字面意思进行匹配。

tsquery tsquery类型表示一个检索条件，存储用于检索的词汇，并且使用布尔操作符&（AND），|（OR）和!（NOT）来组合他们，括号用来强调操作符的分组。to_tsquery函数及plainto_tsquery函数会将单词转换为tsquery类型前进行规范化处理。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 openGauss=# SELECT 'fat & rat'::tsquery; tsquery --------------- 'fat' & 'rat' (1 row) openGauss=# SELECT 'fat & (rat | cat)'::tsquery; tsquery --------------------------- 'fat' & ( 'rat' | 'cat' ) (1 row) openGauss=# SELECT 'fat & rat & ! cat'::tsquery; tsquery ------------------------ 'fat' & 'rat' & !'cat' (1 row) 在没有括号的情况下，!（非）结合的最紧密，而&（和）结合的比|（或）紧密。 tsquery中的词汇可以用一个或多个权字母来标记，这些权字母限制这次词汇只能与带有匹配权的tsvector词汇进行匹配。 1 2 3 4 5 openGauss=# SELECT 'fat:ab & cat'::tsquery; tsquery ------------------ 'fat':AB & 'cat' (1 row) 同样，tsquery中的词汇可以用*标记来指定前缀匹配： 1 2 3 4 5 openGauss=# SELECT 'super:*'::tsquery; tsquery ----------- 'super':* (1 row) 这个查询可以匹配tsvector中以“super”开始的任意单词。 请注意，前缀首先被文本搜索分词器处理，这也就意味着下面的结果为真： 1 2 3 4 5 openGauss=# SELECT to_tsvector( 'postgraduate' ) @@ to_tsquery( 'postgres:*' ) AS RESULT; result ---------- t (1 row) 因为postgres经过处理后得到postgr： 1 2 3 4 5 openGauss=# SELECT to_tsquery('postgres:*'); to_tsquery ------------ 'postgr':* (1 row) 这样就匹配postgraduate了。 'Fat:ab & Cats'规范化转为tsquery类型结果如下： 1 2 3 4 5 openGauss=# SELECT to_tsquery('Fat:ab & Cats'); to_tsquery ------------------ 'fat':AB & 'cat' (1 row)

tsvector tsvector类型表示一个检索单元，通常是一个数据库表中一行的文本字段或者这些字段的组合，tsvector类型的值是一个标准词位的有序列表，标准词位就是把同一个词的变型体都标准化成相同的，在输入的同时会自动排序和消除重复。to_tsvector函数通常用于解析和标准化文档字符串。 tsvector的值是唯一分词的分类列表，把一句话的词格式化为不同的词条，在进行分词处理的时候tsvector会自动去掉分词中重复的词条，按照一定的顺序录入。如： 1 2 3 4 5 openGauss=# SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector; tsvector ---------------------------------------------------- 'a' 'and' 'ate' 'cat' 'fat' 'mat' 'on' 'rat' 'sat' (1 row) 从上面的例子可以看出，通过tsvector把一个字符串按照空格进行分词，分词的顺序是按照长短和字母排序的。但是如果词条中需要包含空格或标点符号，可以用引号标记： 1 2 3 4 5 openGauss=# SELECT $$the lexeme ' ' contains spaces$$::tsvector; tsvector ------------------------------------------- ' ' 'contains' 'lexeme' 'spaces' 'the' (1 row) 如果在词条中使用引号，可以使用双$$符号作为标记： 1 2 3 4 5 openGauss=# SELECT $$the lexeme 'Joe''s' contains a quote$$::tsvector; tsvector ------------------------------------------------ 'Joe''s' 'a' 'contains' 'lexeme' 'quote' 'the' (1 row) 词条位置常量也可以放到词汇中： 1 2 3 4 5 openGauss=# SELECT 'a:1 fat:2 cat:3 sat:4 on:5 a:6 mat:7 and:8 ate:9 a:10 fat:11 rat:12'::tsvector; tsvector ------------------------------------------------------------------------------- 'a':1,6,10 'and':8 'ate':9 'cat':3 'fat':2,11 'mat':7 'on':5 'rat':12 'sat':4 (1 row) 位置常量通常表示文档中源字的位置。位置信息可以用于进行排名。位置常量的范围是1到16383，最大值默认是16383。相同词的重复位会被忽略掉。 拥有位置的词汇甚至可以用一个权来标记，这个权可以是A、B、C或D。默认的是D，因此输出中不会出现： 1 2 3 4 5 openGauss=# SELECT 'a:1A fat:2B,4C cat:5D'::tsvector; tsvector ---------------------------- 'a':1A 'cat':5 'fat':2B,4C (1 row) 权可以用来反映文档结构，如：标记标题与主体文字的区别。全文检索排序函数可以为不同的权标记分配不同的优先级。 下面的示例是tsvector类型标准用法。如： 1 2 3 4 5 openGauss=# SELECT 'The Fat Rats'::tsvector; tsvector -------------------- 'Fat' 'Rats' 'The' (1 row) 但是对于英文全文检索应用来说，上面的单词会被认为非规范化的，所以需要通过to_tsvector函数对这些单词进行规范化处理： 1 2 3 4 5 openGauss=# SELECT to_tsvector('english', 'The Fat Rats'); to_tsvector ----------------- 'fat':2 'rat':3 (1 row)

元命令 元命令的详细说明请参见表1、表2、表3、表4、表6、表8、表9、表10和表12。 以下命令中所提到的FILE代表文件路径。此路径可以是绝对路径（如/home/gauss/file.txt），也可以是相对路径（file.txt，file.txt会默认在用户执行gsql命令所在的路径下创建）。 表1 一般的元命令 参数 参数说明 取值范围 \copyright 显示GaussDB的版本和版权信息。 - \g [FILE] or ; 执行查询（并将结果发送到文件或管道）。 - \h(\help) [NAME] 给出指定SQL语句的语法帮助。 如果没有给出NAME，gsql将列出可获得帮助的所有命令。如果NAME是一个星号（*），则显示所有SQL语句的语法帮助。 \parallel [on [num]|off] 控制并发执行开关。 on：打开控制并发执行开关，且最大并发数为num。 off：关闭控制并发执行开关。 说明： 不支持事务中开启并发执行以及并发中开启事务。 不支持\d这类元命令的并发。 并发select返回结果混乱问题，此为客户可接受，core、进程停止响应不可接受。 不推荐在并发中使用set语句，否则导致结果与预期不一致。 不支持创建临时表！如需使用临时表，需要在开启parallel之前创建好，并在parallel内部使用。parallel内部不允许创建临时表。 \parallel执行时最多会启动num个独立的gsql进程连接服务器。 \parallel中所有作业的持续时间不能超过session_timeout，否则可能会导致并发执行过程中断连。 在\parallel on 之后一条或多条命令，会等到\parallel off执行后才会执行，因而，\parallel on之后需要有对应的\parallel off，否则\parallel on后的命令都无法执行。 num的默认值：1024。 须知： 服务器能接受的最大连接数受max_connection及当前已有连接数限制。 设置num时请考虑服务器当前可接受的实际连接数合理指定。 \q 退出gsql程序。在一个脚本文件里，只在脚本终止的时候执行。 - 表2 查询缓存区元命令 参数 参数说明 \e [FILE] [LINE] 使用外部编辑器编辑查询缓冲区（或者文件）。 \ef [FUNCNAME [LINE]] 使用外部编辑器编辑函数定义。如果指定了LINE（即行号），则光标会指到函数体的指定行。 \p 打印当前查询缓冲区到标准输出。 \r 重置（或清空）查询缓冲区。 \w FILE 将当前查询缓冲区输出到文件。 表3 输入/输出元命令 参数 参数说明 \copy { table [ ( column_list ) ] | ( query ) } { from | to } { filename | stdin | stdout | pstdin | pstdout } [ with ] [ binary ] [ oids ] [ delimiter [ as ] 'character' ] [ null [ as ] 'string' ] [ csv [ header ] [ quote [ as ] 'character' ] [ escape [ as ] 'character' ] [ force quote column_list | * ] [ force not null column_list ] ] [parallel integer] 在任何gsql客户端登录数据库成功后可以执行导入导出数据，这是一个运行SQL COPY命令的操作，但不是读取或写入指定文件的服务器，而是读取或写入文件，并在服务器和本地文件系统之间路由数据。这意味着文件的可访问性和权限是本地用户的权限，而不是服务器的权限，并且不需要数据库初始化用户权限。 说明： \COPY只适合小批量，格式良好的数据导入，不会对非法字符进行预处理，也无容错能力。导入数据应优先选择GDS或COPY。 \COPY 可以指定数据导入时的客户端数量，从而实现数据文件的并行导入，目前并发数范围为[1, 8]。 \COPY并行导入目前存在以下约束：临时表的并行导入不支持、在事务内的并行导入不支持、对二进制文件的并行导入不支持、数据导入支持AES128加密时不支持以及COPY选项中存在EOL。在这些情况下，即使指定了parallel参数，仍然会走非并行流程。 \echo [STRING] 把字符串写到标准输出。 \i FILE 从文件FILE中读取内容，并将其当作输入，执行查询。 \i+ FILE KEY 执行加密文件中的命令。 \ir FILE 和\i类似，只是相对于存放当前脚本的路径。 \ir+ FILE KEY 和\i+类似，只是相对于存放当前脚本的路径。 \o [FILE] 把所有的查询结果发送到文件里。 \qecho [STRING] 把字符串写到查询结果输出流里。 表4中的选项S表示显示系统对象，+表示显示对象附加的描述信息。PATTERN用来指定要被显示的对象名称。 表4 显示信息元命令 参数 参数说明 取值范围 示例 \d[S+] 列出当前search_path中模式下所有的表、视图和序列。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。 - 列出当前search_path中模式下所有的表、视图和序列。 1 openGauss=# \d \d[S+] NAME 列出指定表、视图和索引的结构。 - 假设存在表a，列出指定表a的结构。 1 openGauss=# \dtable+ a \d+ [PATTERN] 列出所有表、视图和索引。 如果声明了PATTERN，只显示名称匹配PATTERN的表、视图和索引。 列出所有名称以f开头的表、视图和索引。 1 openGauss=# \d+ f* \da[S] [PATTERN] 列出所有可用的聚集函数，以及它们操作的数据类型和返回值类型。 如果声明了PATTERN，只显示名称匹配PATTERN的聚集函数。 列出所有名称以f开头可用的聚集函数，以及它们操作的数据类型和返回值类型。 1 openGauss=# \da f* \db[+] [PATTERN] 列出所有可用的表空间。 如果声明了PATTERN，只显示名称匹配PATTERN的表空间。 列出所有名称以p开头的可用表空间。 1 openGauss=# \db p* \dc[S+] [PATTERN] 列出所有字符集之间的可用转换。 如果声明了PATTERN，只显示名称匹配PATTERN的转换。 列出所有字符集之间的可用转换。 1 openGauss=# \dc * \dC[+] [PATTERN] 列出所有类型转换。 PATTERN需要使用实际类型名，不能使用别名。 如果声明了PATTERN，只显示名称匹配PATTERN的转换。 列出所有名称以c开头的类型转换。 1 openGauss=# \dC c* \dd[S] [PATTERN] 显示所有匹配PATTERN的描述。 如果没有给出参数，则显示所有可视对象。“对象”包括：聚集、函数、操作符、类型、关系(表、视图、索引、序列、大对象)、规则。 列出所有可视对象。 1 openGauss=# \dd \ddp [PATTERN] 显示所有默认的使用权限。 如果指定了PATTERN，只显示名称匹配PATTERN的使用权限。 列出所有默认的使用权限。 1 openGauss=# \ddp \dD[S+] [PATTERN] 列出所有可用域。 如果声明了PATTERN，只显示名称匹配PATTERN的域。 列出所有可用域。 1 openGauss=# \dD \ded[+] [PATTERN] 列出所有的Data Source对象。 如果声明了PATTERN，只显示名称匹配PATTERN的对象。 列出所有的Data Source对象。 1 openGauss=# \ded \det[+] [PATTERN] 列出所有的外部表。 如果声明了PATTERN，只显示名称匹配PATTERN的表。 列出所有的外部表。 1 openGauss=# \det \des[+] [PATTERN] 列出所有的外部服务器。 如果声明了PATTERN，只显示名称匹配PATTERN的服务器。 列出所有的外部服务器。 1 openGauss=# \des \deu[+] [PATTERN] 列出用户映射信息。 如果声明了PATTERN，只显示名称匹配PATTERN的信息。 列出用户映射信息。 1 openGauss=#\deu \dew[+] [PATTERN] 列出封装的外部数据。 如果声明了PATTERN，只显示名称匹配PATTERN的数据。 列出封装的外部数据。 1 openGauss=# \dew \df[antw][S+] [PATTERN] 列出所有可用函数，以及它们的参数和返回的数据类型。a代表聚集函数，n代表普通函数，t代表触发器，w代表窗口函数。 如果声明了PATTERN，只显示名称匹配PATTERN的函数。 列出所有可用函数，以及它们的参数和返回的数据类型。 1 openGauss=# \df \dF[+] [PATTERN] 列出所有的文本搜索配置信息。 如果声明了PATTERN，只显示名称匹配PATTERN的配置信息。 列出所有的文本搜索配置信息。 1 openGauss=# \dF+ \dFd[+] [PATTERN] 列出所有的文本搜索字典。 如果声明了PATTERN，只显示名称匹配PATTERN的字典。 列出所有的文本搜索字典。 1 openGauss=# \dFd \dFp[+] [PATTERN] 列出所有的文本搜索分析器。 如果声明了PATTERN，只显示名称匹配PATTERN的分析器。 列出所有的文本搜索分析器。 1 openGauss=# \dFp \dFt[+] [PATTERN] 列出所有的文本搜索模板。 如果声明了PATTERN，只显示名称匹配PATTERN的模板。 列出所有的文本搜索模板。 1 openGauss=# \dFt \dg[+] [PATTERN] 列出所有数据库角色。 说明： 因为用户和群组的概念被统一为角色，所以这个命令等价于\du。为了和以前兼容，所以保留两个命令。 如果指定了PATTERN，只显示名称匹配PATTERN的角色。 列出名称为‘j_e’所有数据库角色。 1 openGauss=# \dg j?e \dl \lo_list的别名，显示一个大对象的列表。 - 列出所有的大对象。 1 openGauss=# \dl \dL[S+] [PATTERN] 列出可用的程序语言。 如果指定了PATTERN，只列出名称匹配PATTERN的语言。 列出可用的程序语言。 1 openGauss=# \dL \dm[S+] [PATTERN] 列出物化视图。 如果指定了PATTERN，只列出名称匹配PATTERN的物化视图。 列出物化视图。 1 openGauss=# \dm \dn[S+] [PATTERN] 列出所有模式（名称空间）。如果向命令追加+，会列出每个模式相关的权限及描述。 如果声明了PATTERN，只列出名称匹配PATTERN的模式名。缺省时，只列出用户创建的模式。 列出所有名称以d开头的模式以及相关信息。 1 openGauss=# \dn+ d* \do[S] [PATTERN] 列出所有可用的操作符，以及它们的操作数和返回的数据类型。 如果声明了PATTERN，只列出名称匹配PATTERN的操作符。缺省时，只列出用户创建的操作符。 列出所有可用的操作符，以及它们的操作数和返回的数据类型。 1 openGauss=# \do \dO[S+] [PATTERN] 列出排序规则。 如果声明了PATTERN，只列出名称匹配PATTERN的规则。缺省时，只列出用户创建的规则。 列出排序规则。 1 openGauss=# \dO \dp [PATTERN] 列出一列可用的表、视图以及相关的权限信息。 \dp显示结果如下： rolename=xxxx/yyyy --赋予一个角色的权限 =xxxx/yyyy --赋予public的权限 xxxx表示赋予的权限，yyyy表示授予这个权限的角色。权限的参数说明请参见表5。 如果指定了PATTERN，只列出名称匹配PATTERN的表、视图。 列出一列可用的表、视图以及相关的权限信息。 1 openGauss=# \dp \drds [PATTERN1 [PATTERN2]] 列出所有修改过的配置参数。这些设置可以是针对角色的、针对数据库的或者同时针对两者的。PATTERN1和PATTERN2表示要列出的角色PATTERN和数据库PATTERN。 如果声明了PATTERN，只列出名称匹配PATTERN的规则。缺省或指定*时，则会列出所有设置。 列出postgres数据库所有修改过的配置参数。 1 openGauss=# \drds *openGausss \dT[S+] [PATTERN] 列出所有的数据类型。 如果指定了PATTERN，只列出名称匹配PATTERN的类型。 列出所有的数据类型。 1 openGauss=# \dT \du[+] [PATTERN] 列出所有数据库角色。 说明： 因为用户和群组的概念被统一为角色，所以这个命令等价于\dg。为了和以前兼容，所以保留两个命令。 如果指定了PATTERN，则只列出名称匹配PATTERN的角色。 列出所有数据库角色。 1 openGauss=# \du \dE[S+] [PATTERN] \di[S+] [PATTERN] \ds[S+] [PATTERN] \dt[S+] [PATTERN] \dv[S+] [PATTERN] 这一组命令，字母E，i，s，t和v分别代表着外部表，索引，序列，表和视图。可以以任意顺序指定其中一个或者它们的组合来列出这些对象。例如：\dit列出所有的索引和表。在命令名称后面追加+，则每一个对象的物理尺寸以及相关的描述也会被列出。 如果指定了PATTERN，只列出名称匹配该PATTERN的对象。默认情况下只会显示用户创建的对象。通过PATTERN或者S修饰符可以把系统对象包括在内。 列出所有的索引和视图。 1 openGauss=# \div \dx[+] [PATTERN] 列出安装数据库的扩展信息。 如果指定了PATTERN，则只列出名称匹配PATTERN的扩展信息。 列出安装数据库的扩展信息。 1 openGauss=# \dx \l[+] 列出服务器上所有数据库的名称、所有者、字符集编码以及使用权限。 - 列出服务器上所有数据库的名称、所有者、字符集编码以及使用权限。 1 openGauss=# \l \sf[+] FUNCNAME 显示函数的定义。 说明： 对于带圆括号的函数名，需要在函数名两端添加双引号，并且在双引号后面加上参数类型列表。参数类型列表两端添加圆括号。 - 假设存在函数function_a和函数名带圆括号的函数func()name，列出函数的定义。 1 2 3 openGauss=# \sf function_a openGauss=# \sf "func()name"(argtype1, argtype2) \z [PATTERN] 列出数据库中所有表、视图和序列，以及它们相关的访问特权。 如果给出任何pattern ，则被当成一个正则表达式，只显示匹配的表、视图、序列。 列出数据库中所有表、视图和序列，以及它们相关的访问特权。 1 openGauss=# \z 表5 权限的参数说明 参数 参数说明 r SELECT：允许对指定的表、视图读取数据。 w UPDATE：允许对指定表更新字段。 a INSERT：允许对指定表插入数据。 d DELETE：允许删除指定表中的数据。 D TRUNCATE：允许清理指定表中的数据。 x REFERENCES：允许创建外键约束。 t TRIGGER：允许在指定表上创建触发器。 X EXECUTE：允许使用指定的函数，以及利用这些函数实现的操作符。 U USAGE： 对于过程语言，允许用户在创建函数时，指定过程语言。 对于模式，允许访问包含在指定模式中的对象。 对于序列，允许使用nextval函数。 C CREATE： 对于数据库，允许在该数据库里创建新的模式。 对于模式，允许在该模式中创建新的对象。 对于表空间，允许在其中创建表，以及允许创建数据库和模式的时候把该表空间指定为其缺省表空间。 c CONNECT：允许用户连接到指定的数据库。 T TEMPORARY：允许创建临时表。 A ALTER：允许用户修改指定对象的属性。 P DROP：允许用户删除指定的对象。 m COMMENT：允许用户定义或修改指定对象的注释。 i INDEX：允许用户在指定表上创建索引。 v VACUUM：允许用户对指定的表执行ANALYZE和VACUUM操作。 * 给前面权限的授权选项。 表6 格式化元命令 参数 参数说明 \a 对齐模式和非对齐模式之间的切换。 \C [STRING] 把正在打印的表的标题设置为一个查询的结果或者取消这样的设置。 \f [STRING] 对于不对齐的查询输出，显示或者设置域分隔符。 \H 若当前模式为文本格式，则切换为HTML输出格式。 若当前模式为HTML格式，则切换回文本格式。 \pset NAME [VALUE] 设置影响查询结果表输出的选项。NAME的取值见表7。 \t [on|off] 切换输出的字段名的信息和行计数脚注。 \T [STRING] 指定在使用HTML输出格式时放在table标签里的属性。如果参数为空，不设置。 \x [on|off|auto] 切换扩展行格式。 表7 可调节的打印选项 选项 选项说明 取值范围 border value必须是一个数字。通常这个数字越大，表的边界就越宽线就越多，但是这个取决于特定的格式。 在HTML格式下，取值范围为大于0的整数。 在其他格式下，取值范围： 0：无边框 1：内部分隔线 2：台架 expanded (或x) 在正常和扩展格式之间切换。 当打开扩展格式时，查询结果用两列显示，字段名称在左、数据在右。这个模式在数据无法放进通常的"水平"模式的屏幕时很有用。 在正常格式下，当查询输出的格式比屏幕宽时，用扩展格式。正常格式只对aligned和wrapped格式有用。 fieldsep 声明域分隔符来实现非对齐输出。这样就可以创建其他程序希望的制表符或逗号分隔的输出。要设置制表符域分隔符，键入\pset fieldsep '\t'。缺省域分隔符是 '|' (竖条符)。 - fieldsep_zero 声明域分隔符来实现非对齐输出到零字节。 - footer 用来切换脚注。 - format 设置输出格式。允许使用唯一缩写（这意味着一个字母就够了）。 取值范围： unaligned：写一行的所有列在一条直线上中，当前活动字段分隔符分隔。 aligned：此格式是标准的，可读性好的文本输出。 wrapped：类似aligned，但是包装跨行的宽数据值，使其适应目标字段的宽度输出。 html：把表输出为可用于文档里的对应标记语言。输出不是完整的文档。 latex：把表输出为可用于文档里的对应标记语言。输出不是完整的文档。 troff-ms：把表输出为可用于文档里的对应标记语言。输出不是完整的文档。 null 打印一个字符串，用来代替一个null值。 缺省是什么都不打印，这样很容易和空字符串混淆。 numericlocale 切换分隔小数点左边的数值的区域相关的分组符号。 on：显示指定的分隔符。 off：不显示分隔符。 忽略此参数，显示默认的分隔符。 pager 控制查询和gsql帮助输出的分页器。如果设置了环境变量PAGER，输出将被指向到指定程序，否则使用系统缺省。 on：当输出到终端且不适合屏幕显示时，使用分页器。 off：不使用分页器。 always：当输出到终端无论是否符合屏幕显示时，都使用分页器。 recordsep 声明在非对齐输出格式时的记录分隔符。 - recordsep_zero 声明在非对齐输出到零字节时的记录分隔符。 - tableattr（或T） 声明放在html输出格式中HTML table标签的属性（例如：cellpadding或bgcolor）。注意：这里可能不需要声明border，因为已经在\pset border里用过了。如果没有给出value，则不设置表的属性。 - title 为随后打印的表设置标题。这个可以用于给输出一个描述性标签。如果没有给出value，不设置标题。 - tuples_only （或者t） 在完全显示和只显示实际的表数据之间切换。完全显示将输出像列头、标题、各种脚注等信息。在tuples_only模式下，只显示实际的表数据。 - feedback 切换是否输出结果行数 - 表8 连接元命令 参数 参数说明 取值范围 \c[onnect] [DBNAME|- USER|- HOST|- PORT|-] 连接到一个新的数据库（当前数据库为postgres）。当数据库名称长度超过63个字节时，默认前63个字节有效，连接到前63个字节对应的数据库，但是gsql的命令提示符中显示的数据库对象名仍为截断前的名称。 说明： 重新建立连接时，如果切换数据库登录用户，将可能会出现交互式输入，要求输入新用户的连接密码。该密码最长长度为999字节，受限于GUC参数password_max_length的最大值。 - \encoding [ENCODING] 设置客户端字符编码格式。 不带参数时，显示当前的编码格式。 \conninfo 输出当前连接的数据库的信息。 - 表9 操作系统元命令 参数 参数说明 取值范围 \cd [DIR] 切换当前的工作目录。 绝对路径或相对路径，且满足操作系统路径命名规则。 \setenv NAME [VALUE] 设置环境变量NAME为VALUE，如果没有给出VALUE值，则不设置环境变量。 - \timing [on|off] 以毫秒为单位显示每条SQL语句的执行时间。 on表示打开显示。 off表示关闭显示。 \! [COMMAND] 返回到一个单独的Unix shell或者执行Unix命令COMMAND。 - 表10 变量元命令 参数 参数说明 \prompt [TEXT] NAME 提示用户用文本格式来指定变量名称。 \set [NAME [VALUE]] 设置内部变量NAME为VALUE或者如果给出了多于一个值，设置为所有这些值的连接结果。如果没有给出第二个参数，只设变量不设值。 有一些常用变量被gsql特殊对待，它们是一些选项设置，通常所有特殊对待的变量都是由大写字母组成(可能还有数字和下划线)。 表11是一个所有特殊对待的变量列表。 \unset NAME 不设置（或删除）gsql变量名。 表11 \set常用命令 名称 命令说明 取值范围 \set VERBOSITY value 这个选项可以设置为值default，verbose，terse之一以控制错误报告的冗余行。 value取值范围：default， verbose，terse \set ON_ERROR_STOP value 如果设置了这个变量，脚本处理将马上停止。如果该脚本是从另外一个脚本调用的，那个脚本也会按同样的方式停止。如果最外层的脚本不是从一次交互的gsql会话中调用的而是用-f选项调用的，gsql将返回错误代码3，以示这个情况与致命错误条件的区别(错误代码为1)。 value取值范围为：on/off，true/false，yes/no，1/0 \set AUTOCOMMIT [on|off] 设置当前gsql连接的自动提交行为，on为打开自动提交，off为关闭自动提交。默认情况下，gsql连接处于自动提交模式，每个单独的语句都被隐式提交。如果基于性能或者其它方面考虑，需要关闭自动提交时，需要用户自己显示的发出COMMIT命令来保证事务的提交。例如，在指定的业务SQL执行完之后发送COMMIT语句显式提交，特别是gsql客户端退出之前务必保证所有的事务已经提交。 说明： gsql默认使用自动提交模式，若关闭自动提交，将会导致后面执行的语句都受到隐式事务包裹，数据库中不支持在事务中执行的语句不能在此模式下执行。 on表示打开自动提交。 off表示关闭自动提交。 \set RETRY [retry_times] 用于控制是否开启语句出错场景下的重试功能，参数retry_times用来指定最大重试次数，缺省值为5，取值范围为5-10。当重试功能已经开启时，再次执行\set RETRY可以关闭该功能。 使用配置文件retry_errcodes.conf列举需要重试的错误码列表，该文件和gsql可执行程序位于同一级目录下。该配置文件为系统配置，非用户定义，不允许用户直接修改。 当前支持以下出错场景的重试： YY002：TCP通信错误，Connection reset by peer（DN和DN间通信） YY003：锁超时，Lock wait timeout.../wait transaction xxx sync time exceed xxx YY004：TCP通信错误，Connection timed out YY005：SET命令发送失败，ERROR SET query YY006：内存申请失败，memory is temporarily unavailable YY007：通信库错误，Memory allocate error YY008：通信库错误，No data in buffer YY009：通信库错误，Close because release memory YY010：通信库错误，TCP disconnect YY011：通信库错误，SCTP disconnect（由于规格变更，当前版本已经不再支持本特性，请不要使用） YY012：通信库错误，Stream closed by remote YY013：通信库错误，Wait poll unknown error 同时，出错时gsql会查询所有DN的连接状态，当状态异常时会sleep1分钟再进行重试，能够覆盖大部分主备切换场景下的出错重试。 说明： 不支持事务块中的语句错误重试。 不支持通过ODBC、JDBC接口查询的出错重试。 含有unlogged表的sql语句，不支持节点故障后的出错重试。 gsql客户端本身出现的错误，不在重跑考虑范围之内。 retry_times取值范围为：5-10 表12 大对象元命令 参数 参数说明 \lo_list 显示一个目前存储在该数据库里的所有GaussDB大对象和提供给他们的注释。

注意事项 一个gsql元命令的格式是反斜杠后面紧跟一个动词，然后是任意参数。参数命令动词和其他参数以任意个空白字符间隔。 要在参数里面包含空白，必须用单引号把它引起来。要在这样的参数里包含单引号，可以在前面加一个反斜杠。任何包含在单引号里的内容都会被进一步进行类似C语言的替换：\n（新行）、\t（制表符）、\b（退格）、\r（回车）、\f（换页）、\digits（八进制表示的字符）、\xdigits（十六进制表示的字符）。 用""包围的内容被当做一个命令行传入shell。该命令的输出（删除了结尾的新行）被当做参数值。 如果不带引号的参数以冒号（:）开头，它会被当做一个gsql变量，并且该变量的值最终会成为真正的参数值。 有些命令以一个SQL标识的名称（比如一个表）为参数。这些参数遵循SQL语法关于双引号的规则：不带双引号的标识强制转换成小写，而双引号保护字母不进行大小写转换，并且允许在标识符中使用空白。在双引号中，成对的双引号在结果名称中分析成一个双引号。比如，FOO"BAR"BAZ解析成fooBARbaz；而"Aweird""name"解析成A weird"name。 对参数的分析在遇到另一个不带引号的反斜杠时停止。这里会认为是一个新的元命令的开始。特殊的双反斜杠序列（\\）标识参数的结尾并将继续分析后面的SQL语句（如果存在）。这样SQL和gsql命令可以自由的在一行里面混合。但是在任何情况下，一条元命令的参数不能延续超过行尾。

示例 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 --在存储过程中操作RAW数据 CREATE OR REPLACE PROCEDURE proc_raw AS str varchar2(100) := 'abcdef'; source raw(100); amount integer; BEGIN source := dbe_raw.cast_from_varchar2_to_raw(str);--类型转换 amount := dbe_raw.get_length(source);--获取长度 dbe_output.print_line(amount); END; / --调用存储过程 CALL proc_raw(); --删除存储过程 DROP PROCEDURE proc_raw;

接口介绍 高级功能包DBE_RAW支持的所有接口请参见表 DBE_RAW。 表1 DBE_RAW 接口名称 描述 DBE_RAW.CAST_FROM_BINARY_INTEGER_TO_RAW 将INTEGER类型值转换为二进制表示形式（即RAW类型）。 DBE_RAW.CAST_FROM_RAW_TO_BINARY_INTEGER 将二进制表示形式的整型值（即RAW类型）转换为INTEGER类型。 DBE_RAW.GET_LENGTH 获取RAW类型对象的长度。 DBE_RAW.CAST_FROM_VARCHA... 将VARCHAR2类型值转化为二进制表示形式（即RAW类型）。 DBE_RAW.CAST_TO_VARCHAR2 将RAW类型值转换成VARCHAR2类型。 DBE_RAW.BIT_OR RAW类型按位或。 DBE_RAW.SUBSTR 求RAW类型子串。 RAW类型的外部表现形式是十六进制，内部存储形式是二进制。例如一个RAW类型的数据11001011的表现形式为‘CB’，即在实际的类型转换中输入的是‘CB’。 DBE_RAW.CAST_FROM_BINARY_INTEGER_TO_RAW 存储过程CAST_FROM_BINARY_INTEGER_TO_RAW将INTEGER类型值转换为二进制表示形式（即RAW类型）。 DBE_RAW.CAST_FROM_BINARY_INTEGER_TO_RAW函数原型为： 1 2 3 4 DBE_RAW.CAST_FROM_BINARY_INTEGER_TO_RAW ( value IN INTEGER, endianess IN INTEGER DEFAULT 1) RETURN RAW; 表2 DBE_RAW.CAST_FROM_BINARY_INTEGER_TO_RAW接口参数说明 参数 描述 value 待转成RAW类型的整型数值。 endianess 表示字节序的整型值1或2（1代表BIG_ENDIAN，2代表LITTLE-ENDIAN）。 DBE_RAW.CAST_FROM_RAW_TO_BINARY_INTEGER 存储过程CAST_FROM_RAW_TO_BINARY_INTEGER将二进制表示形式的整型值（即RAW类型）转换为INTEGER类型。 DBE_RAW.CAST_FROM_RAW_TO_BINARY_INTEGER函数原型为： 1 2 3 4 DBE_RAW.CAST_FROM_RAW_TO_BINARY_INTEGER ( value IN RAW, endianess IN INTEGER DEFAULT 1) RETURN BINARY_INTEGER; 表3 DBE_RAW.CAST_FROM_RAW_TO_BINARY_INTEGER接口参数说明 参数 描述 value 二进制表示形式的整型值（即RAW类型）。 endianess 表示字节序的整型值1或2（1代表BIG_ENDIAN，2代表LITTLE-ENDIAN）。 DBE_RAW.GET_LENGTH 存储过程GET_LENGTH返回RAW类型对象的长度。 DBE_RAW.GET_LENGTH函数原型为： 1 2 3 DBE_RAW.GET_LENGTH( value IN RAW) RETURN INTEGER; 表4 DBE_RAW.GET_LENGTH接口参数说明 参数 描述 value RAW类型对象 DBE_RAW.CAST_FROM_VARCHAR2_TO_RAW 存储过程CAST_FROM_VARCHAR2_TO_RAW将VARCHAR2类型的对象转换成RAW类型。 DBE_RAW.CAST_FROM_VARCHAR2_TO_RAW函数原型为： 1 2 3 DBE_RAW.CAST_TO_RAW( str IN VARCHAR2) RETURN RAW; 表5 DBE_RAW.CAST_FROM_VARCHAR2_TO_RAW接口参数说明 参数 描述 c 待转换的VARCHAR2类型对象 DBE_RAW.CAST_TO_VARCHAR2 存储过程CAST_TO_VARCHAR2将RAW类型的对象转换成VARCHAR2类型。 DBE_RAW.CAST_TO_VARCHAR2函数原型为： 1 2 3 DBE_RAW.CAST_TO_VARCHAR2( str IN RAW) RETURN VARCHAR2; 表6 DBE_RAW.CAST_TO_VARCHAR2接口参数说明 参数 描述 str 待转换的RAW类型对象 DBE_RAW.BIT_OR 存储过程BIT_OR求两个RAW按位或的结果。 DBE_RAW.BIT_OR函数原型为： 1 2 3 4 DBE_RAW.BIT_OR( str1 IN RAW, str2 IN RAW) RETURN RAW; 表7 DBE_RAW.BIT_OR接口参数说明 参数 描述 str1 按位或的第一个字符串 str2 按位或的第二个字符串 DBE_RAW.SUBSTR 存储过程SUBSTR将RAW类型的对象按起始位和长度截取。 DBE_RAW.SUBSTR函数原型为： 1 2 3 4 5 DBE_RAW.SUBSTR( IN lob_loc raw, IN off_set integer default 1, IN amount integer default 32767) RETURN RAW; 表8 DBE_RAW.SUBSTR接口参数说明 参数 描述 lob_loc 源raw字符串。 off_set 子串的起始位置，默认值1。 amount 子串的长度，默认值32767。

位串类型 位串就是一串1和0的字符串。它们可以用于存储位掩码。 GaussDB支持两种位串类型：bit(n)和bit varying(n)，这里的n是一个正整数。 bit类型的数据必须准确匹配长度n，如果存储短或者长的数据都会报错。bit varying类型的数据是最长为n的变长类型，超过n的类型会被拒绝。一个没有长度的bit等效于bit(1)，没有长度的bit varying表示没有长度限制。 如果用户明确地把一个位串值转换成bit(n)，则此位串右边的内容将被截断或者在右边补齐零，直到刚好n位，而不会抛出任何错误。 如果用户明确地把一个位串数值转换成bit varying(n)，如果它超过了n位，则它的右边将被截断。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 --创建表。 openGauss=# CREATE TABLE bit_type_t1 ( BT_COL1 INTEGER, BT_COL2 BIT(3), BT_COL3 BIT VARYING(5) ) ; --插入数据。 openGauss=# INSERT INTO bit_type_t1 VALUES(1, B'101', B'00'); --插入数据的长度不符合类型的标准会报错。 openGauss=# INSERT INTO bit_type_t1 VALUES(2, B'10', B'101'); ERROR: bit string length 2 does not match type bit(3) CONTEXT: referenced column: bt_col2 --将不符合类型长度的数据进行转换。 openGauss=# INSERT INTO bit_type_t1 VALUES(2, B'10'::bit(3), B'101'); --查看数据。 openGauss=# SELECT * FROM bit_type_t1; bt_col1 | bt_col2 | bt_col3 ---------+---------+--------- 1 | 101 | 00 2 | 100 | 101 (2 rows) --删除表。 openGauss=# DROP TABLE bit_type_t1; 父主题： 数据类型

NOT IN expression NOT IN (value [, ...]) 右侧括号中的是一个表达式列表。左侧表达式的结果与表达式列表的内容进行比较。如果在列表中的内容没有符合左侧表达式结果的内容，则NOT IN的结果为true。如果有符合的内容，则NOT IN的结果为false。 示例如下： 1 2 3 4 5 openGauss=# SELECT 8000+500 NOT IN (10000, 9000) AS RESULT; result ---------- t (1 row) 如果查询语句返回结果为空，或者表达式列表不符合表达式的条件且右侧表达式列表返回结果至少一处为空，则NOT IN的返回结果为null，而不是false。这样的处理方式和SQL返回空值的布尔组合规则是一致的。 在所有情况下X NOT IN Y等价于NOT(X IN Y)。

IN expression IN (value [, ...]) 右侧括号中的是一个表达式列表。左侧表达式的结果与表达式列表的内容进行比较。如果列表中的内容符合左侧表达式的结果，则IN的结果为true。如果没有相符的结果，则IN的结果为false。 示例如下： 1 2 3 4 5 openGauss=# SELECT 8000+500 IN (10000, 9000) AS RESULT; result ---------- f (1 row) 如果表达式结果为null，或者表达式列表不符合表达式的条件且右侧表达式列表返回结果至少一处为空，则IN的返回结果为null，而不是false。这样的处理方式和SQL返回空值的布尔组合规则是一致的。

搜索表 在不使用索引的情况下也可以进行全文检索。 一个简单查询：将body字段中包含america的每一行打印出来。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 openGauss=# DROP SCHEMA IF EXISTS tsearch CASCADE; openGauss=# CREATE SCHEMA tsearch; openGauss=# CREATE TABLE tsearch.pgweb(id int, body text, title text, last_mod_date date); openGauss=# INSERT INTO tsearch.pgweb VALUES(1, 'China, officially the People''s Republic of China (PRC), located in Asia, is the world''s most populous state.', 'China', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(2, 'America is a rock band, formed in England in 1970 by multi-instrumentalists Dewey Bunnell, Dan Peek, and Gerry Beckley.', 'America', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(3, 'England is a country that is part of the United Kingdom. It shares land borders with Scotland to the north and Wales to the west.', 'England', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(4, 'Australia, officially the Commonwealth of Australia, is a country comprising the mainland of the Australian continent, the island of Tasmania, and numerous smaller islands.', 'Australia', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(6, 'Japan is an island country in East Asia.', 'Japan', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(7, 'Germany, officially the Federal Republic of Germany, is a sovereign state and federal parliamentary republic in central-western Europe.', 'Germany', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(8, 'France, is a sovereign state comprising territory in western Europe and several overseas regions and territories.', 'France', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(9, 'Italy officially the Italian Republic, is a unitary parliamentary republic in Europe.', 'Italy', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(10, 'India, officially the Republic of India, is a country in South Asia.', 'India', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(11, 'Brazil, officially the Federative Republic of Brazil, is the largest country in both South America and Latin America.', 'Brazil', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(12, 'Canada is a country in the northern half of North America.', 'Canada', '2010-1-1'); openGauss=# INSERT INTO tsearch.pgweb VALUES(13, 'Mexico, officially the United Mexican States, is a federal republic in the southern part of North America.', 'Mexico', '2010-1-1'); openGauss=# SELECT id, body, title FROM tsearch.pgweb WHERE to_tsvector('english', body) @@ to_tsquery('english', 'america'); id | body | title ----+-------------------------------------------------------------------------------------------------------------------------+--------- 2 | America is a rock band, formed in England in 1970 by multi-instrumentalists Dewey Bunnell, Dan Peek, and Gerry Beckley. | America 11 | Brazil, officially the Federative Republic of Brazil, is the largest country in both South America and Latin America. | Brazil 12 | Canada is a country in the northern half of North America. | Canada 13 | Mexico, officially the United Mexican States, is a federal republic in the southern part of North America. | Mexico (4 rows) 像America这样的相关词也会被找到，因为这些词都被处理成了相同标准的词条。 上面的查询指定english配置来解析和规范化字符串。当然也可以省略此配置，通过default_text_search_config进行配置设置： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 openGauss=# SHOW default_text_search_config; default_text_search_config ---------------------------- pg_catalog.english (1 row) openGauss=# SELECT id, body, title FROM tsearch.pgweb WHERE to_tsvector(body) @@ to_tsquery('america'); id | body | title ----+-------------------------------------------------------------------------------------------------------------------------+--------- 2 | America is a rock band, formed in England in 1970 by multi-instrumentalists Dewey Bunnell, Dan Peek, and Gerry Beckley. | America 11 | Brazil, officially the Federative Republic of Brazil, is the largest country in both South America and Latin America. | Brazil 12 | Canada is a country in the northern half of North America. | Canada 13 | Mexico, officially the United Mexican States, is a federal republic in the southern part of North America. | Mexico (4 rows) 一个复杂查询：检索出在title或者body字段中包含north和america的最近10篇文档： 1 2 3 4 5 6 openGauss=# SELECT title FROM tsearch.pgweb WHERE to_tsvector(title || ' ' || body) @@ to_tsquery('north & america') ORDER BY last_mod_date DESC LIMIT 10; title -------- Canada Mexico (2 rows) 为了清晰，举例中没有调用coalesce函数在两个字段中查找包含NULL的行。 以上例子均在没有索引的情况下进行查询。对于大多数应用程序来说，这个方法很慢。因此除了偶尔的特定搜索，文本搜索在实际使用中通常需要创建索引。 父主题： 表和索引

archive_dest 参数说明：由管理员设置的用于归档WAL日志的目录，建议归档路径为绝对路径。 该参数属于SIGHUP类型参数，请参考表1中对应设置方法进行设置。 当archive_dest和archive_command同时配置时，WAL日志优先保存到archive_dest所设置的目录中，archive_command配置的命令不生效。 字符串中如果是相对路径为相对于数据目录的。示例如下。 1 archive_dest = '/mnt/server/archivedir/' 取值范围：字符串 默认值：空字符串

time_to_target_rpo 参数说明： 双数据库实例异地灾备模式下，设置主数据库实例发生异常发生时到已归档到OBS的恢复点所允许的time_to_target_rpo秒。 该参数属于SIGHUP类型参数，请参考表1中对应设置方法进行设置。 取值范围：整型，0~3600（秒） 双数据库实例异地灾备模式下，主数据库实例日志将被归档到OBS。0是指不开启日志流控，1~3600是指设置主数据库实例发生异常发生时到已归档到OBS的恢复点所允许的time_to_target_rpo秒，保证主数据库实例因灾难崩溃时，最多可能丢失的数据的时长在允许范围内。time_to_target_rpo设置时间过小会影响主机的性能，设置过大会失去流控效果。 默认值：0

archive_timeout 参数说明：表示归档周期。 该参数属于SIGHUP类型参数，请参考表1中对应设置方法进行设置。 超过该参数设定的时间时强制切换WAL段。 由于强制切换而提早关闭的归档文件仍然与完整的归档文件长度相同。因此，将archive_timeout设为很小的值将导致占用巨大的归档存储空间，建议将archive_timeout设置为60秒。 取值范围：整型，0 ~ 1073741823，单位为秒。其中0表示禁用该功能。 默认值：0

archive_mode 参数说明：表示是否进行归档操作。 该参数属于SIGHUP类型参数，请参考表1中对应设置方法进行设置。 当wal_level设置成minimal时，archive_mode参数无法使用。 无论是同步备机还是异步备机都能够开启归档，归档开启的方式与单机开启归档一致，将archive_mode置为on，并设置正确的archive_dest或者archive_command即可。 若未开启最大可用模式以及有同步备机与主机断开连接时，主机会因为业务阻塞的原因无法给备机发送归档的位置，从而导致归档失败。 取值范围: 布尔型 on表示进行归档。 off表示不进行归档。 默认值：off

archive_command 参数说明：由管理员设置的用于归档WAL日志的命令，建议归档路径为绝对路径。 该参数属于SIGHUP类型参数，请参考表1中对应设置方法进行设置。 当archive_dest和archive_command同时配置时，WAL日志优先保存到archive_dest所设置的目录中，archive_command配置的命令不生效。 字符串中任何%p都被要归档的文件的绝对路径代替，而任何%f都只被该文件名代替（相对路径都相对于数据目录的）。如果需要在命令里嵌入%字符就必须双写%。 这个命令当且仅当成功的时候才返回零。示例如下： 1 archive_command = 'cp --remove-destination %p /mnt/server/archivedir/%f' --remove-destination选项作用为：拷贝前如果目标文件已存在，会先删除已存在的目标文件，然后执行拷贝操作。 如果归档命令有多条，则需将其写入SHELL脚本文件中，然后将archive_command配置为执行该脚本的命令。示例如下： --假设多条命令如下。 test ! -f dir/%f && cp %p dir/%f --则test.sh脚本内容如下。 test ! -f dir/$2 && cp $1 dir/$2 --归档命令如下。 archive_command='sh dir/test.sh %p %f' 取值范围：字符串 默认值：(disabled)

基本文本匹配 GaussDB的全文检索基于匹配算子@@，当一个tsvector(document)匹配到一个tsquery(query)时，则返回true。其中，tsvector(document)和tsquery(query)两种数据类型可以任意排序。 1 2 3 4 5 openGauss=# SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector @@ 'cat & rat'::tsquery AS RESULT; result ---------- t (1 row) 1 2 3 4 5 openGauss=# SELECT 'fat & cow'::tsquery @@ 'a fat cat sat on a mat and ate a fat rat'::tsvector AS RESULT; result ---------- f (1 row) 正如上面例子表明，tsquery不仅是文本，且比tsvector包含的要多。tsquery包含已经标注化为词条的搜索词，同时可能是使用AND、OR、或NOT操作符连接的多个术语。详细请参见文本搜索类型。函数to_tsquery和plainto_tsquery对于将用户书写文本转换成适合的tsquery是非常有用的，比如将文本中的词标准化。类似地，to_tsvector用于解析和标准化文档字符串。因此，实际中文本搜索匹配看起来更像这样： 1 2 3 4 5 openGauss=# SELECT to_tsvector('fat cats ate fat rats') @@ to_tsquery('fat & rat') AS RESULT; result ---------- t (1 row) 需要注意的是，下面这种方式是不可行的： 1 2 3 4 5 openGauss=# SELECT 'fat cats ate fat rats'::tsvector @@ to_tsquery('fat & rat')AS RESULT; result ---------- f (1 row) 由于tsvector没有对rats进行标准化，所以rats不匹配rat。 @@操作符也支持text输入，允许一个文本字符串的显示转换为tsvector或者在简单情况下忽略tsquery。可用形式是： 1 2 3 4 tsvector @@ tsquery tsquery @@ tsvector text @@ tsquery text @@ text 我们已经看到了前面两种，形式text @@ tsquery等价于to_tsvector(text) @@ tsquery，而text @@ text等价于to_tsvector(text) @@ plainto_tsquery(text)。 父主题： 介绍

操作步骤 创建表空间 执行如下命令创建用户jack。 1 openGauss=# CREATE USER jack IDENTIFIED BY 'xxxxxxxxx'; 当结果显示为如下信息，则表示创建成功。 1 CREATE ROLE 执行如下命令创建表空间。 1 openGauss=# CREATE TABLESPACE fastspace RELATIVE LOCATION 'tablespace/tablespace_1'; 当结果显示为如下信息，则表示创建成功。 1 CREATE TABLESPACE 其中“fastspace”为新创建的表空间，“数据库节点数据目录/pg_location/tablespace/tablespace_1”是用户拥有读写权限的空目录。 数据库系统管理员执行如下命令将“fastspace”表空间的访问权限赋予数据用户jack。 1 openGauss=# GRANT CREATE ON TABLESPACE fastspace TO jack; 当结果显示为如下信息，则表示赋予成功。 1 GRANT

背景信息 通过使用表空间，管理员可以控制一个数据库安装的磁盘布局。这样有以下优点： 如果初始化数据库所在的分区或者卷空间已满，又不能逻辑上扩展更多空间，可以在不同的分区上创建和使用表空间，直到系统重新配置空间。 表空间允许管理员根据数据库对象的使用模式安排数据位置，从而提高性能。 一个频繁使用的索引可以放在性能稳定且运算速度较快的磁盘上，比如一种固态设备。 一个存储归档的数据，很少使用的或者对性能要求不高的表可以存储在一个运算速度较慢的磁盘上。 管理员通过表空间可以设置占用的磁盘空间。用以在和其他数据共用分区的时候，防止表空间占用相同分区上的其他空间。 表空间可以控制数据库数据占用的磁盘空间，当表空间所在磁盘的使用率达到90%时，数据库将被设置为只读模式，当磁盘使用率降到90%以下时，数据库将恢复到读写模式。 建议用户使用数据库时，通过后台监控程序或者Database Manager进行磁盘空间使用率监控，以免出现数据库只读情况。 表空间对应于一个文件系统目录，假定数据库节点数据目录/pg_location/mount1/path1是用户拥有读写权限的空目录。 使用表空间配额管理会使性能有30%左右的影响，MAXSIZE指定每个数据库节点的配额大小，误差范围在500MB以内。请根据实际的情况确认是否需要设置表空间的最大值。 GaussDB自带了两个表空间：pg_default和pg_global。 默认表空间pg_default：用来存储非共享系统表、用户表、用户表index、临时表、临时表index、内部临时表的默认表空间。对应存储目录为实例数据目录下的base目录。 共享表空间pg_global：用来存放共享系统表的表空间。对应存储目录为实例数据目录下的global目录。

通用文件访问函数 通用文件访问函数提供了对数据库服务器上的文件的本地访问接口。只有数据库目录和log_directory目录里面的文件可以访问。使用相对路径访问数据库目录里面的文件，以及匹配log_directory配置而设置的路径访问日志文件。只有数据库初始化用户才能使用这些函数。 pg_ls_dir(dirname text) 描述：列出目录中的文件。 返回值类型：setof text 备注：pg_ls_dir返回指定目录里面的除了特殊项“.”和“..”之外所有名称。 示例： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 openGauss=# SELECT pg_ls_dir('./'); pg_ls_dir ---------------------- .postgresql.conf.swp postgresql.conf pg_tblspc PG_VERSION pg_ident.conf core server.crt pg_serial pg_twophase postgresql.conf.lock pg_stat_tmp pg_notify pg_subtrans pg_ctl.lock pg_xlog pg_clog base pg_snapshots postmaster.opts postmaster.pid server.key.rand server.key.cipher pg_multixact pg_errorinfo server.key pg_hba.conf pg_replslot .pg_hba.conf.swp cacert.pem pg_hba.conf.lock global gaussdb.state (32 rows) pg_read_file(filename text, offset bigint, length bigint) 描述：返回一个文本文件的内容。 返回值类型：text 备注：pg_read_file返回一个文本文件的一部分，从offset开始，最多返回length字节（如果先达到文件结尾，则小于这个数值）。如果offset是负数，则它是相对于文件结尾回退的长度。如果省略了offset和length，则返回整个文件。 示例： 1 2 3 4 5 6 7 8 9 10 11 openGauss=# SELECT pg_read_file('postmaster.pid',0,100); pg_read_file --------------------------------------- 53078 + /srv/BigData/hadoop/data1/dbnode+ 1500022474 + 8000 + /var/run/FusionInsight + localhost + 2 (1 row) pg_read_binary_file(filename text [, offset bigint, length bigint,missing_ok boolean]) 描述：返回一个二进制文件的内容。 返回值类型：bytea 备注：pg_read_binary_file的功能与pg_read_file类似，除了结果的返回值为bytea类型不一致，相应地不会执行编码检查。与convert_from函数结合，这个函数可以用来读取用指定编码的一个文件。 1 openGauss=# SELECT convert_from(pg_read_binary_file('filename'), 'UTF8'); pg_stat_file(filename text) 描述：返回一个文本文件的状态信息。 返回值类型：record 备注：pg_stat_file返回一条记录，其中包含：文件大小、最后访问时间戳、最后更改时间戳、最后文件状态修改时间戳以及标识传入参数是否为目录的Boolean值。典型的用法： 1 openGauss=# SELECT * FROM pg_stat_file('filename'); 1 openGauss=# SELECT (pg_stat_file('filename')).modification; 示例： 1 2 3 4 5 6 7 8 9 10 11 12 openGauss=# SELECT convert_from(pg_read_binary_file('postmaster.pid'), 'UTF8'); convert_from -------------------------------------- 4881 + /srv/BigData/gaussdb/data1/dbnode+ 1496308688 + 25108 + /opt/user/Bigdata/gaussdb/gaussdb_tmp + * + 25108001 43352069 + (1 row) 1 2 3 4 5 6 7 8 9 openGauss=# SELECT * FROM pg_stat_file('postmaster.pid'); size | access | modification | change | creation | isdir ------+------------------------+------------------------+------------------------ +----------+------- 117 | 2017-06-05 11:06:34+08 | 2017-06-01 17:18:08+08 | 2017-06-01 17:18:08+08 | | f (1 row) 1 2 3 4 5 openGauss=# SELECT (pg_stat_file('postmaster.pid')).modification; modification ------------------------ 2017-06-01 17:18:08+08 (1 row) 父主题： 系统管理函数

文档概念 文档是全文搜索系统的搜索单元，例如：杂志上的一篇文章或电子邮件消息。文本搜索引擎必须能够解析文档，而且可以存储父文档的关联词素（关键词）。后续，这些关联词素用来搜索包含查询词的文档。 在GaussDB中，文档通常是一个数据库表中一行的文本字段，或者这些字段的可能组合（级联）。文档可能存储在多个表中或者需动态获取。换句话说，一个文档由被索引化的不同部分构成，因此无法存储为一个整体。比如： 1 2 3 4 5 6 7 8 9 10 11 openGauss=# SELECT d_dow || '-' || d_dom || '-' || d_fy_week_seq AS identify_serials FROM tpcds.date_dim WHERE d_fy_week_seq = 1; identify_serials ------------------ 5-6-1 0-8-1 2-3-1 3-4-1 4-5-1 1-2-1 6-7-1 (7 rows) 实际上，在这些示例查询中，应该使用coalesce防止一个独立的NULL属性导致整个文档的NULL结果。 另外一种可能是：文档在文件系统中作为简单的文本文件存储。在这种情况下，数据库可以用于存储全文索引并且执行搜索，同时可以使用一些唯一标识从文件系统中检索文档。然而，从数据库外部检索文件需要拥有系统管理员权限或者特殊函数支持。因此，还是将所有数据保存在数据库中比较方便。同时，将所有数据保存在数据库中可以方便地访问文档元数据以便于索引和显示。 为了实现文本搜索目的，必须将每个文档减少至预处理后的tsvector格式。搜索和相关性排序都是在tsvector形式的文档上执行的。原始文档只有在被选中要呈现给用户时才会被检索。因此，我们常将tsvector说成文档，但是很显然其实它只是完整文档的一种紧凑表示。 父主题： 介绍

示例 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 CREATE OR REPLACE PROCEDURE proc_case_branch(pi_result in integer, pi_return out integer) AS BEGIN CASE pi_result WHEN 1 THEN pi_return := 111; WHEN 2 THEN pi_return := 222; WHEN 3 THEN pi_return := 333; WHEN 6 THEN pi_return := 444; WHEN 7 THEN pi_return := 555; WHEN 8 THEN pi_return := 666; WHEN 9 THEN pi_return := 777; WHEN 10 THEN pi_return := 888; ELSE pi_return := 999; END CASE; raise info 'pi_return : %',pi_return ; END; / CALL proc_case_branch(3,0); --删除存储过程 DROP PROCEDURE proc_case_branch;