Debian Codegraph @

src/interfaces/ecpg/ecpglib/descriptor.c

raw
1 /* dynamic SQL support routines
2 *
3 * src/interfaces/ecpg/ecpglib/descriptor.c
4 */
5
6 #define POSTGRES_ECPG_INTERNAL
7 #include "postgres_fe.h"
8
9 #include "catalog/pg_type_d.h"
10 #include "ecpg-pthread-win32.h"
11 #include "ecpgerrno.h"
12 #include "ecpglib.h"
13 #include "ecpglib_extern.h"
14 #include "ecpgtype.h"
15 #include "sql3types.h"
16 #include "sqlca.h"
17 #include "sqlda.h"
18
19 static void descriptor_free(struct descriptor *desc);
20
21 /* We manage descriptors separately for each thread. */
22 static pthread_key_t descriptor_key;
23 static pthread_once_t descriptor_once = PTHREAD_ONCE_INIT;
24
25 static void descriptor_deallocate_all(struct descriptor *list);
26
27 static void
28 descriptor_destructor(void *arg)
29 {
30 descriptor_deallocate_all(arg);
31 }
32
33 static void
34 descriptor_key_init(void)
35 {
36 pthread_key_create(&descriptor_key, descriptor_destructor);
37 }
38
39 static struct descriptor *
40 get_descriptors(void)
41 {
42 pthread_once(&descriptor_once, descriptor_key_init);
43 return (struct descriptor *) pthread_getspecific(descriptor_key);
44 }
45
46 static void
47 set_descriptors(struct descriptor *value)
48 {
49 pthread_setspecific(descriptor_key, value);
50 }
51
52 /* old internal convenience function that might go away later */
53 static PGresult *
54 ecpg_result_by_descriptor(int line, const char *name)
55 {
56 struct descriptor *desc = ecpg_find_desc(line, name);
57
58 if (desc == NULL)
59 return NULL;
60 return desc->result;
61 }
62
63 static unsigned int
64 ecpg_dynamic_type_DDT(Oid type)
65 {
66 switch (type)
67 {
68 case DATEOID:
69 return SQL3_DDT_DATE;
70 case TIMEOID:
71 return SQL3_DDT_TIME;
72 case TIMESTAMPOID:
73 return SQL3_DDT_TIMESTAMP;
74 case TIMESTAMPTZOID:
75 return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE;
76 case TIMETZOID:
77 return SQL3_DDT_TIME_WITH_TIME_ZONE;
78 default:
79 return SQL3_DDT_ILLEGAL;
80 }
81 }
82
83 bool
84 ECPGget_desc_header(int lineno, const char *desc_name, int *count)
85 {
86 PGresult *ECPGresult;
87 struct sqlca_t *sqlca = ECPGget_sqlca();
88
89 if (sqlca == NULL)
90 {
91 ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
92 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
93 return false;
94 }
95
96 ecpg_init_sqlca(sqlca);
97 ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
98 if (!ECPGresult)
99 return false;
100
101 *count = PQnfields(ECPGresult);
102 sqlca->sqlerrd[2] = 1;
103 ecpg_log("ECPGget_desc_header: found %d attributes\n", *count);
104 return true;
105 }
106
107 static bool
108 get_int_item(int lineno, void *var, enum ECPGttype vartype, int value)
109 {
110 switch (vartype)
111 {
112 case ECPGt_short:
113 *(short *) var = (short) value;
114 break;
115 case ECPGt_int:
116 *(int *) var = (int) value;
117 break;
118 case ECPGt_long:
119 *(long *) var = (long) value;
120 break;
121 case ECPGt_unsigned_short:
122 *(unsigned short *) var = (unsigned short) value;
123 break;
124 case ECPGt_unsigned_int:
125 *(unsigned int *) var = (unsigned int) value;
126 break;
127 case ECPGt_unsigned_long:
128 *(unsigned long *) var = (unsigned long) value;
129 break;
130 case ECPGt_long_long:
131 *(long long int *) var = (long long int) value;
132 break;
133 case ECPGt_unsigned_long_long:
134 *(unsigned long long int *) var = (unsigned long long int) value;
135 break;
136 case ECPGt_float:
137 *(float *) var = (float) value;
138 break;
139 case ECPGt_double:
140 *(double *) var = (double) value;
141 break;
142 default:
143 ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
144 return false;
145 }
146
147 return true;
148 }
149
150 static bool
151 set_int_item(int lineno, int *target, const void *var, enum ECPGttype vartype)
152 {
153 switch (vartype)
154 {
155 case ECPGt_short:
156 *target = *(const short *) var;
157 break;
158 case ECPGt_int:
159 *target = *(const int *) var;
160 break;
161 case ECPGt_long:
162 *target = *(const long *) var;
163 break;
164 case ECPGt_unsigned_short:
165 *target = *(const unsigned short *) var;
166 break;
167 case ECPGt_unsigned_int:
168 *target = *(const unsigned int *) var;
169 break;
170 case ECPGt_unsigned_long:
171 *target = *(const unsigned long *) var;
172 break;
173 case ECPGt_long_long:
174 *target = *(const long long int *) var;
175 break;
176 case ECPGt_unsigned_long_long:
177 *target = *(const unsigned long long int *) var;
178 break;
179 case ECPGt_float:
180 *target = *(const float *) var;
181 break;
182 case ECPGt_double:
183 *target = *(const double *) var;
184 break;
185 default:
186 ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
187 return false;
188 }
189
190 return true;
191 }
192
193 static bool
194 get_char_item(int lineno, void *var, enum ECPGttype vartype, char *value, int varcharsize)
195 {
196 switch (vartype)
197 {
198 case ECPGt_char:
199 case ECPGt_unsigned_char:
200 case ECPGt_string:
201 strncpy(var, value, varcharsize);
202 break;
203 case ECPGt_varchar:
204 {
205 struct ECPGgeneric_varchar *variable =
206 (struct ECPGgeneric_varchar *) var;
207
208 if (varcharsize == 0)
209 memcpy(variable->arr, value, strlen(value));
210 else
211 strncpy(variable->arr, value, varcharsize);
212
213 variable->len = strlen(value);
214 if (varcharsize > 0 && variable->len > varcharsize)
215 variable->len = varcharsize;
216 }
217 break;
218 default:
219 ecpg_raise(lineno, ECPG_VAR_NOT_CHAR, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
220 return false;
221 }
222
223 return true;
224 }
225
226 #define RETURN_IF_NO_DATA if (ntuples < 1) \
227 { \
228 va_end(args); \
229 ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL); \
230 return false; \
231 }
232
233 bool
234 ECPGget_desc(int lineno, const char *desc_name, int index,...)
235 {
236 va_list args;
237 PGresult *ECPGresult;
238 enum ECPGdtype type;
239 int ntuples,
240 act_tuple;
241 struct variable data_var;
242 struct sqlca_t *sqlca = ECPGget_sqlca();
243
244 if (sqlca == NULL)
245 {
246 ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
247 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
248 return false;
249 }
250
251 va_start(args, index);
252 ecpg_init_sqlca(sqlca);
253 ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
254 if (!ECPGresult)
255 {
256 va_end(args);
257 return false;
258 }
259
260 ntuples = PQntuples(ECPGresult);
261
262 if (index < 1 || index > PQnfields(ECPGresult))
263 {
264 ecpg_raise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX, NULL);
265 va_end(args);
266 return false;
267 }
268
269 ecpg_log("ECPGget_desc: reading items for tuple %d\n", index);
270 --index;
271
272 type = va_arg(args, enum ECPGdtype);
273
274 memset(&data_var, 0, sizeof data_var);
275 data_var.type = ECPGt_EORT;
276 data_var.ind_type = ECPGt_NO_INDICATOR;
277
278 while (type != ECPGd_EODT)
279 {
280 char type_str[20];
281 long varcharsize;
282 long offset;
283 long arrsize;
284 enum ECPGttype vartype;
285 void *var;
286
287 vartype = va_arg(args, enum ECPGttype);
288 var = va_arg(args, void *);
289 varcharsize = va_arg(args, long);
290 arrsize = va_arg(args, long);
291 offset = va_arg(args, long);
292
293 switch (type)
294 {
295 case (ECPGd_indicator):
296 RETURN_IF_NO_DATA;
297 data_var.ind_type = vartype;
298 data_var.ind_pointer = var;
299 data_var.ind_varcharsize = varcharsize;
300 data_var.ind_arrsize = arrsize;
301 data_var.ind_offset = offset;
302 if (data_var.ind_arrsize == 0 || data_var.ind_varcharsize == 0)
303 data_var.ind_value = *((void **) (data_var.ind_pointer));
304 else
305 data_var.ind_value = data_var.ind_pointer;
306 break;
307
308 case ECPGd_data:
309 RETURN_IF_NO_DATA;
310 data_var.type = vartype;
311 data_var.pointer = var;
312 data_var.varcharsize = varcharsize;
313 data_var.arrsize = arrsize;
314 data_var.offset = offset;
315 if (data_var.arrsize == 0 || data_var.varcharsize == 0)
316 data_var.value = *((void **) (data_var.pointer));
317 else
318 data_var.value = data_var.pointer;
319 break;
320
321 case ECPGd_name:
322 if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
323 {
324 va_end(args);
325 return false;
326 }
327
328 ecpg_log("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
329 break;
330
331 case ECPGd_nullable:
332 if (!get_int_item(lineno, var, vartype, 1))
333 {
334 va_end(args);
335 return false;
336 }
337
338 break;
339
340 case ECPGd_key_member:
341 if (!get_int_item(lineno, var, vartype, 0))
342 {
343 va_end(args);
344 return false;
345 }
346
347 break;
348
349 case ECPGd_scale:
350 if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
351 {
352 va_end(args);
353 return false;
354 }
355
356 ecpg_log("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
357 break;
358
359 case ECPGd_precision:
360 if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
361 {
362 va_end(args);
363 return false;
364 }
365
366 ecpg_log("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
367 break;
368
369 case ECPGd_octet:
370 if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
371 {
372 va_end(args);
373 return false;
374 }
375
376 ecpg_log("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
377 break;
378
379 case ECPGd_length:
380 if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
381 {
382 va_end(args);
383 return false;
384 }
385
386 ecpg_log("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
387 break;
388
389 case ECPGd_type:
390 if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type(PQftype(ECPGresult, index))))
391 {
392 va_end(args);
393 return false;
394 }
395
396 ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type(PQftype(ECPGresult, index)));
397 break;
398
399 case ECPGd_di_code:
400 if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type_DDT(PQftype(ECPGresult, index))))
401 {
402 va_end(args);
403 return false;
404 }
405
406 ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type_DDT(PQftype(ECPGresult, index)));
407 break;
408
409 case ECPGd_cardinality:
410 if (!get_int_item(lineno, var, vartype, PQntuples(ECPGresult)))
411 {
412 va_end(args);
413 return false;
414 }
415
416 ecpg_log("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));
417 break;
418
419 case ECPGd_ret_length:
420 case ECPGd_ret_octet:
421
422 RETURN_IF_NO_DATA;
423
424 /*
425 * this is like ECPGstore_result
426 */
427 if (arrsize > 0 && ntuples > arrsize)
428 {
429 ecpg_log("ECPGget_desc on line %d: incorrect number of matches; %d don't fit into array of %ld\n",
430 lineno, ntuples, arrsize);
431 ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
432 va_end(args);
433 return false;
434 }
435 /* allocate storage if needed */
436 if (arrsize == 0 && *(void **) var == NULL)
437 {
438 void *mem = ecpg_auto_alloc(offset * ntuples, lineno);
439
440 if (!mem)
441 {
442 va_end(args);
443 return false;
444 }
445 *(void **) var = mem;
446 var = mem;
447 }
448
449 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
450 {
451 if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, act_tuple, index)))
452 {
453 va_end(args);
454 return false;
455 }
456 var = (char *) var + offset;
457 ecpg_log("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));
458 }
459 break;
460
461 default:
462 snprintf(type_str, sizeof(type_str), "%d", type);
463 ecpg_raise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
464 va_end(args);
465 return false;
466 }
467
468 type = va_arg(args, enum ECPGdtype);
469 }
470
471 if (data_var.type != ECPGt_EORT)
472 {
473 struct statement stmt;
474
475 memset(&stmt, 0, sizeof stmt);
476 stmt.lineno = lineno;
477
478 /* desperate try to guess something sensible */
479 stmt.connection = ecpg_get_connection(NULL);
480 if (stmt.connection == NULL)
481 {
482 ecpg_raise(lineno, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
483 ecpg_gettext("NULL"));
484 va_end(args);
485 return false;
486 }
487
488 /* Make sure we do NOT honor the locale for numeric input */
489 /* since the database gives the standard decimal point */
490 /* (see comments in execute.c) */
491 #ifdef HAVE_USELOCALE
492
493 /*
494 * To get here, the above PQnfields() test must have found nonzero
495 * fields. One needs a connection to create such a descriptor. (EXEC
496 * SQL SET DESCRIPTOR can populate the descriptor's "items", but it
497 * can't change the descriptor's PQnfields().) Any successful
498 * connection initializes ecpg_clocale.
499 */
500 Assert(ecpg_clocale);
501 stmt.oldlocale = uselocale(ecpg_clocale);
502 #else
503 #ifdef WIN32
504 stmt.oldthreadlocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
505 #endif
506 stmt.oldlocale = ecpg_strdup(setlocale(LC_NUMERIC, NULL), lineno);
507 setlocale(LC_NUMERIC, "C");
508 #endif
509
510 ecpg_store_result(ECPGresult, index, &stmt, &data_var);
511
512 #ifdef HAVE_USELOCALE
513 if (stmt.oldlocale != (locale_t) 0)
514 uselocale(stmt.oldlocale);
515 #else
516 if (stmt.oldlocale)
517 {
518 setlocale(LC_NUMERIC, stmt.oldlocale);
519 ecpg_free(stmt.oldlocale);
520 }
521 #ifdef WIN32
522 if (stmt.oldthreadlocale != -1)
523 _configthreadlocale(stmt.oldthreadlocale);
524 #endif
525 #endif
526 }
527 else if (data_var.ind_type != ECPGt_NO_INDICATOR && data_var.ind_pointer != NULL)
528
529 /*
530 * ind_type != NO_INDICATOR should always have ind_pointer != NULL but
531 * since this might be changed manually in the .c file let's play it
532 * safe
533 */
534 {
535 /*
536 * this is like ECPGstore_result but since we don't have a data
537 * variable at hand, we can't call it
538 */
539 if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)
540 {
541 ecpg_log("ECPGget_desc on line %d: incorrect number of matches (indicator); %d don't fit into array of %ld\n",
542 lineno, ntuples, data_var.ind_arrsize);
543 ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
544 va_end(args);
545 return false;
546 }
547
548 /* allocate storage if needed */
549 if (data_var.ind_arrsize == 0 && data_var.ind_value == NULL)
550 {
551 void *mem = ecpg_auto_alloc(data_var.ind_offset * ntuples, lineno);
552
553 if (!mem)
554 {
555 va_end(args);
556 return false;
557 }
558 *(void **) data_var.ind_pointer = mem;
559 data_var.ind_value = mem;
560 }
561
562 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
563 {
564 if (!get_int_item(lineno, data_var.ind_value, data_var.ind_type, -PQgetisnull(ECPGresult, act_tuple, index)))
565 {
566 va_end(args);
567 return false;
568 }
569 data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;
570 ecpg_log("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));
571 }
572 }
573 sqlca->sqlerrd[2] = ntuples;
574 va_end(args);
575 return true;
576 }
577
578 #undef RETURN_IF_NO_DATA
579
580 bool
581 ECPGset_desc_header(int lineno, const char *desc_name, int count)
582 {
583 struct descriptor *desc = ecpg_find_desc(lineno, desc_name);
584
585 if (desc == NULL)
586 return false;
587 desc->count = count;
588 return true;
589 }
590
591 static void
592 set_desc_attr(struct descriptor_item *desc_item, struct variable *var,
593 char *tobeinserted)
594 {
595 if (var->type != ECPGt_bytea)
596 desc_item->is_binary = false;
597
598 else
599 {
600 struct ECPGgeneric_bytea *variable =
601 (struct ECPGgeneric_bytea *) (var->value);
602
603 desc_item->is_binary = true;
604 desc_item->data_len = variable->len;
605 }
606
607 ecpg_free(desc_item->data); /* free() takes care of a potential NULL value */
608 desc_item->data = tobeinserted;
609 }
610
611
612 bool
613 ECPGset_desc(int lineno, const char *desc_name, int index,...)
614 {
615 va_list args;
616 struct descriptor *desc;
617 struct descriptor_item *desc_item;
618 struct variable *var;
619
620 desc = ecpg_find_desc(lineno, desc_name);
621 if (desc == NULL)
622 return false;
623
624 for (desc_item = desc->items; desc_item; desc_item = desc_item->next)
625 {
626 if (desc_item->num == index)
627 break;
628 }
629
630 if (desc_item == NULL)
631 {
632 desc_item = (struct descriptor_item *) ecpg_alloc(sizeof(*desc_item), lineno);
633 if (!desc_item)
634 return false;
635 desc_item->num = index;
636 if (desc->count < index)
637 desc->count = index;
638 desc_item->next = desc->items;
639 desc->items = desc_item;
640 }
641
642 if (!(var = (struct variable *) ecpg_alloc(sizeof(struct variable), lineno)))
643 return false;
644
645 va_start(args, index);
646
647 for (;;)
648 {
649 enum ECPGdtype itemtype;
650 char *tobeinserted = NULL;
651
652 itemtype = va_arg(args, enum ECPGdtype);
653
654 if (itemtype == ECPGd_EODT)
655 break;
656
657 var->type = va_arg(args, enum ECPGttype);
658 var->pointer = va_arg(args, char *);
659
660 var->varcharsize = va_arg(args, long);
661 var->arrsize = va_arg(args, long);
662 var->offset = va_arg(args, long);
663
664 if (var->arrsize == 0 || var->varcharsize == 0)
665 var->value = *((char **) (var->pointer));
666 else
667 var->value = var->pointer;
668
669 /*
670 * negative values are used to indicate an array without given bounds
671 */
672 /* reset to zero for us */
673 if (var->arrsize < 0)
674 var->arrsize = 0;
675 if (var->varcharsize < 0)
676 var->varcharsize = 0;
677
678 var->next = NULL;
679
680 switch (itemtype)
681 {
682 case ECPGd_data:
683 {
684 if (!ecpg_store_input(lineno, true, var, &tobeinserted, false))
685 {
686 ecpg_free(var);
687 va_end(args);
688 return false;
689 }
690
691 set_desc_attr(desc_item, var, tobeinserted);
692 tobeinserted = NULL;
693 break;
694 }
695
696 case ECPGd_indicator:
697 set_int_item(lineno, &desc_item->indicator, var->pointer, var->type);
698 break;
699
700 case ECPGd_length:
701 set_int_item(lineno, &desc_item->length, var->pointer, var->type);
702 break;
703
704 case ECPGd_precision:
705 set_int_item(lineno, &desc_item->precision, var->pointer, var->type);
706 break;
707
708 case ECPGd_scale:
709 set_int_item(lineno, &desc_item->scale, var->pointer, var->type);
710 break;
711
712 case ECPGd_type:
713 set_int_item(lineno, &desc_item->type, var->pointer, var->type);
714 break;
715
716 default:
717 {
718 char type_str[20];
719
720 snprintf(type_str, sizeof(type_str), "%d", itemtype);
721 ecpg_raise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
722 ecpg_free(var);
723 va_end(args);
724 return false;
725 }
726 }
727 }
728 ecpg_free(var);
729 va_end(args);
730
731 return true;
732 }
733
734 /* Free the descriptor and items in it. */
735 static void
736 descriptor_free(struct descriptor *desc)
737 {
738 struct descriptor_item *desc_item;
739
740 for (desc_item = desc->items; desc_item;)
741 {
742 struct descriptor_item *di;
743
744 ecpg_free(desc_item->data);
745 di = desc_item;
746 desc_item = desc_item->next;
747 ecpg_free(di);
748 }
749
750 ecpg_free(desc->name);
751 PQclear(desc->result);
752 ecpg_free(desc);
753 }
754
755 bool
756 ECPGdeallocate_desc(int line, const char *name)
757 {
758 struct descriptor *desc;
759 struct descriptor *prev;
760 struct sqlca_t *sqlca = ECPGget_sqlca();
761
762 if (sqlca == NULL)
763 {
764 ecpg_raise(line, ECPG_OUT_OF_MEMORY,
765 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
766 return false;
767 }
768
769 ecpg_init_sqlca(sqlca);
770 for (desc = get_descriptors(), prev = NULL; desc; prev = desc, desc = desc->next)
771 {
772 if (strcmp(name, desc->name) == 0)
773 {
774 if (prev)
775 prev->next = desc->next;
776 else
777 set_descriptors(desc->next);
778 descriptor_free(desc);
779 return true;
780 }
781 }
782 ecpg_raise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
783 return false;
784 }
785
786 /* Deallocate all descriptors in the list */
787 static void
788 descriptor_deallocate_all(struct descriptor *list)
789 {
790 while (list)
791 {
792 struct descriptor *next = list->next;
793
794 descriptor_free(list);
795 list = next;
796 }
797 }
798
799 bool
800 ECPGallocate_desc(int line, const char *name)
801 {
802 struct descriptor *new;
803 struct sqlca_t *sqlca = ECPGget_sqlca();
804
805 if (sqlca == NULL)
806 {
807 ecpg_raise(line, ECPG_OUT_OF_MEMORY,
808 ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
809 return false;
810 }
811
812 ecpg_init_sqlca(sqlca);
813 new = (struct descriptor *) ecpg_alloc(sizeof(struct descriptor), line);
814 if (!new)
815 return false;
816 new->next = get_descriptors();
817 new->name = ecpg_alloc(strlen(name) + 1, line);
818 if (!new->name)
819 {
820 ecpg_free(new);
821 return false;
822 }
823 new->count = -1;
824 new->items = NULL;
825 new->result = PQmakeEmptyPGresult(NULL, 0);
826 if (!new->result)
827 {
828 ecpg_free(new->name);
829 ecpg_free(new);
830 ecpg_raise(line, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
831 return false;
832 }
833 strcpy(new->name, name);
834 set_descriptors(new);
835 return true;
836 }
837
838 /* Find descriptor with name in the connection. */
839 struct descriptor *
840 ecpg_find_desc(int line, const char *name)
841 {
842 struct descriptor *desc;
843
844 for (desc = get_descriptors(); desc; desc = desc->next)
845 {
846 if (strcmp(name, desc->name) == 0)
847 return desc;
848 }
849
850 ecpg_raise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
851 return NULL; /* not found */
852 }
853
854 bool
855 ECPGdescribe(int line, int compat, bool input, const char *connection_name, const char *stmt_name,...)
856 {
857 bool ret = false;
858 struct connection *con;
859 struct prepared_statement *prep;
860 PGresult *res;
861 va_list args;
862
863 /* DESCRIBE INPUT is not yet supported */
864 if (input)
865 {
866 ecpg_raise(line, ECPG_UNSUPPORTED, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, "DESCRIBE INPUT");
867 return ret;
868 }
869
870 con = ecpg_get_connection(connection_name);
871 if (!con)
872 {
873 ecpg_raise(line, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
874 connection_name ? connection_name : ecpg_gettext("NULL"));
875 return ret;
876 }
877 prep = ecpg_find_prepared_statement(stmt_name, con, NULL);
878 if (!prep)
879 {
880 ecpg_raise(line, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, stmt_name);
881 return ret;
882 }
883
884 va_start(args, stmt_name);
885
886 for (;;)
887 {
888 enum ECPGttype type;
889 void *ptr;
890
891 /* variable type */
892 type = va_arg(args, enum ECPGttype);
893
894 if (type == ECPGt_EORT)
895 break;
896
897 /* rest of variable parameters */
898 ptr = va_arg(args, void *);
899 (void) va_arg(args, long); /* skip args */
900 (void) va_arg(args, long);
901 (void) va_arg(args, long);
902
903 /* variable indicator */
904 (void) va_arg(args, enum ECPGttype);
905 (void) va_arg(args, void *); /* skip args */
906 (void) va_arg(args, long);
907 (void) va_arg(args, long);
908 (void) va_arg(args, long);
909
910 switch (type)
911 {
912 case ECPGt_descriptor:
913 {
914 char *name = ptr;
915 struct descriptor *desc = ecpg_find_desc(line, name);
916
917 if (desc == NULL)
918 break;
919
920 res = PQdescribePrepared(con->connection, stmt_name);
921 if (!ecpg_check_PQresult(res, line, con->connection, compat))
922 break;
923
924 PQclear(desc->result);
925
926 desc->result = res;
927 ret = true;
928 break;
929 }
930 case ECPGt_sqlda:
931 {
932 if (INFORMIX_MODE(compat))
933 {
934 struct sqlda_compat **_sqlda = ptr;
935 struct sqlda_compat *sqlda;
936
937 res = PQdescribePrepared(con->connection, stmt_name);
938 if (!ecpg_check_PQresult(res, line, con->connection, compat))
939 break;
940
941 sqlda = ecpg_build_compat_sqlda(line, res, -1, compat);
942 if (sqlda)
943 {
944 struct sqlda_compat *sqlda_old = *_sqlda;
945 struct sqlda_compat *sqlda_old1;
946
947 while (sqlda_old)
948 {
949 sqlda_old1 = sqlda_old->desc_next;
950 free(sqlda_old);
951 sqlda_old = sqlda_old1;
952 }
953
954 *_sqlda = sqlda;
955 ret = true;
956 }
957
958 PQclear(res);
959 }
960 else
961 {
962 struct sqlda_struct **_sqlda = ptr;
963 struct sqlda_struct *sqlda;
964
965 res = PQdescribePrepared(con->connection, stmt_name);
966 if (!ecpg_check_PQresult(res, line, con->connection, compat))
967 break;
968
969 sqlda = ecpg_build_native_sqlda(line, res, -1, compat);
970 if (sqlda)
971 {
972 struct sqlda_struct *sqlda_old = *_sqlda;
973 struct sqlda_struct *sqlda_old1;
974
975 while (sqlda_old)
976 {
977 sqlda_old1 = sqlda_old->desc_next;
978 free(sqlda_old);
979 sqlda_old = sqlda_old1;
980 }
981
982 *_sqlda = sqlda;
983 ret = true;
984 }
985
986 PQclear(res);
987 }
988 break;
989 }
990 default:
991 /* nothing else may come */
992 ;
993 }
994 }
995
996 va_end(args);
997
998 return ret;
999 }