descriptor.c File Reference

#include "postgres_fe.h"
#include "catalog/pg_type_d.h"
#include "ecpg-pthread-win32.h"
#include "ecpgerrno.h"
#include "ecpglib.h"
#include "ecpglib_extern.h"
#include "ecpgtype.h"
#include "sql3types.h"
#include "sqlca.h"
#include "sqlda.h"

Include dependency graph for descriptor.c:

Go to the source code of this file.

Macros
#define	POSTGRES_ECPG_INTERNAL
#define	RETURN_IF_NO_DATA

Functions
static void	descriptor_free (struct descriptor *desc)
static void	descriptor_deallocate_all (struct descriptor *list)
static void	descriptor_destructor (void *arg)
static void	descriptor_key_init (void)
static struct descriptor *	get_descriptors (void)
static void	set_descriptors (struct descriptor *value)
static PGresult *	ecpg_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 descriptor *	ecpg_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 pthread_key_t	descriptor_key
static pthread_once_t	descriptor_once = PTHREAD_ONCE_INIT

Macro Definition Documentation

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; \
                }

Definition at line 226 of file descriptor.c.

Function Documentation

descriptor_deallocate_all()

static void descriptor_deallocate_all ( struct descriptor *  list )

static

Definition at line 780 of file descriptor.c.

{
    while (list)
    {
        struct descriptor *next = list->next;
 
        descriptor_free(list);
        list = next;
    }
}

References descriptor_free(), sort-test::list, and next.

Referenced by descriptor_destructor().

descriptor_destructor()

static void descriptor_destructor ( void *  arg )

static

Definition at line 28 of file descriptor.c.

{
    descriptor_deallocate_all(arg);
}

References arg, and descriptor_deallocate_all().

Referenced by descriptor_key_init().

descriptor_free()

static void descriptor_free ( struct descriptor *  desc )

static

Definition at line 728 of file descriptor.c.

{
    struct descriptor_item *desc_item;
 
    for (desc_item = desc->items; desc_item;)
    {
        struct descriptor_item *di;
 
        ecpg_free(desc_item->data);
        di = desc_item;
        desc_item = desc_item->next;
        ecpg_free(di);
    }
 
    ecpg_free(desc->name);
    PQclear(desc->result);
    ecpg_free(desc);
}

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

Referenced by descriptor_deallocate_all(), and ECPGdeallocate_desc().

descriptor_key_init()

static void descriptor_key_init ( void  )

static

Definition at line 34 of file descriptor.c.

{
    pthread_key_create(&descriptor_key, descriptor_destructor);
}

References descriptor_destructor(), and descriptor_key.

Referenced by get_descriptors().

ecpg_dynamic_type_DDT()

static unsigned int ecpg_dynamic_type_DDT ( Oid  type )

static

Definition at line 64 of file descriptor.c.

{
    switch (type)
    {
        case DATEOID:
            return SQL3_DDT_DATE;
        case TIMEOID:
            return SQL3_DDT_TIME;
        case TIMESTAMPOID:
            return SQL3_DDT_TIMESTAMP;
        case TIMESTAMPTZOID:
            return SQL3_DDT_TIMESTAMP_WITH_TIME_ZONE;
        case TIMETZOID:
            return SQL3_DDT_TIME_WITH_TIME_ZONE;
        default:
            return SQL3_DDT_ILLEGAL;
    }
}

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

Referenced by ECPGget_desc().

ecpg_find_desc()

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

Definition at line 832 of file descriptor.c.

{
    struct descriptor *desc;
 
    for (desc = get_descriptors(); desc; desc = desc->next)
    {
        if (strcmp(name, desc->name) == 0)
            return desc;
    }
 
    ecpg_raise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
    return NULL;                /* not found */
}

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

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

ecpg_result_by_descriptor()

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

static

Definition at line 54 of file descriptor.c.

{
    struct descriptor *desc = ecpg_find_desc(line, name);
 
    if (desc == NULL)
        return NULL;
    return desc->result;
}

References ecpg_find_desc(), name, and descriptor::result.

Referenced by ECPGget_desc(), and ECPGget_desc_header().

ECPGallocate_desc()

bool ECPGallocate_desc	(	int	line,
		const char *	name
	)

Definition at line 792 of file descriptor.c.

{
    struct descriptor *new;
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_raise(line, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    ecpg_init_sqlca(sqlca);
    new = (struct descriptor *) ecpg_alloc(sizeof(struct descriptor), line);
    if (!new)
        return false;
    new->next = get_descriptors();
    new->name = ecpg_alloc(strlen(name) + 1, line);
    if (!new->name)
    {
        ecpg_free(new);
        return false;
    }
    new->count = -1;
    new->items = NULL;
    new->result = PQmakeEmptyPGresult(NULL, 0);
    if (!new->result)
    {
        ecpg_free(new->name);
        ecpg_free(new);
        ecpg_raise(line, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
    strcpy(new->name, name);
    set_descriptors(new);
    return true;
}

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

Referenced by execute_test(), fn(), and main().

ECPGdeallocate_desc()

bool ECPGdeallocate_desc	(	int	line,
		const char *	name
	)

Definition at line 748 of file descriptor.c.

{
    struct descriptor *desc;
    struct descriptor *prev;
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_raise(line, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    ecpg_init_sqlca(sqlca);
    for (desc = get_descriptors(), prev = NULL; desc; prev = desc, desc = desc->next)
    {
        if (strcmp(name, desc->name) == 0)
        {
            if (prev)
                prev->next = desc->next;
            else
                set_descriptors(desc->next);
            descriptor_free(desc);
            return true;
        }
    }
    ecpg_raise(line, ECPG_UNKNOWN_DESCRIPTOR, ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME, name);
    return false;
}

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(), name, descriptor::name, descriptor::next, set_descriptors(), and sqlca.

Referenced by execute_test(), fn(), and main().

ECPGdescribe()

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

Definition at line 847 of file descriptor.c.

{
    bool        ret = false;
    struct connection *con;
    struct prepared_statement *prep;
    PGresult   *res;
    va_list     args;
 
    /* DESCRIBE INPUT is not yet supported */
    if (input)
    {
        ecpg_raise(line, ECPG_UNSUPPORTED, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, "DESCRIBE INPUT");
        return ret;
    }
 
    con = ecpg_get_connection(connection_name);
    if (!con)
    {
        ecpg_raise(line, ECPG_NO_CONN, ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST,
                   connection_name ? connection_name : ecpg_gettext("NULL"));
        return ret;
    }
    prep = ecpg_find_prepared_statement(stmt_name, con, NULL);
    if (!prep)
    {
        ecpg_raise(line, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, stmt_name);
        return ret;
    }
 
    va_start(args, stmt_name);
 
    for (;;)
    {
        enum ECPGttype type;
        void       *ptr;
 
        /* variable type */
        type = va_arg(args, enum ECPGttype);
 
        if (type == ECPGt_EORT)
            break;
 
        /* rest of variable parameters */
        ptr = va_arg(args, void *);
        (void) va_arg(args, long);  /* skip args */
        (void) va_arg(args, long);
        (void) va_arg(args, long);
 
        /* variable indicator */
        (void) va_arg(args, enum ECPGttype);
        (void) va_arg(args, void *);    /* skip args */
        (void) va_arg(args, long);
        (void) va_arg(args, long);
        (void) va_arg(args, long);
 
        switch (type)
        {
            case ECPGt_descriptor:
                {
                    char       *name = ptr;
                    struct descriptor *desc = ecpg_find_desc(line, name);
 
                    if (desc == NULL)
                        break;
 
                    res = PQdescribePrepared(con->connection, stmt_name);
                    if (!ecpg_check_PQresult(res, line, con->connection, compat))
                        break;
 
                    PQclear(desc->result);
 
                    desc->result = res;
                    ret = true;
                    break;
                }
            case ECPGt_sqlda:
                {
                    if (INFORMIX_MODE(compat))
                    {
                        struct sqlda_compat **_sqlda = ptr;
                        struct sqlda_compat *sqlda;
 
                        res = PQdescribePrepared(con->connection, stmt_name);
                        if (!ecpg_check_PQresult(res, line, con->connection, compat))
                            break;
 
                        sqlda = ecpg_build_compat_sqlda(line, res, -1, compat);
                        if (sqlda)
                        {
                            struct sqlda_compat *sqlda_old = *_sqlda;
                            struct sqlda_compat *sqlda_old1;
 
                            while (sqlda_old)
                            {
                                sqlda_old1 = sqlda_old->desc_next;
                                free(sqlda_old);
                                sqlda_old = sqlda_old1;
                            }
 
                            *_sqlda = sqlda;
                            ret = true;
                        }
 
                        PQclear(res);
                    }
                    else
                    {
                        struct sqlda_struct **_sqlda = ptr;
                        struct sqlda_struct *sqlda;
 
                        res = PQdescribePrepared(con->connection, stmt_name);
                        if (!ecpg_check_PQresult(res, line, con->connection, compat))
                            break;
 
                        sqlda = ecpg_build_native_sqlda(line, res, -1, compat);
                        if (sqlda)
                        {
                            struct sqlda_struct *sqlda_old = *_sqlda;
                            struct sqlda_struct *sqlda_old1;
 
                            while (sqlda_old)
                            {
                                sqlda_old1 = sqlda_old->desc_next;
                                free(sqlda_old);
                                sqlda_old = sqlda_old1;
                            }
 
                            *_sqlda = sqlda;
                            ret = true;
                        }
 
                        PQclear(res);
                    }
                    break;
                }
            default:
                /* nothing else may come */
                ;
        }
    }
 
    va_end(args);
 
    return ret;
}

References generate_unaccent_rules::args, compat, connection::connection, sqlda_compat::desc_next, sqlda_struct::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, input, name, PQclear(), PQdescribePrepared(), res, descriptor::result, type, va_end(), and va_start().

Referenced by execute_test(), and main().

ECPGget_desc()

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

Definition at line 234 of file descriptor.c.

{
    va_list     args;
    PGresult   *ECPGresult;
    enum ECPGdtype type;
    int         ntuples,
                act_tuple;
    struct variable data_var;
    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;
    }
 
    va_start(args, index);
    ecpg_init_sqlca(sqlca);
    ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
    if (!ECPGresult)
    {
        va_end(args);
        return false;
    }
 
    ntuples = PQntuples(ECPGresult);
 
    if (index < 1 || index > PQnfields(ECPGresult))
    {
        ecpg_raise(lineno, ECPG_INVALID_DESCRIPTOR_INDEX, ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX, NULL);
        va_end(args);
        return false;
    }
 
    ecpg_log("ECPGget_desc: reading items for tuple %d\n", index);
    --index;
 
    type = va_arg(args, enum ECPGdtype);
 
    memset(&data_var, 0, sizeof data_var);
    data_var.type = ECPGt_EORT;
    data_var.ind_type = ECPGt_NO_INDICATOR;
 
    while (type != ECPGd_EODT)
    {
        char        type_str[20];
        long        varcharsize;
        long        offset;
        long        arrsize;
        enum ECPGttype vartype;
        void       *var;
 
        vartype = va_arg(args, enum ECPGttype);
        var = va_arg(args, void *);
        varcharsize = va_arg(args, long);
        arrsize = va_arg(args, long);
        offset = va_arg(args, long);
 
        switch (type)
        {
            case (ECPGd_indicator):
                RETURN_IF_NO_DATA;
                data_var.ind_type = vartype;
                data_var.ind_pointer = var;
                data_var.ind_varcharsize = varcharsize;
                data_var.ind_arrsize = arrsize;
                data_var.ind_offset = offset;
                if (data_var.ind_arrsize == 0 || data_var.ind_varcharsize == 0)
                    data_var.ind_value = *((void **) (data_var.ind_pointer));
                else
                    data_var.ind_value = data_var.ind_pointer;
                break;
 
            case ECPGd_data:
                RETURN_IF_NO_DATA;
                data_var.type = vartype;
                data_var.pointer = var;
                data_var.varcharsize = varcharsize;
                data_var.arrsize = arrsize;
                data_var.offset = offset;
                if (data_var.arrsize == 0 || data_var.varcharsize == 0)
                    data_var.value = *((void **) (data_var.pointer));
                else
                    data_var.value = data_var.pointer;
                break;
 
            case ECPGd_name:
                if (!get_char_item(lineno, var, vartype, PQfname(ECPGresult, index), varcharsize))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: NAME = %s\n", PQfname(ECPGresult, index));
                break;
 
            case ECPGd_nullable:
                if (!get_int_item(lineno, var, vartype, 1))
                {
                    va_end(args);
                    return false;
                }
 
                break;
 
            case ECPGd_key_member:
                if (!get_int_item(lineno, var, vartype, 0))
                {
                    va_end(args);
                    return false;
                }
 
                break;
 
            case ECPGd_scale:
                if (!get_int_item(lineno, var, vartype, (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: SCALE = %d\n", (PQfmod(ECPGresult, index) - VARHDRSZ) & 0xffff);
                break;
 
            case ECPGd_precision:
                if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) >> 16))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);
                break;
 
            case ECPGd_octet:
                if (!get_int_item(lineno, var, vartype, PQfsize(ECPGresult, index)))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: OCTET_LENGTH = %d\n", PQfsize(ECPGresult, index));
                break;
 
            case ECPGd_length:
                if (!get_int_item(lineno, var, vartype, PQfmod(ECPGresult, index) - VARHDRSZ))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: LENGTH = %d\n", PQfmod(ECPGresult, index) - VARHDRSZ);
                break;
 
            case ECPGd_type:
                if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type(PQftype(ECPGresult, index))))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type(PQftype(ECPGresult, index)));
                break;
 
            case ECPGd_di_code:
                if (!get_int_item(lineno, var, vartype, ecpg_dynamic_type_DDT(PQftype(ECPGresult, index))))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: TYPE = %d\n", ecpg_dynamic_type_DDT(PQftype(ECPGresult, index)));
                break;
 
            case ECPGd_cardinality:
                if (!get_int_item(lineno, var, vartype, PQntuples(ECPGresult)))
                {
                    va_end(args);
                    return false;
                }
 
                ecpg_log("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));
                break;
 
            case ECPGd_ret_length:
            case ECPGd_ret_octet:
 
                RETURN_IF_NO_DATA;
 
                /*
                 * this is like ECPGstore_result
                 */
                if (arrsize > 0 && ntuples > arrsize)
                {
                    ecpg_log("ECPGget_desc on line %d: incorrect number of matches; %d don't fit into array of %ld\n",
                             lineno, ntuples, arrsize);
                    ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
                    va_end(args);
                    return false;
                }
                /* allocate storage if needed */
                if (arrsize == 0 && *(void **) var == NULL)
                {
                    void       *mem = (void *) ecpg_auto_alloc(offset * ntuples, lineno);
 
                    if (!mem)
                    {
                        va_end(args);
                        return false;
                    }
                    *(void **) var = mem;
                    var = mem;
                }
 
                for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
                {
                    if (!get_int_item(lineno, var, vartype, PQgetlength(ECPGresult, act_tuple, index)))
                    {
                        va_end(args);
                        return false;
                    }
                    var = (char *) var + offset;
                    ecpg_log("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));
                }
                break;
 
            default:
                snprintf(type_str, sizeof(type_str), "%d", type);
                ecpg_raise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
                va_end(args);
                return false;
        }
 
        type = va_arg(args, enum ECPGdtype);
    }
 
    if (data_var.type != ECPGt_EORT)
    {
        struct statement stmt;
 
        memset(&stmt, 0, sizeof stmt);
        stmt.lineno = lineno;
 
        /* Make sure we do NOT honor the locale for numeric input */
        /* since the database gives the standard decimal point */
        /* (see comments in execute.c) */
#ifdef HAVE_USELOCALE
 
        /*
         * To get here, the above PQnfields() test must have found nonzero
         * fields.  One needs a connection to create such a descriptor.  (EXEC
         * SQL SET DESCRIPTOR can populate the descriptor's "items", but it
         * can't change the descriptor's PQnfields().)  Any successful
         * connection initializes ecpg_clocale.
         */
        Assert(ecpg_clocale);
        stmt.oldlocale = uselocale(ecpg_clocale);
#else
#ifdef HAVE__CONFIGTHREADLOCALE
        stmt.oldthreadlocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
#endif
        stmt.oldlocale = ecpg_strdup(setlocale(LC_NUMERIC, NULL), lineno);
        setlocale(LC_NUMERIC, "C");
#endif
 
        /* desperate try to guess something sensible */
        stmt.connection = ecpg_get_connection(NULL);
        ecpg_store_result(ECPGresult, index, &stmt, &data_var);
 
#ifdef HAVE_USELOCALE
        if (stmt.oldlocale != (locale_t) 0)
            uselocale(stmt.oldlocale);
#else
        if (stmt.oldlocale)
        {
            setlocale(LC_NUMERIC, stmt.oldlocale);
            ecpg_free(stmt.oldlocale);
        }
#ifdef HAVE__CONFIGTHREADLOCALE
        if (stmt.oldthreadlocale != -1)
            (void) _configthreadlocale(stmt.oldthreadlocale);
#endif
#endif
    }
    else if (data_var.ind_type != ECPGt_NO_INDICATOR && data_var.ind_pointer != NULL)
 
        /*
         * ind_type != NO_INDICATOR should always have ind_pointer != NULL but
         * since this might be changed manually in the .c file let's play it
         * safe
         */
    {
        /*
         * this is like ECPGstore_result but since we don't have a data
         * variable at hand, we can't call it
         */
        if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)
        {
            ecpg_log("ECPGget_desc on line %d: incorrect number of matches (indicator); %d don't fit into array of %ld\n",
                     lineno, ntuples, data_var.ind_arrsize);
            ecpg_raise(lineno, ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
            va_end(args);
            return false;
        }
 
        /* allocate storage if needed */
        if (data_var.ind_arrsize == 0 && data_var.ind_value == NULL)
        {
            void       *mem = (void *) ecpg_auto_alloc(data_var.ind_offset * ntuples, lineno);
 
            if (!mem)
            {
                va_end(args);
                return false;
            }
            *(void **) data_var.ind_pointer = mem;
            data_var.ind_value = mem;
        }
 
        for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
        {
            if (!get_int_item(lineno, data_var.ind_value, data_var.ind_type, -PQgetisnull(ECPGresult, act_tuple, index)))
            {
                va_end(args);
                return false;
            }
            data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;
            ecpg_log("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));
        }
    }
    sqlca->sqlerrd[2] = ntuples;
    va_end(args);
    return true;
}

References generate_unaccent_rules::args, variable::arrsize, Assert(), 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, variable::pointer, PQfmod(), PQfname(), PQfsize(), PQftype(), PQgetisnull(), PQgetlength(), PQnfields(), PQntuples(), RETURN_IF_NO_DATA, setlocale, snprintf, sqlca, stmt, type, variable::type, va_end(), va_start(), variable::value, variable::varcharsize, and VARHDRSZ.

Referenced by execute_test(), and main().

ECPGget_desc_header()

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

Definition at line 84 of file descriptor.c.

{
    PGresult   *ECPGresult;
    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);
    ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
    if (!ECPGresult)
        return false;
 
    *count = PQnfields(ECPGresult);
    sqlca->sqlerrd[2] = 1;
    ecpg_log("ECPGget_desc_header: found %d attributes\n", *count);
    return true;
}

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

Referenced by execute_test(), and main().

ECPGset_desc()

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

Definition at line 605 of file descriptor.c.

{
    va_list     args;
    struct descriptor *desc;
    struct descriptor_item *desc_item;
    struct variable *var;
 
    desc = ecpg_find_desc(lineno, desc_name);
    if (desc == NULL)
        return false;
 
    for (desc_item = desc->items; desc_item; desc_item = desc_item->next)
    {
        if (desc_item->num == index)
            break;
    }
 
    if (desc_item == NULL)
    {
        desc_item = (struct descriptor_item *) ecpg_alloc(sizeof(*desc_item), lineno);
        if (!desc_item)
            return false;
        desc_item->num = index;
        if (desc->count < index)
            desc->count = index;
        desc_item->next = desc->items;
        desc->items = desc_item;
    }
 
    if (!(var = (struct variable *) ecpg_alloc(sizeof(struct variable), lineno)))
        return false;
 
    va_start(args, index);
 
    for (;;)
    {
        enum ECPGdtype itemtype;
        char       *tobeinserted = NULL;
 
        itemtype = va_arg(args, enum ECPGdtype);
 
        if (itemtype == ECPGd_EODT)
            break;
 
        var->type = va_arg(args, enum ECPGttype);
        var->pointer = va_arg(args, char *);
 
        var->varcharsize = va_arg(args, long);
        var->arrsize = va_arg(args, long);
        var->offset = va_arg(args, long);
 
        if (var->arrsize == 0 || var->varcharsize == 0)
            var->value = *((char **) (var->pointer));
        else
            var->value = var->pointer;
 
        /*
         * negative values are used to indicate an array without given bounds
         */
        /* reset to zero for us */
        if (var->arrsize < 0)
            var->arrsize = 0;
        if (var->varcharsize < 0)
            var->varcharsize = 0;
 
        var->next = NULL;
 
        switch (itemtype)
        {
            case ECPGd_data:
                {
                    if (!ecpg_store_input(lineno, true, var, &tobeinserted, false))
                    {
                        ecpg_free(var);
                        va_end(args);
                        return false;
                    }
 
                    set_desc_attr(desc_item, var, tobeinserted);
                    tobeinserted = NULL;
                    break;
                }
 
            case ECPGd_indicator:
                set_int_item(lineno, &desc_item->indicator, var->pointer, var->type);
                break;
 
            case ECPGd_length:
                set_int_item(lineno, &desc_item->length, var->pointer, var->type);
                break;
 
            case ECPGd_precision:
                set_int_item(lineno, &desc_item->precision, var->pointer, var->type);
                break;
 
            case ECPGd_scale:
                set_int_item(lineno, &desc_item->scale, var->pointer, var->type);
                break;
 
            case ECPGd_type:
                set_int_item(lineno, &desc_item->type, var->pointer, var->type);
                break;
 
            default:
                {
                    char        type_str[20];
 
                    snprintf(type_str, sizeof(type_str), "%d", itemtype);
                    ecpg_raise(lineno, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, type_str);
                    ecpg_free(var);
                    va_end(args);
                    return false;
                }
        }
    }
    ecpg_free(var);
    va_end(args);
 
    return true;
}

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, va_end(), va_start(), variable::value, and variable::varcharsize.

Referenced by main().

ECPGset_desc_header()

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

Definition at line 573 of file descriptor.c.

{
    struct descriptor *desc = ecpg_find_desc(lineno, desc_name);
 
    if (desc == NULL)
        return false;
    desc->count = count;
    return true;
}

References descriptor::count, and ecpg_find_desc().

Referenced by main().

get_char_item()

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

static

Definition at line 194 of file descriptor.c.

{
    switch (vartype)
    {
        case ECPGt_char:
        case ECPGt_unsigned_char:
        case ECPGt_string:
            strncpy((char *) var, value, varcharsize);
            break;
        case ECPGt_varchar:
            {
                struct ECPGgeneric_varchar *variable =
                    (struct ECPGgeneric_varchar *) var;
 
                if (varcharsize == 0)
                    memcpy(variable->arr, value, strlen(value));
                else
                    strncpy(variable->arr, value, varcharsize);
 
                variable->len = strlen(value);
                if (varcharsize > 0 && variable->len > varcharsize)
                    variable->len = varcharsize;
            }
            break;
        default:
            ecpg_raise(lineno, ECPG_VAR_NOT_CHAR, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
            return false;
    }
 
    return true;
}

References ecpg_raise(), ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, ECPG_VAR_NOT_CHAR, ECPGt_char, ECPGt_string, ECPGt_unsigned_char, ECPGt_varchar, and value.

Referenced by ECPGget_desc().

get_descriptors()

static struct descriptor* get_descriptors ( void  )

static

Definition at line 40 of file descriptor.c.

{
    pthread_once(&descriptor_once, descriptor_key_init);
    return (struct descriptor *) pthread_getspecific(descriptor_key);
}

References descriptor_key, descriptor_key_init(), descriptor_once, and pthread_getspecific().

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

get_int_item()

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

static

Definition at line 108 of file descriptor.c.

{
    switch (vartype)
    {
        case ECPGt_short:
            *(short *) var = (short) value;
            break;
        case ECPGt_int:
            *(int *) var = (int) value;
            break;
        case ECPGt_long:
            *(long *) var = (long) value;
            break;
        case ECPGt_unsigned_short:
            *(unsigned short *) var = (unsigned short) value;
            break;
        case ECPGt_unsigned_int:
            *(unsigned int *) var = (unsigned int) value;
            break;
        case ECPGt_unsigned_long:
            *(unsigned long *) var = (unsigned long) value;
            break;
        case ECPGt_long_long:
            *(long long int *) var = (long long int) value;
            break;
        case ECPGt_unsigned_long_long:
            *(unsigned long long int *) var = (unsigned long long int) value;
            break;
        case ECPGt_float:
            *(float *) var = (float) value;
            break;
        case ECPGt_double:
            *(double *) var = (double) value;
            break;
        default:
            ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
            return false;
    }
 
    return true;
}

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

set_desc_attr()

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

static

Definition at line 584 of file descriptor.c.

{
    if (var->type != ECPGt_bytea)
        desc_item->is_binary = false;
 
    else
    {
        struct ECPGgeneric_bytea *variable =
            (struct ECPGgeneric_bytea *) (var->value);
 
        desc_item->is_binary = true;
        desc_item->data_len = variable->len;
    }
 
    ecpg_free(desc_item->data); /* free() takes care of a potential NULL value */
    desc_item->data = (char *) tobeinserted;
}

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

Referenced by ECPGset_desc().

set_descriptors()

static void set_descriptors ( struct descriptor *  value )

static

Definition at line 47 of file descriptor.c.

{
    pthread_setspecific(descriptor_key, value);
}

References descriptor_key, pthread_setspecific(), and value.

Referenced by ECPGallocate_desc(), and ECPGdeallocate_desc().

set_int_item()

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

static

Definition at line 151 of file descriptor.c.

{
    switch (vartype)
    {
        case ECPGt_short:
            *target = *(const short *) var;
            break;
        case ECPGt_int:
            *target = *(const int *) var;
            break;
        case ECPGt_long:
            *target = *(const long *) var;
            break;
        case ECPGt_unsigned_short:
            *target = *(const unsigned short *) var;
            break;
        case ECPGt_unsigned_int:
            *target = *(const unsigned int *) var;
            break;
        case ECPGt_unsigned_long:
            *target = *(const unsigned long *) var;
            break;
        case ECPGt_long_long:
            *target = *(const long long int *) var;
            break;
        case ECPGt_unsigned_long_long:
            *target = *(const unsigned long long int *) var;
            break;
        case ECPGt_float:
            *target = *(const float *) var;
            break;
        case ECPGt_double:
            *target = *(const double *) var;
            break;
        default:
            ecpg_raise(lineno, ECPG_VAR_NOT_NUMERIC, ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION, NULL);
            return false;
    }
 
    return true;
}

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

Variable Documentation

descriptor_key

pthread_key_t descriptor_key

static

Definition at line 22 of file descriptor.c.

Referenced by descriptor_key_init(), get_descriptors(), and set_descriptors().

descriptor_once

pthread_once_t descriptor_once = PTHREAD_ONCE_INIT

static

Definition at line 23 of file descriptor.c.

Referenced by get_descriptors().