1 files changed, 169 insertions, 446 deletions

diff --git a/src/interfaces/ecpg/lib/ecpglib.c b/src/interfaces/ecpg/lib/ecpglib.c
index afdf93bda24..2891eefe084 100644
--- a/src/interfaces/ecpg/lib/ecpglib.c
+++ b/src/interfaces/ecpg/lib/ecpglib.c
@@ -75,56 +75,11 @@ struct variable
 	struct variable *next;
 };
 
-struct statement
-{
-	int			lineno;
-	char	   *command;
-	struct connection *connection;
-	struct variable *inlist;
-	struct variable *outlist;
-};
-
-static struct prepared_statement
-{
-	char	   *name;
-	struct statement *stmt;
-	struct prepared_statement *next;
-}		   *prep_stmts = NULL;
-
-static struct auto_mem
-{
-	void	   *pointer;
-	struct auto_mem *next;
-}		   *auto_allocs = NULL;
+struct auto_mem *auto_allocs;
 
 static int	simple_debug = 0;
 static FILE *debugstream = NULL;
 
-static void
-register_error(long code, char *fmt,...)
-{
-	va_list		args;
-	struct auto_mem *am;
-
-	sqlca.sqlcode = code;
-	va_start(args, fmt);
-	vsnprintf(sqlca.sqlerrm.sqlerrmc, SQLERRMC_LEN, fmt, args);
-	va_end(args);
-	sqlca.sqlerrm.sqlerrml = strlen(sqlca.sqlerrm.sqlerrmc);
-
-	/* free all memory we have allocated for the user */
-	for (am = auto_allocs; am;)
-	{
-		struct auto_mem *act = am;
-
-		am = am->next;
-		free(act->pointer);
-		free(act);
-	}
-
-	auto_allocs = NULL;
-}
-
 static struct connection *
 get_connection(const char *connection_name)
 {
@@ -146,10 +101,12 @@ ecpg_init(const struct connection *con, const char * connection_name, const int
 	memcpy((char *) &sqlca, (char *) &sqlca_init, sizeof(sqlca));
 	if (con == NULL)
 	{
-		register_error(ECPG_NO_CONN, "No such connection %s in line %d.", connection_name ? connection_name : "NULL", lineno);
+		ECPGraise(lineno, ECPG_NO_CONN, connection_name ? connection_name : "NULL");
 		return (false);
 	}
 	
+	auto_allocs = NULL;
+	
 	return (true);
 }
 
@@ -182,37 +139,6 @@ ecpg_finish(struct connection * act)
 		ECPGlog("ecpg_finish: called an extra time.\n");
 }
 
-static char *
-ecpg_alloc(long size, int lineno)
-{
-	char	   *new = (char *) calloc(1L, size);
-
-	if (!new)
-	{
-		ECPGlog("out of memory\n");
-		ECPGraise(lineno, ECPG_OUT_OF_MEMORY, NULL);
-		return NULL;
-	}
-
-	memset(new, '\0', size);
-	return (new);
-}
-
-static char *
-ecpg_strdup(const char *string, int lineno)
-{
-	char	   *new = strdup(string);
-
-	if (!new)
-	{
-		ECPGlog("out of memory\n");
-		ECPGraise(lineno, ECPG_OUT_OF_MEMORY, NULL);
-		return NULL;
-	}
-
-	return (new);
-}
-
 static void
 add_mem(void *ptr, int lineno)
 {
@@ -313,7 +239,7 @@ create_statement(int lineno, struct connection * connection, struct statement **
 			if (var->pointer == NULL)
 			{
 				ECPGlog("create_statement: invalid statement name\n");
-				register_error(ECPG_INVALID_STMT, "Invalid statement name in line %d.", lineno);
+				ECPGraise(lineno, ECPG_INVALID_STMT, NULL);
 				free(var);
 				return false;
 			}
@@ -704,7 +630,7 @@ ECPGexecute(struct statement * stmt)
 	{
 		if ((results = PQexec(stmt->connection->connection, "begin transaction")) == NULL)
 		{
-			register_error(ECPG_TRANS, "Error in transaction processing line %d.", stmt->lineno);
+			ECPGraise(stmt->lineno, ECPG_TRANS, NULL);
 			return false;
 		}
 		PQclear(results);
@@ -719,8 +645,7 @@ ECPGexecute(struct statement * stmt)
 	{
 		ECPGlog("ECPGexecute line %d: error: %s", stmt->lineno,
 				PQerrorMessage(stmt->connection->connection));
-		register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
-			 PQerrorMessage(stmt->connection->connection), stmt->lineno);
+		ECPGraise(stmt->lineno, ECPG_PGSQL, PQerrorMessage(stmt->connection->connection));
 	}
 	else
 	{
@@ -749,8 +674,6 @@ ECPGexecute(struct statement * stmt)
 
 				for (act_field = 0; act_field < nfields && status; act_field++)
 				{
-					char	   *pval;
-					char	   *scan_length;
 					char	   *array_query;
 					
 					if (var == NULL)
@@ -820,247 +743,10 @@ ECPGexecute(struct statement * stmt)
 										
 					for (act_tuple = 0; act_tuple < ntuples && status; act_tuple++)
 					{
-						pval = (char *)PQgetvalue(results, act_tuple, act_field);
-
-						ECPGlog("ECPGexecute line %d: RESULT: %s\n", stmt->lineno, pval ? pval : "");
-
-						/* Now the pval is a pointer to the value. */
-						/* We will have to decode the value */
-
-						/*
-						 * check for null value and set indicator
-						 * accordingly
-						 */
-						switch (var->ind_type)
-						{
-							case ECPGt_short:
-							case ECPGt_unsigned_short:
-								((short *) var->ind_value)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
-								break;
-							case ECPGt_int:
-							case ECPGt_unsigned_int:
-								((int *) var->ind_value)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
-								break;
-							case ECPGt_long:
-							case ECPGt_unsigned_long:
-								((long *) var->ind_value)[act_tuple] = -PQgetisnull(results, act_tuple, act_field);
-								break;
-							case ECPGt_NO_INDICATOR:
-								if (PQgetisnull(results, act_tuple, act_field))
-								{
-									register_error(ECPG_MISSING_INDICATOR, "NULL value without indicator variable on line %d.", stmt->lineno);
-									status = false;
-								}
-								break;
-							default:
-								ECPGraise(stmt->lineno, ECPG_UNSUPPORTED, ECPGtype_name(var->ind_type));
-								status = false;
-								break;
-						}
-						
-						switch (var->type)
-						{
-								long		res;
-								unsigned long ures;
-								double		dres;
-
-							case ECPGt_short:
-							case ECPGt_int:
-							case ECPGt_long:
-								if (pval)
-								{
-									res = strtol(pval, &scan_length, 10);
-									if (*scan_length != '\0')	/* Garbage left */
-									{
-										register_error(ECPG_INT_FORMAT, "Not correctly formatted int type: %s line %d.",
-													 pval, stmt->lineno);
-										status = false;
-										res = 0L;
-									}
-								}
-								else
-									res = 0L;
-
-								switch (var->type)
-								{
-									case ECPGt_short:
-										((short *) var->value)[act_tuple] = (short) res;
-										break;
-									case ECPGt_int:
-										((int *) var->value)[act_tuple] = (int) res;
-										break;
-									case ECPGt_long:
-										((long *) var->value)[act_tuple] = res;
-										break;
-									default:
-										/* Cannot happen */
-										break;
-								}
-								break;
-
-							case ECPGt_unsigned_short:
-							case ECPGt_unsigned_int:
-							case ECPGt_unsigned_long:
-								if (pval)
-								{
-									ures = strtoul(pval, &scan_length, 10);
-									if (*scan_length != '\0')	/* Garbage left */
-									{
-										register_error(ECPG_UINT_FORMAT, "Not correctly formatted unsigned type: %s line %d.",
-													 pval, stmt->lineno);
-										status = false;
-										ures = 0L;
-									}
-								}
-								else
-									ures = 0L;
-
-								switch (var->type)
-								{
-									case ECPGt_unsigned_short:
-										((unsigned short *) var->value)[act_tuple] = (unsigned short) ures;
-										break;
-									case ECPGt_unsigned_int:
-										((unsigned int *) var->value)[act_tuple] = (unsigned int) ures;
-										break;
-									case ECPGt_unsigned_long:
-										((unsigned long *) var->value)[act_tuple] = ures;
-										break;
-									default:
-										/* Cannot happen */
-										break;
-								}
-								break;
-
-
-							case ECPGt_float:
-							case ECPGt_double:
-								if (pval)
-								{
-									dres = strtod(pval, &scan_length);
-									if (*scan_length != '\0')	/* Garbage left */
-									{
-										register_error(ECPG_FLOAT_FORMAT, "Not correctly formatted floating point type: %s line %d.",
-													 pval, stmt->lineno);
-										status = false;
-										dres = 0.0;
-									}
-								}
-								else
-									dres = 0.0;
-
-								switch (var->type)
-								{
-									case ECPGt_float:
-										((float *) var->value)[act_tuple] = dres;
-										break;
-									case ECPGt_double:
-										((double *) var->value)[act_tuple] = dres;
-										break;
-									default:
-										/* Cannot happen */
-										break;
-								}
-								break;
-
-							case ECPGt_bool:
-								if (pval)
-								{
-									if (pval[0] == 'f' && pval[1] == '\0')
-									{
-										((char *) var->value)[act_tuple] = false;
-										break;
-									}
-									else if (pval[0] == 't' && pval[1] == '\0')
-									{
-										((char *) var->value)[act_tuple] = true;
-										break;
-									}
-									else if (pval[0] == '\0' && PQgetisnull(results, act_tuple, act_field))
-									{
-										// NULL is valid
-										break;
-									}
-								}
-
-								register_error(ECPG_CONVERT_BOOL, "Unable to convert %s to bool on line %d.",
-											   (pval ? pval : "NULL"),
-											   stmt->lineno);
-								status = false;
-								break;
-
-							case ECPGt_char:
-							case ECPGt_unsigned_char:
-								{
-									strncpy((char *) ((long) var->value + var->offset * act_tuple), pval, var->varcharsize);
-									if (var->varcharsize && var->varcharsize < strlen(pval))
-									{
-										/* truncation */
-										switch (var->ind_type)
-										{
-											case ECPGt_short:
-											case ECPGt_unsigned_short:
-												((short *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											case ECPGt_int:
-											case ECPGt_unsigned_int:
-												((int *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											case ECPGt_long:
-											case ECPGt_unsigned_long:
-												((long *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											default:
-												break;
-										}
-										sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
-									}
-								}
-								break;
-
-							case ECPGt_varchar:
-								{
-									struct ECPGgeneric_varchar *variable =
-									(struct ECPGgeneric_varchar *) ((long) var->value + var->offset * act_tuple);
-
-									if (var->varcharsize == 0)
-										strncpy(variable->arr, pval, strlen(pval));
-									else
-										strncpy(variable->arr, pval, var->varcharsize);
-
-									variable->len = strlen(pval);
-									if (var->varcharsize > 0 && variable->len > var->varcharsize)
-									{
-										/* truncation */
-										switch (var->ind_type)
-										{
-											case ECPGt_short:
-											case ECPGt_unsigned_short:
-												((short *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											case ECPGt_int:
-											case ECPGt_unsigned_int:
-												((int *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											case ECPGt_long:
-											case ECPGt_unsigned_long:
-												((long *) var->ind_value)[act_tuple] = var->varcharsize;
-												break;
-											default:
-												break;
-										}
-										sqlca.sqlwarn[0] = sqlca.sqlwarn[1] = 'W';
-
-										variable->len = var->varcharsize;
-									}
-								}
-								break;
-
-							default:
-								ECPGraise(stmt->lineno, ECPG_UNSUPPORTED, ECPGtype_name(var->type));
-								status = false;
-								break;
-						}
+						if (!get_data(results, act_tuple, act_field, stmt->lineno,
+						         var->type, var->ind_type, var->value,
+						         var->ind_value, var->varcharsize, var->offset))
+						         status = false;
 					}
 					var = var->next;
 				}
@@ -1074,7 +760,7 @@ ECPGexecute(struct statement * stmt)
 				break;
 			case PGRES_EMPTY_QUERY:
 				/* do nothing */
-				register_error(ECPG_EMPTY, "Empty query line %d.", stmt->lineno);
+				ECPGraise(stmt->lineno, ECPG_EMPTY, NULL);
 				break;
 			case PGRES_COMMAND_OK:
 				status = true;
@@ -1087,8 +773,7 @@ ECPGexecute(struct statement * stmt)
 			case PGRES_BAD_RESPONSE:
 				ECPGlog("ECPGexecute line %d: Error: %s",
 						stmt->lineno, PQerrorMessage(stmt->connection->connection));
-				register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
-							   PQerrorMessage(stmt->connection->connection), stmt->lineno);
+				ECPGraise(stmt->lineno, ECPG_PGSQL, PQerrorMessage(stmt->connection->connection));
 				status = false;
 				break;
 			case PGRES_COPY_OUT:
@@ -1102,8 +787,7 @@ ECPGexecute(struct statement * stmt)
 			default:
 				ECPGlog("ECPGexecute line %d: Got something else, postgres error.\n",
 						stmt->lineno);
-				register_error(ECPG_PGSQL, "Postgres error: %s line %d.",
-							   PQerrorMessage(stmt->connection->connection), stmt->lineno);
+				ECPGraise(stmt->lineno, ECPG_PGSQL, PQerrorMessage(stmt->connection->connection));
 				status = false;
 				break;
 		}
@@ -1154,7 +838,7 @@ ECPGdo(int lineno, const char *connection_name, char *query, ...)
 	{
 		free_statement(stmt);
 		ECPGlog("ECPGdo: not connected to %s\n", con->name);
-		register_error(ECPG_NOT_CONN, "Not connected in line %d.", lineno);
+		ECPGraise(lineno, ECPG_NOT_CONN, NULL);
 		setlocale(LC_NUMERIC, locale);
 		return false;
 	}
@@ -1179,7 +863,7 @@ ECPGstatus(int lineno, const char *connection_name)
 	if (con->connection == NULL)
 	{
 		ECPGlog("ECPGdo: not connected to %s\n", con->name);
-		register_error(ECPG_NOT_CONN, "Not connected in line %d", lineno);
+		ECPGraise(lineno, ECPG_NOT_CONN, NULL);
 		return false;
 	}
 
@@ -1202,7 +886,7 @@ ECPGtrans(int lineno, const char *connection_name, const char *transaction)
 	{
 		if ((res = PQexec(con->connection, transaction)) == NULL)
 		{
-			register_error(ECPG_TRANS, "Error in transaction processing line %d.", lineno);
+			ECPGraise(lineno, ECPG_TRANS, NULL);
 			return FALSE;
 		}
 		PQclear(res);
@@ -1213,13 +897,8 @@ ECPGtrans(int lineno, const char *connection_name, const char *transaction)
 		con->committed = true;
 
 		/* deallocate all prepared statements */
-		while(prep_stmts != NULL)
-		{
-			bool		b = ECPGdeallocate(lineno, prep_stmts->name);
-
-			if (!b)
+		if (!ECPGdeallocate_all(lineno))
 				return false;
-		}
 	}
 
 	return true;
@@ -1242,7 +921,7 @@ ECPGsetcommit(int lineno, const char *mode, const char *connection_name)
 		{
 			if ((results = PQexec(con->connection, "begin transaction")) == NULL)
 			{
-				register_error(ECPG_TRANS, "Error in transaction processing line %d.", lineno);
+				ECPGraise(lineno, ECPG_TRANS, NULL);
 				return false;
 			}
 			PQclear(results);
@@ -1256,7 +935,7 @@ ECPGsetcommit(int lineno, const char *mode, const char *connection_name)
 		{
 			if ((results = PQexec(con->connection, "commit")) == NULL)
 			{
-				register_error(ECPG_TRANS, "Error in transaction processing line %d.", lineno);
+				ECPGraise(lineno, ECPG_TRANS, NULL);
 				return false;
 			}
 			PQclear(results);
@@ -1315,7 +994,7 @@ ECPGconnect(int lineno, const char *dbname, const char *user, const char *passwd
 	{
 		ecpg_finish(this);
 		ECPGlog("connect: could not open database %s %s%s in line %d\n", dbname ? dbname : "<DEFAULT>", user ? "for user " : "", user ? user : "", lineno);
-		register_error(ECPG_CONNECT, "connect: could not open database %s.", dbname ? dbname : "<DEFAULT>");
+		ECPGraise(lineno, ECPG_CONNECT, dbname ? dbname : "<DEFAULT>");
 		return false;
 	}
 
@@ -1384,135 +1063,179 @@ ECPGlog(const char *format,...)
 	}
 }
 
-/* print out an error message */
-void
-sqlprint(void)
-{
-	sqlca.sqlerrm.sqlerrmc[sqlca.sqlerrm.sqlerrml] = '\0';
-	fprintf(stderr, "sql error %s\n", sqlca.sqlerrm.sqlerrmc);
-}
-
-static bool
-isvarchar(unsigned char c)
-{
-	if (isalnum(c))
-		return true;
+/* dynamic SQL support routines
+ *
+ * Copyright (c) 2000, Christof Petig <christof.petig@wtal.de>
+ *
+ * $Header: /cvsroot/pgsql/src/interfaces/ecpg/lib/Attic/ecpglib.c,v 1.60 2000/02/23 19:25:43 meskes Exp $
+ */
 
-	if (c == '_' || c == '>' || c == '-' || c == '.')
-		return true;
+/* I borrowed the include files from ecpglib.c, maybe we don't need all of them */
 
-	if (c >= 128)
-		return true;
+#include <sql3types.h>
 
-	return (false);
-}
+PGconn *ECPG_internal_get_connection(char *name);
 
-static void
-replace_variables(char *text)
+extern struct descriptor
 {
-	char	   *ptr = text;
-	bool		string = false;
+   char *name;
+   PGresult *result;
+   struct descriptor *next;
+} *all_descriptors;
+
+// like ECPGexecute
+static bool execute_descriptor(int lineno,const char *query
+							,struct connection *con,PGresult **resultptr)
+{
+	bool	status = false;
+	PGresult   *results;
+	PGnotify   *notify;
+	
+	/* Now the request is built. */
 
-	for (; *ptr != '\0'; ptr++)
+	if (con->committed && !con->autocommit)
 	{
-		if (*ptr == '\'')
-			string = string ? false : true;
-
-		if (!string && *ptr == ':')
+		if ((results = PQexec(con->connection, "begin transaction")) == NULL)
 		{
-			*ptr = '?';
-			for (++ptr; *ptr && isvarchar(*ptr); ptr++)
-				*ptr = ' ';
+			ECPGraise(lineno, ECPG_TRANS, NULL);
+			return false;
 		}
+		PQclear(results);
+		con->committed = false;
 	}
-}
 
-/* handle the EXEC SQL PREPARE statement */
-bool
-ECPGprepare(int lineno, char *name, char *variable)
-{
-	struct statement *stmt;
-	struct prepared_statement *this;
+	ECPGlog("execute_descriptor line %d: QUERY: %s on connection %s\n", lineno, query, con->name);
+	results = PQexec(con->connection, query);
 
-	/* check if we already have prepared this statement */
-	for (this = prep_stmts; this != NULL && strcmp(this->name, name) != 0; this = this->next);
-	if (this)
+	if (results == NULL)
 	{
-		bool		b = ECPGdeallocate(lineno, name);
-
-		if (!b)
-			return false;
+		ECPGlog("ECPGexecute line %d: error: %s", lineno,
+				PQerrorMessage(con->connection));
+		ECPGraise(lineno, ECPG_PGSQL, PQerrorMessage(con->connection));
+	}
+	else
+	{	*resultptr=results;
+		switch (PQresultStatus(results))
+		{	int ntuples;
+			case PGRES_TUPLES_OK:
+				status = true;
+				sqlca.sqlerrd[2] = ntuples = PQntuples(results);
+				if (ntuples < 1)
+				{
+					ECPGlog("execute_descriptor line %d: Incorrect number of matches: %d\n",
+							lineno, ntuples);
+					ECPGraise(lineno, ECPG_NOT_FOUND, NULL);
+					status = false;
+					break;
+				}
+				break;
+#if 1 /* strictly these are not needed (yet) */
+			case PGRES_EMPTY_QUERY:
+				/* do nothing */
+				ECPGraise(lineno, ECPG_EMPTY, NULL);
+				break;
+			case PGRES_COMMAND_OK:
+				status = true;
+				sqlca.sqlerrd[1] = atol(PQoidStatus(results));
+				sqlca.sqlerrd[2] = atol(PQcmdTuples(results));
+				ECPGlog("ECPGexecute line %d Ok: %s\n", lineno, PQcmdStatus(results));
+				break;
+			case PGRES_COPY_OUT:
+				ECPGlog("ECPGexecute line %d: Got PGRES_COPY_OUT ... tossing.\n", lineno);
+				PQendcopy(con->connection);
+				break;
+			case PGRES_COPY_IN:
+				ECPGlog("ECPGexecute line %d: Got PGRES_COPY_IN ... tossing.\n", lineno);
+				PQendcopy(con->connection);
+				break;
+#else
+			case PGRES_EMPTY_QUERY:
+			case PGRES_COMMAND_OK:
+			case PGRES_COPY_OUT:
+			case PGRES_COPY_IN:
+				break;
+#endif
+			case PGRES_NONFATAL_ERROR:
+			case PGRES_FATAL_ERROR:
+			case PGRES_BAD_RESPONSE:
+				ECPGlog("ECPGexecute line %d: Error: %s",
+						lineno, PQerrorMessage(con->connection));
+				ECPGraise(lineno, ECPG_PGSQL, PQerrorMessage(con->connection));
+				status = false;
+				break;
+			default:
+				ECPGlog("ECPGexecute line %d: Got something else, postgres error.\n",
+						lineno);
+				ECPGraise(lineno, ECPG_PGSQL, PQerrorMessage(con->connection));
+				status = false;
+				break;
+		}
 	}
 
-	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)
+	/* check for asynchronous returns */
+	notify = PQnotifies(con->connection);
+	if (notify)
 	{
-		free(this);
-		return false;
+		ECPGlog("ECPGexecute line %d: ASYNC NOTIFY of '%s' from backend pid '%d' received\n",
+				lineno, notify->relname, notify->be_pid);
+		free(notify);
 	}
+	return status;
+}
 
-	/* create statement */
-	stmt->lineno = lineno;
-	stmt->connection = NULL;
-	stmt->command = ecpg_strdup(variable, lineno);
-	stmt->inlist = stmt->outlist = NULL;
+/* like ECPGdo */
+static bool do_descriptor2(int lineno,const char *connection_name,
+					PGresult **resultptr, const char *query)
+{
+	struct connection *con = get_connection(connection_name);
+	bool		status=true;
+	char *locale = setlocale(LC_NUMERIC, NULL);
+
+	/* Make sure we do NOT honor the locale for numeric input/output */
+	/* since the database wants teh standard decimal point */
+	setlocale(LC_NUMERIC, "C");
 
-	/* if we have C variables in our statment replace them with '?' */
-	replace_variables(stmt->command);
+	if (!ecpg_init(con, connection_name, lineno))
+	{	setlocale(LC_NUMERIC, locale);
+		return(false);
+	}
 
-	/* add prepared statement to our list */
-	this->name = ecpg_strdup(name, lineno);
-	this->stmt = stmt;
+	/* are we connected? */
+	if (con == NULL || con->connection == NULL)
+	{
+		ECPGlog("do_descriptor2: not connected to %s\n", con->name);
+		ECPGraise(lineno, ECPG_NOT_CONN, NULL);
+		setlocale(LC_NUMERIC, locale);
+		return false;
+	}
 
-	if (prep_stmts == NULL)
-		this->next = NULL;
-	else
-		this->next = prep_stmts;
+	status = execute_descriptor(lineno,query,con,resultptr);
 
-	prep_stmts = this;
-	return true;
+	/* and reset locale value so our application is not affected */
+	setlocale(LC_NUMERIC, locale);
+	return (status);
 }
 
-/* handle the EXEC SQL DEALLOCATE PREPARE statement */
-bool
-ECPGdeallocate(int lineno, char *name)
+bool ECPGdo_descriptor(int line,const char *connection,
+							const char *descriptor,const char *query)
 {
-	struct prepared_statement *this,
-			   *prev;
-
-	/* check if we really have prepared this statement */
-	for (this = prep_stmts, prev = NULL; this != NULL && strcmp(this->name, name) != 0; prev = this, this = this->next);
-	if (this)
-	{
-		/* okay, free all the resources */
-		free(this->name);
-		free(this->stmt->command);
-		free(this->stmt);
-		if (prev != NULL)
-			prev->next = this->next;
-		else
-			prep_stmts = this->next;
-		
-		free(this);
-		return true;
+	struct descriptor *i;
+	for (i=all_descriptors;i!=NULL;i=i->next)
+	{	if (!strcmp(descriptor,i->name)) 
+	    {	
+			bool status;
+
+			/* free previous result */
+			if (i->result) PQclear(i->result);
+		    	i->result=NULL;
+	    	
+			status=do_descriptor2(line,connection,&i->result,query);
+			
+			if (!i->result) PQmakeEmptyPGresult(NULL, 0);
+			return (status);
+	    }
 	}
-	ECPGlog("deallocate_prepare: invalid statement name %s\n", name);
-	register_error(ECPG_INVALID_STMT, "Invalid statement name %s in line %d", name, lineno);
+	
+	ECPGraise(line, ECPG_UNKNOWN_DESCRIPTOR, descriptor);
 	return false;
 }
-
-/* return the prepared statement */
-char *
-ECPGprepared_statement(char *name)
-{
-	struct prepared_statement *this;
-
-	for (this = prep_stmts; this != NULL && strcmp(this->name, name) != 0; this = this->next);
-	return (this) ? this->stmt->command : NULL;
-}
-
-#include "dynamic.c"