Age Owner Branch data TLA Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * oid.c
4 : : * Functions for the built-in type Oid ... also oidvector.
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/oid.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : : #include "postgres.h"
16 : :
17 : : #include <ctype.h>
18 : : #include <limits.h>
19 : :
20 : : #include "catalog/pg_type.h"
21 : : #include "common/int.h"
22 : : #include "libpq/pqformat.h"
23 : : #include "nodes/miscnodes.h"
24 : : #include "nodes/value.h"
25 : : #include "utils/array.h"
26 : : #include "utils/builtins.h"
27 : :
28 : :
29 : : #define OidVectorSize(n) (offsetof(oidvector, values) + (n) * sizeof(Oid))
30 : :
31 : :
32 : : /*****************************************************************************
33 : : * USER I/O ROUTINES *
34 : : *****************************************************************************/
35 : :
36 : : Datum
9214 tgl@sss.pgh.pa.us 37 :CBC 3085958 : oidin(PG_FUNCTION_ARGS)
38 : : {
39 : 3085958 : char *s = PG_GETARG_CSTRING(0);
40 : : Oid result;
41 : :
1174 42 : 3085958 : result = uint32in_subr(s, NULL, "oid", fcinfo->context);
9214 43 : 3085928 : PG_RETURN_OID(result);
44 : : }
45 : :
46 : : Datum
47 : 11771055 : oidout(PG_FUNCTION_ARGS)
48 : : {
49 : 11771055 : Oid o = PG_GETARG_OID(0);
50 : 11771055 : char *result = (char *) palloc(12);
51 : :
52 : 11771055 : snprintf(result, 12, "%u", o);
53 : 11771055 : PG_RETURN_CSTRING(result);
54 : : }
55 : :
56 : : /*
57 : : * oidrecv - converts external binary format to oid
58 : : */
59 : : Datum
8346 60 : 106 : oidrecv(PG_FUNCTION_ARGS)
61 : : {
62 : 106 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
63 : :
64 : 106 : PG_RETURN_OID((Oid) pq_getmsgint(buf, sizeof(Oid)));
65 : : }
66 : :
67 : : /*
68 : : * oidsend - converts oid to binary format
69 : : */
70 : : Datum
71 : 7 : oidsend(PG_FUNCTION_ARGS)
72 : : {
73 : 7 : Oid arg1 = PG_GETARG_OID(0);
74 : : StringInfoData buf;
75 : :
76 : 7 : pq_begintypsend(&buf);
3077 andres@anarazel.de 77 : 7 : pq_sendint32(&buf, arg1);
8346 tgl@sss.pgh.pa.us 78 : 7 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
79 : : }
80 : :
81 : : /*
82 : : * construct oidvector given a raw array of Oids
83 : : *
84 : : * If oids is NULL then caller must fill values[] afterward
85 : : */
86 : : oidvector *
7656 87 : 67481 : buildoidvector(const Oid *oids, int n)
88 : : {
89 : : oidvector *result;
90 : :
91 : 67481 : result = (oidvector *) palloc0(OidVectorSize(n));
92 : :
93 [ + + + - ]: 67481 : if (n > 0 && oids)
94 : 64956 : memcpy(result->values, oids, n * sizeof(Oid));
95 : :
96 : : /*
97 : : * Attach standard array header. For historical reasons, we set the index
98 : : * lower bound to 0 not 1.
99 : : */
6956 100 : 67481 : SET_VARSIZE(result, OidVectorSize(n));
7656 101 : 67481 : result->ndim = 1;
7423 102 : 67481 : result->dataoffset = 0; /* never any nulls */
7656 103 : 67481 : result->elemtype = OIDOID;
104 : 67481 : result->dim1 = n;
105 : 67481 : result->lbound1 = 0;
106 : :
107 : 67481 : return result;
108 : : }
109 : :
110 : : /*
111 : : * validate that an array object meets the restrictions of oidvector
112 : : *
113 : : * We need this because there are pathways by which a general oid[] array can
114 : : * be cast to oidvector, allowing the type's restrictions to be violated.
115 : : * All code that receives an oidvector as a SQL parameter should check this.
116 : : */
117 : : void
34 118 : 8663031 : check_valid_oidvector(const oidvector *oidArray)
119 : : {
120 : : /*
121 : : * We insist on ndim == 1 and dataoffset == 0 (that is, no nulls) because
122 : : * otherwise the array's layout will not be what calling code expects. We
123 : : * needn't be picky about the index lower bound though. Checking elemtype
124 : : * is just paranoia.
125 : : */
126 [ + + ]: 8663031 : if (oidArray->ndim != 1 ||
127 [ + - ]: 8663028 : oidArray->dataoffset != 0 ||
128 [ - + ]: 8663028 : oidArray->elemtype != OIDOID)
129 [ + - ]: 3 : ereport(ERROR,
130 : : (errcode(ERRCODE_DATATYPE_MISMATCH),
131 : : errmsg("array is not a valid oidvector")));
132 : 8663028 : }
133 : :
134 : : /*
135 : : * oidvectorin - converts "num num ..." to internal form
136 : : */
137 : : Datum
9414 138 : 175371 : oidvectorin(PG_FUNCTION_ARGS)
139 : : {
140 : 175371 : char *oidString = PG_GETARG_CSTRING(0);
1187 141 : 175371 : Node *escontext = fcinfo->context;
142 : : oidvector *result;
143 : : int nalloc;
144 : : int n;
145 : :
1155 146 : 175371 : nalloc = 32; /* arbitrary initial size guess */
147 : 175371 : result = (oidvector *) palloc0(OidVectorSize(nalloc));
148 : :
149 : 175371 : for (n = 0;; n++)
150 : : {
9233 151 [ + + + + ]: 646275 : while (*oidString && isspace((unsigned char) *oidString))
9561 bruce@momjian.us 152 : 152163 : oidString++;
9214 tgl@sss.pgh.pa.us 153 [ + + ]: 494112 : if (*oidString == '\0')
154 : 175359 : break;
155 : :
1155 156 [ - + ]: 318753 : if (n >= nalloc)
157 : : {
1155 tgl@sss.pgh.pa.us 158 :UBC 0 : nalloc *= 2;
159 : 0 : result = (oidvector *) repalloc(result, OidVectorSize(nalloc));
160 : : }
161 : :
1174 tgl@sss.pgh.pa.us 162 :CBC 318753 : result->values[n] = uint32in_subr(oidString, &oidString,
163 : : "oid", escontext);
1187 164 [ + + + - : 318753 : if (SOFT_ERROR_OCCURRED(escontext))
+ + ]
165 : 12 : PG_RETURN_NULL();
166 : : }
167 : :
6956 168 : 175359 : SET_VARSIZE(result, OidVectorSize(n));
7656 169 : 175359 : result->ndim = 1;
7423 170 : 175359 : result->dataoffset = 0; /* never any nulls */
7656 171 : 175359 : result->elemtype = OIDOID;
172 : 175359 : result->dim1 = n;
173 : 175359 : result->lbound1 = 0;
174 : :
9414 175 : 175359 : PG_RETURN_POINTER(result);
176 : : }
177 : :
178 : : /*
179 : : * oidvectorout - converts internal form to "num num ..."
180 : : */
181 : : Datum
182 : 21604 : oidvectorout(PG_FUNCTION_ARGS)
183 : : {
7656 184 : 21604 : oidvector *oidArray = (oidvector *) PG_GETARG_POINTER(0);
185 : : int num,
186 : : nnums;
187 : : char *rp;
188 : : char *result;
189 : :
190 : : /* validate input before fetching dim1 */
34 191 : 21604 : check_valid_oidvector(oidArray);
192 : 21601 : nnums = oidArray->dim1;
193 : :
194 : : /* assumes sign, 10 digits, ' ' */
7656 195 : 21601 : rp = result = (char *) palloc(nnums * 12 + 1);
196 [ + + ]: 57331 : for (num = 0; num < nnums; num++)
197 : : {
9561 bruce@momjian.us 198 [ + + ]: 35730 : if (num != 0)
199 : 16025 : *rp++ = ' ';
7656 tgl@sss.pgh.pa.us 200 : 35730 : sprintf(rp, "%u", oidArray->values[num]);
10416 bruce@momjian.us 201 [ + + ]: 100795 : while (*++rp != '\0')
202 : : ;
203 : : }
9561 204 : 21601 : *rp = '\0';
9414 tgl@sss.pgh.pa.us 205 : 21601 : PG_RETURN_CSTRING(result);
206 : : }
207 : :
208 : : /*
209 : : * oidvectorrecv - converts external binary format to oidvector
210 : : */
211 : : Datum
8346 tgl@sss.pgh.pa.us 212 :UBC 0 : oidvectorrecv(PG_FUNCTION_ARGS)
213 : : {
2605 andres@anarazel.de 214 : 0 : LOCAL_FCINFO(locfcinfo, 3);
8346 tgl@sss.pgh.pa.us 215 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
216 : : oidvector *result;
217 : :
218 : : /*
219 : : * Normally one would call array_recv() using DirectFunctionCall3, but
220 : : * that does not work since array_recv wants to cache some data using
221 : : * fcinfo->flinfo->fn_extra. So we need to pass it our own flinfo
222 : : * parameter.
223 : : */
2605 andres@anarazel.de 224 : 0 : InitFunctionCallInfoData(*locfcinfo, fcinfo->flinfo, 3,
225 : : InvalidOid, NULL, NULL);
226 : :
227 : 0 : locfcinfo->args[0].value = PointerGetDatum(buf);
228 : 0 : locfcinfo->args[0].isnull = false;
229 : 0 : locfcinfo->args[1].value = ObjectIdGetDatum(OIDOID);
230 : 0 : locfcinfo->args[1].isnull = false;
231 : 0 : locfcinfo->args[2].value = Int32GetDatum(-1);
232 : 0 : locfcinfo->args[2].isnull = false;
233 : :
234 : 0 : result = (oidvector *) DatumGetPointer(array_recv(locfcinfo));
235 : :
236 [ # # ]: 0 : Assert(!locfcinfo->isnull);
237 : :
238 : : /* sanity checks: oidvector must be 1-D, 0-based, no nulls */
7423 tgl@sss.pgh.pa.us 239 [ # # ]: 0 : if (ARR_NDIM(result) != 1 ||
240 [ # # ]: 0 : ARR_HASNULL(result) ||
6036 heikki.linnakangas@i 241 [ # # ]: 0 : ARR_ELEMTYPE(result) != OIDOID ||
242 [ # # ]: 0 : ARR_LBOUND(result)[0] != 0)
7656 tgl@sss.pgh.pa.us 243 [ # # ]: 0 : ereport(ERROR,
244 : : (errcode(ERRCODE_INVALID_BINARY_REPRESENTATION),
245 : : errmsg("invalid oidvector data")));
246 : :
8346 247 : 0 : PG_RETURN_POINTER(result);
248 : : }
249 : :
250 : : /*
251 : : * oidvectorsend - converts oidvector to binary format
252 : : */
253 : : Datum
254 : 0 : oidvectorsend(PG_FUNCTION_ARGS)
255 : : {
256 : : /* We don't do check_valid_oidvector, since array_send won't care */
7656 257 : 0 : return array_send(fcinfo);
258 : : }
259 : :
260 : : /*
261 : : * oidparse - get OID from ICONST/FCONST node
262 : : */
263 : : Oid
5754 rhaas@postgresql.org 264 :CBC 96 : oidparse(Node *node)
265 : : {
266 [ + + - ]: 96 : switch (nodeTag(node))
267 : : {
268 : 90 : case T_Integer:
269 : 90 : return intVal(node);
270 : 6 : case T_Float:
271 : :
272 : : /*
273 : : * Values too large for int4 will be represented as Float
274 : : * constants by the lexer. Accept these if they are valid OID
275 : : * strings.
276 : : */
1174 tgl@sss.pgh.pa.us 277 : 6 : return uint32in_subr(castNode(Float, node)->fval, NULL,
278 : : "oid", NULL);
5754 rhaas@postgresql.org 279 :UBC 0 : default:
280 [ # # ]: 0 : elog(ERROR, "unrecognized node type: %d", (int) nodeTag(node));
281 : : }
282 : : return InvalidOid; /* keep compiler quiet */
283 : : }
284 : :
285 : : /* qsort comparison function for Oids */
286 : : int
3301 peter_e@gmx.net 287 :CBC 209892 : oid_cmp(const void *p1, const void *p2)
288 : : {
289 : 209892 : Oid v1 = *((const Oid *) p1);
290 : 209892 : Oid v2 = *((const Oid *) p2);
291 : :
758 nathan@postgresql.or 292 : 209892 : return pg_cmp_u32(v1, v2);
293 : : }
294 : :
295 : :
296 : : /*****************************************************************************
297 : : * PUBLIC ROUTINES *
298 : : *****************************************************************************/
299 : :
300 : : Datum
9414 tgl@sss.pgh.pa.us 301 : 68483208 : oideq(PG_FUNCTION_ARGS)
302 : : {
303 : 68483208 : Oid arg1 = PG_GETARG_OID(0);
304 : 68483208 : Oid arg2 = PG_GETARG_OID(1);
305 : :
306 : 68483208 : PG_RETURN_BOOL(arg1 == arg2);
307 : : }
308 : :
309 : : Datum
310 : 1685604 : oidne(PG_FUNCTION_ARGS)
311 : : {
312 : 1685604 : Oid arg1 = PG_GETARG_OID(0);
313 : 1685604 : Oid arg2 = PG_GETARG_OID(1);
314 : :
315 : 1685604 : PG_RETURN_BOOL(arg1 != arg2);
316 : : }
317 : :
318 : : Datum
9245 319 : 3460874 : oidlt(PG_FUNCTION_ARGS)
320 : : {
321 : 3460874 : Oid arg1 = PG_GETARG_OID(0);
322 : 3460874 : Oid arg2 = PG_GETARG_OID(1);
323 : :
324 : 3460874 : PG_RETURN_BOOL(arg1 < arg2);
325 : : }
326 : :
327 : : Datum
328 : 1207007 : oidle(PG_FUNCTION_ARGS)
329 : : {
330 : 1207007 : Oid arg1 = PG_GETARG_OID(0);
331 : 1207007 : Oid arg2 = PG_GETARG_OID(1);
332 : :
333 : 1207007 : PG_RETURN_BOOL(arg1 <= arg2);
334 : : }
335 : :
336 : : Datum
337 : 45632 : oidge(PG_FUNCTION_ARGS)
338 : : {
339 : 45632 : Oid arg1 = PG_GETARG_OID(0);
340 : 45632 : Oid arg2 = PG_GETARG_OID(1);
341 : :
342 : 45632 : PG_RETURN_BOOL(arg1 >= arg2);
343 : : }
344 : :
345 : : Datum
346 : 190054 : oidgt(PG_FUNCTION_ARGS)
347 : : {
348 : 190054 : Oid arg1 = PG_GETARG_OID(0);
349 : 190054 : Oid arg2 = PG_GETARG_OID(1);
350 : :
351 : 190054 : PG_RETURN_BOOL(arg1 > arg2);
352 : : }
353 : :
354 : : Datum
8979 tgl@sss.pgh.pa.us 355 :UBC 0 : oidlarger(PG_FUNCTION_ARGS)
356 : : {
357 : 0 : Oid arg1 = PG_GETARG_OID(0);
358 : 0 : Oid arg2 = PG_GETARG_OID(1);
359 : :
360 : 0 : PG_RETURN_OID((arg1 > arg2) ? arg1 : arg2);
361 : : }
362 : :
363 : : Datum
364 : 0 : oidsmaller(PG_FUNCTION_ARGS)
365 : : {
366 : 0 : Oid arg1 = PG_GETARG_OID(0);
367 : 0 : Oid arg2 = PG_GETARG_OID(1);
368 : :
369 : 0 : PG_RETURN_OID((arg1 < arg2) ? arg1 : arg2);
370 : : }
371 : :
372 : : Datum
9414 tgl@sss.pgh.pa.us 373 :CBC 17076 : oidvectoreq(PG_FUNCTION_ARGS)
374 : : {
7656 375 : 17076 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
376 : :
377 : 17076 : PG_RETURN_BOOL(cmp == 0);
378 : : }
379 : :
380 : : Datum
9414 381 : 11234 : oidvectorne(PG_FUNCTION_ARGS)
382 : : {
7656 383 : 11234 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
384 : :
385 : 11234 : PG_RETURN_BOOL(cmp != 0);
386 : : }
387 : :
388 : : Datum
9414 389 : 1842 : oidvectorlt(PG_FUNCTION_ARGS)
390 : : {
7656 391 : 1842 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
392 : :
393 : 1842 : PG_RETURN_BOOL(cmp < 0);
394 : : }
395 : :
396 : : Datum
9414 397 : 636 : oidvectorle(PG_FUNCTION_ARGS)
398 : : {
7656 399 : 636 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
400 : :
401 : 636 : PG_RETURN_BOOL(cmp <= 0);
402 : : }
403 : :
404 : : Datum
9414 tgl@sss.pgh.pa.us 405 :UBC 0 : oidvectorge(PG_FUNCTION_ARGS)
406 : : {
7656 407 : 0 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
408 : :
409 : 0 : PG_RETURN_BOOL(cmp >= 0);
410 : : }
411 : :
412 : : Datum
9414 413 : 0 : oidvectorgt(PG_FUNCTION_ARGS)
414 : : {
7656 415 : 0 : int32 cmp = DatumGetInt32(btoidvectorcmp(fcinfo));
416 : :
417 : 0 : PG_RETURN_BOOL(cmp > 0);
418 : : }
|
