prepare.c File Reference

#include "postgres_fe.h"
#include <ctype.h>
#include "ecpgerrno.h"
#include "ecpglib.h"
#include "ecpglib_extern.h"
#include "ecpgtype.h"
#include "sqlca.h"

Include dependency graph for prepare.c:

Go to the source code of this file.

Data Structures
struct	stmtCacheEntry

Macros
#define	POSTGRES_ECPG_INTERNAL
#define	STMTID_SIZE   32
#define	stmtCacheNBuckets   2039 /* should be a prime number */
#define	stmtCacheEntPerBucket   8
#define	stmtCacheArraySize   (stmtCacheNBuckets * stmtCacheEntPerBucket + 1)

Functions
static bool	deallocate_one (int lineno, enum COMPAT_MODE c, struct connection *con, struct prepared_statement *prev, struct prepared_statement *this)
static bool	isvarchar (unsigned char c)
bool	ecpg_register_prepared_stmt (struct statement *stmt)
static bool	replace_variables (char **text, int lineno)
static bool	prepare_common (int lineno, struct connection *con, const char *name, const char *variable)
bool	ECPGprepare (int lineno, const char *connection_name, const bool questionmarks, const char *name, const char *variable)
struct prepared_statement *	ecpg_find_prepared_statement (const char *name, struct connection *con, struct prepared_statement **prev_)
bool	ECPGdeallocate (int lineno, int c, const char *connection_name, const char *name)
bool	ecpg_deallocate_all_conn (int lineno, enum COMPAT_MODE c, struct connection *con)
bool	ECPGdeallocate_all (int lineno, int compat, const char *connection_name)
char *	ecpg_prepared (const char *name, struct connection *con)
char *	ECPGprepared_statement (const char *connection_name, const char *name, int lineno)
static int	HashStmt (const char *ecpgQuery)
static int	SearchStmtCache (const char *ecpgQuery)
static int	ecpg_freeStmtCacheEntry (int lineno, int compat, int entNo)
static int	AddStmtToCache (int lineno, const char *stmtID, const char *connection, int compat, const char *ecpgQuery)
bool	ecpg_auto_prepare (int lineno, const char *connection_name, const int compat, char **name, const char *query)

Variables
static int	nextStmtID = 1
static stmtCacheEntry *	stmtCacheEntries = NULL

Macro Definition Documentation

POSTGRES_ECPG_INTERNAL

#define POSTGRES_ECPG_INTERNAL

Definition at line 3 of file prepare.c.

stmtCacheArraySize

#define stmtCacheArraySize   (stmtCacheNBuckets * stmtCacheEntPerBucket + 1)

Definition at line 26 of file prepare.c.

stmtCacheEntPerBucket

#define stmtCacheEntPerBucket   8

Definition at line 24 of file prepare.c.

stmtCacheNBuckets

#define stmtCacheNBuckets   2039 /* should be a prime number */

Definition at line 23 of file prepare.c.

STMTID_SIZE

#define STMTID_SIZE   32

Definition at line 14 of file prepare.c.

Function Documentation

AddStmtToCache()

static int AddStmtToCache ( int  lineno, const char *  stmtID, const char *  connection, int  compat, const char *  ecpgQuery  )

static

Definition at line 537 of file prepare.c.

{
    int         ix,
                initEntNo,
                luEntNo,
                entNo;
    stmtCacheEntry *entry;
 
    /* allocate and zero cache array if we haven't already */
    if (stmtCacheEntries == NULL)
    {
        stmtCacheEntries = (stmtCacheEntry *)
            ecpg_alloc(sizeof(stmtCacheEntry) * stmtCacheArraySize, lineno);
        if (stmtCacheEntries == NULL)
            return -1;
    }
 
    /* hash the statement */
    initEntNo = HashStmt(ecpgQuery);
 
    /* search for an unused entry */
    entNo = initEntNo;          /* start with the initial entry # for the
                                 * bucket */
    luEntNo = initEntNo;        /* use it as the initial 'least used' entry */
    for (ix = 0; ix < stmtCacheEntPerBucket; ++ix)
    {
        entry = &stmtCacheEntries[entNo];
        if (!entry->stmtID[0])  /* unused entry  -  use it */
            break;
        if (entry->execs < stmtCacheEntries[luEntNo].execs)
            luEntNo = entNo;    /* save new 'least used' entry */
        ++entNo;                /* increment entry # */
    }
 
    /*
     * if no unused entries were found, re-use the 'least used' entry found in
     * the bucket
     */
    if (ix >= stmtCacheEntPerBucket)
        entNo = luEntNo;
 
    /* 'entNo' is the entry to use - make sure its free */
    if (ecpg_freeStmtCacheEntry(lineno, compat, entNo) < 0)
        return -1;
 
    /* add the query to the entry */
    entry = &stmtCacheEntries[entNo];
    entry->lineno = lineno;
    entry->ecpgQuery = ecpg_strdup(ecpgQuery, lineno, NULL);
    if (!entry->ecpgQuery)
        return -1;
    entry->connection = connection;
    entry->execs = 0;
    memcpy(entry->stmtID, stmtID, sizeof(entry->stmtID));
 
    return entNo;
}

References compat, stmtCacheEntry::connection, ecpg_alloc(), ecpg_freeStmtCacheEntry(), ecpg_strdup(), stmtCacheEntry::ecpgQuery, stmtCacheEntry::execs, fb(), HashStmt(), stmtCacheEntry::lineno, memcpy(), stmtCacheArraySize, stmtCacheEntPerBucket, stmtCacheEntries, and stmtCacheEntry::stmtID.

Referenced by ecpg_auto_prepare().

deallocate_one()

static bool deallocate_one ( int  lineno, enum COMPAT_MODE  c, struct connection *  con, struct prepared_statement *  prev, struct prepared_statement *  this  )

static

Definition at line 292 of file prepare.c.

{
    bool        r = false;
 
    ecpg_log("deallocate_one on line %d: name %s\n", lineno, this->name);
 
    /* first deallocate the statement in the backend */
    if (this->prepared)
    {
        char       *text;
        PGresult   *query;
 
        text = ecpg_alloc(strlen("deallocate \"\" ") + strlen(this->name), this->stmt->lineno);
 
        if (text)
        {
            sprintf(text, "deallocate \"%s\"", this->name);
            query = PQexec(this->stmt->connection->connection, text);
            ecpg_free(text);
            if (ecpg_check_PQresult(query, lineno,
                                    this->stmt->connection->connection,
                                    this->stmt->compat))
            {
                PQclear(query);
                r = true;
            }
        }
    }
 
    /*
     * Just ignore all errors since we do not know the list of cursors we are
     * allowed to free. We have to trust the software.
     */
    if (!r && !INFORMIX_MODE(c))
    {
        ecpg_raise(lineno, ECPG_INVALID_STMT, ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, this->name);
        return false;
    }
 
    /* okay, free all the resources */
    ecpg_free(this->stmt->command);
    ecpg_free(this->stmt);
    ecpg_free(this->name);
    if (prev != NULL)
        prev->next = this->next;
    else
        con->prep_stmts = this->next;
 
    ecpg_free(this);
    return true;
}

References ecpg_alloc(), ecpg_check_PQresult(), ecpg_free(), ECPG_INVALID_STMT, ecpg_log(), ecpg_raise(), ECPG_SQLSTATE_INVALID_SQL_STATEMENT_NAME, fb(), INFORMIX_MODE, name, next, prepared_statement::next, PQclear, PQexec(), connection::prep_stmts, prepared_statement::prepared, sprintf, and stmt.

Referenced by ecpg_deallocate_all_conn(), ecpg_freeStmtCacheEntry(), ecpg_register_prepared_stmt(), ECPGdeallocate(), and ECPGprepare().

ecpg_auto_prepare()

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

Definition at line 601 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, fb(), name, nextStmtID, prepare_common(), SearchStmtCache(), sprintf, stmtCacheEntries, stmtCacheEntry::stmtID, and STMTID_SIZE.

Referenced by ecpg_do_prologue().

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(), fb(), and connection::prep_stmts.

Referenced by ecpg_finish(), and ECPGdeallocate_all().

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 fb(), name, next, and connection::prep_stmts.

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

ecpg_freeStmtCacheEntry()

static int ecpg_freeStmtCacheEntry ( int  lineno, int  compat, int  entNo  )

static

Definition at line 489 of file prepare.c.

{
    stmtCacheEntry *entry;
    struct connection *con;
    struct prepared_statement *this,
               *prev;
 
    /* fail if cache isn't set up */
    if (stmtCacheEntries == NULL)
        return -1;
 
    entry = &stmtCacheEntries[entNo];
    if (!entry->stmtID[0])      /* return if the entry isn't in use */
        return 0;
 
    con = ecpg_get_connection(entry->connection);
 
    /*
     * If the connection is gone, the prepared_statement list it owned is
     * already unreachable, so just skip that cleanup.  We must still clear
     * the cache slot below so it can be reused.
     */
    if (con)
    {
        /* free the 'prepared_statement' list entry */
        this = ecpg_find_prepared_statement(entry->stmtID, con, &prev);
        if (this && !deallocate_one(lineno, compat, con, prev, this))
            return -1;
    }
 
    entry->stmtID[0] = '\0';
 
    /* free the memory used by the cache entry */
    if (entry->ecpgQuery)
    {
        ecpg_free(entry->ecpgQuery);
        entry->ecpgQuery = NULL;
    }
 
    return entNo;
}

References compat, stmtCacheEntry::connection, deallocate_one(), ecpg_find_prepared_statement(), ecpg_free(), ecpg_get_connection(), stmtCacheEntry::ecpgQuery, fb(), stmtCacheEntries, and stmtCacheEntry::stmtID.

Referenced by AddStmtToCache().

ecpg_prepared()

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

Definition at line 393 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(), fb(), name, and stmt.

Referenced by ecpg_do_prologue(), and ECPGprepared_statement().

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, connection::connection, deallocate_one(), ecpg_alloc(), ECPG_COMPAT_PGSQL, ecpg_find_prepared_statement(), ecpg_free(), ecpg_strdup(), fb(), statement::lineno, name, statement::name, next, connection::prep_stmts, and stmt.

Referenced by ecpg_execute().

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

{
    struct connection *con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return false;
 
    return ecpg_deallocate_all_conn(lineno, compat, con);
}

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

Referenced by main().

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

{
    struct connection *con = ecpg_get_connection(connection_name);
 
    if (!ecpg_init(con, connection_name, lineno))
        return NULL;
 
    return ecpg_prepared(name, con);
}

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

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

HashStmt()

static int HashStmt ( const char *  ecpgQuery )

static

Definition at line 417 of file prepare.c.

{
    int         stmtIx,
                bucketNo,
                hashLeng,
                stmtLeng;
    uint64      hashVal,
                rotVal;
 
    stmtLeng = strlen(ecpgQuery);
    hashLeng = 50;              /* use 1st 50 characters of statement */
    if (hashLeng > stmtLeng)    /* if the statement isn't that long */
        hashLeng = stmtLeng;    /* use its actual length */
 
    hashVal = 0;
    for (stmtIx = 0; stmtIx < hashLeng; ++stmtIx)
    {
        hashVal = hashVal + (unsigned char) ecpgQuery[stmtIx];
        /* rotate 32-bit hash value left 13 bits */
        hashVal = hashVal << 13;
        rotVal = (hashVal & UINT64CONST(0x1fff00000000)) >> 32;
        hashVal = (hashVal & UINT64CONST(0xffffffff)) | rotVal;
    }
 
    bucketNo = hashVal % stmtCacheNBuckets;
 
    /* Add 1 so that array entry 0 is never used */
    return bucketNo * stmtCacheEntPerBucket + 1;
}

References fb(), stmtCacheEntPerBucket, stmtCacheNBuckets, and UINT64CONST.

Referenced by AddStmtToCache(), and SearchStmtCache().

isvarchar()

static bool isvarchar ( unsigned char  c )

static

Definition at line 44 of file prepare.c.

{
    if (isalnum(c))
        return true;
 
    if (c == '_' || c == '>' || c == '-' || c == '.')
        return true;
 
    if (c >= 128)
        return true;
 
    return false;
}

References fb().

Referenced by replace_variables().

prepare_common()

static bool prepare_common ( int  lineno, struct connection *  con, const char *  name, const char *  variable  )

static

Definition at line 172 of file prepare.c.

{
    struct statement *stmt;
    struct prepared_statement *this;
    PGresult   *query;
 
    /* allocate new statement */
    this = (struct prepared_statement *) ecpg_alloc(sizeof(struct prepared_statement), lineno);
    if (!this)
        return false;
 
    stmt = (struct statement *) ecpg_alloc(sizeof(struct statement), lineno);
    if (!stmt)
    {
        ecpg_free(this);
        return false;
    }
 
    /* create statement */
    stmt->lineno = lineno;
    stmt->connection = con;
    stmt->command = ecpg_strdup(variable, lineno, NULL);
    if (!stmt->command)
    {
        ecpg_free(stmt);
        ecpg_free(this);
        return false;
    }
    stmt->inlist = stmt->outlist = NULL;
 
    /* if we have C variables in our statement replace them with '?' */
    if (!replace_variables(&(stmt->command), lineno))
    {
        ecpg_free(stmt->command);
        ecpg_free(stmt);
        ecpg_free(this);
        return false;
    }
 
    /* add prepared statement to our list */
    this->name = ecpg_strdup(name, lineno, NULL);
    if (!this->name)
    {
        ecpg_free(stmt->command);
        ecpg_free(stmt);
        ecpg_free(this);
        return false;
    }
    this->stmt = stmt;
 
    /* and finally really prepare the statement */
    query = PQprepare(stmt->connection->connection, name, stmt->command, 0, NULL);
    if (!ecpg_check_PQresult(query, stmt->lineno, stmt->connection->connection, stmt->compat))
    {
        ecpg_free(stmt->command);
        ecpg_free(this->name);
        ecpg_free(this);
        ecpg_free(stmt);
        return false;
    }
 
    ecpg_log("prepare_common on line %d: name %s; query: \"%s\"\n", stmt->lineno, name, stmt->command);
    PQclear(query);
    this->prepared = true;
 
    if (con->prep_stmts == NULL)
        this->next = NULL;
    else
        this->next = con->prep_stmts;
 
    con->prep_stmts = this;
    return true;
}

References ecpg_alloc(), ecpg_check_PQresult(), ecpg_free(), ecpg_log(), ecpg_strdup(), fb(), statement::lineno, name, next, PQclear, PQprepare(), connection::prep_stmts, replace_variables(), and stmt.

Referenced by ecpg_auto_prepare(), and ECPGprepare().

replace_variables()

static bool replace_variables ( char **  text, int  lineno  )

static

Definition at line 117 of file prepare.c.

{
    bool        string = false;
    int         counter = 1,
                ptr = 0;
 
    for (; (*text)[ptr] != '\0'; ptr++)
    {
        if ((*text)[ptr] == '\'')
            string = string ? false : true;
 
        if (string || (((*text)[ptr] != ':') && ((*text)[ptr] != '?')))
            continue;
 
        if (((*text)[ptr] == ':') && ((*text)[ptr + 1] == ':'))
            ptr += 2;           /* skip  '::' */
        else
        {
            /* a rough guess of the size we need: */
            int         buffersize = sizeof(int) * CHAR_BIT * 10 / 3;
            int         len;
            char       *buffer,
                       *newcopy;
 
            if (!(buffer = ecpg_alloc(buffersize, lineno)))
                return false;
 
            snprintf(buffer, buffersize, "$%d", counter++);
 
            for (len = 1; (*text)[ptr + len] && isvarchar((*text)[ptr + len]); len++)
                 /* skip */ ;
            if (!(newcopy = ecpg_alloc(strlen(*text) - len + strlen(buffer) + 1, lineno)))
            {
                ecpg_free(buffer);
                return false;
            }
 
            memcpy(newcopy, *text, ptr);
            strcpy(newcopy + ptr, buffer);
            strcat(newcopy, (*text) +ptr + len);
 
            ecpg_free(*text);
            ecpg_free(buffer);
 
            *text = newcopy;
 
            if ((*text)[ptr] == '\0')   /* we reached the end */
                ptr--;          /* since we will (*text)[ptr]++ in the top
                                 * level for loop */
        }
    }
    return true;
}

References ecpg_alloc(), ecpg_free(), false, fb(), isvarchar(), len, statement::lineno, memcpy(), and snprintf.

Referenced by prepare_common().

SearchStmtCache()

static int SearchStmtCache ( const char *  ecpgQuery )

static

Definition at line 453 of file prepare.c.

{
    int         entNo,
                entIx;
 
    /* quick failure if cache not set up */
    if (stmtCacheEntries == NULL)
        return 0;
 
    /* hash the statement */
    entNo = HashStmt(ecpgQuery);
 
    /* search the cache */
    for (entIx = 0; entIx < stmtCacheEntPerBucket; ++entIx)
    {
        if (stmtCacheEntries[entNo].stmtID[0])  /* check if entry is in use */
        {
            if (strcmp(ecpgQuery, stmtCacheEntries[entNo].ecpgQuery) == 0)
                break;          /* found it */
        }
        ++entNo;                /* incr entry # */
    }
 
    /* if entry wasn't found - set entry # to zero */
    if (entIx >= stmtCacheEntPerBucket)
        entNo = 0;
 
    return entNo;
}

References fb(), HashStmt(), stmtCacheEntPerBucket, and stmtCacheEntries.

Referenced by ecpg_auto_prepare().

Variable Documentation

nextStmtID

int nextStmtID = 1

static

Definition at line 37 of file prepare.c.

Referenced by ecpg_auto_prepare().

stmtCacheEntries

stmtCacheEntry* stmtCacheEntries = NULL

static

Definition at line 38 of file prepare.c.

Referenced by AddStmtToCache(), ecpg_auto_prepare(), ecpg_freeStmtCacheEntry(), and SearchStmtCache().