ecpglib_extern.h File Reference

#include "ecpg_config.h"
#include "ecpgtype.h"
#include "libpq-fe.h"
#include "sqlca.h"
#include "sqlda-compat.h"
#include "sqlda-native.h"
#include <limits.h>

Include dependency graph for ecpglib_extern.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	ECPGgeneric_varchar
struct	ECPGgeneric_bytea
struct	ECPGtype_information_cache
struct	statement
struct	prepared_statement
struct	connection
struct	descriptor
struct	descriptor_item
struct	variable
struct	var_list

Macros
#define	INFORMIX_MODE(X)   ((X) == ECPG_COMPAT_INFORMIX || (X) == ECPG_COMPAT_INFORMIX_SE)
#define	ORACLE_MODE(X)   ((X) == ECPG_COMPAT_ORACLE)
#define	ECPG_IS_ARRAY(X)   ((X) == ECPG_ARRAY_ARRAY || (X) == ECPG_ARRAY_VECTOR)
#define	ecpg_gettext(x)   (x)
#define	ECPG_SQLSTATE_NO_DATA   "02000"
#define	ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS   "07001"
#define	ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS   "07002"
#define	ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION   "07006"
#define	ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX   "07009"
#define	ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION   "08001"
#define	ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST   "08003"
#define	ECPG_SQLSTATE_TRANSACTION_RESOLUTION_UNKNOWN   "08007"
#define	ECPG_SQLSTATE_CARDINALITY_VIOLATION   "21000"
#define	ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER   "22002"
#define	ECPG_SQLSTATE_ACTIVE_SQL_TRANSACTION   "25001"
#define	ECPG_SQLSTATE_NO_ACTIVE_SQL_TRANSACTION   "25P01"
#define	ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME   "26000"
#define	ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME   "33000"
#define	ECPG_SQLSTATE_INVALID_CURSOR_NAME   "34000"
#define	ECPG_SQLSTATE_SYNTAX_ERROR   "42601"
#define	ECPG_SQLSTATE_DATATYPE_MISMATCH   "42804"
#define	ECPG_SQLSTATE_DUPLICATE_CURSOR   "42P03"
#define	ECPG_SQLSTATE_ECPG_INTERNAL_ERROR   "YE000"
#define	ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY   "YE001"

Enumerations
enum	COMPAT_MODE {   ECPG_COMPAT_PGSQL = 0 , ECPG_COMPAT_INFORMIX , ECPG_COMPAT_INFORMIX_SE , ECPG_COMPAT_ORACLE ,   ECPG_COMPAT_PGSQL = 0 , ECPG_COMPAT_INFORMIX , ECPG_COMPAT_INFORMIX_SE , ECPG_COMPAT_ORACLE }
enum	ARRAY_TYPE {   ECPG_ARRAY_ERROR , ECPG_ARRAY_NOT_SET , ECPG_ARRAY_ARRAY , ECPG_ARRAY_VECTOR ,   ECPG_ARRAY_NONE }

Functions
bool	ecpg_add_mem (void *ptr, int lineno)
bool	ecpg_get_data (const PGresult *, int, int, int, enum ECPGttype type, enum ECPGttype, char *, char *, long, long, long, enum ARRAY_TYPE, enum COMPAT_MODE, bool)
void	ecpg_pthreads_init (void)
struct connection *	ecpg_get_connection (const char *connection_name)
char *	ecpg_alloc (long size, int lineno)
char *	ecpg_auto_alloc (long size, int lineno)
char *	ecpg_realloc (void *ptr, long size, int lineno)
void	ecpg_free (void *ptr)
bool	ecpg_init (const struct connection *con, const char *connection_name, const int lineno)
char *	ecpg_strdup (const char *string, int lineno, bool *alloc_failed)
const char *	ecpg_type_name (enum ECPGttype typ)
int	ecpg_dynamic_type (Oid type)
int	sqlda_dynamic_type (Oid type, enum COMPAT_MODE compat)
void	ecpg_clear_auto_mem (void)
struct descriptor *	ecpg_find_desc (int line, const char *name)
struct prepared_statement *	ecpg_find_prepared_statement (const char *name, struct connection *con, struct prepared_statement **prev_)
bool	ecpg_store_result (const PGresult *results, int act_field, const struct statement *stmt, struct variable *var)
bool	ecpg_store_input (const int lineno, const bool force_indicator, const struct variable *var, char **tobeinserted_p, bool quote)
void	ecpg_free_params (struct statement *stmt, bool print)
bool	ecpg_do_prologue (int lineno, const int compat, const int force_indicator, const char *connection_name, const bool questionmarks, enum ECPG_statement_type statement_type, const char *query, va_list args, struct statement **stmt_out)
bool	ecpg_build_params (struct statement *stmt)
bool	ecpg_autostart_transaction (struct statement *stmt)
bool	ecpg_execute (struct statement *stmt)
bool	ecpg_process_output (struct statement *stmt, bool clear_result)
void	ecpg_do_epilogue (struct statement *stmt)
bool	ecpg_do (const int lineno, const int compat, const int force_indicator, const char *connection_name, const bool questionmarks, const int st, const char *query, va_list args)
bool	ecpg_check_PQresult (PGresult *results, int lineno, PGconn *connection, enum COMPAT_MODE compat)
void	ecpg_raise (int line, int code, const char *sqlstate, const char *str)
void	ecpg_raise_backend (int line, PGresult *result, PGconn *conn, int compat)
char *	ecpg_prepared (const char *name, struct connection *con)
bool	ecpg_deallocate_all_conn (int lineno, enum COMPAT_MODE c, struct connection *con)
void	ecpg_log (const char *format,...) pg_attribute_printf(1
void bool	ecpg_auto_prepare (int lineno, const char *connection_name, const int compat, char **name, const char *query)
bool	ecpg_register_prepared_stmt (struct statement *stmt)
void	ecpg_init_sqlca (struct sqlca_t *sqlca)
struct sqlda_compat *	ecpg_build_compat_sqlda (int line, PGresult *res, int row, enum COMPAT_MODE compat)
void	ecpg_set_compat_sqlda (int lineno, struct sqlda_compat **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
struct sqlda_struct *	ecpg_build_native_sqlda (int line, PGresult *res, int row, enum COMPAT_MODE compat)
void	ecpg_set_native_sqlda (int lineno, struct sqlda_struct **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
unsigned	ecpg_hex_dec_len (unsigned srclen)
unsigned	ecpg_hex_enc_len (unsigned srclen)
unsigned	ecpg_hex_encode (const char *src, unsigned len, char *dst)

Variables
bool	ecpg_internal_regression_mode
struct var_list *	ivlist

Macro Definition Documentation

ecpg_gettext

#define ecpg_gettext

(

x

)

(x)

Definition at line 239 of file ecpglib_extern.h.

ECPG_IS_ARRAY

#define ECPG_IS_ARRAY

(

X

)

((X) == ECPG_ARRAY_ARRAY || (X) == ECPG_ARRAY_VECTOR)

Definition at line 32 of file ecpglib_extern.h.

ECPG_SQLSTATE_ACTIVE_SQL_TRANSACTION

#define ECPG_SQLSTATE_ACTIVE_SQL_TRANSACTION   "25001"

Definition at line 255 of file ecpglib_extern.h.

ECPG_SQLSTATE_CARDINALITY_VIOLATION

#define ECPG_SQLSTATE_CARDINALITY_VIOLATION   "21000"

Definition at line 253 of file ecpglib_extern.h.

ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST

#define ECPG_SQLSTATE_CONNECTION_DOES_NOT_EXIST   "08003"

Definition at line 251 of file ecpglib_extern.h.

ECPG_SQLSTATE_DATATYPE_MISMATCH

#define ECPG_SQLSTATE_DATATYPE_MISMATCH   "42804"

Definition at line 261 of file ecpglib_extern.h.

ECPG_SQLSTATE_DUPLICATE_CURSOR

#define ECPG_SQLSTATE_DUPLICATE_CURSOR   "42P03"

Definition at line 262 of file ecpglib_extern.h.

ECPG_SQLSTATE_ECPG_INTERNAL_ERROR

#define ECPG_SQLSTATE_ECPG_INTERNAL_ERROR   "YE000"

Definition at line 265 of file ecpglib_extern.h.

ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY

#define ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY   "YE001"

Definition at line 266 of file ecpglib_extern.h.

ECPG_SQLSTATE_INVALID_CURSOR_NAME

#define ECPG_SQLSTATE_INVALID_CURSOR_NAME   "34000"

Definition at line 259 of file ecpglib_extern.h.

ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX

#define ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX   "07009"

Definition at line 249 of file ecpglib_extern.h.

ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME

#define ECPG_SQLSTATE_INVALID_SQL_DESCRIPTOR_NAME   "33000"

Definition at line 258 of file ecpglib_extern.h.

ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME

#define ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME   "26000"

Definition at line 257 of file ecpglib_extern.h.

ECPG_SQLSTATE_NO_ACTIVE_SQL_TRANSACTION

#define ECPG_SQLSTATE_NO_ACTIVE_SQL_TRANSACTION   "25P01"

Definition at line 256 of file ecpglib_extern.h.

ECPG_SQLSTATE_NO_DATA

#define ECPG_SQLSTATE_NO_DATA   "02000"

Definition at line 245 of file ecpglib_extern.h.

ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER

#define ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER   "22002"

Definition at line 254 of file ecpglib_extern.h.

ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION

#define ECPG_SQLSTATE_RESTRICTED_DATA_TYPE_ATTRIBUTE_VIOLATION   "07006"

Definition at line 248 of file ecpglib_extern.h.

ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION

#define ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION   "08001"

Definition at line 250 of file ecpglib_extern.h.

ECPG_SQLSTATE_SYNTAX_ERROR

#define ECPG_SQLSTATE_SYNTAX_ERROR   "42601"

Definition at line 260 of file ecpglib_extern.h.

ECPG_SQLSTATE_TRANSACTION_RESOLUTION_UNKNOWN

#define ECPG_SQLSTATE_TRANSACTION_RESOLUTION_UNKNOWN   "08007"

Definition at line 252 of file ecpglib_extern.h.

ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS

#define ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS   "07001"

Definition at line 246 of file ecpglib_extern.h.

ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS

#define ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS   "07002"

Definition at line 247 of file ecpglib_extern.h.

INFORMIX_MODE

#define INFORMIX_MODE

(

X

)

((X) == ECPG_COMPAT_INFORMIX || (X) == ECPG_COMPAT_INFORMIX_SE)

Definition at line 24 of file ecpglib_extern.h.

ORACLE_MODE

#define ORACLE_MODE

(

X

)

((X) == ECPG_COMPAT_ORACLE)

Definition at line 25 of file ecpglib_extern.h.

Enumeration Type Documentation

ARRAY_TYPE

enum ARRAY_TYPE

Enumerator
ECPG_ARRAY_ERROR
ECPG_ARRAY_NOT_SET
ECPG_ARRAY_ARRAY
ECPG_ARRAY_VECTOR
ECPG_ARRAY_NONE

Definition at line 27 of file ecpglib_extern.h.

{
    ECPG_ARRAY_ERROR, ECPG_ARRAY_NOT_SET, ECPG_ARRAY_ARRAY, ECPG_ARRAY_VECTOR, ECPG_ARRAY_NONE
};

COMPAT_MODE

enum COMPAT_MODE

Enumerator
ECPG_COMPAT_PGSQL
ECPG_COMPAT_INFORMIX
ECPG_COMPAT_INFORMIX_SE
ECPG_COMPAT_ORACLE
ECPG_COMPAT_PGSQL
ECPG_COMPAT_INFORMIX
ECPG_COMPAT_INFORMIX_SE
ECPG_COMPAT_ORACLE

Definition at line 17 of file ecpglib_extern.h.

{
    ECPG_COMPAT_PGSQL = 0, ECPG_COMPAT_INFORMIX, ECPG_COMPAT_INFORMIX_SE, ECPG_COMPAT_ORACLE
};

Function Documentation

ecpg_add_mem()

bool ecpg_add_mem	(	void *	ptr,
		int	lineno
	)

Definition at line 126 of file memory.c.

{
    struct auto_mem *am = (struct auto_mem *) ecpg_alloc(sizeof(struct auto_mem), lineno);
 
    if (!am)
        return false;
 
    am->pointer = ptr;
    am->next = get_auto_allocs();
    set_auto_allocs(am);
    return true;
}

References ecpg_alloc(), get_auto_allocs(), auto_mem::next, auto_mem::pointer, and set_auto_allocs().

Referenced by ecpg_auto_alloc().

ecpg_alloc()

char * ecpg_alloc	(	long	size,
		int	lineno
	)

Definition at line 19 of file memory.c.

{
    char       *new = (char *) calloc(1L, size);
 
    if (!new)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return NULL;
    }
 
    return new;
}

References calloc, ECPG_OUT_OF_MEMORY, ecpg_raise(), and ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY.

Referenced by AddStmtToCache(), convert_bytea_to_string(), deallocate_one(), ecpg_add_mem(), ecpg_auto_alloc(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_build_params(), ecpg_do_prologue(), ecpg_get_data(), ecpg_is_type_an_array(), ecpg_register_prepared_stmt(), ecpg_store_input(), ecpg_type_infocache_push(), ECPGallocate_desc(), ECPGconnect(), ECPGset_desc(), insert_tobeinserted(), prepare_common(), print_param_value(), quote_postgres(), replace_variables(), and store_input_from_desc().

ecpg_auto_alloc()

char * ecpg_auto_alloc	(	long	size,
		int	lineno
	)

Definition at line 110 of file memory.c.

{
    void       *ptr = ecpg_alloc(size, lineno);
 
    if (!ptr)
        return NULL;
 
    if (!ecpg_add_mem(ptr, lineno))
    {
        ecpg_free(ptr);
        return NULL;
    }
    return ptr;
}

References ecpg_add_mem(), ecpg_alloc(), and ecpg_free().

Referenced by ecpg_store_result(), and ECPGget_desc().

ecpg_auto_prepare()

void bool ecpg_auto_prepare	(	int	lineno,
		const char *	connection_name,
		const int	compat,
		char **	name,
		const char *	query
	)

Definition at line 587 of file prepare.c.

{
    int         entNo;
 
    /* search the statement cache for this statement */
    entNo = SearchStmtCache(query);
 
    /* if not found - add the statement to the cache */
    if (entNo)
    {
        char       *stmtID;
        struct connection *con;
        struct prepared_statement *prep;
 
        ecpg_log("ecpg_auto_prepare on line %d: statement found in cache; entry %d\n", lineno, entNo);
 
        stmtID = stmtCacheEntries[entNo].stmtID;
        *name = ecpg_strdup(stmtID, lineno, NULL);
        if (*name == NULL)
            return false;
 
        con = ecpg_get_connection(connection_name);
        prep = ecpg_find_prepared_statement(stmtID, con, NULL);
        /* This prepared name doesn't exist on this connection. */
        if (!prep && !prepare_common(lineno, con, stmtID, query))
        {
            ecpg_free(*name);
            return false;
        }
 
    }
    else
    {
        char        stmtID[STMTID_SIZE];
 
        ecpg_log("ecpg_auto_prepare on line %d: statement not in cache; inserting\n", lineno);
 
        /* generate a statement ID */
        sprintf(stmtID, "ecpg%d", nextStmtID++);
        *name = ecpg_strdup(stmtID, lineno, NULL);
        if (*name == NULL)
            return false;
 
        if (!ECPGprepare(lineno, connection_name, 0, stmtID, query))
        {
            ecpg_free(*name);
            return false;
        }
 
        entNo = AddStmtToCache(lineno, stmtID, connection_name, compat, query);
        if (entNo < 0)
        {
            ecpg_free(*name);
            return false;
        }
    }
 
    /* increase usage counter */
    stmtCacheEntries[entNo].execs++;
 
    return true;
}

References AddStmtToCache(), compat, ecpg_find_prepared_statement(), ecpg_free(), ecpg_get_connection(), ecpg_log(), ecpg_strdup(), ECPGprepare(), stmtCacheEntry::execs, name, nextStmtID, prepare_common(), SearchStmtCache(), sprintf, stmtCacheEntries, stmtCacheEntry::stmtID, and STMTID_SIZE.

Referenced by ecpg_do_prologue().

ecpg_autostart_transaction()

bool ecpg_autostart_transaction

(

struct statement *

stmt

)

Definition at line 1579 of file execute.c.

{
    if (PQtransactionStatus(stmt->connection->connection) == PQTRANS_IDLE && !stmt->connection->autocommit)
    {
        stmt->results = PQexec(stmt->connection->connection, "begin transaction");
        if (!ecpg_check_PQresult(stmt->results, stmt->lineno, stmt->connection->connection, stmt->compat))
        {
            ecpg_free_params(stmt, false);
            return false;
        }
        PQclear(stmt->results);
        stmt->results = NULL;
    }
    return true;
}

References ecpg_check_PQresult(), ecpg_free_params(), PQclear, PQexec(), PQTRANS_IDLE, PQtransactionStatus(), and stmt.

Referenced by ecpg_do().

ecpg_build_compat_sqlda()

struct sqlda_compat * ecpg_build_compat_sqlda	(	int	line,
		PGresult *	res,
		int	row,
		enum COMPAT_MODE	compat
	)

Definition at line 205 of file sqlda.c.

{
    struct sqlda_compat *sqlda;
    struct sqlvar_compat *sqlvar;
    char       *fname;
    long        size;
    int         sqld;
    int         i;
 
    size = sqlda_compat_total_size(res, row, compat);
    sqlda = (struct sqlda_compat *) ecpg_alloc(size, line);
    if (!sqlda)
        return NULL;
 
    memset(sqlda, 0, size);
    sqlvar = (struct sqlvar_compat *) (sqlda + 1);
    sqld = PQnfields(res);
    fname = (char *) (sqlvar + sqld);
 
    sqlda->sqld = sqld;
    ecpg_log("ecpg_build_compat_sqlda on line %d sqld = %d\n", line, sqld);
    sqlda->desc_occ = size;     /* cheat here, keep the full allocated size */
    sqlda->sqlvar = sqlvar;
 
    for (i = 0; i < sqlda->sqld; i++)
    {
        sqlda->sqlvar[i].sqltype = sqlda_dynamic_type(PQftype(res, i), compat);
        strcpy(fname, PQfname(res, i));
        sqlda->sqlvar[i].sqlname = fname;
        fname += strlen(sqlda->sqlvar[i].sqlname) + 1;
 
        /*
         * this is reserved for future use, so we leave it empty for the time
         * being
         */
        /* sqlda->sqlvar[i].sqlformat = (char *) (long) PQfformat(res, i); */
        sqlda->sqlvar[i].sqlxid = PQftype(res, i);
        sqlda->sqlvar[i].sqltypelen = PQfsize(res, i);
    }
 
    return sqlda;
}

References compat, sqlda_compat::desc_occ, ecpg_alloc(), ecpg_log(), i, PQfname, PQfsize(), PQftype(), PQnfields, sqlda_compat::sqld, sqlda_compat_total_size(), sqlda_dynamic_type(), sqlvar_compat::sqlname, sqlvar_compat::sqltype, sqlvar_compat::sqltypelen, sqlda_compat::sqlvar, and sqlvar_compat::sqlxid.

Referenced by ecpg_process_output(), and ECPGdescribe().

ecpg_build_native_sqlda()

struct sqlda_struct * ecpg_build_native_sqlda	(	int	line,
		PGresult *	res,
		int	row,
		enum COMPAT_MODE	compat
	)

Definition at line 412 of file sqlda.c.

{
    struct sqlda_struct *sqlda;
    long        size;
    int         i;
 
    size = sqlda_native_total_size(res, row, compat);
    sqlda = (struct sqlda_struct *) ecpg_alloc(size, line);
    if (!sqlda)
        return NULL;
 
    memset(sqlda, 0, size);
 
    sprintf(sqlda->sqldaid, "SQLDA  ");
    sqlda->sqld = sqlda->sqln = PQnfields(res);
    ecpg_log("ecpg_build_native_sqlda on line %d sqld = %d\n", line, sqlda->sqld);
    sqlda->sqldabc = sizeof(struct sqlda_struct) + (sqlda->sqld - 1) * sizeof(struct sqlvar_struct);
 
    for (i = 0; i < sqlda->sqld; i++)
    {
        char       *fname;
 
        sqlda->sqlvar[i].sqltype = sqlda_dynamic_type(PQftype(res, i), compat);
        fname = PQfname(res, i);
        sqlda->sqlvar[i].sqlname.length = strlen(fname);
        strcpy(sqlda->sqlvar[i].sqlname.data, fname);
    }
 
    return sqlda;
}

References compat, sqlname::data, ecpg_alloc(), ecpg_log(), i, sqlname::length, PQfname, PQftype(), PQnfields, sprintf, sqlda_struct::sqld, sqlda_dynamic_type(), sqlda_native_total_size(), sqlda_struct::sqldabc, sqlda_struct::sqldaid, sqlda_struct::sqln, sqlvar_struct::sqlname, sqlvar_struct::sqltype, and sqlda_struct::sqlvar.

Referenced by ecpg_process_output(), and ECPGdescribe().

ecpg_build_params()

bool ecpg_build_params

(

struct statement *

stmt

)

Definition at line 1211 of file execute.c.

{
    struct variable *var;
    int         desc_counter = 0;
    int         position = 0;
    const char *value;
    bool        std_strings = false;
 
    /* Get standard_conforming_strings setting. */
    value = PQparameterStatus(stmt->connection->connection, "standard_conforming_strings");
    if (value && strcmp(value, "on") == 0)
        std_strings = true;
 
    /*
     * If the type is one of the fill in types then we take the argument and
     * enter it to our parameter array at the first position. Then if there
     * are any more fill in types we add more parameters.
     */
    var = stmt->inlist;
    while (var)
    {
        char       *tobeinserted;
        int         counter = 1;
        bool        binary_format;
        int         binary_length;
 
 
        tobeinserted = NULL;
        binary_length = 0;
        binary_format = false;
 
        /*
         * A descriptor is a special case since it contains many variables but
         * is listed only once.
         */
        if (var->type == ECPGt_descriptor)
        {
            /*
             * We create an additional variable list here, so the same logic
             * applies.
             */
            struct descriptor *desc;
            struct descriptor_item *desc_item;
 
            desc = ecpg_find_desc(stmt->lineno, var->pointer);
            if (desc == NULL)
                return false;
 
            desc_counter++;
            for (desc_item = desc->items; desc_item; desc_item = desc_item->next)
            {
                if (desc_item->num != desc_counter)
                    continue;
 
                if (!store_input_from_desc(stmt, desc_item, &tobeinserted))
                    return false;
 
                if (desc_item->is_binary)
                {
                    binary_length = desc_item->data_len;
                    binary_format = true;
                }
                break;
            }
            if (desc->count == desc_counter)
                desc_counter = 0;
        }
        else if (var->type == ECPGt_sqlda)
        {
            if (INFORMIX_MODE(stmt->compat))
            {
                struct sqlda_compat *sqlda = *(struct sqlda_compat **) var->pointer;
                struct variable desc_inlist;
                int         i;
 
                if (sqlda == NULL)
                    return false;
 
                desc_counter++;
                for (i = 0; i < sqlda->sqld; i++)
                {
                    if (i + 1 == desc_counter)
                    {
                        desc_inlist.type = sqlda->sqlvar[i].sqltype;
                        desc_inlist.value = sqlda->sqlvar[i].sqldata;
                        desc_inlist.pointer = &(sqlda->sqlvar[i].sqldata);
                        switch (desc_inlist.type)
                        {
                            case ECPGt_char:
                            case ECPGt_varchar:
                                desc_inlist.varcharsize = strlen(sqlda->sqlvar[i].sqldata);
                                break;
                            default:
                                desc_inlist.varcharsize = 0;
                                break;
                        }
                        desc_inlist.arrsize = 1;
                        desc_inlist.offset = 0;
                        if (sqlda->sqlvar[i].sqlind)
                        {
                            desc_inlist.ind_type = ECPGt_short;
                            /* ECPG expects indicator value < 0 */
                            if (*(sqlda->sqlvar[i].sqlind))
                                *(sqlda->sqlvar[i].sqlind) = -1;
                            desc_inlist.ind_value = sqlda->sqlvar[i].sqlind;
                            desc_inlist.ind_pointer = &(sqlda->sqlvar[i].sqlind);
                            desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = 1;
                            desc_inlist.ind_offset = 0;
                        }
                        else
                        {
                            desc_inlist.ind_type = ECPGt_NO_INDICATOR;
                            desc_inlist.ind_value = desc_inlist.ind_pointer = NULL;
                            desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = desc_inlist.ind_offset = 0;
                        }
                        if (!ecpg_store_input(stmt->lineno, stmt->force_indicator, &desc_inlist, &tobeinserted, false))
                            return false;
 
                        break;
                    }
                }
                if (sqlda->sqld == desc_counter)
                    desc_counter = 0;
            }
            else
            {
                struct sqlda_struct *sqlda = *(struct sqlda_struct **) var->pointer;
                struct variable desc_inlist;
                int         i;
 
                if (sqlda == NULL)
                    return false;
 
                desc_counter++;
                for (i = 0; i < sqlda->sqln; i++)
                {
                    if (i + 1 == desc_counter)
                    {
                        desc_inlist.type = sqlda->sqlvar[i].sqltype;
                        desc_inlist.value = sqlda->sqlvar[i].sqldata;
                        desc_inlist.pointer = &(sqlda->sqlvar[i].sqldata);
                        switch (desc_inlist.type)
                        {
                            case ECPGt_char:
                            case ECPGt_varchar:
                                desc_inlist.varcharsize = strlen(sqlda->sqlvar[i].sqldata);
                                break;
                            default:
                                desc_inlist.varcharsize = 0;
                                break;
                        }
                        desc_inlist.arrsize = 1;
                        desc_inlist.offset = 0;
                        if (sqlda->sqlvar[i].sqlind)
                        {
                            desc_inlist.ind_type = ECPGt_short;
                            /* ECPG expects indicator value < 0 */
                            if (*(sqlda->sqlvar[i].sqlind))
                                *(sqlda->sqlvar[i].sqlind) = -1;
                            desc_inlist.ind_value = sqlda->sqlvar[i].sqlind;
                            desc_inlist.ind_pointer = &(sqlda->sqlvar[i].sqlind);
                            desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = 1;
                            desc_inlist.ind_offset = 0;
                        }
                        else
                        {
                            desc_inlist.ind_type = ECPGt_NO_INDICATOR;
                            desc_inlist.ind_value = desc_inlist.ind_pointer = NULL;
                            desc_inlist.ind_varcharsize = desc_inlist.ind_arrsize = desc_inlist.ind_offset = 0;
                        }
                        if (!ecpg_store_input(stmt->lineno, stmt->force_indicator, &desc_inlist, &tobeinserted, false))
                            return false;
 
                        break;
                    }
                }
                if (sqlda->sqln == desc_counter)
                    desc_counter = 0;
            }
        }
        else
        {
            if (!ecpg_store_input(stmt->lineno, stmt->force_indicator, var, &tobeinserted, false))
                return false;
 
            if (var->type == ECPGt_bytea)
            {
                binary_length = ((struct ECPGgeneric_bytea *) (var->value))->len;
                binary_format = true;
            }
        }
 
        /*
         * now tobeinserted points to an area that contains the next
         * parameter; now find the position in the string where it belongs
         */
        if ((position = next_insert(stmt->command, position, stmt->questionmarks, std_strings) + 1) == 0)
        {
            /*
             * We have an argument but we don't have the matched up
             * placeholder in the string
             */
            ecpg_raise(stmt->lineno, ECPG_TOO_MANY_ARGUMENTS,
                       ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS,
                       NULL);
            ecpg_free_params(stmt, false);
            ecpg_free(tobeinserted);
            return false;
        }
 
        /*
         * if var->type=ECPGt_char_variable we have a dynamic cursor we have
         * to simulate a dynamic cursor because there is no backend
         * functionality for it
         */
        if (var->type == ECPGt_char_variable)
        {
            int         ph_len = (stmt->command[position] == '?') ? strlen("?") : strlen("$1");
 
            if (!insert_tobeinserted(position, ph_len, stmt, tobeinserted))
            {
                ecpg_free_params(stmt, false);
                return false;
            }
            tobeinserted = NULL;
        }
 
        /*
         * if the placeholder is '$0' we have to replace it on the client side
         * this is for places we want to support variables at that are not
         * supported in the backend
         */
        else if (stmt->command[position] == '0')
        {
            if (stmt->statement_type == ECPGst_prepare ||
                stmt->statement_type == ECPGst_exec_with_exprlist)
            {
                /* Need to double-quote the inserted statement name. */
                char       *str = ecpg_alloc(strlen(tobeinserted) + 2 + 1,
                                             stmt->lineno);
 
                if (!str)
                {
                    ecpg_free(tobeinserted);
                    ecpg_free_params(stmt, false);
                    return false;
                }
                sprintf(str, "\"%s\"", tobeinserted);
                ecpg_free(tobeinserted);
                tobeinserted = str;
            }
 
            if (!insert_tobeinserted(position, 2, stmt, tobeinserted))
            {
                ecpg_free_params(stmt, false);
                return false;
            }
            tobeinserted = NULL;
        }
        else if (stmt->statement_type == ECPGst_exec_with_exprlist)
        {
            if (binary_format)
            {
                char       *p = convert_bytea_to_string(tobeinserted,
                                                        binary_length,
                                                        stmt->lineno);
 
                ecpg_free(tobeinserted);
                if (!p)
                {
                    ecpg_free_params(stmt, false);
                    return false;
                }
                tobeinserted = p;
            }
 
            if (!insert_tobeinserted(position, 2, stmt, tobeinserted))
            {
                ecpg_free_params(stmt, false);
                return false;
            }
            tobeinserted = NULL;
        }
        else
        {
            bool        realloc_failed = false;
            char      **newparamvalues;
            int        *newparamlengths;
            int        *newparamformats;
 
            /* enlarge all the param arrays */
            if ((newparamvalues = (char **) ecpg_realloc(stmt->paramvalues, sizeof(char *) * (stmt->nparams + 1), stmt->lineno)))
                stmt->paramvalues = newparamvalues;
            else
                realloc_failed = true;
 
            if ((newparamlengths = (int *) ecpg_realloc(stmt->paramlengths, sizeof(int) * (stmt->nparams + 1), stmt->lineno)))
                stmt->paramlengths = newparamlengths;
            else
                realloc_failed = true;
 
            if ((newparamformats = (int *) ecpg_realloc(stmt->paramformats, sizeof(int) * (stmt->nparams + 1), stmt->lineno)))
                stmt->paramformats = newparamformats;
            else
                realloc_failed = true;
 
            if (realloc_failed)
            {
                ecpg_free_params(stmt, false);
                ecpg_free(tobeinserted);
                return false;
            }
 
            /* only now can we assign ownership of "tobeinserted" to stmt */
            stmt->paramvalues[stmt->nparams] = tobeinserted;
            stmt->paramlengths[stmt->nparams] = binary_length;
            stmt->paramformats[stmt->nparams] = (binary_format ? 1 : 0);
            stmt->nparams++;
 
            /* let's see if this was an old style placeholder */
            if (stmt->command[position] == '?')
            {
                /* yes, replace with new style */
                int         buffersize = sizeof(int) * CHAR_BIT * 10 / 3;   /* a rough guess of the
                                                                             * size we need */
 
                if (!(tobeinserted = ecpg_alloc(buffersize, stmt->lineno)))
                {
                    ecpg_free_params(stmt, false);
                    return false;
                }
 
                snprintf(tobeinserted, buffersize, "$%d", counter++);
 
                if (!insert_tobeinserted(position, 2, stmt, tobeinserted))
                {
                    ecpg_free_params(stmt, false);
                    return false;
                }
                tobeinserted = NULL;
            }
        }
 
        if (desc_counter == 0)
            var = var->next;
    }
 
    /*
     * Check if there are unmatched things left. PREPARE AS has no parameter.
     * Check other statement.
     */
    if (stmt->statement_type != ECPGst_prepare &&
        next_insert(stmt->command, position, stmt->questionmarks, std_strings) >= 0)
    {
        ecpg_raise(stmt->lineno, ECPG_TOO_FEW_ARGUMENTS,
                   ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS, NULL);
        ecpg_free_params(stmt, false);
        return false;
    }
 
    return true;
}

References convert_bytea_to_string(), descriptor::count, descriptor_item::data_len, ecpg_alloc(), ecpg_find_desc(), ecpg_free(), ecpg_free_params(), ecpg_raise(), ecpg_realloc(), ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_PARAMETERS, ecpg_store_input(), ECPG_TOO_FEW_ARGUMENTS, ECPG_TOO_MANY_ARGUMENTS, ECPGst_exec_with_exprlist, ECPGst_prepare, ECPGt_bytea, ECPGt_char, ECPGt_char_variable, ECPGt_descriptor, ECPGt_NO_INDICATOR, ECPGt_short, ECPGt_sqlda, ECPGt_varchar, i, if(), INFORMIX_MODE, insert_tobeinserted(), descriptor_item::is_binary, descriptor::items, len, descriptor_item::next, variable::next, next_insert(), descriptor_item::num, variable::pointer, PQparameterStatus(), snprintf, sprintf, sqlda_compat::sqld, sqlvar_compat::sqldata, sqlvar_struct::sqldata, sqlvar_compat::sqlind, sqlvar_struct::sqlind, sqlda_struct::sqln, sqlvar_compat::sqltype, sqlvar_struct::sqltype, sqlda_compat::sqlvar, sqlda_struct::sqlvar, stmt, store_input_from_desc(), str, variable::type, value, and variable::value.

Referenced by ecpg_do().

ecpg_check_PQresult()

bool ecpg_check_PQresult	(	PGresult *	results,
		int	lineno,
		PGconn *	connection,
		enum COMPAT_MODE	compat
	)

Definition at line 281 of file error.c.

{
    if (results == NULL)
    {
        ecpg_log("ecpg_check_PQresult on line %d: no result - %s", lineno, PQerrorMessage(connection));
        ecpg_raise_backend(lineno, NULL, connection, compat);
        return false;
    }
 
    switch (PQresultStatus(results))
    {
 
        case PGRES_TUPLES_OK:
            return true;
            break;
        case PGRES_EMPTY_QUERY:
            /* do nothing */
            ecpg_raise(lineno, ECPG_EMPTY, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, NULL);
            PQclear(results);
            return false;
            break;
        case PGRES_COMMAND_OK:
            return true;
            break;
        case PGRES_NONFATAL_ERROR:
        case PGRES_FATAL_ERROR:
        case PGRES_BAD_RESPONSE:
            ecpg_log("ecpg_check_PQresult on line %d: bad response - %s", lineno, PQresultErrorMessage(results));
            ecpg_raise_backend(lineno, results, connection, compat);
            PQclear(results);
            return false;
            break;
        case PGRES_COPY_OUT:
            return true;
            break;
        case PGRES_COPY_IN:
            ecpg_log("ecpg_check_PQresult on line %d: COPY IN data transfer in progress\n", lineno);
            PQendcopy(connection);
            PQclear(results);
            return false;
            break;
        default:
            ecpg_log("ecpg_check_PQresult on line %d: unknown execution status type\n",
                     lineno);
            ecpg_raise_backend(lineno, results, connection, compat);
            PQclear(results);
            return false;
            break;
    }
}

References compat, ECPG_EMPTY, ecpg_log(), ecpg_raise(), ecpg_raise_backend(), ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, PGRES_BAD_RESPONSE, PGRES_COMMAND_OK, PGRES_COPY_IN, PGRES_COPY_OUT, PGRES_EMPTY_QUERY, PGRES_FATAL_ERROR, PGRES_NONFATAL_ERROR, PGRES_TUPLES_OK, PQclear, PQendcopy(), PQerrorMessage(), PQresultErrorMessage, and PQresultStatus.

Referenced by deallocate_one(), ecpg_autostart_transaction(), ecpg_execute(), ecpg_is_type_an_array(), ECPGdescribe(), ECPGsetcommit(), ECPGtrans(), and prepare_common().

ecpg_clear_auto_mem()

void ecpg_clear_auto_mem

(

void

)

Definition at line 160 of file memory.c.

{
    struct auto_mem *am = get_auto_allocs();
 
    /* only free our own structure */
    if (am)
    {
        do
        {
            struct auto_mem *act = am;
 
            am = am->next;
            ecpg_free(act);
        } while (am);
        set_auto_allocs(NULL);
    }
}

References ecpg_free(), get_auto_allocs(), auto_mem::next, and set_auto_allocs().

Referenced by ecpg_do_prologue(), and ECPGconnect().

ecpg_deallocate_all_conn()

bool ecpg_deallocate_all_conn	(	int	lineno,
		enum COMPAT_MODE	c,
		struct connection *	con
	)

Definition at line 369 of file prepare.c.

{
    /* deallocate all prepared statements */
    while (con->prep_stmts)
    {
        if (!deallocate_one(lineno, c, con, NULL, con->prep_stmts))
            return false;
    }
 
    return true;
}

References deallocate_one(), and connection::prep_stmts.

Referenced by ecpg_finish(), and ECPGdeallocate_all().

ecpg_do()

bool ecpg_do	(	const int	lineno,
		const int	compat,
		const int	force_indicator,
		const char *	connection_name,
		const bool	questionmarks,
		const int	st,
		const char *	query,
		va_list	args
	)

Definition at line 2257 of file execute.c.

{
    struct statement *stmt = NULL;
 
    if (!ecpg_do_prologue(lineno, compat, force_indicator, connection_name,
                          questionmarks, (enum ECPG_statement_type) st,
                          query, args, &stmt))
        goto fail;
 
    if (!ecpg_build_params(stmt))
        goto fail;
 
    if (!ecpg_autostart_transaction(stmt))
        goto fail;
 
    if (!ecpg_execute(stmt))
        goto fail;
 
    if (!ecpg_process_output(stmt, true))
        goto fail;
 
    ecpg_do_epilogue(stmt);
    return true;
 
fail:
    ecpg_do_epilogue(stmt);
    return false;
}

References generate_unaccent_rules::args, compat, ecpg_autostart_transaction(), ecpg_build_params(), ecpg_do_epilogue(), ecpg_do_prologue(), ecpg_execute(), ecpg_process_output(), force_indicator, statement::lineno, questionmarks, and stmt.

Referenced by ECPGdo().

ecpg_do_epilogue()

void ecpg_do_epilogue

(

struct statement *

stmt

)

Definition at line 2230 of file execute.c.

{
    if (stmt == NULL)
        return;
 
#ifdef HAVE_USELOCALE
    if (stmt->oldlocale != (locale_t) 0)
        uselocale(stmt->oldlocale);
#else
    if (stmt->oldlocale)
    {
        setlocale(LC_NUMERIC, stmt->oldlocale);
#ifdef WIN32
        _configthreadlocale(stmt->oldthreadlocale);
#endif
    }
#endif
 
    free_statement(stmt);
}

References free_statement(), locale_t, setlocale, and stmt.

Referenced by ecpg_do(), and ecpg_do_prologue().

ecpg_do_prologue()

bool ecpg_do_prologue	(	int	lineno,
		const int	compat,
		const int	force_indicator,
		const char *	connection_name,
		const bool	questionmarks,
		enum ECPG_statement_type	statement_type,
		const char *	query,
		va_list	args,
		struct statement **	stmt_out
	)

Definition at line 1942 of file execute.c.

{
    struct statement *stmt = NULL;
    struct connection *con;
    enum ECPGttype type;
    struct variable **list;
    char       *prepname;
    bool        is_prepared_name_set;
 
    *stmt_out = NULL;
 
    if (!query)
    {
        ecpg_raise(lineno, ECPG_EMPTY, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, NULL);
        return false;
    }
 
    ecpg_pthreads_init();
 
    con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    stmt = (struct statement *) ecpg_alloc(sizeof(struct statement), lineno);
 
    if (stmt == NULL)
        return false;
 
    /*
     * Make sure we do NOT honor the locale for numeric input/output since the
     * database wants the standard decimal point.  If available, use
     * uselocale() for this because it's thread-safe.  Windows doesn't have
     * that, but it does have _configthreadlocale().
     */
#ifdef HAVE_USELOCALE
 
    /*
     * Since ecpg_init() succeeded, we have a connection.  Any successful
     * connection initializes ecpg_clocale.
     */
    Assert(ecpg_clocale);
    stmt->oldlocale = uselocale(ecpg_clocale);
    if (stmt->oldlocale == (locale_t) 0)
    {
        ecpg_do_epilogue(stmt);
        return false;
    }
#else
#ifdef WIN32
    stmt->oldthreadlocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);
    if (stmt->oldthreadlocale == -1)
    {
        ecpg_do_epilogue(stmt);
        return false;
    }
#endif
    stmt->oldlocale = ecpg_strdup(setlocale(LC_NUMERIC, NULL), lineno,
                                  NULL);
    if (stmt->oldlocale == NULL)
    {
        ecpg_do_epilogue(stmt);
        return false;
    }
    setlocale(LC_NUMERIC, "C");
#endif
 
    /*
     * If statement type is ECPGst_prepnormal we are supposed to prepare the
     * statement before executing them
     */
    if (statement_type == ECPGst_prepnormal)
    {
        if (!ecpg_auto_prepare(lineno, connection_name, compat, &prepname, query))
        {
            ecpg_do_epilogue(stmt);
            return false;
        }
 
        /*
         * statement is now prepared, so instead of the query we have to
         * execute the name
         */
        stmt->command = prepname;
        statement_type = ECPGst_execute;
    }
    else
    {
        stmt->command = ecpg_strdup(query, lineno, NULL);
        if (!stmt->command)
        {
            ecpg_do_epilogue(stmt);
            return false;
        }
    }
 
    stmt->name = NULL;
 
    if (statement_type == ECPGst_execute)
    {
        /* if we have an EXECUTE command, only the name is send */
        char       *command = ecpg_prepared(stmt->command, con);
 
        if (command)
        {
            stmt->name = stmt->command;
            stmt->command = ecpg_strdup(command, lineno, NULL);
            if (!stmt->command)
            {
                ecpg_do_epilogue(stmt);
                return false;
            }
        }
        else
        {
            ecpg_raise(lineno, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, stmt->command);
            ecpg_do_epilogue(stmt);
            return false;
        }
    }
    /* name of PREPARE AS will be set in loop of inlist */
 
    stmt->connection = con;
    stmt->lineno = lineno;
    stmt->compat = compat;
    stmt->force_indicator = force_indicator;
    stmt->questionmarks = questionmarks;
    stmt->statement_type = statement_type;
 
    /*------
     * create a list of variables
     *
     * The variables are listed with input variables preceding output
     * variables.  The end of each group is marked by an end marker.
     * Per variable we list:
     *
     * type - as defined in ecpgtype.h
     * value - where to store the data
     * varcharsize - length of string in case we have a stringvariable, else 0
     * arraysize - 0 for pointer (we don't know the size of the array), 1 for
     * simple variable, size for arrays
     * offset - offset between ith and (i+1)th entry in an array, normally
     * that means sizeof(type)
     * ind_type - type of indicator variable
     * ind_pointer - pointer to indicator variable
     * ind_varcharsize - empty
     * ind_arrsize - arraysize of indicator array
     * ind_offset - indicator offset
     *------
     */
 
    is_prepared_name_set = false;
 
    list = &(stmt->inlist);
 
    type = va_arg(args, enum ECPGttype);
 
    while (type != ECPGt_EORT)
    {
        if (type == ECPGt_EOIT)
            list = &(stmt->outlist);
        else
        {
            struct variable *var,
                       *ptr;
 
            if (!(var = (struct variable *) ecpg_alloc(sizeof(struct variable), lineno)))
            {
                ecpg_do_epilogue(stmt);
                return false;
            }
 
            var->type = type;
            var->pointer = va_arg(args, char *);
 
            var->varcharsize = va_arg(args, long);
            var->arrsize = va_arg(args, long);
            var->offset = va_arg(args, long);
 
            /*
             * Unknown array size means pointer to an array. Unknown
             * varcharsize usually also means pointer. But if the type is
             * character and the array size is known, it is an array of
             * pointers to char, so use var->pointer as it is.
             */
            if (var->arrsize == 0 ||
                (var->varcharsize == 0 && ((var->type != ECPGt_char && var->type != ECPGt_unsigned_char) || (var->arrsize <= 1))))
                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;
 
            var->ind_type = va_arg(args, enum ECPGttype);
            var->ind_pointer = va_arg(args, char *);
            var->ind_varcharsize = va_arg(args, long);
            var->ind_arrsize = va_arg(args, long);
            var->ind_offset = va_arg(args, long);
 
            if (var->ind_type != ECPGt_NO_INDICATOR
                && (var->ind_arrsize == 0 || var->ind_varcharsize == 0))
                var->ind_value = *((char **) (var->ind_pointer));
            else
                var->ind_value = var->ind_pointer;
 
            /*
             * negative values are used to indicate an array without given
             * bounds
             */
            /* reset to zero for us */
            if (var->ind_arrsize < 0)
                var->ind_arrsize = 0;
            if (var->ind_varcharsize < 0)
                var->ind_varcharsize = 0;
 
            /* if variable is NULL, the statement hasn't been prepared */
            if (var->pointer == NULL)
            {
                ecpg_raise(lineno, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, NULL);
                ecpg_free(var);
                ecpg_do_epilogue(stmt);
                return false;
            }
 
            for (ptr = *list; ptr && ptr->next; ptr = ptr->next)
                ;
 
            if (ptr == NULL)
                *list = var;
            else
                ptr->next = var;
 
            if (!is_prepared_name_set && stmt->statement_type == ECPGst_prepare)
            {
                stmt->name = ecpg_strdup(var->value, lineno, NULL);
                if (!stmt->name)
                {
                    ecpg_do_epilogue(stmt);
                    return false;
                }
                is_prepared_name_set = true;
            }
        }
 
        type = va_arg(args, enum ECPGttype);
    }
 
    /* are we connected? */
    if (con == NULL || con->connection == NULL)
    {
        ecpg_raise(lineno, ECPG_NOT_CONN, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, (con) ? con->name : ecpg_gettext("<empty>"));
        ecpg_do_epilogue(stmt);
        return false;
    }
 
    if (!is_prepared_name_set && stmt->statement_type == ECPGst_prepare)
    {
        ecpg_raise(lineno, ECPG_TOO_FEW_ARGUMENTS, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, (con) ? con->name : ecpg_gettext("<empty>"));
        ecpg_do_epilogue(stmt);
        return false;
    }
 
    /* initialize auto_mem struct */
    ecpg_clear_auto_mem();
 
    *stmt_out = stmt;
 
    return true;
}

References generate_unaccent_rules::args, variable::arrsize, Assert(), statement::command, compat, connection::connection, ecpg_alloc(), ecpg_auto_prepare(), ecpg_clear_auto_mem(), ecpg_do_epilogue(), ECPG_EMPTY, ecpg_free(), ecpg_get_connection(), ecpg_gettext, ecpg_init(), ECPG_INVALID_STMT, ECPG_NOT_CONN, ecpg_prepared(), ecpg_pthreads_init(), ecpg_raise(), ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, ecpg_strdup(), ECPG_TOO_FEW_ARGUMENTS, ECPGst_execute, ECPGst_prepare, ECPGst_prepnormal, ECPGt_char, ECPGt_EOIT, ECPGt_EORT, ECPGt_NO_INDICATOR, ECPGt_unsigned_char, force_indicator, variable::ind_arrsize, variable::ind_offset, variable::ind_pointer, variable::ind_type, variable::ind_value, variable::ind_varcharsize, statement::lineno, sort-test::list, locale_t, connection::name, variable::next, variable::offset, variable::pointer, questionmarks, setlocale, statement::statement_type, stmt, type, variable::type, variable::value, and variable::varcharsize.

Referenced by ecpg_do().

ecpg_dynamic_type()

int ecpg_dynamic_type

(

Oid

type

)

Definition at line 73 of file typename.c.

{
    switch (type)
    {
        case BOOLOID:
            return SQL3_BOOLEAN;    /* bool */
        case INT2OID:
            return SQL3_SMALLINT;   /* int2 */
        case INT4OID:
            return SQL3_INTEGER;    /* int4 */
        case TEXTOID:
            return SQL3_CHARACTER;  /* text */
        case FLOAT4OID:
            return SQL3_REAL;   /* float4 */
        case FLOAT8OID:
            return SQL3_DOUBLE_PRECISION;   /* float8 */
        case BPCHAROID:
            return SQL3_CHARACTER;  /* bpchar */
        case VARCHAROID:
            return SQL3_CHARACTER_VARYING;  /* varchar */
        case DATEOID:
            return SQL3_DATE_TIME_TIMESTAMP;    /* date */
        case TIMEOID:
            return SQL3_DATE_TIME_TIMESTAMP;    /* time */
        case TIMESTAMPOID:
            return SQL3_DATE_TIME_TIMESTAMP;    /* datetime */
        case NUMERICOID:
            return SQL3_NUMERIC;    /* numeric */
        default:
            return 0;
    }
}

References SQL3_BOOLEAN, SQL3_CHARACTER, SQL3_CHARACTER_VARYING, SQL3_DATE_TIME_TIMESTAMP, SQL3_DOUBLE_PRECISION, SQL3_INTEGER, SQL3_NUMERIC, SQL3_REAL, SQL3_SMALLINT, and type.

Referenced by ecpg_is_type_an_array(), and ECPGget_desc().

ecpg_execute()

bool ecpg_execute

(

struct statement *

stmt

)

Definition at line 1600 of file execute.c.

{
    ecpg_log("ecpg_execute on line %d: query: %s; with %d parameter(s) on connection %s\n", stmt->lineno, stmt->command, stmt->nparams, stmt->connection->name);
    if (stmt->statement_type == ECPGst_execute)
    {
        stmt->results = PQexecPrepared(stmt->connection->connection,
                                       stmt->name,
                                       stmt->nparams,
                                       (const char *const *) stmt->paramvalues,
                                       (const int *) stmt->paramlengths,
                                       (const int *) stmt->paramformats,
                                       0);
        ecpg_log("ecpg_execute on line %d: using PQexecPrepared for \"%s\"\n", stmt->lineno, stmt->command);
    }
    else
    {
        if (stmt->nparams == 0)
        {
            stmt->results = PQexec(stmt->connection->connection, stmt->command);
            ecpg_log("ecpg_execute on line %d: using PQexec\n", stmt->lineno);
        }
        else
        {
            stmt->results = PQexecParams(stmt->connection->connection,
                                         stmt->command, stmt->nparams, NULL,
                                         (const char *const *) stmt->paramvalues,
                                         (const int *) stmt->paramlengths,
                                         (const int *) stmt->paramformats,
                                         0);
 
            ecpg_log("ecpg_execute on line %d: using PQexecParams\n", stmt->lineno);
        }
 
        if (stmt->statement_type == ECPGst_prepare)
        {
            if (!ecpg_register_prepared_stmt(stmt))
            {
                ecpg_free_params(stmt, true);
                return false;
            }
        }
    }
 
    ecpg_free_params(stmt, true);
 
    if (!ecpg_check_PQresult(stmt->results, stmt->lineno, stmt->connection->connection, stmt->compat))
        return false;
 
    return true;
}

References ecpg_check_PQresult(), ecpg_free_params(), ecpg_log(), ecpg_register_prepared_stmt(), ECPGst_execute, ECPGst_prepare, PQexec(), PQexecParams(), PQexecPrepared(), and stmt.

Referenced by ecpg_do().

ecpg_find_desc()

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

Definition at line 840 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_find_prepared_statement()

struct prepared_statement * ecpg_find_prepared_statement	(	const char *	name,
		struct connection *	con,
		struct prepared_statement **	prev_
	)

Definition at line 271 of file prepare.c.

{
    struct prepared_statement *this,
               *prev;
 
    for (this = con->prep_stmts, prev = NULL;
         this != NULL;
         prev = this, this = this->next)
    {
        if (strcmp(this->name, name) == 0)
        {
            if (prev_)
                *prev_ = prev;
            return this;
        }
    }
    return NULL;
}

References name, prepared_statement::next, and connection::prep_stmts.

Referenced by ecpg_auto_prepare(), ecpg_freeStmtCacheEntry(), ecpg_prepared(), ecpg_register_prepared_stmt(), ECPGdeallocate(), ECPGdescribe(), and ECPGprepare().

ecpg_free()

void ecpg_free

(

void *

ptr

)

Definition at line 13 of file memory.c.

{
    free(ptr);
}

References free.

Referenced by deallocate_one(), descriptor_free(), ecpg_auto_alloc(), ecpg_auto_prepare(), ecpg_build_params(), ecpg_clear_auto_mem(), ecpg_do_prologue(), ecpg_finish(), ecpg_free_params(), ecpg_freeStmtCacheEntry(), ecpg_is_type_an_array(), ecpg_register_prepared_stmt(), ecpg_store_input(), ECPGallocate_desc(), ECPGconnect(), ECPGfree_auto_mem(), ECPGget_desc(), ECPGset_desc(), free_statement(), free_variable(), insert_tobeinserted(), prepare_common(), print_param_value(), quote_postgres(), replace_variables(), and set_desc_attr().

ecpg_free_params()

void ecpg_free_params	(	struct statement *	stmt,
		bool	print
	)

Definition at line 1106 of file execute.c.

{
    int         n;
 
    for (n = 0; n < stmt->nparams; n++)
    {
        if (print)
            print_param_value(stmt->paramvalues[n], stmt->paramlengths[n],
                              stmt->paramformats[n], stmt->lineno, n + 1);
        ecpg_free(stmt->paramvalues[n]);
    }
    ecpg_free(stmt->paramvalues);
    ecpg_free(stmt->paramlengths);
    ecpg_free(stmt->paramformats);
    stmt->paramvalues = NULL;
    stmt->paramlengths = NULL;
    stmt->paramformats = NULL;
    stmt->nparams = 0;
}

References ecpg_free(), print(), print_param_value(), and stmt.

Referenced by ecpg_autostart_transaction(), ecpg_build_params(), and ecpg_execute().

ecpg_get_connection()

struct connection * ecpg_get_connection

(

const char *

connection_name

)

Definition at line 76 of file connect.c.

{
    struct connection *ret = NULL;
 
    if ((connection_name == NULL) || (strcmp(connection_name, "CURRENT") == 0))
    {
        ecpg_pthreads_init();   /* ensure actual_connection_key is valid */
 
        ret = pthread_getspecific(actual_connection_key);
 
        /*
         * if no connection in TSD for this thread, get the global default
         * connection and hope the user knows what they're doing (i.e. using
         * their own mutex to protect that connection from concurrent accesses
         */
        if (ret == NULL)
            /* no TSD connection here either, using global */
            ret = actual_connection;
    }
    else
    {
        pthread_mutex_lock(&connections_mutex);
 
        ret = ecpg_get_connection_nr(connection_name);
 
        pthread_mutex_unlock(&connections_mutex);
    }
 
    return ret;
}

References actual_connection, actual_connection_key, connections_mutex, ecpg_get_connection_nr(), ecpg_pthreads_init(), pthread_getspecific(), pthread_mutex_lock(), and pthread_mutex_unlock().

Referenced by ecpg_auto_prepare(), ecpg_do_prologue(), ecpg_freeStmtCacheEntry(), ECPGconnect(), ECPGdeallocate(), ECPGdeallocate_all(), ECPGdescribe(), ECPGget_desc(), ECPGget_PGconn(), ECPGprepare(), ECPGprepared_statement(), ECPGsetcommit(), ECPGsetconn(), ECPGstatus(), ECPGtrans(), and ECPGtransactionStatus().

ecpg_get_data()

bool ecpg_get_data	(	const PGresult *	results,
		int	act_tuple,
		int	act_field,
		int	lineno,
		enum ECPGttype	type,
		enum	ECPGttype,
		char *	var,
		char *	ind,
		long	varcharsize,
		long	offset,
		long	ind_offset,
		enum	ARRAY_TYPE,
		enum	COMPAT_MODE,
		bool	force_indicator
	)

Definition at line 195 of file data.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
    char       *pval = (char *) PQgetvalue(results, act_tuple, act_field);
    int         binary = PQfformat(results, act_field);
    int         size = PQgetlength(results, act_tuple, act_field);
    int         value_for_indicator = 0;
    long        log_offset;
 
    if (sqlca == NULL)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    /*
     * If we are running in a regression test, do not log the offset variable,
     * it depends on the machine's alignment.
     */
    if (ecpg_internal_regression_mode)
        log_offset = -1;
    else
        log_offset = offset;
 
    ecpg_log("ecpg_get_data on line %d: RESULT: %s offset: %ld; array: %s\n", lineno, pval ? (binary ? "BINARY" : pval) : "EMPTY", log_offset, ECPG_IS_ARRAY(isarray) ? "yes" : "no");
 
    /* pval is a pointer to the value */
    if (!pval)
    {
        /*
         * This should never happen because we already checked that we found
         * at least one tuple, but let's play it safe.
         */
        ecpg_raise(lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
        return false;
    }
 
    /* We will have to decode the value */
 
    /*
     * check for null value and set indicator accordingly, i.e. -1 if NULL and
     * 0 if not
     */
    if (PQgetisnull(results, act_tuple, act_field))
        value_for_indicator = -1;
 
    switch (ind_type)
    {
        case ECPGt_short:
        case ECPGt_unsigned_short:
            *((short *) (ind + ind_offset * act_tuple)) = value_for_indicator;
            break;
        case ECPGt_int:
        case ECPGt_unsigned_int:
            *((int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
            break;
        case ECPGt_long:
        case ECPGt_unsigned_long:
            *((long *) (ind + ind_offset * act_tuple)) = value_for_indicator;
            break;
        case ECPGt_long_long:
        case ECPGt_unsigned_long_long:
            *((long long int *) (ind + ind_offset * act_tuple)) = value_for_indicator;
            break;
        case ECPGt_NO_INDICATOR:
            if (value_for_indicator == -1)
            {
                if (force_indicator == false)
                {
                    /*
                     * Informix has an additional way to specify NULLs note
                     * that this uses special values to denote NULL
                     */
                    ECPGset_noind_null(type, var + offset * act_tuple);
                }
                else
                {
                    ecpg_raise(lineno, ECPG_MISSING_INDICATOR,
                               ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER,
                               NULL);
                    return false;
                }
            }
            break;
        default:
            ecpg_raise(lineno, ECPG_UNSUPPORTED,
                       ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
                       ecpg_type_name(ind_type));
            return false;
            break;
    }
 
    if (value_for_indicator == -1)
        return true;
 
    /* let's check if it really is an array if it should be one */
    if (isarray == ECPG_ARRAY_ARRAY)
    {
        if (*pval != '{')
        {
            ecpg_raise(lineno, ECPG_DATA_NOT_ARRAY,
                       ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
            return false;
        }
 
        switch (type)
        {
            case ECPGt_char:
            case ECPGt_unsigned_char:
            case ECPGt_varchar:
            case ECPGt_string:
                break;
 
            default:
                pval++;
                break;
        }
    }
 
    do
    {
        if (binary)
        {
            if (varcharsize == 0 || varcharsize * offset >= size)
                memcpy(var + offset * act_tuple, pval, size);
            else
            {
                memcpy(var + offset * act_tuple, pval, varcharsize * offset);
 
                if (varcharsize * offset < size)
                {
                    /* truncation */
                    switch (ind_type)
                    {
                        case ECPGt_short:
                        case ECPGt_unsigned_short:
                            *((short *) (ind + ind_offset * act_tuple)) = size;
                            break;
                        case ECPGt_int:
                        case ECPGt_unsigned_int:
                            *((int *) (ind + ind_offset * act_tuple)) = size;
                            break;
                        case ECPGt_long:
                        case ECPGt_unsigned_long:
                            *((long *) (ind + ind_offset * act_tuple)) = size;
                            break;
                        case ECPGt_long_long:
                        case ECPGt_unsigned_long_long:
                            *((long long int *) (ind + ind_offset * act_tuple)) = size;
                            break;
                        default:
                            break;
                    }
                    sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
                }
            }
            pval += size;
        }
        else
        {
            switch (type)
            {
                    long        res;
                    unsigned long ures;
                    double      dres;
                    char       *scan_length;
                    numeric    *nres;
                    date        ddres;
                    timestamp   tres;
                    interval   *ires;
                    char       *endptr,
                                endchar;
 
                case ECPGt_short:
                case ECPGt_int:
                case ECPGt_long:
                    res = strtol(pval, &scan_length, 10);
                    if (garbage_left(isarray, &scan_length, compat))
                    {
                        ecpg_raise(lineno, ECPG_INT_FORMAT,
                                   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                        return false;
                    }
                    pval = scan_length;
 
                    switch (type)
                    {
                        case ECPGt_short:
                            *((short *) (var + offset * act_tuple)) = (short) res;
                            break;
                        case ECPGt_int:
                            *((int *) (var + offset * act_tuple)) = (int) res;
                            break;
                        case ECPGt_long:
                            *((long *) (var + offset * act_tuple)) = (long) res;
                            break;
                        default:
                            /* Cannot happen */
                            break;
                    }
                    break;
 
                case ECPGt_unsigned_short:
                case ECPGt_unsigned_int:
                case ECPGt_unsigned_long:
                    ures = strtoul(pval, &scan_length, 10);
                    if (garbage_left(isarray, &scan_length, compat))
                    {
                        ecpg_raise(lineno, ECPG_UINT_FORMAT,
                                   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                        return false;
                    }
                    pval = scan_length;
 
                    switch (type)
                    {
                        case ECPGt_unsigned_short:
                            *((unsigned short *) (var + offset * act_tuple)) = (unsigned short) ures;
                            break;
                        case ECPGt_unsigned_int:
                            *((unsigned int *) (var + offset * act_tuple)) = (unsigned int) ures;
                            break;
                        case ECPGt_unsigned_long:
                            *((unsigned long *) (var + offset * act_tuple)) = (unsigned long) ures;
                            break;
                        default:
                            /* Cannot happen */
                            break;
                    }
                    break;
 
                case ECPGt_long_long:
                    *((long long int *) (var + offset * act_tuple)) = strtoll(pval, &scan_length, 10);
                    if (garbage_left(isarray, &scan_length, compat))
                    {
                        ecpg_raise(lineno, ECPG_INT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                        return false;
                    }
                    pval = scan_length;
 
                    break;
 
                case ECPGt_unsigned_long_long:
                    *((unsigned long long int *) (var + offset * act_tuple)) = strtoull(pval, &scan_length, 10);
                    if (garbage_left(isarray, &scan_length, compat))
                    {
                        ecpg_raise(lineno, ECPG_UINT_FORMAT, ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                        return false;
                    }
                    pval = scan_length;
 
                    break;
 
                case ECPGt_float:
                case ECPGt_double:
                    if (isarray && *pval == '"')
                        pval++;
 
                    if (!check_special_value(pval, &dres, &scan_length))
                        dres = strtod(pval, &scan_length);
 
                    if (isarray && *scan_length == '"')
                        scan_length++;
 
                    /* no special INFORMIX treatment for floats */
                    if (garbage_left(isarray, &scan_length, ECPG_COMPAT_PGSQL))
                    {
                        ecpg_raise(lineno, ECPG_FLOAT_FORMAT,
                                   ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                        return false;
                    }
                    pval = scan_length;
 
                    switch (type)
                    {
                        case ECPGt_float:
                            *((float *) (var + offset * act_tuple)) = dres;
                            break;
                        case ECPGt_double:
                            *((double *) (var + offset * act_tuple)) = dres;
                            break;
                        default:
                            /* Cannot happen */
                            break;
                    }
                    break;
 
                case ECPGt_bool:
                    if (pval[0] == 'f' && pval[1] == '\0')
                    {
                        *((bool *) (var + offset * act_tuple)) = false;
                        pval++;
                        break;
                    }
                    else if (pval[0] == 't' && pval[1] == '\0')
                    {
                        *((bool *) (var + offset * act_tuple)) = true;
                        pval++;
                        break;
                    }
                    else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
                    {
                        /* NULL is valid */
                        break;
                    }
 
                    ecpg_raise(lineno, ECPG_CONVERT_BOOL,
                               ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                    return false;
                    break;
 
                case ECPGt_bytea:
                    {
                        struct ECPGgeneric_bytea *variable =
                            (struct ECPGgeneric_bytea *) (var + offset * act_tuple);
                        long        dst_size,
                                    src_size,
                                    dec_size;
 
                        dst_size = ecpg_hex_enc_len(varcharsize);
                        src_size = size - 2;    /* exclude backslash + 'x' */
                        dec_size = src_size < dst_size ? src_size : dst_size;
                        variable->len = hex_decode(pval + 2, dec_size, variable->arr);
 
                        if (dst_size < src_size)
                        {
                            long        rcv_size = ecpg_hex_dec_len(size - 2);
 
                            /* truncation */
                            switch (ind_type)
                            {
                                case ECPGt_short:
                                case ECPGt_unsigned_short:
                                    *((short *) (ind + ind_offset * act_tuple)) = rcv_size;
                                    break;
                                case ECPGt_int:
                                case ECPGt_unsigned_int:
                                    *((int *) (ind + ind_offset * act_tuple)) = rcv_size;
                                    break;
                                case ECPGt_long:
                                case ECPGt_unsigned_long:
                                    *((long *) (ind + ind_offset * act_tuple)) = rcv_size;
                                    break;
                                case ECPGt_long_long:
                                case ECPGt_unsigned_long_long:
                                    *((long long int *) (ind + ind_offset * act_tuple)) = rcv_size;
                                    break;
                                default:
                                    break;
                            }
                            sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
                        }
 
                        pval += size;
                    }
                    break;
 
                case ECPGt_char:
                case ECPGt_unsigned_char:
                case ECPGt_string:
                    {
                        char       *str = (char *) (var + offset * act_tuple);
 
                        /*
                         * If varcharsize is unknown and the offset is that of
                         * char *, then this variable represents the array of
                         * character pointers. So, use extra indirection.
                         */
                        if (varcharsize == 0 && offset == sizeof(char *))
                            str = *(char **) str;
 
                        if (varcharsize > size)
                        {
                            /*
                             * compatibility mode, blank pad and null
                             * terminate char array
                             */
                            if (ORACLE_MODE(compat) && (type == ECPGt_char || type == ECPGt_unsigned_char))
                            {
                                memset(str, ' ', varcharsize);
                                memcpy(str, pval, size);
                                str[varcharsize - 1] = '\0';
 
                                /*
                                 * compatibility mode empty string gets -1
                                 * indicator but no warning
                                 */
                                if (size == 0)
                                {
                                    /* truncation */
                                    switch (ind_type)
                                    {
                                        case ECPGt_short:
                                        case ECPGt_unsigned_short:
                                            *((short *) (ind + ind_offset * act_tuple)) = -1;
                                            break;
                                        case ECPGt_int:
                                        case ECPGt_unsigned_int:
                                            *((int *) (ind + ind_offset * act_tuple)) = -1;
                                            break;
                                        case ECPGt_long:
                                        case ECPGt_unsigned_long:
                                            *((long *) (ind + ind_offset * act_tuple)) = -1;
                                            break;
                                        case ECPGt_long_long:
                                        case ECPGt_unsigned_long_long:
                                            *((long long int *) (ind + ind_offset * act_tuple)) = -1;
                                            break;
                                        default:
                                            break;
                                    }
                                }
                            }
                            else
                            {
                                strncpy(str, pval, size + 1);
                            }
                            /* do the rtrim() */
                            if (type == ECPGt_string)
                            {
                                char       *last = str + size;
 
                                while (last > str && (*last == ' ' || *last == '\0'))
                                {
                                    *last = '\0';
                                    last--;
                                }
                            }
                        }
                        else
                        {
                            int         charsize = varcharsize;
 
                            /*
                             * assume that the caller provided storage exactly
                             * fit when varcharsize is zero.
                             */
                            if (varcharsize == 0)
                                charsize = size + 1;
 
                            strncpy(str, pval, charsize);
 
                            /* compatibility mode, null terminate char array */
                            if (ORACLE_MODE(compat) && (charsize - 1) < size)
                            {
                                if (type == ECPGt_char || type == ECPGt_unsigned_char)
                                    str[charsize - 1] = '\0';
                            }
 
                            if (charsize < size || (ORACLE_MODE(compat) && (charsize - 1) < size))
                            {
                                /* truncation */
                                switch (ind_type)
                                {
                                    case ECPGt_short:
                                    case ECPGt_unsigned_short:
                                        *((short *) (ind + ind_offset * act_tuple)) = size;
                                        break;
                                    case ECPGt_int:
                                    case ECPGt_unsigned_int:
                                        *((int *) (ind + ind_offset * act_tuple)) = size;
                                        break;
                                    case ECPGt_long:
                                    case ECPGt_unsigned_long:
                                        *((long *) (ind + ind_offset * act_tuple)) = size;
                                        break;
                                    case ECPGt_long_long:
                                    case ECPGt_unsigned_long_long:
                                        *((long long int *) (ind + ind_offset * act_tuple)) = size;
                                        break;
                                    default:
                                        break;
                                }
                                sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
                            }
                        }
                        pval += size;
                    }
                    break;
 
                case ECPGt_varchar:
                    {
                        struct ECPGgeneric_varchar *variable =
                            (struct ECPGgeneric_varchar *) (var + offset * act_tuple);
 
                        variable->len = size;
                        if (varcharsize == 0)
                            strncpy(variable->arr, pval, variable->len);
                        else
                        {
                            strncpy(variable->arr, pval, varcharsize);
 
                            if (variable->len > varcharsize)
                            {
                                /* truncation */
                                switch (ind_type)
                                {
                                    case ECPGt_short:
                                    case ECPGt_unsigned_short:
                                        *((short *) (ind + ind_offset * act_tuple)) = variable->len;
                                        break;
                                    case ECPGt_int:
                                    case ECPGt_unsigned_int:
                                        *((int *) (ind + ind_offset * act_tuple)) = variable->len;
                                        break;
                                    case ECPGt_long:
                                    case ECPGt_unsigned_long:
                                        *((long *) (ind + ind_offset * act_tuple)) = variable->len;
                                        break;
                                    case ECPGt_long_long:
                                    case ECPGt_unsigned_long_long:
                                        *((long long int *) (ind + ind_offset * act_tuple)) = variable->len;
                                        break;
                                    default:
                                        break;
                                }
                                sqlca->sqlwarn[0] = sqlca->sqlwarn[1] = 'W';
 
                                variable->len = varcharsize;
                            }
                        }
                        pval += size;
                    }
                    break;
 
                case ECPGt_decimal:
                case ECPGt_numeric:
                    for (endptr = pval; *endptr && *endptr != ',' && *endptr != '}'; endptr++);
                    endchar = *endptr;
                    *endptr = '\0';
                    nres = PGTYPESnumeric_from_asc(pval, &scan_length);
                    *endptr = endchar;
 
                    /* did we get an error? */
                    if (nres == NULL)
                    {
                        ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
                                 lineno, pval, errno);
 
                        if (INFORMIX_MODE(compat))
                        {
                            /*
                             * Informix wants its own NULL value here instead
                             * of an error
                             */
                            nres = PGTYPESnumeric_new();
                            if (nres)
                                ECPGset_noind_null(ECPGt_numeric, nres);
                            else
                            {
                                ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                                           ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
                                return false;
                            }
                        }
                        else
                        {
                            ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    else
                    {
                        if (!isarray && garbage_left(isarray, &scan_length, compat))
                        {
                            free(nres);
                            ecpg_raise(lineno, ECPG_NUMERIC_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    pval = scan_length;
 
                    if (type == ECPGt_numeric)
                        PGTYPESnumeric_copy(nres, (numeric *) (var + offset * act_tuple));
                    else
                        PGTYPESnumeric_to_decimal(nres, (decimal *) (var + offset * act_tuple));
 
                    PGTYPESnumeric_free(nres);
                    break;
 
                case ECPGt_interval:
                    if (*pval == '"')
                        pval++;
 
                    for (endptr = pval; *endptr && *endptr != ',' && *endptr != '"' && *endptr != '}'; endptr++);
                    endchar = *endptr;
                    *endptr = '\0';
                    ires = PGTYPESinterval_from_asc(pval, &scan_length);
                    *endptr = endchar;
 
                    /* did we get an error? */
                    if (ires == NULL)
                    {
                        ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
                                 lineno, pval, errno);
 
                        if (INFORMIX_MODE(compat))
                        {
                            /*
                             * Informix wants its own NULL value here instead
                             * of an error
                             */
                            ires = (interval *) ecpg_alloc(sizeof(interval), lineno);
                            if (!ires)
                                return false;
 
                            ECPGset_noind_null(ECPGt_interval, ires);
                        }
                        else
                        {
                            ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    else
                    {
                        if (*scan_length == '"')
                            scan_length++;
 
                        if (!isarray && garbage_left(isarray, &scan_length, compat))
                        {
                            free(ires);
                            ecpg_raise(lineno, ECPG_INTERVAL_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    pval = scan_length;
 
                    PGTYPESinterval_copy(ires, (interval *) (var + offset * act_tuple));
                    free(ires);
                    break;
 
                case ECPGt_date:
                    if (*pval == '"')
                        pval++;
 
                    for (endptr = pval; *endptr && *endptr != ',' && *endptr != '"' && *endptr != '}'; endptr++);
                    endchar = *endptr;
                    *endptr = '\0';
                    ddres = PGTYPESdate_from_asc(pval, &scan_length);
                    *endptr = endchar;
 
                    /* did we get an error? */
                    if (errno != 0)
                    {
                        ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
                                 lineno, pval, errno);
 
                        if (INFORMIX_MODE(compat))
                        {
                            /*
                             * Informix wants its own NULL value here instead
                             * of an error
                             */
                            ECPGset_noind_null(ECPGt_date, &ddres);
                        }
                        else
                        {
                            ecpg_raise(lineno, ECPG_DATE_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    else
                    {
                        if (*scan_length == '"')
                            scan_length++;
 
                        if (!isarray && garbage_left(isarray, &scan_length, compat))
                        {
                            ecpg_raise(lineno, ECPG_DATE_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
 
                    *((date *) (var + offset * act_tuple)) = ddres;
                    pval = scan_length;
                    break;
 
                case ECPGt_timestamp:
                    if (*pval == '"')
                        pval++;
 
                    for (endptr = pval; *endptr && *endptr != ',' && *endptr != '"' && *endptr != '}'; endptr++);
                    endchar = *endptr;
                    *endptr = '\0';
                    tres = PGTYPEStimestamp_from_asc(pval, &scan_length);
                    *endptr = endchar;
 
                    /* did we get an error? */
                    if (errno != 0)
                    {
                        ecpg_log("ecpg_get_data on line %d: RESULT %s; errno %d\n",
                                 lineno, pval, errno);
 
                        if (INFORMIX_MODE(compat))
                        {
                            /*
                             * Informix wants its own NULL value here instead
                             * of an error
                             */
                            ECPGset_noind_null(ECPGt_timestamp, &tres);
                        }
                        else
                        {
                            ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
                    else
                    {
                        if (*scan_length == '"')
                            scan_length++;
 
                        if (!isarray && garbage_left(isarray, &scan_length, compat))
                        {
                            ecpg_raise(lineno, ECPG_TIMESTAMP_FORMAT,
                                       ECPG_SQLSTATE_DATATYPE_MISMATCH, pval);
                            return false;
                        }
                    }
 
                    *((timestamp *) (var + offset * act_tuple)) = tres;
                    pval = scan_length;
                    break;
 
                default:
                    ecpg_raise(lineno, ECPG_UNSUPPORTED,
                               ECPG_SQLSTATE_ECPG_INTERNAL_ERROR,
                               ecpg_type_name(type));
                    return false;
                    break;
            }
            if (ECPG_IS_ARRAY(isarray))
            {
                bool        string = false;
 
                /* set array to next entry */
                ++act_tuple;
 
                /* set pval to the next entry */
 
                /*
                 * *pval != '\0' should not be needed, but is used as a safety
                 * guard
                 */
                for (; *pval != '\0' && (string || (!array_delimiter(isarray, *pval) && !array_boundary(isarray, *pval))); ++pval)
                    if (*pval == '"')
                        string = string ? false : true;
 
                if (array_delimiter(isarray, *pval))
                    ++pval;
            }
        }
    } while (*pval != '\0' && !array_boundary(isarray, *pval));
 
    return true;
}

References array_boundary(), array_delimiter(), check_special_value(), compat, ecpg_alloc(), ECPG_ARRAY_ARRAY, ECPG_COMPAT_PGSQL, ECPG_CONVERT_BOOL, ECPG_DATA_NOT_ARRAY, ECPG_DATE_FORMAT, ECPG_FLOAT_FORMAT, ecpg_hex_dec_len(), ecpg_hex_enc_len(), ECPG_INT_FORMAT, ecpg_internal_regression_mode, ECPG_INTERVAL_FORMAT, ECPG_IS_ARRAY, ecpg_log(), ECPG_MISSING_INDICATOR, ECPG_NOT_FOUND, ECPG_NUMERIC_FORMAT, ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_DATATYPE_MISMATCH, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_NO_DATA, ECPG_SQLSTATE_NULL_VALUE_NO_INDICATOR_PARAMETER, ECPG_TIMESTAMP_FORMAT, ecpg_type_name(), ECPG_UINT_FORMAT, ECPG_UNSUPPORTED, ECPGget_sqlca(), ECPGset_noind_null(), ECPGt_bool, ECPGt_bytea, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_NO_INDICATOR, 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, false, force_indicator, free, garbage_left(), hex_decode(), INFORMIX_MODE, ORACLE_MODE, PGTYPESdate_from_asc(), PGTYPESinterval_copy(), PGTYPESinterval_from_asc(), PGTYPESnumeric_copy(), PGTYPESnumeric_free(), PGTYPESnumeric_from_asc(), PGTYPESnumeric_new(), PGTYPESnumeric_to_decimal(), PGTYPEStimestamp_from_asc(), PQfformat(), PQgetisnull, PQgetlength, PQgetvalue, sqlca, str, and type.

Referenced by ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), and ecpg_store_result().

ecpg_hex_dec_len()

unsigned ecpg_hex_dec_len

(

unsigned

srclen

)

Definition at line 123 of file data.c.

{
    return srclen >> 1;
}

Referenced by ecpg_get_data().

ecpg_hex_enc_len()

unsigned ecpg_hex_enc_len

(

unsigned

srclen

)

Definition at line 117 of file data.c.

{
    return srclen << 1;
}

Referenced by convert_bytea_to_string(), ecpg_get_data(), and print_param_value().

ecpg_hex_encode()

unsigned ecpg_hex_encode	(	const char *	src,
		unsigned	len,
		char *	dst
	)

Definition at line 180 of file data.c.

{
    static const char hextbl[] = "0123456789abcdef";
    const char *end = src + len;
 
    while (src < end)
    {
        *dst++ = hextbl[(*src >> 4) & 0xF];
        *dst++ = hextbl[*src & 0xF];
        src++;
    }
    return len * 2;
}

References hextbl, and len.

Referenced by convert_bytea_to_string(), and print_param_value().

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

Referenced by deallocate_one(), ecpg_auto_prepare(), ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ecpg_check_PQresult(), ecpg_execute(), ecpg_finish(), ecpg_get_data(), ecpg_is_type_an_array(), ecpg_process_output(), ecpg_raise(), ecpg_raise_backend(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ecpg_store_result(), ECPGconnect(), ECPGget_desc(), ECPGget_desc_header(), ECPGnoticeReceiver(), ECPGsetcommit(), prepare_common(), print_param_value(), and sqlprint().

ecpg_prepared()

char * ecpg_prepared	(	const char *	name,
		struct connection *	con
	)

Definition at line 389 of file prepare.c.

{
    struct prepared_statement *this;
 
    this = ecpg_find_prepared_statement(name, con, NULL);
    return this ? this->stmt->command : NULL;
}

References ecpg_find_prepared_statement(), name, and stmt.

Referenced by ecpg_do_prologue(), and ECPGprepared_statement().

ecpg_process_output()

bool ecpg_process_output	(	struct statement *	stmt,
		bool	clear_result
	)

Definition at line 1669 of file execute.c.

{
    struct variable *var;
    bool        status = false;
    char       *cmdstat;
    PGnotify   *notify;
    struct sqlca_t *sqlca = ECPGget_sqlca();
    int         nfields,
                ntuples,
                act_field;
 
    if (sqlca == NULL)
    {
        ecpg_raise(stmt->lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    var = stmt->outlist;
    switch (PQresultStatus(stmt->results))
    {
        case PGRES_TUPLES_OK:
            nfields = PQnfields(stmt->results);
            sqlca->sqlerrd[2] = ntuples = PQntuples(stmt->results);
 
            ecpg_log("ecpg_process_output on line %d: correctly got %d tuples with %d fields\n", stmt->lineno, ntuples, nfields);
            status = true;
 
            if (ntuples < 1)
            {
                if (ntuples)
                    ecpg_log("ecpg_process_output on line %d: incorrect number of matches (%d)\n",
                             stmt->lineno, ntuples);
                ecpg_raise(stmt->lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
                status = false;
                break;
            }
 
            if (var != NULL && var->type == ECPGt_descriptor)
            {
                struct descriptor *desc = ecpg_find_desc(stmt->lineno, var->pointer);
 
                if (desc == NULL)
                    status = false;
                else
                {
                    PQclear(desc->result);
                    desc->result = stmt->results;
                    clear_result = false;
                    ecpg_log("ecpg_process_output on line %d: putting result (%d tuples) into descriptor %s\n",
                             stmt->lineno, PQntuples(stmt->results), (const char *) var->pointer);
                }
                var = var->next;
            }
            else if (var != NULL && var->type == ECPGt_sqlda)
            {
                if (INFORMIX_MODE(stmt->compat))
                {
                    struct sqlda_compat **_sqlda = (struct sqlda_compat **) var->pointer;
                    struct sqlda_compat *sqlda = *_sqlda;
                    struct sqlda_compat *sqlda_new;
                    int         i;
 
                    /*
                     * If we are passed in a previously existing sqlda (chain)
                     * then free it.
                     */
                    while (sqlda)
                    {
                        sqlda_new = sqlda->desc_next;
                        free(sqlda);
                        sqlda = sqlda_new;
                    }
                    *_sqlda = sqlda = sqlda_new = NULL;
                    for (i = ntuples - 1; i >= 0; i--)
                    {
                        /*
                         * Build a new sqlda structure. Note that only
                         * fetching 1 record is supported
                         */
                        sqlda_new = ecpg_build_compat_sqlda(stmt->lineno, stmt->results, i, stmt->compat);
 
                        if (!sqlda_new)
                        {
                            /* cleanup all SQLDAs we created up */
                            while (sqlda)
                            {
                                sqlda_new = sqlda->desc_next;
                                free(sqlda);
                                sqlda = sqlda_new;
                            }
                            *_sqlda = NULL;
 
                            ecpg_log("ecpg_process_output on line %d: out of memory allocating a new sqlda\n", stmt->lineno);
                            status = false;
                            break;
                        }
                        else
                        {
                            ecpg_log("ecpg_process_output on line %d: new sqlda was built\n", stmt->lineno);
 
                            *_sqlda = sqlda_new;
 
                            ecpg_set_compat_sqlda(stmt->lineno, _sqlda, stmt->results, i, stmt->compat);
                            ecpg_log("ecpg_process_output on line %d: putting result (1 tuple %d fields) into sqlda descriptor\n",
                                     stmt->lineno, PQnfields(stmt->results));
 
                            sqlda_new->desc_next = sqlda;
                            sqlda = sqlda_new;
                        }
                    }
                }
                else
                {
                    struct sqlda_struct **_sqlda = (struct sqlda_struct **) var->pointer;
                    struct sqlda_struct *sqlda = *_sqlda;
                    struct sqlda_struct *sqlda_new;
                    int         i;
 
                    /*
                     * If we are passed in a previously existing sqlda (chain)
                     * then free it.
                     */
                    while (sqlda)
                    {
                        sqlda_new = sqlda->desc_next;
                        free(sqlda);
                        sqlda = sqlda_new;
                    }
                    *_sqlda = sqlda = sqlda_new = NULL;
                    for (i = ntuples - 1; i >= 0; i--)
                    {
                        /*
                         * Build a new sqlda structure. Note that only
                         * fetching 1 record is supported
                         */
                        sqlda_new = ecpg_build_native_sqlda(stmt->lineno, stmt->results, i, stmt->compat);
 
                        if (!sqlda_new)
                        {
                            /* cleanup all SQLDAs we created up */
                            while (sqlda)
                            {
                                sqlda_new = sqlda->desc_next;
                                free(sqlda);
                                sqlda = sqlda_new;
                            }
                            *_sqlda = NULL;
 
                            ecpg_log("ecpg_process_output on line %d: out of memory allocating a new sqlda\n", stmt->lineno);
                            status = false;
                            break;
                        }
                        else
                        {
                            ecpg_log("ecpg_process_output on line %d: new sqlda was built\n", stmt->lineno);
 
                            *_sqlda = sqlda_new;
 
                            ecpg_set_native_sqlda(stmt->lineno, _sqlda, stmt->results, i, stmt->compat);
                            ecpg_log("ecpg_process_output on line %d: putting result (1 tuple %d fields) into sqlda descriptor\n",
                                     stmt->lineno, PQnfields(stmt->results));
 
                            sqlda_new->desc_next = sqlda;
                            sqlda = sqlda_new;
                        }
                    }
                }
 
                var = var->next;
            }
            else
                for (act_field = 0; act_field < nfields && status; act_field++)
                {
                    if (var != NULL)
                    {
                        status = ecpg_store_result(stmt->results, act_field, stmt, var);
                        var = var->next;
                    }
                    else if (!INFORMIX_MODE(stmt->compat))
                    {
                        ecpg_raise(stmt->lineno, ECPG_TOO_FEW_ARGUMENTS, ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS, NULL);
                        return false;
                    }
                }
 
            if (status && var != NULL)
            {
                ecpg_raise(stmt->lineno, ECPG_TOO_MANY_ARGUMENTS, ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS, NULL);
                status = false;
            }
 
            break;
        case PGRES_COMMAND_OK:
            status = true;
            cmdstat = PQcmdStatus(stmt->results);
            sqlca->sqlerrd[1] = PQoidValue(stmt->results);
            sqlca->sqlerrd[2] = atol(PQcmdTuples(stmt->results));
            ecpg_log("ecpg_process_output on line %d: OK: %s\n", stmt->lineno, cmdstat);
            if (stmt->compat != ECPG_COMPAT_INFORMIX_SE &&
                !sqlca->sqlerrd[2] &&
                (strncmp(cmdstat, "UPDATE", 6) == 0
                 || strncmp(cmdstat, "INSERT", 6) == 0
                 || strncmp(cmdstat, "DELETE", 6) == 0))
                ecpg_raise(stmt->lineno, ECPG_NOT_FOUND, ECPG_SQLSTATE_NO_DATA, NULL);
            break;
        case PGRES_COPY_OUT:
            {
                char       *buffer;
                int         res;
 
                ecpg_log("ecpg_process_output on line %d: COPY OUT data transfer in progress\n", stmt->lineno);
                while ((res = PQgetCopyData(stmt->connection->connection,
                                            &buffer, 0)) > 0)
                {
                    printf("%s", buffer);
                    PQfreemem(buffer);
                }
                if (res == -1)
                {
                    /* COPY done */
                    PQclear(stmt->results);
                    stmt->results = PQgetResult(stmt->connection->connection);
                    if (PQresultStatus(stmt->results) == PGRES_COMMAND_OK)
                        ecpg_log("ecpg_process_output on line %d: got PGRES_COMMAND_OK after PGRES_COPY_OUT\n", stmt->lineno);
                    else
                        ecpg_log("ecpg_process_output on line %d: got error after PGRES_COPY_OUT: %s", stmt->lineno, PQresultErrorMessage(stmt->results));
                }
                break;
            }
        default:
 
            /*
             * execution should never reach this code because it is already
             * handled in ecpg_check_PQresult()
             */
            ecpg_log("ecpg_process_output on line %d: unknown execution status type\n",
                     stmt->lineno);
            ecpg_raise_backend(stmt->lineno, stmt->results, stmt->connection->connection, stmt->compat);
            status = false;
            break;
    }
 
    if (clear_result)
    {
        PQclear(stmt->results);
        stmt->results = NULL;
    }
 
    /* check for asynchronous returns */
    PQconsumeInput(stmt->connection->connection);
    while ((notify = PQnotifies(stmt->connection->connection)) != NULL)
    {
        ecpg_log("ecpg_process_output on line %d: asynchronous notification of \"%s\" from backend PID %d received\n",
                 stmt->lineno, notify->relname, notify->be_pid);
        PQfreemem(notify);
        PQconsumeInput(stmt->connection->connection);
    }
 
    return status;
}

References pgNotify::be_pid, ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), ECPG_COMPAT_INFORMIX_SE, ecpg_find_desc(), ecpg_log(), ECPG_NOT_FOUND, ECPG_OUT_OF_MEMORY, ecpg_raise(), ecpg_raise_backend(), ecpg_set_compat_sqlda(), ecpg_set_native_sqlda(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_NO_DATA, ECPG_SQLSTATE_USING_CLAUSE_DOES_NOT_MATCH_TARGETS, ecpg_store_result(), ECPG_TOO_FEW_ARGUMENTS, ECPG_TOO_MANY_ARGUMENTS, ECPGget_sqlca(), ECPGt_descriptor, ECPGt_sqlda, free, i, INFORMIX_MODE, variable::next, PGRES_COMMAND_OK, PGRES_COPY_OUT, PGRES_TUPLES_OK, variable::pointer, PQclear, PQcmdStatus, PQcmdTuples, PQconsumeInput(), PQfreemem(), PQgetCopyData(), PQgetResult, PQnfields, PQnotifies(), PQntuples, PQoidValue(), PQresultErrorMessage, PQresultStatus, printf, pgNotify::relname, descriptor::result, sqlca, stmt, variable::type, and while().

Referenced by ecpg_do().

ecpg_pthreads_init()

void ecpg_pthreads_init

(

void

)

Definition at line 30 of file connect.c.

{
    pthread_once(&actual_connection_key_once, ecpg_actual_connection_init);
}

ecpg_raise()

void ecpg_raise	(	int	line,
		int	code,
		const char *	sqlstate,
		const char *	str
	)

Definition at line 13 of file error.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_log("out of memory");
        ECPGfree_auto_mem();
        return;
    }
 
    sqlca->sqlcode = code;
    strncpy(sqlca->sqlstate, sqlstate, sizeof(sqlca->sqlstate));
 
    switch (code)
    {
        case ECPG_NOT_FOUND:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("no data found on line %d"), line);
            break;
 
        case ECPG_OUT_OF_MEMORY:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("out of memory on line %d"), line);
            break;
 
        case ECPG_UNSUPPORTED:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("unsupported type \"%s\" on line %d"), str, line);
            break;
 
        case ECPG_TOO_MANY_ARGUMENTS:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("too many arguments on line %d"), line);
            break;
 
        case ECPG_TOO_FEW_ARGUMENTS:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("too few arguments on line %d"), line);
            break;
 
        case ECPG_INT_FORMAT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("invalid input syntax for type int: \"%s\", on line %d"), str, line);
            break;
 
        case ECPG_UINT_FORMAT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("invalid input syntax for type unsigned int: \"%s\", on line %d"), str, line);
            break;
 
        case ECPG_FLOAT_FORMAT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("invalid input syntax for floating-point type: \"%s\", on line %d"), str, line);
            break;
 
        case ECPG_CONVERT_BOOL:
            if (str)
                snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
                /*------
                   translator: this string will be truncated at 149 characters expanded.  */
                         ecpg_gettext("invalid syntax for type boolean: \"%s\", on line %d"), str, line);
            else
                snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
                /*------
                   translator: this string will be truncated at 149 characters expanded.  */
                         ecpg_gettext("could not convert boolean value: size mismatch, on line %d"), line);
            break;
 
        case ECPG_EMPTY:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("empty query on line %d"), line);
            break;
 
        case ECPG_MISSING_INDICATOR:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("null value without indicator on line %d"), line);
            break;
 
        case ECPG_NO_ARRAY:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("variable does not have an array type on line %d"), line);
            break;
 
        case ECPG_DATA_NOT_ARRAY:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("data read from server is not an array on line %d"), line);
            break;
 
        case ECPG_ARRAY_INSERT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("inserting an array of variables is not supported on line %d"), line);
            break;
 
        case ECPG_NO_CONN:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("connection \"%s\" does not exist on line %d"), str, line);
            break;
 
        case ECPG_NOT_CONN:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("not connected to connection \"%s\" on line %d"), str, line);
            break;
 
        case ECPG_INVALID_STMT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("invalid statement name \"%s\" on line %d"), str, line);
            break;
 
        case ECPG_UNKNOWN_DESCRIPTOR:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("descriptor \"%s\" not found on line %d"), str, line);
            break;
 
        case ECPG_INVALID_DESCRIPTOR_INDEX:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("descriptor index out of range on line %d"), line);
            break;
 
        case ECPG_UNKNOWN_DESCRIPTOR_ITEM:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("unrecognized descriptor item \"%s\" on line %d"), str, line);
            break;
 
        case ECPG_VAR_NOT_NUMERIC:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("variable does not have a numeric type on line %d"), line);
            break;
 
        case ECPG_VAR_NOT_CHAR:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("variable does not have a character type on line %d"), line);
            break;
 
        case ECPG_TRANS:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("error in transaction processing on line %d"), line);
            break;
 
        case ECPG_CONNECT:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("could not connect to database \"%s\" on line %d"), str, line);
            break;
 
        default:
            snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc),
            /*------
               translator: this string will be truncated at 149 characters expanded.  */
                     ecpg_gettext("SQL error %d on line %d"), code, line);
            break;
    }
 
    sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
    ecpg_log("raising sqlcode %d on line %d: %s\n", code, line, sqlca->sqlerrm.sqlerrmc);
 
    /* free all memory we have allocated for the user */
    ECPGfree_auto_mem();
}

References ECPG_ARRAY_INSERT, ECPG_CONNECT, ECPG_CONVERT_BOOL, ECPG_DATA_NOT_ARRAY, ECPG_EMPTY, ECPG_FLOAT_FORMAT, ecpg_gettext, ECPG_INT_FORMAT, ECPG_INVALID_DESCRIPTOR_INDEX, ECPG_INVALID_STMT, ecpg_log(), ECPG_MISSING_INDICATOR, ECPG_NO_ARRAY, ECPG_NO_CONN, ECPG_NOT_CONN, ECPG_NOT_FOUND, ECPG_OUT_OF_MEMORY, ECPG_TOO_FEW_ARGUMENTS, ECPG_TOO_MANY_ARGUMENTS, ECPG_TRANS, ECPG_UINT_FORMAT, ECPG_UNKNOWN_DESCRIPTOR, ECPG_UNKNOWN_DESCRIPTOR_ITEM, ECPG_UNSUPPORTED, ECPG_VAR_NOT_CHAR, ECPG_VAR_NOT_NUMERIC, ECPGfree_auto_mem(), ECPGget_sqlca(), snprintf, sqlca, sqlca_t::sqlstate, and str.

Referenced by deallocate_one(), ecpg_alloc(), ecpg_build_params(), ecpg_check_PQresult(), ecpg_do_prologue(), ecpg_find_desc(), ecpg_get_data(), ecpg_init(), ecpg_process_output(), ecpg_realloc(), ecpg_store_input(), ecpg_store_result(), ecpg_strdup(), ECPGallocate_desc(), ECPGconnect(), ECPGdeallocate(), ECPGdeallocate_desc(), ECPGdescribe(), ECPGdisconnect(), ECPGget_desc(), ECPGget_desc_header(), ECPGset_desc(), ECPGset_var(), ECPGstatus(), get_char_item(), get_int_item(), and set_int_item().

ecpg_raise_backend()

void ecpg_raise_backend	(	int	line,
		PGresult *	result,
		PGconn *	conn,
		int	compat
	)

Definition at line 219 of file error.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
    char       *sqlstate;
    char       *message;
 
    if (sqlca == NULL)
    {
        ecpg_log("out of memory");
        ECPGfree_auto_mem();
        return;
    }
 
    /*
     * PQresultErrorField will return NULL if "result" is NULL, or if there is
     * no such field, which will happen for libpq-generated errors.  Fall back
     * to PQerrorMessage in such cases.
     */
    sqlstate = PQresultErrorField(result, PG_DIAG_SQLSTATE);
    if (sqlstate == NULL)
        sqlstate = ECPG_SQLSTATE_ECPG_INTERNAL_ERROR;
    message = PQresultErrorField(result, PG_DIAG_MESSAGE_PRIMARY);
    if (message == NULL)
        message = PQerrorMessage(conn);
 
    if (strcmp(sqlstate, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR) == 0)
    {
        /*
         * we might get here if the connection breaks down, so let's check for
         * this instead of giving just the generic internal error
         */
        if (PQstatus(conn) == CONNECTION_BAD)
        {
            sqlstate = "57P02";
            message = ecpg_gettext("the connection to the server was lost");
        }
    }
 
    /* copy error message */
    snprintf(sqlca->sqlerrm.sqlerrmc, sizeof(sqlca->sqlerrm.sqlerrmc), "%s on line %d", message, line);
    sqlca->sqlerrm.sqlerrml = strlen(sqlca->sqlerrm.sqlerrmc);
 
    /* copy SQLSTATE */
    strncpy(sqlca->sqlstate, sqlstate, sizeof(sqlca->sqlstate));
 
    /* assign SQLCODE for backward compatibility */
    if (strncmp(sqlca->sqlstate, "23505", sizeof(sqlca->sqlstate)) == 0)
        sqlca->sqlcode = INFORMIX_MODE(compat) ? ECPG_INFORMIX_DUPLICATE_KEY : ECPG_DUPLICATE_KEY;
    else if (strncmp(sqlca->sqlstate, "21000", sizeof(sqlca->sqlstate)) == 0)
        sqlca->sqlcode = INFORMIX_MODE(compat) ? ECPG_INFORMIX_SUBSELECT_NOT_ONE : ECPG_SUBSELECT_NOT_ONE;
    else
        sqlca->sqlcode = ECPG_PGSQL;
 
    ecpg_log("raising sqlstate %.*s (sqlcode %ld): %s\n",
             (int) sizeof(sqlca->sqlstate), sqlca->sqlstate, sqlca->sqlcode, sqlca->sqlerrm.sqlerrmc);
 
    /* free all memory we have allocated for the user */
    ECPGfree_auto_mem();
}

References compat, conn, CONNECTION_BAD, ECPG_DUPLICATE_KEY, ecpg_gettext, ECPG_INFORMIX_DUPLICATE_KEY, ECPG_INFORMIX_SUBSELECT_NOT_ONE, ecpg_log(), ECPG_PGSQL, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ECPG_SUBSELECT_NOT_ONE, ECPGfree_auto_mem(), ECPGget_sqlca(), INFORMIX_MODE, PG_DIAG_MESSAGE_PRIMARY, PG_DIAG_SQLSTATE, PQerrorMessage(), PQresultErrorField, PQstatus(), snprintf, sqlca, and sqlca_t::sqlstate.

Referenced by ecpg_check_PQresult(), and ecpg_process_output().

ecpg_realloc()

char * ecpg_realloc	(	void *	ptr,
		long	size,
		int	lineno
	)

Definition at line 33 of file memory.c.

{
    char       *new = (char *) realloc(ptr, size);
 
    if (!new)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return NULL;
    }
 
    return new;
}

References ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, and realloc.

Referenced by ecpg_build_params(), and ecpg_store_input().

ecpg_register_prepared_stmt()

bool ecpg_register_prepared_stmt

(

struct statement *

stmt

)

Definition at line 59 of file prepare.c.

{
    struct statement *prep_stmt;
    struct prepared_statement *this;
    struct connection *con = stmt->connection;
    struct prepared_statement *prev = NULL;
    int         lineno = stmt->lineno;
 
    /* check if we already have prepared this statement */
    this = ecpg_find_prepared_statement(stmt->name, con, &prev);
    if (this && !deallocate_one(lineno, ECPG_COMPAT_PGSQL, con, prev, this))
        return false;
 
    /* allocate new statement */
    this = (struct prepared_statement *) ecpg_alloc(sizeof(struct prepared_statement), lineno);
    if (!this)
        return false;
 
    prep_stmt = (struct statement *) ecpg_alloc(sizeof(struct statement), lineno);
    if (!prep_stmt)
    {
        ecpg_free(this);
        return false;
    }
    memset(prep_stmt, 0, sizeof(struct statement));
 
    /* create statement */
    prep_stmt->lineno = lineno;
    prep_stmt->connection = con;
    prep_stmt->command = ecpg_strdup(stmt->command, lineno, NULL);
    if (!prep_stmt->command)
    {
        ecpg_free(prep_stmt);
        ecpg_free(this);
        return false;
    }
    prep_stmt->inlist = prep_stmt->outlist = NULL;
    this->name = ecpg_strdup(stmt->name, lineno, NULL);
    if (!this->name)
    {
        ecpg_free(prep_stmt->command);
        ecpg_free(prep_stmt);
        ecpg_free(this);
        return false;
    }
    this->stmt = prep_stmt;
    this->prepared = true;
 
    if (con->prep_stmts == NULL)
        this->next = NULL;
    else
        this->next = con->prep_stmts;
 
    con->prep_stmts = this;
    return true;
}

References statement::command, statement::connection, deallocate_one(), ecpg_alloc(), ECPG_COMPAT_PGSQL, ecpg_find_prepared_statement(), ecpg_free(), ecpg_strdup(), statement::inlist, statement::lineno, name, statement::name, next, statement::outlist, connection::prep_stmts, and stmt.

Referenced by ecpg_execute().

ecpg_set_compat_sqlda()

void ecpg_set_compat_sqlda	(	int	lineno,
		struct sqlda_compat **	_sqlda,
		const PGresult *	res,
		int	row,
		enum COMPAT_MODE	compat
	)

Definition at line 255 of file sqlda.c.

{
    struct sqlda_compat *sqlda = (*_sqlda);
    int         i;
    long        offset,
                next_offset;
 
    if (row < 0)
        return;
 
    /* Offset for the first field value */
    offset = sqlda_compat_empty_size(res);
 
    /*
     * Set sqlvar[i]->sqldata pointers and convert values to correct format
     */
    for (i = 0; i < sqlda->sqld; i++)
    {
        int         isnull;
        int         datalen;
        bool        set_data = true;
 
        switch (sqlda->sqlvar[i].sqltype)
        {
            case ECPGt_short:
            case ECPGt_unsigned_short:
                ecpg_sqlda_align_add_size(offset, sizeof(short), sizeof(short), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(short);
                break;
            case ECPGt_int:
            case ECPGt_unsigned_int:
                ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(int), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(int);
                break;
            case ECPGt_long:
            case ECPGt_unsigned_long:
                ecpg_sqlda_align_add_size(offset, sizeof(long), sizeof(long), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(long);
                break;
            case ECPGt_long_long:
            case ECPGt_unsigned_long_long:
                ecpg_sqlda_align_add_size(offset, sizeof(long long), sizeof(long long), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(long long);
                break;
            case ECPGt_bool:
                ecpg_sqlda_align_add_size(offset, sizeof(bool), sizeof(bool), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(bool);
                break;
            case ECPGt_float:
                ecpg_sqlda_align_add_size(offset, sizeof(float), sizeof(float), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(float);
                break;
            case ECPGt_double:
                ecpg_sqlda_align_add_size(offset, sizeof(double), sizeof(double), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(double);
                break;
            case ECPGt_decimal:
                ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(decimal), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(decimal);
                break;
            case ECPGt_numeric:
                {
                    numeric    *num;
                    char       *val;
 
                    set_data = false;
 
                    ecpg_sqlda_align_add_size(offset, sizeof(NumericDigit *), sizeof(numeric), &offset, &next_offset);
                    sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                    sqlda->sqlvar[i].sqllen = sizeof(numeric);
 
                    if (PQgetisnull(res, row, i))
                    {
                        ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
                        break;
                    }
 
                    val = PQgetvalue(res, row, i);
                    num = PGTYPESnumeric_from_asc(val, NULL);
                    if (!num)
                    {
                        ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
                        break;
                    }
 
                    memcpy(sqlda->sqlvar[i].sqldata, num, sizeof(numeric));
 
                    if (num->buf)
                    {
                        ecpg_sqlda_align_add_size(next_offset, sizeof(int), num->digits - num->buf + num->ndigits, &offset, &next_offset);
                        memcpy((char *) sqlda + offset, num->buf, num->digits - num->buf + num->ndigits);
 
                        ((numeric *) sqlda->sqlvar[i].sqldata)->buf = (NumericDigit *) sqlda + offset;
                        ((numeric *) sqlda->sqlvar[i].sqldata)->digits = (NumericDigit *) sqlda + offset + (num->digits - num->buf);
                    }
 
                    PGTYPESnumeric_free(num);
 
                    break;
                }
            case ECPGt_date:
                ecpg_sqlda_align_add_size(offset, sizeof(date), sizeof(date), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(date);
                break;
            case ECPGt_timestamp:
                ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(timestamp), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(timestamp);
                break;
            case ECPGt_interval:
                ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(interval), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(interval);
                break;
            case ECPGt_char:
            case ECPGt_unsigned_char:
            case ECPGt_string:
            default:
                datalen = strlen(PQgetvalue(res, row, i)) + 1;
                ecpg_sqlda_align_add_size(offset, sizeof(int), datalen, &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = datalen;
                if (datalen > 32768)
                    sqlda->sqlvar[i].sqlilongdata = sqlda->sqlvar[i].sqldata;
                break;
        }
 
        isnull = PQgetisnull(res, row, i);
        ecpg_log("ecpg_set_compat_sqlda on line %d row %d col %d %s\n", lineno, row, i, isnull ? "IS NULL" : "IS NOT NULL");
        sqlda->sqlvar[i].sqlind = isnull ? &value_is_null : &value_is_not_null;
        sqlda->sqlvar[i].sqlitype = ECPGt_short;
        sqlda->sqlvar[i].sqlilen = sizeof(short);
        if (!isnull)
        {
            if (set_data)
                ecpg_get_data(res, row, i, lineno,
                              sqlda->sqlvar[i].sqltype, ECPGt_NO_INDICATOR,
                              sqlda->sqlvar[i].sqldata, NULL, 0, 0, 0,
                              ECPG_ARRAY_NONE, compat, false);
        }
        else
            ECPGset_noind_null(sqlda->sqlvar[i].sqltype, sqlda->sqlvar[i].sqldata);
 
        offset = next_offset;
    }
}

References numeric::buf, compat, numeric::digits, ECPG_ARRAY_NONE, ecpg_get_data(), ecpg_log(), ecpg_sqlda_align_add_size(), ECPGset_noind_null(), ECPGt_bool, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_NO_INDICATOR, ECPGt_numeric, ECPGt_short, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, i, numeric::ndigits, numeric(), PGTYPESnumeric_free(), PGTYPESnumeric_from_asc(), PQgetisnull, PQgetvalue, sqlda_compat::sqld, sqlda_compat_empty_size(), sqlvar_compat::sqldata, sqlvar_compat::sqlilen, sqlvar_compat::sqlilongdata, sqlvar_compat::sqlind, sqlvar_compat::sqlitype, sqlvar_compat::sqllen, sqlvar_compat::sqltype, sqlda_compat::sqlvar, val, value_is_not_null, and value_is_null.

Referenced by ecpg_process_output().

ecpg_set_native_sqlda()

void ecpg_set_native_sqlda	(	int	lineno,
		struct sqlda_struct **	_sqlda,
		const PGresult *	res,
		int	row,
		enum COMPAT_MODE	compat
	)

Definition at line 444 of file sqlda.c.

{
    struct sqlda_struct *sqlda = (*_sqlda);
    int         i;
    long        offset,
                next_offset;
 
    if (row < 0)
        return;
 
    /* Offset for the first field value */
    offset = sqlda_native_empty_size(res);
 
    /*
     * Set sqlvar[i]->sqldata pointers and convert values to correct format
     */
    for (i = 0; i < sqlda->sqld; i++)
    {
        int         isnull;
        int         datalen;
        bool        set_data = true;
 
        switch (sqlda->sqlvar[i].sqltype)
        {
            case ECPGt_short:
            case ECPGt_unsigned_short:
                ecpg_sqlda_align_add_size(offset, sizeof(short), sizeof(short), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(short);
                break;
            case ECPGt_int:
            case ECPGt_unsigned_int:
                ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(int), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(int);
                break;
            case ECPGt_long:
            case ECPGt_unsigned_long:
                ecpg_sqlda_align_add_size(offset, sizeof(long), sizeof(long), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(long);
                break;
            case ECPGt_long_long:
            case ECPGt_unsigned_long_long:
                ecpg_sqlda_align_add_size(offset, sizeof(long long), sizeof(long long), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(long long);
                break;
            case ECPGt_bool:
                ecpg_sqlda_align_add_size(offset, sizeof(bool), sizeof(bool), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(bool);
                break;
            case ECPGt_float:
                ecpg_sqlda_align_add_size(offset, sizeof(float), sizeof(float), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(float);
                break;
            case ECPGt_double:
                ecpg_sqlda_align_add_size(offset, sizeof(double), sizeof(double), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(double);
                break;
            case ECPGt_decimal:
                ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(decimal), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(decimal);
                break;
            case ECPGt_numeric:
                {
                    numeric    *num;
                    char       *val;
 
                    set_data = false;
 
                    ecpg_sqlda_align_add_size(offset, sizeof(NumericDigit *), sizeof(numeric), &offset, &next_offset);
                    sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                    sqlda->sqlvar[i].sqllen = sizeof(numeric);
 
                    if (PQgetisnull(res, row, i))
                    {
                        ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
                        break;
                    }
 
                    val = PQgetvalue(res, row, i);
                    num = PGTYPESnumeric_from_asc(val, NULL);
                    if (!num)
                    {
                        ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
                        break;
                    }
 
                    memcpy(sqlda->sqlvar[i].sqldata, num, sizeof(numeric));
 
                    if (num->buf)
                    {
                        ecpg_sqlda_align_add_size(next_offset, sizeof(int), num->digits - num->buf + num->ndigits, &offset, &next_offset);
                        memcpy((char *) sqlda + offset, num->buf, num->digits - num->buf + num->ndigits);
 
                        ((numeric *) sqlda->sqlvar[i].sqldata)->buf = (NumericDigit *) sqlda + offset;
                        ((numeric *) sqlda->sqlvar[i].sqldata)->digits = (NumericDigit *) sqlda + offset + (num->digits - num->buf);
                    }
 
                    PGTYPESnumeric_free(num);
 
                    break;
                }
            case ECPGt_date:
                ecpg_sqlda_align_add_size(offset, sizeof(date), sizeof(date), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(date);
                break;
            case ECPGt_timestamp:
                ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(timestamp), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(timestamp);
                break;
            case ECPGt_interval:
                ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(interval), &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = sizeof(interval);
                break;
            case ECPGt_char:
            case ECPGt_unsigned_char:
            case ECPGt_string:
            default:
                datalen = strlen(PQgetvalue(res, row, i)) + 1;
                ecpg_sqlda_align_add_size(offset, sizeof(int), datalen, &offset, &next_offset);
                sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
                sqlda->sqlvar[i].sqllen = datalen;
                break;
        }
 
        isnull = PQgetisnull(res, row, i);
        ecpg_log("ecpg_set_native_sqlda on line %d row %d col %d %s\n", lineno, row, i, isnull ? "IS NULL" : "IS NOT NULL");
        sqlda->sqlvar[i].sqlind = isnull ? &value_is_null : &value_is_not_null;
        if (!isnull)
        {
            if (set_data)
                ecpg_get_data(res, row, i, lineno,
                              sqlda->sqlvar[i].sqltype, ECPGt_NO_INDICATOR,
                              sqlda->sqlvar[i].sqldata, NULL, 0, 0, 0,
                              ECPG_ARRAY_NONE, compat, false);
        }
 
        offset = next_offset;
    }
}

References numeric::buf, compat, numeric::digits, ECPG_ARRAY_NONE, ecpg_get_data(), ecpg_log(), ecpg_sqlda_align_add_size(), ECPGset_noind_null(), ECPGt_bool, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_NO_INDICATOR, ECPGt_numeric, ECPGt_short, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, i, numeric::ndigits, numeric(), PGTYPESnumeric_free(), PGTYPESnumeric_from_asc(), PQgetisnull, PQgetvalue, sqlda_struct::sqld, sqlda_native_empty_size(), sqlvar_struct::sqldata, sqlvar_struct::sqlind, sqlvar_struct::sqllen, sqlvar_struct::sqltype, sqlda_struct::sqlvar, val, value_is_not_null, and value_is_null.

Referenced by ecpg_process_output().

ecpg_store_input()

bool ecpg_store_input	(	const int	lineno,
		const bool	force_indicator,
		const struct variable *	var,
		char **	tobeinserted_p,
		bool	quote
	)

Definition at line 506 of file execute.c.

{
    char       *mallocedval = NULL;
    char       *newcopy = NULL;
 
    /*
     * arrays are not possible unless the column is an array, too FIXME: we do
     * not know if the column is an array here array input to singleton column
     * will result in a runtime error
     */
 
    /*
     * Some special treatment is needed for records since we want their
     * contents to arrive in a comma-separated list on insert (I think).
     */
 
    *tobeinserted_p = "";
 
    /* check for null value and set input buffer accordingly */
    switch (var->ind_type)
    {
        case ECPGt_short:
        case ECPGt_unsigned_short:
            if (*(short *) var->ind_value < 0)
                *tobeinserted_p = NULL;
            break;
        case ECPGt_int:
        case ECPGt_unsigned_int:
            if (*(int *) var->ind_value < 0)
                *tobeinserted_p = NULL;
            break;
        case ECPGt_long:
        case ECPGt_unsigned_long:
            if (*(long *) var->ind_value < 0L)
                *tobeinserted_p = NULL;
            break;
        case ECPGt_long_long:
        case ECPGt_unsigned_long_long:
            if (*(long long int *) var->ind_value < (long long) 0)
                *tobeinserted_p = NULL;
            break;
        case ECPGt_NO_INDICATOR:
            if (force_indicator == false)
            {
                if (ECPGis_noind_null(var->type, var->value))
                    *tobeinserted_p = NULL;
            }
            break;
        default:
            break;
    }
    if (*tobeinserted_p != NULL)
    {
        int         asize = var->arrsize ? var->arrsize : 1;
 
        switch (var->type)
        {
                int         element;
 
            case ECPGt_short:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%hd,", ((short *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%hd", *((short *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_int:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%d,", ((int *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%d", *((int *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_unsigned_short:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%hu,", ((unsigned short *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%hu", *((unsigned short *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_unsigned_int:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%u,", ((unsigned int *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%u", *((unsigned int *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_long:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%ld,", ((long *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%ld", *((long *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_unsigned_long:
                if (!(mallocedval = ecpg_alloc(asize * 20, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%lu,", ((unsigned long *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%lu", *((unsigned long *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_long_long:
                if (!(mallocedval = ecpg_alloc(asize * 30, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%lld,", ((long long int *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%lld", *((long long int *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_unsigned_long_long:
                if (!(mallocedval = ecpg_alloc(asize * 30, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%llu,", ((unsigned long long int *) var->value)[element]);
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf(mallocedval, "%llu", *((unsigned long long int *) var->value));
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_float:
                if (!(mallocedval = ecpg_alloc(asize * 25, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf_float_value(mallocedval + strlen(mallocedval), ((float *) var->value)[element], ",");
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf_float_value(mallocedval, *((float *) var->value), "");
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_double:
                if (!(mallocedval = ecpg_alloc(asize * 25, lineno)))
                    return false;
 
                if (asize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf_double_value(mallocedval + strlen(mallocedval), ((double *) var->value)[element], ",");
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                    sprintf_double_value(mallocedval, *((double *) var->value), "");
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_bool:
                if (!(mallocedval = ecpg_alloc(var->arrsize + sizeof("{}"), lineno)))
                    return false;
 
                if (var->arrsize > 1)
                {
                    strcpy(mallocedval, "{");
 
                    for (element = 0; element < asize; element++)
                        sprintf(mallocedval + strlen(mallocedval), "%c,", (((bool *) var->value)[element]) ? 't' : 'f');
 
                    strcpy(mallocedval + strlen(mallocedval) - 1, "}");
                }
                else
                {
                    if (var->offset == sizeof(char))
                        sprintf(mallocedval, "%c", (*((char *) var->value)) ? 't' : 'f');
                    else if (var->offset == sizeof(int))
                        sprintf(mallocedval, "%c", (*((int *) var->value)) ? 't' : 'f');
                    else
                        ecpg_raise(lineno, ECPG_CONVERT_BOOL, ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
                }
 
                *tobeinserted_p = mallocedval;
                break;
 
            case ECPGt_char:
            case ECPGt_unsigned_char:
            case ECPGt_string:
                {
                    /* set slen to string length if type is char * */
                    int         slen = (var->varcharsize == 0) ? strlen((char *) var->value) : (unsigned int) var->varcharsize;
 
                    if (!(newcopy = ecpg_alloc(slen + 1, lineno)))
                        return false;
 
                    strncpy(newcopy, (char *) var->value, slen);
                    newcopy[slen] = '\0';
 
                    mallocedval = quote_postgres(newcopy, quote, lineno);
                    if (!mallocedval)
                    {
                        ecpg_free(newcopy);
                        return false;
                    }
 
                    *tobeinserted_p = mallocedval;
                }
                break;
            case ECPGt_const:
            case ECPGt_char_variable:
                {
                    int         slen = strlen((char *) var->value);
 
                    if (!(mallocedval = ecpg_alloc(slen + 1, lineno)))
                        return false;
 
                    strncpy(mallocedval, (char *) var->value, slen);
                    mallocedval[slen] = '\0';
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_bytea:
                {
                    struct ECPGgeneric_bytea *variable =
                        (struct ECPGgeneric_bytea *) (var->value);
 
                    if (!(mallocedval = ecpg_alloc(variable->len, lineno)))
                        return false;
 
                    memcpy(mallocedval, variable->arr, variable->len);
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_varchar:
                {
                    struct ECPGgeneric_varchar *variable =
                        (struct ECPGgeneric_varchar *) (var->value);
 
                    if (!(newcopy = ecpg_alloc(variable->len + 1, lineno)))
                        return false;
 
                    strncpy(newcopy, variable->arr, variable->len);
                    newcopy[variable->len] = '\0';
 
                    mallocedval = quote_postgres(newcopy, quote, lineno);
                    if (!mallocedval)
                    {
                        ecpg_free(newcopy);
                        return false;
                    }
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_decimal:
            case ECPGt_numeric:
                {
                    char       *str = NULL;
                    int         slen;
                    numeric    *nval;
 
                    if (var->arrsize > 1)
                        mallocedval = ecpg_strdup("{", lineno, NULL);
                    else
                        mallocedval = ecpg_strdup("", lineno, NULL);
 
                    if (!mallocedval)
                        return false;
 
                    for (element = 0; element < asize; element++)
                    {
                        int         result;
 
                        nval = PGTYPESnumeric_new();
                        if (!nval)
                        {
                            ecpg_free(mallocedval);
                            return false;
                        }
 
                        if (var->type == ECPGt_numeric)
                            result = PGTYPESnumeric_copy(&(((numeric *) (var->value))[element]), nval);
                        else
                            result = PGTYPESnumeric_from_decimal(&(((decimal *) (var->value))[element]), nval);
 
                        if (result != 0)
                        {
                            PGTYPESnumeric_free(nval);
                            ecpg_free(mallocedval);
                            return false;
                        }
 
                        str = PGTYPESnumeric_to_asc(nval, nval->dscale);
                        slen = strlen(str);
                        PGTYPESnumeric_free(nval);
 
                        if (!(newcopy = ecpg_realloc(mallocedval, strlen(mallocedval) + slen + 2, lineno)))
                        {
                            ecpg_free(mallocedval);
                            ecpg_free(str);
                            return false;
                        }
                        mallocedval = newcopy;
 
                        /* also copy trailing '\0' */
                        memcpy(mallocedval + strlen(mallocedval), str, slen + 1);
                        if (var->arrsize > 1)
                            strcpy(mallocedval + strlen(mallocedval), ",");
 
                        ecpg_free(str);
                    }
 
                    if (var->arrsize > 1)
                        strcpy(mallocedval + strlen(mallocedval) - 1, "}");
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_interval:
                {
                    char       *str = NULL;
                    int         slen;
 
                    if (var->arrsize > 1)
                        mallocedval = ecpg_strdup("{", lineno, NULL);
                    else
                        mallocedval = ecpg_strdup("", lineno, NULL);
 
                    if (!mallocedval)
                        return false;
 
                    for (element = 0; element < asize; element++)
                    {
                        str = quote_postgres(PGTYPESinterval_to_asc(&(((interval *) (var->value))[element])), quote, lineno);
                        if (!str)
                        {
                            ecpg_free(mallocedval);
                            return false;
                        }
 
                        slen = strlen(str);
 
                        if (!(newcopy = ecpg_realloc(mallocedval, strlen(mallocedval) + slen + 2, lineno)))
                        {
                            ecpg_free(mallocedval);
                            ecpg_free(str);
                            return false;
                        }
                        mallocedval = newcopy;
 
                        /* also copy trailing '\0' */
                        memcpy(mallocedval + strlen(mallocedval), str, slen + 1);
                        if (var->arrsize > 1)
                            strcpy(mallocedval + strlen(mallocedval), ",");
 
                        ecpg_free(str);
                    }
 
                    if (var->arrsize > 1)
                        strcpy(mallocedval + strlen(mallocedval) - 1, "}");
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_date:
                {
                    char       *str = NULL;
                    int         slen;
 
                    if (var->arrsize > 1)
                        mallocedval = ecpg_strdup("{", lineno, NULL);
                    else
                        mallocedval = ecpg_strdup("", lineno, NULL);
 
                    if (!mallocedval)
                        return false;
 
                    for (element = 0; element < asize; element++)
                    {
                        str = quote_postgres(PGTYPESdate_to_asc(((date *) (var->value))[element]), quote, lineno);
                        if (!str)
                        {
                            ecpg_free(mallocedval);
                            return false;
                        }
 
                        slen = strlen(str);
 
                        if (!(newcopy = ecpg_realloc(mallocedval, strlen(mallocedval) + slen + 2, lineno)))
                        {
                            ecpg_free(mallocedval);
                            ecpg_free(str);
                            return false;
                        }
                        mallocedval = newcopy;
 
                        /* also copy trailing '\0' */
                        memcpy(mallocedval + strlen(mallocedval), str, slen + 1);
                        if (var->arrsize > 1)
                            strcpy(mallocedval + strlen(mallocedval), ",");
 
                        ecpg_free(str);
                    }
 
                    if (var->arrsize > 1)
                        strcpy(mallocedval + strlen(mallocedval) - 1, "}");
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_timestamp:
                {
                    char       *str = NULL;
                    int         slen;
 
                    if (var->arrsize > 1)
                        mallocedval = ecpg_strdup("{", lineno, NULL);
                    else
                        mallocedval = ecpg_strdup("", lineno, NULL);
 
                    if (!mallocedval)
                        return false;
 
                    for (element = 0; element < asize; element++)
                    {
                        str = quote_postgres(PGTYPEStimestamp_to_asc(((timestamp *) (var->value))[element]), quote, lineno);
                        if (!str)
                        {
                            ecpg_free(mallocedval);
                            return false;
                        }
 
                        slen = strlen(str);
 
                        if (!(newcopy = ecpg_realloc(mallocedval, strlen(mallocedval) + slen + 2, lineno)))
                        {
                            ecpg_free(mallocedval);
                            ecpg_free(str);
                            return false;
                        }
                        mallocedval = newcopy;
 
                        /* also copy trailing '\0' */
                        memcpy(mallocedval + strlen(mallocedval), str, slen + 1);
                        if (var->arrsize > 1)
                            strcpy(mallocedval + strlen(mallocedval), ",");
 
                        ecpg_free(str);
                    }
 
                    if (var->arrsize > 1)
                        strcpy(mallocedval + strlen(mallocedval) - 1, "}");
 
                    *tobeinserted_p = mallocedval;
                }
                break;
 
            case ECPGt_descriptor:
            case ECPGt_sqlda:
                break;
 
            default:
                /* Not implemented yet */
                ecpg_raise(lineno, ECPG_UNSUPPORTED, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ecpg_type_name(var->type));
                return false;
                break;
        }
    }
    return true;
}

References variable::arrsize, numeric::dscale, ecpg_alloc(), ECPG_CONVERT_BOOL, ecpg_free(), ecpg_raise(), ecpg_realloc(), ECPG_SQLSTATE_DATATYPE_MISMATCH, ECPG_SQLSTATE_ECPG_INTERNAL_ERROR, ecpg_strdup(), ecpg_type_name(), ECPG_UNSUPPORTED, ECPGis_noind_null(), ECPGt_bool, ECPGt_bytea, ECPGt_char, ECPGt_char_variable, ECPGt_const, ECPGt_date, ECPGt_decimal, ECPGt_descriptor, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_NO_INDICATOR, ECPGt_numeric, ECPGt_short, ECPGt_sqlda, ECPGt_string, ECPGt_timestamp, ECPGt_unsigned_char, ECPGt_unsigned_int, ECPGt_unsigned_long, ECPGt_unsigned_long_long, ECPGt_unsigned_short, ECPGt_varchar, element(), force_indicator, variable::ind_type, variable::ind_value, variable::offset, PGTYPESdate_to_asc(), PGTYPESinterval_to_asc(), PGTYPESnumeric_copy(), PGTYPESnumeric_free(), PGTYPESnumeric_from_decimal(), PGTYPESnumeric_new(), PGTYPESnumeric_to_asc(), PGTYPEStimestamp_to_asc(), quote_postgres(), sprintf, sprintf_double_value(), sprintf_float_value(), str, variable::type, variable::value, and variable::varcharsize.

Referenced by ecpg_build_params(), ECPGset_desc(), and store_input_from_desc().

ecpg_store_result()

bool ecpg_store_result	(	const PGresult *	results,
		int	act_field,
		const struct statement *	stmt,
		struct variable *	var
	)

Definition at line 303 of file execute.c.

{
    enum ARRAY_TYPE isarray;
    int         act_tuple,
                ntuples = PQntuples(results);
    bool        status = true;
 
    if ((isarray = ecpg_is_type_an_array(PQftype(results, act_field), stmt, var)) == ECPG_ARRAY_ERROR)
    {
        ecpg_raise(stmt->lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    if (isarray == ECPG_ARRAY_NONE)
    {
        /*
         * if we don't have enough space, we cannot read all tuples
         */
        if ((var->arrsize > 0 && ntuples > var->arrsize) || (var->ind_arrsize > 0 && ntuples > var->ind_arrsize))
        {
            ecpg_log("ecpg_store_result on line %d: incorrect number of matches; %d don't fit into array of %ld\n",
                     stmt->lineno, ntuples, var->arrsize);
            ecpg_raise(stmt->lineno, INFORMIX_MODE(stmt->compat) ? ECPG_INFORMIX_SUBSELECT_NOT_ONE : ECPG_TOO_MANY_MATCHES, ECPG_SQLSTATE_CARDINALITY_VIOLATION, NULL);
            return false;
        }
    }
    else
    {
        /*
         * since we read an array, the variable has to be an array too
         */
        if (var->arrsize == 0)
        {
            ecpg_raise(stmt->lineno, ECPG_NO_ARRAY, ECPG_SQLSTATE_DATATYPE_MISMATCH, NULL);
            return false;
        }
    }
 
    /*
     * allocate memory for NULL pointers
     */
    if ((var->arrsize == 0 || var->varcharsize == 0) && var->value == NULL)
    {
        int         len = 0;
 
        if (!PQfformat(results, act_field))
        {
            switch (var->type)
            {
                case ECPGt_char:
                case ECPGt_unsigned_char:
                case ECPGt_string:
                    if (!var->varcharsize && !var->arrsize)
                    {
                        /* special mode for handling char**foo=0 */
                        for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
                            len += strlen(PQgetvalue(results, act_tuple, act_field)) + 1;
                        len *= var->offset; /* should be 1, but YMNK */
                        len += (ntuples + 1) * sizeof(char *);
                    }
                    else
                    {
                        var->varcharsize = 0;
                        /* check strlen for each tuple */
                        for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
                        {
                            int         slen = strlen(PQgetvalue(results, act_tuple, act_field)) + 1;
 
                            if (slen > var->varcharsize)
                                var->varcharsize = slen;
                        }
                        var->offset *= var->varcharsize;
                        len = var->offset * ntuples;
                    }
                    break;
                case ECPGt_varchar:
                    len = ntuples * (var->varcharsize + sizeof(int));
                    break;
                default:
                    len = var->offset * ntuples;
                    break;
            }
        }
        else
        {
            for (act_tuple = 0; act_tuple < ntuples; act_tuple++)
                len += PQgetlength(results, act_tuple, act_field);
        }
 
        ecpg_log("ecpg_store_result on line %d: allocating memory for %d tuples\n", stmt->lineno, ntuples);
        var->value = ecpg_auto_alloc(len, stmt->lineno);
        if (!var->value)
            return false;
        *((char **) var->pointer) = var->value;
    }
 
    /* allocate indicator variable if needed */
    if ((var->ind_arrsize == 0 || var->ind_varcharsize == 0) && var->ind_value == NULL && var->ind_pointer != NULL)
    {
        int         len = var->ind_offset * ntuples;
 
        var->ind_value = ecpg_auto_alloc(len, stmt->lineno);
        if (!var->ind_value)
            return false;
        *((char **) var->ind_pointer) = var->ind_value;
    }
 
    /* fill the variable with the tuple(s) */
    if (!var->varcharsize && !var->arrsize &&
        (var->type == ECPGt_char || var->type == ECPGt_unsigned_char || var->type == ECPGt_string))
    {
        /* special mode for handling char**foo=0 */
 
        /* filling the array of (char*)s */
        char      **current_string = (char **) var->value;
 
        /* storing the data (after the last array element) */
        char       *current_data_location = (char *) &current_string[ntuples + 1];
 
        for (act_tuple = 0; act_tuple < ntuples && status; act_tuple++)
        {
            int         len = strlen(PQgetvalue(results, act_tuple, act_field)) + 1;
 
            if (!ecpg_get_data(results, act_tuple, act_field, stmt->lineno,
                               var->type, var->ind_type, current_data_location,
                               var->ind_value, len, 0, var->ind_offset, isarray, stmt->compat, stmt->force_indicator))
                status = false;
            else
            {
                *current_string = current_data_location;
                current_data_location += len;
                current_string++;
            }
        }
 
        /* terminate the list */
        *current_string = NULL;
    }
    else
    {
        for (act_tuple = 0; act_tuple < ntuples && status; act_tuple++)
        {
            if (!ecpg_get_data(results, act_tuple, act_field, stmt->lineno,
                               var->type, var->ind_type, var->value,
                               var->ind_value, var->varcharsize, var->offset, var->ind_offset, isarray, stmt->compat, stmt->force_indicator))
                status = false;
        }
    }
    return status;
}

References variable::arrsize, ECPG_ARRAY_ERROR, ECPG_ARRAY_NONE, ecpg_auto_alloc(), ecpg_get_data(), ECPG_INFORMIX_SUBSELECT_NOT_ONE, ecpg_is_type_an_array(), ecpg_log(), ECPG_NO_ARRAY, ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_CARDINALITY_VIOLATION, ECPG_SQLSTATE_DATATYPE_MISMATCH, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_TOO_MANY_MATCHES, ECPGt_char, ECPGt_string, ECPGt_unsigned_char, ECPGt_varchar, variable::ind_arrsize, variable::ind_offset, variable::ind_pointer, variable::ind_type, variable::ind_value, variable::ind_varcharsize, INFORMIX_MODE, ECPGtype_information_cache::isarray, len, variable::offset, variable::pointer, PQfformat(), PQftype(), PQgetlength, PQgetvalue, PQntuples, stmt, variable::type, variable::value, and variable::varcharsize.

Referenced by ecpg_process_output(), and ECPGget_desc().

ecpg_strdup()

char * ecpg_strdup	(	const char *	string,
		int	lineno,
		bool *	alloc_failed
	)

Definition at line 54 of file memory.c.

{
    char       *new;
 
    if (string == NULL)
        return NULL;
 
    new = strdup(string);
    if (!new)
    {
        if (alloc_failed)
            *alloc_failed = true;
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return NULL;
    }
 
    return new;
}

References ECPG_OUT_OF_MEMORY, ecpg_raise(), and ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY.

Referenced by AddStmtToCache(), ecpg_auto_prepare(), ecpg_do_prologue(), ecpg_register_prepared_stmt(), ecpg_store_input(), ECPGconnect(), ECPGget_desc(), and prepare_common().

ecpg_type_name()

const char * ecpg_type_name

(

enum ECPGttype

typ

)

Definition at line 17 of file typename.c.

{
    switch (typ)
    {
        case ECPGt_char:
        case ECPGt_string:
            return "char";
        case ECPGt_unsigned_char:
            return "unsigned char";
        case ECPGt_short:
            return "short";
        case ECPGt_unsigned_short:
            return "unsigned short";
        case ECPGt_int:
            return "int";
        case ECPGt_unsigned_int:
            return "unsigned int";
        case ECPGt_long:
            return "long";
        case ECPGt_unsigned_long:
            return "unsigned long";
        case ECPGt_long_long:
            return "long long";
        case ECPGt_unsigned_long_long:
            return "unsigned long long";
        case ECPGt_float:
            return "float";
        case ECPGt_double:
            return "double";
        case ECPGt_bool:
            return "bool";
        case ECPGt_varchar:
            return "varchar";
        case ECPGt_bytea:
            return "bytea";
        case ECPGt_char_variable:
            return "char";
        case ECPGt_decimal:
            return "decimal";
        case ECPGt_numeric:
            return "numeric";
        case ECPGt_date:
            return "date";
        case ECPGt_timestamp:
            return "timestamp";
        case ECPGt_interval:
            return "interval";
        case ECPGt_const:
            return "Const";
        default:
            abort();
    }
    return "";                  /* keep MSC compiler happy */
}

References ECPGt_bool, ECPGt_bytea, ECPGt_char, ECPGt_char_variable, ECPGt_const, 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, and ECPGt_varchar.

Referenced by ecpg_get_data(), ecpg_store_input(), and ECPGdump_a_simple().

sqlda_dynamic_type()

int sqlda_dynamic_type	(	Oid	type,
		enum COMPAT_MODE	compat
	)

Definition at line 107 of file typename.c.

{
    switch (type)
    {
        case CHAROID:
        case VARCHAROID:
        case BPCHAROID:
        case TEXTOID:
            return ECPGt_char;
        case INT2OID:
            return ECPGt_short;
        case INT4OID:
            return ECPGt_int;
        case FLOAT8OID:
            return ECPGt_double;
        case FLOAT4OID:
            return ECPGt_float;
        case NUMERICOID:
            return INFORMIX_MODE(compat) ? ECPGt_decimal : ECPGt_numeric;
        case DATEOID:
            return ECPGt_date;
        case TIMESTAMPOID:
        case TIMESTAMPTZOID:
            return ECPGt_timestamp;
        case INTERVALOID:
            return ECPGt_interval;
        case INT8OID:
#if SIZEOF_LONG == 8
            return ECPGt_long;
#elif SIZEOF_LONG_LONG == 8
            return ECPGt_long_long;
#else
#error "cannot find integer type of the same size as INT8OID"
#endif
            /* Unhandled types always return a string */
        default:
            return ECPGt_char;
    }
}

References compat, ECPGt_char, ECPGt_date, ECPGt_decimal, ECPGt_double, ECPGt_float, ECPGt_int, ECPGt_interval, ECPGt_long, ECPGt_long_long, ECPGt_numeric, ECPGt_short, ECPGt_timestamp, INFORMIX_MODE, and type.

Referenced by ecpg_build_compat_sqlda(), ecpg_build_native_sqlda(), and sqlda_common_total_size().

Variable Documentation

ecpg_internal_regression_mode

bool ecpg_internal_regression_mode

extern

Definition at line 29 of file misc.c.

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

ivlist

struct var_list* ivlist

extern

Definition at line 535 of file misc.c.

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