Debian Codegraph @

src/backend/utils/adt/domains.c

raw
1 /*-------------------------------------------------------------------------
2 *
3 * domains.c
4 * I/O functions for domain types.
5 *
6 * The output functions for a domain type are just the same ones provided
7 * by its underlying base type. The input functions, however, must be
8 * prepared to apply any constraints defined by the type. So, we create
9 * special input functions that invoke the base type's input function
10 * and then check the constraints.
11 *
12 * The overhead required for constraint checking can be high, since examining
13 * the catalogs to discover the constraints for a given domain is not cheap.
14 * We have three mechanisms for minimizing this cost:
15 * 1. We rely on the typcache to keep up-to-date copies of the constraints.
16 * 2. In a nest of domains, we flatten the checking of all the levels
17 * into just one operation (the typcache does this for us).
18 * 3. If there are CHECK constraints, we cache a standalone ExprContext
19 * to evaluate them in.
20 *
21 *
22 * Portions Copyright (c) 1996-2025, PostgreSQL Global Development Group
23 * Portions Copyright (c) 1994, Regents of the University of California
24 *
25 *
26 * IDENTIFICATION
27 * src/backend/utils/adt/domains.c
28 *
29 *-------------------------------------------------------------------------
30 */
31 #include "postgres.h"
32
33 #include "access/htup_details.h"
34 #include "catalog/pg_type.h"
35 #include "executor/executor.h"
36 #include "lib/stringinfo.h"
37 #include "utils/builtins.h"
38 #include "utils/expandeddatum.h"
39 #include "utils/lsyscache.h"
40 #include "utils/syscache.h"
41 #include "utils/typcache.h"
42
43 static bool domain_check_internal(Datum value, bool isnull, Oid domainType,
44 void **extra, MemoryContext mcxt,
45 Node *escontext);
46
47 /*
48 * structure to cache state across multiple calls
49 */
50 typedef struct DomainIOData
51 {
52 Oid domain_type;
53 /* Data needed to call base type's input function */
54 Oid typiofunc;
55 Oid typioparam;
56 int32 typtypmod;
57 FmgrInfo proc;
58 /* Reference to cached list of constraint items to check */
59 DomainConstraintRef constraint_ref;
60 /* Context for evaluating CHECK constraints in */
61 ExprContext *econtext;
62 /* Memory context this cache is in */
63 MemoryContext mcxt;
64 } DomainIOData;
65
66
67 /*
68 * domain_state_setup - initialize the cache for a new domain type.
69 *
70 * Note: we can't re-use the same cache struct for a new domain type,
71 * since there's no provision for releasing the DomainConstraintRef.
72 * If a call site needs to deal with a new domain type, we just leak
73 * the old struct for the duration of the query.
74 */
75 static DomainIOData *
76 domain_state_setup(Oid domainType, bool binary, MemoryContext mcxt)
77 {
78 DomainIOData *my_extra;
79 TypeCacheEntry *typentry;
80 Oid baseType;
81
82 my_extra = (DomainIOData *) MemoryContextAlloc(mcxt, sizeof(DomainIOData));
83
84 /*
85 * Verify that domainType represents a valid domain type. We need to be
86 * careful here because domain_in and domain_recv can be called from SQL,
87 * possibly with incorrect arguments. We use lookup_type_cache mainly
88 * because it will throw a clean user-facing error for a bad OID; but also
89 * it can cache the underlying base type info.
90 */
91 typentry = lookup_type_cache(domainType, TYPECACHE_DOMAIN_BASE_INFO);
92 if (typentry->typtype != TYPTYPE_DOMAIN)
93 ereport(ERROR,
94 (errcode(ERRCODE_DATATYPE_MISMATCH),
95 errmsg("type %s is not a domain",
96 format_type_be(domainType))));
97
98 /* Find out the base type */
99 baseType = typentry->domainBaseType;
100 my_extra->typtypmod = typentry->domainBaseTypmod;
101
102 /* Look up underlying I/O function */
103 if (binary)
104 getTypeBinaryInputInfo(baseType,
105 &my_extra->typiofunc,
106 &my_extra->typioparam);
107 else
108 getTypeInputInfo(baseType,
109 &my_extra->typiofunc,
110 &my_extra->typioparam);
111 fmgr_info_cxt(my_extra->typiofunc, &my_extra->proc, mcxt);
112
113 /* Look up constraints for domain */
114 InitDomainConstraintRef(domainType, &my_extra->constraint_ref, mcxt, true);
115
116 /* We don't make an ExprContext until needed */
117 my_extra->econtext = NULL;
118 my_extra->mcxt = mcxt;
119
120 /* Mark cache valid */
121 my_extra->domain_type = domainType;
122
123 return my_extra;
124 }
125
126 /*
127 * domain_check_input - apply the cached checks.
128 *
129 * This is roughly similar to the handling of CoerceToDomain nodes in
130 * execExpr*.c, but we execute each constraint separately, rather than
131 * compiling them in-line within a larger expression.
132 *
133 * If escontext points to an ErrorSaveContext, any failures are reported
134 * there, otherwise they are ereport'ed. Note that we do not attempt to do
135 * soft reporting of errors raised during execution of CHECK constraints.
136 */
137 static void
138 domain_check_input(Datum value, bool isnull, DomainIOData *my_extra,
139 Node *escontext)
140 {
141 ExprContext *econtext = my_extra->econtext;
142 ListCell *l;
143
144 /* Make sure we have up-to-date constraints */
145 UpdateDomainConstraintRef(&my_extra->constraint_ref);
146
147 foreach(l, my_extra->constraint_ref.constraints)
148 {
149 DomainConstraintState *con = (DomainConstraintState *) lfirst(l);
150
151 switch (con->constrainttype)
152 {
153 case DOM_CONSTRAINT_NOTNULL:
154 if (isnull)
155 {
156 errsave(escontext,
157 (errcode(ERRCODE_NOT_NULL_VIOLATION),
158 errmsg("domain %s does not allow null values",
159 format_type_be(my_extra->domain_type)),
160 errdatatype(my_extra->domain_type)));
161 goto fail;
162 }
163 break;
164 case DOM_CONSTRAINT_CHECK:
165 {
166 /* Make the econtext if we didn't already */
167 if (econtext == NULL)
168 {
169 MemoryContext oldcontext;
170
171 oldcontext = MemoryContextSwitchTo(my_extra->mcxt);
172 econtext = CreateStandaloneExprContext();
173 MemoryContextSwitchTo(oldcontext);
174 my_extra->econtext = econtext;
175 }
176
177 /*
178 * Set up value to be returned by CoerceToDomainValue
179 * nodes. Unlike in the generic expression case, this
180 * econtext couldn't be shared with anything else, so no
181 * need to save and restore fields. But we do need to
182 * protect the passed-in value against being changed by
183 * called functions. (It couldn't be a R/W expanded
184 * object for most uses, but that seems possible for
185 * domain_check().)
186 */
187 econtext->domainValue_datum =
188 MakeExpandedObjectReadOnly(value, isnull,
189 my_extra->constraint_ref.tcache->typlen);
190 econtext->domainValue_isNull = isnull;
191
192 if (!ExecCheck(con->check_exprstate, econtext))
193 {
194 errsave(escontext,
195 (errcode(ERRCODE_CHECK_VIOLATION),
196 errmsg("value for domain %s violates check constraint \"%s\"",
197 format_type_be(my_extra->domain_type),
198 con->name),
199 errdomainconstraint(my_extra->domain_type,
200 con->name)));
201 goto fail;
202 }
203 break;
204 }
205 default:
206 elog(ERROR, "unrecognized constraint type: %d",
207 (int) con->constrainttype);
208 break;
209 }
210 }
211
212 /*
213 * Before exiting, call any shutdown callbacks and reset econtext's
214 * per-tuple memory. This avoids leaking non-memory resources, if
215 * anything in the expression(s) has any.
216 */
217 fail:
218 if (econtext)
219 ReScanExprContext(econtext);
220 }
221
222
223 /*
224 * domain_in - input routine for any domain type.
225 */
226 Datum
227 domain_in(PG_FUNCTION_ARGS)
228 {
229 char *string;
230 Oid domainType;
231 Node *escontext = fcinfo->context;
232 DomainIOData *my_extra;
233 Datum value;
234
235 /*
236 * Since domain_in is not strict, we have to check for null inputs. The
237 * typioparam argument should never be null in normal system usage, but it
238 * could be null in a manual invocation --- if so, just return null.
239 */
240 if (PG_ARGISNULL(0))
241 string = NULL;
242 else
243 string = PG_GETARG_CSTRING(0);
244 if (PG_ARGISNULL(1))
245 PG_RETURN_NULL();
246 domainType = PG_GETARG_OID(1);
247
248 /*
249 * We arrange to look up the needed info just once per series of calls,
250 * assuming the domain type doesn't change underneath us (which really
251 * shouldn't happen, but cope if it does).
252 */
253 my_extra = (DomainIOData *) fcinfo->flinfo->fn_extra;
254 if (my_extra == NULL || my_extra->domain_type != domainType)
255 {
256 my_extra = domain_state_setup(domainType, false,
257 fcinfo->flinfo->fn_mcxt);
258 fcinfo->flinfo->fn_extra = my_extra;
259 }
260
261 /*
262 * Invoke the base type's typinput procedure to convert the data.
263 */
264 if (!InputFunctionCallSafe(&my_extra->proc,
265 string,
266 my_extra->typioparam,
267 my_extra->typtypmod,
268 escontext,
269 &value))
270 PG_RETURN_NULL();
271
272 /*
273 * Do the necessary checks to ensure it's a valid domain value.
274 */
275 domain_check_input(value, (string == NULL), my_extra, escontext);
276
277 if (string == NULL)
278 PG_RETURN_NULL();
279 else
280 PG_RETURN_DATUM(value);
281 }
282
283 /*
284 * domain_recv - binary input routine for any domain type.
285 */
286 Datum
287 domain_recv(PG_FUNCTION_ARGS)
288 {
289 StringInfo buf;
290 Oid domainType;
291 DomainIOData *my_extra;
292 Datum value;
293
294 /*
295 * Since domain_recv is not strict, we have to check for null inputs. The
296 * typioparam argument should never be null in normal system usage, but it
297 * could be null in a manual invocation --- if so, just return null.
298 */
299 if (PG_ARGISNULL(0))
300 buf = NULL;
301 else
302 buf = (StringInfo) PG_GETARG_POINTER(0);
303 if (PG_ARGISNULL(1))
304 PG_RETURN_NULL();
305 domainType = PG_GETARG_OID(1);
306
307 /*
308 * We arrange to look up the needed info just once per series of calls,
309 * assuming the domain type doesn't change underneath us (which really
310 * shouldn't happen, but cope if it does).
311 */
312 my_extra = (DomainIOData *) fcinfo->flinfo->fn_extra;
313 if (my_extra == NULL || my_extra->domain_type != domainType)
314 {
315 my_extra = domain_state_setup(domainType, true,
316 fcinfo->flinfo->fn_mcxt);
317 fcinfo->flinfo->fn_extra = my_extra;
318 }
319
320 /*
321 * Invoke the base type's typreceive procedure to convert the data.
322 */
323 value = ReceiveFunctionCall(&my_extra->proc,
324 buf,
325 my_extra->typioparam,
326 my_extra->typtypmod);
327
328 /*
329 * Do the necessary checks to ensure it's a valid domain value.
330 */
331 domain_check_input(value, (buf == NULL), my_extra, NULL);
332
333 if (buf == NULL)
334 PG_RETURN_NULL();
335 else
336 PG_RETURN_DATUM(value);
337 }
338
339 /*
340 * domain_check - check that a datum satisfies the constraints of a
341 * domain. extra and mcxt can be passed if they are available from,
342 * say, a FmgrInfo structure, or they can be NULL, in which case the
343 * setup is repeated for each call.
344 */
345 void
346 domain_check(Datum value, bool isnull, Oid domainType,
347 void **extra, MemoryContext mcxt)
348 {
349 (void) domain_check_internal(value, isnull, domainType, extra, mcxt,
350 NULL);
351 }
352
353 /* Error-safe variant of domain_check(). */
354 bool
355 domain_check_safe(Datum value, bool isnull, Oid domainType,
356 void **extra, MemoryContext mcxt,
357 Node *escontext)
358 {
359 return domain_check_internal(value, isnull, domainType, extra, mcxt,
360 escontext);
361 }
362
363 /*
364 * domain_check_internal
365 * Workhorse for domain_check() and domain_check_safe()
366 *
367 * Returns false if an error occurred in domain_check_input() and 'escontext'
368 * points to an ErrorSaveContext, true otherwise.
369 */
370 static bool
371 domain_check_internal(Datum value, bool isnull, Oid domainType,
372 void **extra, MemoryContext mcxt,
373 Node *escontext)
374 {
375 DomainIOData *my_extra = NULL;
376
377 if (mcxt == NULL)
378 mcxt = CurrentMemoryContext;
379
380 /*
381 * We arrange to look up the needed info just once per series of calls,
382 * assuming the domain type doesn't change underneath us (which really
383 * shouldn't happen, but cope if it does).
384 */
385 if (extra)
386 my_extra = (DomainIOData *) *extra;
387 if (my_extra == NULL || my_extra->domain_type != domainType)
388 {
389 my_extra = domain_state_setup(domainType, true, mcxt);
390 if (extra)
391 *extra = my_extra;
392 }
393
394 /*
395 * Do the necessary checks to ensure it's a valid domain value.
396 */
397 domain_check_input(value, isnull, my_extra, escontext);
398
399 return !SOFT_ERROR_OCCURRED(escontext);
400 }
401
402 /*
403 * errdatatype --- stores schema_name and datatype_name of a datatype
404 * within the current errordata.
405 */
406 int
407 errdatatype(Oid datatypeOid)
408 {
409 HeapTuple tup;
410 Form_pg_type typtup;
411
412 tup = SearchSysCache1(TYPEOID, ObjectIdGetDatum(datatypeOid));
413 if (!HeapTupleIsValid(tup))
414 elog(ERROR, "cache lookup failed for type %u", datatypeOid);
415 typtup = (Form_pg_type) GETSTRUCT(tup);
416
417 err_generic_string(PG_DIAG_SCHEMA_NAME,
418 get_namespace_name(typtup->typnamespace));
419 err_generic_string(PG_DIAG_DATATYPE_NAME, NameStr(typtup->typname));
420
421 ReleaseSysCache(tup);
422
423 return 0; /* return value does not matter */
424 }
425
426 /*
427 * errdomainconstraint --- stores schema_name, datatype_name and
428 * constraint_name of a domain-related constraint within the current errordata.
429 */
430 int
431 errdomainconstraint(Oid datatypeOid, const char *conname)
432 {
433 errdatatype(datatypeOid);
434 err_generic_string(PG_DIAG_CONSTRAINT_NAME, conname);
435
436 return 0; /* return value does not matter */
437 }