Branch data Line data Source code
1 : : /*
2 : : * contrib/intarray/_int_op.c
3 : : */
4 : : #include "postgres.h"
5 : :
6 : : #include "_int.h"
7 : :
8 : 1 : PG_MODULE_MAGIC_EXT(
9 : : .name = "intarray",
10 : : .version = PG_VERSION
11 : : );
12 : :
13 : 1 : PG_FUNCTION_INFO_V1(_int_different);
14 : 1 : PG_FUNCTION_INFO_V1(_int_same);
15 : 2 : PG_FUNCTION_INFO_V1(_int_contains);
16 : 2 : PG_FUNCTION_INFO_V1(_int_contained);
17 : 2 : PG_FUNCTION_INFO_V1(_int_overlap);
18 : 2 : PG_FUNCTION_INFO_V1(_int_union);
19 : 2 : PG_FUNCTION_INFO_V1(_int_inter);
20 : :
21 : : Datum
22 : 41160 : _int_contained(PG_FUNCTION_ARGS)
23 : : {
24 : : /* just reverse the operands and call _int_contains */
25 : 41160 : return DirectFunctionCall2(_int_contains,
26 : : PG_GETARG_DATUM(1),
27 : : PG_GETARG_DATUM(0));
28 : : }
29 : :
30 : : Datum
31 : 68284 : _int_contains(PG_FUNCTION_ARGS)
32 : : {
33 : : /* Force copy so we can modify the arrays in-place */
34 : 68284 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
35 : 68284 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
36 : : bool res;
37 : :
38 [ - + - - : 68284 : CHECKARRVALID(a);
- - ]
39 [ - + - - : 68284 : CHECKARRVALID(b);
- - ]
40 [ - + ]: 68284 : PREPAREARR(a);
41 [ - + ]: 68284 : PREPAREARR(b);
42 : 68284 : res = inner_int_contains(a, b);
43 : 68284 : pfree(a);
44 : 68284 : pfree(b);
45 : 68284 : PG_RETURN_BOOL(res);
46 : : }
47 : :
48 : : Datum
49 : 0 : _int_different(PG_FUNCTION_ARGS)
50 : : {
51 : 0 : PG_RETURN_BOOL(!DatumGetBool(DirectFunctionCall2(_int_same,
52 : : PointerGetDatum(PG_GETARG_POINTER(0)),
53 : : PointerGetDatum(PG_GETARG_POINTER(1)))));
54 : : }
55 : :
56 : : Datum
57 : 0 : _int_same(PG_FUNCTION_ARGS)
58 : : {
59 : 0 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
60 : 0 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
61 : : int na,
62 : : nb;
63 : : int n;
64 : : int *da,
65 : : *db;
66 : : bool result;
67 : :
68 [ # # # # : 0 : CHECKARRVALID(a);
# # ]
69 [ # # # # : 0 : CHECKARRVALID(b);
# # ]
70 : 0 : na = ARRNELEMS(a);
71 : 0 : nb = ARRNELEMS(b);
72 [ # # ]: 0 : da = ARRPTR(a);
73 [ # # ]: 0 : db = ARRPTR(b);
74 : :
75 : 0 : result = false;
76 : :
77 [ # # ]: 0 : if (na == nb)
78 : : {
79 [ # # ]: 0 : SORT(a);
80 [ # # ]: 0 : SORT(b);
81 : 0 : result = true;
82 : :
83 [ # # ]: 0 : for (n = 0; n < na; n++)
84 : : {
85 [ # # ]: 0 : if (da[n] != db[n])
86 : : {
87 : 0 : result = false;
88 : 0 : break;
89 : : }
90 : : }
91 : : }
92 : :
93 : 0 : pfree(a);
94 : 0 : pfree(b);
95 : :
96 : 0 : PG_RETURN_BOOL(result);
97 : : }
98 : :
99 : : /*
100 : : * _int_overlap -- does a overlap b?
101 : : */
102 : : Datum
103 : 7563 : _int_overlap(PG_FUNCTION_ARGS)
104 : : {
105 : 7563 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
106 : 7563 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
107 : : bool result;
108 : :
109 [ - + - - : 7563 : CHECKARRVALID(a);
- - ]
110 [ - + - - : 7563 : CHECKARRVALID(b);
- - ]
111 [ + + - + ]: 7563 : if (ARRISEMPTY(a) || ARRISEMPTY(b))
112 : 9 : PG_RETURN_BOOL(false);
113 : :
114 [ - + ]: 7554 : SORT(a);
115 [ - + ]: 7554 : SORT(b);
116 : :
117 : 7554 : result = inner_int_overlap(a, b);
118 : :
119 : 7554 : pfree(a);
120 : 7554 : pfree(b);
121 : :
122 : 7554 : PG_RETURN_BOOL(result);
123 : : }
124 : :
125 : : Datum
126 : 1 : _int_union(PG_FUNCTION_ARGS)
127 : : {
128 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
129 : 1 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
130 : : ArrayType *result;
131 : :
132 [ - + - - : 1 : CHECKARRVALID(a);
- - ]
133 [ - + - - : 1 : CHECKARRVALID(b);
- - ]
134 : :
135 [ - + ]: 1 : SORT(a);
136 [ - + ]: 1 : SORT(b);
137 : :
138 : 1 : result = inner_int_union(a, b);
139 : :
140 : 1 : pfree(a);
141 : 1 : pfree(b);
142 : :
143 : 1 : PG_RETURN_POINTER(result);
144 : : }
145 : :
146 : : Datum
147 : 6 : _int_inter(PG_FUNCTION_ARGS)
148 : : {
149 : 6 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
150 : 6 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
151 : : ArrayType *result;
152 : :
153 [ - + - - : 6 : CHECKARRVALID(a);
- - ]
154 [ - + - - : 6 : CHECKARRVALID(b);
- - ]
155 : :
156 [ - + ]: 6 : SORT(a);
157 [ - + ]: 6 : SORT(b);
158 : :
159 : 6 : result = inner_int_inter(a, b);
160 : :
161 : 6 : pfree(a);
162 : 6 : pfree(b);
163 : :
164 : 6 : PG_RETURN_POINTER(result);
165 : : }
166 : :
167 : :
168 : 2 : PG_FUNCTION_INFO_V1(intset);
169 : 2 : PG_FUNCTION_INFO_V1(icount);
170 : 4 : PG_FUNCTION_INFO_V1(sort);
171 : 2 : PG_FUNCTION_INFO_V1(sort_asc);
172 : 2 : PG_FUNCTION_INFO_V1(sort_desc);
173 : 2 : PG_FUNCTION_INFO_V1(uniq);
174 : 2 : PG_FUNCTION_INFO_V1(idx);
175 : 3 : PG_FUNCTION_INFO_V1(subarray);
176 : 2 : PG_FUNCTION_INFO_V1(intarray_push_elem);
177 : 2 : PG_FUNCTION_INFO_V1(intarray_push_array);
178 : 2 : PG_FUNCTION_INFO_V1(intarray_del_elem);
179 : 2 : PG_FUNCTION_INFO_V1(intset_union_elem);
180 : 2 : PG_FUNCTION_INFO_V1(intset_subtract);
181 : :
182 : : Datum
183 : 1 : intset(PG_FUNCTION_ARGS)
184 : : {
185 : 1 : PG_RETURN_POINTER(int_to_intset(PG_GETARG_INT32(0)));
186 : : }
187 : :
188 : : Datum
189 : 2 : icount(PG_FUNCTION_ARGS)
190 : : {
191 : 2 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
192 : 2 : int32 count = ARRNELEMS(a);
193 : :
194 [ - + ]: 2 : PG_FREE_IF_COPY(a, 0);
195 : 2 : PG_RETURN_INT32(count);
196 : : }
197 : :
198 : : Datum
199 : 3 : sort(PG_FUNCTION_ARGS)
200 : : {
201 : 3 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
202 [ + + ]: 3 : text *dirstr = (fcinfo->nargs == 2) ? PG_GETARG_TEXT_PP(1) : NULL;
203 [ + + ]: 3 : int32 dc = (dirstr) ? VARSIZE_ANY_EXHDR(dirstr) : 0;
204 [ + + ]: 3 : char *d = (dirstr) ? VARDATA_ANY(dirstr) : NULL;
205 : 3 : int dir = -1;
206 : :
207 [ - + - - : 3 : CHECKARRVALID(a);
- - ]
208 [ - + ]: 3 : if (ARRNELEMS(a) < 2)
209 : 0 : PG_RETURN_POINTER(a);
210 : :
211 [ + + + + ]: 3 : if (dirstr == NULL || (dc == 3
212 [ + - + - ]: 1 : && (d[0] == 'A' || d[0] == 'a')
213 [ + - + - ]: 1 : && (d[1] == 'S' || d[1] == 's')
214 [ + - + - ]: 1 : && (d[2] == 'C' || d[2] == 'c')))
215 : 2 : dir = 1;
216 [ + - ]: 1 : else if (dc == 4
217 [ + - + - ]: 1 : && (d[0] == 'D' || d[0] == 'd')
218 [ + - + - ]: 1 : && (d[1] == 'E' || d[1] == 'e')
219 [ + - + - ]: 1 : && (d[2] == 'S' || d[2] == 's')
220 [ + - + - ]: 1 : && (d[3] == 'C' || d[3] == 'c'))
221 : 1 : dir = 0;
222 [ - + ]: 3 : if (dir == -1)
223 [ # # ]: 0 : ereport(ERROR,
224 : : (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
225 : : errmsg("second parameter must be \"ASC\" or \"DESC\"")));
226 [ - + ]: 3 : QSORT(a, dir);
227 : 3 : PG_RETURN_POINTER(a);
228 : : }
229 : :
230 : : Datum
231 : 2 : sort_asc(PG_FUNCTION_ARGS)
232 : : {
233 : 2 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
234 : :
235 [ - + - - : 2 : CHECKARRVALID(a);
- - ]
236 [ - + ]: 2 : QSORT(a, 1);
237 : 2 : PG_RETURN_POINTER(a);
238 : : }
239 : :
240 : : Datum
241 : 1 : sort_desc(PG_FUNCTION_ARGS)
242 : : {
243 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
244 : :
245 [ - + - - : 1 : CHECKARRVALID(a);
- - ]
246 [ - + ]: 1 : QSORT(a, 0);
247 : 1 : PG_RETURN_POINTER(a);
248 : : }
249 : :
250 : : Datum
251 : 2 : uniq(PG_FUNCTION_ARGS)
252 : : {
253 : 2 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
254 : :
255 [ - + - - : 2 : CHECKARRVALID(a);
- - ]
256 [ - + ]: 2 : if (ARRNELEMS(a) < 2)
257 : 0 : PG_RETURN_POINTER(a);
258 : 2 : a = _int_unique(a);
259 : 2 : PG_RETURN_POINTER(a);
260 : : }
261 : :
262 : : Datum
263 : 1 : idx(PG_FUNCTION_ARGS)
264 : : {
265 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
266 : : int32 result;
267 : :
268 [ - + - - : 1 : CHECKARRVALID(a);
- - ]
269 : 1 : result = ARRNELEMS(a);
270 [ + - ]: 1 : if (result)
271 : 1 : result = intarray_match_first(a, PG_GETARG_INT32(1));
272 [ - + ]: 1 : PG_FREE_IF_COPY(a, 0);
273 : 1 : PG_RETURN_INT32(result);
274 : : }
275 : :
276 : : Datum
277 : 3 : subarray(PG_FUNCTION_ARGS)
278 : : {
279 : 3 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
280 : 3 : int32 start = PG_GETARG_INT32(1);
281 [ + - ]: 3 : int32 len = (fcinfo->nargs == 3) ? PG_GETARG_INT32(2) : 0;
282 : 3 : int32 end = 0;
283 : : int32 c;
284 : : ArrayType *result;
285 : :
286 [ + + ]: 3 : start = (start > 0) ? start - 1 : start;
287 : :
288 [ - + - - : 3 : CHECKARRVALID(a);
- - ]
289 [ - + ]: 3 : if (ARRISEMPTY(a))
290 : : {
291 [ # # ]: 0 : PG_FREE_IF_COPY(a, 0);
292 : 0 : PG_RETURN_POINTER(new_intArrayType(0));
293 : : }
294 : :
295 : 3 : c = ARRNELEMS(a);
296 : :
297 [ + + ]: 3 : if (start < 0)
298 : 1 : start = c + start;
299 : :
300 [ + + ]: 3 : if (len < 0)
301 : 1 : end = c + len;
302 [ - + ]: 2 : else if (len == 0)
303 : 0 : end = c;
304 : : else
305 : 2 : end = start + len;
306 : :
307 [ - + ]: 3 : if (end > c)
308 : 0 : end = c;
309 : :
310 [ - + ]: 3 : if (start < 0)
311 : 0 : start = 0;
312 : :
313 [ + - - + ]: 3 : if (start >= end || end <= 0)
314 : : {
315 [ # # ]: 0 : PG_FREE_IF_COPY(a, 0);
316 : 0 : PG_RETURN_POINTER(new_intArrayType(0));
317 : : }
318 : :
319 : 3 : result = new_intArrayType(end - start);
320 [ + - ]: 3 : if (end - start > 0)
321 [ - + - + ]: 3 : memcpy(ARRPTR(result), ARRPTR(a) + start, (end - start) * sizeof(int32));
322 [ - + ]: 3 : PG_FREE_IF_COPY(a, 0);
323 : 3 : PG_RETURN_POINTER(result);
324 : : }
325 : :
326 : : Datum
327 : 2 : intarray_push_elem(PG_FUNCTION_ARGS)
328 : : {
329 : 2 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
330 : : ArrayType *result;
331 : :
332 : 2 : result = intarray_add_elem(a, PG_GETARG_INT32(1));
333 [ - + ]: 2 : PG_FREE_IF_COPY(a, 0);
334 : 2 : PG_RETURN_POINTER(result);
335 : : }
336 : :
337 : : Datum
338 : 1 : intarray_push_array(PG_FUNCTION_ARGS)
339 : : {
340 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
341 : 1 : ArrayType *b = PG_GETARG_ARRAYTYPE_P(1);
342 : : ArrayType *result;
343 : :
344 : 1 : result = intarray_concat_arrays(a, b);
345 [ - + ]: 1 : PG_FREE_IF_COPY(a, 0);
346 [ - + ]: 1 : PG_FREE_IF_COPY(b, 1);
347 : 1 : PG_RETURN_POINTER(result);
348 : : }
349 : :
350 : : Datum
351 : 1 : intarray_del_elem(PG_FUNCTION_ARGS)
352 : : {
353 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
354 : 1 : int32 elem = PG_GETARG_INT32(1);
355 : : int32 c;
356 : : int32 *aa;
357 : 1 : int32 n = 0,
358 : : i;
359 : :
360 [ - + - - : 1 : CHECKARRVALID(a);
- - ]
361 [ + - ]: 1 : if (!ARRISEMPTY(a))
362 : : {
363 : 1 : c = ARRNELEMS(a);
364 [ - + ]: 1 : aa = ARRPTR(a);
365 [ + + ]: 4 : for (i = 0; i < c; i++)
366 : : {
367 [ + + ]: 3 : if (aa[i] != elem)
368 : : {
369 [ + + ]: 2 : if (i > n)
370 : 1 : aa[n++] = aa[i];
371 : : else
372 : 1 : n++;
373 : : }
374 : : }
375 : 1 : a = resize_intArrayType(a, n);
376 : : }
377 : 1 : PG_RETURN_POINTER(a);
378 : : }
379 : :
380 : : Datum
381 : 2 : intset_union_elem(PG_FUNCTION_ARGS)
382 : : {
383 : 2 : ArrayType *a = PG_GETARG_ARRAYTYPE_P(0);
384 : : ArrayType *result;
385 : :
386 : 2 : result = intarray_add_elem(a, PG_GETARG_INT32(1));
387 [ - + ]: 2 : PG_FREE_IF_COPY(a, 0);
388 [ - + ]: 2 : QSORT(result, 1);
389 : 2 : PG_RETURN_POINTER(_int_unique(result));
390 : : }
391 : :
392 : : Datum
393 : 1 : intset_subtract(PG_FUNCTION_ARGS)
394 : : {
395 : 1 : ArrayType *a = PG_GETARG_ARRAYTYPE_P_COPY(0);
396 : 1 : ArrayType *b = PG_GETARG_ARRAYTYPE_P_COPY(1);
397 : : ArrayType *result;
398 : : int32 ca;
399 : : int32 cb;
400 : : int32 *aa,
401 : : *bb,
402 : : *r;
403 : 1 : int32 n = 0,
404 : 1 : i = 0,
405 : 1 : k = 0;
406 : :
407 [ - + - - : 1 : CHECKARRVALID(a);
- - ]
408 [ - + - - : 1 : CHECKARRVALID(b);
- - ]
409 : :
410 [ - + ]: 1 : QSORT(a, 1);
411 : 1 : a = _int_unique(a);
412 : 1 : ca = ARRNELEMS(a);
413 [ - + ]: 1 : QSORT(b, 1);
414 : 1 : b = _int_unique(b);
415 : 1 : cb = ARRNELEMS(b);
416 : 1 : result = new_intArrayType(ca);
417 [ - + ]: 1 : aa = ARRPTR(a);
418 [ - + ]: 1 : bb = ARRPTR(b);
419 [ - + ]: 1 : r = ARRPTR(result);
420 [ + + ]: 4 : while (i < ca)
421 : : {
422 [ + - + + ]: 3 : if (k == cb || aa[i] < bb[k])
423 : 2 : r[n++] = aa[i++];
424 [ + - ]: 1 : else if (aa[i] == bb[k])
425 : : {
426 : 1 : i++;
427 : 1 : k++;
428 : : }
429 : : else
430 : 0 : k++;
431 : : }
432 : 1 : result = resize_intArrayType(result, n);
433 : 1 : pfree(a);
434 : 1 : pfree(b);
435 : 1 : PG_RETURN_POINTER(result);
436 : : }
|
