Branch data Line data Source code
1 : : /*-------------------------------------------------------------------------
2 : : *
3 : : * bool.c
4 : : * Functions for the built-in type "bool".
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/bool.c
12 : : *
13 : : *-------------------------------------------------------------------------
14 : : */
15 : :
16 : : #include "postgres.h"
17 : :
18 : : #include <ctype.h>
19 : :
20 : : #include "common/hashfn.h"
21 : : #include "libpq/pqformat.h"
22 : : #include "utils/builtins.h"
23 : :
24 : : /*
25 : : * Try to interpret value as boolean value. Valid values are: true,
26 : : * false, yes, no, on, off, 1, 0; as well as unique prefixes thereof.
27 : : * If the string parses okay, return true, else false.
28 : : * If okay and result is not NULL, return the value in *result.
29 : : */
30 : : bool
31 : 165046 : parse_bool(const char *value, bool *result)
32 : : {
33 : 165046 : return parse_bool_with_len(value, strlen(value), result);
34 : : }
35 : :
36 : : bool
37 : 1989486 : parse_bool_with_len(const char *value, size_t len, bool *result)
38 : : {
39 : : /* Check the most-used possibilities first. */
40 [ + + + + : 1989486 : switch (*value)
+ + + + ]
41 : : {
42 : 322364 : case 't':
43 : : case 'T':
44 [ + + ]: 322364 : if (pg_strncasecmp(value, "true", len) == 0)
45 : : {
46 [ + - ]: 322356 : if (result)
47 : 322356 : *result = true;
48 : 322356 : return true;
49 : : }
50 : 8 : break;
51 : 1585277 : case 'f':
52 : : case 'F':
53 [ + + ]: 1585277 : if (pg_strncasecmp(value, "false", len) == 0)
54 : : {
55 [ + - ]: 1585266 : if (result)
56 : 1585266 : *result = false;
57 : 1585266 : return true;
58 : : }
59 : 11 : break;
60 : 283 : case 'y':
61 : : case 'Y':
62 [ + + ]: 283 : if (pg_strncasecmp(value, "yes", len) == 0)
63 : : {
64 [ + - ]: 279 : if (result)
65 : 279 : *result = true;
66 : 279 : return true;
67 : : }
68 : 4 : break;
69 : 2617 : case 'n':
70 : : case 'N':
71 [ + + ]: 2617 : if (pg_strncasecmp(value, "no", len) == 0)
72 : : {
73 [ + - ]: 2604 : if (result)
74 : 2604 : *result = false;
75 : 2604 : return true;
76 : : }
77 : 13 : break;
78 : 70511 : case 'o':
79 : : case 'O':
80 : : /* 'o' is not unique enough */
81 [ + + ]: 70511 : if (pg_strncasecmp(value, "on", (len > 2 ? len : 2)) == 0)
82 : : {
83 [ + - ]: 50956 : if (result)
84 : 50956 : *result = true;
85 : 50956 : return true;
86 : : }
87 [ + + ]: 19555 : else if (pg_strncasecmp(value, "off", (len > 2 ? len : 2)) == 0)
88 : : {
89 [ + - ]: 19543 : if (result)
90 : 19543 : *result = false;
91 : 19543 : return true;
92 : : }
93 : 12 : break;
94 : 4502 : case '1':
95 [ + + ]: 4502 : if (len == 1)
96 : : {
97 [ + - ]: 4470 : if (result)
98 : 4470 : *result = true;
99 : 4470 : return true;
100 : : }
101 : 32 : break;
102 : 3861 : case '0':
103 [ + + ]: 3861 : if (len == 1)
104 : : {
105 [ + - ]: 3857 : if (result)
106 : 3857 : *result = false;
107 : 3857 : return true;
108 : : }
109 : 4 : break;
110 : 71 : default:
111 : 71 : break;
112 : : }
113 : :
114 [ + - ]: 155 : if (result)
115 : 155 : *result = false; /* suppress compiler warning */
116 : 155 : return false;
117 : : }
118 : :
119 : : /*****************************************************************************
120 : : * USER I/O ROUTINES *
121 : : *****************************************************************************/
122 : :
123 : : /*
124 : : * boolin - input function for type boolean
125 : : */
126 : : Datum
127 : 1824440 : boolin(PG_FUNCTION_ARGS)
128 : : {
129 : 1824440 : const char *in_str = PG_GETARG_CSTRING(0);
130 : : const char *str;
131 : : size_t len;
132 : : bool result;
133 : :
134 : : /*
135 : : * Skip leading and trailing whitespace
136 : : */
137 : 1824440 : str = in_str;
138 [ + + ]: 1824505 : while (isspace((unsigned char) *str))
139 : 65 : str++;
140 : :
141 : 1824440 : len = strlen(str);
142 [ + + + + ]: 1824503 : while (len > 0 && isspace((unsigned char) str[len - 1]))
143 : 63 : len--;
144 : :
145 [ + + ]: 1824440 : if (parse_bool_with_len(str, len, &result))
146 : 1824351 : PG_RETURN_BOOL(result);
147 : :
148 [ + + ]: 89 : ereturn(fcinfo->context, (Datum) 0,
149 : : (errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
150 : : errmsg("invalid input syntax for type %s: \"%s\"",
151 : : "boolean", in_str)));
152 : : }
153 : :
154 : : /*
155 : : * boolout - converts 1 or 0 to "t" or "f"
156 : : */
157 : : Datum
158 : 1573004 : boolout(PG_FUNCTION_ARGS)
159 : : {
160 : 1573004 : bool b = PG_GETARG_BOOL(0);
161 : 1573004 : char *result = (char *) palloc(2);
162 : :
163 [ + + ]: 1573004 : result[0] = (b) ? 't' : 'f';
164 : 1573004 : result[1] = '\0';
165 : 1573004 : PG_RETURN_CSTRING(result);
166 : : }
167 : :
168 : : /*
169 : : * boolrecv - converts external binary format to bool
170 : : *
171 : : * The external representation is one byte. Any nonzero value is taken
172 : : * as "true".
173 : : */
174 : : Datum
175 : 0 : boolrecv(PG_FUNCTION_ARGS)
176 : : {
177 : 0 : StringInfo buf = (StringInfo) PG_GETARG_POINTER(0);
178 : : int ext;
179 : :
180 : 0 : ext = pq_getmsgbyte(buf);
181 : 0 : PG_RETURN_BOOL(ext != 0);
182 : : }
183 : :
184 : : /*
185 : : * boolsend - converts bool to binary format
186 : : */
187 : : Datum
188 : 0 : boolsend(PG_FUNCTION_ARGS)
189 : : {
190 : 0 : bool arg1 = PG_GETARG_BOOL(0);
191 : : StringInfoData buf;
192 : :
193 : 0 : pq_begintypsend(&buf);
194 : 0 : pq_sendbyte(&buf, arg1 ? 1 : 0);
195 : 0 : PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
196 : : }
197 : :
198 : : /*
199 : : * booltext - cast function for bool => text
200 : : *
201 : : * We need this because it's different from the behavior of boolout();
202 : : * this function follows the SQL-spec result (except for producing lower case)
203 : : */
204 : : Datum
205 : 100 : booltext(PG_FUNCTION_ARGS)
206 : : {
207 : 100 : bool arg1 = PG_GETARG_BOOL(0);
208 : : const char *str;
209 : :
210 [ + + ]: 100 : if (arg1)
211 : 46 : str = "true";
212 : : else
213 : 54 : str = "false";
214 : :
215 : 100 : PG_RETURN_TEXT_P(cstring_to_text(str));
216 : : }
217 : :
218 : :
219 : : /*****************************************************************************
220 : : * PUBLIC ROUTINES *
221 : : *****************************************************************************/
222 : :
223 : : Datum
224 : 217971 : booleq(PG_FUNCTION_ARGS)
225 : : {
226 : 217971 : bool arg1 = PG_GETARG_BOOL(0);
227 : 217971 : bool arg2 = PG_GETARG_BOOL(1);
228 : :
229 : 217971 : PG_RETURN_BOOL(arg1 == arg2);
230 : : }
231 : :
232 : : Datum
233 : 54495 : boolne(PG_FUNCTION_ARGS)
234 : : {
235 : 54495 : bool arg1 = PG_GETARG_BOOL(0);
236 : 54495 : bool arg2 = PG_GETARG_BOOL(1);
237 : :
238 : 54495 : PG_RETURN_BOOL(arg1 != arg2);
239 : : }
240 : :
241 : : Datum
242 : 7 : boollt(PG_FUNCTION_ARGS)
243 : : {
244 : 7 : bool arg1 = PG_GETARG_BOOL(0);
245 : 7 : bool arg2 = PG_GETARG_BOOL(1);
246 : :
247 : 7 : PG_RETURN_BOOL(arg1 < arg2);
248 : : }
249 : :
250 : : Datum
251 : 7 : boolgt(PG_FUNCTION_ARGS)
252 : : {
253 : 7 : bool arg1 = PG_GETARG_BOOL(0);
254 : 7 : bool arg2 = PG_GETARG_BOOL(1);
255 : :
256 : 7 : PG_RETURN_BOOL(arg1 > arg2);
257 : : }
258 : :
259 : : Datum
260 : 12 : boolle(PG_FUNCTION_ARGS)
261 : : {
262 : 12 : bool arg1 = PG_GETARG_BOOL(0);
263 : 12 : bool arg2 = PG_GETARG_BOOL(1);
264 : :
265 : 12 : PG_RETURN_BOOL(arg1 <= arg2);
266 : : }
267 : :
268 : : Datum
269 : 12 : boolge(PG_FUNCTION_ARGS)
270 : : {
271 : 12 : bool arg1 = PG_GETARG_BOOL(0);
272 : 12 : bool arg2 = PG_GETARG_BOOL(1);
273 : :
274 : 12 : PG_RETURN_BOOL(arg1 >= arg2);
275 : : }
276 : :
277 : : Datum
278 : 56888 : hashbool(PG_FUNCTION_ARGS)
279 : : {
280 : 56888 : return hash_uint32((int32) PG_GETARG_BOOL(0));
281 : : }
282 : :
283 : : Datum
284 : 0 : hashboolextended(PG_FUNCTION_ARGS)
285 : : {
286 : 0 : return hash_uint32_extended((int32) PG_GETARG_BOOL(0), PG_GETARG_INT64(1));
287 : : }
288 : :
289 : : /*
290 : : * boolean-and and boolean-or aggregates.
291 : : */
292 : :
293 : : /*
294 : : * Function for standard EVERY aggregate conforming to SQL 2003.
295 : : * The aggregate is also named bool_and for consistency.
296 : : *
297 : : * Note: this is only used in plain aggregate mode, not moving-aggregate mode.
298 : : */
299 : : Datum
300 : 16070 : booland_statefunc(PG_FUNCTION_ARGS)
301 : : {
302 [ + + + + ]: 16070 : PG_RETURN_BOOL(PG_GETARG_BOOL(0) && PG_GETARG_BOOL(1));
303 : : }
304 : :
305 : : /*
306 : : * Function for standard ANY/SOME aggregate conforming to SQL 2003.
307 : : * The aggregate is named bool_or, because ANY/SOME have parsing conflicts.
308 : : *
309 : : * Note: this is only used in plain aggregate mode, not moving-aggregate mode.
310 : : */
311 : : Datum
312 : 41 : boolor_statefunc(PG_FUNCTION_ARGS)
313 : : {
314 [ + + + + ]: 41 : PG_RETURN_BOOL(PG_GETARG_BOOL(0) || PG_GETARG_BOOL(1));
315 : : }
316 : :
317 : : typedef struct BoolAggState
318 : : {
319 : : int64 aggcount; /* number of non-null values aggregated */
320 : : int64 aggtrue; /* number of values aggregated that are true */
321 : : } BoolAggState;
322 : :
323 : : static BoolAggState *
324 : 8 : makeBoolAggState(FunctionCallInfo fcinfo)
325 : : {
326 : : BoolAggState *state;
327 : : MemoryContext agg_context;
328 : :
329 [ - + ]: 8 : if (!AggCheckCallContext(fcinfo, &agg_context))
330 [ # # ]: 0 : elog(ERROR, "aggregate function called in non-aggregate context");
331 : :
332 : 8 : state = (BoolAggState *) MemoryContextAlloc(agg_context,
333 : : sizeof(BoolAggState));
334 : 8 : state->aggcount = 0;
335 : 8 : state->aggtrue = 0;
336 : :
337 : 8 : return state;
338 : : }
339 : :
340 : : Datum
341 : 40 : bool_accum(PG_FUNCTION_ARGS)
342 : : {
343 : : BoolAggState *state;
344 : :
345 [ + + ]: 40 : state = PG_ARGISNULL(0) ? NULL : (BoolAggState *) PG_GETARG_POINTER(0);
346 : :
347 : : /* Create the state data on first call */
348 [ + + ]: 40 : if (state == NULL)
349 : 8 : state = makeBoolAggState(fcinfo);
350 : :
351 [ + - ]: 40 : if (!PG_ARGISNULL(1))
352 : : {
353 : 40 : state->aggcount++;
354 [ + + ]: 40 : if (PG_GETARG_BOOL(1))
355 : 24 : state->aggtrue++;
356 : : }
357 : :
358 : 40 : PG_RETURN_POINTER(state);
359 : : }
360 : :
361 : : Datum
362 : 32 : bool_accum_inv(PG_FUNCTION_ARGS)
363 : : {
364 : : BoolAggState *state;
365 : :
366 [ + - ]: 32 : state = PG_ARGISNULL(0) ? NULL : (BoolAggState *) PG_GETARG_POINTER(0);
367 : :
368 : : /* bool_accum should have created the state data */
369 [ - + ]: 32 : if (state == NULL)
370 [ # # ]: 0 : elog(ERROR, "bool_accum_inv called with NULL state");
371 : :
372 [ + - ]: 32 : if (!PG_ARGISNULL(1))
373 : : {
374 : 32 : state->aggcount--;
375 [ + + ]: 32 : if (PG_GETARG_BOOL(1))
376 : 16 : state->aggtrue--;
377 : : }
378 : :
379 : 32 : PG_RETURN_POINTER(state);
380 : : }
381 : :
382 : : Datum
383 : 20 : bool_alltrue(PG_FUNCTION_ARGS)
384 : : {
385 : : BoolAggState *state;
386 : :
387 [ + - ]: 20 : state = PG_ARGISNULL(0) ? NULL : (BoolAggState *) PG_GETARG_POINTER(0);
388 : :
389 : : /* if there were no non-null values, return NULL */
390 [ + - - + ]: 20 : if (state == NULL || state->aggcount == 0)
391 : 0 : PG_RETURN_NULL();
392 : :
393 : : /* true if all non-null values are true */
394 : 20 : PG_RETURN_BOOL(state->aggtrue == state->aggcount);
395 : : }
396 : :
397 : : Datum
398 : 20 : bool_anytrue(PG_FUNCTION_ARGS)
399 : : {
400 : : BoolAggState *state;
401 : :
402 [ + - ]: 20 : state = PG_ARGISNULL(0) ? NULL : (BoolAggState *) PG_GETARG_POINTER(0);
403 : :
404 : : /* if there were no non-null values, return NULL */
405 [ + - - + ]: 20 : if (state == NULL || state->aggcount == 0)
406 : 0 : PG_RETURN_NULL();
407 : :
408 : : /* true if any non-null value is true */
409 : 20 : PG_RETURN_BOOL(state->aggtrue > 0);
410 : : }
|
