Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * tid.c
4 : : * Functions for the built-in type tuple id
5 : : *
6 : : * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
7 : : * Portions Copyright (c) 1994, Regents of the University of California
8 : : *
9 : : *
10 : : * IDENTIFICATION
11 : : * src/backend/utils/adt/tid.c
12 : : *
13 : : * NOTES
14 : : * input routine largely stolen from boxin().
15 : : *
16 : : *-------------------------------------------------------------------------
17 : : */
18 : : #include "postgres.h"
19 : :
20 : : #include <limits.h>
21 : :
22 : : #include "access/sysattr.h"
23 : : #include "access/table.h"
24 : : #include "access/tableam.h"
25 : : #include "catalog/namespace.h"
26 : : #include "catalog/pg_type.h"
27 : : #include "common/hashfn.h"
28 : : #include "libpq/pqformat.h"
29 : : #include "miscadmin.h"
30 : : #include "parser/parsetree.h"
31 : : #include "utils/acl.h"
32 : : #include "utils/fmgrprotos.h"
33 : : #include "utils/lsyscache.h"
34 : : #include "utils/rel.h"
35 : : #include "utils/snapmgr.h"
36 : : #include "utils/varlena.h"
37 : :
38 : :
39 : : #define LDELIM '('
40 : : #define RDELIM ')'
41 : : #define DELIM ','
42 : : #define NTIDARGS 2
43 : :
44 : : static ItemPointer currtid_for_view(Relation viewrel, const ItemPointerData *tid);
45 : :
46 : : /* ----------------------------------------------------------------
47 : : * tidin
48 : : * ----------------------------------------------------------------
49 : : */
50 : : Datum
51 : 6154 : tidin(PG_FUNCTION_ARGS)
52 : : {
53 : 6154 : char *str = PG_GETARG_CSTRING(0);
54 : 6154 : Node *escontext = fcinfo->context;
55 : : char *p,
56 : : *coord[NTIDARGS];
57 : : int i;
58 : : ItemPointer result;
59 : : BlockNumber blockNumber;
60 : : OffsetNumber offsetNumber;
61 : : char *badp;
62 : : unsigned long cvt;
63 : :
64 [ + - + + : 30445 : for (i = 0, p = str; *p && i < NTIDARGS && *p != RDELIM; p++)
+ + ]
65 [ + + + + : 24291 : if (*p == DELIM || (*p == LDELIM && i == 0))
+ - ]
66 : 12300 : coord[i++] = p + 1;
67 : :
68 [ + + ]: 6154 : if (i < NTIDARGS)
69 [ + + ]: 8 : ereturn(escontext, (Datum) 0,
70 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
71 : : errmsg("invalid input syntax for type %s: \"%s\"",
72 : : "tid", str)));
73 : :
74 : 6146 : errno = 0;
75 : 6146 : cvt = strtoul(coord[0], &badp, 10);
76 [ + - - + ]: 6146 : if (errno || *badp != DELIM)
77 [ # # ]: 0 : ereturn(escontext, (Datum) 0,
78 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
79 : : errmsg("invalid input syntax for type %s: \"%s\"",
80 : : "tid", str)));
81 : 6146 : blockNumber = (BlockNumber) cvt;
82 : :
83 : : /*
84 : : * Cope with possibility that unsigned long is wider than BlockNumber, in
85 : : * which case strtoul will not raise an error for some values that are out
86 : : * of the range of BlockNumber. (See similar code in uint32in_subr().)
87 : : */
88 : : #if SIZEOF_LONG > 4
89 [ + + ]: 6146 : if (cvt != (unsigned long) blockNumber &&
90 [ + + ]: 12 : cvt != (unsigned long) ((int32) blockNumber))
91 [ + - ]: 4 : ereturn(escontext, (Datum) 0,
92 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
93 : : errmsg("invalid input syntax for type %s: \"%s\"",
94 : : "tid", str)));
95 : : #endif
96 : :
97 : 6142 : cvt = strtoul(coord[1], &badp, 10);
98 [ + - + - : 6142 : if (errno || *badp != RDELIM ||
+ + ]
99 : : cvt > USHRT_MAX)
100 [ + + ]: 12 : ereturn(escontext, (Datum) 0,
101 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
102 : : errmsg("invalid input syntax for type %s: \"%s\"",
103 : : "tid", str)));
104 : 6130 : offsetNumber = (OffsetNumber) cvt;
105 : :
106 : 6130 : result = (ItemPointer) palloc_object(ItemPointerData);
107 : :
108 : 6130 : ItemPointerSet(result, blockNumber, offsetNumber);
109 : :
110 : 6130 : PG_RETURN_ITEMPOINTER(result);
111 : : }
112 : :
113 : : /* ----------------------------------------------------------------
114 : : * tidout
115 : : * ----------------------------------------------------------------
116 : : */
117 : : Datum
118 : 24715 : tidout(PG_FUNCTION_ARGS)
119 : : {
120 : 24715 : ItemPointer itemPtr = PG_GETARG_ITEMPOINTER(0);
121 : : BlockNumber blockNumber;
122 : : OffsetNumber offsetNumber;
123 : : char buf[32];
124 : :
125 : 24715 : blockNumber = ItemPointerGetBlockNumberNoCheck(itemPtr);
126 : 24715 : offsetNumber = ItemPointerGetOffsetNumberNoCheck(itemPtr);
127 : :
128 : : /* Perhaps someday we should output this as a record. */
129 : 24715 : snprintf(buf, sizeof(buf), "(%u,%u)", blockNumber, offsetNumber);
130 : :
131 : 24715 : PG_RETURN_CSTRING(pstrdup(buf));
132 : : }
133 : :
134 : : /*
135 : : * tidrecv - converts external binary format to tid
136 : : */
137 : : Datum
138 : 0 : tidrecv(PG_FUNCTION_ARGS)
139 : : {
140 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
141 : : ItemPointer result;
142 : : BlockNumber blockNumber;
143 : : OffsetNumber offsetNumber;
144 : :
145 : 0 : blockNumber = pq_getmsgint(buf, sizeof(blockNumber));
146 : 0 : offsetNumber = pq_getmsgint(buf, sizeof(offsetNumber));
147 : :
148 : 0 : result = (ItemPointer) palloc_object(ItemPointerData);
149 : :
150 : 0 : ItemPointerSet(result, blockNumber, offsetNumber);
151 : :
152 : 0 : PG_RETURN_ITEMPOINTER(result);
153 : : }
154 : :
155 : : /*
156 : : * tidsend - converts tid to binary format
157 : : */
158 : : Datum
159 : 0 : tidsend(PG_FUNCTION_ARGS)
160 : : {
161 : 0 : ItemPointer itemPtr = PG_GETARG_ITEMPOINTER(0);
162 : : StringInfoData buf;
163 : :
164 : 0 : pq_begintypsend(&buf);
165 : 0 : pq_sendint32(&buf, ItemPointerGetBlockNumberNoCheck(itemPtr));
166 : 0 : pq_sendint16(&buf, ItemPointerGetOffsetNumberNoCheck(itemPtr));
167 : 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
168 : : }
169 : :
170 : : /*****************************************************************************
171 : : * PUBLIC ROUTINES *
172 : : *****************************************************************************/
173 : :
174 : : Datum
175 : 12254593 : tideq(PG_FUNCTION_ARGS)
176 : : {
177 : 12254593 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
178 : 12254593 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
179 : :
180 : 12254593 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) == 0);
181 : : }
182 : :
183 : : Datum
184 : 143 : tidne(PG_FUNCTION_ARGS)
185 : : {
186 : 143 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
187 : 143 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
188 : :
189 : 143 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) != 0);
190 : : }
191 : :
192 : : Datum
193 : 9727 : tidlt(PG_FUNCTION_ARGS)
194 : : {
195 : 9727 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
196 : 9727 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
197 : :
198 : 9727 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) < 0);
199 : : }
200 : :
201 : : Datum
202 : 2532 : tidle(PG_FUNCTION_ARGS)
203 : : {
204 : 2532 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
205 : 2532 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
206 : :
207 : 2532 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) <= 0);
208 : : }
209 : :
210 : : Datum
211 : 3556 : tidgt(PG_FUNCTION_ARGS)
212 : : {
213 : 3556 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
214 : 3556 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
215 : :
216 : 3556 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) > 0);
217 : : }
218 : :
219 : : Datum
220 : 2488 : tidge(PG_FUNCTION_ARGS)
221 : : {
222 : 2488 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
223 : 2488 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
224 : :
225 : 2488 : PG_RETURN_BOOL(ItemPointerCompare(arg1, arg2) >= 0);
226 : : }
227 : :
228 : : Datum
229 : 1962651 : bttidcmp(PG_FUNCTION_ARGS)
230 : : {
231 : 1962651 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
232 : 1962651 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
233 : :
234 : 1962651 : PG_RETURN_INT32(ItemPointerCompare(arg1, arg2));
235 : : }
236 : :
237 : : Datum
238 : 800 : tidlarger(PG_FUNCTION_ARGS)
239 : : {
240 : 800 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
241 : 800 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
242 : :
243 [ - + ]: 800 : PG_RETURN_ITEMPOINTER(ItemPointerCompare(arg1, arg2) >= 0 ? arg1 : arg2);
244 : : }
245 : :
246 : : Datum
247 : 800 : tidsmaller(PG_FUNCTION_ARGS)
248 : : {
249 : 800 : ItemPointer arg1 = PG_GETARG_ITEMPOINTER(0);
250 : 800 : ItemPointer arg2 = PG_GETARG_ITEMPOINTER(1);
251 : :
252 [ + - ]: 800 : PG_RETURN_ITEMPOINTER(ItemPointerCompare(arg1, arg2) <= 0 ? arg1 : arg2);
253 : : }
254 : :
255 : : Datum
256 : 84048 : hashtid(PG_FUNCTION_ARGS)
257 : : {
258 : 84048 : ItemPointer key = PG_GETARG_ITEMPOINTER(0);
259 : :
260 : : /*
261 : : * While you'll probably have a lot of trouble with a compiler that
262 : : * insists on appending pad space to struct ItemPointerData, we can at
263 : : * least make this code work, by not using sizeof(ItemPointerData).
264 : : * Instead rely on knowing the sizes of the component fields.
265 : : */
266 : 84048 : return hash_any((unsigned char *) key,
267 : : sizeof(BlockIdData) + sizeof(OffsetNumber));
268 : : }
269 : :
270 : : Datum
271 : 0 : hashtidextended(PG_FUNCTION_ARGS)
272 : : {
273 : 0 : ItemPointer key = PG_GETARG_ITEMPOINTER(0);
274 : 0 : uint64 seed = PG_GETARG_INT64(1);
275 : :
276 : : /* As above */
277 : 0 : return hash_any_extended((unsigned char *) key,
278 : : sizeof(BlockIdData) + sizeof(OffsetNumber),
279 : : seed);
280 : : }
281 : :
282 : : /*
283 : : * Extract the block number from a TID
284 : : *
285 : : * Returns int8 because BlockNumber is uint32, which exceeds the range of int4.
286 : : */
287 : : Datum
288 : 65 : tid_block(PG_FUNCTION_ARGS)
289 : : {
290 : 65 : ItemPointer tid = PG_GETARG_ITEMPOINTER(0);
291 : :
292 : : /* need to use NoCheck, as tidin allows InvalidBlockNumber */
293 : 65 : PG_RETURN_INT64((int64) ItemPointerGetBlockNumberNoCheck(tid));
294 : : }
295 : :
296 : : /*
297 : : * Extract the offset number from a TID
298 : : *
299 : : * Returns int4 because OffsetNumber is uint16, which exceeds the range of
300 : : * int2.
301 : : */
302 : : Datum
303 : 60 : tid_offset(PG_FUNCTION_ARGS)
304 : : {
305 : 60 : ItemPointer tid = PG_GETARG_ITEMPOINTER(0);
306 : :
307 : : /* need to use NoCheck, as tidin allows InvalidOffsetNumber */
308 : 60 : PG_RETURN_INT32((int32) ItemPointerGetOffsetNumberNoCheck(tid));
309 : : }
310 : :
311 : :
312 : : /*
313 : : * Functions to get latest tid of a specified tuple.
314 : : *
315 : : * Maybe these implementations should be moved to another place
316 : : */
317 : :
318 : : /*
319 : : * Utility wrapper for current CTID functions.
320 : : * Returns the latest version of a tuple pointing at "tid" for
321 : : * relation "rel".
322 : : */
323 : : static ItemPointer
324 : 40 : currtid_internal(Relation rel, const ItemPointerData *tid)
325 : : {
326 : : ItemPointer result;
327 : : AclResult aclresult;
328 : : Snapshot snapshot;
329 : : TableScanDesc scan;
330 : :
331 : 40 : result = (ItemPointer) palloc_object(ItemPointerData);
332 : :
333 : 40 : aclresult = pg_class_aclcheck(RelationGetRelid(rel), GetUserId(),
334 : : ACL_SELECT);
335 [ - + ]: 40 : if (aclresult != ACLCHECK_OK)
336 : 0 : aclcheck_error(aclresult, get_relkind_objtype(rel->rd_rel->relkind),
337 : 0 : RelationGetRelationName(rel));
338 : :
339 [ + + ]: 40 : if (rel->rd_rel->relkind == RELKIND_VIEW)
340 : 16 : return currtid_for_view(rel, tid);
341 : :
342 [ + + + - : 24 : if (!RELKIND_HAS_STORAGE(rel->rd_rel->relkind))
+ + + - +
+ ]
343 [ + - ]: 4 : ereport(ERROR,
344 : : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
345 : : errmsg("cannot look at latest visible tid for relation \"%s.%s\"",
346 : : get_namespace_name(RelationGetNamespace(rel)),
347 : : RelationGetRelationName(rel)));
348 : :
349 : 20 : ItemPointerCopy(tid, result);
350 : :
351 : 20 : snapshot = RegisterSnapshot(GetLatestSnapshot());
352 : 20 : scan = table_beginscan_tid(rel, snapshot);
353 : 20 : table_tuple_get_latest_tid(scan, result);
354 : 12 : table_endscan(scan);
355 : 12 : UnregisterSnapshot(snapshot);
356 : :
357 : 12 : return result;
358 : : }
359 : :
360 : : /*
361 : : * Handle CTIDs of views.
362 : : * CTID should be defined in the view and it must
363 : : * correspond to the CTID of a base relation.
364 : : */
365 : : static ItemPointer
366 : 16 : currtid_for_view(Relation viewrel, const ItemPointerData *tid)
367 : : {
368 : 16 : TupleDesc att = RelationGetDescr(viewrel);
369 : : RuleLock *rulelock;
370 : : RewriteRule *rewrite;
371 : : int i,
372 : 16 : natts = att->natts,
373 : 16 : tididx = -1;
374 : :
375 [ + + ]: 20 : for (i = 0; i < natts; i++)
376 : : {
377 : 16 : Form_pg_attribute attr = TupleDescAttr(att, i);
378 : :
379 [ + + ]: 16 : if (strcmp(NameStr(attr->attname), "ctid") == 0)
380 : : {
381 [ + + ]: 12 : if (attr->atttypid != TIDOID)
382 [ + - ]: 4 : ereport(ERROR,
383 : : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
384 : : errmsg("ctid isn't of type TID"));
385 : 8 : tididx = i;
386 : 8 : break;
387 : : }
388 : : }
389 [ + + ]: 12 : if (tididx < 0)
390 [ + - ]: 4 : ereport(ERROR,
391 : : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
392 : : errmsg("currtid cannot handle views with no CTID"));
393 : 8 : rulelock = viewrel->rd_rules;
394 [ - + ]: 8 : if (!rulelock)
395 [ # # ]: 0 : ereport(ERROR,
396 : : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
397 : : errmsg("the view has no rules"));
398 [ + - ]: 8 : for (i = 0; i < rulelock->numLocks; i++)
399 : : {
400 : 8 : rewrite = rulelock->rules[i];
401 [ + - ]: 8 : if (rewrite->event == CMD_SELECT)
402 : : {
403 : : Query *query;
404 : : TargetEntry *tle;
405 : :
406 [ - + ]: 8 : if (list_length(rewrite->actions) != 1)
407 [ # # ]: 0 : ereport(ERROR,
408 : : errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
409 : : errmsg("only one select rule is allowed in views"));
410 : 8 : query = (Query *) linitial(rewrite->actions);
411 : 8 : tle = get_tle_by_resno(query->targetList, tididx + 1);
412 [ + - + - : 8 : if (tle && tle->expr && IsA(tle->expr, Var))
+ - ]
413 : : {
414 : 8 : Var *var = (Var *) tle->expr;
415 : : RangeTblEntry *rte;
416 : :
417 [ + - ]: 8 : if (!IS_SPECIAL_VARNO(var->varno) &&
418 [ + - ]: 8 : var->varattno == SelfItemPointerAttributeNumber)
419 : : {
420 : 8 : rte = rt_fetch(var->varno, query->rtable);
421 [ + - ]: 8 : if (rte)
422 : : {
423 : : ItemPointer result;
424 : : Relation rel;
425 : :
426 : 8 : rel = table_open(rte->relid, AccessShareLock);
427 : 8 : result = currtid_internal(rel, tid);
428 : 4 : table_close(rel, AccessShareLock);
429 : 4 : return result;
430 : : }
431 : : }
432 : : }
433 : 0 : break;
434 : : }
435 : : }
436 [ # # ]: 0 : elog(ERROR, "currtid cannot handle this view");
437 : : return NULL;
438 : : }
439 : :
440 : : /*
441 : : * currtid_byrelname
442 : : * Get the latest tuple version of the tuple pointing at a CTID, for a
443 : : * given relation name.
444 : : */
445 : : Datum
446 : 36 : currtid_byrelname(PG_FUNCTION_ARGS)
447 : : {
448 : 36 : text *relname = PG_GETARG_TEXT_PP(0);
449 : 36 : ItemPointer tid = PG_GETARG_ITEMPOINTER(1);
450 : : ItemPointer result;
451 : : RangeVar *relrv;
452 : : Relation rel;
453 : :
454 : 36 : relrv = makeRangeVarFromNameList(textToQualifiedNameList(relname));
455 : 36 : rel = table_openrv(relrv, AccessShareLock);
456 : :
457 : : /* grab the latest tuple version associated to this CTID */
458 : 32 : result = currtid_internal(rel, tid);
459 : :
460 : 12 : table_close(rel, AccessShareLock);
461 : :
462 : 12 : PG_RETURN_ITEMPOINTER(result);
463 : : }
|
