PostgreSQL Source Code  git master
misc.c File Reference
#include "postgres_fe.h"
#include <limits.h>
#include <unistd.h>
#include "ecpg-pthread-win32.h"
#include "ecpgerrno.h"
#include "ecpglib.h"
#include "ecpglib_extern.h"
#include "ecpgtype.h"
#include "pg_config_paths.h"
#include "pgtypes_date.h"
#include "pgtypes_interval.h"
#include "pgtypes_numeric.h"
#include "pgtypes_timestamp.h"
#include "sqlca.h"
Include dependency graph for misc.c:

Go to the source code of this file.

Macros

#define POSTGRES_ECPG_INTERNAL
 
#define LONG_LONG_MIN   LONGLONG_MIN
 

Functions

void ecpg_init_sqlca (struct sqlca_t *sqlca)
 
bool ecpg_init (const struct connection *con, const char *connection_name, const int lineno)
 
static void ecpg_sqlca_key_destructor (void *arg)
 
static void ecpg_sqlca_key_init (void)
 
struct sqlca_tECPGget_sqlca (void)
 
bool ECPGstatus (int lineno, const char *connection_name)
 
PGTransactionStatusType ECPGtransactionStatus (const char *connection_name)
 
bool ECPGtrans (int lineno, const char *connection_name, const char *transaction)
 
void ECPGdebug (int n, FILE *dbgs)
 
void ecpg_log (const char *format,...)
 
void ECPGset_noind_null (enum ECPGttype type, void *ptr)
 
static bool _check (const unsigned char *ptr, int length)
 
bool ECPGis_noind_null (enum ECPGttype type, const void *ptr)
 
void ECPGset_var (int number, void *pointer, int lineno)
 
void * ECPGget_var (int number)
 

Variables

bool ecpg_internal_regression_mode = false
 
static struct sqlca_t sqlca_init
 
static pthread_key_t sqlca_key
 
static pthread_once_t sqlca_key_once = PTHREAD_ONCE_INIT
 
static pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER
 
static pthread_mutex_t debug_init_mutex = PTHREAD_MUTEX_INITIALIZER
 
static int simple_debug = 0
 
static FILE * debugstream = NULL
 
struct var_listivlist = NULL
 

Macro Definition Documentation

◆ LONG_LONG_MIN

#define LONG_LONG_MIN   LONGLONG_MIN

Definition at line 25 of file misc.c.

◆ POSTGRES_ECPG_INTERNAL

#define POSTGRES_ECPG_INTERNAL

Definition at line 3 of file misc.c.

Function Documentation

◆ _check()

static bool _check ( const unsigned char *  ptr,
int  length 
)
static

Definition at line 332 of file misc.c.

333 {
334  for (length--; length >= 0; length--)
335  if (ptr[length] != 0xff)
336  return false;
337 
338  return true;
339 }

Referenced by ECPGis_noind_null().

◆ ecpg_init()

bool ecpg_init ( const struct connection con,
const char *  connection_name,
const int  lineno 
)

Definition at line 73 of file misc.c.

74 {
75  struct sqlca_t *sqlca = ECPGget_sqlca();
76 
77  if (sqlca == NULL)
78  {
80  NULL);
81  return false;
82  }
83 
85  if (con == NULL)
86  {
88  connection_name ? connection_name : ecpg_gettext("NULL"));
89  return false;
90  }
91 
92  return true;
93 }
#define ECPG_OUT_OF_MEMORY
Definition: ecpgerrno.h:15
#define ECPG_NO_CONN
Definition: ecpgerrno.h:36
#define ecpg_gettext(x)
#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY
#define ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST
void ecpg_raise(int line, int code, const char *sqlstate, const char *str)
Definition: error.c:13
struct sqlca_t * ECPGget_sqlca(void)
Definition: misc.c:108
void ecpg_init_sqlca(struct sqlca_t *sqlca)
Definition: misc.c:67
#define sqlca
Definition: sqlca.h:59
Definition: sqlca.h:20

References ecpg_gettext, ecpg_init_sqlca(), ECPG_NO_CONN, ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGget_sqlca(), and sqlca.

Referenced by ecpg_do_prologue(), ECPGdeallocate(), ECPGdisconnect(), ECPGprepare(), ECPGsetcommit(), ECPGsetconn(), ECPGstatus(), and ECPGtrans().

◆ ecpg_init_sqlca()

void ecpg_init_sqlca ( struct sqlca_t sqlca)

Definition at line 67 of file misc.c.

68 {
69  memcpy((char *) sqlca, (char *) &sqlca_init, sizeof(struct sqlca_t));
70 }
static struct sqlca_t sqlca_init
Definition: misc.c:31

References sqlca, and sqlca_init.

Referenced by ecpg_init(), ECPGallocate_desc(), ECPGconnect(), ECPGdeallocate_desc(), ECPGdisconnect(), ECPGget_desc(), ECPGget_desc_header(), ECPGget_sqlca(), and ECPGset_var().

◆ ecpg_log()

void ecpg_log ( const char *  format,
  ... 
)

Definition at line 224 of file misc.c.

225 {
226  va_list ap;
227  struct sqlca_t *sqlca = ECPGget_sqlca();
228  const char *intl_format;
229  int bufsize;
230  char *fmt;
231 
232  if (!simple_debug)
233  return;
234 
235  /* localize the error message string */
236  intl_format = ecpg_gettext(format);
237 
238  /*
239  * Insert PID into the format, unless ecpg_internal_regression_mode is set
240  * (regression tests want unchanging output).
241  */
242  bufsize = strlen(intl_format) + 100;
243  fmt = (char *) malloc(bufsize);
244  if (fmt == NULL)
245  return;
246 
248  snprintf(fmt, bufsize, "[NO_PID]: %s", intl_format);
249  else
250  snprintf(fmt, bufsize, "[%d]: %s", (int) getpid(), intl_format);
251 
253 
254  va_start(ap, format);
255  vfprintf(debugstream, fmt, ap);
256  va_end(ap);
257 
258  /* dump out internal sqlca variables */
259  if (ecpg_internal_regression_mode && sqlca != NULL)
260  {
261  fprintf(debugstream, "[NO_PID]: sqlca: code: %ld, state: %s\n",
262  sqlca->sqlcode, sqlca->sqlstate);
263  }
264 
266 
268 
269  free(fmt);
270 }
#define free(a)
Definition: header.h:65
#define malloc(a)
Definition: header.h:50
#define bufsize
Definition: indent_globs.h:36
static int simple_debug
Definition: misc.c:63
static pthread_mutex_t debug_mutex
Definition: misc.c:61
static FILE * debugstream
Definition: misc.c:64
bool ecpg_internal_regression_mode
Definition: misc.c:29
static void const char * fmt
static void const char fflush(stdout)
va_end(args)
vfprintf(stderr, fmt, args)
va_start(args, fmt)
static char format
#define snprintf
Definition: port.h:238
#define fprintf
Definition: port.h:242
int pthread_mutex_unlock(pthread_mutex_t *mp)
Definition: pthread-win32.c:60
int pthread_mutex_lock(pthread_mutex_t *mp)
Definition: pthread-win32.c:42

References bufsize, debug_mutex, debugstream, ecpg_gettext, ecpg_internal_regression_mode, ECPGget_sqlca(), fflush(), fmt, format, fprintf, free, malloc, pthread_mutex_lock(), pthread_mutex_unlock(), simple_debug, snprintf, sqlca, va_end(), va_start(), and vfprintf().

Referenced by ECPGdebug(), and ECPGtrans().

◆ ecpg_sqlca_key_destructor()

static void ecpg_sqlca_key_destructor ( void *  arg)
static

Definition at line 96 of file misc.c.

97 {
98  free(arg); /* sqlca structure allocated in ECPGget_sqlca */
99 }
void * arg

References arg, and free.

Referenced by ecpg_sqlca_key_init().

◆ ecpg_sqlca_key_init()

static void ecpg_sqlca_key_init ( void  )
static

Definition at line 102 of file misc.c.

103 {
104  pthread_key_create(&sqlca_key, ecpg_sqlca_key_destructor);
105 }
static pthread_key_t sqlca_key
Definition: misc.c:58
static void ecpg_sqlca_key_destructor(void *arg)
Definition: misc.c:96

References ecpg_sqlca_key_destructor(), and sqlca_key.

Referenced by ECPGget_sqlca().

◆ ECPGdebug()

void ECPGdebug ( int  n,
FILE *  dbgs 
)

Definition at line 204 of file misc.c.

205 {
207 
208  if (n > 100)
209  {
211  simple_debug = n - 100;
212  }
213  else
214  simple_debug = n;
215 
216  debugstream = dbgs;
217 
218  ecpg_log("ECPGdebug: set to %d\n", simple_debug);
219 
221 }
static pthread_mutex_t debug_init_mutex
Definition: misc.c:62
void ecpg_log(const char *format,...)
Definition: misc.c:224

References debug_init_mutex, debugstream, ecpg_internal_regression_mode, ecpg_log(), pthread_mutex_lock(), pthread_mutex_unlock(), and simple_debug.

◆ ECPGget_sqlca()

struct sqlca_t* ECPGget_sqlca ( void  )

Definition at line 108 of file misc.c.

109 {
110  struct sqlca_t *sqlca;
111 
112  pthread_once(&sqlca_key_once, ecpg_sqlca_key_init);
113 
115  if (sqlca == NULL)
116  {
117  sqlca = malloc(sizeof(struct sqlca_t));
118  if (sqlca == NULL)
119  return NULL;
122  }
123  return sqlca;
124 }
static void ecpg_sqlca_key_init(void)
Definition: misc.c:102
static pthread_once_t sqlca_key_once
Definition: misc.c:59
void * pthread_getspecific(pthread_key_t key)
Definition: pthread-win32.c:29
void pthread_setspecific(pthread_key_t key, void *val)
Definition: pthread-win32.c:24

References ecpg_init_sqlca(), ecpg_sqlca_key_init(), malloc, pthread_getspecific(), pthread_setspecific(), sqlca, sqlca_key, and sqlca_key_once.

Referenced by ecpg_get_data(), ECPG_informix_reset_sqlca(), ecpg_init(), ecpg_log(), ecpg_process_output(), ecpg_raise(), ecpg_raise_backend(), ECPGallocate_desc(), ECPGconnect(), ECPGdeallocate_desc(), ECPGdisconnect(), ECPGget_desc(), ECPGget_desc_header(), ECPGnoticeReceiver(), ECPGset_var(), and sqlprint().

◆ ECPGget_var()

void* ECPGget_var ( int  number)

Definition at line 574 of file misc.c.

575 {
576  struct var_list *ptr;
577 
578  for (ptr = ivlist; ptr != NULL && ptr->number != number; ptr = ptr->next);
579  return (ptr) ? ptr->pointer : NULL;
580 }
struct var_list * ivlist
Definition: misc.c:516
struct var_list * next
void * pointer

References ivlist, var_list::next, var_list::number, and var_list::pointer.

Referenced by ECPG_informix_get_var(), get_record1(), open_cur1(), and openit().

◆ ECPGis_noind_null()

bool ECPGis_noind_null ( enum ECPGttype  type,
const void *  ptr 
)

Definition at line 342 of file misc.c.

343 {
344  switch (type)
345  {
346  case ECPGt_char:
347  case ECPGt_unsigned_char:
348  case ECPGt_string:
349  if (*((const char *) ptr) == '\0')
350  return true;
351  break;
352  case ECPGt_short:
354  if (*((const short int *) ptr) == SHRT_MIN)
355  return true;
356  break;
357  case ECPGt_int:
358  case ECPGt_unsigned_int:
359  if (*((const int *) ptr) == INT_MIN)
360  return true;
361  break;
362  case ECPGt_long:
363  case ECPGt_unsigned_long:
364  case ECPGt_date:
365  if (*((const long *) ptr) == LONG_MIN)
366  return true;
367  break;
368  case ECPGt_long_long:
370  if (*((const long long *) ptr) == LONG_LONG_MIN)
371  return true;
372  break;
373  case ECPGt_float:
374  return _check(ptr, sizeof(float));
375  break;
376  case ECPGt_double:
377  return _check(ptr, sizeof(double));
378  break;
379  case ECPGt_varchar:
380  if (*(((const struct ECPGgeneric_varchar *) ptr)->arr) == 0x00)
381  return true;
382  break;
383  case ECPGt_bytea:
384  if (((const struct ECPGgeneric_bytea *) ptr)->len == 0)
385  return true;
386  break;
387  case ECPGt_decimal:
388  if (((const decimal *) ptr)->sign == NUMERIC_NULL)
389  return true;
390  break;
391  case ECPGt_numeric:
392  if (((const numeric *) ptr)->sign == NUMERIC_NULL)
393  return true;
394  break;
395  case ECPGt_interval:
396  return _check(ptr, sizeof(interval));
397  break;
398  case ECPGt_timestamp:
399  return _check(ptr, sizeof(timestamp));
400  break;
401  default:
402  break;
403  }
404 
405  return false;
406 }
@ ECPGt_float
Definition: ecpgtype.h:47
@ ECPGt_long_long
Definition: ecpgtype.h:45
@ ECPGt_short
Definition: ecpgtype.h:43
@ ECPGt_decimal
Definition: ecpgtype.h:51
@ ECPGt_bytea
Definition: ecpgtype.h:67
@ ECPGt_numeric
Definition: ecpgtype.h:49
@ ECPGt_varchar
Definition: ecpgtype.h:48
@ ECPGt_timestamp
Definition: ecpgtype.h:54
@ ECPGt_unsigned_short
Definition: ecpgtype.h:43
@ ECPGt_int
Definition: ecpgtype.h:44
@ ECPGt_long
Definition: ecpgtype.h:44
@ ECPGt_unsigned_char
Definition: ecpgtype.h:43
@ ECPGt_double
Definition: ecpgtype.h:47
@ ECPGt_date
Definition: ecpgtype.h:53
@ ECPGt_interval
Definition: ecpgtype.h:55
@ ECPGt_unsigned_long
Definition: ecpgtype.h:44
@ ECPGt_unsigned_long_long
Definition: ecpgtype.h:45
@ ECPGt_unsigned_int
Definition: ecpgtype.h:44
@ ECPGt_char
Definition: ecpgtype.h:43
@ ECPGt_string
Definition: ecpgtype.h:65
char sign
Definition: informix.c:668
static bool _check(const unsigned char *ptr, int length)
Definition: misc.c:332
#define LONG_LONG_MIN
Definition: misc.c:25
const void size_t len
#define NUMERIC_NULL
int64 timestamp
const char * type

References _check(), ECPGgeneric_bytea::arr, ECPGt_bytea, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_numeric, ECPGt_short, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ECPGt_varchar, len, LONG_LONG_MIN, NUMERIC_NULL, sign, and type.

Referenced by ecpg_store_input(), and risnull().

◆ ECPGset_noind_null()

void ECPGset_noind_null ( enum ECPGttype  type,
void *  ptr 
)

Definition at line 273 of file misc.c.

274 {
275  switch (type)
276  {
277  case ECPGt_char:
278  case ECPGt_unsigned_char:
279  case ECPGt_string:
280  *((char *) ptr) = '\0';
281  break;
282  case ECPGt_short:
284  *((short int *) ptr) = SHRT_MIN;
285  break;
286  case ECPGt_int:
287  case ECPGt_unsigned_int:
288  *((int *) ptr) = INT_MIN;
289  break;
290  case ECPGt_long:
291  case ECPGt_unsigned_long:
292  case ECPGt_date:
293  *((long *) ptr) = LONG_MIN;
294  break;
295  case ECPGt_long_long:
297  *((long long *) ptr) = LONG_LONG_MIN;
298  break;
299  case ECPGt_float:
300  memset((char *) ptr, 0xff, sizeof(float));
301  break;
302  case ECPGt_double:
303  memset((char *) ptr, 0xff, sizeof(double));
304  break;
305  case ECPGt_varchar:
306  *(((struct ECPGgeneric_varchar *) ptr)->arr) = 0x00;
307  ((struct ECPGgeneric_varchar *) ptr)->len = 0;
308  break;
309  case ECPGt_bytea:
310  ((struct ECPGgeneric_bytea *) ptr)->len = 0;
311  break;
312  case ECPGt_decimal:
313  memset((char *) ptr, 0, sizeof(decimal));
314  ((decimal *) ptr)->sign = NUMERIC_NULL;
315  break;
316  case ECPGt_numeric:
317  memset((char *) ptr, 0, sizeof(numeric));
318  ((numeric *) ptr)->sign = NUMERIC_NULL;
319  break;
320  case ECPGt_interval:
321  memset((char *) ptr, 0xff, sizeof(interval));
322  break;
323  case ECPGt_timestamp:
324  memset((char *) ptr, 0xff, sizeof(timestamp));
325  break;
326  default:
327  break;
328  }
329 }

References ECPGt_bytea, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_numeric, ECPGt_short, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ECPGt_varchar, LONG_LONG_MIN, NUMERIC_NULL, and type.

Referenced by ecpg_get_data(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), and rsetnull().

◆ ECPGset_var()

void ECPGset_var ( int  number,
void *  pointer,
int  lineno 
)

Definition at line 519 of file misc.c.

520 {
521  struct var_list *ptr;
522 
523  struct sqlca_t *sqlca = ECPGget_sqlca();
524 
525  if (sqlca == NULL)
526  {
529  return;
530  }
531 
533 
534  for (ptr = ivlist; ptr != NULL; ptr = ptr->next)
535  {
536  if (ptr->number == number)
537  {
538  /* already known => just change pointer value */
539  ptr->pointer = pointer;
540  return;
541  }
542  }
543 
544  /* a new one has to be added */
545  ptr = (struct var_list *) calloc(1L, sizeof(struct var_list));
546  if (!ptr)
547  {
548  sqlca = ECPGget_sqlca();
549 
550  if (sqlca == NULL)
551  {
554  return;
555  }
556 
557  sqlca->sqlcode = ECPG_OUT_OF_MEMORY;
558  strncpy(sqlca->sqlstate, "YE001", sizeof(sqlca->sqlstate));
559  snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "out of memory on line %d", lineno);
560  sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
561  /* free all memory we have allocated for the user */
563  }
564  else
565  {
566  ptr->number = number;
567  ptr->pointer = pointer;
568  ptr->next = ivlist;
569  ivlist = ptr;
570  }
571 }
#define calloc(a, b)
Definition: header.h:55
void ECPGfree_auto_mem(void)
Definition: memory.c:131

References calloc, ecpg_init_sqlca(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGfree_auto_mem(), ECPGget_sqlca(), ivlist, var_list::next, var_list::number, var_list::pointer, snprintf, and sqlca.

Referenced by ECPG_informix_set_var(), get_var1(), and main().

◆ ECPGstatus()

bool ECPGstatus ( int  lineno,
const char *  connection_name 
)

Definition at line 127 of file misc.c.

128 {
129  struct connection *con = ecpg_get_connection(connection_name);
130 
131  if (!ecpg_init(con, connection_name, lineno))
132  return false;
133 
134  /* are we connected? */
135  if (con->connection == NULL)
136  {
138  return false;
139  }
140 
141  return true;
142 }
struct connection * ecpg_get_connection(const char *connection_name)
Definition: connect.c:71
#define ECPG_NOT_CONN
Definition: ecpgerrno.h:37
#define ECPG_SQLSTATE_ECPG_INTERNAL_ERROR
bool ecpg_init(const struct connection *con, const char *connection_name, const int lineno)
Definition: misc.c:73
PGconn * connection

References connection::connection, ecpg_get_connection(), ecpg_init(), ECPG_NOT_CONN, ecpg_raise(), ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, and connection::name.

◆ ECPGtrans()

bool ECPGtrans ( int  lineno,
const char *  connection_name,
const char *  transaction 
)

Definition at line 160 of file misc.c.

161 {
162  PGresult *res;
163  struct connection *con = ecpg_get_connection(connection_name);
164 
165  if (!ecpg_init(con, connection_name, lineno))
166  return false;
167 
168  ecpg_log("ECPGtrans on line %d: action \"%s\"; connection \"%s\"\n", lineno, transaction, con ? con->name : "null");
169 
170  /* if we have no connection we just simulate the command */
171  if (con && con->connection)
172  {
173  /*
174  * If we got a transaction command but have no open transaction, we
175  * have to start one, unless we are in autocommit, where the
176  * developers have to take care themselves. However, if the command is
177  * a begin statement, we just execute it once. And if the command is
178  * commit or rollback prepared, we don't execute it.
179  */
181  !con->autocommit &&
182  strncmp(transaction, "begin", 5) != 0 &&
183  strncmp(transaction, "start", 5) != 0 &&
184  strncmp(transaction, "commit prepared", 15) != 0 &&
185  strncmp(transaction, "rollback prepared", 17) != 0)
186  {
187  res = PQexec(con->connection, "begin transaction");
189  return false;
190  PQclear(res);
191  }
192 
193  res = PQexec(con->connection, transaction);
195  return false;
196  PQclear(res);
197  }
198 
199  return true;
200 }
bool ecpg_check_PQresult(PGresult *results, int lineno, PGconn *connection, enum COMPAT_MODE compat)
Definition: error.c:281
@ ECPG_COMPAT_PGSQL
PGTransactionStatusType PQtransactionStatus(const PGconn *conn)
Definition: fe-connect.c:6796
PGresult * PQexec(PGconn *conn, const char *query)
Definition: fe-exec.c:2224
@ PQTRANS_IDLE
Definition: libpq-fe.h:118

References connection::autocommit, connection::connection, ecpg_check_PQresult(), ECPG_COMPAT_PGSQL, ecpg_get_connection(), ecpg_init(), ecpg_log(), connection::name, PQclear(), PQexec(), PQTRANS_IDLE, PQtransactionStatus(), and res.

Referenced by commitTable(), main(), sql_check(), and test_thread().

◆ ECPGtransactionStatus()

PGTransactionStatusType ECPGtransactionStatus ( const char *  connection_name)

Definition at line 145 of file misc.c.

146 {
147  const struct connection *con;
148 
149  con = ecpg_get_connection(connection_name);
150  if (con == NULL)
151  {
152  /* transaction status is unknown */
153  return PQTRANS_UNKNOWN;
154  }
155 
156  return PQtransactionStatus(con->connection);
157 }
@ PQTRANS_UNKNOWN
Definition: libpq-fe.h:122

References connection::connection, ecpg_get_connection(), PQTRANS_UNKNOWN, and PQtransactionStatus().

Variable Documentation

◆ debug_init_mutex

pthread_mutex_t debug_init_mutex = PTHREAD_MUTEX_INITIALIZER
static

Definition at line 62 of file misc.c.

Referenced by ECPGdebug().

◆ debug_mutex

Definition at line 61 of file misc.c.

Referenced by ecpg_log().

◆ debugstream

FILE* debugstream = NULL
static

Definition at line 64 of file misc.c.

Referenced by ecpg_log(), and ECPGdebug().

◆ ecpg_internal_regression_mode

bool ecpg_internal_regression_mode = false

Definition at line 29 of file misc.c.

Referenced by ecpg_get_data(), ecpg_log(), ECPGconnect(), and ECPGdebug().

◆ ivlist

struct var_list* ivlist = NULL

Definition at line 516 of file misc.c.

Referenced by ecpg_finish(), ECPGget_var(), and ECPGset_var().

◆ simple_debug

int simple_debug = 0
static

Definition at line 63 of file misc.c.

Referenced by ecpg_log(), and ECPGdebug().

◆ sqlca_init

struct sqlca_t sqlca_init
static
Initial value:
=
{
{
'S', 'Q', 'L', 'C', 'A', ' ', ' ', ' '
},
sizeof(struct sqlca_t),
0,
{
0,
{
0
}
},
{
'N', 'O', 'T', ' ', 'S', 'E', 'T', ' '
},
{
0, 0, 0, 0, 0, 0
},
{
0, 0, 0, 0, 0, 0, 0, 0
},
{
'0', '0', '0', '0', '0'
}
}

Definition at line 29 of file misc.c.

Referenced by ecpg_init_sqlca().

◆ sqlca_key

pthread_key_t sqlca_key
static

Definition at line 58 of file misc.c.

Referenced by ecpg_sqlca_key_init(), and ECPGget_sqlca().

◆ sqlca_key_once

pthread_once_t sqlca_key_once = PTHREAD_ONCE_INIT
static

Definition at line 59 of file misc.c.

Referenced by ECPGget_sqlca().