PostgreSQL Source Code  git master
descriptor.c File Reference
#include "postgres_fe.h"
#include "catalog/pg_type_d.h"
#include "ecpg-pthread-win32.h"
#include "ecpgtype.h"
#include "ecpglib.h"
#include "ecpgerrno.h"
#include "ecpglib_extern.h"
#include "sqlca.h"
#include "sqlda.h"
#include "sql3types.h"
Include dependency graph for descriptor.c:

Go to the source code of this file.

Macros

#define POSTGRES_ECPG_INTERNAL
 
#define get_descriptors()   (all_descriptors)
 
#define set_descriptors(value)   do { all_descriptors = (value); } while(0)
 
#define RETURN_IF_NO_DATA
 

Functions

static void descriptor_free (struct descriptor *desc)
 
static PGresultecpg_result_by_descriptor (int line, const char *name)
 
static unsigned int ecpg_dynamic_type_DDT (Oid type)
 
bool ECPGget_desc_header (int lineno, const char *desc_name, int *count)
 
static bool get_int_item (int lineno, void *var, enum ECPGttype vartype, int value)
 
static bool set_int_item (int lineno, int *target, const void *var, enum ECPGttype vartype)
 
static bool get_char_item (int lineno, void *var, enum ECPGttype vartype, char *value, int varcharsize)
 
bool ECPGget_desc (int lineno, const char *desc_name, int index,...)
 
bool ECPGset_desc_header (int lineno, const char *desc_name, int count)
 
static void set_desc_attr (struct descriptor_item *desc_item, struct variable *var, char *tobeinserted)
 
bool ECPGset_desc (int lineno, const char *desc_name, int index,...)
 
bool ECPGdeallocate_desc (int line, const char *name)
 
bool ECPGallocate_desc (int line, const char *name)
 
struct descriptorecpg_find_desc (int line, const char *name)
 
bool ECPGdescribe (int line, int compat, bool input, const char *connection_name, const char *stmt_name,...)
 

Variables

static struct descriptorall_descriptors = NULL
 

Macro Definition Documentation

◆ get_descriptors

#define get_descriptors ( )    (all_descriptors)

Definition at line 56 of file descriptor.c.

Referenced by ecpg_find_desc(), ECPGallocate_desc(), and ECPGdeallocate_desc().

◆ POSTGRES_ECPG_INTERNAL

#define POSTGRES_ECPG_INTERNAL

Definition at line 6 of file descriptor.c.

◆ RETURN_IF_NO_DATA

#define RETURN_IF_NO_DATA
Value:
if (ntuples < 1) \
{ \
va_end(args); \
ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL); \
return false; \
}
#define ECPG_SQLSTATE_NO_DATA
#define ECPG_NOT_FOUND
Definition: ecpgerrno.h:10

Definition at line 238 of file descriptor.c.

Referenced by ECPGget_desc().

◆ set_descriptors

#define set_descriptors (   value)    do { all_descriptors = (value); } while(0)

Definition at line 57 of file descriptor.c.

Referenced by ECPGallocate_desc(), and ECPGdeallocate_desc().

Function Documentation

◆ descriptor_free()

static void descriptor_free ( struct descriptor desc)
static

Definition at line 735 of file descriptor.c.

References descriptor_item::data, ecpg_free(), descriptor::items, descriptor::name, descriptor_item::next, PQclear(), and descriptor::result.

Referenced by ECPGdeallocate_desc().

736 {
737  struct descriptor_item *desc_item;
738 
739  for (desc_item = desc->items; desc_item;)
740  {
741  struct descriptor_item *di;
742 
743  ecpg_free(desc_item->data);
744  di = desc_item;
745  desc_item = desc_item->next;
746  ecpg_free(di);
747  }
748 
749  ecpg_free(desc->name);
750  PQclear(desc->result);
751  ecpg_free(desc);
752 }
void ecpg_free(void *)
Definition: memory.c:13
PGresult * result
void PQclear(PGresult *res)
Definition: fe-exec.c:695
struct descriptor_item * items
struct descriptor_item * next

◆ ecpg_dynamic_type_DDT()

static unsigned int ecpg_dynamic_type_DDT ( Oid  type)
static

Definition at line 72 of file descriptor.c.

References SQL3_DDT_DATE, SQL3_DDT_ILLEGAL, SQL3_DDT_TIME, SQL3_DDT_TIME_WITH_TIME_ZONE, SQL3_DDT_TIMESTAMP, and SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE.

Referenced by ECPGget_desc().

73 {
74  switch (type)
75  {
76  case DATEOID:
77  return SQL3_DDT_DATE;
78  case TIMEOID:
79  return SQL3_DDT_TIME;
80  case TIMESTAMPOID:
81  return SQL3_DDT_TIMESTAMP;
82  case TIMESTAMPTZOID:
84  case TIMETZOID:
86  default:
87  return SQL3_DDT_ILLEGAL;
88  }
89 }

◆ ecpg_find_desc()

struct descriptor* ecpg_find_desc ( int  line,
const char *  name 
)

Definition at line 842 of file descriptor.c.

References ecpg_raise(), ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, ECPG_UNKNOWN_DESCRIPTOR, get_descriptors, descriptor::name, and descriptor::next.

Referenced by ecpg_build_params(), ecpg_process_output(), ecpg_result_by_descriptor(), ECPGdescribe(), ECPGset_desc(), and ECPGset_desc_header().

843 {
844  struct descriptor *desc;
845 
846  for (desc = get_descriptors(); desc; desc = desc->next)
847  {
848  if (strcmp(name, desc->name) == 0)
849  return desc;
850  }
851 
853  return NULL; /* not found */
854 }
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME
struct descriptor * next
#define ECPG_UNKNOWN_DESCRIPTOR
Definition: ecpgerrno.h:42
const char * name
Definition: encode.c:521
#define get_descriptors()
Definition: descriptor.c:56

◆ ecpg_result_by_descriptor()

static PGresult* ecpg_result_by_descriptor ( int  line,
const char *  name 
)
static

Definition at line 62 of file descriptor.c.

References ecpg_find_desc(), and descriptor::result.

Referenced by ECPGget_desc(), and ECPGget_desc_header().

63 {
64  struct descriptor *desc = ecpg_find_desc(line, name);
65 
66  if (desc == NULL)
67  return NULL;
68  return desc->result;
69 }
struct descriptor * ecpg_find_desc(int line, const char *name)
Definition: descriptor.c:842
PGresult * result
const char * name
Definition: encode.c:521

◆ ECPGallocate_desc()

bool ECPGallocate_desc ( int  line,
const char *  name 
)

Definition at line 802 of file descriptor.c.

References ecpg_alloc(), ecpg_free(), ecpg_init_sqlca(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGget_sqlca(), get_descriptors, PQmakeEmptyPGresult(), set_descriptors, and sqlca.

Referenced by fn(), and main().

803 {
804  struct descriptor *new;
805  struct sqlca_t *sqlca = ECPGget_sqlca();
806 
807  if (sqlca == NULL)
808  {
811  return false;
812  }
813 
814  ecpg_init_sqlca(sqlca);
815  new = (struct descriptor *) ecpg_alloc(sizeof(struct descriptor), line);
816  if (!new)
817  return false;
818  new->next = get_descriptors();
819  new->name = ecpg_alloc(strlen(name) + 1, line);
820  if (!new->name)
821  {
822  ecpg_free(new);
823  return false;
824  }
825  new->count = -1;
826  new->items = NULL;
827  new->result = PQmakeEmptyPGresult(NULL, 0);
828  if (!new->result)
829  {
830  ecpg_free(new->name);
831  ecpg_free(new);
833  return false;
834  }
835  strcpy(new->name, name);
836  set_descriptors(new);
837  return true;
838 }
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define sqlca
Definition: sqlca.h:59
#define set_descriptors(value)
Definition: descriptor.c:57
void ecpg_free(void *)
Definition: memory.c:13
#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY
#define ECPG_OUT_OF_MEMORY
Definition: ecpgerrno.h:15
struct sqlca_t * ECPGget_sqlca(void)
Definition: misc.c:142
Definition: sqlca.h:19
PGresult * PQmakeEmptyPGresult(PGconn *conn, ExecStatusType status)
Definition: fe-exec.c:142
char * ecpg_alloc(long, int)
Definition: memory.c:19
void ecpg_init_sqlca(struct sqlca_t *sqlca)
Definition: misc.c:99
const char * name
Definition: encode.c:521
#define get_descriptors()
Definition: descriptor.c:56

◆ ECPGdeallocate_desc()

bool ECPGdeallocate_desc ( int  line,
const char *  name 
)

Definition at line 755 of file descriptor.c.

References descriptor_free(), ecpg_init_sqlca(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, ECPG_UNKNOWN_DESCRIPTOR, ECPGget_sqlca(), get_descriptors, sort-test::list, descriptor::next, next, set_descriptors, and sqlca.

Referenced by fn(), and main().

756 {
757  struct descriptor *desc;
758  struct descriptor *prev;
759  struct sqlca_t *sqlca = ECPGget_sqlca();
760 
761  if (sqlca == NULL)
762  {
765  return false;
766  }
767 
768  ecpg_init_sqlca(sqlca);
769  for (desc = get_descriptors(), prev = NULL; desc; prev = desc, desc = desc->next)
770  {
771  if (strcmp(name, desc->name) == 0)
772  {
773  if (prev)
774  prev->next = desc->next;
775  else
776  set_descriptors(desc->next);
777  descriptor_free(desc);
778  return true;
779  }
780  }
782  return false;
783 }
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define sqlca
Definition: sqlca.h:59
#define set_descriptors(value)
Definition: descriptor.c:57
#define ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME
#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY
#define ECPG_OUT_OF_MEMORY
Definition: ecpgerrno.h:15
struct descriptor * next
struct sqlca_t * ECPGget_sqlca(void)
Definition: misc.c:142
Definition: sqlca.h:19
void ecpg_init_sqlca(struct sqlca_t *sqlca)
Definition: misc.c:99
#define ECPG_UNKNOWN_DESCRIPTOR
Definition: ecpgerrno.h:42
static void descriptor_free(struct descriptor *desc)
Definition: descriptor.c:735
const char * name
Definition: encode.c:521
#define get_descriptors()
Definition: descriptor.c:56

◆ ECPGdescribe()

bool ECPGdescribe ( int  line,
int  compat,
bool  input,
const char *  connection_name,
const char *  stmt_name,
  ... 
)

Definition at line 857 of file descriptor.c.

References generate_unaccent_rules::args, connection::connection, sqlda_struct::desc_next, sqlda_compat::desc_next, ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_check_PQresult(), ecpg_find_desc(), ecpg_find_prepared_statement(), ecpg_get_connection(), ecpg_gettext, ECPG_INVALID_STMT, ECPG_NO_CONN, ecpg_raise(), ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, ECPG_UNSUPPORTED, ECPGt_descriptor, ECPGt_EORT, ECPGt_sqlda, free, INFORMIX_MODE, name, PQclear(), PQdescribePrepared(), descriptor::result, and generate_unaccent_rules::type.

Referenced by main().

858 {
859  bool ret = false;
860  struct connection *con;
861  struct prepared_statement *prep;
862  PGresult *res;
863  va_list args;
864 
865  /* DESCRIBE INPUT is not yet supported */
866  if (input)
867  {
869  return ret;
870  }
871 
872  con = ecpg_get_connection(connection_name);
873  if (!con)
874  {
876  connection_name ? connection_name : ecpg_gettext("NULL"));
877  return ret;
878  }
879  prep = ecpg_find_prepared_statement(stmt_name, con, NULL);
880  if (!prep)
881  {
883  return ret;
884  }
885 
886  va_start(args, stmt_name);
887 
888  for (;;)
889  {
890  enum ECPGttype type;
891  void *ptr;
892 
893  /* variable type */
894  type = va_arg(args, enum ECPGttype);
895 
896  if (type == ECPGt_EORT)
897  break;
898 
899  /* rest of variable parameters */
900  ptr = va_arg(args, void *);
901  (void) va_arg(args, long); /* skip args */
902  (void) va_arg(args, long);
903  (void) va_arg(args, long);
904 
905  /* variable indicator */
906  (void) va_arg(args, enum ECPGttype);
907  (void) va_arg(args, void *); /* skip args */
908  (void) va_arg(args, long);
909  (void) va_arg(args, long);
910  (void) va_arg(args, long);
911 
912  switch (type)
913  {
914  case ECPGt_descriptor:
915  {
916  char *name = ptr;
917  struct descriptor *desc = ecpg_find_desc(line, name);
918 
919  if (desc == NULL)
920  break;
921 
922  res = PQdescribePrepared(con->connection, stmt_name);
923  if (!ecpg_check_PQresult(res, line, con->connection, compat))
924  break;
925 
926  if (desc->result != NULL)
927  PQclear(desc->result);
928 
929  desc->result = res;
930  ret = true;
931  break;
932  }
933  case ECPGt_sqlda:
934  {
935  if (INFORMIX_MODE(compat))
936  {
937  struct sqlda_compat **_sqlda = ptr;
938  struct sqlda_compat *sqlda;
939 
940  res = PQdescribePrepared(con->connection, stmt_name);
941  if (!ecpg_check_PQresult(res, line, con->connection, compat))
942  break;
943 
944  sqlda = ecpg_build_compat_sqlda(line, res, -1, compat);
945  if (sqlda)
946  {
947  struct sqlda_compat *sqlda_old = *_sqlda;
948  struct sqlda_compat *sqlda_old1;
949 
950  while (sqlda_old)
951  {
952  sqlda_old1 = sqlda_old->desc_next;
953  free(sqlda_old);
954  sqlda_old = sqlda_old1;
955  }
956 
957  *_sqlda = sqlda;
958  ret = true;
959  }
960 
961  PQclear(res);
962  }
963  else
964  {
965  struct sqlda_struct **_sqlda = ptr;
966  struct sqlda_struct *sqlda;
967 
968  res = PQdescribePrepared(con->connection, stmt_name);
969  if (!ecpg_check_PQresult(res, line, con->connection, compat))
970  break;
971 
972  sqlda = ecpg_build_native_sqlda(line, res, -1, compat);
973  if (sqlda)
974  {
975  struct sqlda_struct *sqlda_old = *_sqlda;
976  struct sqlda_struct *sqlda_old1;
977 
978  while (sqlda_old)
979  {
980  sqlda_old1 = sqlda_old->desc_next;
981  free(sqlda_old);
982  sqlda_old = sqlda_old1;
983  }
984 
985  *_sqlda = sqlda;
986  ret = true;
987  }
988 
989  PQclear(res);
990  }
991  break;
992  }
993  default:
994  /* nothing else may come */
995  ;
996  }
997  }
998 
999  va_end(args);
1000 
1001  return ret;
1002 }
PGresult * PQdescribePrepared(PGconn *conn, const char *stmt)
Definition: fe-exec.c:2157
struct sqlda_struct * desc_next
Definition: sqlda-native.h:39
#define ECPG_SQLSTATE_ECPG_INTERNAL_ERROR
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define ECPG_INVALID_STMT
Definition: ecpgerrno.h:39
Definition: type.h:102
#define INFORMIX_MODE(X)
struct sqlda_compat * desc_next
Definition: sqlda-compat.h:43
#define ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST
struct descriptor * ecpg_find_desc(int line, const char *name)
Definition: descriptor.c:842
struct sqlda_struct * ecpg_build_native_sqlda(int, PGresult *, int, enum COMPAT_MODE)
Definition: sqlda.c:413
PGresult * result
#define ECPG_UNSUPPORTED
Definition: ecpgerrno.h:18
struct sqlda_compat * ecpg_build_compat_sqlda(int, PGresult *, int, enum COMPAT_MODE)
Definition: sqlda.c:206
enum COMPAT_MODE compat
Definition: ecpg.c:25
#define ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME
struct prepared_statement * ecpg_find_prepared_statement(const char *, struct connection *, struct prepared_statement **)
Definition: prepare.c:239
#define ecpg_gettext(x)
Definition: ecpglib.h:18
void PQclear(PGresult *res)
Definition: fe-exec.c:695
#define free(a)
Definition: header.h:65
bool ecpg_check_PQresult(PGresult *, int, PGconn *, enum COMPAT_MODE)
Definition: error.c:283
PGconn * connection
const char * name
Definition: encode.c:521
struct connection * ecpg_get_connection(const char *connection_name)
Definition: connect.c:74
#define ECPG_NO_CONN
Definition: ecpgerrno.h:36
ECPGttype
Definition: ecpgtype.h:41

◆ ECPGget_desc()

bool ECPGget_desc ( int  lineno,
const char *  desc_name,
int  index,
  ... 
)

Definition at line 246 of file descriptor.c.

References generate_unaccent_rules::args, variable::arrsize, statement::connection, ecpg_auto_alloc(), ecpg_dynamic_type(), ecpg_dynamic_type_DDT(), ecpg_free(), ecpg_get_connection(), ecpg_init_sqlca(), ECPG_INVALID_DESCRIPTOR_INDEX, ecpg_log(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ecpg_result_by_descriptor(), ECPG_SQLSTATE_CARDINALITY_VIOLATION, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX, ecpg_store_result(), ecpg_strdup(), ECPG_TOO_MANY_MATCHES, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPGd_cardinality, ECPGd_data, ECPGd_di_code, ECPGd_EODT, ECPGd_indicator, ECPGd_key_member, ECPGd_length, ECPGd_name, ECPGd_nullable, ECPGd_octet, ECPGd_precision, ECPGd_ret_length, ECPGd_ret_octet, ECPGd_scale, ECPGd_type, ECPGget_sqlca(), ECPGt_EORT, ECPGt_NO_INDICATOR, get_char_item(), get_int_item(), variable::ind_arrsize, variable::ind_offset, variable::ind_pointer, variable::ind_type, variable::ind_value, variable::ind_varcharsize, statement::lineno, locale_t, variable::offset, statement::oldlocale, variable::pointer, PQfmod(), PQfname(), PQfsize(), PQftype(), PQgetisnull(), PQgetlength(), PQnfields(), PQntuples(), RETURN_IF_NO_DATA, setlocale, snprintf, sqlca, sqlca_t::sqlerrd, variable::type, generate_unaccent_rules::type, variable::value, variable::varcharsize, and VARHDRSZ.

Referenced by main().

247 {
248  va_list args;
249  PGresult *ECPGresult;
250  enum ECPGdtype type;
251  int ntuples,
252  act_tuple;
253  struct variable data_var;
254  struct sqlca_t *sqlca = ECPGget_sqlca();
255 
256  if (sqlca == NULL)
257  {
260  return false;
261  }
262 
263  va_start(args, index);
264  ecpg_init_sqlca(sqlca);
265  ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
266  if (!ECPGresult)
267  {
268  va_end(args);
269  return false;
270  }
271 
272  ntuples = PQntuples(ECPGresult);
273 
274  if (index < 1 || index > PQnfields(ECPGresult))
275  {
277  va_end(args);
278  return false;
279  }
280 
281  ecpg_log("ECPGget_desc: reading items for tuple %d\n", index);
282  --index;
283 
284  type = va_arg(args, enum ECPGdtype);
285 
286  memset(&data_var, 0, sizeof data_var);
287  data_var.type = ECPGt_EORT;
288  data_var.ind_type = ECPGt_NO_INDICATOR;
289 
290  while (type != ECPGd_EODT)
291  {
292  char type_str[20];
293  long varcharsize;
294  long offset;
295  long arrsize;
296  enum ECPGttype vartype;
297  void *var;
298 
299  vartype = va_arg(args, enum ECPGttype);
300  var = va_arg(args, void *);
301  varcharsize = va_arg(args, long);
302  arrsize = va_arg(args, long);
303  offset = va_arg(args, long);
304 
305  switch (type)
306  {
307  case (ECPGd_indicator):
309  data_var.ind_type = vartype;
310  data_var.ind_pointer = var;
311  data_var.ind_varcharsize = varcharsize;
312  data_var.ind_arrsize = arrsize;
313  data_var.ind_offset = offset;
314  if (data_var.ind_arrsize == 0 || data_var.ind_varcharsize == 0)
315  data_var.ind_value = *((void **) (data_var.ind_pointer));
316  else
317  data_var.ind_value = data_var.ind_pointer;
318  break;
319 
320  case ECPGd_data:
322  data_var.type = vartype;
323  data_var.pointer = var;
324  data_var.varcharsize = varcharsize;
325  data_var.arrsize = arrsize;
326  data_var.offset = offset;
327  if (data_var.arrsize == 0 || data_var.varcharsize == 0)
328  data_var.value = *((void **) (data_var.pointer));
329  else
330  data_var.value = data_var.pointer;
331  break;
332 
333  case ECPGd_name:
334  if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
335  {
336  va_end(args);
337  return false;
338  }
339 
340  ecpg_log("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
341  break;
342 
343  case ECPGd_nullable:
344  if (!get_int_item(lineno, var, vartype, 1))
345  {
346  va_end(args);
347  return false;
348  }
349 
350  break;
351 
352  case ECPGd_key_member:
353  if (!get_int_item(lineno, var, vartype, 0))
354  {
355  va_end(args);
356  return false;
357  }
358 
359  break;
360 
361  case ECPGd_scale:
362  if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
363  {
364  va_end(args);
365  return false;
366  }
367 
368  ecpg_log("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
369  break;
370 
371  case ECPGd_precision:
372  if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
373  {
374  va_end(args);
375  return false;
376  }
377 
378  ecpg_log("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
379  break;
380 
381  case ECPGd_octet:
382  if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
383  {
384  va_end(args);
385  return false;
386  }
387 
388  ecpg_log("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
389  break;
390 
391  case ECPGd_length:
392  if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
393  {
394  va_end(args);
395  return false;
396  }
397 
398  ecpg_log("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
399  break;
400 
401  case ECPGd_type:
402  if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type(PQftype(ECPGresult, index))))
403  {
404  va_end(args);
405  return false;
406  }
407 
408  ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type(PQftype(ECPGresult, index)));
409  break;
410 
411  case ECPGd_di_code:
412  if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type_DDT(PQftype(ECPGresult, index))))
413  {
414  va_end(args);
415  return false;
416  }
417 
418  ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type_DDT(PQftype(ECPGresult, index)));
419  break;
420 
421  case ECPGd_cardinality:
422  if (!get_int_item(lineno, var, vartype, PQntuples(ECPGresult)))
423  {
424  va_end(args);
425  return false;
426  }
427 
428  ecpg_log("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));
429  break;
430 
431  case ECPGd_ret_length:
432  case ECPGd_ret_octet:
433 
435 
436  /*
437  * this is like ECPGstore_result
438  */
439  if (arrsize > 0 && ntuples > arrsize)
440  {
441  ecpg_log("ECPGget_desc on line %d: incorrect number of matches; %d don't fit into array of %ld\n",
442  lineno, ntuples, arrsize);
444  va_end(args);
445  return false;
446  }
447  /* allocate storage if needed */
448  if (arrsize == 0 && *(void **) var == NULL)
449  {
450  void *mem = (void *) ecpg_auto_alloc(offset * ntuples, lineno);
451 
452  if (!mem)
453  {
454  va_end(args);
455  return false;
456  }
457  *(void **) var = mem;
458  var = mem;
459  }
460 
461  for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
462  {
463  if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, act_tuple, index)))
464  {
465  va_end(args);
466  return false;
467  }
468  var = (char *) var + offset;
469  ecpg_log("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));
470  }
471  break;
472 
473  default:
474  snprintf(type_str, sizeof(type_str), "%d", type);
476  va_end(args);
477  return false;
478  }
479 
480  type = va_arg(args, enum ECPGdtype);
481  }
482 
483  if (data_var.type != ECPGt_EORT)
484  {
485  struct statement stmt;
486 
487  memset(&stmt, 0, sizeof stmt);
488  stmt.lineno = lineno;
489 
490  /* Make sure we do NOT honor the locale for numeric input */
491  /* since the database gives the standard decimal point */
492  /* (see comments in execute.c) */
493 #ifdef HAVE_USELOCALE
494  stmt.clocale = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
495  if (stmt.clocale != (locale_t) 0)
496  stmt.oldlocale = uselocale(stmt.clocale);
497 #else
498 #ifdef HAVE__CONFIGTHREADLOCALE
499  stmt.oldthreadlocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
500 #endif
501  stmt.oldlocale = ecpg_strdup(setlocale(LC_NUMERIC, NULL), lineno);
502  setlocale(LC_NUMERIC, "C");
503 #endif
504 
505  /* desperate try to guess something sensible */
506  stmt.connection = ecpg_get_connection(NULL);
507  ecpg_store_result(ECPGresult, index, &stmt, &data_var);
508 
509 #ifdef HAVE_USELOCALE
510  if (stmt.oldlocale != (locale_t) 0)
511  uselocale(stmt.oldlocale);
512  if (stmt.clocale)
513  freelocale(stmt.clocale);
514 #else
515  if (stmt.oldlocale)
516  {
517  setlocale(LC_NUMERIC, stmt.oldlocale);
518  ecpg_free(stmt.oldlocale);
519  }
520 #ifdef HAVE__CONFIGTHREADLOCALE
521  if (stmt.oldthreadlocale != -1)
522  (void) _configthreadlocale(stmt.oldthreadlocale);
523 #endif
524 #endif
525  }
526  else if (data_var.ind_type != ECPGt_NO_INDICATOR && data_var.ind_pointer != NULL)
527 
528  /*
529  * ind_type != NO_INDICATOR should always have ind_pointer != NULL but
530  * since this might be changed manually in the .c file let's play it
531  * safe
532  */
533  {
534  /*
535  * this is like ECPGstore_result but since we don't have a data
536  * variable at hand, we can't call it
537  */
538  if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)
539  {
540  ecpg_log("ECPGget_desc on line %d: incorrect number of matches (indicator); %d don't fit into array of %ld\n",
541  lineno, ntuples, data_var.ind_arrsize);
543  va_end(args);
544  return false;
545  }
546 
547  /* allocate storage if needed */
548  if (data_var.ind_arrsize == 0 && data_var.ind_value == NULL)
549  {
550  void *mem = (void *) ecpg_auto_alloc(data_var.ind_offset * ntuples, lineno);
551 
552  if (!mem)
553  {
554  va_end(args);
555  return false;
556  }
557  *(void **) data_var.ind_pointer = mem;
558  data_var.ind_value = mem;
559  }
560 
561  for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
562  {
563  if (!get_int_item(lineno, data_var.ind_value, data_var.ind_type, -PQgetisnull(ECPGresult, act_tuple, index)))
564  {
565  va_end(args);
566  return false;
567  }
568  data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;
569  ecpg_log("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));
570  }
571  }
572  sqlca->sqlerrd[2] = ntuples;
573  va_end(args);
574  return true;
575 }
int PQgetlength(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3175
static bool get_char_item(int lineno, void *var, enum ECPGttype vartype, char *value, int varcharsize)
Definition: descriptor.c:206
int PQnfields(const PGresult *res)
Definition: fe-exec.c:2778
#define setlocale(a, b)
Definition: win32_port.h:408
int PQfsize(const PGresult *res, int field_num)
Definition: fe-exec.c:3019
#define ECPG_SQLSTATE_ECPG_INTERNAL_ERROR
char * PQfname(const PGresult *res, int field_num)
Definition: fe-exec.c:2856
static bool get_int_item(int lineno, void *var, enum ECPGttype vartype, int value)
Definition: descriptor.c:116
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
int ecpg_dynamic_type(Oid)
Definition: typename.c:74
#define sqlca
Definition: sqlca.h:59
#define VARHDRSZ
Definition: c.h:555
void ecpg_free(void *)
Definition: memory.c:13
char * ecpg_strdup(const char *, int)
Definition: memory.c:47
#define ECPG_INVALID_DESCRIPTOR_INDEX
Definition: ecpgerrno.h:43
#define ECPG_UNKNOWN_DESCRIPTOR_ITEM
Definition: ecpgerrno.h:44
#define ECPG_SQLSTATE_CARDINALITY_VIOLATION
int PQntuples(const PGresult *res)
Definition: fe-exec.c:2770
#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY
Definition: type.h:89
#define ECPG_TOO_MANY_MATCHES
Definition: ecpgerrno.h:21
char * ecpg_auto_alloc(long, int)
Definition: memory.c:108
#define ECPG_OUT_OF_MEMORY
Definition: ecpgerrno.h:15
struct sqlca_t * ECPGget_sqlca(void)
Definition: misc.c:142
static PGresult * ecpg_result_by_descriptor(int line, const char *name)
Definition: descriptor.c:62
Definition: sqlca.h:19
Oid PQftype(const PGresult *res, int field_num)
Definition: fe-exec.c:3008
#define ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX
long sqlerrd[6]
Definition: sqlca.h:30
#define locale_t
Definition: win32_port.h:363
void ecpg_log(const char *format,...) pg_attribute_printf(1
void ecpg_init_sqlca(struct sqlca_t *sqlca)
Definition: misc.c:99
ECPGdtype
Definition: ecpgtype.h:71
bool ecpg_store_result(const PGresult *results, int act_field, const struct statement *stmt, struct variable *var)
Definition: execute.c:307
int PQfmod(const PGresult *res, int field_num)
Definition: fe-exec.c:3030
struct connection * ecpg_get_connection(const char *connection_name)
Definition: connect.c:74
static unsigned int ecpg_dynamic_type_DDT(Oid type)
Definition: descriptor.c:72
int PQgetisnull(const PGresult *res, int tup_num, int field_num)
Definition: fe-exec.c:3189
#define RETURN_IF_NO_DATA
Definition: descriptor.c:238
#define snprintf
Definition: port.h:192
ECPGttype
Definition: ecpgtype.h:41

◆ ECPGget_desc_header()

bool ECPGget_desc_header ( int  lineno,
const char *  desc_name,
int *  count 
)

Definition at line 92 of file descriptor.c.

References ecpg_init_sqlca(), ecpg_log(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ecpg_result_by_descriptor(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGget_sqlca(), PQnfields(), sqlca, and sqlca_t::sqlerrd.

Referenced by main().

93 {
94  PGresult *ECPGresult;
95  struct sqlca_t *sqlca = ECPGget_sqlca();
96 
97  if (sqlca == NULL)
98  {
101  return false;
102  }
103 
104  ecpg_init_sqlca(sqlca);
105  ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
106  if (!ECPGresult)
107  return false;
108 
109  *count = PQnfields(ECPGresult);
110  sqlca->sqlerrd[2] = 1;
111  ecpg_log("ECPGget_desc_header: found %d attributes\n", *count);
112  return true;
113 }
int PQnfields(const PGresult *res)
Definition: fe-exec.c:2778
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define sqlca
Definition: sqlca.h:59
#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY
#define ECPG_OUT_OF_MEMORY
Definition: ecpgerrno.h:15
struct sqlca_t * ECPGget_sqlca(void)
Definition: misc.c:142
static PGresult * ecpg_result_by_descriptor(int line, const char *name)
Definition: descriptor.c:62
Definition: sqlca.h:19
long sqlerrd[6]
Definition: sqlca.h:30
void ecpg_log(const char *format,...) pg_attribute_printf(1
void ecpg_init_sqlca(struct sqlca_t *sqlca)
Definition: misc.c:99

◆ ECPGset_desc()

bool ECPGset_desc ( int  lineno,
const char *  desc_name,
int  index,
  ... 
)

Definition at line 612 of file descriptor.c.

References generate_unaccent_rules::args, variable::arrsize, descriptor::count, ecpg_alloc(), ecpg_find_desc(), ecpg_free(), ecpg_raise(), ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ecpg_store_input(), ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPGd_data, ECPGd_EODT, ECPGd_indicator, ECPGd_length, ECPGd_precision, ECPGd_scale, ECPGd_type, descriptor_item::indicator, descriptor::items, descriptor_item::length, descriptor_item::next, variable::next, descriptor_item::num, variable::offset, variable::pointer, descriptor_item::precision, descriptor_item::scale, set_desc_attr(), set_int_item(), snprintf, descriptor_item::type, variable::type, variable::value, and variable::varcharsize.

Referenced by main().

613 {
614  va_list args;
615  struct descriptor *desc;
616  struct descriptor_item *desc_item;
617  struct variable *var;
618 
619  desc = ecpg_find_desc(lineno, desc_name);
620  if (desc == NULL)
621  return false;
622 
623  for (desc_item = desc->items; desc_item; desc_item = desc_item->next)
624  {
625  if (desc_item->num == index)
626  break;
627  }
628 
629  if (desc_item == NULL)
630  {
631  desc_item = (struct descriptor_item *) ecpg_alloc(sizeof(*desc_item), lineno);
632  if (!desc_item)
633  return false;
634  desc_item->num = index;
635  if (desc->count < index)
636  desc->count = index;
637  desc_item->next = desc->items;
638  desc->items = desc_item;
639  }
640 
641  if (!(var = (struct variable *) ecpg_alloc(sizeof(struct variable), lineno)))
642  return false;
643 
644  va_start(args, index);
645 
646  for (;;)
647  {
648  enum ECPGdtype itemtype;
649  char *tobeinserted = NULL;
650 
651  itemtype = va_arg(args, enum ECPGdtype);
652 
653  if (itemtype == ECPGd_EODT)
654  break;
655 
656  var->type = va_arg(args, enum ECPGttype);
657  var->pointer = va_arg(args, char *);
658 
659  var->varcharsize = va_arg(args, long);
660  var->arrsize = va_arg(args, long);
661  var->offset = va_arg(args, long);
662 
663  if (var->arrsize == 0 || var->varcharsize == 0)
664  var->value = *((char **) (var->pointer));
665  else
666  var->value = var->pointer;
667 
668  /*
669  * negative values are used to indicate an array without given bounds
670  */
671  /* reset to zero for us */
672  if (var->arrsize < 0)
673  var->arrsize = 0;
674  if (var->varcharsize < 0)
675  var->varcharsize = 0;
676 
677  var->next = NULL;
678 
679  switch (itemtype)
680  {
681  case ECPGd_data:
682  {
683  if (!ecpg_store_input(lineno, true, var, &tobeinserted, false))
684  {
685  ecpg_free(var);
686  va_end(args);
687  return false;
688  }
689 
690  set_desc_attr(desc_item, var, tobeinserted);
691  tobeinserted = NULL;
692  break;
693  }
694 
695  case ECPGd_indicator:
696  set_int_item(lineno, &desc_item->indicator, var->pointer, var->type);
697  break;
698 
699  case ECPGd_length:
700  set_int_item(lineno, &desc_item->length, var->pointer, var->type);
701  break;
702 
703  case ECPGd_precision:
704  set_int_item(lineno, &desc_item->precision, var->pointer, var->type);
705  break;
706 
707  case ECPGd_scale:
708  set_int_item(lineno, &desc_item->scale, var->pointer, var->type);
709  break;
710 
711  case ECPGd_type:
712  set_int_item(lineno, &desc_item->type, var->pointer, var->type);
713  break;
714 
715  default:
716  {
717  char type_str[20];
718 
719  snprintf(type_str, sizeof(type_str), "%d", itemtype);
721  ecpg_free(var);
722  va_end(args);
723  return false;
724  }
725  }
726  }
727  ecpg_free(var);
728  va_end(args);
729 
730  return true;
731 }
bool ecpg_store_input(const int, const bool, const struct variable *, char **, bool)
Definition: execute.c:510
static bool set_int_item(int lineno, int *target, const void *var, enum ECPGttype vartype)
Definition: descriptor.c:161
#define ECPG_SQLSTATE_ECPG_INTERNAL_ERROR
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
void ecpg_free(void *)
Definition: memory.c:13
void * pointer
#define ECPG_UNKNOWN_DESCRIPTOR_ITEM
Definition: ecpgerrno.h:44
enum ECPGttype type
struct variable * next
Definition: type.h:89
struct descriptor * ecpg_find_desc(int line, const char *name)
Definition: descriptor.c:842
void * value
char * ecpg_alloc(long, int)
Definition: memory.c:19
ECPGdtype
Definition: ecpgtype.h:71
struct descriptor_item * items
struct descriptor_item * next
static void set_desc_attr(struct descriptor_item *desc_item, struct variable *var, char *tobeinserted)
Definition: descriptor.c:591
#define snprintf
Definition: port.h:192
long varcharsize
ECPGttype
Definition: ecpgtype.h:41

◆ ECPGset_desc_header()

bool ECPGset_desc_header ( int  lineno,
const char *  desc_name,
int  count 
)

Definition at line 580 of file descriptor.c.

References descriptor::count, and ecpg_find_desc().

Referenced by main().

581 {
582  struct descriptor *desc = ecpg_find_desc(lineno, desc_name);
583 
584  if (desc == NULL)
585  return false;
586  desc->count = count;
587  return true;
588 }
struct descriptor * ecpg_find_desc(int line, const char *name)
Definition: descriptor.c:842

◆ get_char_item()

static bool get_char_item ( int  lineno,
void *  var,
enum ECPGttype  vartype,
char *  value,
int  varcharsize 
)
static

Definition at line 206 of file descriptor.c.

References ECPGgeneric_varchar::arr, ecpg_raise(), ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, ECPG_VAR_NOT_CHAR, ECPGt_char, ECPGt_string, ECPGt_unsigned_char, ECPGt_varchar, and ECPGgeneric_varchar::len.

Referenced by ECPGget_desc().

207 {
208  switch (vartype)
209  {
210  case ECPGt_char:
211  case ECPGt_unsigned_char:
212  case ECPGt_string:
213  strncpy((char *) var, value, varcharsize);
214  break;
215  case ECPGt_varchar:
216  {
217  struct ECPGgeneric_varchar *variable =
218  (struct ECPGgeneric_varchar *) var;
219 
220  if (varcharsize == 0)
221  memcpy(variable->arr, value, strlen(value));
222  else
223  strncpy(variable->arr, value, varcharsize);
224 
225  variable->len = strlen(value);
226  if (varcharsize > 0 && variable->len > varcharsize)
227  variable->len = varcharsize;
228  }
229  break;
230  default:
232  return false;
233  }
234 
235  return true;
236 }
char arr[FLEXIBLE_ARRAY_MEMBER]
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define ECPG_VAR_NOT_CHAR
Definition: ecpgerrno.h:46
static struct @145 value
#define ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION

◆ get_int_item()

static bool get_int_item ( int  lineno,
void *  var,
enum ECPGttype  vartype,
int  value 
)
static

Definition at line 116 of file descriptor.c.

References ecpg_raise(), ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, ECPG_VAR_NOT_NUMERIC, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_long, ECPGt_long_long, ECPGt_short, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, and value.

Referenced by ECPGget_desc().

117 {
118  switch (vartype)
119  {
120  case ECPGt_short:
121  *(short *) var = (short) value;
122  break;
123  case ECPGt_int:
124  *(int *) var = (int) value;
125  break;
126  case ECPGt_long:
127  *(long *) var = (long) value;
128  break;
130  *(unsigned short *) var = (unsigned short) value;
131  break;
132  case ECPGt_unsigned_int:
133  *(unsigned int *) var = (unsigned int) value;
134  break;
135  case ECPGt_unsigned_long:
136  *(unsigned long *) var = (unsigned long) value;
137  break;
138 #ifdef HAVE_LONG_LONG_INT
139  case ECPGt_long_long:
140  *(long long int *) var = (long long int) value;
141  break;
143  *(unsigned long long int *) var = (unsigned long long int) value;
144  break;
145 #endif /* HAVE_LONG_LONG_INT */
146  case ECPGt_float:
147  *(float *) var = (float) value;
148  break;
149  case ECPGt_double:
150  *(double *) var = (double) value;
151  break;
152  default:
154  return false;
155  }
156 
157  return true;
158 }
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
static struct @145 value
#define ECPG_VAR_NOT_NUMERIC
Definition: ecpgerrno.h:45
#define ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION

◆ set_desc_attr()

static void set_desc_attr ( struct descriptor_item desc_item,
struct variable var,
char *  tobeinserted 
)
static

Definition at line 591 of file descriptor.c.

References descriptor_item::data, descriptor_item::data_len, ecpg_free(), ECPGt_bytea, descriptor_item::is_binary, ECPGgeneric_varchar::len, variable::type, and variable::value.

Referenced by ECPGset_desc().

593 {
594  if (var->type != ECPGt_bytea)
595  desc_item->is_binary = false;
596 
597  else
598  {
599  struct ECPGgeneric_varchar *variable =
600  (struct ECPGgeneric_varchar *) (var->value);
601 
602  desc_item->is_binary = true;
603  desc_item->data_len = variable->len;
604  }
605 
606  ecpg_free(desc_item->data); /* free() takes care of a potential NULL value */
607  desc_item->data = (char *) tobeinserted;
608 }
void ecpg_free(void *)
Definition: memory.c:13
enum ECPGttype type
void * value

◆ set_int_item()

static bool set_int_item ( int  lineno,
int *  target,
const void *  var,
enum ECPGttype  vartype 
)
static

Definition at line 161 of file descriptor.c.

References ecpg_raise(), ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, ECPG_VAR_NOT_NUMERIC, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_long, ECPGt_long_long, ECPGt_short, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, and ECPGt_unsigned_short.

Referenced by ECPGset_desc().

162 {
163  switch (vartype)
164  {
165  case ECPGt_short:
166  *target = *(const short *) var;
167  break;
168  case ECPGt_int:
169  *target = *(const int *) var;
170  break;
171  case ECPGt_long:
172  *target = *(const long *) var;
173  break;
175  *target = *(const unsigned short *) var;
176  break;
177  case ECPGt_unsigned_int:
178  *target = *(const unsigned int *) var;
179  break;
180  case ECPGt_unsigned_long:
181  *target = *(const unsigned long *) var;
182  break;
183 #ifdef HAVE_LONG_LONG_INT
184  case ECPGt_long_long:
185  *target = *(const long long int *) var;
186  break;
188  *target = *(const unsigned long long int *) var;
189  break;
190 #endif /* HAVE_LONG_LONG_INT */
191  case ECPGt_float:
192  *target = *(const float *) var;
193  break;
194  case ECPGt_double:
195  *target = *(const double *) var;
196  break;
197  default:
199  return false;
200  }
201 
202  return true;
203 }
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
#define ECPG_VAR_NOT_NUMERIC
Definition: ecpgerrno.h:45
#define ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION

Variable Documentation

◆ all_descriptors

struct descriptor* all_descriptors = NULL
static

Definition at line 54 of file descriptor.c.