PostgreSQL Source Code: src/backend/catalog/heap.c Source File (original) (raw)
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
31
74#include "utils/fmgroids.h"
78
79
80
85
88 Oid new_rel_oid,
89 Oid new_type_oid,
90 Oid reloftype,
91 Oid relowner,
92 char relkind,
96 Datum reloptions);
98 Oid typeNamespace,
99 Oid new_rel_oid,
100 char new_rel_kind,
101 Oid ownerid,
102 Oid new_row_type,
103 Oid new_array_type);
106 bool is_enforced, bool is_validated, bool is_local,
107 int16 inhcount, bool is_no_inherit, bool is_internal);
109 bool is_internal);
111 bool allow_merge, bool is_local,
112 bool is_enforced,
113 bool is_initially_valid,
114 bool is_no_inherit);
117 Node *raw_constraint,
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
145 .attname = {"ctid"},
146 .atttypid = TIDOID,
149 .atttypmod = -1,
154 .attislocal = true,
155};
156
158 .attname = {"xmin"},
159 .atttypid = XIDOID,
162 .atttypmod = -1,
167 .attislocal = true,
168};
169
171 .attname = {"cmin"},
172 .atttypid = CIDOID,
175 .atttypmod = -1,
180 .attislocal = true,
181};
182
184 .attname = {"xmax"},
185 .atttypid = XIDOID,
188 .atttypmod = -1,
193 .attislocal = true,
194};
195
197 .attname = {"cmax"},
198 .atttypid = CIDOID,
201 .atttypmod = -1,
206 .attislocal = true,
207};
208
209
210
211
212
213
214
216 .attname = {"tableoid"},
217 .atttypid = OIDOID,
218 .attlen = sizeof(Oid),
220 .atttypmod = -1,
225 .attislocal = true,
226};
227
229
230
231
232
233
234
237{
239 elog(ERROR, "invalid system attribute number %d", attno);
240 return SysAtt[-attno - 1];
241}
242
243
244
245
246
249{
250 int j;
251
253 {
255
257 return att;
258 }
259
260 return NULL;
261}
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
286 Oid relnamespace,
287 Oid reltablespace,
288 Oid relid,
290 Oid accessmtd,
292 char relkind,
293 char relpersistence,
294 bool shared_relation,
295 bool mapped_relation,
296 bool allow_system_table_mods,
299 bool create_storage)
300{
302
303
305
306
307
308
309
310
311
312
313
314
315 if (!allow_system_table_mods &&
320 (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE),
321 errmsg("permission denied to create \"%s.%s\"",
323 errdetail("System catalog modifications are currently disallowed.")));
324
327
328
329
330
331
332 if (!RELKIND_HAS_TABLESPACE(relkind))
334
335
336 if (!RELKIND_HAS_STORAGE(relkind))
337 create_storage = false;
338 else
339 {
340
341
342
343
345 relfilenumber = relid;
346 }
347
348
349
350
351
352
353
354
355
356
359
360
361
362
364 relnamespace,
365 tupDesc,
366 relid,
367 accessmtd,
368 relfilenumber,
369 reltablespace,
370 shared_relation,
371 mapped_relation,
372 relpersistence,
373 relkind);
374
375
376
377
378
379
380
381
382 if (create_storage)
383 {
384 if (RELKIND_HAS_TABLE_AM(rel->rd_rel->relkind))
386 relpersistence,
387 relfrozenxid, relminmxid);
388 else if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
390 else
392 }
393
394
395
396
397
398
399 if (!create_storage && reltablespace != InvalidOid)
401 reltablespace);
402
403
405
406 return rel;
407}
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451void
453 int flags)
454{
455 int i;
456 int j;
457 int natts = tupdesc->natts;
458
459
462 (errcode(ERRCODE_TOO_MANY_COLUMNS),
463 errmsg("tables can have at most %d columns",
465
466
467
468
469
470
471
472 if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
473 {
474 for (i = 0; i < natts; i++)
475 {
477
480 (errcode(ERRCODE_DUPLICATE_COLUMN),
481 errmsg("column name \"%s\" conflicts with a system column name",
482 NameStr(attr->attname))));
483 }
484 }
485
486
487
488
489 for (i = 1; i < natts; i++)
490 {
492 {
496 (errcode(ERRCODE_DUPLICATE_COLUMN),
497 errmsg("column name \"%s\" specified more than once",
499 }
500 }
501
502
503
504
505 for (i = 0; i < natts; i++)
506 {
510 NIL,
512 }
513}
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543void
545 Oid atttypid, Oid attcollation,
546 List *containing_rowtypes,
547 int flags)
548{
549 char att_typtype = get_typtype(atttypid);
550 Oid att_typelem;
551
552
554
555 if (att_typtype == TYPTYPE_PSEUDO)
556 {
557
558
559
560
561
562
563
564
565
566
567 if (!((atttypid == ANYARRAYOID && (flags & CHKATYPE_ANYARRAY)) ||
570 {
573 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
574
575 errmsg("partition key column %s has pseudo-type %s",
577 else
579 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
580 errmsg("column \"%s\" has pseudo-type %s",
582 }
583 }
584 else if (att_typtype == TYPTYPE_DOMAIN)
585 {
586
587
588
589
590
591
594 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
595 errmsg("virtual generated column \"%s\" cannot have a domain type", attname));
596
597
598
599
601 containing_rowtypes,
602 flags);
603 }
604 else if (att_typtype == TYPTYPE_COMPOSITE)
605 {
606
607
608
611 int i;
612
613
614
615
616
617
618
621 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
622 errmsg("composite type %s cannot be made a member of itself",
624
625 containing_rowtypes = lappend_oid(containing_rowtypes, atttypid);
626
628
630
631 for (i = 0; i < tupdesc->natts; i++)
632 {
634
635 if (attr->attisdropped)
636 continue;
638 attr->atttypid, attr->attcollation,
639 containing_rowtypes,
641 }
642
644
646 }
647 else if (att_typtype == TYPTYPE_RANGE)
648 {
649
650
651
654 containing_rowtypes,
655 flags);
656 }
658 {
659
660
661
663 containing_rowtypes,
664 flags);
665 }
666
667
668
669
670
672 {
675 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
676
677 errmsg("no collation was derived for partition key column %s with collatable type %s",
679 errhint("Use the COLLATE clause to set the collation explicitly.")));
680 else
682 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
683 errmsg("no collation was derived for column \"%s\" with collatable type %s",
685 errhint("Use the COLLATE clause to set the collation explicitly.")));
686 }
687}
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707void
710 Oid new_rel_oid,
713{
716 int nslots;
717 int natts = 0;
718 int slotCount = 0;
719 bool close_index = false;
720
722
723
727 for (int i = 0; i < nslots; i++)
729
730 while (natts < tupdesc->natts)
731 {
734
736
737 memset(slot[slotCount]->tts_isnull, false,
738 slot[slotCount]->tts_tupleDescriptor->natts * sizeof(bool));
739
742 else
744
745 slot[slotCount]->tts_values[Anum_pg_attribute_attname - 1] = NameGetDatum(&attrs->attname);
747 slot[slotCount]->tts_values[Anum_pg_attribute_attlen - 1] = Int16GetDatum(attrs->attlen);
748 slot[slotCount]->tts_values[Anum_pg_attribute_attnum - 1] = Int16GetDatum(attrs->attnum);
749 slot[slotCount]->tts_values[Anum_pg_attribute_atttypmod - 1] = Int32GetDatum(attrs->atttypmod);
750 slot[slotCount]->tts_values[Anum_pg_attribute_attndims - 1] = Int16GetDatum(attrs->attndims);
751 slot[slotCount]->tts_values[Anum_pg_attribute_attbyval - 1] = BoolGetDatum(attrs->attbyval);
752 slot[slotCount]->tts_values[Anum_pg_attribute_attalign - 1] = CharGetDatum(attrs->attalign);
753 slot[slotCount]->tts_values[Anum_pg_attribute_attstorage - 1] = CharGetDatum(attrs->attstorage);
754 slot[slotCount]->tts_values[Anum_pg_attribute_attcompression - 1] = CharGetDatum(attrs->attcompression);
755 slot[slotCount]->tts_values[Anum_pg_attribute_attnotnull - 1] = BoolGetDatum(attrs->attnotnull);
756 slot[slotCount]->tts_values[Anum_pg_attribute_atthasdef - 1] = BoolGetDatum(attrs->atthasdef);
757 slot[slotCount]->tts_values[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(attrs->atthasmissing);
758 slot[slotCount]->tts_values[Anum_pg_attribute_attidentity - 1] = CharGetDatum(attrs->attidentity);
759 slot[slotCount]->tts_values[Anum_pg_attribute_attgenerated - 1] = CharGetDatum(attrs->attgenerated);
760 slot[slotCount]->tts_values[Anum_pg_attribute_attisdropped - 1] = BoolGetDatum(attrs->attisdropped);
761 slot[slotCount]->tts_values[Anum_pg_attribute_attislocal - 1] = BoolGetDatum(attrs->attislocal);
762 slot[slotCount]->tts_values[Anum_pg_attribute_attinhcount - 1] = Int16GetDatum(attrs->attinhcount);
763 slot[slotCount]->tts_values[Anum_pg_attribute_attcollation - 1] = ObjectIdGetDatum(attrs->attcollation);
764 if (attrs_extra)
765 {
768
771 }
772 else
773 {
774 slot[slotCount]->tts_isnull[Anum_pg_attribute_attstattarget - 1] = true;
775 slot[slotCount]->tts_isnull[Anum_pg_attribute_attoptions - 1] = true;
776 }
777
778
779
780
781 slot[slotCount]->tts_isnull[Anum_pg_attribute_attacl - 1] = true;
782 slot[slotCount]->tts_isnull[Anum_pg_attribute_attfdwoptions - 1] = true;
783 slot[slotCount]->tts_isnull[Anum_pg_attribute_attmissingval - 1] = true;
784
786 slotCount++;
787
788
789
790
791
792 if (slotCount == nslots || natts == tupdesc->natts - 1)
793 {
794
795 if (!indstate)
796 {
798 close_index = true;
799 }
800
801
803 indstate);
804 slotCount = 0;
805 }
806
807 natts++;
808 }
809
810 if (close_index)
812 for (int i = 0; i < nslots; i++)
815}
816
817
818
819
820
821
822
823
824static void
827 char relkind)
828{
831 int natts = tupdesc->natts;
833 referenced;
834
835
836
837
839
841
843
844
845 for (int i = 0; i < natts; i++)
846 {
848
849
851 ObjectAddressSet(referenced, TypeRelationId, attr->atttypid);
853
854
855 if (OidIsValid(attr->attcollation) &&
856 attr->attcollation != DEFAULT_COLLATION_OID)
857 {
859 attr->attcollation);
861 }
862 }
863
864
865
866
867
868
869 if (relkind != RELKIND_VIEW && relkind != RELKIND_COMPOSITE_TYPE)
870 {
872
874
877 }
878
879
880
881
883
885}
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900void
903 Oid new_rel_oid,
905 Datum reloptions)
906{
909 bool nulls[Natts_pg_class];
911
912
914 memset(nulls, false, sizeof(nulls));
915
927 values[Anum_pg_class_relallvisible - 1] = Int32GetDatum(rd_rel->relallvisible);
928 values[Anum_pg_class_relallfrozen - 1] = Int32GetDatum(rd_rel->relallfrozen);
930 values[Anum_pg_class_relhasindex - 1] = BoolGetDatum(rd_rel->relhasindex);
931 values[Anum_pg_class_relisshared - 1] = BoolGetDatum(rd_rel->relisshared);
932 values[Anum_pg_class_relpersistence - 1] = CharGetDatum(rd_rel->relpersistence);
936 values[Anum_pg_class_relhasrules - 1] = BoolGetDatum(rd_rel->relhasrules);
937 values[Anum_pg_class_relhastriggers - 1] = BoolGetDatum(rd_rel->relhastriggers);
938 values[Anum_pg_class_relrowsecurity - 1] = BoolGetDatum(rd_rel->relrowsecurity);
939 values[Anum_pg_class_relforcerowsecurity - 1] = BoolGetDatum(rd_rel->relforcerowsecurity);
940 values[Anum_pg_class_relhassubclass - 1] = BoolGetDatum(rd_rel->relhassubclass);
941 values[Anum_pg_class_relispopulated - 1] = BoolGetDatum(rd_rel->relispopulated);
942 values[Anum_pg_class_relreplident - 1] = CharGetDatum(rd_rel->relreplident);
943 values[Anum_pg_class_relispartition - 1] = BoolGetDatum(rd_rel->relispartition);
947 if (relacl != (Datum) 0)
948 values[Anum_pg_class_relacl - 1] = relacl;
949 else
950 nulls[Anum_pg_class_relacl - 1] = true;
951 if (reloptions != (Datum) 0)
952 values[Anum_pg_class_reloptions - 1] = reloptions;
953 else
954 nulls[Anum_pg_class_reloptions - 1] = true;
955
956
957 nulls[Anum_pg_class_relpartbound - 1] = true;
958
960
961
963
965}
966
967
968
969
970
971
972
973
974static void
977 Oid new_rel_oid,
978 Oid new_type_oid,
979 Oid reloftype,
980 Oid relowner,
981 char relkind,
985 Datum reloptions)
986{
988
989
990
991
992
993 new_rel_reltup = new_rel_desc->rd_rel;
994
995
996 new_rel_reltup->relpages = 0;
997 new_rel_reltup->reltuples = -1;
998 new_rel_reltup->relallvisible = 0;
999 new_rel_reltup->relallfrozen = 0;
1000
1001
1002 if (relkind == RELKIND_SEQUENCE)
1003 {
1004 new_rel_reltup->relpages = 1;
1005 new_rel_reltup->reltuples = 1;
1006 }
1007
1008 new_rel_reltup->relfrozenxid = relfrozenxid;
1009 new_rel_reltup->relminmxid = relminmxid;
1010 new_rel_reltup->relowner = relowner;
1011 new_rel_reltup->reltype = new_type_oid;
1012 new_rel_reltup->reloftype = reloftype;
1013
1014
1015 new_rel_reltup->relispartition = false;
1016
1017
1018 new_rel_desc->rd_att->tdtypeid = new_type_oid ? new_type_oid : RECORDOID;
1020
1021
1023 relacl, reloptions);
1024}
1025
1026
1027
1028
1029
1030
1031
1032
1035 Oid typeNamespace,
1036 Oid new_rel_oid,
1037 char new_rel_kind,
1038 Oid ownerid,
1039 Oid new_row_type,
1040 Oid new_array_type)
1041{
1042 return
1043 TypeCreate(new_row_type,
1044 typeName,
1045 typeNamespace,
1046 new_rel_oid,
1047 new_rel_kind,
1048 ownerid,
1049 -1,
1050 TYPTYPE_COMPOSITE,
1051 TYPCATEGORY_COMPOSITE,
1052 false,
1054 F_RECORD_IN,
1055 F_RECORD_OUT,
1056 F_RECORD_RECV,
1057 F_RECORD_SEND,
1058 InvalidOid,
1059 InvalidOid,
1060 InvalidOid,
1061 InvalidOid,
1062 InvalidOid,
1063 false,
1064 new_array_type,
1065 InvalidOid,
1066 NULL,
1067 NULL,
1068 false,
1069 TYPALIGN_DOUBLE,
1070 TYPSTORAGE_EXTENDED,
1071 -1,
1072 0,
1073 false,
1074 InvalidOid);
1075}
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1113 Oid relnamespace,
1114 Oid reltablespace,
1115 Oid relid,
1116 Oid reltypeid,
1117 Oid reloftypeid,
1118 Oid ownerid,
1119 Oid accessmtd,
1121 List *cooked_constraints,
1122 char relkind,
1123 char relpersistence,
1124 bool shared_relation,
1125 bool mapped_relation,
1127 Datum reloptions,
1128 bool use_user_acl,
1129 bool allow_system_table_mods,
1130 bool is_internal,
1131 Oid relrewrite,
1133{
1136 Acl *relacl;
1137 Oid existing_relid;
1138 Oid old_type_oid;
1139 Oid new_type_oid;
1140
1141
1145
1147
1148
1149
1150
1152
1153
1154
1155
1156
1157
1160
1161
1162
1163
1164
1168 (errcode(ERRCODE_DUPLICATE_TABLE),
1169 errmsg("relation \"%s\" already exists", relname)));
1170
1171
1172
1173
1174
1175
1176
1177 old_type_oid = GetSysCacheOid2(TYPENAMENSP, Anum_pg_type_oid,
1181 {
1186 errhint("A relation has an associated type of the same name, "
1187 "so you must use a name that doesn't conflict "
1188 "with any existing type.")));
1189 }
1190
1191
1192
1193
1194 if (shared_relation && reltablespace != GLOBALTABLESPACE_OID)
1195 elog(ERROR, "shared relations must be placed in pg_global tablespace");
1196
1197
1198
1199
1200
1201
1202
1204 {
1205
1207 {
1208
1209
1210
1211
1212 Assert(relkind != RELKIND_INDEX);
1213 Assert(relkind != RELKIND_PARTITIONED_INDEX);
1214
1215 if (relkind == RELKIND_TOASTVALUE)
1216 {
1217
1219 {
1222
1225 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1226 errmsg("toast relfilenumber value not set when in binary upgrade mode")));
1227
1230 }
1231 }
1232 else
1233 {
1236 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1237 errmsg("pg_class heap OID value not set when in binary upgrade mode")));
1238
1241
1242 if (RELKIND_HAS_STORAGE(relkind))
1243 {
1246 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
1247 errmsg("relfilenumber value not set when in binary upgrade mode")));
1248
1251 }
1252 }
1253 }
1254
1257 relpersistence);
1258 }
1259
1260
1261
1262
1263
1264
1266
1267
1268
1269
1270 if (use_user_acl)
1271 {
1272 switch (relkind)
1273 {
1274 case RELKIND_RELATION:
1275 case RELKIND_VIEW:
1276 case RELKIND_MATVIEW:
1277 case RELKIND_FOREIGN_TABLE:
1278 case RELKIND_PARTITIONED_TABLE:
1280 relnamespace);
1281 break;
1282 case RELKIND_SEQUENCE:
1284 relnamespace);
1285 break;
1286 default:
1287 relacl = NULL;
1288 break;
1289 }
1290 }
1291 else
1292 relacl = NULL;
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1304 relnamespace,
1305 reltablespace,
1306 relid,
1307 relfilenumber,
1308 accessmtd,
1309 tupdesc,
1310 relkind,
1311 relpersistence,
1312 shared_relation,
1313 mapped_relation,
1314 allow_system_table_mods,
1315 &relfrozenxid,
1316 &relminmxid,
1317 true);
1318
1320
1321 new_rel_desc->rd_rel->relrewrite = relrewrite;
1322
1323
1324
1325
1326
1327
1328 if (!(relkind == RELKIND_SEQUENCE ||
1329 relkind == RELKIND_TOASTVALUE ||
1330 relkind == RELKIND_INDEX ||
1331 relkind == RELKIND_PARTITIONED_INDEX))
1332 {
1333 Oid new_array_oid;
1335 char *relarrayname;
1336
1337
1338
1339
1340
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1353 relnamespace,
1354 relid,
1355 relkind,
1356 ownerid,
1357 reltypeid,
1358 new_array_oid);
1359 new_type_oid = new_type_addr.objectId;
1360 if (typaddress)
1361 *typaddress = new_type_addr;
1362
1363
1365
1366 TypeCreate(new_array_oid,
1367 relarrayname,
1368 relnamespace,
1369 InvalidOid,
1370 0,
1371 ownerid,
1372 -1,
1373 TYPTYPE_BASE,
1374 TYPCATEGORY_ARRAY,
1375 false,
1377 F_ARRAY_IN,
1378 F_ARRAY_OUT,
1379 F_ARRAY_RECV,
1380 F_ARRAY_SEND,
1381 InvalidOid,
1382 InvalidOid,
1383 F_ARRAY_TYPANALYZE,
1384 F_ARRAY_SUBSCRIPT_HANDLER,
1385 new_type_oid,
1386 true,
1387 InvalidOid,
1388 InvalidOid,
1389 NULL,
1390 NULL,
1391 false,
1392 TYPALIGN_DOUBLE,
1393 TYPSTORAGE_EXTENDED,
1394 -1,
1395 0,
1396 false,
1397 InvalidOid);
1398
1399 pfree(relarrayname);
1400 }
1401 else
1402 {
1403
1405 Assert(typaddress == NULL);
1406
1408 }
1409
1410
1411
1412
1413
1414
1415
1416
1418 new_rel_desc,
1419 relid,
1420 new_type_oid,
1421 reloftypeid,
1422 ownerid,
1423 relkind,
1424 relfrozenxid,
1425 relminmxid,
1427 reloptions);
1428
1429
1430
1431
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449 if (relkind != RELKIND_COMPOSITE_TYPE &&
1450 relkind != RELKIND_TOASTVALUE &&
1452 {
1454 referenced;
1456
1458
1460
1462
1464
1466
1467 ObjectAddressSet(referenced, NamespaceRelationId, relnamespace);
1469
1470 if (reloftypeid)
1471 {
1474 }
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484 if ((RELKIND_HAS_TABLE_AM(relkind) && relkind != RELKIND_TOASTVALUE) ||
1485 (relkind == RELKIND_PARTITIONED_TABLE && OidIsValid(accessmtd)))
1486 {
1487 ObjectAddressSet(referenced, AccessMethodRelationId, accessmtd);
1489 }
1490
1493 }
1494
1495
1497
1498
1499
1500
1501
1502
1503
1504
1505 StoreConstraints(new_rel_desc, cooked_constraints, is_internal);
1506
1507
1508
1509
1512
1513
1514
1515
1516
1517 table_close(new_rel_desc, NoLock);
1519
1520 return relid;
1521}
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532static void
1534{
1539
1541
1543 Anum_pg_inherits_inhrelid,
1546
1547 scan = systable_beginscan(catalogRelation, InheritsRelidSeqnoIndexId, true,
1548 NULL, 1, &key);
1549
1552
1555}
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565void
1567{
1570
1571
1573
1576 elog(ERROR, "cache lookup failed for relation %u", relid);
1577
1578
1580
1582
1584}
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594void
1596{
1601
1602
1604
1605
1607 Anum_pg_attribute_attrelid,
1610
1612 NULL, 1, key);
1613
1614
1617
1618
1621}
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631void
1633{
1638
1639
1641
1642
1644 Anum_pg_attribute_attrelid,
1648 Anum_pg_attribute_attnum,
1651
1653 NULL, 2, key);
1654
1655
1658
1659
1662}
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672void
1674{
1680 Datum valuesAtt[Natts_pg_attribute] = {0};
1681 bool nullsAtt[Natts_pg_attribute] = {0};
1682 bool replacesAtt[Natts_pg_attribute] = {0};
1683
1684
1685
1686
1687
1688
1689
1691
1693
1698 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
1701
1702
1703 attStruct->attisdropped = true;
1704
1705
1706
1707
1708
1709
1710
1711
1712
1714
1715
1716 attStruct->attnotnull = false;
1717
1718
1719 attStruct->attgenerated = '\0';
1720
1721
1722
1723
1724 snprintf(newattname, sizeof(newattname),
1725 "........pg.dropped.%d........", attnum);
1726 namestrcpy(&(attStruct->attname), newattname);
1727
1728
1729 attStruct->atthasmissing = false;
1730 nullsAtt[Anum_pg_attribute_attmissingval - 1] = true;
1731 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
1732
1733
1734
1735
1736
1737 nullsAtt[Anum_pg_attribute_attstattarget - 1] = true;
1738 replacesAtt[Anum_pg_attribute_attstattarget - 1] = true;
1739 nullsAtt[Anum_pg_attribute_attacl - 1] = true;
1740 replacesAtt[Anum_pg_attribute_attacl - 1] = true;
1741 nullsAtt[Anum_pg_attribute_attoptions - 1] = true;
1742 replacesAtt[Anum_pg_attribute_attoptions - 1] = true;
1743 nullsAtt[Anum_pg_attribute_attfdwoptions - 1] = true;
1744 replacesAtt[Anum_pg_attribute_attfdwoptions - 1] = true;
1745
1747 valuesAtt, nullsAtt, replacesAtt);
1748
1750
1751
1752
1753
1754
1755
1756
1758
1760
1762}
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773void
1775{
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1793 elog(ERROR, "cache lookup failed for relation %u", relid);
1795 {
1796
1797
1798
1799
1800
1803
1804
1805
1806
1807
1809 if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
1811 }
1812
1814
1815
1816
1817
1819
1820
1821
1822
1823
1824
1826
1827
1828
1829
1830
1831
1832
1834
1835
1836
1837
1838 if (rel->rd_rel->relkind == RELKIND_FOREIGN_TABLE)
1839 {
1842
1844
1847 elog(ERROR, "cache lookup failed for foreign table %u", relid);
1848
1850
1853 }
1854
1855
1856
1857
1858 if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
1860
1861
1862
1863
1864
1865 if (relid == defaultPartOid)
1867
1868
1869
1870
1871 if (RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
1873
1874
1876
1877
1878
1879
1880
1881
1883
1884
1885
1886
1888
1889
1890
1891
1893
1894
1895
1896
1897
1898
1899
1900
1902
1903
1904
1905
1907
1908
1909
1910
1912
1913
1914
1915
1917
1918
1919
1920
1922
1924 {
1925
1926
1927
1928
1929
1930 if (OidIsValid(defaultPartOid) && relid != defaultPartOid)
1932
1933
1934
1935
1936
1938
1939 }
1940}
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953void
1955{
1960 Datum repl_val[Natts_pg_attribute];
1961 bool repl_null[Natts_pg_attribute];
1962 bool repl_repl[Natts_pg_attribute];
1965 newtuple;
1966
1967 memset(repl_val, 0, sizeof(repl_val));
1968 memset(repl_null, false, sizeof(repl_null));
1969 memset(repl_repl, false, sizeof(repl_repl));
1970
1971 repl_val[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(false);
1972 repl_null[Anum_pg_attribute_attmissingval - 1] = true;
1973
1974 repl_repl[Anum_pg_attribute_atthasmissing - 1] = true;
1975 repl_repl[Anum_pg_attribute_attmissingval - 1] = true;
1976
1977
1978
1980
1981
1983 {
1988 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
1990
1992
1993
1994 if (attrtuple->atthasmissing)
1995 {
1997 repl_val, repl_null, repl_repl);
1998
2000
2002 }
2003
2005 }
2006
2007
2008
2009
2010
2012}
2013
2014
2015
2016
2017
2018
2019void
2021{
2022 Datum valuesAtt[Natts_pg_attribute] = {0};
2023 bool nullsAtt[Natts_pg_attribute] = {0};
2024 bool replacesAtt[Natts_pg_attribute] = {0};
2028 newtup;
2029
2030
2031 Assert(rel->rd_rel->relkind == RELKIND_RELATION);
2032
2033
2035
2040 elog(ERROR, "cache lookup failed for attribute %d of relation %u",
2043
2044
2046 1,
2047 attStruct->atttypid,
2048 attStruct->attlen,
2049 attStruct->attbyval,
2050 attStruct->attalign));
2051
2052
2053 valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);
2054 replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
2055
2056 valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
2057 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
2058
2060 valuesAtt, nullsAtt, replacesAtt);
2062
2063
2066}
2067
2068
2069
2070
2071
2072
2073
2074
2075void
2077{
2078 Datum valuesAtt[Natts_pg_attribute] = {0};
2079 bool nullsAtt[Natts_pg_attribute] = {0};
2080 bool replacesAtt[Natts_pg_attribute] = {0};
2081 Datum missingval;
2084 tablerel;
2086 newtup;
2087
2088
2090
2091
2092 if (tablerel->rd_rel->relkind != RELKIND_RELATION)
2093 {
2095 return;
2096 }
2097
2098
2102 elog(ERROR, "cache lookup failed for attribute %s of relation %u",
2105
2106
2111
2112
2113 valuesAtt[Anum_pg_attribute_atthasmissing - 1] = BoolGetDatum(true);
2114 replacesAtt[Anum_pg_attribute_atthasmissing - 1] = true;
2115 valuesAtt[Anum_pg_attribute_attmissingval - 1] = missingval;
2116 replacesAtt[Anum_pg_attribute_attmissingval - 1] = true;
2117
2119 valuesAtt, nullsAtt, replacesAtt);
2121
2122
2126}
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136static Oid
2138 bool is_enforced, bool is_validated, bool is_local,
2139 int16 inhcount, bool is_no_inherit, bool is_internal)
2140{
2141 char *ccbin;
2142 List *varList;
2143 int keycount;
2145 Oid constrOid;
2146
2147
2148
2149
2151
2152
2153
2154
2155
2156
2157
2158
2161
2162 if (keycount > 0)
2163 {
2165 int i = 0;
2166
2168 foreach(vl, varList)
2169 {
2171 int j;
2172
2175 break;
2178 }
2179 keycount = i;
2180 }
2181 else
2182 attNos = NULL;
2183
2184
2185
2186
2187
2188 if (is_no_inherit &&
2189 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
2191 (errcode(ERRCODE_INVALID_TABLE_DEFINITION),
2192 errmsg("cannot add NO INHERIT constraint to partitioned table \"%s\"",
2194
2195
2196
2197
2198 constrOid =
2201 CONSTRAINT_CHECK,
2202 false,
2203 false,
2204 is_enforced,
2205 is_validated,
2206 InvalidOid,
2208 attNos,
2209 keycount,
2210 keycount,
2211 InvalidOid,
2212 InvalidOid,
2213 InvalidOid,
2214 NULL,
2215 NULL,
2216 NULL,
2217 NULL,
2218 0,
2219 ' ',
2220 ' ',
2221 NULL,
2222 0,
2223 ' ',
2224 NULL,
2225 expr,
2226 ccbin,
2227 is_local,
2228 inhcount,
2229 is_no_inherit,
2230 false,
2231 is_internal);
2232
2234
2235 return constrOid;
2236}
2237
2238
2239
2240
2241
2242
2243static Oid
2245 bool is_validated, bool is_local, int inhcount,
2246 bool is_no_inherit)
2247{
2248 Oid constrOid;
2249
2251
2252 constrOid =
2255 CONSTRAINT_NOTNULL,
2256 false,
2257 false,
2258 true,
2259 is_validated,
2263 1,
2264 1,
2265 InvalidOid,
2266 InvalidOid,
2267 InvalidOid,
2268 NULL,
2269 NULL,
2270 NULL,
2271 NULL,
2272 0,
2273 ' ',
2274 ' ',
2275 NULL,
2276 0,
2277 ' ',
2278 NULL,
2279 NULL,
2280 NULL,
2281 is_local,
2282 inhcount,
2283 is_no_inherit,
2284 false,
2285 false);
2286 return constrOid;
2287}
2288
2289
2290
2291
2292
2293
2294
2295
2296
2297
2298
2299static void
2301{
2302 int numchecks = 0;
2304
2305 if (cooked_constraints == NIL)
2306 return;
2307
2308
2309
2310
2311
2312
2314
2315 foreach(lc, cooked_constraints)
2316 {
2318
2320 {
2323 is_internal);
2324 break;
2331 numchecks++;
2332 break;
2333
2334 default:
2335 elog(ERROR, "unrecognized constraint type: %d",
2337 }
2338 }
2339
2340 if (numchecks > 0)
2342}
2343
2344
2345
2346
2347
2348
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
2364
2365
2366
2367
2368
2369
2370
2371
2372
2373
2376 List *newColDefaults,
2377 List *newConstraints,
2378 bool allow_merge,
2379 bool is_local,
2380 bool is_internal,
2381 const char *queryString)
2382{
2383 List *cookedConstraints = NIL;
2386 int numoldchecks;
2389 int numchecks;
2390 List *checknames;
2391 List *nnnames;
2394
2395
2396
2397
2399 oldconstr = tupleDesc->constr;
2400 if (oldconstr)
2401 numoldchecks = oldconstr->num_check;
2402 else
2403 numoldchecks = 0;
2404
2405
2406
2407
2408
2412 rel,
2414 NULL,
2415 false,
2416 true);
2418
2419
2420
2421
2423 {
2425 Oid defOid;
2426
2427 expr = cookDefault(pstate, colDef->raw_default,
2428 atp->atttypid, atp->atttypmod,
2430 atp->attgenerated);
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444 if (expr == NULL ||
2445 (!colDef->generated &&
2448 continue;
2449
2450 defOid = StoreAttrDefault(rel, colDef->attnum, expr, is_internal);
2451
2454 cooked->conoid = defOid;
2455 cooked->name = NULL;
2456 cooked->attnum = colDef->attnum;
2457 cooked->expr = expr;
2460 cooked->is_local = is_local;
2461 cooked->inhcount = is_local ? 0 : 1;
2463 cookedConstraints = lappend(cookedConstraints, cooked);
2464 }
2465
2466
2467
2468
2469 numchecks = numoldchecks;
2470 checknames = NIL;
2471 nnnames = NIL;
2473 {
2474 Oid constrOid;
2475
2477 {
2478 char *ccname;
2479
2480 if (cdef->raw_expr != NULL)
2481 {
2482 Assert(cdef->cooked_expr == NULL);
2483
2484
2485
2486
2487
2490 }
2491 else
2492 {
2493 Assert(cdef->cooked_expr != NULL);
2494
2495
2496
2497
2498
2500 }
2501
2502
2503
2504
2505 if (cdef->conname != NULL)
2506 {
2507 ccname = cdef->conname;
2508
2509
2511 {
2512 if (strcmp(chkname, ccname) == 0)
2515 errmsg("check constraint \"%s\" already exists",
2516 ccname)));
2517 }
2518
2519
2520 checknames = lappend(checknames, ccname);
2521
2522
2523
2524
2525
2526
2527
2529 allow_merge, is_local,
2530 cdef->is_enforced,
2531 cdef->initially_valid,
2532 cdef->is_no_inherit))
2533 continue;
2534 }
2535 else
2536 {
2537
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2551 char *colname;
2552
2554
2555
2557
2561 true);
2562 else
2563 colname = NULL;
2564
2566 colname,
2567 "check",
2569 checknames);
2570
2571
2572 checknames = lappend(checknames, ccname);
2573 }
2574
2575
2576
2577
2578 constrOid =
2579 StoreRelCheck(rel, ccname, expr, cdef->is_enforced,
2580 cdef->initially_valid, is_local,
2581 is_local ? 0 : 1, cdef->is_no_inherit,
2582 is_internal);
2583
2584 numchecks++;
2585
2588 cooked->conoid = constrOid;
2589 cooked->name = ccname;
2591 cooked->expr = expr;
2592 cooked->is_enforced = cdef->is_enforced;
2594 cooked->is_local = is_local;
2595 cooked->inhcount = is_local ? 0 : 1;
2597 cookedConstraints = lappend(cookedConstraints, cooked);
2598 }
2600 {
2603 int16 inhcount = is_local ? 0 : 1;
2604 char *nnname;
2605
2606
2610 errcode(ERRCODE_UNDEFINED_COLUMN),
2611 errmsg("column \"%s\" of relation \"%s\" does not exist",
2615 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2616 errmsg("cannot add not-null constraint on system column \"%s\"",
2618
2619 Assert(cdef->initially_valid != cdef->skip_validation);
2620
2621
2622
2623
2624
2625
2626
2628 is_local, cdef->is_no_inherit,
2629 cdef->skip_validation))
2630 continue;
2631
2632
2633
2634
2635
2636 if (cdef->conname)
2637 {
2640 cdef->conname))
2643 errmsg("constraint \"%s\" for relation \"%s\" already exists",
2645 nnname = cdef->conname;
2646 }
2647 else
2650 "not_null",
2652 nnnames);
2653 nnnames = lappend(nnnames, nnname);
2654
2655 constrOid =
2657 cdef->initially_valid,
2658 is_local,
2659 inhcount,
2660 cdef->is_no_inherit);
2661
2664 nncooked->conoid = constrOid;
2665 nncooked->name = nnname;
2666 nncooked->attnum = colnum;
2667 nncooked->expr = NULL;
2670 nncooked->is_local = is_local;
2671 nncooked->inhcount = inhcount;
2673
2674 cookedConstraints = lappend(cookedConstraints, nncooked);
2675 }
2676 }
2677
2678
2679
2680
2681
2682
2683
2684
2686
2687 return cookedConstraints;
2688}
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700static bool
2702 bool allow_merge, bool is_local,
2703 bool is_enforced,
2704 bool is_initially_valid,
2705 bool is_no_inherit)
2706{
2707 bool found;
2712
2713
2715
2716 found = false;
2717
2719 Anum_pg_constraint_conrelid,
2723 Anum_pg_constraint_contypid,
2727 Anum_pg_constraint_conname,
2730
2731 conscan = systable_beginscan(conDesc, ConstraintRelidTypidNameIndexId, true,
2732 NULL, 3, skey);
2733
2734
2736 {
2738
2739
2740 if (con->contype == CONSTRAINT_CHECK)
2741 {
2743 bool isnull;
2744
2746 Anum_pg_constraint_conbin,
2747 conDesc->rd_att, &isnull);
2748 if (isnull)
2749 elog(ERROR, "null conbin for rel %s",
2752 found = true;
2753 }
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763 if (is_local && !con->conislocal && !rel->rd_rel->relispartition)
2764 allow_merge = true;
2765
2766 if (!found || !allow_merge)
2769 errmsg("constraint \"%s\" for relation \"%s\" already exists",
2771
2772
2773 if (con->connoinherit)
2775 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2776 errmsg("constraint \"%s\" conflicts with non-inherited constraint on relation \"%s\"",
2778
2779
2780
2781
2782
2783
2784 if (con->coninhcount > 0 && is_no_inherit)
2786 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2787 errmsg("constraint \"%s\" conflicts with inherited constraint on relation \"%s\"",
2789
2790
2791
2792
2793
2794 if (is_initially_valid && con->conenforced && !con->convalidated)
2796 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2797 errmsg("constraint \"%s\" conflicts with NOT VALID constraint on relation \"%s\"",
2799
2800
2801
2802
2803
2804
2805 if ((!is_local && is_enforced && !con->conenforced) ||
2806 (is_local && !is_enforced && con->conenforced))
2808 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
2809 errmsg("constraint \"%s\" conflicts with NOT ENFORCED constraint on relation \"%s\"",
2811
2812
2814 (errmsg("merging constraint \"%s\" with inherited definition",
2815 ccname)));
2816
2819
2820
2821
2822
2823
2824
2825 if (rel->rd_rel->relispartition)
2826 {
2827 con->coninhcount = 1;
2828 con->conislocal = false;
2829 }
2830 else
2831 {
2832 if (is_local)
2833 con->conislocal = true;
2835 &con->coninhcount))
2837 errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
2838 errmsg("too many inheritance parents"));
2839 }
2840
2841 if (is_no_inherit)
2842 {
2844 con->connoinherit = true;
2845 }
2846
2847
2848
2849
2850
2851
2852
2853 if (is_enforced && !con->conenforced)
2854 {
2856 con->conenforced = true;
2857 con->convalidated = true;
2858 }
2859
2861 }
2862
2865
2866 return found;
2867}
2868
2869
2870
2871
2872
2873
2874
2875
2876
2877
2878
2879
2880
2881
2882
2885 List *old_notnulls)
2886{
2887 List *givennames;
2888 List *nnnames;
2890
2891
2892
2893
2894
2895
2896
2897 nnnames = NIL;
2898 givennames = NIL;
2899
2900
2901
2902
2903
2904
2905
2906
2907
2908
2909
2910
2911
2912
2913
2914 for (int outerpos = 0; outerpos < list_length(constraints); outerpos++)
2915 {
2918 char *conname;
2919 int inhcount = 0;
2920
2922
2924
2929 errcode(ERRCODE_UNDEFINED_COLUMN),
2930 errmsg("column \"%s\" of relation \"%s\" does not exist",
2935 errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
2936 errmsg("cannot add not-null constraint on system column \"%s\"",
2938
2939
2940
2941
2942
2943
2944 for (int restpos = outerpos + 1; restpos < list_length(constraints);)
2945 {
2947
2951 {
2954 errcode(ERRCODE_SYNTAX_ERROR),
2955 errmsg("conflicting NO INHERIT declaration for not-null constraint on column \"%s\"",
2957
2958
2959
2960
2961
2963 {
2966 else if (strcmp(constr->conname, other->conname) != 0)
2968 errcode(ERRCODE_SYNTAX_ERROR),
2969 errmsg("conflicting not-null constraint names \"%s\" and \"%s\"",
2971 }
2972
2973
2975 }
2976 else
2977 restpos++;
2978 }
2979
2980
2981
2982
2983
2984
2985
2986
2987
2989 {
2990 if (old->attnum == attnum)
2991 {
2992
2993
2994
2995
2998 (errcode(ERRCODE_DATATYPE_MISMATCH),
2999 errmsg("cannot define not-null constraint on column \"%s\" with NO INHERIT",
3001 errdetail("The column has an inherited not-null constraint.")));
3002
3003 inhcount++;
3005 }
3006 }
3007
3008
3009
3010
3011
3012
3014 {
3016 {
3017 if (strcmp(thisname, constr->conname) == 0)
3020 errmsg("constraint \"%s\" for relation \"%s\" already exists",
3023 }
3024
3025 conname = constr->conname;
3026 givennames = lappend(givennames, conname);
3027 }
3028 else
3032 "not_null",
3034 nnnames);
3035 nnnames = lappend(nnnames, conname);
3036
3040
3042 }
3043
3044
3045
3046
3047
3048
3049
3050
3051
3052
3053
3054
3055
3056
3057
3058 for (int outerpos = 0; outerpos < list_length(old_notnulls); outerpos++)
3059 {
3061 char *conname = NULL;
3062 int inhcount = 1;
3063
3067
3068
3069
3070
3071 if (conname == NULL)
3072 conname = cooked->name;
3073
3074 for (int restpos = outerpos + 1; restpos < list_length(old_notnulls);)
3075 {
3077
3081 {
3082 if (conname == NULL)
3083 conname = other->name;
3084
3085 inhcount++;
3087 }
3088 else
3089 restpos++;
3090 }
3091
3092
3093 if (conname != NULL)
3094 {
3096 {
3097 if (strcmp(thisname, conname) == 0)
3098 {
3099 conname = NULL;
3100 break;
3101 }
3102 }
3103 }
3104
3105
3106 if (conname == NULL)
3109 cooked->attnum, false),
3110 "not_null",
3112 nnnames);
3113 nnnames = lappend(nnnames, conname);
3114
3115
3117 false, inhcount, false);
3118
3120 }
3121
3122 return nncols;
3123}
3124
3125
3126
3127
3128
3129
3130
3131
3132
3133
3134
3135static void
3137{
3141
3146 elog(ERROR, "cache lookup failed for relation %u",
3149
3150 if (relStruct->relchecks != numchecks)
3151 {
3152 relStruct->relchecks = numchecks;
3153
3155 }
3156 else
3157 {
3158
3160 }
3161
3164}
3165
3166
3167
3168
3169static bool
3171{
3173
3174 if (node == NULL)
3175 return false;
3177 {
3179 Oid relid;
3181
3184 return false;
3185
3187
3190 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3191 errmsg("cannot use generated column \"%s\" in column generation expression",
3193 errdetail("A generated column cannot reference another generated column."),
3195
3198 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3199 errmsg("cannot use whole-row variable in column generation expression"),
3200 errdetail("This would cause the generated column to depend on its own value."),
3202
3203
3204 return false;
3205 }
3206 else
3208 context);
3209}
3210
3211static void
3213{
3215}
3216
3217
3218
3219
3220
3221
3222
3223
3224
3225
3226
3227
3228
3231 Node *raw_default,
3232 Oid atttypid,
3233 int32 atttypmod,
3235 char attgenerated)
3236{
3238
3239 Assert(raw_default != NULL);
3240
3241
3242
3243
3245
3246 if (attgenerated)
3247 {
3248
3250
3251
3254 (errcode(ERRCODE_INVALID_OBJECT_DEFINITION),
3255 errmsg("generation expression is not immutable")));
3256 }
3257 else
3258 {
3259
3260
3261
3262
3264 }
3265
3266
3267
3268
3269
3270
3272 {
3274
3276 atttypid, atttypmod,
3279 -1);
3280 if (expr == NULL)
3282 (errcode(ERRCODE_DATATYPE_MISMATCH),
3283 errmsg("column \"%s\" is of type %s"
3284 " but default expression is of type %s",
3288 errhint("You will need to rewrite or cast the expression.")));
3289 }
3290
3291
3292
3293
3295
3296 return expr;
3297}
3298
3299
3300
3301
3302
3303
3304
3305
3306static Node *
3308 Node *raw_constraint,
3310{
3312
3313
3314
3315
3317
3318
3319
3320
3322
3323
3324
3325
3327
3328
3329
3330
3331
3334 (errcode(ERRCODE_INVALID_COLUMN_REFERENCE),
3335 errmsg("only table \"%s\" can be referenced in check constraint",
3337
3338 return expr;
3339}
3340
3341
3342
3343
3344void
3346{
3352
3354
3355
3357 Anum_pg_statistic_starelid,
3360
3362 true, NULL, 1, key);
3363
3365 {
3367
3368
3371
3372
3373 statform->starelid = torelid;
3374
3375
3376 if (indstate == NULL)
3378
3380
3382 }
3383
3385
3386 if (indstate != NULL)
3389}
3390
3391
3392
3393
3394
3395
3396
3397void
3399{
3403 int nkeys;
3405
3407
3409 Anum_pg_statistic_starelid,
3412
3414 nkeys = 1;
3415 else
3416 {
3418 Anum_pg_statistic_staattnum,
3421 nkeys = 2;
3422 }
3423
3424 scan = systable_beginscan(pgstatistic, StatisticRelidAttnumInhIndexId, true,
3425 NULL, nkeys, key);
3426
3427
3430
3432
3434}
3435
3436
3437
3438
3439
3440
3441
3442
3443
3444static void
3446{
3448
3449
3451 {
3455
3456
3458
3459
3460
3461
3462
3463
3464
3465
3466
3468
3469
3470
3471
3473
3474
3475
3476 index_build(heapRelation, currentIndex, indexInfo, true, false);
3477
3478
3480 }
3481}
3482
3483
3484
3485
3486
3487
3488
3489
3490
3491
3492void
3494{
3497
3498
3499 foreach(cell, relids)
3500 {
3503
3505 relations = lappend(relations, rel);
3506 }
3507
3508
3510
3511
3512 foreach(cell, relations)
3513 {
3515
3516
3518
3519
3521 }
3522}
3523
3524
3525
3526
3527
3528
3529
3530
3531
3532
3533void
3535{
3536 Oid toastrelid;
3537
3538
3539
3540
3541
3542 if (rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3543 return;
3544
3545
3547
3548
3550
3551
3552 toastrelid = rel->rd_rel->reltoastrelid;
3554 {
3556
3559
3561 }
3562}
3563
3564
3565
3566
3567
3568
3569
3570
3571
3572
3573
3574
3575
3576
3577void
3579{
3581 List *dependents;
3583
3584
3585
3586
3587
3588
3589
3590
3591
3592 foreach(cell, relations)
3593 {
3595
3596 if (rel->rd_rel->relhastriggers ||
3597 rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE)
3599 }
3600
3601
3602
3603
3604 if (oids == NIL)
3605 return;
3606
3607
3608
3609
3610
3612 if (dependents == NIL)
3613 return;
3614
3615
3616
3617
3618
3619
3620
3621
3622 foreach(cell, oids)
3623 {
3626
3628
3629 foreach(cell2, dependents)
3630 {
3632
3634 {
3637
3638 if (tempTables)
3640 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3641 errmsg("unsupported ON COMMIT and foreign key combination"),
3642 errdetail("Table \"%s\" references \"%s\", but they do not have the same ON COMMIT setting.",
3644 else
3646 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
3647 errmsg("cannot truncate a table referenced in a foreign key constraint"),
3648 errdetail("Table \"%s\" references \"%s\".",
3650 errhint("Truncate table \"%s\" at the same time, "
3651 "or use TRUNCATE ... CASCADE.",
3652 relname2)));
3653 }
3654 }
3655 }
3656}
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3674{
3677 List *parent_cons;
3683 bool restart;
3684
3686
3687
3688
3689
3690
3692
3693restart:
3694 restart = false;
3695 parent_cons = NIL;
3696
3698 NULL, 0, NULL);
3699
3701 {
3703
3704
3705 if (con->contype != CONSTRAINT_FOREIGN)
3706 continue;
3707
3708
3710 continue;
3711
3712
3713
3714
3715
3716
3717
3720 parent_cons = lappend_oid(parent_cons, con->conparentid);
3721
3722
3723
3724
3725
3727 result = lappend_oid(result, con->conrelid);
3728 }
3729
3731
3732
3733
3734
3735
3736
3737
3738
3739 foreach(cell, parent_cons)
3740 {
3742
3744 Anum_pg_constraint_oid,
3747
3749 true, NULL, 1, &key);
3750
3753 {
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3770 con->conparentid);
3772 {
3773 oids = lappend_oid(oids, con->confrelid);
3774 restart = true;
3775 }
3776 }
3777
3779 }
3780
3782 if (restart)
3783 goto restart;
3784
3787
3788
3791
3792 return result;
3793}
3794
3795
3796
3797
3798
3799void
3801 char strategy,
3802 int16 partnatts,
3804 List *partexprs,
3805 Oid *partopclass,
3806 Oid *partcollation)
3807{
3808 int i;
3812 Datum partexprDatum;
3813 Relation pg_partitioned_table;
3815 Datum values[Natts_pg_partitioned_table];
3816 bool nulls[Natts_pg_partitioned_table] = {0};
3820
3821 Assert(rel->rd_rel->relkind == RELKIND_PARTITIONED_TABLE);
3822
3823
3825 partopclass_vec = buildoidvector(partopclass, partnatts);
3826 partcollation_vec = buildoidvector(partcollation, partnatts);
3827
3828
3829 if (partexprs)
3830 {
3831 char *exprString;
3832
3835 pfree(exprString);
3836 }
3837 else
3838 partexprDatum = (Datum) 0;
3839
3841
3842
3843 if (!partexprDatum)
3844 nulls[Anum_pg_partitioned_table_partexprs - 1] = true;
3845
3847 values[Anum_pg_partitioned_table_partstrat - 1] = CharGetDatum(strategy);
3848 values[Anum_pg_partitioned_table_partnatts - 1] = Int16GetDatum(partnatts);
3850 values[Anum_pg_partitioned_table_partattrs - 1] = PointerGetDatum(partattrs_vec);
3851 values[Anum_pg_partitioned_table_partclass - 1] = PointerGetDatum(partopclass_vec);
3852 values[Anum_pg_partitioned_table_partcollation - 1] = PointerGetDatum(partcollation_vec);
3853 values[Anum_pg_partitioned_table_partexprs - 1] = partexprDatum;
3854
3856
3859
3860
3863
3864
3865 for (i = 0; i < partnatts; i++)
3866 {
3867 ObjectAddressSet(referenced, OperatorClassRelationId, partopclass[i]);
3869
3870
3872 partcollation[i] != DEFAULT_COLLATION_OID)
3873 {
3874 ObjectAddressSet(referenced, CollationRelationId, partcollation[i]);
3876 }
3877 }
3878
3881
3882
3883
3884
3885
3886
3887
3888 for (i = 0; i < partnatts; i++)
3889 {
3890 if (partattrs[i] == 0)
3891 continue;
3892
3896 }
3897
3898
3899
3900
3901
3902
3903
3904 if (partexprs)
3906 (Node *) partexprs,
3910 true );
3911
3912
3913
3914
3915
3916
3918}
3919
3920
3921
3922
3923
3924void
3926{
3929
3931
3934 elog(ERROR, "cache lookup failed for partition key of relation %u",
3935 relid);
3936
3938
3941}
3942
3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955void
3957{
3960 newtuple;
3961 Datum new_val[Natts_pg_class];
3962 bool new_null[Natts_pg_class],
3963 new_repl[Natts_pg_class];
3964 Oid defaultPartOid;
3965
3966
3971 elog(ERROR, "cache lookup failed for relation %u",
3973
3974#ifdef USE_ASSERT_CHECKING
3975 {
3977 bool isnull;
3978
3980 Assert(!classForm->relispartition);
3981 (void) SysCacheGetAttr(RELOID, tuple, Anum_pg_class_relpartbound,
3982 &isnull);
3984 }
3985#endif
3986
3987
3988 memset(new_val, 0, sizeof(new_val));
3989 memset(new_null, false, sizeof(new_null));
3990 memset(new_repl, false, sizeof(new_repl));
3992 new_null[Anum_pg_class_relpartbound - 1] = false;
3993 new_repl[Anum_pg_class_relpartbound - 1] = true;
3995 new_val, new_null, new_repl);
3996
3998
3999
4000
4001
4002
4003 if (rel->rd_rel->relkind == RELKIND_RELATION && rel->rd_rel->relhassubclass)
4005
4009
4010
4011
4012
4013
4017
4018
4020
4021
4022
4023
4024
4025
4026
4027 defaultPartOid =
4031
4033}
void recordDependencyOnNewAcl(Oid classId, Oid objectId, int32 objsubId, Oid ownerId, Acl *acl)
Acl * get_user_default_acl(ObjectType objtype, Oid ownerId, Oid nsp_oid)
ArrayType * construct_array(Datum *elems, int nelems, Oid elmtype, int elmlen, bool elmbyval, char elmalign)
#define InvalidAttrNumber
static Datum values[MAXATTR]
#define CStringGetTextDatum(s)
#define TextDatumGetCString(d)
TransactionId MultiXactId
#define OidIsValid(objectId)
bool IsToastNamespace(Oid namespaceId)
RelFileNumber GetNewRelFileNumber(Oid reltablespace, Relation pg_class, char relpersistence)
bool IsCatalogNamespace(Oid namespaceId)
bool contain_mutable_functions_after_planning(Expr *expr)
void record_object_address_dependencies(const ObjectAddress *depender, ObjectAddresses *referenced, DependencyType behavior)
void recordDependencyOnSingleRelExpr(const ObjectAddress *depender, Node *expr, Oid relId, DependencyType behavior, DependencyType self_behavior, bool reverse_self)
void add_exact_object_address(const ObjectAddress *object, ObjectAddresses *addrs)
ObjectAddresses * new_object_addresses(void)
void free_object_addresses(ObjectAddresses *addrs)
int errdetail(const char *fmt,...)
int errhint(const char *fmt,...)
int errcode(int sqlerrcode)
int errmsg(const char *fmt,...)
#define ereport(elevel,...)
bool equal(const void *a, const void *b)
TupleTableSlot * MakeSingleTupleTableSlot(TupleDesc tupdesc, const TupleTableSlotOps *tts_ops)
void ExecDropSingleTupleTableSlot(TupleTableSlot *slot)
TupleTableSlot * ExecStoreVirtualTuple(TupleTableSlot *slot)
const TupleTableSlotOps TTSOpsHeapTuple
#define OidFunctionCall3(functionId, arg1, arg2, arg3)
char * format_type_be(Oid type_oid)
void systable_endscan(SysScanDesc sysscan)
HeapTuple systable_getnext(SysScanDesc sysscan)
SysScanDesc systable_beginscan(Relation heapRelation, Oid indexId, bool indexOK, Snapshot snapshot, int nkeys, ScanKey key)
Assert(PointerIsAligned(start, uint64))
void RemoveAttributeById(Oid relid, AttrNumber attnum)
void RelationClearMissing(Relation rel)
void SetAttrMissing(Oid relid, char *attname, char *value)
static Oid StoreRelCheck(Relation rel, const char *ccname, Node *expr, bool is_enforced, bool is_validated, bool is_local, int16 inhcount, bool is_no_inherit, bool is_internal)
List * heap_truncate_find_FKs(List *relationIds)
void DeleteSystemAttributeTuples(Oid relid)
void StorePartitionKey(Relation rel, char strategy, int16 partnatts, AttrNumber *partattrs, List *partexprs, Oid *partopclass, Oid *partcollation)
static void StoreConstraints(Relation rel, List *cooked_constraints, bool is_internal)
static void AddNewAttributeTuples(Oid new_rel_oid, TupleDesc tupdesc, char relkind)
void DeleteRelationTuple(Oid relid)
static void RelationTruncateIndexes(Relation heapRelation)
RelFileNumber binary_upgrade_next_heap_pg_class_relfilenumber
static void AddNewRelationTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Oid new_type_oid, Oid reloftype, Oid relowner, char relkind, TransactionId relfrozenxid, TransactionId relminmxid, Datum relacl, Datum reloptions)
void DeleteAttributeTuples(Oid relid)
void RemoveStatistics(Oid relid, AttrNumber attnum)
static const FormData_pg_attribute a4
RelFileNumber binary_upgrade_next_toast_pg_class_relfilenumber
static ObjectAddress AddNewRelationType(const char *typeName, Oid typeNamespace, Oid new_rel_oid, char new_rel_kind, Oid ownerid, Oid new_row_type, Oid new_array_type)
static const FormData_pg_attribute a1
Oid heap_create_with_catalog(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, Oid reltypeid, Oid reloftypeid, Oid ownerid, Oid accessmtd, TupleDesc tupdesc, List *cooked_constraints, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, OnCommitAction oncommit, Datum reloptions, bool use_user_acl, bool allow_system_table_mods, bool is_internal, Oid relrewrite, ObjectAddress *typaddress)
void heap_truncate(List *relids)
static bool MergeWithExistingConstraint(Relation rel, const char *ccname, Node *expr, bool allow_merge, bool is_local, bool is_enforced, bool is_initially_valid, bool is_no_inherit)
static const FormData_pg_attribute *const SysAtt[]
static Oid StoreRelNotNull(Relation rel, const char *nnname, AttrNumber attnum, bool is_validated, bool is_local, int inhcount, bool is_no_inherit)
void CheckAttributeType(const char *attname, Oid atttypid, Oid attcollation, List *containing_rowtypes, int flags)
const FormData_pg_attribute * SystemAttributeByName(const char *attname)
void CopyStatistics(Oid fromrelid, Oid torelid)
void heap_truncate_check_FKs(List *relations, bool tempTables)
static const FormData_pg_attribute a6
static bool check_nested_generated_walker(Node *node, void *context)
static void SetRelationNumChecks(Relation rel, int numchecks)
static const FormData_pg_attribute a3
static void RelationRemoveInheritance(Oid relid)
static const FormData_pg_attribute a2
void StorePartitionBound(Relation rel, Relation parent, PartitionBoundSpec *bound)
List * AddRelationNotNullConstraints(Relation rel, List *constraints, List *old_notnulls)
void heap_drop_with_catalog(Oid relid)
List * AddRelationNewConstraints(Relation rel, List *newColDefaults, List *newConstraints, bool allow_merge, bool is_local, bool is_internal, const char *queryString)
void InsertPgClassTuple(Relation pg_class_desc, Relation new_rel_desc, Oid new_rel_oid, Datum relacl, Datum reloptions)
void CheckAttributeNamesTypes(TupleDesc tupdesc, char relkind, int flags)
static void check_nested_generated(ParseState *pstate, Node *node)
Oid binary_upgrade_next_toast_pg_class_oid
void InsertPgAttributeTuples(Relation pg_attribute_rel, TupleDesc tupdesc, Oid new_rel_oid, const FormExtraData_pg_attribute tupdesc_extra[], CatalogIndexState indstate)
Node * cookDefault(ParseState *pstate, Node *raw_default, Oid atttypid, int32 atttypmod, const char *attname, char attgenerated)
void heap_truncate_one_rel(Relation rel)
void RemovePartitionKeyByRelId(Oid relid)
Oid binary_upgrade_next_heap_pg_class_oid
const FormData_pg_attribute * SystemAttributeDefinition(AttrNumber attno)
static const FormData_pg_attribute a5
void StoreAttrMissingVal(Relation rel, AttrNumber attnum, Datum missingval)
Relation heap_create(const char *relname, Oid relnamespace, Oid reltablespace, Oid relid, RelFileNumber relfilenumber, Oid accessmtd, TupleDesc tupDesc, char relkind, char relpersistence, bool shared_relation, bool mapped_relation, bool allow_system_table_mods, TransactionId *relfrozenxid, MultiXactId *relminmxid, bool create_storage)
static Node * cookConstraint(ParseState *pstate, Node *raw_constraint, char *relname)
#define CHKATYPE_ANYRECORD
#define CHKATYPE_ANYARRAY
#define CHKATYPE_IS_VIRTUAL
#define CHKATYPE_IS_PARTKEY
HeapTuple heap_modify_tuple(HeapTuple tuple, TupleDesc tupleDesc, const Datum *replValues, const bool *replIsnull, const bool *doReplace)
HeapTuple heap_copytuple(HeapTuple tuple)
HeapTuple heap_form_tuple(TupleDesc tupleDescriptor, const Datum *values, const bool *isnull)
void heap_freetuple(HeapTuple htup)
#define HeapTupleIsValid(tuple)
static void * GETSTRUCT(const HeapTupleData *tuple)
#define MaxHeapAttributeNumber
static Datum fastgetattr(HeapTuple tup, int attnum, TupleDesc tupleDesc, bool *isnull)
IndexInfo * BuildDummyIndexInfo(Relation index)
void index_build(Relation heapRelation, Relation indexRelation, IndexInfo *indexInfo, bool isreindex, bool parallel)
void index_close(Relation relation, LOCKMODE lockmode)
Relation index_open(Oid relationId, LOCKMODE lockmode)
void CatalogTupleUpdate(Relation heapRel, ItemPointer otid, HeapTuple tup)
void CatalogTuplesMultiInsertWithInfo(Relation heapRel, TupleTableSlot **slot, int ntuples, CatalogIndexState indstate)
void CatalogTupleInsertWithInfo(Relation heapRel, HeapTuple tup, CatalogIndexState indstate)
void CatalogCloseIndexes(CatalogIndexState indstate)
void CatalogTupleInsert(Relation heapRel, HeapTuple tup)
CatalogIndexState CatalogOpenIndexes(Relation heapRel)
void CatalogTupleDelete(Relation heapRel, ItemPointer tid)
#define MAX_CATALOG_MULTI_INSERT_BYTES
int2vector * buildint2vector(const int16 *int2s, int n)
static bool pg_add_s16_overflow(int16 a, int16 b, int16 *result)
void CacheInvalidateRelcache(Relation relation)
void CacheInvalidateRelcacheByRelid(Oid relid)
struct ItemPointerData ItemPointerData
List * lappend(List *list, void *datum)
void list_sort(List *list, list_sort_comparator cmp)
List * list_delete_nth_cell(List *list, int n)
List * list_copy(const List *oldlist)
List * lappend_int(List *list, int datum)
List * lappend_oid(List *list, Oid datum)
List * list_append_unique_oid(List *list, Oid datum)
void list_deduplicate_oid(List *list)
int list_oid_cmp(const ListCell *p1, const ListCell *p2)
List * list_delete_last(List *list)
void list_free(List *list)
bool list_member_oid(const List *list, Oid datum)
List * list_union(const List *list1, const List *list2)
void LockRelationOid(Oid relid, LOCKMODE lockmode)
#define AccessExclusiveLock
Oid get_range_subtype(Oid rangeOid)
char * get_rel_name(Oid relid)
AttrNumber get_attnum(Oid relid, const char *attname)
Oid get_element_type(Oid typid)
char get_attgenerated(Oid relid, AttrNumber attnum)
char * get_attname(Oid relid, AttrNumber attnum, bool missing_ok)
Oid get_range_collation(Oid rangeOid)
bool type_is_collatable(Oid typid)
Oid get_typ_typrelid(Oid typid)
char get_typtype(Oid typid)
Oid getBaseType(Oid typid)
char * get_namespace_name(Oid nspid)
Oid get_relname_relid(const char *relname, Oid relnamespace)
char * pstrdup(const char *in)
void pfree(void *pointer)
#define IsBootstrapProcessingMode()
#define IsNormalProcessingMode()
#define InvalidMultiXactId
void namestrcpy(Name name, const char *str)
Oid exprType(const Node *expr)
#define expression_tree_walker(n, w, c)
#define IsA(nodeptr, _type_)
#define castNode(_type_, nodeptr)
#define InvokeObjectPostCreateHookArg(classId, objectId, subId, is_internal)
#define ObjectAddressSet(addr, class_id, object_id)
#define ObjectAddressSubSet(addr, class_id, object_id, object_sub_id)
oidvector * buildoidvector(const Oid *oids, int n)
char * nodeToString(const void *obj)
Node * coerce_to_boolean(ParseState *pstate, Node *node, const char *constructName)
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
void assign_expr_collations(ParseState *pstate, Node *expr)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
int parser_errposition(ParseState *pstate, int location)
ParseState * make_parsestate(ParseState *parentParseState)
@ EXPR_KIND_COLUMN_DEFAULT
@ EXPR_KIND_GENERATED_COLUMN
@ EXPR_KIND_CHECK_CONSTRAINT
ParseNamespaceItem * addRangeTableEntryForRelation(ParseState *pstate, Relation rel, int lockmode, Alias *alias, bool inh, bool inFromCl)
void addNSItemToQuery(ParseState *pstate, ParseNamespaceItem *nsitem, bool addToJoinList, bool addToRelNameSpace, bool addToVarNameSpace)
#define rt_fetch(rangetable_index, rangetable)
PartitionDesc RelationGetPartitionDesc(Relation rel, bool omit_detached)
Oid get_default_oid_from_partdesc(PartitionDesc partdesc)
void update_default_partition_oid(Oid parentId, Oid defaultPartId)
Oid get_default_partition_oid(Oid parentId)
Oid get_partition_parent(Oid relid, bool even_if_detached)
Oid StoreAttrDefault(Relation rel, AttrNumber attnum, Node *expr, bool is_internal)
FormData_pg_attribute * Form_pg_attribute
FormData_pg_class * Form_pg_class
Oid CreateConstraintEntry(const char *constraintName, Oid constraintNamespace, char constraintType, bool isDeferrable, bool isDeferred, bool isEnforced, bool isValidated, Oid parentConstrId, Oid relId, const int16 *constraintKey, int constraintNKeys, int constraintNTotalKeys, Oid domainId, Oid indexRelId, Oid foreignRelId, const int16 *foreignKey, const Oid *pfEqOp, const Oid *ppEqOp, const Oid *ffEqOp, int foreignNKeys, char foreignUpdateType, char foreignDeleteType, const int16 *fkDeleteSetCols, int numFkDeleteSetCols, char foreignMatchType, const Oid *exclOp, Node *conExpr, const char *conBin, bool conIsLocal, int16 conInhCount, bool conNoInherit, bool conPeriod, bool is_internal)
bool ConstraintNameIsUsed(ConstraintCategory conCat, Oid objId, const char *conname)
char * ChooseConstraintName(const char *name1, const char *name2, const char *label, Oid namespaceid, List *others)
bool AdjustNotNullInheritance(Oid relid, AttrNumber attnum, bool is_local, bool is_no_inherit, bool is_notvalid)
FormData_pg_constraint * Form_pg_constraint
void recordDependencyOn(const ObjectAddress *depender, const ObjectAddress *referenced, DependencyType behavior)
void recordDependencyOnCurrentExtension(const ObjectAddress *object, bool isReplace)
static int list_length(const List *l)
#define foreach_delete_current(lst, var_or_cell)
#define list_make1_oid(x1)
#define foreach_ptr(type, var, lst)
static void * list_nth(const List *list, int n)
#define foreach_node(type, var, lst)
#define list_nth_node(type, list, n)
void recordDependencyOnOwner(Oid classId, Oid objectId, Oid owner)
void recordDependencyOnTablespace(Oid classId, Oid objectId, Oid tablespace)
FormData_pg_statistic * Form_pg_statistic
void RemoveSubscriptionRel(Oid subid, Oid relid)
ObjectAddress TypeCreate(Oid newTypeOid, const char *typeName, Oid typeNamespace, Oid relationOid, char relationKind, Oid ownerId, int16 internalSize, char typeType, char typeCategory, bool typePreferred, char typDelim, Oid inputProcedure, Oid outputProcedure, Oid receiveProcedure, Oid sendProcedure, Oid typmodinProcedure, Oid typmodoutProcedure, Oid analyzeProcedure, Oid subscriptProcedure, Oid elementType, bool isImplicitArray, Oid arrayType, Oid baseType, const char *defaultTypeValue, char *defaultTypeBin, bool passedByValue, char alignment, char storage, int32 typeMod, int32 typNDims, bool typeNotNull, Oid typeCollation)
bool moveArrayTypeName(Oid typeOid, const char *typeName, Oid typeNamespace)
char * makeArrayTypeName(const char *typeName, Oid typeNamespace)
void pgstat_create_relation(Relation rel)
void pgstat_drop_relation(Relation rel)
static Datum PointerGetDatum(const void *X)
static Datum Float4GetDatum(float4 X)
static Datum TransactionIdGetDatum(TransactionId X)
static Datum Int16GetDatum(int16 X)
static Datum MultiXactIdGetDatum(MultiXactId X)
static Datum BoolGetDatum(bool X)
static Datum ObjectIdGetDatum(Oid X)
static Datum NameGetDatum(const NameData *X)
static Datum CStringGetDatum(const char *X)
static Datum Int32GetDatum(int32 X)
static Datum CharGetDatum(char X)
void CheckTableForSerializableConflictIn(Relation relation)
void * stringToNode(const char *str)
#define RelationGetRelid(relation)
#define RelationGetDescr(relation)
#define RelationGetNumberOfAttributes(relation)
#define RelationGetRelationName(relation)
#define RelationGetNamespace(relation)
List * RelationGetIndexList(Relation relation)
void RelationForgetRelation(Oid rid)
Relation RelationBuildLocalRelation(const char *relname, Oid relnamespace, TupleDesc tupDesc, Oid relid, Oid accessmtd, RelFileNumber relfilenumber, Oid reltablespace, bool shared_relation, bool mapped_relation, char relpersistence, char relkind)
#define InvalidRelFileNumber
#define RelFileNumberIsValid(relnumber)
void ScanKeyInit(ScanKey entry, AttrNumber attributeNumber, StrategyNumber strategy, RegProcedure procedure, Datum argument)
void relation_close(Relation relation, LOCKMODE lockmode)
Relation relation_open(Oid relationId, LOCKMODE lockmode)
void check_stack_depth(void)
SMgrRelation RelationCreateStorage(RelFileLocator rlocator, char relpersistence, bool register_delete)
void RelationDropStorage(Relation rel)
void RelationTruncate(Relation rel, BlockNumber nblocks)
#define BTEqualStrategyNumber
#define BTLessEqualStrategyNumber
#define ERRCODE_DUPLICATE_OBJECT
const char * p_sourcetext
RelFileLocator rd_locator
#define MinTransactionIdAttributeNumber
#define MaxCommandIdAttributeNumber
#define MaxTransactionIdAttributeNumber
#define TableOidAttributeNumber
#define SelfItemPointerAttributeNumber
#define MinCommandIdAttributeNumber
void ReleaseSysCache(HeapTuple tuple)
HeapTuple SearchSysCache1(int cacheId, Datum key1)
Datum SysCacheGetAttr(int cacheId, HeapTuple tup, AttrNumber attributeNumber, bool *isNull)
HeapTuple SearchSysCache2(int cacheId, Datum key1, Datum key2)
HeapTuple SearchSysCacheAttName(Oid relid, const char *attname)
#define SearchSysCacheCopy1(cacheId, key1)
#define SearchSysCacheCopy2(cacheId, key1, key2)
#define GetSysCacheOid2(cacheId, oidcol, key1, key2)
void table_close(Relation relation, LOCKMODE lockmode)
Relation table_open(Oid relationId, LOCKMODE lockmode)
static void table_relation_set_new_filelocator(Relation rel, const RelFileLocator *newrlocator, char persistence, TransactionId *freezeXid, MultiXactId *minmulti)
static void table_relation_nontransactional_truncate(Relation rel)
void CheckTableNotInUse(Relation rel, const char *stmt)
void remove_on_commit_action(Oid relid)
void register_on_commit_action(Oid relid, OnCommitAction action)
#define InvalidTransactionId
void FreeTupleDesc(TupleDesc tupdesc)
TupleDesc CreateTupleDesc(int natts, Form_pg_attribute *attrs)
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
static TupleTableSlot * ExecClearTuple(TupleTableSlot *slot)
Oid AssignTypeArrayOid(void)
bool contain_var_clause(Node *node)
List * pull_var_clause(Node *node, int flags)
void CommandCounterIncrement(void)