1 /* dynamic SQL support routines
3 * $PostgreSQL: pgsql/src/interfaces/ecpg/ecpglib/descriptor.c,v 1.24 2007/10/02 09:49:59 meskes Exp $
6 #define POSTGRES_ECPG_INTERNAL
7 #include "postgres_fe.h"
10 #include "ecpg-pthread-win32.h"
13 #include "ecpgerrno.h"
16 #include "sql3types.h"
18 static void descriptor_free(struct descriptor *desc);
19 static void descriptor_deallocate_all(struct descriptor *list);
21 /* We manage descriptors separately for each thread. */
22 #ifdef ENABLE_THREAD_SAFETY
23 static pthread_key_t descriptor_key;
25 static pthread_once_t descriptor_once = PTHREAD_ONCE_INIT;
29 descriptor_destructor(void *arg)
31 descriptor_deallocate_all(arg);
35 descriptor_key_init(void)
37 pthread_key_create(&descriptor_key, descriptor_destructor);
40 static struct descriptor *
43 pthread_once(&descriptor_once, descriptor_key_init);
44 return (struct descriptor *) pthread_getspecific(descriptor_key);
48 set_descriptors(struct descriptor *value)
50 pthread_setspecific(descriptor_key, value);
54 static struct descriptor *all_descriptors = NULL;
55 #define get_descriptors() (all_descriptors)
56 #define set_descriptors(value) do { all_descriptors = (value); } while(0)
59 /* old internal convenience function that might go away later */
61 ECPGresultByDescriptor(int line, const char *name)
63 struct descriptor *desc = ECPGfind_desc(line, name);
70 ECPGDynamicType_DDT(Oid type)
79 return SQL3_DDT_TIMESTAMP;
81 return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE;
83 return SQL3_DDT_TIME_WITH_TIME_ZONE;
85 return SQL3_DDT_ILLEGAL;
90 ECPGget_desc_header(int lineno, const char *desc_name, int *count)
93 struct sqlca_t *sqlca = ECPGget_sqlca();
95 ECPGinit_sqlca(sqlca);
96 ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
100 *count = PQnfields(ECPGresult);
101 sqlca->sqlerrd[2] = 1;
102 ECPGlog("ECPGget_desc_header: found %d attributes.\n", *count);
107 get_int_item(int lineno, void *var, enum ECPGttype vartype, int value)
112 *(short *) var = (short) value;
115 *(int *) var = (int) value;
118 *(long *) var = (long) value;
120 case ECPGt_unsigned_short:
121 *(unsigned short *) var = (unsigned short) value;
123 case ECPGt_unsigned_int:
124 *(unsigned int *) var = (unsigned int) value;
126 case ECPGt_unsigned_long:
127 *(unsigned long *) var = (unsigned long) value;
129 #ifdef HAVE_LONG_LONG_INT_64
130 case ECPGt_long_long:
131 *(long long int *) var = (long long int) value;
133 case ECPGt_unsigned_long_long:
134 *(unsigned long long int *) var = (unsigned long long int) value;
136 #endif /* HAVE_LONG_LONG_INT_64 */
138 *(float *) var = (float) value;
141 *(double *) var = (double) value;
144 ECPGraise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
152 set_int_item(int lineno, int *target, const void *var, enum ECPGttype vartype)
157 *target = *(short *) var;
160 *target = *(int *) var;
163 *target = *(long *) var;
165 case ECPGt_unsigned_short:
166 *target = *(unsigned short *) var;
168 case ECPGt_unsigned_int:
169 *target = *(unsigned int *) var;
171 case ECPGt_unsigned_long:
172 *target = *(unsigned long *) var;
174 #ifdef HAVE_LONG_LONG_INT_64
175 case ECPGt_long_long:
176 *target = *(long long int *) var;
178 case ECPGt_unsigned_long_long:
179 *target = *(unsigned long long int *) var;
181 #endif /* HAVE_LONG_LONG_INT_64 */
183 *target = *(float *) var;
186 *target = *(double *) var;
189 ECPGraise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
197 get_char_item(int lineno, void *var, enum ECPGttype vartype, char *value, int varcharsize)
202 case ECPGt_unsigned_char:
203 strncpy((char *) var, value, varcharsize);
207 struct ECPGgeneric_varchar *variable =
208 (struct ECPGgeneric_varchar *) var;
210 if (varcharsize == 0)
211 strncpy(variable->arr, value, strlen(value));
213 strncpy(variable->arr, value, varcharsize);
215 variable->len = strlen(value);
216 if (varcharsize > 0 && variable->len > varcharsize)
217 variable->len = varcharsize;
221 ECPGraise(lineno, ECPG_VAR_NOT_CHAR, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
229 ECPGget_desc(int lineno, const char *desc_name, int index,...)
232 PGresult *ECPGresult;
236 struct variable data_var;
237 struct sqlca_t *sqlca = ECPGget_sqlca();
239 va_start(args, index);
240 ECPGinit_sqlca(sqlca);
241 ECPGresult = ECPGresultByDescriptor(lineno, desc_name);
245 ntuples = PQntuples(ECPGresult);
248 ECPGraise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
252 if (index < 1 || index > PQnfields(ECPGresult))
254 ECPGraise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX, NULL);
258 ECPGlog("ECPGget_desc: reading items for tuple %d\n", index);
261 type = va_arg(args, enum ECPGdtype);
263 memset(&data_var, 0, sizeof data_var);
264 data_var.type = ECPGt_EORT;
265 data_var.ind_type = ECPGt_NO_INDICATOR;
267 while (type != ECPGd_EODT)
273 enum ECPGttype vartype;
276 vartype = va_arg(args, enum ECPGttype);
277 var = va_arg(args, void *);
278 varcharsize = va_arg(args, long);
279 arrsize = va_arg(args, long);
280 offset = va_arg(args, long);
284 case (ECPGd_indicator):
285 data_var.ind_type = vartype;
286 data_var.ind_pointer = var;
287 data_var.ind_varcharsize = varcharsize;
288 data_var.ind_arrsize = arrsize;
289 data_var.ind_offset = offset;
290 if (data_var.ind_arrsize == 0 || data_var.ind_varcharsize == 0)
291 data_var.ind_value = *((void **) (data_var.ind_pointer));
293 data_var.ind_value = data_var.ind_pointer;
297 data_var.type = vartype;
298 data_var.pointer = var;
299 data_var.varcharsize = varcharsize;
300 data_var.arrsize = arrsize;
301 data_var.offset = offset;
302 if (data_var.arrsize == 0 || data_var.varcharsize == 0)
303 data_var.value = *((void **) (data_var.pointer));
305 data_var.value = data_var.pointer;
309 if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
312 ECPGlog("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
316 if (!get_int_item(lineno, var, vartype, 1))
321 case ECPGd_key_member:
322 if (!get_int_item(lineno, var, vartype, 0))
328 if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
331 ECPGlog("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
334 case ECPGd_precision:
335 if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
338 ECPGlog("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
342 if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
345 ECPGlog("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
349 if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
352 ECPGlog("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
356 if (!get_int_item(lineno, var, vartype, ECPGDynamicType(PQftype(ECPGresult, index))))
359 ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType(PQftype(ECPGresult, index)));
363 if (!get_int_item(lineno, var, vartype, ECPGDynamicType_DDT(PQftype(ECPGresult, index))))
366 ECPGlog("ECPGget_desc: TYPE = %d\n", ECPGDynamicType_DDT(PQftype(ECPGresult, index)));
369 case ECPGd_cardinality:
370 if (!get_int_item(lineno, var, vartype, PQntuples(ECPGresult)))
373 ECPGlog("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));
376 case ECPGd_ret_length:
377 case ECPGd_ret_octet:
380 * this is like ECPGstore_result
382 if (arrsize > 0 && ntuples > arrsize)
384 ECPGlog("ECPGget_desc line %d: Incorrect number of matches: %d don't fit into array of %d\n",
385 lineno, ntuples, arrsize);
386 ECPGraise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
389 /* allocate storage if needed */
390 if (arrsize == 0 && *(void **) var == NULL)
392 void *mem = (void *) ECPGalloc(offset * ntuples, lineno);
396 *(void **) var = mem;
397 ECPGadd_mem(mem, lineno);
401 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
403 if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, act_tuple, index)))
405 var = (char *) var + offset;
406 ECPGlog("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));
411 snprintf(type_str, sizeof(type_str), "%d", type);
412 ECPGraise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
416 type = va_arg(args, enum ECPGdtype);
419 if (data_var.type != ECPGt_EORT)
421 struct statement stmt;
424 /* Make sure we do NOT honor the locale for numeric input */
425 /* since the database gives the standard decimal point */
426 oldlocale = ECPGstrdup(setlocale(LC_NUMERIC, NULL), lineno);
427 setlocale(LC_NUMERIC, "C");
429 memset(&stmt, 0, sizeof stmt);
430 stmt.lineno = lineno;
432 /* desparate try to guess something sensible */
433 stmt.connection = ECPGget_connection(NULL);
434 ECPGstore_result(ECPGresult, index, &stmt, &data_var);
436 setlocale(LC_NUMERIC, oldlocale);
439 else if (data_var.ind_type != ECPGt_NO_INDICATOR && data_var.ind_pointer != NULL)
442 * ind_type != NO_INDICATOR should always have ind_pointer != NULL but
443 * since this might be changed manually in the .c file let's play it
448 * this is like ECPGstore_result but since we don't have a data
449 * variable at hand, we can't call it
451 if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)
453 ECPGlog("ECPGget_desc line %d: Incorrect number of matches (indicator): %d don't fit into array of %d\n",
454 lineno, ntuples, data_var.ind_arrsize);
455 ECPGraise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
459 /* allocate storage if needed */
460 if (data_var.ind_arrsize == 0 && data_var.ind_value == NULL)
462 void *mem = (void *) ECPGalloc(data_var.ind_offset * ntuples, lineno);
466 *(void **) data_var.ind_pointer = mem;
467 ECPGadd_mem(mem, lineno);
468 data_var.ind_value = mem;
471 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
473 if (!get_int_item(lineno, data_var.ind_value, data_var.ind_type, -PQgetisnull(ECPGresult, act_tuple, index)))
475 data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;
476 ECPGlog("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));
479 sqlca->sqlerrd[2] = ntuples;
484 ECPGset_desc_header(int lineno, const char *desc_name, int count)
486 struct descriptor *desc = ECPGfind_desc(lineno, desc_name);
494 ECPGset_desc(int lineno, const char *desc_name, int index,...)
497 struct descriptor *desc;
498 struct descriptor_item *desc_item;
499 struct variable *var;
501 desc = ECPGfind_desc(lineno, desc_name);
505 for (desc_item = desc->items; desc_item; desc_item = desc_item->next)
507 if (desc_item->num == index)
511 if (desc_item == NULL)
513 desc_item = (struct descriptor_item *) ECPGalloc(sizeof(*desc_item), lineno);
516 desc_item->num = index;
517 if (desc->count < index)
519 desc_item->next = desc->items;
520 desc->items = desc_item;
523 if (!(var = (struct variable *) ECPGalloc(sizeof(struct variable), lineno)))
526 va_start(args, index);
530 enum ECPGdtype itemtype;
531 const char *tobeinserted = NULL;
533 itemtype = va_arg(args, enum ECPGdtype);
535 if (itemtype == ECPGd_EODT)
538 var->type = va_arg(args, enum ECPGttype);
539 var->pointer = va_arg(args, char *);
541 var->varcharsize = va_arg(args, long);
542 var->arrsize = va_arg(args, long);
543 var->offset = va_arg(args, long);
545 if (var->arrsize == 0 || var->varcharsize == 0)
546 var->value = *((char **) (var->pointer));
548 var->value = var->pointer;
551 * negative values are used to indicate an array without given bounds
553 /* reset to zero for us */
554 if (var->arrsize < 0)
556 if (var->varcharsize < 0)
557 var->varcharsize = 0;
565 if (!ECPGstore_input(lineno, true, var, &tobeinserted, false))
571 ECPGfree(desc_item->data); /* free() takes care of a potential NULL value */
572 desc_item->data = (char *) tobeinserted;
577 case ECPGd_indicator:
578 set_int_item(lineno, &desc_item->indicator, var->pointer, var->type);
582 set_int_item(lineno, &desc_item->length, var->pointer, var->type);
585 case ECPGd_precision:
586 set_int_item(lineno, &desc_item->precision, var->pointer, var->type);
590 set_int_item(lineno, &desc_item->scale, var->pointer, var->type);
594 set_int_item(lineno, &desc_item->type, var->pointer, var->type);
601 snprintf(type_str, sizeof(type_str), "%d", itemtype);
602 ECPGraise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
613 /* Free the descriptor and items in it. */
615 descriptor_free(struct descriptor *desc)
617 struct descriptor_item *desc_item;
619 for (desc_item = desc->items; desc_item;)
621 struct descriptor_item *di;
623 ECPGfree(desc_item->data);
625 desc_item = desc_item->next;
629 ECPGfree(desc->name);
630 PQclear(desc->result);
635 ECPGdeallocate_desc(int line, const char *name)
637 struct descriptor *desc;
638 struct descriptor *prev;
639 struct sqlca_t *sqlca = ECPGget_sqlca();
641 ECPGinit_sqlca(sqlca);
642 for (desc = get_descriptors(), prev = NULL; desc; prev = desc, desc = desc->next)
644 if (!strcmp(name, desc->name))
647 prev->next = desc->next;
649 set_descriptors(desc->next);
650 descriptor_free(desc);
654 ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
658 /* Deallocate all descriptors in the list */
660 descriptor_deallocate_all(struct descriptor *list)
664 struct descriptor *next = list->next;
665 descriptor_free(list);
671 ECPGallocate_desc(int line, const char *name)
673 struct descriptor *new;
674 struct sqlca_t *sqlca = ECPGget_sqlca();
676 ECPGinit_sqlca(sqlca);
677 new = (struct descriptor *) ECPGalloc(sizeof(struct descriptor), line);
680 new->next = get_descriptors();
681 new->name = ECPGalloc(strlen(name) + 1, line);
689 new->result = PQmakeEmptyPGresult(NULL, 0);
694 ECPGraise(line, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
697 strcpy(new->name, name);
698 set_descriptors(new);
702 /* Find descriptor with name in the connection. */
704 ECPGfind_desc(int line, const char *name)
706 struct descriptor *desc;
708 for (desc = get_descriptors(); desc; desc = desc->next)
710 if (strcmp(name, desc->name) == 0)
714 ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
715 return NULL; /* not found */
719 ECPGdescribe(int line, bool input, const char *statement,...)
721 ECPGlog("ECPGdescribe called on line %d for %s in %s\n", line, (input) ? "input" : "output", statement);