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_t *	ECPGget_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 volatile int	simple_debug = 0
static FILE *	debugstream = NULL
struct var_list *	ivlist = 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 351 of file misc.c.

{
    for (length--; length >= 0; length--)
        if (ptr[length] != 0xff)
            return false;
 
    return true;
}

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.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY,
                   NULL);
        return false;
    }
 
    ecpg_init_sqlca(sqlca);
    if (con == NULL)
    {
        ecpg_raise(lineno, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
                   connection_name ? connection_name : ecpg_gettext("NULL"));
        return false;
    }
 
    return true;
}

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(), fb(), 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.

{
    memcpy(sqlca, &sqlca_init, sizeof(struct sqlca_t));
}

References fb(), 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 232 of file misc.c.

{
    va_list     ap;
    const char *intl_format;
    int         bufsize;
    char       *fmt;
    struct sqlca_t *sqlca;
 
    /*
     * For performance reasons, inspect simple_debug without taking the mutex.
     * This could be problematic if fetching an int isn't atomic, but we
     * assume that it is in many other places too.
     */
    if (!simple_debug)
        return;
 
    /* localize the error message string */
    intl_format = ecpg_gettext(format);
 
    /*
     * Insert PID into the format, unless ecpg_internal_regression_mode is set
     * (regression tests want unchanging output).
     */
    bufsize = strlen(intl_format) + 100;
    fmt = (char *) malloc(bufsize);
    if (fmt == NULL)
        return;
 
    if (ecpg_internal_regression_mode)
        snprintf(fmt, bufsize, "[NO_PID]: %s", intl_format);
    else
        snprintf(fmt, bufsize, "[%d]: %s", (int) getpid(), intl_format);
 
    sqlca = ECPGget_sqlca();
 
    pthread_mutex_lock(&debug_mutex);
 
    /* Now that we hold the mutex, recheck simple_debug */
    if (simple_debug)
    {
        va_start(ap, format);
        vfprintf(debugstream, fmt, ap);
        va_end(ap);
 
        /* dump out internal sqlca variables */
        if (ecpg_internal_regression_mode && sqlca != NULL)
        {
            fprintf(debugstream, "[NO_PID]: sqlca: code: %ld, state: %s\n",
                    sqlca->sqlcode, sqlca->sqlstate);
        }
 
        fflush(debugstream);
    }
 
    pthread_mutex_unlock(&debug_mutex);
 
    free(fmt);
}

References bufsize, debug_mutex, debugstream, ecpg_gettext, ecpg_internal_regression_mode, ECPGget_sqlca(), fb(), format, fprintf, free, malloc, pthread_mutex_lock(), pthread_mutex_unlock(), simple_debug, snprintf, sqlca, 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.

{
    free(arg);                  /* sqlca structure allocated in ECPGget_sqlca */
}

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.

{
    pthread_key_create(&sqlca_key, ecpg_sqlca_key_destructor);
}

References ecpg_sqlca_key_destructor(), fb(), and sqlca_key.

Referenced by ECPGget_sqlca().

ECPGdebug()

void ECPGdebug	(	int	n,
		FILE *	dbgs
	)

Definition at line 204 of file misc.c.

{
    /* Interlock against concurrent executions of ECPGdebug() */
    pthread_mutex_lock(&debug_init_mutex);
 
    /* Prevent ecpg_log() from printing while we change settings */
    pthread_mutex_lock(&debug_mutex);
 
    if (n > 100)
    {
        ecpg_internal_regression_mode = true;
        simple_debug = n - 100;
    }
    else
        simple_debug = n;
 
    debugstream = dbgs;
 
    /* We must release debug_mutex before invoking ecpg_log() ... */
    pthread_mutex_unlock(&debug_mutex);
 
    /* ... but keep holding debug_init_mutex to avoid racy printout */
    ecpg_log("ECPGdebug: set to %d\n", simple_debug);
 
    pthread_mutex_unlock(&debug_init_mutex);
}

References debug_init_mutex, debug_mutex, debugstream, ecpg_internal_regression_mode, ecpg_log(), fb(), 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.

{
    struct sqlca_t *sqlca;
 
    pthread_once(&sqlca_key_once, ecpg_sqlca_key_init);
 
    sqlca = pthread_getspecific(sqlca_key);
    if (sqlca == NULL)
    {
        sqlca = malloc(sizeof(struct sqlca_t));
        if (sqlca == NULL)
            return NULL;
        ecpg_init_sqlca(sqlca);
        pthread_setspecific(sqlca_key, sqlca);
    }
    return sqlca;
}

References ecpg_init_sqlca(), ecpg_sqlca_key_init(), fb(), 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 593 of file misc.c.

{
    struct var_list *ptr;
 
    for (ptr = ivlist; ptr != NULL && ptr->number != number; ptr = ptr->next);
    return (ptr) ? ptr->pointer : NULL;
}

References fb(), 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 361 of file misc.c.

{
    switch (type)
    {
        case ECPGt_char:
        case ECPGt_unsigned_char:
        case ECPGt_string:
            if (*((const char *) ptr) == '\0')
                return true;
            break;
        case ECPGt_short:
        case ECPGt_unsigned_short:
            if (*((const short int *) ptr) == SHRT_MIN)
                return true;
            break;
        case ECPGt_int:
        case ECPGt_unsigned_int:
            if (*((const int *) ptr) == INT_MIN)
                return true;
            break;
        case ECPGt_long:
        case ECPGt_unsigned_long:
        case ECPGt_date:
            if (*((const long *) ptr) == LONG_MIN)
                return true;
            break;
        case ECPGt_long_long:
        case ECPGt_unsigned_long_long:
            if (*((const long long *) ptr) == LONG_LONG_MIN)
                return true;
            break;
        case ECPGt_float:
            return _check(ptr, sizeof(float));
            break;
        case ECPGt_double:
            return _check(ptr, sizeof(double));
            break;
        case ECPGt_varchar:
            if (*(((const struct ECPGgeneric_varchar *) ptr)->arr) == 0x00)
                return true;
            break;
        case ECPGt_bytea:
            if (((const struct ECPGgeneric_bytea *) ptr)->len == 0)
                return true;
            break;
        case ECPGt_decimal:
            if (((const decimal *) ptr)->sign == NUMERIC_NULL)
                return true;
            break;
        case ECPGt_numeric:
            if (((const numeric *) ptr)->sign == NUMERIC_NULL)
                return true;
            break;
        case ECPGt_interval:
            return _check(ptr, sizeof(interval));
            break;
        case ECPGt_timestamp:
            return _check(ptr, sizeof(timestamp));
            break;
        default:
            break;
    }
 
    return false;
}

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, fb(), 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 292 of file misc.c.

{
    switch (type)
    {
        case ECPGt_char:
        case ECPGt_unsigned_char:
        case ECPGt_string:
            *((char *) ptr) = '\0';
            break;
        case ECPGt_short:
        case ECPGt_unsigned_short:
            *((short int *) ptr) = SHRT_MIN;
            break;
        case ECPGt_int:
        case ECPGt_unsigned_int:
            *((int *) ptr) = INT_MIN;
            break;
        case ECPGt_long:
        case ECPGt_unsigned_long:
        case ECPGt_date:
            *((long *) ptr) = LONG_MIN;
            break;
        case ECPGt_long_long:
        case ECPGt_unsigned_long_long:
            *((long long *) ptr) = LONG_LONG_MIN;
            break;
        case ECPGt_float:
            memset(ptr, 0xff, sizeof(float));
            break;
        case ECPGt_double:
            memset(ptr, 0xff, sizeof(double));
            break;
        case ECPGt_varchar:
            *(((struct ECPGgeneric_varchar *) ptr)->arr) = 0x00;
            ((struct ECPGgeneric_varchar *) ptr)->len = 0;
            break;
        case ECPGt_bytea:
            ((struct ECPGgeneric_bytea *) ptr)->len = 0;
            break;
        case ECPGt_decimal:
            memset(ptr, 0, sizeof(decimal));
            ((decimal *) ptr)->sign = NUMERIC_NULL;
            break;
        case ECPGt_numeric:
            memset(ptr, 0, sizeof(numeric));
            ((numeric *) ptr)->sign = NUMERIC_NULL;
            break;
        case ECPGt_interval:
            memset(ptr, 0xff, sizeof(interval));
            break;
        case ECPGt_timestamp:
            memset(ptr, 0xff, sizeof(timestamp));
            break;
        default:
            break;
    }
}

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, fb(), 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 538 of file misc.c.

{
    struct var_list *ptr;
 
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return;
    }
 
    ecpg_init_sqlca(sqlca);
 
    for (ptr = ivlist; ptr != NULL; ptr = ptr->next)
    {
        if (ptr->number == number)
        {
            /* already known => just change pointer value */
            ptr->pointer = pointer;
            return;
        }
    }
 
    /* a new one has to be added */
    ptr = (struct var_list *) calloc(1L, sizeof(struct var_list));
    if (!ptr)
    {
        sqlca = ECPGget_sqlca();
 
        if (sqlca == NULL)
        {
            ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                       ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
            return;
        }
 
        sqlca->sqlcode = ECPG_OUT_OF_MEMORY;
        strncpy(sqlca->sqlstate, "YE001", sizeof(sqlca->sqlstate));
        snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "out of memory on line %d", lineno);
        sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
        /* free all memory we have allocated for the user */
        ECPGfree_auto_mem();
    }
    else
    {
        ptr->number = number;
        ptr->pointer = pointer;
        ptr->next = ivlist;
        ivlist = ptr;
    }
}

References calloc, ecpg_init_sqlca(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGfree_auto_mem(), ECPGget_sqlca(), fb(), 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.

{
    struct connection *con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    /* are we connected? */
    if (con->connection == NULL)
    {
        ecpg_raise(lineno, ECPG_NOT_CONN, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, con->name);
        return false;
    }
 
    return true;
}

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

ECPGtrans()

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

Definition at line 160 of file misc.c.

{
    PGresult   *res;
    struct connection *con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    ecpg_log("ECPGtrans on line %d: action \"%s\"; connection \"%s\"\n", lineno, transaction, con ? con->name : "null");
 
    /* if we have no connection we just simulate the command */
    if (con && con->connection)
    {
        /*
         * If we got a transaction command but have no open transaction, we
         * have to start one, unless we are in autocommit, where the
         * developers have to take care themselves. However, if the command is
         * a begin statement, we just execute it once. And if the command is
         * commit or rollback prepared, we don't execute it.
         */
        if (PQtransactionStatus(con->connection) == PQTRANS_IDLE &&
            !con->autocommit &&
            strncmp(transaction, "begin", 5) != 0 &&
            strncmp(transaction, "start", 5) != 0 &&
            strncmp(transaction, "commit prepared", 15) != 0 &&
            strncmp(transaction, "rollback prepared", 17) != 0)
        {
            res = PQexec(con->connection, "begin transaction");
            if (!ecpg_check_PQresult(res, lineno, con->connection, ECPG_COMPAT_PGSQL))
                return false;
            PQclear(res);
        }
 
        res = PQexec(con->connection, transaction);
        if (!ecpg_check_PQresult(res, lineno, con->connection, ECPG_COMPAT_PGSQL))
            return false;
        PQclear(res);
    }
 
    return true;
}

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

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

ECPGtransactionStatus()

PGTransactionStatusType ECPGtransactionStatus

(

const char *

connection_name

)

Definition at line 145 of file misc.c.

{
    const struct connection *con;
 
    con = ecpg_get_connection(connection_name);
    if (con == NULL)
    {
        /* transaction status is unknown */
        return PQTRANS_UNKNOWN;
    }
 
    return PQtransactionStatus(con->connection);
}

References connection::connection, ecpg_get_connection(), fb(), 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

pthread_mutex_t debug_mutex = PTHREAD_MUTEX_INITIALIZER

static

Definition at line 61 of file misc.c.

Referenced by ecpg_log(), and ECPGdebug().

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 535 of file misc.c.

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

simple_debug

volatile 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 31 of file misc.c.

{
    {
        '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'
    }
};

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().