ecpglib.h File Reference

#include <stdbool.h>
#include <string.h>
#include "ecpg_config.h"
#include "ecpgtype.h"
#include "libpq-fe.h"
#include "sqlca.h"

Include dependency graph for ecpglib.h:

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

Go to the source code of this file.

Macros
#define	SQLCODE   sqlca.sqlcode
#define	SQLSTATE   sqlca.sqlstate

Functions
void	ECPGdebug (int n, FILE *dbgs)
bool	ECPGstatus (int lineno, const char *connection_name)
bool	ECPGsetcommit (int lineno, const char *mode, const char *connection_name)
bool	ECPGsetconn (int lineno, const char *connection_name)
bool	ECPGconnect (int lineno, int c, const char *name, const char *user, const char *passwd, const char *connection_name, int autocommit)
bool	ECPGdo (const int lineno, const int compat, const int force_indicator, const char *connection_name, const bool questionmarks, const int st, const char *query,...)
bool	ECPGtrans (int lineno, const char *connection_name, const char *transaction)
bool	ECPGdisconnect (int lineno, const char *connection_name)
bool	ECPGprepare (int lineno, const char *connection_name, const bool questionmarks, const char *name, const char *variable)
bool	ECPGdeallocate (int lineno, int c, const char *connection_name, const char *name)
bool	ECPGdeallocate_all (int lineno, int compat, const char *connection_name)
char *	ECPGprepared_statement (const char *connection_name, const char *name, int lineno)
PGconn *	ECPGget_PGconn (const char *connection_name)
PGTransactionStatusType	ECPGtransactionStatus (const char *connection_name)
void	sqlprint (void)
bool	ECPGdo_descriptor (int line, const char *connection, const char *descriptor, const char *query)
bool	ECPGdeallocate_desc (int line, const char *name)
bool	ECPGallocate_desc (int line, const char *name)
bool	ECPGget_desc_header (int lineno, const char *desc_name, int *count)
bool	ECPGget_desc (int lineno, const char *desc_name, int index,...)
bool	ECPGset_desc_header (int lineno, const char *desc_name, int count)
bool	ECPGset_desc (int lineno, const char *desc_name, int index,...)
void	ECPGset_noind_null (enum ECPGttype type, void *ptr)
bool	ECPGis_noind_null (enum ECPGttype type, const void *ptr)
bool	ECPGdescribe (int line, int compat, bool input, const char *connection_name, const char *stmt_name,...)
void	ECPGset_var (int number, void *pointer, int lineno)
void *	ECPGget_var (int number)
void	ECPGfree_auto_mem (void)
void	ecpg_pthreads_init (void)

Macro Definition Documentation

SQLCODE

#define SQLCODE   sqlca.sqlcode

Definition at line 48 of file ecpglib.h.

SQLSTATE

#define SQLSTATE   sqlca.sqlstate

Definition at line 49 of file ecpglib.h.

Function Documentation

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

References actual_connection_key_once, and ecpg_actual_connection_init().

Referenced by ecpg_do_prologue(), ecpg_get_connection(), ecpg_get_connection_nr(), and ECPGconnect().

ECPGallocate_desc()

bool ECPGallocate_desc	(	int	line,
		const char *	name
	)

Definition at line 800 of file descriptor.c.

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

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

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

ECPGconnect()

bool ECPGconnect	(	int	lineno,
		int	c,
		const char *	name,
		const char *	user,
		const char *	passwd,
		const char *	connection_name,
		int	autocommit
	)

Definition at line 260 of file connect.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
    enum COMPAT_MODE compat = c;
    struct connection *this;
    int         i,
                connect_params = 0;
    bool        alloc_failed = (sqlca == NULL);
    char       *dbname = name ? ecpg_strdup(name, lineno, &alloc_failed) : NULL,
               *host = NULL,
               *tmp,
               *port = NULL,
               *realname = NULL,
               *options = NULL;
    const char **conn_keywords;
    const char **conn_values;
 
    if (alloc_failed)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        if (dbname)
            ecpg_free(dbname);
        return false;
    }
 
    ecpg_init_sqlca(sqlca);
 
    /*
     * clear auto_mem structure because some error handling functions might
     * access it
     */
    ecpg_clear_auto_mem();
 
    if (INFORMIX_MODE(compat))
    {
        char       *envname;
 
        /*
         * Informix uses an environment variable DBPATH that overrides the
         * connection parameters given here. We do the same with PG_DBPATH as
         * the syntax is different.
         */
        envname = getenv("PG_DBPATH");
        if (envname)
        {
            ecpg_free(dbname);
            dbname = ecpg_strdup(envname, lineno, &alloc_failed);
        }
    }
 
    if (dbname == NULL && connection_name == NULL)
        connection_name = "DEFAULT";
 
    ecpg_pthreads_init();
 
    /* check if the identifier is unique */
    if (ecpg_get_connection(connection_name))
    {
        ecpg_free(dbname);
        ecpg_log("ECPGconnect: connection identifier %s is already in use\n",
                 connection_name);
        return false;
    }
 
    if ((this = (struct connection *) ecpg_alloc(sizeof(struct connection), lineno)) == NULL)
    {
        ecpg_free(dbname);
        return false;
    }
 
    if (dbname != NULL)
    {
        /* get the detail information from dbname */
        if (strncmp(dbname, "tcp:", 4) == 0 || strncmp(dbname, "unix:", 5) == 0)
        {
            int         offset = 0;
 
            /*
             * only allow protocols tcp and unix
             */
            if (strncmp(dbname, "tcp:", 4) == 0)
                offset = 4;
            else if (strncmp(dbname, "unix:", 5) == 0)
                offset = 5;
 
            if (strncmp(dbname + offset, "postgresql://", strlen("postgresql://")) == 0)
            {
 
                /*------
                 * new style:
                 *  <tcp|unix>:postgresql://server[:port][/db-name][?options]
                 *------
                 */
                offset += strlen("postgresql://");
 
                tmp = strrchr(dbname + offset, '?');
                if (tmp != NULL)    /* options given */
                {
                    options = ecpg_strdup(tmp + 1, lineno, &alloc_failed);
                    *tmp = '\0';
                }
 
                tmp = last_dir_separator(dbname + offset);
                if (tmp != NULL)    /* database name given */
                {
                    if (tmp[1] != '\0') /* non-empty database name */
                    {
                        realname = ecpg_strdup(tmp + 1, lineno, &alloc_failed);
                        connect_params++;
                    }
                    *tmp = '\0';
                }
 
                tmp = strrchr(dbname + offset, ':');
                if (tmp != NULL)    /* port number given */
                {
                    *tmp = '\0';
                    port = ecpg_strdup(tmp + 1, lineno, &alloc_failed);
                    connect_params++;
                }
 
                if (strncmp(dbname, "unix:", 5) == 0)
                {
                    /*
                     * The alternative of using "127.0.0.1" here is deprecated
                     * and undocumented; we'll keep it for backward
                     * compatibility's sake, but not extend it to allow IPv6.
                     */
                    if (strcmp(dbname + offset, "localhost") != 0 &&
                        strcmp(dbname + offset, "127.0.0.1") != 0)
                    {
                        ecpg_log("ECPGconnect: non-localhost access via sockets on line %d\n", lineno);
                        ecpg_raise(lineno, ECPG_CONNECT, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, realname ? realname : ecpg_gettext("<DEFAULT>"));
                        if (host)
                            ecpg_free(host);
                        if (port)
                            ecpg_free(port);
                        if (options)
                            ecpg_free(options);
                        if (realname)
                            ecpg_free(realname);
                        if (dbname)
                            ecpg_free(dbname);
                        free(this);
                        return false;
                    }
                }
                else
                {
                    if (*(dbname + offset) != '\0')
                    {
                        host = ecpg_strdup(dbname + offset, lineno, &alloc_failed);
                        connect_params++;
                    }
                }
            }
        }
        else
        {
            /* old style: dbname[@server][:port] */
            tmp = strrchr(dbname, ':');
            if (tmp != NULL)    /* port number given */
            {
                port = ecpg_strdup(tmp + 1, lineno, &alloc_failed);
                connect_params++;
                *tmp = '\0';
            }
 
            tmp = strrchr(dbname, '@');
            if (tmp != NULL)    /* host name given */
            {
                host = ecpg_strdup(tmp + 1, lineno, &alloc_failed);
                connect_params++;
                *tmp = '\0';
            }
 
            if (strlen(dbname) > 0)
            {
                realname = ecpg_strdup(dbname, lineno, &alloc_failed);
                connect_params++;
            }
            else
                realname = NULL;
        }
    }
    else
        realname = NULL;
 
    /*
     * Count options for the allocation done below (this may produce an
     * overestimate, it's ok).
     */
    if (options)
        for (i = 0; options[i]; i++)
            if (options[i] == '=')
                connect_params++;
 
    if (user && strlen(user) > 0)
        connect_params++;
    if (passwd && strlen(passwd) > 0)
        connect_params++;
 
    /*
     * Allocate enough space for all connection parameters.  These allocations
     * are done before manipulating the list of connections to ease the error
     * handling on failure.
     */
    conn_keywords = (const char **) ecpg_alloc((connect_params + 1) * sizeof(char *), lineno);
    conn_values = (const char **) ecpg_alloc(connect_params * sizeof(char *), lineno);
 
    /* Decide on a connection name */
    if (connection_name != NULL || realname != NULL)
    {
        this->name = ecpg_strdup(connection_name ? connection_name : realname,
                                 lineno, &alloc_failed);
    }
    else
        this->name = NULL;
 
    /* Deal with any failed allocations above */
    if (conn_keywords == NULL || conn_values == NULL || alloc_failed)
    {
        if (host)
            ecpg_free(host);
        if (port)
            ecpg_free(port);
        if (options)
            ecpg_free(options);
        if (realname)
            ecpg_free(realname);
        if (dbname)
            ecpg_free(dbname);
        if (conn_keywords)
            ecpg_free(conn_keywords);
        if (conn_values)
            ecpg_free(conn_values);
        if (this->name)
            ecpg_free(this->name);
        free(this);
        return false;
    }
 
    /* add connection to our list */
    pthread_mutex_lock(&connections_mutex);
 
    /*
     * ... but first, make certain we have created ecpg_clocale.  Rely on
     * holding connections_mutex to ensure this is done by only one thread.
     */
#ifdef HAVE_USELOCALE
    if (!ecpg_clocale)
    {
        ecpg_clocale = newlocale(LC_NUMERIC_MASK, "C", (locale_t) 0);
        if (!ecpg_clocale)
        {
            pthread_mutex_unlock(&connections_mutex);
            ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                       ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
            if (host)
                ecpg_free(host);
            if (port)
                ecpg_free(port);
            if (options)
                ecpg_free(options);
            if (realname)
                ecpg_free(realname);
            if (dbname)
                ecpg_free(dbname);
            if (conn_keywords)
                ecpg_free(conn_keywords);
            if (conn_values)
                ecpg_free(conn_values);
            if (this->name)
                ecpg_free(this->name);
            free(this);
            return false;
        }
    }
#endif
 
    this->cache_head = NULL;
    this->prep_stmts = NULL;
 
    if (all_connections == NULL)
        this->next = NULL;
    else
        this->next = all_connections;
 
    all_connections = this;
    pthread_setspecific(actual_connection_key, all_connections);
    actual_connection = all_connections;
 
    ecpg_log("ECPGconnect: opening database %s on %s port %s %s%s %s%s\n",
             realname ? realname : "<DEFAULT>",
             host ? host : "<DEFAULT>",
             port ? (ecpg_internal_regression_mode ? "<REGRESSION_PORT>" : port) : "<DEFAULT>",
             options ? "with options " : "", options ? options : "",
             (user && strlen(user) > 0) ? "for user " : "", user ? user : "");
 
    i = 0;
    if (realname)
    {
        conn_keywords[i] = "dbname";
        conn_values[i] = realname;
        i++;
    }
    if (host)
    {
        conn_keywords[i] = "host";
        conn_values[i] = host;
        i++;
    }
    if (port)
    {
        conn_keywords[i] = "port";
        conn_values[i] = port;
        i++;
    }
    if (user && strlen(user) > 0)
    {
        conn_keywords[i] = "user";
        conn_values[i] = user;
        i++;
    }
    if (passwd && strlen(passwd) > 0)
    {
        conn_keywords[i] = "password";
        conn_values[i] = passwd;
        i++;
    }
    if (options)
    {
        char       *str;
 
        /*
         * The options string contains "keyword=value" pairs separated by
         * '&'s.  We must break this up into keywords and values to pass to
         * libpq (it's okay to scribble on the options string).  We ignore
         * spaces just before each keyword or value.  (The preprocessor used
         * to add spaces around '&'s, making it necessary to ignore spaces
         * before keywords here.  While it no longer does that, we still must
         * skip spaces to support code compiled with older preprocessors.)
         */
        for (str = options; *str;)
        {
            int         e,
                        a;
            char       *token1,
                       *token2;
 
            /* Skip spaces before keyword */
            for (token1 = str; *token1 == ' '; token1++)
                 /* skip */ ;
            /* Find end of keyword */
            for (e = 0; token1[e] && token1[e] != '='; e++)
                 /* skip */ ;
            if (token1[e])      /* found "=" */
            {
                token1[e] = '\0';
                /* Skip spaces before value */
                for (token2 = token1 + e + 1; *token2 == ' '; token2++)
                     /* skip */ ;
                /* Find end of value */
                for (a = 0; token2[a] && token2[a] != '&'; a++)
                     /* skip */ ;
                if (token2[a])  /* found "&" => another option follows */
                {
                    token2[a] = '\0';
                    str = token2 + a + 1;
                }
                else
                    str = token2 + a;
 
                conn_keywords[i] = token1;
                conn_values[i] = token2;
                i++;
            }
            else
            {
                /* Bogus options syntax ... ignore trailing garbage */
                str = token1 + e;
            }
        }
    }
 
    Assert(i <= connect_params);
    conn_keywords[i] = NULL;    /* terminator */
 
    this->connection = PQconnectdbParams(conn_keywords, conn_values, 0);
 
    if (host)
        ecpg_free(host);
    if (port)
        ecpg_free(port);
    if (options)
        ecpg_free(options);
    if (dbname)
        ecpg_free(dbname);
    ecpg_free(conn_values);
    ecpg_free(conn_keywords);
 
    if (PQstatus(this->connection) == CONNECTION_BAD)
    {
        const char *errmsg = PQerrorMessage(this->connection);
        const char *db = realname ? realname : ecpg_gettext("<DEFAULT>");
 
        /* PQerrorMessage's result already has a trailing newline */
        ecpg_log("ECPGconnect: %s", errmsg);
 
        ecpg_finish(this);
        pthread_mutex_unlock(&connections_mutex);
 
        ecpg_raise(lineno, ECPG_CONNECT, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, db);
        if (realname)
            ecpg_free(realname);
 
        return false;
    }
 
    if (realname)
        ecpg_free(realname);
 
    pthread_mutex_unlock(&connections_mutex);
 
    this->autocommit = autocommit;
 
    PQsetNoticeReceiver(this->connection, &ECPGnoticeReceiver, this);
 
    return true;
}

References a, actual_connection, actual_connection_key, all_connections, Assert(), autocommit, connection::cache_head, compat, CONNECTION_BAD, connections_mutex, dbname, ecpg_alloc(), ecpg_clear_auto_mem(), ECPG_CONNECT, ecpg_finish(), ecpg_free(), ecpg_get_connection(), ecpg_gettext, ecpg_init_sqlca(), ecpg_internal_regression_mode, ecpg_log(), ECPG_OUT_OF_MEMORY, ecpg_pthreads_init(), ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPG_SQLSTATE_SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION, ecpg_strdup(), ECPGget_sqlca(), ECPGnoticeReceiver(), errmsg(), free, i, INFORMIX_MODE, last_dir_separator(), locale_t, name, next, port, PQconnectdbParams(), PQerrorMessage(), PQsetNoticeReceiver(), PQstatus(), connection::prep_stmts, pthread_mutex_lock(), pthread_mutex_unlock(), pthread_setspecific(), sqlca, str, and user.

Referenced by fn(), main(), test(), and test_thread().

ECPGdeallocate()

bool ECPGdeallocate	(	int	lineno,
		int	c,
		const char *	connection_name,
		const char *	name
	)

Definition at line 347 of file prepare.c.

{
    struct connection *con;
    struct prepared_statement *this,
               *prev;
 
    con = ecpg_get_connection(connection_name);
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    this = ecpg_find_prepared_statement(name, con, &prev);
    if (this)
        return deallocate_one(lineno, c, con, prev, this);
 
    /* prepared statement is not found */
    if (INFORMIX_MODE(c))
        return true;
    ecpg_raise(lineno, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, name);
    return false;
}

References deallocate_one(), ecpg_find_prepared_statement(), ecpg_get_connection(), ecpg_init(), ECPG_INVALID_STMT, ecpg_raise(), ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, INFORMIX_MODE, and name.

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

ECPGdeallocate_all()

bool ECPGdeallocate_all	(	int	lineno,
		int	compat,
		const char *	connection_name
	)

Definition at line 382 of file prepare.c.

{
    return ecpg_deallocate_all_conn(lineno, compat,
                                    ecpg_get_connection(connection_name));
}

References compat, ecpg_deallocate_all_conn(), and ecpg_get_connection().

Referenced by main().

ECPGdeallocate_desc()

bool ECPGdeallocate_desc	(	int	line,
		const char *	name
	)

Definition at line 756 of file descriptor.c.

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

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

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

ECPGdebug()

void ECPGdebug	(	int	n,
		FILE *	dbgs
	)

Definition at line 204 of file misc.c.

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

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

ECPGdescribe()

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

Definition at line 855 of file descriptor.c.

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

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

Referenced by execute_test(), and main().

ECPGdisconnect()

bool ECPGdisconnect	(	int	lineno,
		const char *	connection_name
	)

Definition at line 693 of file connect.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
    struct connection *con;
 
    if (sqlca == NULL)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    pthread_mutex_lock(&connections_mutex);
 
    if (strcmp(connection_name, "ALL") == 0)
    {
        ecpg_init_sqlca(sqlca);
        for (con = all_connections; con;)
        {
            struct connection *f = con;
 
            con = con->next;
            ecpg_finish(f);
        }
    }
    else
    {
        con = ecpg_get_connection_nr(connection_name);
 
        if (!ecpg_init(con, connection_name, lineno))
        {
            pthread_mutex_unlock(&connections_mutex);
            return false;
        }
        else
            ecpg_finish(con);
    }
 
    pthread_mutex_unlock(&connections_mutex);
 
    return true;
}

References all_connections, connections_mutex, ecpg_finish(), ecpg_get_connection_nr(), ecpg_init(), ecpg_init_sqlca(), ECPG_OUT_OF_MEMORY, ecpg_raise(), ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, ECPGget_sqlca(), connection::next, pthread_mutex_lock(), pthread_mutex_unlock(), and sqlca.

Referenced by fn(), main(), test(), and test_thread().

ECPGdo()

bool ECPGdo	(	const int	lineno,
		const int	compat,
		const int	force_indicator,
		const char *	connection_name,
		const bool	questionmarks,
		const int	st,
		const char *	query,
			...
	)

Definition at line 2293 of file execute.c.

{
    va_list     args;
    bool        ret;
 
    va_start(args, query);
    ret = ecpg_do(lineno, compat, force_indicator, connection_name,
                  questionmarks, st, query, args);
    va_end(args);
 
    return ret;
}

References generate_unaccent_rules::args, compat, ecpg_do(), force_indicator, statement::lineno, and questionmarks.

Referenced by check_result_of_insert(), close_cur1(), ECPGdo_descriptor(), execute_test(), fn(), get_record1(), main(), open_cur1(), openit(), test(), and test_thread().

ECPGdo_descriptor()

bool ECPGdo_descriptor	(	int	line,
		const char *	connection,
		const char *	descriptor,
		const char *	query
	)

Definition at line 2308 of file execute.c.

{
    return ECPGdo(line, ECPG_COMPAT_PGSQL, true, connection, '\0', 0, query, ECPGt_EOIT,
                  ECPGt_descriptor, descriptor, 0L, 0L, 0L,
                  ECPGt_NO_INDICATOR, NULL, 0L, 0L, 0L, ECPGt_EORT);
}

References ECPG_COMPAT_PGSQL, ECPGdo(), ECPGt_descriptor, ECPGt_EOIT, ECPGt_EORT, and ECPGt_NO_INDICATOR.

ECPGfree_auto_mem()

void ECPGfree_auto_mem

(

void

)

Definition at line 140 of file memory.c.

{
    struct auto_mem *am = get_auto_allocs();
 
    /* free all memory we have allocated for the user */
    if (am)
    {
        do
        {
            struct auto_mem *act = am;
 
            am = am->next;
            ecpg_free(act->pointer);
            ecpg_free(act);
        } while (am);
        set_auto_allocs(NULL);
    }
}

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

Referenced by auto_mem_destructor(), ecpg_raise(), ecpg_raise_backend(), ECPGset_var(), and main().

ECPGget_desc()

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

Definition at line 234 of file descriptor.c.

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

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

Referenced by execute_test(), and main().

ECPGget_desc_header()

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

Definition at line 84 of file descriptor.c.

{
    PGresult   *ECPGresult;
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_raise(lineno, ECPG_OUT_OF_MEMORY,
                   ECPG_SQLSTATE_ECPG_OUT_OF_MEMORY, NULL);
        return false;
    }
 
    ecpg_init_sqlca(sqlca);
    ECPGresult = ecpg_result_by_descriptor(lineno, desc_name);
    if (!ECPGresult)
        return false;
 
    *count = PQnfields(ECPGresult);
    sqlca->sqlerrd[2] = 1;
    ecpg_log("ECPGget_desc_header: found %d attributes\n", *count);
    return true;
}

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

Referenced by execute_test(), and main().

ECPGget_PGconn()

PGconn * ECPGget_PGconn

(

const char *

connection_name

)

Definition at line 737 of file connect.c.

{
    struct connection *con;
 
    con = ecpg_get_connection(connection_name);
    if (con == NULL)
        return NULL;
 
    return con->connection;
}

References connection::connection, and ecpg_get_connection().

ECPGget_var()

void * ECPGget_var

(

int

number

)

Definition at line 593 of file misc.c.

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

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

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

ECPGis_noind_null()

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

Definition at line 361 of file misc.c.

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

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

Referenced by ecpg_store_input(), and risnull().

ECPGprepare()

bool ECPGprepare	(	int	lineno,
		const char *	connection_name,
		const bool	questionmarks,
		const char *	name,
		const char *	variable
	)

Definition at line 249 of file prepare.c.

{
    struct connection *con;
    struct prepared_statement *this,
               *prev;
 
    (void) questionmarks;       /* quiet the compiler */
 
    con = ecpg_get_connection(connection_name);
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    /* check if we already have prepared this statement */
    this = ecpg_find_prepared_statement(name, con, &prev);
    if (this && !deallocate_one(lineno, ECPG_COMPAT_PGSQL, con, prev, this))
        return false;
 
    return prepare_common(lineno, con, name, variable);
}

References deallocate_one(), ECPG_COMPAT_PGSQL, ecpg_find_prepared_statement(), ecpg_get_connection(), ecpg_init(), name, prepare_common(), and questionmarks.

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

ECPGprepared_statement()

char * ECPGprepared_statement	(	const char *	connection_name,
		const char *	name,
		int	lineno
	)

Definition at line 400 of file prepare.c.

{
    (void) lineno;              /* keep the compiler quiet */
 
    return ecpg_prepared(name, ecpg_get_connection(connection_name));
}

References ecpg_get_connection(), ecpg_prepared(), and name.

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

ECPGset_desc()

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

Definition at line 613 of file descriptor.c.

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

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

Referenced by main().

ECPGset_desc_header()

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

Definition at line 581 of file descriptor.c.

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

References descriptor::count, and ecpg_find_desc().

Referenced by main().

ECPGset_noind_null()

void ECPGset_noind_null	(	enum ECPGttype	type,
		void *	ptr
	)

Definition at line 292 of file misc.c.

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

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

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

ECPGset_var()

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

Definition at line 538 of file misc.c.

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

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

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

ECPGsetcommit()

bool ECPGsetcommit	(	int	lineno,
		const char *	mode,
		const char *	connection_name
	)

Definition at line 158 of file connect.c.

{
    struct connection *con = ecpg_get_connection(connection_name);
    PGresult   *results;
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    ecpg_log("ECPGsetcommit on line %d: action \"%s\"; connection \"%s\"\n", lineno, mode, con->name);
 
    if (con->autocommit && strncmp(mode, "off", strlen("off")) == 0)
    {
        if (PQtransactionStatus(con->connection) == PQTRANS_IDLE)
        {
            results = PQexec(con->connection, "begin transaction");
            if (!ecpg_check_PQresult(results, lineno, con->connection, ECPG_COMPAT_PGSQL))
                return false;
            PQclear(results);
        }
        con->autocommit = false;
    }
    else if (!con->autocommit && strncmp(mode, "on", strlen("on")) == 0)
    {
        if (PQtransactionStatus(con->connection) != PQTRANS_IDLE)
        {
            results = PQexec(con->connection, "commit");
            if (!ecpg_check_PQresult(results, lineno, con->connection, ECPG_COMPAT_PGSQL))
                return false;
            PQclear(results);
        }
        con->autocommit = true;
    }
 
    return true;
}

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

Referenced by fn(), and main().

ECPGsetconn()

bool ECPGsetconn	(	int	lineno,
		const char *	connection_name
	)

Definition at line 195 of file connect.c.

{
    struct connection *con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    pthread_setspecific(actual_connection_key, con);
    return true;
}

References actual_connection_key, ecpg_get_connection(), ecpg_init(), and pthread_setspecific().

Referenced by main().

ECPGstatus()

bool ECPGstatus	(	int	lineno,
		const char *	connection_name
	)

Definition at line 127 of file misc.c.

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

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

ECPGtrans()

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

Definition at line 160 of file misc.c.

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

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

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

ECPGtransactionStatus()

PGTransactionStatusType ECPGtransactionStatus

(

const char *

connection_name

)

Definition at line 145 of file misc.c.

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

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

sqlprint()

void sqlprint

(

void

)

Definition at line 334 of file error.c.

{
    struct sqlca_t *sqlca = ECPGget_sqlca();
 
    if (sqlca == NULL)
    {
        ecpg_log("out of memory");
        return;
    }
 
    sqlca->sqlerrm.sqlerrmc[sqlca->sqlerrm.sqlerrml] = '\0';
    fprintf(stderr, ecpg_gettext("SQL error: %s\n"), sqlca->sqlerrm.sqlerrmc);
}

References ecpg_gettext, ecpg_log(), ECPGget_sqlca(), fprintf, and sqlca.

Referenced by check_result_of_insert(), commitTable(), execute_test(), fn(), main(), print(), print2(), test(), and test_thread().