| 1 |
/* ------------------------------------------------------------------------- |
| 2 |
* |
| 3 |
* pgstat_relation.c |
| 4 |
* Implementation of relation statistics. |
| 5 |
* |
| 6 |
* This file contains the implementation of function relation. It is kept |
| 7 |
* separate from pgstat.c to enforce the line between the statistics access / |
| 8 |
* storage implementation and the details about individual types of |
| 9 |
* statistics. |
| 10 |
* |
| 11 |
* Copyright (c) 2001-2025, PostgreSQL Global Development Group |
| 12 |
* |
| 13 |
* IDENTIFICATION |
| 14 |
* src/backend/utils/activity/pgstat_relation.c |
| 15 |
* ------------------------------------------------------------------------- |
| 16 |
*/ |
| 17 |
|
| 18 |
#include "postgres.h" |
| 19 |
|
| 20 |
#include "access/twophase_rmgr.h" |
| 21 |
#include "access/xact.h" |
| 22 |
#include "catalog/catalog.h" |
| 23 |
#include "utils/memutils.h" |
| 24 |
#include "utils/pgstat_internal.h" |
| 25 |
#include "utils/rel.h" |
| 26 |
#include "utils/timestamp.h" |
| 27 |
|
| 28 |
|
| 29 |
/* Record that's written to 2PC state file when pgstat state is persisted */ |
| 30 |
typedef struct TwoPhasePgStatRecord |
| 31 |
{ |
| 32 |
PgStat_Counter tuples_inserted; /* tuples inserted in xact */ |
| 33 |
PgStat_Counter tuples_updated; /* tuples updated in xact */ |
| 34 |
PgStat_Counter tuples_deleted; /* tuples deleted in xact */ |
| 35 |
/* tuples i/u/d prior to truncate/drop */ |
| 36 |
PgStat_Counter inserted_pre_truncdrop; |
| 37 |
PgStat_Counter updated_pre_truncdrop; |
| 38 |
PgStat_Counter deleted_pre_truncdrop; |
| 39 |
Oid id; /* table's OID */ |
| 40 |
bool shared; /* is it a shared catalog? */ |
| 41 |
bool truncdropped; /* was the relation truncated/dropped? */ |
| 42 |
} TwoPhasePgStatRecord; |
| 43 |
|
| 44 |
|
| 45 |
static PgStat_TableStatus *pgstat_prep_relation_pending(Oid rel_id, bool isshared); |
| 46 |
static void add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level); |
| 47 |
static void ensure_tabstat_xact_level(PgStat_TableStatus *pgstat_info); |
| 48 |
static void save_truncdrop_counters(PgStat_TableXactStatus *trans, bool is_drop); |
| 49 |
static void restore_truncdrop_counters(PgStat_TableXactStatus *trans); |
| 50 |
|
| 51 |
|
| 52 |
/* |
| 53 |
* Copy stats between relations. This is used for things like REINDEX |
| 54 |
* CONCURRENTLY. |
| 55 |
*/ |
| 56 |
void |
| 57 |
pgstat_copy_relation_stats(Relation dst, Relation src) |
| 58 |
{ |
| 59 |
PgStat_StatTabEntry *srcstats; |
| 60 |
PgStatShared_Relation *dstshstats; |
| 61 |
PgStat_EntryRef *dst_ref; |
| 62 |
|
| 63 |
srcstats = pgstat_fetch_stat_tabentry_ext(src->rd_rel->relisshared, |
| 64 |
RelationGetRelid(src)); |
| 65 |
if (!srcstats) |
| 66 |
return; |
| 67 |
|
| 68 |
dst_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, |
| 69 |
dst->rd_rel->relisshared ? InvalidOid : MyDatabaseId, |
| 70 |
RelationGetRelid(dst), |
| 71 |
false); |
| 72 |
|
| 73 |
dstshstats = (PgStatShared_Relation *) dst_ref->shared_stats; |
| 74 |
dstshstats->stats = *srcstats; |
| 75 |
|
| 76 |
pgstat_unlock_entry(dst_ref); |
| 77 |
} |
| 78 |
|
| 79 |
/* |
| 80 |
* Initialize a relcache entry to count access statistics. Called whenever a |
| 81 |
* relation is opened. |
| 82 |
* |
| 83 |
* We assume that a relcache entry's pgstat_info field is zeroed by relcache.c |
| 84 |
* when the relcache entry is made; thereafter it is long-lived data. |
| 85 |
* |
| 86 |
* This does not create a reference to a stats entry in shared memory, nor |
| 87 |
* allocate memory for the pending stats. That happens in |
| 88 |
* pgstat_assoc_relation(). |
| 89 |
*/ |
| 90 |
void |
| 91 |
pgstat_init_relation(Relation rel) |
| 92 |
{ |
| 93 |
char relkind = rel->rd_rel->relkind; |
| 94 |
|
| 95 |
/* |
| 96 |
* We only count stats for relations with storage and partitioned tables |
| 97 |
*/ |
| 98 |
if (!RELKIND_HAS_STORAGE(relkind) && relkind != RELKIND_PARTITIONED_TABLE) |
| 99 |
{ |
| 100 |
rel->pgstat_enabled = false; |
| 101 |
rel->pgstat_info = NULL; |
| 102 |
return; |
| 103 |
} |
| 104 |
|
| 105 |
if (!pgstat_track_counts) |
| 106 |
{ |
| 107 |
if (rel->pgstat_info) |
| 108 |
pgstat_unlink_relation(rel); |
| 109 |
|
| 110 |
/* We're not counting at all */ |
| 111 |
rel->pgstat_enabled = false; |
| 112 |
rel->pgstat_info = NULL; |
| 113 |
return; |
| 114 |
} |
| 115 |
|
| 116 |
rel->pgstat_enabled = true; |
| 117 |
} |
| 118 |
|
| 119 |
/* |
| 120 |
* Prepare for statistics for this relation to be collected. |
| 121 |
* |
| 122 |
* This ensures we have a reference to the stats entry before stats can be |
| 123 |
* generated. That is important because a relation drop in another connection |
| 124 |
* could otherwise lead to the stats entry being dropped, which then later |
| 125 |
* would get recreated when flushing stats. |
| 126 |
* |
| 127 |
* This is separate from pgstat_init_relation() as it is not uncommon for |
| 128 |
* relcache entries to be opened without ever getting stats reported. |
| 129 |
*/ |
| 130 |
void |
| 131 |
pgstat_assoc_relation(Relation rel) |
| 132 |
{ |
| 133 |
Assert(rel->pgstat_enabled); |
| 134 |
Assert(rel->pgstat_info == NULL); |
| 135 |
|
| 136 |
/* Else find or make the PgStat_TableStatus entry, and update link */ |
| 137 |
rel->pgstat_info = pgstat_prep_relation_pending(RelationGetRelid(rel), |
| 138 |
rel->rd_rel->relisshared); |
| 139 |
|
| 140 |
/* don't allow link a stats to multiple relcache entries */ |
| 141 |
Assert(rel->pgstat_info->relation == NULL); |
| 142 |
|
| 143 |
/* mark this relation as the owner */ |
| 144 |
rel->pgstat_info->relation = rel; |
| 145 |
} |
| 146 |
|
| 147 |
/* |
| 148 |
* Break the mutual link between a relcache entry and pending stats entry. |
| 149 |
* This must be called whenever one end of the link is removed. |
| 150 |
*/ |
| 151 |
void |
| 152 |
pgstat_unlink_relation(Relation rel) |
| 153 |
{ |
| 154 |
/* remove the link to stats info if any */ |
| 155 |
if (rel->pgstat_info == NULL) |
| 156 |
return; |
| 157 |
|
| 158 |
/* link sanity check */ |
| 159 |
Assert(rel->pgstat_info->relation == rel); |
| 160 |
rel->pgstat_info->relation = NULL; |
| 161 |
rel->pgstat_info = NULL; |
| 162 |
} |
| 163 |
|
| 164 |
/* |
| 165 |
* Ensure that stats are dropped if transaction aborts. |
| 166 |
*/ |
| 167 |
void |
| 168 |
pgstat_create_relation(Relation rel) |
| 169 |
{ |
| 170 |
pgstat_create_transactional(PGSTAT_KIND_RELATION, |
| 171 |
rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId, |
| 172 |
RelationGetRelid(rel)); |
| 173 |
} |
| 174 |
|
| 175 |
/* |
| 176 |
* Ensure that stats are dropped if transaction commits. |
| 177 |
*/ |
| 178 |
void |
| 179 |
pgstat_drop_relation(Relation rel) |
| 180 |
{ |
| 181 |
int nest_level = GetCurrentTransactionNestLevel(); |
| 182 |
PgStat_TableStatus *pgstat_info; |
| 183 |
|
| 184 |
pgstat_drop_transactional(PGSTAT_KIND_RELATION, |
| 185 |
rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId, |
| 186 |
RelationGetRelid(rel)); |
| 187 |
|
| 188 |
if (!pgstat_should_count_relation(rel)) |
| 189 |
return; |
| 190 |
|
| 191 |
/* |
| 192 |
* Transactionally set counters to 0. That ensures that accesses to |
| 193 |
* pg_stat_xact_all_tables inside the transaction show 0. |
| 194 |
*/ |
| 195 |
pgstat_info = rel->pgstat_info; |
| 196 |
if (pgstat_info->trans && |
| 197 |
pgstat_info->trans->nest_level == nest_level) |
| 198 |
{ |
| 199 |
save_truncdrop_counters(pgstat_info->trans, true); |
| 200 |
pgstat_info->trans->tuples_inserted = 0; |
| 201 |
pgstat_info->trans->tuples_updated = 0; |
| 202 |
pgstat_info->trans->tuples_deleted = 0; |
| 203 |
} |
| 204 |
} |
| 205 |
|
| 206 |
/* |
| 207 |
* Report that the table was just vacuumed and flush IO statistics. |
| 208 |
*/ |
| 209 |
void |
| 210 |
pgstat_report_vacuum(Oid tableoid, bool shared, |
| 211 |
PgStat_Counter livetuples, PgStat_Counter deadtuples, |
| 212 |
TimestampTz starttime) |
| 213 |
{ |
| 214 |
PgStat_EntryRef *entry_ref; |
| 215 |
PgStatShared_Relation *shtabentry; |
| 216 |
PgStat_StatTabEntry *tabentry; |
| 217 |
Oid dboid = (shared ? InvalidOid : MyDatabaseId); |
| 218 |
TimestampTz ts; |
| 219 |
PgStat_Counter elapsedtime; |
| 220 |
|
| 221 |
if (!pgstat_track_counts) |
| 222 |
return; |
| 223 |
|
| 224 |
/* Store the data in the table's hash table entry. */ |
| 225 |
ts = GetCurrentTimestamp(); |
| 226 |
elapsedtime = TimestampDifferenceMilliseconds(starttime, ts); |
| 227 |
|
| 228 |
/* block acquiring lock for the same reason as pgstat_report_autovac() */ |
| 229 |
entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, |
| 230 |
dboid, tableoid, false); |
| 231 |
|
| 232 |
shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats; |
| 233 |
tabentry = &shtabentry->stats; |
| 234 |
|
| 235 |
tabentry->live_tuples = livetuples; |
| 236 |
tabentry->dead_tuples = deadtuples; |
| 237 |
|
| 238 |
/* |
| 239 |
* It is quite possible that a non-aggressive VACUUM ended up skipping |
| 240 |
* various pages, however, we'll zero the insert counter here regardless. |
| 241 |
* It's currently used only to track when we need to perform an "insert" |
| 242 |
* autovacuum, which are mainly intended to freeze newly inserted tuples. |
| 243 |
* Zeroing this may just mean we'll not try to vacuum the table again |
| 244 |
* until enough tuples have been inserted to trigger another insert |
| 245 |
* autovacuum. An anti-wraparound autovacuum will catch any persistent |
| 246 |
* stragglers. |
| 247 |
*/ |
| 248 |
tabentry->ins_since_vacuum = 0; |
| 249 |
|
| 250 |
if (AmAutoVacuumWorkerProcess()) |
| 251 |
{ |
| 252 |
tabentry->last_autovacuum_time = ts; |
| 253 |
tabentry->autovacuum_count++; |
| 254 |
tabentry->total_autovacuum_time += elapsedtime; |
| 255 |
} |
| 256 |
else |
| 257 |
{ |
| 258 |
tabentry->last_vacuum_time = ts; |
| 259 |
tabentry->vacuum_count++; |
| 260 |
tabentry->total_vacuum_time += elapsedtime; |
| 261 |
} |
| 262 |
|
| 263 |
pgstat_unlock_entry(entry_ref); |
| 264 |
|
| 265 |
/* |
| 266 |
* Flush IO statistics now. pgstat_report_stat() will flush IO stats, |
| 267 |
* however this will not be called until after an entire autovacuum cycle |
| 268 |
* is done -- which will likely vacuum many relations -- or until the |
| 269 |
* VACUUM command has processed all tables and committed. |
| 270 |
*/ |
| 271 |
pgstat_flush_io(false); |
| 272 |
(void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); |
| 273 |
} |
| 274 |
|
| 275 |
/* |
| 276 |
* Report that the table was just analyzed and flush IO statistics. |
| 277 |
* |
| 278 |
* Caller must provide new live- and dead-tuples estimates, as well as a |
| 279 |
* flag indicating whether to reset the mod_since_analyze counter. |
| 280 |
*/ |
| 281 |
void |
| 282 |
pgstat_report_analyze(Relation rel, |
| 283 |
PgStat_Counter livetuples, PgStat_Counter deadtuples, |
| 284 |
bool resetcounter, TimestampTz starttime) |
| 285 |
{ |
| 286 |
PgStat_EntryRef *entry_ref; |
| 287 |
PgStatShared_Relation *shtabentry; |
| 288 |
PgStat_StatTabEntry *tabentry; |
| 289 |
Oid dboid = (rel->rd_rel->relisshared ? InvalidOid : MyDatabaseId); |
| 290 |
TimestampTz ts; |
| 291 |
PgStat_Counter elapsedtime; |
| 292 |
|
| 293 |
if (!pgstat_track_counts) |
| 294 |
return; |
| 295 |
|
| 296 |
/* |
| 297 |
* Unlike VACUUM, ANALYZE might be running inside a transaction that has |
| 298 |
* already inserted and/or deleted rows in the target table. ANALYZE will |
| 299 |
* have counted such rows as live or dead respectively. Because we will |
| 300 |
* report our counts of such rows at transaction end, we should subtract |
| 301 |
* off these counts from the update we're making now, else they'll be |
| 302 |
* double-counted after commit. (This approach also ensures that the |
| 303 |
* shared stats entry ends up with the right numbers if we abort instead |
| 304 |
* of committing.) |
| 305 |
* |
| 306 |
* Waste no time on partitioned tables, though. |
| 307 |
*/ |
| 308 |
if (pgstat_should_count_relation(rel) && |
| 309 |
rel->rd_rel->relkind != RELKIND_PARTITIONED_TABLE) |
| 310 |
{ |
| 311 |
PgStat_TableXactStatus *trans; |
| 312 |
|
| 313 |
for (trans = rel->pgstat_info->trans; trans; trans = trans->upper) |
| 314 |
{ |
| 315 |
livetuples -= trans->tuples_inserted - trans->tuples_deleted; |
| 316 |
deadtuples -= trans->tuples_updated + trans->tuples_deleted; |
| 317 |
} |
| 318 |
/* count stuff inserted by already-aborted subxacts, too */ |
| 319 |
deadtuples -= rel->pgstat_info->counts.delta_dead_tuples; |
| 320 |
/* Since ANALYZE's counts are estimates, we could have underflowed */ |
| 321 |
livetuples = Max(livetuples, 0); |
| 322 |
deadtuples = Max(deadtuples, 0); |
| 323 |
} |
| 324 |
|
| 325 |
/* Store the data in the table's hash table entry. */ |
| 326 |
ts = GetCurrentTimestamp(); |
| 327 |
elapsedtime = TimestampDifferenceMilliseconds(starttime, ts); |
| 328 |
|
| 329 |
/* block acquiring lock for the same reason as pgstat_report_autovac() */ |
| 330 |
entry_ref = pgstat_get_entry_ref_locked(PGSTAT_KIND_RELATION, dboid, |
| 331 |
RelationGetRelid(rel), |
| 332 |
false); |
| 333 |
/* can't get dropped while accessed */ |
| 334 |
Assert(entry_ref != NULL && entry_ref->shared_stats != NULL); |
| 335 |
|
| 336 |
shtabentry = (PgStatShared_Relation *) entry_ref->shared_stats; |
| 337 |
tabentry = &shtabentry->stats; |
| 338 |
|
| 339 |
tabentry->live_tuples = livetuples; |
| 340 |
tabentry->dead_tuples = deadtuples; |
| 341 |
|
| 342 |
/* |
| 343 |
* If commanded, reset mod_since_analyze to zero. This forgets any |
| 344 |
* changes that were committed while the ANALYZE was in progress, but we |
| 345 |
* have no good way to estimate how many of those there were. |
| 346 |
*/ |
| 347 |
if (resetcounter) |
| 348 |
tabentry->mod_since_analyze = 0; |
| 349 |
|
| 350 |
if (AmAutoVacuumWorkerProcess()) |
| 351 |
{ |
| 352 |
tabentry->last_autoanalyze_time = ts; |
| 353 |
tabentry->autoanalyze_count++; |
| 354 |
tabentry->total_autoanalyze_time += elapsedtime; |
| 355 |
} |
| 356 |
else |
| 357 |
{ |
| 358 |
tabentry->last_analyze_time = ts; |
| 359 |
tabentry->analyze_count++; |
| 360 |
tabentry->total_analyze_time += elapsedtime; |
| 361 |
} |
| 362 |
|
| 363 |
pgstat_unlock_entry(entry_ref); |
| 364 |
|
| 365 |
/* see pgstat_report_vacuum() */ |
| 366 |
pgstat_flush_io(false); |
| 367 |
(void) pgstat_flush_backend(false, PGSTAT_BACKEND_FLUSH_IO); |
| 368 |
} |
| 369 |
|
| 370 |
/* |
| 371 |
* count a tuple insertion of n tuples |
| 372 |
*/ |
| 373 |
void |
| 374 |
pgstat_count_heap_insert(Relation rel, PgStat_Counter n) |
| 375 |
{ |
| 376 |
if (pgstat_should_count_relation(rel)) |
| 377 |
{ |
| 378 |
PgStat_TableStatus *pgstat_info = rel->pgstat_info; |
| 379 |
|
| 380 |
ensure_tabstat_xact_level(pgstat_info); |
| 381 |
pgstat_info->trans->tuples_inserted += n; |
| 382 |
} |
| 383 |
} |
| 384 |
|
| 385 |
/* |
| 386 |
* count a tuple update |
| 387 |
*/ |
| 388 |
void |
| 389 |
pgstat_count_heap_update(Relation rel, bool hot, bool newpage) |
| 390 |
{ |
| 391 |
Assert(!(hot && newpage)); |
| 392 |
|
| 393 |
if (pgstat_should_count_relation(rel)) |
| 394 |
{ |
| 395 |
PgStat_TableStatus *pgstat_info = rel->pgstat_info; |
| 396 |
|
| 397 |
ensure_tabstat_xact_level(pgstat_info); |
| 398 |
pgstat_info->trans->tuples_updated++; |
| 399 |
|
| 400 |
/* |
| 401 |
* tuples_hot_updated and tuples_newpage_updated counters are |
| 402 |
* nontransactional, so just advance them |
| 403 |
*/ |
| 404 |
if (hot) |
| 405 |
pgstat_info->counts.tuples_hot_updated++; |
| 406 |
else if (newpage) |
| 407 |
pgstat_info->counts.tuples_newpage_updated++; |
| 408 |
} |
| 409 |
} |
| 410 |
|
| 411 |
/* |
| 412 |
* count a tuple deletion |
| 413 |
*/ |
| 414 |
void |
| 415 |
pgstat_count_heap_delete(Relation rel) |
| 416 |
{ |
| 417 |
if (pgstat_should_count_relation(rel)) |
| 418 |
{ |
| 419 |
PgStat_TableStatus *pgstat_info = rel->pgstat_info; |
| 420 |
|
| 421 |
ensure_tabstat_xact_level(pgstat_info); |
| 422 |
pgstat_info->trans->tuples_deleted++; |
| 423 |
} |
| 424 |
} |
| 425 |
|
| 426 |
/* |
| 427 |
* update tuple counters due to truncate |
| 428 |
*/ |
| 429 |
void |
| 430 |
pgstat_count_truncate(Relation rel) |
| 431 |
{ |
| 432 |
if (pgstat_should_count_relation(rel)) |
| 433 |
{ |
| 434 |
PgStat_TableStatus *pgstat_info = rel->pgstat_info; |
| 435 |
|
| 436 |
ensure_tabstat_xact_level(pgstat_info); |
| 437 |
save_truncdrop_counters(pgstat_info->trans, false); |
| 438 |
pgstat_info->trans->tuples_inserted = 0; |
| 439 |
pgstat_info->trans->tuples_updated = 0; |
| 440 |
pgstat_info->trans->tuples_deleted = 0; |
| 441 |
} |
| 442 |
} |
| 443 |
|
| 444 |
/* |
| 445 |
* update dead-tuples count |
| 446 |
* |
| 447 |
* The semantics of this are that we are reporting the nontransactional |
| 448 |
* recovery of "delta" dead tuples; so delta_dead_tuples decreases |
| 449 |
* rather than increasing, and the change goes straight into the per-table |
| 450 |
* counter, not into transactional state. |
| 451 |
*/ |
| 452 |
void |
| 453 |
pgstat_update_heap_dead_tuples(Relation rel, int delta) |
| 454 |
{ |
| 455 |
if (pgstat_should_count_relation(rel)) |
| 456 |
{ |
| 457 |
PgStat_TableStatus *pgstat_info = rel->pgstat_info; |
| 458 |
|
| 459 |
pgstat_info->counts.delta_dead_tuples -= delta; |
| 460 |
} |
| 461 |
} |
| 462 |
|
| 463 |
/* |
| 464 |
* Support function for the SQL-callable pgstat* functions. Returns |
| 465 |
* the collected statistics for one table or NULL. NULL doesn't mean |
| 466 |
* that the table doesn't exist, just that there are no statistics, so the |
| 467 |
* caller is better off to report ZERO instead. |
| 468 |
*/ |
| 469 |
PgStat_StatTabEntry * |
| 470 |
pgstat_fetch_stat_tabentry(Oid relid) |
| 471 |
{ |
| 472 |
return pgstat_fetch_stat_tabentry_ext(IsSharedRelation(relid), relid); |
| 473 |
} |
| 474 |
|
| 475 |
/* |
| 476 |
* More efficient version of pgstat_fetch_stat_tabentry(), allowing to specify |
| 477 |
* whether the to-be-accessed table is a shared relation or not. |
| 478 |
*/ |
| 479 |
PgStat_StatTabEntry * |
| 480 |
pgstat_fetch_stat_tabentry_ext(bool shared, Oid reloid) |
| 481 |
{ |
| 482 |
Oid dboid = (shared ? InvalidOid : MyDatabaseId); |
| 483 |
|
| 484 |
return (PgStat_StatTabEntry *) |
| 485 |
pgstat_fetch_entry(PGSTAT_KIND_RELATION, dboid, reloid); |
| 486 |
} |
| 487 |
|
| 488 |
/* |
| 489 |
* find any existing PgStat_TableStatus entry for rel |
| 490 |
* |
| 491 |
* Find any existing PgStat_TableStatus entry for rel_id in the current |
| 492 |
* database. If not found, try finding from shared tables. |
| 493 |
* |
| 494 |
* If an entry is found, copy it and increment the copy's counters with their |
| 495 |
* subtransaction counterparts, then return the copy. The caller may need to |
| 496 |
* pfree() the copy. |
| 497 |
* |
| 498 |
* If no entry found, return NULL, don't create a new one. |
| 499 |
*/ |
| 500 |
PgStat_TableStatus * |
| 501 |
find_tabstat_entry(Oid rel_id) |
| 502 |
{ |
| 503 |
PgStat_EntryRef *entry_ref; |
| 504 |
PgStat_TableXactStatus *trans; |
| 505 |
PgStat_TableStatus *tabentry = NULL; |
| 506 |
PgStat_TableStatus *tablestatus = NULL; |
| 507 |
|
| 508 |
entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, MyDatabaseId, rel_id); |
| 509 |
if (!entry_ref) |
| 510 |
{ |
| 511 |
entry_ref = pgstat_fetch_pending_entry(PGSTAT_KIND_RELATION, InvalidOid, rel_id); |
| 512 |
if (!entry_ref) |
| 513 |
return tablestatus; |
| 514 |
} |
| 515 |
|
| 516 |
tabentry = (PgStat_TableStatus *) entry_ref->pending; |
| 517 |
tablestatus = palloc(sizeof(PgStat_TableStatus)); |
| 518 |
*tablestatus = *tabentry; |
| 519 |
|
| 520 |
/* |
| 521 |
* Reset tablestatus->trans in the copy of PgStat_TableStatus as it may |
| 522 |
* point to a shared memory area. Its data is saved below, so removing it |
| 523 |
* does not matter. |
| 524 |
*/ |
| 525 |
tablestatus->trans = NULL; |
| 526 |
|
| 527 |
/* |
| 528 |
* Live subtransaction counts are not included yet. This is not a hot |
| 529 |
* code path so reconcile tuples_inserted, tuples_updated and |
| 530 |
* tuples_deleted even if the caller may not be interested in this data. |
| 531 |
*/ |
| 532 |
for (trans = tabentry->trans; trans != NULL; trans = trans->upper) |
| 533 |
{ |
| 534 |
tablestatus->counts.tuples_inserted += trans->tuples_inserted; |
| 535 |
tablestatus->counts.tuples_updated += trans->tuples_updated; |
| 536 |
tablestatus->counts.tuples_deleted += trans->tuples_deleted; |
| 537 |
} |
| 538 |
|
| 539 |
return tablestatus; |
| 540 |
} |
| 541 |
|
| 542 |
/* |
| 543 |
* Perform relation stats specific end-of-transaction work. Helper for |
| 544 |
* AtEOXact_PgStat. |
| 545 |
* |
| 546 |
* Transfer transactional insert/update counts into the base tabstat entries. |
| 547 |
* We don't bother to free any of the transactional state, since it's all in |
| 548 |
* TopTransactionContext and will go away anyway. |
| 549 |
*/ |
| 550 |
void |
| 551 |
AtEOXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit) |
| 552 |
{ |
| 553 |
PgStat_TableXactStatus *trans; |
| 554 |
|
| 555 |
for (trans = xact_state->first; trans != NULL; trans = trans->next) |
| 556 |
{ |
| 557 |
PgStat_TableStatus *tabstat; |
| 558 |
|
| 559 |
Assert(trans->nest_level == 1); |
| 560 |
Assert(trans->upper == NULL); |
| 561 |
tabstat = trans->parent; |
| 562 |
Assert(tabstat->trans == trans); |
| 563 |
/* restore pre-truncate/drop stats (if any) in case of aborted xact */ |
| 564 |
if (!isCommit) |
| 565 |
restore_truncdrop_counters(trans); |
| 566 |
/* count attempted actions regardless of commit/abort */ |
| 567 |
tabstat->counts.tuples_inserted += trans->tuples_inserted; |
| 568 |
tabstat->counts.tuples_updated += trans->tuples_updated; |
| 569 |
tabstat->counts.tuples_deleted += trans->tuples_deleted; |
| 570 |
if (isCommit) |
| 571 |
{ |
| 572 |
tabstat->counts.truncdropped = trans->truncdropped; |
| 573 |
if (trans->truncdropped) |
| 574 |
{ |
| 575 |
/* forget live/dead stats seen by backend thus far */ |
| 576 |
tabstat->counts.delta_live_tuples = 0; |
| 577 |
tabstat->counts.delta_dead_tuples = 0; |
| 578 |
} |
| 579 |
/* insert adds a live tuple, delete removes one */ |
| 580 |
tabstat->counts.delta_live_tuples += |
| 581 |
trans->tuples_inserted - trans->tuples_deleted; |
| 582 |
/* update and delete each create a dead tuple */ |
| 583 |
tabstat->counts.delta_dead_tuples += |
| 584 |
trans->tuples_updated + trans->tuples_deleted; |
| 585 |
/* insert, update, delete each count as one change event */ |
| 586 |
tabstat->counts.changed_tuples += |
| 587 |
trans->tuples_inserted + trans->tuples_updated + |
| 588 |
trans->tuples_deleted; |
| 589 |
} |
| 590 |
else |
| 591 |
{ |
| 592 |
/* inserted tuples are dead, deleted tuples are unaffected */ |
| 593 |
tabstat->counts.delta_dead_tuples += |
| 594 |
trans->tuples_inserted + trans->tuples_updated; |
| 595 |
/* an aborted xact generates no changed_tuple events */ |
| 596 |
} |
| 597 |
tabstat->trans = NULL; |
| 598 |
} |
| 599 |
} |
| 600 |
|
| 601 |
/* |
| 602 |
* Perform relation stats specific end-of-sub-transaction work. Helper for |
| 603 |
* AtEOSubXact_PgStat. |
| 604 |
* |
| 605 |
* Transfer transactional insert/update counts into the next higher |
| 606 |
* subtransaction state. |
| 607 |
*/ |
| 608 |
void |
| 609 |
AtEOSubXact_PgStat_Relations(PgStat_SubXactStatus *xact_state, bool isCommit, int nestDepth) |
| 610 |
{ |
| 611 |
PgStat_TableXactStatus *trans; |
| 612 |
PgStat_TableXactStatus *next_trans; |
| 613 |
|
| 614 |
for (trans = xact_state->first; trans != NULL; trans = next_trans) |
| 615 |
{ |
| 616 |
PgStat_TableStatus *tabstat; |
| 617 |
|
| 618 |
next_trans = trans->next; |
| 619 |
Assert(trans->nest_level == nestDepth); |
| 620 |
tabstat = trans->parent; |
| 621 |
Assert(tabstat->trans == trans); |
| 622 |
|
| 623 |
if (isCommit) |
| 624 |
{ |
| 625 |
if (trans->upper && trans->upper->nest_level == nestDepth - 1) |
| 626 |
{ |
| 627 |
if (trans->truncdropped) |
| 628 |
{ |
| 629 |
/* propagate the truncate/drop status one level up */ |
| 630 |
save_truncdrop_counters(trans->upper, false); |
| 631 |
/* replace upper xact stats with ours */ |
| 632 |
trans->upper->tuples_inserted = trans->tuples_inserted; |
| 633 |
trans->upper->tuples_updated = trans->tuples_updated; |
| 634 |
trans->upper->tuples_deleted = trans->tuples_deleted; |
| 635 |
} |
| 636 |
else |
| 637 |
{ |
| 638 |
trans->upper->tuples_inserted += trans->tuples_inserted; |
| 639 |
trans->upper->tuples_updated += trans->tuples_updated; |
| 640 |
trans->upper->tuples_deleted += trans->tuples_deleted; |
| 641 |
} |
| 642 |
tabstat->trans = trans->upper; |
| 643 |
pfree(trans); |
| 644 |
} |
| 645 |
else |
| 646 |
{ |
| 647 |
/* |
| 648 |
* When there isn't an immediate parent state, we can just |
| 649 |
* reuse the record instead of going through a palloc/pfree |
| 650 |
* pushup (this works since it's all in TopTransactionContext |
| 651 |
* anyway). We have to re-link it into the parent level, |
| 652 |
* though, and that might mean pushing a new entry into the |
| 653 |
* pgStatXactStack. |
| 654 |
*/ |
| 655 |
PgStat_SubXactStatus *upper_xact_state; |
| 656 |
|
| 657 |
upper_xact_state = pgstat_get_xact_stack_level(nestDepth - 1); |
| 658 |
trans->next = upper_xact_state->first; |
| 659 |
upper_xact_state->first = trans; |
| 660 |
trans->nest_level = nestDepth - 1; |
| 661 |
} |
| 662 |
} |
| 663 |
else |
| 664 |
{ |
| 665 |
/* |
| 666 |
* On abort, update top-level tabstat counts, then forget the |
| 667 |
* subtransaction |
| 668 |
*/ |
| 669 |
|
| 670 |
/* first restore values obliterated by truncate/drop */ |
| 671 |
restore_truncdrop_counters(trans); |
| 672 |
/* count attempted actions regardless of commit/abort */ |
| 673 |
tabstat->counts.tuples_inserted += trans->tuples_inserted; |
| 674 |
tabstat->counts.tuples_updated += trans->tuples_updated; |
| 675 |
tabstat->counts.tuples_deleted += trans->tuples_deleted; |
| 676 |
/* inserted tuples are dead, deleted tuples are unaffected */ |
| 677 |
tabstat->counts.delta_dead_tuples += |
| 678 |
trans->tuples_inserted + trans->tuples_updated; |
| 679 |
tabstat->trans = trans->upper; |
| 680 |
pfree(trans); |
| 681 |
} |
| 682 |
} |
| 683 |
} |
| 684 |
|
| 685 |
/* |
| 686 |
* Generate 2PC records for all the pending transaction-dependent relation |
| 687 |
* stats. |
| 688 |
*/ |
| 689 |
void |
| 690 |
AtPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state) |
| 691 |
{ |
| 692 |
PgStat_TableXactStatus *trans; |
| 693 |
|
| 694 |
for (trans = xact_state->first; trans != NULL; trans = trans->next) |
| 695 |
{ |
| 696 |
PgStat_TableStatus *tabstat PG_USED_FOR_ASSERTS_ONLY; |
| 697 |
TwoPhasePgStatRecord record; |
| 698 |
|
| 699 |
Assert(trans->nest_level == 1); |
| 700 |
Assert(trans->upper == NULL); |
| 701 |
tabstat = trans->parent; |
| 702 |
Assert(tabstat->trans == trans); |
| 703 |
|
| 704 |
record.tuples_inserted = trans->tuples_inserted; |
| 705 |
record.tuples_updated = trans->tuples_updated; |
| 706 |
record.tuples_deleted = trans->tuples_deleted; |
| 707 |
record.inserted_pre_truncdrop = trans->inserted_pre_truncdrop; |
| 708 |
record.updated_pre_truncdrop = trans->updated_pre_truncdrop; |
| 709 |
record.deleted_pre_truncdrop = trans->deleted_pre_truncdrop; |
| 710 |
record.id = tabstat->id; |
| 711 |
record.shared = tabstat->shared; |
| 712 |
record.truncdropped = trans->truncdropped; |
| 713 |
|
| 714 |
RegisterTwoPhaseRecord(TWOPHASE_RM_PGSTAT_ID, 0, |
| 715 |
&record, sizeof(TwoPhasePgStatRecord)); |
| 716 |
} |
| 717 |
} |
| 718 |
|
| 719 |
/* |
| 720 |
* All we need do here is unlink the transaction stats state from the |
| 721 |
* nontransactional state. The nontransactional action counts will be |
| 722 |
* reported to the stats system immediately, while the effects on live and |
| 723 |
* dead tuple counts are preserved in the 2PC state file. |
| 724 |
* |
| 725 |
* Note: AtEOXact_PgStat_Relations is not called during PREPARE. |
| 726 |
*/ |
| 727 |
void |
| 728 |
PostPrepare_PgStat_Relations(PgStat_SubXactStatus *xact_state) |
| 729 |
{ |
| 730 |
PgStat_TableXactStatus *trans; |
| 731 |
|
| 732 |
for (trans = xact_state->first; trans != NULL; trans = trans->next) |
| 733 |
{ |
| 734 |
PgStat_TableStatus *tabstat; |
| 735 |
|
| 736 |
tabstat = trans->parent; |
| 737 |
tabstat->trans = NULL; |
| 738 |
} |
| 739 |
} |
| 740 |
|
| 741 |
/* |
| 742 |
* 2PC processing routine for COMMIT PREPARED case. |
| 743 |
* |
| 744 |
* Load the saved counts into our local pgstats state. |
| 745 |
*/ |
| 746 |
void |
| 747 |
pgstat_twophase_postcommit(TransactionId xid, uint16 info, |
| 748 |
void *recdata, uint32 len) |
| 749 |
{ |
| 750 |
TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata; |
| 751 |
PgStat_TableStatus *pgstat_info; |
| 752 |
|
| 753 |
/* Find or create a tabstat entry for the rel */ |
| 754 |
pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared); |
| 755 |
|
| 756 |
/* Same math as in AtEOXact_PgStat, commit case */ |
| 757 |
pgstat_info->counts.tuples_inserted += rec->tuples_inserted; |
| 758 |
pgstat_info->counts.tuples_updated += rec->tuples_updated; |
| 759 |
pgstat_info->counts.tuples_deleted += rec->tuples_deleted; |
| 760 |
pgstat_info->counts.truncdropped = rec->truncdropped; |
| 761 |
if (rec->truncdropped) |
| 762 |
{ |
| 763 |
/* forget live/dead stats seen by backend thus far */ |
| 764 |
pgstat_info->counts.delta_live_tuples = 0; |
| 765 |
pgstat_info->counts.delta_dead_tuples = 0; |
| 766 |
} |
| 767 |
pgstat_info->counts.delta_live_tuples += |
| 768 |
rec->tuples_inserted - rec->tuples_deleted; |
| 769 |
pgstat_info->counts.delta_dead_tuples += |
| 770 |
rec->tuples_updated + rec->tuples_deleted; |
| 771 |
pgstat_info->counts.changed_tuples += |
| 772 |
rec->tuples_inserted + rec->tuples_updated + |
| 773 |
rec->tuples_deleted; |
| 774 |
} |
| 775 |
|
| 776 |
/* |
| 777 |
* 2PC processing routine for ROLLBACK PREPARED case. |
| 778 |
* |
| 779 |
* Load the saved counts into our local pgstats state, but treat them |
| 780 |
* as aborted. |
| 781 |
*/ |
| 782 |
void |
| 783 |
pgstat_twophase_postabort(TransactionId xid, uint16 info, |
| 784 |
void *recdata, uint32 len) |
| 785 |
{ |
| 786 |
TwoPhasePgStatRecord *rec = (TwoPhasePgStatRecord *) recdata; |
| 787 |
PgStat_TableStatus *pgstat_info; |
| 788 |
|
| 789 |
/* Find or create a tabstat entry for the rel */ |
| 790 |
pgstat_info = pgstat_prep_relation_pending(rec->id, rec->shared); |
| 791 |
|
| 792 |
/* Same math as in AtEOXact_PgStat, abort case */ |
| 793 |
if (rec->truncdropped) |
| 794 |
{ |
| 795 |
rec->tuples_inserted = rec->inserted_pre_truncdrop; |
| 796 |
rec->tuples_updated = rec->updated_pre_truncdrop; |
| 797 |
rec->tuples_deleted = rec->deleted_pre_truncdrop; |
| 798 |
} |
| 799 |
pgstat_info->counts.tuples_inserted += rec->tuples_inserted; |
| 800 |
pgstat_info->counts.tuples_updated += rec->tuples_updated; |
| 801 |
pgstat_info->counts.tuples_deleted += rec->tuples_deleted; |
| 802 |
pgstat_info->counts.delta_dead_tuples += |
| 803 |
rec->tuples_inserted + rec->tuples_updated; |
| 804 |
} |
| 805 |
|
| 806 |
/* |
| 807 |
* Flush out pending stats for the entry |
| 808 |
* |
| 809 |
* If nowait is true and the lock could not be immediately acquired, returns |
| 810 |
* false without flushing the entry. Otherwise returns true. |
| 811 |
* |
| 812 |
* Some of the stats are copied to the corresponding pending database stats |
| 813 |
* entry when successfully flushing. |
| 814 |
*/ |
| 815 |
bool |
| 816 |
pgstat_relation_flush_cb(PgStat_EntryRef *entry_ref, bool nowait) |
| 817 |
{ |
| 818 |
Oid dboid; |
| 819 |
PgStat_TableStatus *lstats; /* pending stats entry */ |
| 820 |
PgStatShared_Relation *shtabstats; |
| 821 |
PgStat_StatTabEntry *tabentry; /* table entry of shared stats */ |
| 822 |
PgStat_StatDBEntry *dbentry; /* pending database entry */ |
| 823 |
|
| 824 |
dboid = entry_ref->shared_entry->key.dboid; |
| 825 |
lstats = (PgStat_TableStatus *) entry_ref->pending; |
| 826 |
shtabstats = (PgStatShared_Relation *) entry_ref->shared_stats; |
| 827 |
|
| 828 |
/* |
| 829 |
* Ignore entries that didn't accumulate any actual counts, such as |
| 830 |
* indexes that were opened by the planner but not used. |
| 831 |
*/ |
| 832 |
if (pg_memory_is_all_zeros(&lstats->counts, |
| 833 |
sizeof(struct PgStat_TableCounts))) |
| 834 |
return true; |
| 835 |
|
| 836 |
if (!pgstat_lock_entry(entry_ref, nowait)) |
| 837 |
return false; |
| 838 |
|
| 839 |
/* add the values to the shared entry. */ |
| 840 |
tabentry = &shtabstats->stats; |
| 841 |
|
| 842 |
tabentry->numscans += lstats->counts.numscans; |
| 843 |
if (lstats->counts.numscans) |
| 844 |
{ |
| 845 |
TimestampTz t = GetCurrentTransactionStopTimestamp(); |
| 846 |
|
| 847 |
if (t > tabentry->lastscan) |
| 848 |
tabentry->lastscan = t; |
| 849 |
} |
| 850 |
tabentry->tuples_returned += lstats->counts.tuples_returned; |
| 851 |
tabentry->tuples_fetched += lstats->counts.tuples_fetched; |
| 852 |
tabentry->tuples_inserted += lstats->counts.tuples_inserted; |
| 853 |
tabentry->tuples_updated += lstats->counts.tuples_updated; |
| 854 |
tabentry->tuples_deleted += lstats->counts.tuples_deleted; |
| 855 |
tabentry->tuples_hot_updated += lstats->counts.tuples_hot_updated; |
| 856 |
tabentry->tuples_newpage_updated += lstats->counts.tuples_newpage_updated; |
| 857 |
|
| 858 |
/* |
| 859 |
* If table was truncated/dropped, first reset the live/dead counters. |
| 860 |
*/ |
| 861 |
if (lstats->counts.truncdropped) |
| 862 |
{ |
| 863 |
tabentry->live_tuples = 0; |
| 864 |
tabentry->dead_tuples = 0; |
| 865 |
tabentry->ins_since_vacuum = 0; |
| 866 |
} |
| 867 |
|
| 868 |
tabentry->live_tuples += lstats->counts.delta_live_tuples; |
| 869 |
tabentry->dead_tuples += lstats->counts.delta_dead_tuples; |
| 870 |
tabentry->mod_since_analyze += lstats->counts.changed_tuples; |
| 871 |
|
| 872 |
/* |
| 873 |
* Using tuples_inserted to update ins_since_vacuum does mean that we'll |
| 874 |
* track aborted inserts too. This isn't ideal, but otherwise probably |
| 875 |
* not worth adding an extra field for. It may just amount to autovacuums |
| 876 |
* triggering for inserts more often than they maybe should, which is |
| 877 |
* probably not going to be common enough to be too concerned about here. |
| 878 |
*/ |
| 879 |
tabentry->ins_since_vacuum += lstats->counts.tuples_inserted; |
| 880 |
|
| 881 |
tabentry->blocks_fetched += lstats->counts.blocks_fetched; |
| 882 |
tabentry->blocks_hit += lstats->counts.blocks_hit; |
| 883 |
|
| 884 |
/* Clamp live_tuples in case of negative delta_live_tuples */ |
| 885 |
tabentry->live_tuples = Max(tabentry->live_tuples, 0); |
| 886 |
/* Likewise for dead_tuples */ |
| 887 |
tabentry->dead_tuples = Max(tabentry->dead_tuples, 0); |
| 888 |
|
| 889 |
pgstat_unlock_entry(entry_ref); |
| 890 |
|
| 891 |
/* The entry was successfully flushed, add the same to database stats */ |
| 892 |
dbentry = pgstat_prep_database_pending(dboid); |
| 893 |
dbentry->tuples_returned += lstats->counts.tuples_returned; |
| 894 |
dbentry->tuples_fetched += lstats->counts.tuples_fetched; |
| 895 |
dbentry->tuples_inserted += lstats->counts.tuples_inserted; |
| 896 |
dbentry->tuples_updated += lstats->counts.tuples_updated; |
| 897 |
dbentry->tuples_deleted += lstats->counts.tuples_deleted; |
| 898 |
dbentry->blocks_fetched += lstats->counts.blocks_fetched; |
| 899 |
dbentry->blocks_hit += lstats->counts.blocks_hit; |
| 900 |
|
| 901 |
return true; |
| 902 |
} |
| 903 |
|
| 904 |
void |
| 905 |
pgstat_relation_delete_pending_cb(PgStat_EntryRef *entry_ref) |
| 906 |
{ |
| 907 |
PgStat_TableStatus *pending = (PgStat_TableStatus *) entry_ref->pending; |
| 908 |
|
| 909 |
if (pending->relation) |
| 910 |
pgstat_unlink_relation(pending->relation); |
| 911 |
} |
| 912 |
|
| 913 |
/* |
| 914 |
* Find or create a PgStat_TableStatus entry for rel. New entry is created and |
| 915 |
* initialized if not exists. |
| 916 |
*/ |
| 917 |
static PgStat_TableStatus * |
| 918 |
pgstat_prep_relation_pending(Oid rel_id, bool isshared) |
| 919 |
{ |
| 920 |
PgStat_EntryRef *entry_ref; |
| 921 |
PgStat_TableStatus *pending; |
| 922 |
|
| 923 |
entry_ref = pgstat_prep_pending_entry(PGSTAT_KIND_RELATION, |
| 924 |
isshared ? InvalidOid : MyDatabaseId, |
| 925 |
rel_id, NULL); |
| 926 |
pending = entry_ref->pending; |
| 927 |
pending->id = rel_id; |
| 928 |
pending->shared = isshared; |
| 929 |
|
| 930 |
return pending; |
| 931 |
} |
| 932 |
|
| 933 |
/* |
| 934 |
* add a new (sub)transaction state record |
| 935 |
*/ |
| 936 |
static void |
| 937 |
add_tabstat_xact_level(PgStat_TableStatus *pgstat_info, int nest_level) |
| 938 |
{ |
| 939 |
PgStat_SubXactStatus *xact_state; |
| 940 |
PgStat_TableXactStatus *trans; |
| 941 |
|
| 942 |
/* |
| 943 |
* If this is the first rel to be modified at the current nest level, we |
| 944 |
* first have to push a transaction stack entry. |
| 945 |
*/ |
| 946 |
xact_state = pgstat_get_xact_stack_level(nest_level); |
| 947 |
|
| 948 |
/* Now make a per-table stack entry */ |
| 949 |
trans = (PgStat_TableXactStatus *) |
| 950 |
MemoryContextAllocZero(TopTransactionContext, |
| 951 |
sizeof(PgStat_TableXactStatus)); |
| 952 |
trans->nest_level = nest_level; |
| 953 |
trans->upper = pgstat_info->trans; |
| 954 |
trans->parent = pgstat_info; |
| 955 |
trans->next = xact_state->first; |
| 956 |
xact_state->first = trans; |
| 957 |
pgstat_info->trans = trans; |
| 958 |
} |
| 959 |
|
| 960 |
/* |
| 961 |
* Add a new (sub)transaction record if needed. |
| 962 |
*/ |
| 963 |
static void |
| 964 |
ensure_tabstat_xact_level(PgStat_TableStatus *pgstat_info) |
| 965 |
{ |
| 966 |
int nest_level = GetCurrentTransactionNestLevel(); |
| 967 |
|
| 968 |
if (pgstat_info->trans == NULL || |
| 969 |
pgstat_info->trans->nest_level != nest_level) |
| 970 |
add_tabstat_xact_level(pgstat_info, nest_level); |
| 971 |
} |
| 972 |
|
| 973 |
/* |
| 974 |
* Whenever a table is truncated/dropped, we save its i/u/d counters so that |
| 975 |
* they can be cleared, and if the (sub)xact that executed the truncate/drop |
| 976 |
* later aborts, the counters can be restored to the saved (pre-truncate/drop) |
| 977 |
* values. |
| 978 |
* |
| 979 |
* Note that for truncate we do this on the first truncate in any particular |
| 980 |
* subxact level only. |
| 981 |
*/ |
| 982 |
static void |
| 983 |
save_truncdrop_counters(PgStat_TableXactStatus *trans, bool is_drop) |
| 984 |
{ |
| 985 |
if (!trans->truncdropped || is_drop) |
| 986 |
{ |
| 987 |
trans->inserted_pre_truncdrop = trans->tuples_inserted; |
| 988 |
trans->updated_pre_truncdrop = trans->tuples_updated; |
| 989 |
trans->deleted_pre_truncdrop = trans->tuples_deleted; |
| 990 |
trans->truncdropped = true; |
| 991 |
} |
| 992 |
} |
| 993 |
|
| 994 |
/* |
| 995 |
* restore counters when a truncate aborts |
| 996 |
*/ |
| 997 |
static void |
| 998 |
restore_truncdrop_counters(PgStat_TableXactStatus *trans) |
| 999 |
{ |
| 1000 |
if (trans->truncdropped) |
| 1001 |
{ |
| 1002 |
trans->tuples_inserted = trans->inserted_pre_truncdrop; |
| 1003 |
trans->tuples_updated = trans->updated_pre_truncdrop; |
| 1004 |
trans->tuples_deleted = trans->deleted_pre_truncdrop; |
| 1005 |
} |
| 1006 |
} |